16.2 Переупорядочение матриц

: fliplr (x) ¶

Переворачивает массив слева направо.

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

fliplr ([1, 2; 3, 4])
     ⇒  2  1
         4  3

См. также: flipud, flip, rot90, rotdim.

: flipud (x) ¶

Переворачивает массив вверх ногами.

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

flipud ([1, 2; 3, 4])
     ⇒  3  4
         1  2

См. также: fliplr, flip, rot90, rotdim.

: flip (x) ¶

: flip (x, dim) ¶

Возвращает копию массива x с перевернутым порядком элементов вдоль измерения dim.

Если dim не указан, по умолчанию используется первое измерение, не являющееся одинарным.

Примеры:

## row vector
flip ([1  2  3  4])
      ⇒  4  3  2  1

## column vector
flip ([1; 2; 3; 4])
      ⇒  4
          3
          2
          1

## 2-D matrix along dimension 1
flip ([1 2; 3 4])
      ⇒  3  4
          1  2

## 2-D matrix along dimension 2
flip ([1 2; 3 4], 2)
      ⇒  2  1
          4  3

См. также: fliplr, flipud, rot90, rotdim, permute, transpose.

: rot90 (A) ¶

: rot90 (A, k) ¶

Поворачивает массив с шагом в 90 градусов.

Возвращает копию A с элементами, повернутыми против часовой стрелки на 90 градусов.

Второй аргумент необязателен и задаёт количество поворотов на 90 градусов (значение по умолчанию 1). Отрицательные значения k поворачивают матрицу по часовой стрелке. Например,

rot90 ([1, 2; 3, 4], -1)
    ⇒  3  1
        4  2

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

rot90 ([1, 2; 3, 4], -1)
rot90 ([1, 2; 3, 4], 3)
rot90 ([1, 2; 3, 4], 7)

Поворот всегда выполняется на плоскости первых двух измерений, т.е. строк и столбцов. Для выполнения поворота на любой другой плоскости используйте rotdim.

См. также: rotdim, fliplr, flipud, flip.

: rotdim (x) ¶

: rotdim (x, n) ¶

: rotdim (x, n, plane) ¶

Возвращает копию x с элементами, повернутыми против часовой стрелки на 90-градусные интервалы.

Второй аргумент n необязателен и задаёт количество поворотов на 90 градусов (значение по умолчанию 1). Отрицательные значения n поворачивают матрицу по часовой стрелке.

Третий аргумент также необязателен и определяет плоскость поворота. Если он присутствует, plane — это вектор из двух элементов, содержащий два различных допустимых измерения матрицы. Если plane не указан, используются первые два измерения, не являющиеся одинарными.

Например,

rotdim ([1, 2; 3, 4], -1, [1, 2])
     ⇒  3  1
         4  2

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

rotdim ([1, 2; 3, 4], -1, [1, 2])
rotdim ([1, 2; 3, 4], 3, [1, 2])
rotdim ([1, 2; 3, 4], 7, [1, 2])

См. также: rot90, fliplr, flipud, flip.

: cat (dim, array1, array2, …, arrayN) ¶

Возвращает конкатенацию объектов N-мерных массивов, array1, array2, …, arrayN вдоль измерения dim.

A = ones (2, 2);
B = zeros (2, 2);
cat (2, A, B)
  ⇒ 1 1 0 0
     1 1 0 0

Альтернативно, можно конкатенировать A и B вдоль второго измерения следующим образом:

[A, B]

dim может быть больше, чем размерности объектов N-мерных массивов, и результат будет иметь dim измерений, как показано в следующем примере:

cat (4, ones (2, 2), zeros (2, 2))
  ⇒ ans(:,:,1,1) =

       1 1
       1 1

     ans(:,:,1,2) =

       0 0
       0 0

См. также: horzcat, vertcat.

: horzcat (array1, array2, …, arrayN) ¶

Возвращает горизонтальную конкатенацию объектов N-мерных массивов, array1, array2, …, arrayN вдоль измерения 2.

Массивы также можно конкатенировать горизонтально, используя синтаксис для создания новых матриц. Например:

hcat = [ array1, array2, … ]

См. также: cat, vertcat.

: vertcat (array1, array2, …, arrayN) ¶

Возвращает вертикальную конкатенацию объектов N-мерных массивов, array1, array2, …, arrayN вдоль измерения 1.

Массивы также можно конкатенировать вертикально, используя синтаксис для создания новых матриц. Например:

vcat = [ array1; array2; … ]

См. также: cat, horzcat.

: permute (A, perm) ¶

Возвращает обобщённое транспонирование для объекта N-мерного массива A.

Вектор перестановки perm должен содержать элементы 1:ndims (A) (в любом порядке, но каждый элемент должен встречаться только один раз). N-е измерение A переназначается в измерение PERM(N). Например:

x = zeros ([2, 3, 5, 7]);
size (x)
   ⇒  2   3   5   7

size (permute (x, [2, 1, 3, 4]))
   ⇒  3   2   5   7

size (permute (x, [1, 3, 4, 2]))
   ⇒  2   5   7   3

## The identity permutation
size (permute (x, [1, 2, 3, 4]))
   ⇒  2   3   5   7

См. также: ipermute.

: ipermute (A, iperm) ¶

Обратная функция permute.

Выражение

ipermute (permute (A, perm), perm)

возвращает исходный массив A.

См. также: permute.

: reshape (A, m, n, …) ¶

: reshape (A, [m n …]) ¶

: reshape (A, …, [], …) ¶

: reshape (A, size) ¶

Возвращает матрицу с указанными размерами (m, n, …), элементы которой взяты из матрицы A.

Элементы матрицы извлекаются в порядке следования столбцов (как хранятся массивы Fortran).

Следующий код демонстрирует преобразование 1x4 строки в 2x2 квадратную матрицу.

reshape ([1, 2, 3, 4], 2, 2)
      ⇒  1  3
          2  4

Обратите внимание, что общее количество элементов в исходной матрице (prod (size (A))) должно совпадать с общим количеством элементов в новой матрице (prod ([m n …])).

Одно измерение возвращаемой матрицы может быть оставлено неопределённым, и Octave определит его размер автоматически. Для обозначения неопределённого измерения используется пустая матрица ([]).

См. также: resize, vec, postpad, cat, squeeze.

: resize (x, m) ¶

: resize (x, m, n, …) ¶

: resize (x, [m n …]) ¶

Изменяет размер x, отбрасывая элементы по мере необходимости.

В результате элемент с определёнными индексами равен соответствующему элементу x, если индексы находятся в пределах границ x; в противном случае элемент устанавливается в ноль.

Другими словами, выражение

y = resize (x, dv)

эквивалентно следующему коду:

y = zeros (dv, class (x));
sz = min (dv, size (x));
for i = 1:length (sz)
  idx{i} = 1:sz(i);
endfor
y(idx{:}) = x(idx{:});

, но выполняется более эффективно.

Если указан только m, и это скаляр, то размерность результата — m-на-m. Если m, n, … все являются скалярами, то размерности результата — m-на-n-на-…. Если в качестве входных данных задан вектор, то размерности результата задаются элементами этого вектора.

Объект может быть изменён на большее количество измерений, чем у него есть; в таком случае пропущенные измерения считаются равными 1. Изменение размера объекта на меньшее количество измерений невозможно.

См. также: reshape, postpad, prepad, cat.

: y = circshift (x, n) ¶

: y = circshift (x, n, dim) ¶

Циклически сдвинуть значения массива x.

n должен быть вектором целых чисел, не длиннее числа измерений в x. Значения n могут быть как положительными, так и отрицательными, что определяет направление сдвига значений x. Если элемент n равен нулю, то соответствующее измерение x не будет сдвинуто. Если n является скаляром и dim не указан, то сдвиг применяется к первому неединичному измерению.

Если задан скаляр dim, то операция выполняется вдоль указанного измерения. В этом случае n также должен быть скаляром.

Примеры:

x = [1, 2, 3;
     4, 5, 6;
     7, 8, 9];
## positive shift on rows (1st non-singular dim)
circshift (x, 1)
  ⇒
       7   8   9
       1   2   3
       4   5   6
## negative shift on rows (1st non-singular dim)
circshift (x, -2)
  ⇒
       7   8   9
       1   2   3
       4   5   6
## no shift of rows, shift columns by 1 (2nd dimension)
circshift (x, [0,1])
  ⇒
       3   1   2
       6   4   5
       9   7   8
## shift columns (2nd dimension)
circshift (x, 1, 2)
  ⇒
       3   1   2
       6   4   5
       9   7   8

См. также: permute, ipermute, shiftdim.

: shift (x, b) ¶

: shift (x, b, dim) ¶

Если x — вектор, выполняется циклический сдвиг элементов x на длину b.

Если x — матрица, выполняется то же самое для каждого столбца x.

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

: y = shiftdim (x, n) ¶

: [y, ns] = shiftdim (x) ¶

Сдвинуть измерения x на n, где n — целочисленный скаляр.

При положительном n измерения x сдвигаются влево, а ведущие измерения циклически перемещаются в конец. При отрицательном n измерения x сдвигаются вправо, и добавляется n ведущих единичных измерений.

При вызове с одним аргументом, shiftdim, удаляются ведущие единичные измерения, а количество удалённых измерений возвращается во втором выходном аргументе ns.

Например:

x = ones (1, 2, 3);
size (shiftdim (x, -1))
  ⇒   1   1   2   3
size (shiftdim (x, 1))
  ⇒   2   3
[b, ns] = shiftdim (x)
  ⇒ b =
        1   1   1
        1   1   1
  ⇒ ns = 1

См. также: reshape, permute, ipermute, circshift, squeeze.

: [s, i] = sort (x) ¶

: [s, i] = sort (x, dim) ¶

: [s, i] = sort (x, mode) ¶

: [s, i] = sort (x, dim, mode) ¶

Возвращает копию x с элементами, упорядоченными по возрастанию.

Для матриц, sort упорядочивает элементы внутри столбцов.

Например:

sort ([1, 2; 2, 3; 3, 1])
   ⇒  1  1
       2  2
       3  3

Если задан необязательный аргумент dim, то матрица сортируется вдоль измерения, определённого dim. Необязательный аргумент mode определяет порядок сортировки. Допустимые значения mode — "ascend" или "descend".

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

[s, i] = sort ([1, 2; 2, 3; 3, 1])
  ⇒ s = 1  1
         2  2
         3  3
  ⇒ i = 1  3
         2  1
         3  2

Для равных элементов индексы такие, что равные элементы перечислены в порядке их появления в исходном списке.

Сортировка комплексных элементов выполняется сначала по величине (abs (z)) и, при совпадении, по фазе (angle (z)). Например:

sort ([1+i; 1; 1-i])
    ⇒ 1 + 0i
       1 - 1i
       1 + 1i

Значения NaN обрабатываются как большие, чем любые другие значения, и сортируются в конец списка.

Функция sort также может быть использована для сортировки строк и массивов ячеек строк, в этом случае используется лексикографический порядок ASCII (заглавная буква 'A' предшествует строчной 'a') строк.

Алгоритм, используемый в sort, оптимизирован для сортировки частично упорядоченных списков.

См. также: sortrows, issorted.

: [s, i] = sortrows (A) ¶

: [s, i] = sortrows (A, c) ¶

Сортировать строки матрицы A в порядке столбцов, указанных в c.

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

Пример: сортировать по столбцу 2 по убыванию, затем по 3 по возрастанию

x = [ 7, 1, 4;
      8, 3, 5;
      9, 3, 6 ];
sortrows (x, [-2, 3])
   ⇒ 8  3  5
      9  3  6
      7  1  4

См. также: sort.

: issorted (a) ¶

: issorted (a, mode) ¶

: issorted (a, "rows", mode) ¶

Возвращает true, если массив отсортирован в соответствии с mode, которое может быть "ascend", "descend", или "either".

По умолчанию, mode — "ascend". Значения NaN обрабатываются так же, как sort.

Если необязательный аргумент "rows" указан, проверять, отсортирован ли массив по строкам, как выводится функцией sortrows (без опций).

Эта функция не поддерживает разреженные матрицы.

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

: nth_element (x, n) ¶

: nth_element (x, n, dim) ¶

Выбирает n-й наименьший элемент вектора, используя порядок, определённый sort.

Результат эквивалентен sort(x)(n).

n также может быть непрерывным диапазоном, либо возрастающим l:u, либо убывающим u:-1:l, в этом случае возвращается диапазон элементов.

Если x — массив, nth_element работает вдоль измерения, определённого dim, или по первому неединичному измерению, если dim не задан.

Примечание для программистов: nth_element оборачивает алгоритмы C++ стандартной библиотеки nth_element и partial_sort. В среднем, сложность операции — O(M*log(K)), где M = size (x, dim) и K = length (n). Эта функция предназначена для случаев, когда отношение K/M мало; в противном случае может быть лучше использовать sort.

См. также: sort, min, max.

: A_LO = tril (A) ¶

: A_LO = tril (A, k) ¶

: A_LO = tril (A, k, pack) ¶

Возвращает новую матрицу, полученную из нижней треугольной части матрицы A, и устанавливает все остальные элементы в ноль.

Необязательный второй аргумент определяет, сколько диагоналей выше или ниже главной диагонали также должно быть установлено в ноль. Значение по умолчанию k равно нулю, что включает главную диагональ в результат. Если значение k — ненулевое целое число, то выбор элементов начинается со смещения на k диагоналей выше главной диагонали для положительного k или ниже главной диагонали для отрицательного k. Абсолютное значение k не может быть больше числа поддиагоналей или наддиагоналей.

Пример 1: исключить главную диагональ

tril (ones (3), -1)
     ⇒  0  0  0
         1  0  0
         1  1  0

Пример 2: включить первую наддиагональ

tril (ones (3), 1)
     ⇒  1  1  0
         1  1  1
         1  1  1

Если необязательный третий аргумент "pack" задан, то выделенные элементы не вставляются в матрицу, а вместо этого выстраиваются столбцами друг над другом и возвращаются в виде столбцового вектора.

См. также: triu, istril, diag.

: A_UP = triu (A) ¶

: A_UP = triu (A, k) ¶

: A_UP = triu (A, k, pack) ¶

Возвращает новую матрицу, образованную извлечением верхней треугольной части матрицы A, а все остальные элементы устанавливаются в ноль.

Необязательный второй аргумент указывает, сколько диагоналей над или под главной диагональю также должны быть установлены в ноль. Значение по умолчанию для k равно нулю, что включает главную диагональ в результат. Если значение k является ненулевым целым числом, то выбор элементов начинается со смещения k диагоналей над главной диагональю для положительного k или под главной диагональю для отрицательного k. Абсолютное значение k не должно быть больше числа поддиагоналей или наддиагоналей.

Пример 1: исключить главную диагональ

triu (ones (3), 1)
     ⇒  0  1  1
         0  0  1
         0  0  0

Пример 2: включить первую поддиагональ

triu (ones (3), -1)
     ⇒  1  1  1
         1  1  1
         0  1  1

Если дан необязательный третий аргумент "pack", то извлеченные элементы не вставляются в матрицу, а вместо этого укладываются стопкой по столбцам друг над другом и возвращаются как столбец.

См. также: tril, istriu, diag.

: v = vec (x) ¶

: v = vec (x, dim) ¶

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

Без dim это эквивалентно x(:).

Если dim задан, размерности v устанавливаются в dim со всеми элементами вдоль последней размерности. Это эквивалентно shiftdim (x(:), 1-dim).

См. также: vech, resize, cat.

: vech (x) ¶

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

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

См. также: vec.

: prepad (x, l) ¶

: prepad (x, l, c) ¶

: prepad (x, l, c, dim) ¶

Добавляет скалярное значение c к вектору x до тех пор, пока его длина не станет равной l. Если c не задан, используется значение 0.

Если length (x) > l, элементы с начала x удаляются до получения вектора длины l.

Если x является матрицей, элементы добавляются или удаляются из каждой строки.

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

Если dim больше размерностей x, результат будет иметь размерность dim.

См. также: postpad, cat, resize.

: postpad (x, l) ¶

: postpad (x, l, c) ¶

: postpad (x, l, c, dim) ¶

Добавляет скалярное значение c к вектору x до тех пор, пока его длина не станет равной l. Если c не задан, используется значение 0.

Если length (x) > l, элементы с конца x удаляются до получения вектора длины l.

Если x является матрицей, элементы добавляются или удаляются из каждой строки.

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

Если dim больше размерностей x, результат будет иметь размерность dim.

См. также: prepad, cat, resize.

: M = diag (v) ¶

: M = diag (v, k) ¶

: M = diag (v, m, n) ¶

: v = diag (M) ¶

: v = diag (M, k) ¶

Возвращает диагональную матрицу с вектором v на диагонали k.

Второй аргумент необязателен. Если он положителен, вектор помещается на k-ю наддиагональ. Если он отрицателен, он помещается на -k-ю поддиагональ. Значение по умолчанию для k равно 0, и вектор помещается на главную диагональ. Например:

diag ([1, 2, 3], 1)
   ⇒  0  1  0  0
       0  0  2  0
       0  0  0  3
       0  0  0  0

Формат с 3 входными значениями возвращает диагональную матрицу с вектором v на главной диагонали, и результирующая матрица имеет размер m строк х n столбцов.

Для матричного аргумента вместо вектора diag извлекается k-я диагональ матрицы.

: blkdiag (A, B, C, …) ¶

Создает блочно-диагональную матрицу из A, B, C, …

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

См. также: diag, horzcat, vertcat, sparse.