Variable-length Argument Lists (GNU Octave (version 9.3.0))

### 11.6 Variable-length Argument Lists ¶

Sometimes the number of input arguments is not known when the function is defined. As an example think of a function that returns the smallest of all its input arguments. For example:

    a = smallest (1, 2, 3);
    b = smallest (1, 2, 3, 4);

In this example both `a` and `b` would be 1. One way to write the `smallest` function is

    function val = smallest (arg1, arg2, arg3, arg4, arg5)
      body
    endfunction

and then use the value of `nargin` to determine which of the input arguments should be considered. The problem with this approach is that it can only handle a limited number of input arguments.

If the special parameter name `varargin` appears at the end of a function parameter list it indicates that the function takes a variable number of input arguments. Using `varargin` the function looks like this

    function val = smallest (varargin)
      body
    endfunction

In the function body the input arguments can be accessed through the variable `varargin`. This variable is a cell array containing all the input arguments. See Cell Arrays, for details on working with cell arrays. The `smallest` function can now be defined like this

    function val = smallest (varargin)
      val = min ([varargin{:}]);
    endfunction

This implementation handles any number of input arguments, but it’s also a very simple solution to the problem.

A slightly more complex example of `varargin` is a function `print_arguments` that prints all input arguments. Such a function can be defined like this

    function print_arguments (varargin)
      for i = 1:length (varargin)
        printf ("Input argument %d: ", i);
        disp (varargin{i});
      endfor
    endfunction

This function produces output like this

    print_arguments (1, "two", 3);
         -| Input argument 1:  1
         -| Input argument 2: two
         -| Input argument 3:  3

: `[reg, prop] =` parseparams `(params)` ¶
: `[reg, var1, …] =` parseparams `(params, name1, default1, …)` ¶

  Return in reg the cell elements of param up to the first string element and in prop all remaining elements beginning with the first string element.

  For example:

      [reg, prop] = parseparams ({1, 2, "linewidth", 10})
      reg =
      {
        [1,1] = 1
        [1,2] = 2
      }
      prop =
      {
        [1,1] = linewidth
        [1,2] = 10
      }

  The parseparams function may be used to separate regular numeric arguments from additional arguments given as property/value pairs of the varargin cell array.

  In the second form of the call, available options are specified directly with their default values given as name-value pairs. If params do not form name-value pairs, or if an option occurs that does not match any of the available options, an error occurs.

  When called from an m-file function, the error is prefixed with the name of the caller function.

  The matching of options is case-insensitive.

  See also: varargin, inputParser.