16.3 Специальные матрицы для удобства использования

: eye (n) ¶

: eye (m, n) ¶

: eye ([m n]) ¶

: 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.

: repmat (A, m) ¶

: repmat (A, m, n) ¶

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

: repmat (A, [m n]) ¶

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

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

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

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

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

: 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 должны быть указаны в порядке следования. Для измерений, которые не требуют дублирования, можно использовать значение 1.

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 очень легко создавать векторы с равномерно или логарифмически распределёнными элементами. См. Диапазоны.

: linspace (start, end) ¶

: 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.

: logspace (a, b) ¶

: logspace (a, b, n) ¶

: 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.

: rand (n) ¶

: rand (m, n, …) ¶

: rand ([m n …]) ¶

: v = rand ("state") ¶

: rand ("state", v) ¶

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

: v = rand ("seed") ¶

: rand ("seed", v) ¶

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

: rand (…, "single") ¶

: rand (…, "double") ¶

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

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

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

v = rand ("state")

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

rand ("state", v)

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

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

Для вычисления псевдослучайной последовательности rand использует Mersenne Twister с периодом 2^{19937}-1 (См. М. Мацумото и Т. Нисимура, 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 последовательных значений.

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

rand ("seed", val)

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

s = rand ("seed")

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

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

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

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

: randi (imax) ¶

: randi (imax, n) ¶

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

: randi ([imin imax], …) ¶

: 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 (n) ¶

: randn (m, n, …) ¶

: randn ([m n …]) ¶

: v = randn ("state") ¶

: randn ("state", v) ¶

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

: v = randn ("seed") ¶

: randn ("seed", v) ¶

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

: randn (…, "single") ¶

: randn (…, "double") ¶

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

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

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

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

Ссылка: G. Marsaglia и W.W. Tsang, Метод Зиггурата для генерации случайных величин, J. Statistical Software, том 5, 2000, https://www.jstatsoft.org/v05/i08/

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

: rande (n) ¶

: rande (m, n, …) ¶

: rande ([m n …]) ¶

: v = rande ("state") ¶

: rande ("state", v) ¶

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

: v = rande ("seed") ¶

: rande ("seed", v) ¶

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

: rande (…, "single") ¶

: rande (…, "double") ¶

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

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

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

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

Ссылка: G. Marsaglia и W.W. Tsang, Метод Зиггурата для генерации случайных величин, J. Statistical Software, том 5, 2000, https://www.jstatsoft.org/v05/i08/

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

: randp (l, n) ¶

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

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

: v = randp ("state") ¶

: randp ("state", v) ¶

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

: v = randp ("seed") ¶

: randp ("seed", v) ¶

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

: randp (…, "single") ¶

: randp (…, "double") ¶

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

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

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

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

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

Для скалярного l > 12 используется метод отбраковки.

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

Для матричного l ≤ 10 используется метод обратного преобразования.

E. Stadlober и др., исходный код WinRand, доступный по FTP.

Для матричного l > 10 используется метод patchwork rejection.

E. Stadlober и др., исходный код WinRand, доступный по FTP, или H. Zechner, Эффективный отбор из непрерывных и дискретных унимодальных распределений, докторская диссертация, 156 стр., Технический университет Граца, Австрия, 1994.

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

L. Montanet и др., Обзор свойств частиц, Physical Review D 50 стр.1284, 1994.

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

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

: randg (a, n) ¶

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

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

: v = randg ("state") ¶

: randg ("state", v) ¶

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

: v = randg ("seed") ¶

: randg ("seed", v) ¶

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

: randg (…, "single") ¶

: randg (…, "double") ¶

Возвращает матрицу с 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". Значения по умолчанию — использование генератора Мерсенна-Твистера с начальным значением 0.

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

По умолчанию и с "twister" опцией, псевдослучайные последовательности вычисляются с помощью генератора Мерсенна-Твистера с периодом 2^{19937}-1 (См. М. Мацумото и Т. Нисимура, Генератор псевдослучайных чисел Мерсенна-Твистера: 623-мерно равнораспределённый генератор псевдослучайных чисел, ACM Trans. on Modeling and Computer Simulation Vol. 8, No. 1, стр. 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 из Департамента биоматематики в Университете Техаса, Центр онкологических исследований им. М.Д. Андерсона, Хьюстон, TX 77030.

: randperm (n) ¶

: randperm (n, m) ¶

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

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

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

См. также: perms.