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 — матрица, то для целей индексации предполагается, что ее столбцы расположены друг над другом. Всегда возвращается вектор-строка.

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

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. В этом случае компонент измерения j с номером k повторяется R_j(k) раз.

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

Если x — матрица, необходимо указать как минимум две инструкции R_j.

Примечание: использование repelem с вектором x и вектором в качестве R_j эквивалентно декодированию длин серий (Run Length Decoding).

Примеры:

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 при запросе одного значения (n = 1) возвращается второй аргумент (end). Если 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 при запросе одного значения (n = 1) возвращается правая граница диапазона (10^b). Если 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)

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

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

Для вычисления псевдослучайной последовательности rand использует вихрь Мерсенна с периодом 2^{19937}-1 (см. M. Matsumoto и T. Nishimura, Вихрь Мерсенна: равномерный генератор псевдослучайных чисел, эквидистрибутивный в 623 измерениях, ACM Trans. on Modeling and Computer Simulation, т. 8, № 1, с. 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". Это единственные допустимые классы.

Литература: G. Marsaglia и W.W. Tsang, Метод зиггурат для генерации случайных величин, J. Statistical Software, т. 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". Это единственные допустимые классы.

Литература: G. Marsaglia и W.W. Tsang, Метод зиггурат для генерации случайных величин, J. Statistical Software, т. 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 и др., Numerical Recipes in C, Cambridge University Press, 1992.

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

W.H. Press и др., Numerical Recipes in C, Cambridge University Press, 1992.

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

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

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

E. Stadlober и др., исходный код WinRand, доступен по FTP, или H. Zechner, Efficient sampling from continuous and discrete unimodal distributions, докторская диссертация, 156 с., Технический университет Граца, Австрия, 1994.

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

L. Montanet и др., Review of Particle Properties, 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) for a > -1, b > 0

r = b * randg (a)

beta (a, b) for a > -1, b > -1

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

Erlang (a, n)

r = a * randg (n)

chisq (df) for df > 0

r = 2 * randg (df / 2)

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

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

F (n1, n2) for 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) for 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 (см. M. Matsumoto и T. Nishimura, Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator, ACM Trans. on Modeling and Computer Simulation, т. 8, № 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 из Department of Biomathematics при The University of Texas, M.D. Anderson Cancer Center, Houston, 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.