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.

: ones (n)

: ones (m, n)

: ones (m, n, k, …)

: ones ([m n …])

: ones (…, class)

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

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

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

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

val_matrix = val * ones (m, n)

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

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

См. также: zeros.

: zeros (n)

: zeros (m, n)

: zeros (m, n, k, …)

: zeros ([m n …])

: zeros (…, class)

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

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

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

Необязательный аргумент 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.

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

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

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

rand ("seed", val)

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

s = rand ("seed")

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

Состояние или начальное значение генератора может быть сброшено на новое случайное значение с использованием ключевого слова "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". Это единственные допустимые классы.

Ссылка: Дж. Марсальгия и В.В. Цанг, Метод Зиггурата для генерации случайных величин, 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". Это единственные допустимые классы.

Ссылка: Дж. Марсальгия и В.В. Цанг, Метод Зиггурата для генерации случайных величин, 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 используется прямой метод.

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

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

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

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

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

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

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

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

Л. Монтанет и др., Обзор свойств частиц, Physical Review D 50 p1284, 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.

Генераторы работают в новом или старом стиле вместе, смешивать их невозможно. Инициализация любого генератора "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-подпрограмм для генерации случайных чисел, скомпилированный Барри У. Брауном и Джеймсом Ловато из кафедры биоматематики в Техасском университете, онкологическом центре им. М.Д. Энджера, Хьюстон, Техас 77030.

: randperm (n)

: randperm (n, m)

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

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

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

См. также: perms.