16.3 Специальные матрицы-утилиты

: I = eye (n) ¶

: I = eye (m, n) ¶

: I = eye ([m n]) ¶

: I = eye (…, class) ¶

Возвращает единичную матрицу.

Если вызвана с одним скалярным аргументом n, возвращает квадратную единичную матрицу NxN.

Если переданы два скалярных аргумента (m, n), eye рассматривает их как количество строк и столбцов. Если задан вектор с двумя элементами, eye использует значения элементов как количество строк и столбцов соответственно. Например:

eye (3)
 ⇒  1  0  0
     0  1  0
     0  0  1

Следующие выражения дают один и тот же результат:

eye (2)
≡
eye (2, 2)
≡
eye (size ([1, 2; 3, 4]))

Необязательный аргумент class позволяет eye возвращать массив указанного типа, например

val = zeros (n,m, "uint8")

Вызов eye без аргументов эквивалентен вызову с аргументом 1. Любые отрицательные размеры обрабатываются как нулевые. Эти необычные определения предназначены для совместимости с MATLAB.

См. также: speye, ones, zeros.

: val = ones (n) ¶

: val = ones (m, n) ¶

: val = ones (m, n, k, …) ¶

: val = ones ([m n …]) ¶

: val = ones (…, "like", var) ¶

: val = ones (…, class) ¶

Возвращает матрицу или N-мерный массив, элементы которого все равны 1.

Если вызвана с одним скалярным целочисленным аргументом n, возвращает квадратную матрицу NxN.

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

Для создания постоянной матрицы, значения которой все одинаковые, используйте выражение, такое как

val_matrix = val * ones (m, n)

Если переменная var указана после "like", выход val будет иметь тот же тип данных, сложность и разреженность, что и var.

Необязательный аргумент class задаёт класс возвращаемого массива и по умолчанию равен double. Например:

val = ones (m,n, "uint8")

См. также: zeros.

: val = zeros (n) ¶

: val = zeros (m, n) ¶

: val = zeros (m, n, k, …) ¶

: val = zeros ([m n …]) ¶

: val = zeros (…, "like", var) ¶

: val = zeros (…, class) ¶

Возвращает матрицу или N-мерный массив, элементы которого все равны 0.

Если вызвана с одним скалярным целочисленным аргументом, возвращает квадратную матрицу NxN.

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

Если переменная var указана после "like", выход val будет иметь тот же тип данных, сложность и разреженность, что и var.

Необязательный аргумент class задаёт класс возвращаемого массива и по умолчанию равен double. Например:

val = zeros (m,n, "uint8")

См. также: ones.

: B = repmat (A, m) ¶

: B = repmat (A, m, n) ¶

: B = repmat (A, m, n, p …) ¶

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

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

Повторение матрицы или N-мерного массива.

Создаёт блочную матрицу размера m на n, с копией матрицы A в качестве каждого элемента.

Если n не указан, создаётся блочная матрица размера m на m. Для копирования по более чем двум измерениям укажите количество копий по каждому измерению m, n, p, …, в векторе во втором аргументе.

См. также: bsxfun, kron, repelems.

: y = repelems (x, r) ¶

Построение вектора из повторяющихся элементов из x.

r - целочисленная матрица 2xN, которая определяет, какие элементы повторять и как часто.

Элементы в первой строке r(1,j) выбирают элемент для повторения. Соответствующий элемент во второй строке r(2,j) задаёт количество повторений. Если x - матрица, то столбцы x представляются как сложенные друг на друга для целей индекса выбора. Всегда возвращается строковый вектор.

Понятие результата вычисляется следующим образом:

y = [];
for i = 1:columns (r)
  y = [y, x(r(1,i)*ones(1, r(2,i)))];
endfor

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

: xxx = repelem (x, R) ¶

: xxx = repelem (x, R_1, …, R_n) ¶

Построение массива из повторяющихся элементов из x и инструкций повторения R_1, ….

x должен быть скаляром, вектором или N-мерным массивом.

Инструкция повторения R_j должна быть либо скалярной, либо вектором. Если инструкция скалярная, то каждый компонент x в измерении j повторяется R_j раз. Если инструкция векторная, то она должна иметь то же количество элементов, что и соответствующее измерение j массива x. В этом случае k-й компонент измерения j повторяется R_j(k) раз.

Если x скаляр или вектор, то repelem можно вызвать с одной инструкцией повторения R, и repelem вернёт вектор с той же ориентацией, что и входной.

Если x матрица, то нужно указать, по крайней мере, две R_j.

Примечание: использование repelem с вектором x и вектором R_j эквивалентно декодированию длины последовательности.

Примеры:

A = [1 2 3 4 5];
B = [2 1 0 1 2];
repelem (A, B)
  ⇒   1   1   2   4   5   5

A = magic (3)
  ⇒ A =
       8   1   6
       3   5   7
       4   9   2
B1 = [1 2 3];
B2 = 2;
repelem (A, B1, B2)
  ⇒     8   8   1   1   6   6
         3   3   5   5   7   7
         3   3   5   5   7   7
         4   4   9   9   2   2
         4   4   9   9   2   2
         4   4   9   9   2   2

Может быть указано больше R_j, чем измерений x. Любые дополнительные R_j должны быть скалярными (потому что размер x в этих измерениях равен только 1), и x будет соответственно реплицирован в этих измерениях.

A = [1 2 3 4 5];
B1 = 2;
B2 = [2 1 3 0 2];
B3 = 3;
repelem (A, B1, B2, B3)
  ⇒    ans(:,:,1) =
           1   1   2   3   3   3   5   5
           1   1   2   3   3   3   5   5

        ans(:,:,2) =

           1   1   2   3   3   3   5   5
           1   1   2   3   3   3   5   5

        ans(:,:,3) =
           1   1   2   3   3   3   5   5
           1   1   2   3   3   3   5   5

R_j должны быть указаны в порядке.

repelem ([-1, 0; 0, 1], 1, 2, 1, 2)
  ⇒  ans(:,:,1,1) =
        -1  -1   0   0
         0   0   1   1

      ans(:,:,1,2) =
        -1  -1   0   0
         0   0   1   1

Если задано меньше R_j, чем измерений x, repelem предположит, что R_j равен 1 для этих измерений.

A = cat (3, [-1 0; 0 1], [-1 0; 0 1])
  ⇒  ans(:,:,1) =
        -1   0
         0   1

      ans(:,:,2) =
        -1   0
         0   1

repelem (A,2,3)
  ⇒  ans(:,:,1) =
        -1  -1  -1   0   0   0
        -1  -1  -1   0   0   0
         0   0   0   1   1   1
         0   0   0   1   1   1

      ans(:,:,2) =
        -1  -1  -1   0   0   0
        -1  -1  -1   0   0   0
         0   0   0   1   1   1
         0   0   0   1   1   1

repelem сохраняет класс x и работает со строками, массивами ячеек, значениями NA и NAN в качестве входных данных. Если какая-либо R_j равна 0, выходной массив будет пустым.

repelem ("Octave", 2, 3)
  ⇒    OOOccctttaaavvveee
        OOOccctttaaavvveee

repelem ([1 2 3; 1 2 3], 2, 0)
  ⇒    [](4x0)

См. также: cat, kron, repmat.

Функции linspace и logspace очень легко позволяют создавать векторы с равномерно или логарифмически распределёнными элементами. См. Диапазоны.

: y = linspace (start, end) ¶

: y = linspace (start, end, n) ¶

Возвращает строчный вектор с n линейно расположенными элементами между start и end.

Если количество элементов больше одного, то конечные точки start и end всегда включаются в диапазон. Если start больше, чем end, элементы сохраняются в убывающем порядке. Если количество точек не указано, используется значение 100.

Функция linspace возвращает строчный вектор, когда start и end являются скалярами. Если один или оба входных данных являются векторами, то linspace преобразует их в столбцовые векторы и возвращает матрицу, где каждая строка является независимой последовательностью между start(row_n), end(row_n).

Для совместимости с MATLAB, возвращает второй аргумент (end), когда запрашивается только одно значение (n = 1).

См. также: colon, logspace.

: y = logspace (a, b) ¶

: y = logspace (a, b, n) ¶

: y = logspace (a, pi, n) ¶

Возвращает строчный вектор с n элементами, расположенными логарифмически от 10^a до 10^b.

Если n не указано, по умолчанию используется 50.

Если b равно pi, точки находятся между 10^a и pi, а не 10^a и 10^pi, для совместимости с соответствующей функцией MATLAB.

Также для совместимости с MATLAB, возвращает правую границу диапазона (10^b), когда запрашивается только одно значение.

См. также: linspace.

: x = rand (n) ¶

: x = rand (m, n, …) ¶

: x = rand ([m n …]) ¶

: x = rand (…, "single") ¶

: x = rand (…, "double") ¶

: v = rand ("state") ¶

: rand ("state", v) ¶

: rand ("state", "reset") ¶

: v = rand ("seed") ¶

: rand ("seed", v) ¶

: rand ("seed", "reset") ¶

Возвращает матрицу со случайными элементами, равномерно распределенными в интервале (0, 1).

Аргументы обрабатываются так же, как аргументы для eye.

Вы можете запросить состояние генератора случайных чисел, используя форму

v = rand ("state")

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

rand ("state", v)

Вы также можете инициализировать вектор состояния из произвольного вектора длиной ≤ 625 для v. Это новое состояние будет хэшем, основанным на значении v, а не на самом v.

По умолчанию генератор инициализируется путем добавления энтропии от времени работы системы, времени ЦП, текущей доли секунды, идентификатора процесса и — если доступно — до 1024 бит из источника случайных чисел C++ random_device, который может быть недетерминированным (специфичным для реализации). Обратите внимание, что это отличается от MATLAB, который всегда инициализирует состояние в одно и то же состояние при запуске. Чтобы получить поведение, сравнимое с MATLAB, инициализируйте детерминистическим вектором состояния в запускаемых файлах Octave (см. Запускаемые файлы).

Для вычисления псевдослучайной последовательности rand использует Mersenne Twister с периодом 2^{19937}-1 (См. M. Matsumoto и T. Nishimura, Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator, ACM Trans. on Modeling and Computer Simulation Vol. 8, No. 1, pp. 3–30, January 1998, http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html). Не используйте для криптографии без безопасного хэширования нескольких возвращаемых значений вместе, иначе состояние генератора может быть узнано после чтения 624 последовательных значений.

В более старых версиях Octave использовался другой генератор случайных чисел. Новый генератор используется по умолчанию, поскольку он значительно быстрее, чем старый генератор, и производит случайные числа со значительно более длительным циклом. Однако в некоторых случаях может быть желательно получить те же случайные последовательности, что и у старых генераторов. Для этого используется ключевое слово "seed", чтобы указать, что следует использовать старые генераторы, как в

rand ("seed", val)

что устанавливает начальное значение генератора в val. Начальное значение генератора можно запросить с помощью

s = rand ("seed")

Однако следует отметить, что запрос начального значения не приведет к тому, что rand будет использовать старые генераторы, только установка начального значения. Чтобы rand снова использовал новые генераторы, следует использовать ключевое слово "state" для сброса состояния rand.

Состояние или начальное значение генератора можно сбросить до нового случайного значения с помощью ключевого слова "reset".

Класс возвращаемого значения можно контролировать с помощью конечного аргумента "double" или "single". Это единственные допустимые классы.

См. также: randn, rande, randg, randp.

: R = randi (imax) ¶

: R = randi (imax, n) ¶

: R = randi (imax, m, n, …) ¶

: R = randi ([imin imax], …) ¶

: R = randi (…, "class") ¶

Возвращает случайные целые числа в диапазоне 1:imax.

Дополнительные аргументы определяют форму возвращаемой матрицы. Когда аргументы не указаны, возвращается одно случайное целое число. Если указан один аргумент n, то возвращается квадратная матрица (n x n). Два или более аргументов вернут многомерную матрицу (m x n x …).

Диапазон целых чисел может опционально описываться двухэлементной матрицей с нижней и верхней границей, в этом случае возвращаемые целые числа будут находиться в интервале [imin, imax].

Необязательный аргумент class вернет матрицу требуемого типа. По умолчанию используется "double".

В следующем примере возвращается 150 целых чисел в диапазоне 1–10.

ri = randi (10, 150, 1)

Примечание по реализации: randi внутренне полагается на rand, который использует класс "double" для представления чисел. Это ограничивает максимальное целое число (imax) и диапазон (imax - imin) значением, возвращаемым функцией flintmax. Для чисел с плавающей точкой IEEE это значение равно 2^{53} - 1.

См. также: rand, randn.

: x = randn (n) ¶

: x = randn (m, n, …) ¶

: x = randn ([m n …]) ¶

: x = randn (…, "single") ¶

: x = randn (…, "double") ¶

: v = randn ("state") ¶

: randn ("state", v) ¶

: randn ("state", "reset") ¶

: v = randn ("seed") ¶

: randn ("seed", v) ¶

: randn ("seed", "reset") ¶

Возвращает матрицу с случайными элементами, имеющими нормальное распределение со средним значением ноль и дисперсией один.

Аргументы обрабатываются так же, как и аргументы для rand.

По умолчанию randn использует метод «Зиггурат» Марсальи и Цанга для преобразования из равномерного распределения в нормальное.

Тип возвращаемого значения можно контролировать, используя "double" или "single" аргумент. Это единственные допустимые типы.

Ссылка: Г. Марсальгия и В.В. Цанг, Метод Зиггурат для генерации случайных величин, Журнал статистического программного обеспечения, том 5, 2000, https://www.jstatsoft.org/v05/i08/

См. также: rand, rande, randg, randp.

: x = rande (n) ¶

: x = rande (m, n, …) ¶

: x = rande ([m n …]) ¶

: x = rande (…, "single") ¶

: x = rande (…, "double") ¶

: v = rande ("state") ¶

: rande ("state", v) ¶

: rande ("state", "reset") ¶

: v = rande ("seed") ¶

: rande ("seed", v) ¶

: rande ("seed", "reset") ¶

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

Аргументы обрабатываются так же, как и аргументы для rand.

По умолчанию rande использует метод «Зиггурат» Марсальи и Цанга для преобразования из равномерного распределения в экспоненциальное.

Тип возвращаемого значения можно контролировать, используя "double" или "single" аргумент. Это единственные допустимые типы.

Ссылка: Г. Марсальгия и В.В. Цанг, Метод Зиггурат для генерации случайных величин, Журнал статистического программного обеспечения, том 5, 2000, https://www.jstatsoft.org/v05/i08/

См. также: rand, randn, randg, randp.

: x = randp (l, n) ¶

: x = randp (l, m, n, …) ¶

: x = randp (l, [m n …]) ¶

: x = randp (…, "single") ¶

: x = randp (…, "double") ¶

: v = randp ("state") ¶

: randp ("state", v) ¶

: randp ("state", "reset") ¶

: v = randp ("seed") ¶

: randp ("seed", v) ¶

: randp ("seed", "reset") ¶

Возвращает матрицу со случайными элементами, распределёнными по Пуассону, с параметром среднего значения, заданным первым аргументом, l.

Аргументы обрабатываются так же, как и аргументы для rand, за исключением аргумента l.

Используются пять разных алгоритмов в зависимости от диапазона l и является ли l скаляром или матрицей.

Для скаляра l ≤ 12, используется прямой метод.

В.Г. Пресс и др., Численные рецепты на C, Издательство Кембриджского университета, 1992.

Для скаляра l > 12, используется метод отбраковки.[1]

В.Г. Пресс и др., Численные рецепты на C, Издательство Кембриджского университета, 1992.

Для матрицы l ≤ 10, используется метод обратного преобразования.[2]

Е. Штадлобер и др., Исходный код WinRand, доступен через FTP.

Для матрицы l > 10, используется метод кусочной отбраковки.

Е. Штадлобер и др., Исходный код WinRand, доступен через FTP, или Г. Цехнер, Эффективное выборка из непрерывных и дискретных унимодальных распределений, Диссертация, 156 стр., Технический университет Граца, Австрия, 1994.

Для l > 1e8, используется нормальное приближение.

Л. Монтанет и др., Обзор свойств частиц, Physical Review D 50 с. 1284, 1994.

Тип возвращаемого значения можно контролировать, используя "double" или "single" аргумент. Это единственные допустимые типы.

См. также: rand, randn, rande, randg.

: x = randg (a, n) ¶

: x = randg (a, m, n, …) ¶

: x = randg (a, [m n …]) ¶

: x = randg (…, "single") ¶

: x = randg (…, "double") ¶

: v = randg ("state") ¶

: randg ("state", v) ¶

: randg ("state", "reset") ¶

: v = randg ("seed") ¶

: randg ("seed", v) ¶

: randg ("seed", "reset") ¶

Возвращает матрицу с gamma (a,1) распределёнными случайными элементами.

Аргументы обрабатываются так же, как и аргументы для rand, за исключением аргумента a.

Это можно использовать для генерации многих распределений:

gamma (a, b) для a > -1, b > 0

r = b * randg (a)

beta (a, b) для a > -1, b > -1

r1 = randg (a, 1)
r = r1 / (r1 + randg (b, 1))

Erlang (a, n)

r = a * randg (n)

chisq (df) для df > 0

r = 2 * randg (df / 2)

t (df) для 0 < df < inf (используйте randn, если df бесконечен)

r = randn () / sqrt (2 * randg (df / 2) / df)

F (n1, n2) для 0 < n1, 0 < n2

## r1 equals 1 if n1 is infinite
r1 = 2 * randg (n1 / 2) / n1
## r2 equals 1 if n2 is infinite
r2 = 2 * randg (n2 / 2) / n2
r = r1 / r2

отрицательные binomial (n, p) для n > 0, 0 < p <= 1

r = randp ((1 - p) / p * randg (n))

не-центральные chisq (df, L), для df >= 0 и L > 0

(используйте chisq, если L = 0)

r = randp (L / 2)
r(r > 0) = 2 * randg (r(r > 0))
r(df > 0) += 2 * randg (df(df > 0)/2)

Dirichlet (a1, … ak)

r = (randg (a1), …, randg (ak))
r = r / sum (r)

Класс возвращаемого значения может быть контролируется последующим "double" или "single" аргументом. Это единственные допустимые классы.

См. также: rand, randn, rande, randp.

: rng (seed) ¶

: rng (seed, "generator") ¶

: rng ("shuffle") ¶

: rng ("shuffle", "generator") ¶

: rng ("default") ¶

: s = rng () ¶

: rng (s) ¶

: s = rng (…) ¶

Устанавливает или запрашивает начальное значение генератора псевдослучайных чисел, используемого функциями rand и randn.

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

Необязательная строка generator указывает тип генератора псевдослучайных чисел. Ее значение может быть "twister", "v5uniform", или "v5normal". Ключевое слово "twister" описано ниже. "v5uniform" и "v5normal" относятся к более старым версиям Octave, которые использовали другой генератор псевдослучайных чисел.

Состояние или начальное значение генератора псевдослучайных чисел может быть сброшено на новое случайное значение с помощью ключевого слова "shuffle".

Генератор псевдослучайных чисел может быть сброшен до значений по умолчанию с помощью ключевого слова "default". Значения по умолчанию — использовать генератор Mersenne Twister с начальным значением 0.

Необязательное возвращаемое значение s содержит состояние генератора псевдослучайных чисел в момент вызова функции (то есть до возможных изменений в соответствии с входными аргументами). Оно закодировано как структура с тремя полями: "Type", "Seed", и "State". Генератор псевдослучайных чисел может быть восстановлен до состояния s с помощью rng (s). Это полезно, когда требуется идентичная последовательность псевдослучайных чисел для алгоритма.

По умолчанию, и с опцией "twister", псевдослучайные последовательности вычисляются с помощью генератора Mersenne Twister с периодом 2^{19937}-1 (См. M. Matsumoto и T. Nishimura, Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator, ACM Trans. on Modeling and Computer Simulation Vol. 8, No. 1, pp. 3–30, январь 1998, http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html). Не используйте для криптографии без безопасного хеширования нескольких возвращенных значений вместе, в противном случае состояние генератора может быть узнано после чтения 624 последовательных значений.

См. также: rand, randn.

Генераторы работают в новых или старых стилях вместе, смешивать их нельзя. Инициализация любого генератора с "state" или "seed" заставляет другие переключиться на тот же стиль для будущих вызовов.

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

rand ("state", [11, 22, 33]);
randn ("state", [44, 55, 66]);
u = rand (100, 1);
n = randn (100, 1);

и

rand ("state", [11, 22, 33]);
randn ("state", [44, 55, 66]);
u = zeros (100, 1);
n = zeros (100, 1);
for i = 1:100
  u(i) = rand ();
  n(i) = randn ();
end

дают эквивалентные результаты. Когда генераторы инициализируются в старом стиле с "seed" , только rand и randn независимы, потому что старые rande, randg и randp генераторы делают вызовы к rand и randn.

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

Если вызывается без аргументов, rand и randn возвращают один элемент случайной последовательности.

Оригинальные rand и randn функции используют Fortran-код из RANLIB, библиотеки Fortran-процедур для генерации случайных чисел, скомпилированной Barry W. Brown и James Lovato из Департамента биоматематики в Техасском университете, MD Anderson Cancer Center, Хьюстон, TX 77030.

: v = randperm (n) ¶

: v = randperm (n, m) ¶

Возвращает строку-вектор, содержащий случайную перестановку 1:n.

Если m задан, возвращает m уникальных элементов, взятых без повторений из 1:n.

Сложность — O(n) в памяти и O(m) во времени, если m < n/5, в этом случае используется также O(m) памяти. Случайность выполняется с помощью rand(). Все перестановки равновероятны.

См. также: perms.