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)

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)

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;

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;

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.



Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo di WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.

%d blogger hanno fatto clic su Mi Piace per questo: