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)

Если после "like" указана переменная var, выходной 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.

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

Если после "like" указана переменная var, выходной 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 должны быть указаны в порядке. В качестве заполнителя для измерений, которые не требуют дублирования, может использоваться 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 значительно упрощают создание векторов с равномерно или логарифмически распределёнными элементами. См. Диапазоны.

: y = linspace (start, end) ¶

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

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

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

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

Примечания по программированию: Для совместимости с MATLAB возвращается второй аргумент (end) при запросе одного значения (n = 1). Если n не является целым числом, используется floor (n) для округления количества элементов. Если n равно нулю или отрицательно, возвращается пустая матрица 1x0.

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

: y = logspace (a, b) ¶

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

: y = logspace (a, pi) ¶

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

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

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

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

Примечания по программированию: Для совместимости с MATLAB возвращается правая граница диапазона (10^b) при запросе одного значения (n = 1). Если n не является целым числом, используется floor (n) для округления количества элементов. Если n равно нулю или отрицательно, возвращается пустая матрица 1x0.

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

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

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

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

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

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

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

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

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

L. Montanet и др., Обзор свойств частиц, 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 из кафедры биоматематики в Университете Техаса, M.D. 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.