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, transpose.

: 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

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

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 измерений размером 1.

При вызове с одним аргументом shiftdim удаляет начальные измерения размером 1 и возвращает число удалённых измерений во втором выходном аргументе 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, матрица сортируется вдоль указанного измерения. Необязательный аргумент 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.

: 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 строк и n столбцов.

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

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

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

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

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