## Octave – funzioni e scripts III – 47 Continuo, oggi qui.

Lista degli argomenti di lunghezza variabile
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 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 File: `[reg, prop] = parseparams (params)`
Function File: `[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. 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.

Avanti, sono qui.

Ignorare argomenti
In the formal argument list, it is possible to use the dummy placeholder ~ instead of a name. This indicates that the corresponding argument value should be ignored and not stored to any variable.

``````function val = pick2nd (~, arg2)
val = arg2;
endfunction``````

The value of `nargin` is not affected by using this declaration.
Return arguments can also be ignored using the same syntax. Functions may take advantage of ignored outputs to reduce the number of calculations performed. To do so, use the `isargout` function to query whether the output argument is wanted. For example:

``````function [out1, out2] = long_function (x, y, z)
if (isargout (1))
## Long calculation
...
out1 = result;
endif
...
endfunction``````

mahhh… 😳

Built-in Function: `isargout (k)`
Within a function, return a logical value indicating whether the argument `k` will be assigned to a variable on output.
If the result is false, the argument has been ignored during the function call through the use of the tilde (`~`) special output argument. Functions can use `isargout` to avoid performing unnecessary calculations for outputs which are unwanted.
If `k` is outside the range `1:max (nargout)`, the function returns false. `k` can also be an array, in which case the function works element-by-element and a logical array is returned. At the top level, `isargout` returns an error.

Passo avanti, qui.

Ritornare una lista di lunghezza variabile
It is possible to return a variable number of output arguments from a function using a syntax that’s similar to the one used with the special `varargin` parameter name. To let a function return a variable number of output arguments the special output parameter name `varargout` is used. As with `varargin`, `varargout` is a cell array that will contain the requested output arguments.
As an example the following function sets the first output argument to 1, the second to 2, and so on. If `varargin` (`varargout)` does not appear as the last element of the input (output) parameter list, then it is not special, and is handled the same as any other parameter name.

Function File: `[r1, r2, ..., rn] = deal (a)`
Function File: `[r1, r2, ..., rn] = deal (a1, a2, ..., an)`

Copy the input parameters into the corresponding output parameters.
If only a single input parameter is supplied, its value is copied to each of the outputs. Nota: volendo (ma probabilmente non volete, vero?) si può scrivere anche così: Programming Note: `deal` is often used with comma separated lists derived from cell arrays or structures. This is unnecessary as the interpreter can perform the same action without the overhead of a function call. For example:  Posta un commento o usa questo indirizzo per il trackback.