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.