Calling a Function by its Name

Next: Evaluation in a Different Context, Up: Evaluation

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 example, 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 on 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 that f is a function handle or the function name in a string, 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 scripts in the current workspace that are not necessarily on the path. If script is the script to run, including its path, then run changes the directory to the directory where script is found. run then executes the script, and returns to the original directory.
See also: system.