Next: , Up: Evaluation   [Contents][Index]

### 9.1 Calling a Function by its Name

The `feval` function allows you to call a function from a string containing its name. This is useful when writing a function that needs to call user-supplied functions. The `feval` function takes the name of the function to call as its first argument, and the remaining arguments are given to the function.

The following example is a simple-minded function using `feval` that finds the root of a user-supplied function of one variable using Newton’s method.

```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. See Predicates for Numeric Objects, for a list of predicates for numeric objects, and see Status of Variables, for a description of the `exist` function.

Built-in Function: feval (name, …)

Evaluate the function named name. Any arguments after the first are passed as inputs to the named function. For example,

```feval ("acos", -1)
⇒ 3.1416
```

calls the function `acos` with the argument ‘-1’.

The function `feval` can also be used with function handles of any sort (see Function Handles). Historically, `feval` was the only way to call user-supplied functions in strings, but function handles are now preferred due to the cleaner syntax they offer. For example,

```f = @exp;
feval (f, 1)
⇒ 2.7183
f (1)
⇒ 2.7183
```

are equivalent ways to call the function referred to by f. If it cannot be predicted beforehand whether f is a function handle, function name in a string, or inline function then `feval` can be used instead.

A similar function `run` exists for calling user script files, that are not necessarily on the user path

Command: run script
Function File: run ("script")

Run script in the current workspace.

Scripts which reside in directories specified in Octave’s load path, and which end with the extension ".m", can be run simply by typing their name. For scripts not located on the load path, use `run`.

The file name script can be a bare, fully qualified, or relative filename and with or without a file extension. If no extension is specified, Octave will first search for a script with the ".m" extension before falling back to the script name without an extension.

Implementation Note: If script includes a path component, then `run` first changes the directory to the directory where script is found. `run` then executes the script, and returns to the original directory.