8.2 Calling Functions

A function is a name for a particular calculation. Because it has a name, you can ask for it by name at any point in the program. For example, the function sqrt computes the square root of a number.

A fixed set of functions are built-in, which means they are available in every Octave program. The sqrt function is one of these. In addition, you can define your own functions. See section Functions and Script Files, for information about how to do this.

The way to use a function is with a function call expression, which consists of the function name followed by a list of arguments in parentheses. The arguments are expressions which give the raw materials for the calculation that the function will do. When there is more than one argument, they are separated by commas. If there are no arguments, you can omit the parentheses, but it is a good idea to include them anyway, to clearly indicate that a function call was intended. Here are some examples:

sqrt (x^2 + y^2)      # One argument
ones (n, m)           # Two arguments
rand ()               # No arguments

Each function expects a particular number of arguments. For example, the sqrt function must be called with a single argument, the number to take the square root of:

sqrt (argument)

Some of the built-in functions take a variable number of arguments, depending on the particular usage, and their behavior is different depending on the number of arguments supplied.

Like every other expression, the function call has a value, which is computed by the function based on the arguments you give it. In this example, the value of sqrt (argument) is the square root of the argument. A function can also have side effects, such as assigning the values of certain variables or doing input or output operations.

Unlike most languages, functions in Octave may return multiple values. For example, the following statement

[u, s, v] = svd (a)

computes the singular value decomposition of the matrix a and assigns the three result matrices to u, s, and v.

The left side of a multiple assignment expression is itself a list of expressions, and is allowed to be a list of variable names or index expressions. See also Index Expressions, and Assignment Expressions.

8.2.1 Call by Value

In Octave, unlike Fortran, function arguments are passed by value, which means that each argument in a function call is evaluated and assigned to a temporary location in memory before being passed to the function. There is currently no way to specify that a function parameter should be passed by reference instead of by value. This means that it is impossible to directly alter the value of function parameter in the calling function. It can only change the local copy within the function body. For example, the function

function f (x, n)
  while (n-- > 0)
    disp (x);
  endwhile
endfunction

displays the value of the first argument n times. In this function, the variable n is used as a temporary variable without having to worry that its value might also change in the calling function. Call by value is also useful because it is always possible to pass constants for any function parameter without first having to determine that the function will not attempt to modify the parameter.

The caller may use a variable as the expression for the argument, but the called function does not know this: it only knows what value the argument had. For example, given a function called as

foo = "bar";
fcn (foo)

you should not think of the argument as being "the variable foo." Instead, think of the argument as the string value, "bar".

Even though Octave uses pass-by-value semantics for function arguments, values are not copied unnecessarily. For example,

x = rand (1000);
f (x);

does not actually force two 1000 by 1000 element matrices to exist unless the function f modifies the value of its argument. Then Octave must create a copy to avoid changing the value outside the scope of the function f, or attempting (and probably failing!) to modify the value of a constant or the value of a temporary result.

8.2.2 Recursion

With some restrictions(2), recursive function calls are allowed. A recursive function is one which calls itself, either directly or indirectly. For example, here is an inefficient(3) way to compute the factorial of a given integer:

function retval = fact (n)
  if (n > 0)
    retval = n * fact (n-1);
  else
    retval = 1;
  endif
endfunction

This function is recursive because it calls itself directly. It eventually terminates because each time it calls itself, it uses an argument that is one less than was used for the previous call. Once the argument is no longer greater than zero, it does not call itself, and the recursion ends.

The built-in variable max_recursion_depth specifies a limit to the recursion depth and prevents Octave from recursing infinitely.

Built-in Function: val = max_recursion_depth ()

Built-in Function: old_val = max_recursion_depth (new_val)

Query or set the internal limit on the number of times a function may be called recursively. If the limit is exceeded, an error message is printed and control returns to the top level.

This document was generated on December, 26 2007 using texi2html 1.76.