16.2 Перестановка матриц

: B = fliplr (A) ¶

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

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

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

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

: B = flipud (A) ¶

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

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

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

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

: B = flip (A) ¶

: B = flip (A, dim) ¶

Возвращает копию массива A, перевернутого по размерности 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, транспонировать.

: B = rot90 (A) ¶

: B = 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.

: B = rotdim (A) ¶

: B = rotdim (A, n) ¶

: B = rotdim (A, n, plane) ¶

Возвращает копию A с элементами, повернутыми против часовой стрелки на 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.

: A = 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.

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

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

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

A = [ array1, array2, … ]

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

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

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

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

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

A = [ array1; array2; … ]

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

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

: B = 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.

: A = ipermute (B, iperm) ¶

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

Выражение

ipermute (permute (A, perm), perm)

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

См. также: permute.

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

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

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

: B = 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.

: B = resize (A, m) ¶

: B = resize (A, m, n, …) ¶

: B = resize (A, [m n …]) ¶

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

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

Другими словами, оператор

B = resize (A, dv)

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

B = zeros (dv, class (A));
sz = min (dv, size (A));
for i = 1:length (sz)
  idx{i} = 1:sz(i);
endfor
B(idx{:}) = A(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.

: 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 также может использоваться для сортировки строк и массивов ячеек строк, в этом случае используется лексикографический порядок (заглавная ’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.

: tf = issorted (A) ¶

: tf = issorted (A, mode) ¶

: tf = issorted (A, "rows", mode) ¶

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

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

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

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

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

: nel = nth_element (x, n) ¶

: nel = 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.

: v = vech (x) ¶

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

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

См. также: vec.

: B = prepad (A, l) ¶

: B = prepad (A, l, c) ¶

: B = prepad (A, l, c, dim) ¶

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

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

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

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

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

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

: B = postpad (A, l) ¶

: B = postpad (A, l, c) ¶

: B = postpad (A, l, c, dim) ¶

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

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

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

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

Если dim больше размеров A, результат будет иметь 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

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

Если на вход подаётся матрица, а не вектор, diag извлекается k-ая диагональ матрицы.

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

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

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

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