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-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 encapsulates the C++ standard library algorithms nth_element and 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.