19.3 Применение функций

В общем случае функции должны быть написаны с учётом матричных аргументов и должны учитывать операции над целыми матрицами в векторном стиле. Иногда написание функций таким образом оказывается затруднительным или невозможным по разным причинам. В таких ситуациях Octave предоставляет средства для применения функции к каждому элементу массива, ячейки или структуры.

: arrayfun (func, A) ¶

: x = arrayfun (func, A) ¶

: x = arrayfun (func, A, b, …) ¶

: [x, y, …] = arrayfun (func, A, …) ¶

: arrayfun (…, "UniformOutput", val) ¶

: arrayfun (…, "ErrorHandler", errfunc) ¶

Выполняет функцию для каждого элемента массива.

Это полезно для функций, которые не принимают аргументы массива. Если функция принимает аргументы массива, лучше вызвать функцию напрямую.

Первый входной аргумент func может быть строкой, указателем на функцию, встроенной функцией или анонимной функцией. Входной аргумент A может быть логическим массивом, числовым массивом, строковым массивом, массивом структур или массивом ячеек. С помощью вызова функции arrayfun все элементы A передаются в указанную функцию func по одному.

Указанная функция может также принимать более двух входных аргументов, причём входные аргументы указываются как третий входной аргумент b, четвёртый входной аргумент c и так далее. Если передаётся более одного входного аргумента массива, все входные аргументы должны иметь одинаковые размеры, например:

arrayfun (@atan2, [1, 0], [0, 1])
     ⇒ [ 1.57080   0.00000 ]

Если параметр val после дополнительного строкового входного аргумента "UniformOutput" установлен true (по умолчанию), то указанная функция func должна возвращать один элемент, который затем будет соединён в выходное значение и будет типа матрица. В противном случае, если этот параметр установлен в false, то выходные значения объединяются в массив ячеек. Например:

arrayfun (@(x,y) x:y, "abc", "def", "UniformOutput", false)
⇒
   {
     [1,1] = abcd
     [1,2] = bcde
     [1,3] = cdef
   }

Если возвращается более одного выходного аргумента, то указанная функция должна вернуть количество ожидаемых выходных значений, например:

[A, B, C] = arrayfun (@find, [10; 0], "UniformOutput", false)
⇒
A =
{
   [1,1] =  1
   [2,1] = [](0x0)
}
B =
{
   [1,1] =  1
   [2,1] = [](0x0)
}
C =
{
   [1,1] =  10
   [2,1] = [](0x0)
}

Если параметр errfunc после дополнительного строкового входного аргумента "ErrorHandler" — это строка, указатель на функцию, встроенная функция или анонимная функция, то errfunc определяет функцию, которая вызывается в случае возникновения ошибки в func. Определение функции должно иметь вид

function […] = errfunc (s, …)

где есть дополнительный входной аргумент для errfunc относительно func, заданный s. Это структура с элементами "identifier", "message", и "index", представляющими соответственно идентификатор ошибки, сообщение об ошибке и индекс элементов массива, вызвавших ошибку. Размер выходного аргумента errfunc должен совпадать с размером выходного аргумента func, в противном случае возникает ошибка. Например:

function y = ferr (s, x), y = "MyString"; endfunction
arrayfun (@str2num, [1234],
          "UniformOutput", false, "ErrorHandler", @ferr)
⇒
   {
     [1,1] = MyString
   }

См. также: spfun, cellfun, structfun.

: y = spfun (f, S) ¶

Вычисляет f (S) для ненулевых элементов S.

Функция f применяется только к ненулевым элементам входной матрицы S, которая, как правило, является разреженной. Функция f может передаваться в виде строки, указателя на функцию или встроенной функции.

Выходное значение y — разреженная матрица с той же структурой разреженности, что и вход S. spfun сохраняет структуру разреженности, что отличается от простого применения функции f к разреженной матрице S, когда f (0) != 0.

Пример

Сохранение разреженности spfun против обычного применения функции

S = pi * speye (2,2)
S =

Compressed Column Sparse (rows = 2, cols = 2, nnz = 2 [50%])

  (1, 1) -> 3.1416
  (2, 2) -> 3.1416

y = spfun (@cos, S)
y =

Compressed Column Sparse (rows = 2, cols = 2, nnz = 2 [50%])

  (1, 1) -> -1
  (2, 2) -> -1


y = cos (S)
y =

Compressed Column Sparse (rows = 2, cols = 2, nnz = 4 [100%])

  (1, 1) -> -1
  (2, 1) -> 1
  (1, 2) -> 1
  (2, 2) -> -1

См. также: arrayfun, cellfun, structfun.

: cellfun (name, C) ¶

: cellfun ("size", C, k) ¶

: cellfun ("isclass", C, class) ¶

: cellfun (func, C) ¶

: cellfun (func, C, D) ¶

: [a, …] = cellfun (…) ¶

: cellfun (…, "ErrorHandler", errfunc) ¶

: cellfun (…, "UniformOutput", val) ¶

Вычисляет функцию по имени name для элементов массива ячеек C.

Элементы из C передаются в указанную функцию по одному. Функция name может быть одной из функций

isempty

Возвращает 1 для пустых элементов.

islogical

Возвращает 1 для логических элементов.

isnumeric

Возвращает 1 для числовых элементов.

isreal

Возвращает 1 для вещественных элементов.

length

Возвращает вектор длин элементов ячеек.

ndims

Возвращает число измерений каждого элемента.

numel

prodofsize

Возвращает количество элементов, содержащихся в каждом элементе ячейки. Это произведение измерений объекта в каждом элементе ячейки.

size

Возвращает размер вдоль k-го измерения.

isclass

Возвращает 1 для элементов класса class.

Кроме того, cellfun принимает произвольную функцию func в виде встроенной функции, указателя на функцию или имени функции (в строковом представлении). Функция может принимать один или несколько аргументов, причём входные аргументы задаются C, D и т.д. Аналогично, функция может возвращать один или несколько выходных аргументов. Например:

cellfun ("atan2", {1, 0}, {0, 1})
     ⇒ [ 1.57080   0.00000 ]

Количество выходных аргументов cellfun соответствует количеству выходных аргументов функции. Выходные значения функции собираются в выходные аргументы cellfun следующим образом:

function [a, b] = twoouts (x)
  a = x;
  b = x*x;
endfunction
[aa, bb] = cellfun (@twoouts, {1, 2, 3})
     ⇒
        aa =
           1 2 3
        bb =
           1 4 9

Обратите внимание, что по умолчанию выходные аргументы являются массивами тех же размеров, что и входные аргументы. Входные аргументы, являющиеся ячейками-сингулярностями (1x1), автоматически расширяются до размера других аргументов.

Если параметр "UniformOutput" установлен в true (по умолчанию), то функция должна возвращать скаляры, которые будут объединены в выходной массив(ы). Если "UniformOutput" установлен в false, выходные значения объединяются в массив ячеек (или массивы ячеек). Например:

cellfun ("tolower", {"Foo", "Bar", "FooBar"},
         "UniformOutput", false)
⇒ {"foo", "bar", "foobar"}

При заданном параметре "ErrorHandler", тогда errfunc определяет функцию, которая вызывается в случае ошибки в func. Форма функции

function […] = errfunc (s, …)

где есть дополнительный входной аргумент для errfunc по отношению к func, заданный s. Это структура с элементами "identifier", "message", и "index", представляющими соответственно идентификатор ошибки, сообщение об ошибке и индекс входных аргументов элемента, вызвавшего ошибку. Например:

function y = foo (s, x), y = NaN; endfunction
cellfun ("factorial", {-1,2}, "ErrorHandler", @foo)
⇒ [NaN 2]

Используйте cellfun разумно. Функция cellfun — это полезный инструмент для избегания циклов. Часто она используется с анонимными указателями на функции; однако вызов анонимной функции включает в себя накладные расходы, сравнимые с накладными расходами функции m-файла. Передача указателя на встроенную функцию быстрее, потому что интерпретатор не участвует во внутреннем цикле. Например:

a = {…}
v = cellfun (@(x) det (x), a); # compute determinants
v = cellfun (@det, a); # faster

См. также: arrayfun, structfun, spfun.

: structfun (func, S) ¶

: [A, …] = structfun (…) ¶

: structfun (…, "ErrorHandler", errfunc) ¶

: structfun (…, "UniformOutput", val) ¶

Вычислить функцию с именем name по полям структуры S. Поля S передаются в функцию func по отдельности.

structfun принимает произвольную функцию func в виде встроенной функции, дескриптора функции или имени функции (в строковой форме). В случае строкового аргумента функция должна принимать один аргумент с именем x и возвращать строковое значение. Если функция возвращает более одного аргумента, они возвращаются как отдельные переменные вывода.

Если параметр "UniformOutput" установлен в значение true (по умолчанию), то функция должна вернуть один элемент, который будет добавлен в возвращаемое значение. Если "UniformOutput" имеет значение false, выводы помещаются в структуру с теми же именами полей, что и входная структура.

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

Учитывая параметр "ErrorHandler", errfunc определяет функцию, которая должна вызываться в случае, если func генерирует ошибку. Формат функции:

function […] = errfunc (se, …)

где есть дополнительный входной аргумент для errfunc по сравнению с func, заданный se. Это структура с элементами "identifier", "message" и "index", представляющими соответственно идентификатор ошибки, сообщение об ошибке и индекс во входных аргументах элемента, вызвавшего ошибку. Пример использования обработчика ошибок см. в cellfun.

См. также: cellfun, arrayfun, spfun.

В соответствии с предыдущими рекомендациями, старайтесь использовать встроенные функции Octave, когда это возможно, для лучшей производительности. Это особенно относится к четырём функциям выше. Например, при сложении двух массивов по элементам можно использовать дескриптор встроенной функции сложения @plus или определить анонимную функцию @(x,y) x + y. Однако, анонимная функция медленнее на 60% по сравнению с первым методом. См. Перегрузка операторов для списка основных функций, которые можно использовать вместо анонимных.