#### 11.12.1 Function Handles ¶

A function handle is a pointer to another function and is defined with the syntax

    @function-name

For example,

    f = @sin;

creates a function handle called `f` that refers to the function `sin`.

Function handles are used to call other functions indirectly, or to pass a function as an argument to another function like `quad` or `fsolve`. For example:

    f = @sin;
    quad (f, 0, pi)
        ⇒  2

You may use `feval` to call a function using function handle, or simply write the name of the function handle followed by an argument list. If there are no arguments, you must use an empty argument list ‘`()`’. For example:

    f = @sin;
    feval (f, pi/4)
        ⇒  0.70711
    f (pi/4)
        ⇒  0.70711

`tf =` is_function_handle `(x)` ¶

  Return true if x is a function handle.

  See also: isa, typeinfo, class, functions.

`s =` functions `(fcn_handle)` ¶

  Return a structure containing information about the function handle fcn_handle.

  The structure s always contains these three fields:

  function

    The function name. For an anonymous function (no name) this will be the actual function definition.

  type

    Type of the function.

    anonymous

      The function is anonymous.

    private

      The function is private.

    overloaded

      The function overloads an existing function.

    simple

      The function is a built-in or m-file function.

    subfunction

      The function is a subfunction within an m-file.

  nested

    The function is nested.

  file

    The m-file that will be called to perform the function. This field is empty for anonymous and built-in functions.

  In addition, some function types may return more information in additional fields.

  Warning: `functions` is provided for debugging purposes only. Its behavior may change in the future and programs should not depend on any particular output format.

  See also: func2str, str2func.

`str =` func2str `(fcn_handle)` ¶

  Return a string containing the name of the function referenced by the function handle fcn_handle.

  See also: str2func, functions.

`hfcn =` str2func `(str)` ¶

  Return a function handle constructed from the string str.

  The input may be the name of a function such as `"sin"` or a string defining a function such as `"@(x) sin (x + pi)"`.

  Programming Note: In most cases it will be better to use anonymous function syntax and let the Octave parser create the function handle rather than use `str2func`. For example:

      hfcn = @sin ;
      hfcn = @(x) sin (x + pi) ;

  See also: func2str, functions.

`vars =` symvar `(str)` ¶

  Identify the symbolic variable names in the string str.

  Common constant names such as `i`, `j`, `pi`, `Inf` and Octave functions such as `sin` or `plot` are ignored.

  Any names identified are returned in a cell array of strings. The array is empty if no variables were found.

  Example:

      symvar ("x^2 + y^2 == 4")
      ⇒  {
           [1,1] = x
           [2,1] = y
         }