Using Functions

There are two important things to know about functions in Mathematica. The first is that functions always use square brackets for their arguments to distinguish from parentheses which are used for grouping. The second is that built-in functions always begin with a capital, like Sin[x], so you can use lower-case names without fear of a conflict.

Here a function f is defined. Notice that in function definitions, the variables on the left-hand side are marked with an underscore, as in x_. This indicates that x is part of the function definition and not some expression to be evaluated.

Another thing to note is the use := instead of = for the assignment. This is a kind of "delayed assignment" operator that only evaluates the right hand side when necessary.

Delayed assignment can be used to create recursively defined functions, like the Fibonacci sequence (where later values of the function are defined in terms of earlier values).

Functions are defined in a very natural way, using the := operator.

In Axiom, functions are created using the "delayed assignment" operator, ==.

Delayed assignment can also be used to create recursively defined functions, like the Fibonacci sequence (where later values of the function are defined in terms of earlier values).

Since Octave is not a computer algebra system, functions are defined as programs (i.e. like functions in any other programming language).

For simple functions, the definition can be done on a single line instead:

Notice that in each of these forms, we use the .* operator. The basic data type in Octave is the matrix, and the usual operators +, -, *, /, ^ all operate in the natural way for matrices. There are three new operators .*, ./, .^ which act componentwise (the way addition and subtraction work).

Defining functions using these operators allows us to apply them to whole vectors or matrices of values at a time:

Mathematica has several functions for rounding. Floor[] rounds numbers down (towards minus infinity), Ceiling[] rounds them up, and Round[] rounds to the nearest integer.

One important note about Round[]! For even numbers, it rounds exact halves down. For odd numbers it rounds them up. So 2.5 rounds down to 2, while 3.5 rounds up to 4. This is a useful behavior in many statistical or numerical analysis situations.

The functions for rounding and truncating in Maxima are currently implemented within the internal LISP code. That means that you have to precede the function calls with a ? mark, and that they don’t work one every type (like bigfloats). They work fine for integers and reals, however. It also means you can’t graph them. Starting with version 5.9.3 of Maxima, there are ceiling() and floor() functions (without the ? marks) that work more normally.

The most commonly-used functions are ?floor() for rounding down (toward minus infinity), ?ceiling() for rounding up, and ?round() for rounding to the nearest integer.

One important note about ?round()! For even numbers, it rounds exact halves down. For odd numbers it rounds them up. So 2.5 rounds down to 2, while 3.5 rounds up to 4. This is a useful behavior in many statistical or numerical analysis situations.

The /; syntax lets us place conditions on a function. This allows us to create piecewise defined functions. The following function is y=x for negative values and y=x^2 for positive values.

A piecewise defined function may be defined in Maxima using an if-then structure. The following function is y=x for negative values and y=x^2 for positive values.

There is a clever way to create piecewise defined functions in Octave. It uses the way the comparison operators work; they return 1 when true and 0 when false (and operate this way coordinate wise on vectors and matrices). The following function is y=x for negative values and y=x^2 for positive values.