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, транспонировать.

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-by-m. Если m, n, … — скаляры, то размеры результата равны m-by-n-by-…. Если на вход подается вектор, то размеры результата задаются элементами этого вектора.

Объект может быть изменен на большее число размерностей, чем у него есть; в этом случае пропущенные размерности предполагаются равными 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 также может использоваться для сортировки строк и ячеек строк, в этом случае используется лексикографический порядок (заглавная «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

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

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

blkdiag (A, B, C, …)

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

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

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