16.1 Поиск элементов и проверка условий

Функции any и all полезны для определения, удовлетворяют ли какие-либо или все элементы матрицы некоторому условию. Функция find также полезна для определения, какие элементы матрицы удовлетворяют заданному условию.

: any(x) ¶

: any(x, dim) ¶

Для векторного аргумента возвращает true (логическое 1), если какой-либо элемент вектора не равен нулю.

Для матричного аргумента возвращает строковый вектор логических единиц и нулей, где каждый элемент указывает, существует ли хотя бы один ненулевой элемент в соответствующем столбце матрицы. Например:

any (eye (2, 4))
 ⇒ [ 1, 1, 0, 0 ]

Если необязательный аргумент dim указан, работа выполняется вдоль размерности dim. Например:

any (eye (2, 4), 2)
 ⇒ [ 1; 1 ]

См. также: all.

: all(x) ¶

: all(x, dim) ¶

Для векторного аргумента возвращает true (логическое 1), если все элементы вектора не равны нулю.

Для матричного аргумента возвращает строковый вектор логических единиц и нулей, где каждый элемент указывает, все ли элементы в соответствующем столбце матрицы не равны нулю. Например:

all ([2, 3; 1, 0])
    ⇒ [ 1, 0 ]

Если необязательный аргумент dim указан, работа выполняется вдоль размерности dim.

См. также: any.

Поскольку операторы сравнения (см. Операторы сравнения) возвращают матрицы единиц и нулей, легко проверить матрицу на различные условия, а не только на то, являются ли элементы ненулевыми. Например,

all (all (rand (5) < 0.9))
     ⇒ 0

проверяет случайную матрицу 5x5, чтобы определить, все ли её элементы меньше 0,9.

Обратите внимание, что в контекстах условных выражений (например, в условии операторов if и while) Octave обрабатывает проверку так, как если бы вы набрали all (all (condition)).

: z = xor(x, y) ¶

: z = xor(x1, x2, …) ¶

Возвращает операцию исключающего ИЛИ для x и y.

Для булевых выражений x и y, xor (x, y) истинно тогда и только тогда, когда одно из x или y истинно. В противном случае, если x и y оба истинны или оба ложны, xor возвращает false.

Таблица истинности для операции xor:

	x	y	z
	-	-	-
	0	0	0
	1	0	1
	0	1	1
	1	1	0

Если задано более двух аргументов, операция xor применяется кумулятивно слева направо:

(…((x1 XOR x2) XOR x3) XOR …)

См. также: and, or, not.

: diff(x) ¶

: diff(x, k) ¶

: diff(x, k, dim) ¶

Если x — вектор длиной n, diff (x) — вектор первых разностей x(2) - x(1), …, x(n) - x(n-1).

Если x — матрица, diff (x) — матрица разностей столбцов вдоль первой размерности, отличной от единицы.

Второй аргумент необязателен. Если он указан, diff (x, k), где k — неотрицательное целое число, возвращает k-ые разности. Возможно, что k больше, чем первая размерность матрицы, отличная от единицы. В этом случае diff продолжает вычисление разностей вдоль следующей размерности, отличной от единицы.

Размерность, по которой нужно вычислить разность, можно явно указать с помощью необязательной переменной dim. В этом случае k-ые разности вычисляются по этой размерности. В случае, если k превышает size (x, dim), возвращается пустая матрица.

См. также: sort, merge.

: isinf(x) ¶

Возвращает логический массив, равный true, где элементы x бесконечны, и false, где они не бесконечны.

Например:

isinf ([13, Inf, NA, NaN])
      ⇒ [ 0, 1, 0, 0 ]

См. также: isfinite, isnan, isna.

: isnan(x) ¶

Возвращает логический массив, равный true, где элементы x — значения NaN, и false, где они не являются NaN.

Значения NA также считаются значениями NaN. Например:

isnan ([13, Inf, NA, NaN])
      ⇒ [ 0, 0, 1, 1 ]

См. также: isna, isinf, isfinite.

: isfinite(x) ¶

Возвращает логический массив, равный true, где элементы x — конечные значения, и false, где они не являются конечными.

Например:

isfinite ([13, Inf, NA, NaN])
     ⇒ [ 1, 0, 0, 0 ]

См. также: isinf, isnan, isna.

: [err, yi, …] = common_size(xi, …) ¶

Определяет, являются ли все входные аргументы скалярами или имеют общий размер.

Если верно, err — ноль, а yi — матрица общего размера со всеми элементами равными xi, если это скаляр, или xi в противном случае. Если входные данные не могут быть приведены к общему размеру, err — 1, а yi — xi. Например:

[err, a, b] = common_size ([1 2; 3 4], 5)
     ⇒ err = 0
     ⇒ a = [ 1, 2; 3, 4 ]
     ⇒ b = [ 5, 5; 5, 5 ]

Это полезно для реализации функций, где аргументы могут быть либо скалярами, либо иметь общий размер.

См. также: size, size_equal, numel, ndims.

: idx = find(x) ¶

: idx = find(x, n) ¶

: idx = find(x, n, direction) ¶

: [i, j] = find(…) ¶

: [i, j, v] = find(…) ¶

Возвращает вектор индексов ненулевых элементов матрицы как строку, если x — строковый вектор, или как столбец в противном случае.

Для получения единственного индекса для каждого элемента матрицы Octave предполагает, что столбцы матрицы образуют один длинный вектор (как хранятся массивы Fortran). Например:

find (eye (2))
  ⇒ [ 1; 4 ]

Если заданы два входных значения, n указывает максимальное количество элементов, которые нужно найти с начала матрицы или вектора.

Если заданы три входных значения, direction должно быть одним из "first" или "last", запрашивая только первые или последние n индексов соответственно. Однако, индексы всегда возвращаются в порядке возрастания.

Если запрошены два выходных значения, find возвращает индексы строк и столбцов ненулевых элементов матрицы. Например:

[i, j] = find (2 * eye (2))
    ⇒ i = [ 1; 2 ]
    ⇒ j = [ 1; 2 ]

Если запрошены три выходных значения, find также возвращает вектор, содержащий ненулевые значения. Например:

[i, j, v] = find (3 * eye (2))
       ⇒ i = [ 1; 2 ]
       ⇒ j = [ 1; 2 ]
       ⇒ v = [ 3; 3 ]

Если x — многомерный массив размера m x n x p x ..., j содержит позиции столбцов, как если бы x был сжат в двумерную матрицу размера m x (n + p + ...).

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

sz = size (a);
[i, j, v] = find (a);
b = sparse (i, j, v, sz(1), sz(2));

См. также: nonzeros.

: idx = lookup (table, y) ¶

: idx = lookup (table, y, opt) ¶

Поиск значений в отсортированной таблице.

Эта функция обычно используется как прелюдия к интерполяции.

Если таблица возрастает, имеет длину N и idx = lookup (table, y), то table(idx(i)) <= y(i) < table(idx(i+1)) для всех y(i) в таблице. Если y(i) < table(1), то idx(i) равно 0. Если y(i) >= table(end) или isnan (y(i)), то idx(i) равно N.

Если таблица убывает, то тесты меняются на обратные. Для нестрого монотонных таблиц пустые интервалы всегда пропускаются. Результат не определён, если table не монотонна или содержит NaN.

Сложность поиска — O(M*log(N)), где M — размер y. В частном случае, когда y также отсортирована, сложность — O(min (M*log(N), M+N)).

table и y также могут быть ячейками строк (или y может быть одной строкой). В этом случае поиск строк выполняется с использованием лексикографического сравнения.

Если указаны opts, они должны быть строкой с буквами, указывающими дополнительные параметры.

m

Совпадение. table(idx(i)) == y(i) если y(i) встречается в таблице; в противном случае, idx(i) равно нулю.

b

Булево. idx(i) — логическая 1 или 0, указывающая, содержится ли y(i) в таблице или нет.

l

Левый. Для числовых поисков левая подтаблица должна быть расширена до минус бесконечности (т.е., все индексы по крайней мере 1).

r

Правый. Для числовых поисков правая подтаблица должна быть расширена до бесконечности (т.е., все индексы не более N-1).

Примечание: Если table не отсортирована, результаты от lookup будут непредсказуемыми.

Если вы хотите проверить, существует ли переменная вообще, а не свойства ее элементов, обратитесь к Статусу переменных.