It is often useful to evaluate a string as if it were an Octave program, or use a string as the name of a function to call. These functions are necessary in order to evaluate commands that are not known until run time, or to write functions that will need to call user-supplied functions.
evalreturns. For example,
octave:13> a error: `a' undefined octave:14> eval ("a = 13") a = 13 ans = 13 octave:15> a a = 13
In this case, two values are printed: one for the expression that was
evaluated, and one for the value returned from
eval. Just as
with any other expression, you can turn printing off by ending the
expression in a semicolon. For example,
octave:13> a error: `a' undefined octave:14> eval ("a = 13;") ans = 13 octave:15> a a = 13
octave:12> feval ("acos", -1) ans = 3.1416
calls the function
acos with the argument `-1'.
feval is necessary in order to be able to write
functions that call user-supplied functions, because Octave does not
have a way to declare a pointer to a function (like C) or to declare a
special kind of variable that can be used to hold the name of a function
EXTERNAL in Fortran). Instead, you must refer to functions
by name, and use
feval to call them.
Here is a simple-minded function using
feval that finds the root
of a user-supplied function of one variable.
function result = newtroot (fname, x) # usage: newtroot (fname, x) # # fname : a string naming a function f(x). # x : initial guess delta = tol = sqrt (eps); maxit = 200; fx = feval (fname, x); for i = 1:maxit if (abs (fx) < tol) result = x; return; else fx_new = feval (fname, x + delta); deriv = (fx_new - fx) / delta; x = x - fx / deriv; fx = fx_new; endif endfor result = x; endfunction
Note that this is only meant to be an example of calling user-supplied functions and should not be taken too seriously. In addition to using a more robust algorithm, any serious code would check the number and type of all the arguments, ensure that the supplied function really was a function, etc.
The following functions allow you to determine the size of a variable or expression, find out whether a variable exists, print error messages, or delete variable names from the symbol table.
With one input argument and one output argument, the result is returned in a 2 element row vector. If there are two output arguments, the number of rows is assigned to the first, and the number of columns to the second. For example,
octave:13> size ([1, 2; 3, 4; 5, 6]) ans = 3 2 octave:14> [nr, nc] = size ([1, 2; 3, 4; 5, 6]) nr = 3 nc = 2
If given a second argument of either 1 or 2,
size will return
only the row or column dimension. For example
octave:15> size ([1, 2; 3, 4; 5, 6], 2) ans = 2
returns the number of columns in the given matrix.
[ list ]
^, match all characters except those specified by list. For example, the pattern `[a-zA-Z]' will match all lower and upper case alphabetic characters.
For example, the command
clear foo b*r
clears the name
foo and all names that begin with the letter
b and end with the letter
clear is called without any arguments, all user-defined
variables (local and global) are cleared from the symbol table. If
clear is called with at least one argument, only the visible
names matching the arguments are cleared. For example, suppose you have
defined a function
foo, and then hidden it by performing the
foo = 2. Executing the command `clear foo' once
will clear the variable definition and restore the definition of
foo as a function. Executing `clear foo' a second time will
clear the function definition.
This command may not be used within a function body.
Valid patterns are the same as described for the
above. If no patterns are supplied, all symbols from the given category
are listed. By default, only user defined functions and variables
visible in the local scope are displayed.
whos is equivalent to
errorfunction formats the optional arguments under the control of the template string template using the same rules as the
printffamily of functions (see section Formatted Output). The resulting message is prefixed by the string `error: ' and printed on the
error also sets Octave's internal error state such that
control will return to the top level without evaluating any more
commands. This is useful for aborting from functions or scripts.
If the error message does not end with a new line character, Octave will print a traceback of all the function calls leading to the error. For example, given the following function definitions:
function f () g () end function g () h () end function h () nargin == 1 || error ("nargin != 1"); end
calling the function
f() will result in a list of messages that
can help you to quickly locate the exact location of the error:
f () error: nargin != 1 error: evaluating index expression near line 1, column 30 error: evaluating binary operator `||' near line 1, column 27 error: called from `h' error: called from `g' error: called from `f'
If the error message ends in a new line character, Octave will print the message but will not display any traceback messages as it returns control to the top level. For example, modifying the error message in the previous example to end in a new line causes Octave to only print a single message:
function h () nargin == 1 || error ("nargin != 1\n"); end f () error: nargin != 1
beep_on_erroris nonzero, Octave will try to ring your terminal's bell before printing an error message. The default value is 0.
usage is evaluated, Octave will print a traceback of all
the function calls leading to the usage message.
If the file cannot be found in the path, an empty matrix is returned. For example,
octave:13> file_in_path (LOADPATH, "nargchk.m") ans = "/usr/local/share/octave/2.0/m/general/nargchk.m"
This function is provided for the benefit of programs like Emacs which might be controlling Octave and handling user input. The current command number is not incremented when this function is called. This is a feature, not a bug.
This is useful for checking to see that the number of arguments supplied to a function is within an acceptable range.
Since the named file is not opened, by
is possible (though relatively unlikely) that it will not be available
by the time your program attempts to open it.
Normally also displays if each name is user-defined or builtin;
-q option suppresses this behaviour.
Currently, Octave can only display functions that can be compiled cleanly, because it uses its internal representation of the function to recreate the program text.
Comments are not displayed because Octave's parser currently discards them as it converts the text of a function file to its internal representation. This problem may be fixed in a future release.
Go to the first, previous, next, last section, table of contents.