function function_handle(varargin)
%    FUNHANDLE = @FUNCTION_NAME returns a handle to the named function,
%    FUNCTION_NAME. A function handle is a MATLAB value that provides a
%    means of calling a function indirectly. You can pass function
%    handles in calls to other functions (which are often called function
%    functions). You can also store function handles in data structures for
%    later use (for example, as Handle Graphics callbacks). A function
%    handle is one of the standard MATLAB data types. Its class is
%    'function_handle'.
%
%    FUNHANDLE = @(ARGLIST)EXPRESSION constructs an anonymous function and
%    returns a handle to that function. The body of the function, to the 
%    right of the parentheses, is a single MATLAB expression. ARGLIST is a
%    comma-separated list of input arguments. Execute the function by
%    calling it by means of the returned function handle, FUNHANDLE. For
%    more information on anonymous functions, see "Types of Functions" in
%    the MATLAB Programming documentation.
%
%    To call the function referred to by a function handle value, use ordinary
%    parenthesis notation.  That is, specify the function handle variable
%    followed by a comma-separated list of input arguments enclosed in
%    parentheses. For example, HANDLE(ARG1, ARG2, ...). To call a
%    function_handle with no arguments, use empty parenthesis, e.g.,
%    HANDLE().
%
%    Example 2, below, shows how to make a call using a function handle
%    that has been passed as an argument.
%
%    When you evaluate a function handle to a subfunction or private
%    function, that subfunction or private function is always executed when
%    the function handle is called.  When you evaluate a function handle to
%    a built-in or ordinary function, an appropriate method may be selected
%    instead of the built-in or ordinary function.
%
%    With one exception, function handles can be manipulated and operated on in
%    the same manner as other MATLAB values, including assignment to variables
%    and inclusion in cells and structs.  The exception is that you cannot
%    construct a function_handle array.  The reason is that the parenthesis
%    notation for values of this class is used to call a function, not to
%    index an array.  To achieve the effect of an array of function handles,
%    use cells, e.g., write "A = {@sin, @cos}" rather than "A = [@sin, @cos]".
%    Of course, you need to index A with braces: "A{i}".
%
%    Function handles enable you to:
%
%      Pass a function reference to another function.
%      Reduce the number of files that define your functions.
%      Improve performance in repeated operations.
%      Ensure reliability when evaluating functions.
%
%    Note on Backward Compatibility:
%    In R12 and R13, you could form arrays of function handles, and parenthesis
%    notation meant indexing into such an array. To call the function referred 
%    to by a function_handle value, you needed to use the FEVAL command.  In R14, 
%    it is not necessary to use FEVAL (and this command will likely be deprecated
%    in a future release). Now, a function_handle variable, when followed by (...)'s,
%    calls the associated function, and passes the arguments in parenthesis to it.
%    This is faster than calling the function_handle using FEVAL.
%
%    This change is not backward compatible, and R14 has a transition
%    strategy that will leave almost all R12 & R13 programs working:
%
%       o Constructing a non-scalar array of functions handles is only a
%         warning, not an error.
%
%       o Parenthesis notation on a non-scalar function handle means
%         subscripting, just as in R13, while the same notation on scalar
%         function handles means function call, as described above.
%
%    Thus, incompatibility can arise only if you construct a scalar array of
%    function handles and actually index it, necessarily with an index of 1.
%
%    Example 1 - Construct a handle, f, to the HUMPS function, and pass this 
%    handle to FMINBND. (MATLAB maps a specific implementation of the HUMPS
%    function to the handle f at the time the handle is created, and not at
%    the time f is called.)
%
%        f = @humps;
%        x = fminbnd(f,1,2);
%
%    Example 2 - Call a function by means of the function handle, h, that
%    was passed as an argument.
%
%    function trigPlot(h, val)
%    if isa(h, 'function_handle')   % Verify that h is a function handle.
%       A = h(val);                 % Call the function mapped to handle h.
%       plot(A)                     % Plot the resulting data.
%       end
%
%    Call the function, passing the handle generated by @cos:
%
%       trigPlot(@cos, -pi:0.01:pi)
%
%    See also FUNC2STR, STR2FUNC, FUNCTIONS.
%

%   Copyright 1984-2004 The MathWorks, Inc. 
%   $Revision: 1.7.4.6 $ $Date: 2004/08/06 04:02:39 $

error('"function_handle" is the name of a class, but is not a valid constructor.')