Processing Data in Structures - GNU Octave
Description: GNU Octave

Previous: Manipulating Structures, Up: Structures

#### 6.1.5 Processing Data in Structures

The simplest way to process data in a structure is within a `for` loop (see Looping Over Structure Elements). A similar effect can be achieved with the `structfun` function, where a user defined function is applied to each field of the structure.

— Function File: structfun (func, S)
— Function File: [A, ...] = structfun (...)
— Function File: structfun (..., "ErrorHandler", errfunc)
— Function File: structfun (..., "UniformOutput", val)

> Evaluate the function named name on the fields of the structure S. The fields of S are passed to the function func individually.

> `structfun` accepts an arbitrary function func in the form of an inline function, function handle, or the name of a function (in a character string). In the case of a character string argument, the function must accept a single argument named x, and it must return a string value. If the function returns more than one argument, they are returned as separate output variables.

> If the parameter "UniformOutput" is set to true (the default), then the function must return a single element which will be concatenated into the return value. If "UniformOutput" is false, the outputs are placed into a structure with the same fieldnames as the input structure.

>               s.name1 = "John Smith";
>               s.name2 = "Jill Jones";
>               structfun (@(x) regexp (x, '(\w+)$', "matches"){1}, s,
>                          "UniformOutput", false)
>                   ⇒
>                  {
>                    name1 = Smith
>                    name2 = Jones
>                  }

> Given the parameter "ErrorHandler", errfunc defines a function to call in case func generates an error. The form of the function is

>               function [...] = errfunc (se, ...)

> where there is an additional input argument to errfunc relative to func, given by se. This is a structure with the elements "identifier", "message" and "index", giving respectively the error identifier, the error message, and the index into the input arguments of the element that caused the error. For an example on how to use an error handler, see `cellfun`.

> See also: cellfun, arrayfun, spfun.

Alternatively, to process the data in a structure, the structure might be converted to another type of container before being treated.

— Built-in Function: struct2cell (S)

> Create a new cell array from the objects stored in the struct object. If f is the number of fields in the structure, the resulting cell array will have a dimension vector corresponding to `[`F`size(`S`)]`. For example:

>                 s = struct('name', {'Peter', 'Hannah', 'Robert'},
>                            'age', {23, 16, 3});
>                 c = struct2cell(s)
>                    ⇒ c = {1x1x3 Cell Array}
>                 c(1,1,:)(:)
>                    ⇒ ans =
>                       {
>                         [1,1] = Peter
>                         [2,1] = Hannah
>                         [3,1] = Robert
>                       }
>                 c(2,1,:)(:)
>                    ⇒ ans =
>                       {
>                         [1,1] = 23
>                         [2,1] = 16
>                         [3,1] = 3
>                       }

> See also: cell2struct, fieldnames.