<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( https://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) Jean-Philippe Chancelier and Bruno Pincon
 * Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 * Copyright (C) 2013 - Samuel GOUGEON : extension to hypermatrices
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 * Copyright (C) 2023 - Samuel GOUGEON
 *
 * This file is hereby licensed under the terms of the GNU GPL v2.0,
 * pursuant to article 5.3.4 of the CeCILL v.2.1.
 * This file was originally licensed under the terms of the CeCILL v2.1,
 * and continues to be available under such terms.
 * For more information, see the COPYING file which you should have received
 * along with this program.
 *
 -->
<!-- module: randlib -->
<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
          xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
          xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
          xml:lang="ru" xml:id="grand">
    <refnamediv>
        <refname>grand</refname>
        <refpurpose>Случайные числа</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Синтаксис</title>
        <synopsis>
            Y = grand(m, n, "bet", A, B)
            Y = grand(m, n, "bin", N, p)
            Y = grand(m, n, "nbn", N, p)
            Y = grand(m, n, "chi", Df)
            Y = grand(m, n, "nch", Df, Xnon)
            Y = grand(m, n, "exp", Av)
            Y = grand(m, n, "f", Dfn, Dfd)
            Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
            Y = grand(m, n, "gam", shape, rate)
            Y = grand(m, n, "nor", Av, Sd)
            Y = grand(m, n, "geom", p)
            Y = grand(m, n, "poi", mu)
            Y = grand(m, n, "def")
            Y = grand(m, n, "unf", Low, High)
            Y = grand(m, n, "uin", Low, High)
            Y = grand(m, n, "lgi")

            Y = grand(m, n, o, …, PDFname, …)
            Y = grand(X, PDFname, …)
        </synopsis>
        <para/>
        <synopsis>
            Y = grand(n, "mn", Mean, Cov)
            Y = grand(n, "markov", P, x0)
            Y = grand(n, "mul", nb, P)
            Y = grand(n, "prm", array)
        </synopsis>
        <para/>
        <synopsis>
            S = grand("getgen")
            grand("setgen", gen)

            S = grand("getsd")
            grand("setsd", S)

            grand("setcgn", G)
            S = grand("getcgn")

            S = grand("phr2sd", phrase)

            grand("initgn", I)
            grand("setall", s1, s2, s3, s4)
            grand("advnst", K)
        </synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Аргументы</title>
        <variablelist>
            <varlistentry>
                <term>m, n, o</term>
                <listitem>
                    <para>
                        целые числа, определяющие размеры матрицы/гиперматрицы <varname>Y</varname>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>X</term>
                <listitem>
                    <para>
                        матрица, у которой используются только её размеры
                        (скажем <varname>m</varname>  x  <varname>n</varname>).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>PDFname</term>
                <listitem>
                    <para>
                        Name of the chosen probability Density Function:
                        <literal>"def", "unf", "uin", "bet", "gam","exp", "nor", "geo", "poi",
                        "bin", "chi", "nbn", "nch", "f", "nf",  "lgi"</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>Y</term>
                <listitem>
                    <para>
                        матрица или гиперматрица со случайными элементами, зависящая от входных аргументов.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>S</term>
                <listitem>
                    <para>
                        выходное значение действия (строка или вещественный вектор-столбец).
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Описание</title>
        <para>
            Эта функция формирует случайные числа по различным законам
            распределения.
        </para>
        <para>
            Последовательности вызова
            <screen><![CDATA[
Y = grand(m, n, "bet", A, B)
Y = grand(m, n, "bin", N, p)
Y = grand(m, n, "nbn", N, p)
Y = grand(m, n, "chi", Df)
Y = grand(m, n, "nch", Df, Xnon)
Y = grand(m, n, "exp", Av)
Y = grand(m, n, "f", Dfn, Dfd)
Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
Y = grand(m, n, "gam", shape, rate)
Y = grand(m, n, "nor", Av, Sd)
Y = grand(m, n, "geom", p)
Y = grand(m, n, "poi", mu)
Y = grand(m, n, "def")
Y = grand(m, n, "unf", Low, High)
Y = grand(m, n, "uin", Low, High)
Y = grand(m, n, "lgi")
]]></screen>
            формируют матрицу размером <varname>m</varname>  x  <varname>n</varname>,
            элементы которой являются случайными числами.
        </para>
        <para>
            The syntax
            <screen><![CDATA[
Y = grand(m, n, o, …, PDFname, …)
]]></screen>
            produces a <varname>m</varname> x <varname>n</varname> x <varname>o</varname> x... hypermatrix
            with random entries.
        </para>
        <para>
            <screen><![CDATA[
Y = grand(X, PDFname, …)
]]></screen>
            produces a scalar, vector, matrix or hypermatrix of size <literal>size(X)</literal>,
            with random entries. <varname>X</varname> is used only as template to size the result.
        </para>
        <para>
            Последовательности вызова
        <screen><![CDATA[
Y = grand(n, "mn", Mean, Cov)
Y = grand(n, "markov", P, x0)
Y = grand(n, "mul", nb, P)
Y = grand(n, "prm", array)
]]></screen>
            produce an array with random entries, whose sizes depend on <varname>n</varname> and on
            the size of the parameters <varname>Mean</varname>, <varname>P</varname> or
            <varname>array</varname> (see below for details).
        </para>
        <para>
            Последовательности вызова
            <screen><![CDATA[
S = grand("getgen")
grand("setgen", gen)

S = grand("getsd")
grand("setsd", S)

grand("setcgn", G)
S = grand("getcgn")

grand("initgn", I)

grand("setall", s1, s2, s3, s4)

grand("advnst", K)
]]></screen>
            настраивают или запрашивают состояние имеющихся генераторов случайных чисел.
        </para>
    </refsection>
    <refsection>
        <title>Получение случайных чисел по заданному закону распределения</title>
        <variablelist>
            <varlistentry>
                <term>бета-распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "bet", A, B)</code> формирует случайные
                        реализации по бета-распределению с параметрами
                        <varname>A</varname> и <varname>B</varname>.  Плотность бета-распределения лежит
                        на интервале (0 &lt; x &lt; 1):
                    </para>
                    <para>
                        <latex>
                            \dfrac{x^{A-1}(1-x)^{B-1}}{\beta(A,B)}
                        </latex>
                    </para>
                    <para>
                        <varname>A</varname> и <varname>B</varname> должны быть вещественными числами
                        >10<superscript>-37</superscript>. С этой функцией связана
                        функция <link linkend="cdfbet">cdfbet</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>биномиальное распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "bin", N, p)</code> формирует случайные
                        реализации по биномиальному закону распределения с параметрами
                        <varname>N</varname> (положительное целое) и <varname>p</varname>
                        (вещественное число на интервале <literal>[0,1]</literal>): число
                        "успехов" в серии из <varname>N</varname> независимых случайных
                        (распределение Бернулли) экспериментов с вероятностью "успеха" в
                        каждом из них <varname>p</varname>.
                        С этой функцией связаны функции: <link linkend="binomial">binomial</link>,
                        <link linkend="cdfbin">cdfbin</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>отрицательное биномиальное распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "nbn", N, p)</code>  формирует случайные
                        реализации по отрицательному биномиальному распределению с
                        параметрами  <varname>N</varname> (положительное целое) и
                        <varname>p</varname> (вещественное число на интервале
                        <literal>(0,1)</literal>): число "неудач" случившихся до
                        <varname>N</varname>-го "успеха" в последовательности испытаний с
                        вероятностью "успеха" <varname>p</varname>. С этой функцией
                        связана функция <link linkend="cdfnbn">cdfnbn</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>хи-квадрат распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "chi", Df)</code> формирует случайные
                        реализации по распределению хи-квадрат с <varname>Df</varname>
                        степенями свободы. Число степеней свободы должно быть
                        вещественным, строго больше нуля.
                        С этой функцией связана функция: <link linkend="cdfchi">cdfchi</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>нецентральное хи-квадрат распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "nch", Df, Xnonc)</code>  формирует случайные
                        реализации по нецентральному хи-квадрат распределению с
                        <varname>Df</varname>  степенями свободы
                        (вещественное значение ≥ <literal>1.0</literal>) и параметром нецентральности
                        <varname>Xnonc</varname> (вещественное число, больше либо равно
                        нулю). С этой функцией связана функция: <link linkend="cdfchn">cdfchn</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>экспоненциальное распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "exp", Av)</code> формирует случайные
                        реализации по экспоненциальному распределению с математическим
                        ожиданием <varname>Av</varname> (вещественное значение, строго больше нуля).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>F-распределение (отношение дисперсий, распределение Фишера)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "f", Dfn, Dfd)</code> формирует случайные
                        реализации по F-распределению (отношение дисперсий, распределение
                        Фишера) с <varname>Dfn</varname> (вещественное значение, строго больше нуля)
                        в числителе и <varname>Dfd</varname> степенями
                        свободы (вещественное значение, строго больше нуля) в знаменателе.
                        С этой функцией связана функция: <link linkend="cdff">cdff</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>нецентральное F-распределение (отношение дисперсий)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "nf", Dfn, Dfd, Xnonc)</code> формирует
                        случайные реализации по нецентральному F-распределению (отношению
                        дисперсий) с <varname>Dfn</varname> степенями свободы (вещественное значение,
                        больше либо равно <literal>1</literal>)  в
                        числителе, и <varname>Dfd</varname> степенями свободы (вещественное значение,
                        строго больше нуля) в знаменателе и
                        параметром нецентральности <varname>Xnonc</varname> (вещественное число,
                        больше либо равно нулю). С этой функцией связана функция:
                        <link linkend="cdffnc">cdffnc</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>гамма-распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "gam", shape, rate)</code> формирует
                        случайные реализации по гамма-распределению с параметрами
                        <varname>shape</varname> (вещественное значение, строго
                        больше нуля) и <varname>rate</varname> (вещественное
                        значение, строго больше нуля) (<literal>real</literal>
                        &gt; <literal>0</literal>). Плотность гамма-распределения
                        равна:
                    </para>
                    <para>
                        <latex>
                            \dfrac{ \textrm{rate}^{\textrm{shape}} x^{\textrm{shape}-1} e^{-x.\textrm{rate}}}{\gamma(\textrm{shape}) }
                        </latex>
                    </para>
                    <para>
                        С этой функцией связаны: <link linkend="gamma">gamma</link>,
                        <link linkend="cdfgam">cdfgam</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>распределение Гаусса-Лапласа (нормальное)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "nor", Av, Sd)</code> формирует случайные
                        реализации по нормальному распределению с математическим ожиданием
                        <varname>Av</varname>  (вещественное значение), среднеквадратичным
                        отклонением  <varname>Sd</varname> (вещественное значение, больше
                        либо равно нулю). С этой функцией связана: <link linkend="cdfnor">cdfnor</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>многомерное гауссовское (многомерное нормальное) распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(n, "mn", Mean, Cov)</code> формирует случайные
                        реализации по многомерному гауссовскому распределению; среднее
                        значение <varname>Mean</varname> должно быть вектор-столбцом размером
                        <literal>m</literal> x <literal>1</literal>, а
                        ковариация <varname>Cov</varname> должна быть симметричной положительно
                        определённой матрицей размером <literal>m</literal>
                        x <literal>m</literal> (тогда <varname>Y</varname> будет матрицей размером
                        <literal>m</literal> x <literal>n</literal>).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>геометрическое распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "geom", p)</code>  формирует случайные
                        реализации по геометрическому распределению с параметром
                        <varname>p</varname>: количество независимых экспериментов (с вероятностью
                        "успеха" <varname>p</varname>) до тех пор пока не
                        будет "успех". Вероятность  <varname>p</varname> должна быть в интервале
                        <literal>[1.3e-307, 1]</literal>).
                    </para>
                    <para>
                        <varname>Y</varname>  состоит из положительных целочисленных вещественных
                        чисел, которые означают "число экспериментов, проведённых до первого
                        успешного".
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>цепь Маркова</term>
                <listitem>
                    <para>
                        <code>Y = grand(n, "markov", P, x0)</code> формирует
                        <varname>n</varname> последовательных состояний цепи Маркова,
                        описанных матрицей переходных состояний <varname>P</varname>.
                        Сумма элементов в каждой строке в <varname>P</varname> равна
                        <literal>1</literal>. Исходное состояние задаётся через
                        <varname>x0</varname>. Если <varname>x0</varname> является
                        матрицей размером <literal>m=size(x0,"*")</literal>,
                        то <varname>Y</varname> является матрицей размером
                        <varname>m</varname> x <varname>n</varname>.  <literal>Y(i,:)</literal>
                        является выборочной траекторией, полученной из исходного состояния
                        <literal>x0(i)</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>мультиномиальное (полиномиальное) распределение</term>
                <listitem>
                    <para>
                        <code>Y = grand(n, "mul", nb, P)</code>  формирует <varname>n</varname>
                        случайных реализаций по мультиномиальному распределению :
                        совокупность <varname>nb</varname> событий в <literal>m</literal> категориях
                        (положить <varname>nb</varname> "шаров" в <literal>m</literal> "ящиков").
                        <literal>P(i)</literal> является вероятностью того, что событие будет
                        классифицировано в категории <literal>i</literal>.
                        Вектор-столбец вероятностей <varname>P</varname> размером
                        <literal>m-1</literal> (вероятность категории <literal>m</literal> равна
                        <literal>1-sum(P)</literal>). <varname>Y</varname>  имеет размер
                        <literal>m</literal> x <literal>n</literal>.
                        Каждый столбец <literal>Y(:,j)</literal> является случайной реализацией по
                        мультиномиальному распределению, а <literal>Y(i,j)</literal> является
                        количеством событий, попавших в категорию <literal>i</literal> (для
                        <literal>j</literal>-того наблюдения) (<literal>sum(Y(:,j)) = nb</literal>).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>распределение Пуассона</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "poi", mu)</code> формирует случайные
                        реализации по распределению Пуассона с математическим ожиданием
                        <varname>mu</varname> (вещественное значение, больше либо равно
                        нулю). С этой функцией связана: <link linkend="cdfpoi">cdfpoi</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>случайные перестановки</term>
                <listitem>
                    <para>
                        <code>Y = grand(n, "prm", array)</code> generates
                        <varname>n</varname> random permutations of the <varname>array</varname>
                        elements.
                        <varname>array</varname> can be a vector, matrix or hypermatrix of real or
                        complex numbers, of integers, booleans, polynomials or strings; full or sparse.
                        <itemizedlist>
                            <listitem>
                                If <varname>array</varname> is a <literal>1 x m</literal> row vector,
                                <varname>Y</varname> is a <literal>n x m</literal> matrix.
                            </listitem>
                            <listitem>
                                If <varname>array</varname> is a <literal>m x 1</literal> column vector,
                                <varname>Y</varname> is a <literal>m x n</literal> matrix.
                            </listitem>
                            <listitem>
                                If <varname>array</varname> is a <literal>m x p</literal> matrix,
                                <varname>Y</varname> is a <literal>m x p x n</literal> hypermatrix.
                            </listitem>
                            <listitem>
                                If <varname>array</varname> is a <literal>m x p x q…</literal> hypermatrix,
                                <varname>Y</varname> is a <literal>m x p x q… x n</literal> hypermatrix.
                            </listitem>
                        </itemizedlist>
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>непрерывное равномерное распределение (def)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "def")</code> формирует случайные реализации по
                        равномерному распределению на интервале
                        <literal>[0,1)</literal> (<literal>1</literal>  в интервал не входит).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>непрерывное равномерное распределение (unf)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "unf", Low, High)</code> формирует случайные
                        вещественные значения равномерно распределённые на интервале
                        <literal>[Low, High)</literal> (<varname>High</varname> в интервал не входит).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>дискретное равномерное распределение (uin)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "uin", Low, High)</code> формирует случайные
                        целые числа, равномерно распределённые между значениями
                        <varname>Low</varname> и <varname>High</varname> (включительно).
                        <varname>High</varname> и <varname>Low</varname> должны быть
                        такими целыми числами, что <literal>(High-Low+1) &lt; 2.147483561e9</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>равномерное распределение (lgi)</term>
                <listitem>
                    <para>
                        <code>Y = grand(m, n, "lgi")</code> возвращает базовый выход текущего
                        генератора: случайные целые числа по равномерному распределению на интервалах:
                    </para>
                    <itemizedlist>
                        <listitem>
                            <para>
                                <literal>[0, 2^32 - 1]</literal>  для mt и kiss;
                            </para>
                        </listitem>
                        <listitem>
                            <para>
                                <literal>[0, 2^31 - 87]</literal> для clcg2;
                            </para>
                        </listitem>
                        <listitem>
                            <para>
                                <literal>[0, 2^31 - 2]</literal> для clcg4;
                            </para>
                        </listitem>
                        <listitem>
                            <para>
                                <literal>[0, 2^31 - 1]</literal> для urand.
                            </para>
                        </listitem>
                    </itemizedlist>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Установка/получение текущего генератора и его состояния</title>
        <para>
            У пользователя есть возможность выбирать между основными генераторами (которые
            дают случайные целые числа по распределению <literal>"lgi"</literal>, другие
            получаются из него).
        </para>
        <variablelist>
            <varlistentry>
                <term>mt</term>
                <listitem>
                    <para>
                        Вихрь Марсенна (Mersenne-Twister), разработанный японскими учёными
                        Макото Мацумото и Такудзи Нисимурой, период около
                        <literal>2^19937</literal>, состояние задаётся массивом из
                        <literal>624</literal> целых чисел (плюс индекс на этот массив).
                        Этот генератор используется по умолчанию.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>kiss</term>
                <listitem>
                    <para>
                        "Keep It Simple Stupid" ("придерживайся простоты"), разработанный
                        Джорджем Марсальи, период около <literal>2^123</literal>,
                        состояние задаётся четырьмя целыми числами.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>clcg2</term>
                <listitem>
                    <para>
                        Комбинация двух линейных конгруэнтных генераторов П. Л'Экюйера (P. L'Ecuyer)
                        с периодом около <literal>2^61</literal>, состояние
                        задаётся двумя целыми числами.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>clcg4</term>
                <listitem>
                    <para>
                        Комбинация четырёх линейных конгруэнтных генераторов П. Л'Экюйера
                        (P. L'Ecuyer)  с периодом около <literal>2^121</literal>, состояние
                        задаётся четырьмя целыми числами. Этот генератор разделён на разные
                        виртуальные (неперекрывающиеся) генераторы (<literal>101</literal>
                        генератор), которые могут быть полезными для разных задач (см.
                        "Опции, специфичные для "clcg4"" и "Тестовый пример для "clcg4"").
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>urand</term>
                <listitem>
                    <para>
                        Генератор, используемый функцией Scilab'а <link linkend="rand">rand</link>,
                        состояние задаётся одним целым числом,
                        период <literal>2^31</literal>. Этот генератор основан на "Urand,
                        A Universal Random Number Generator" By, Michael A. Malcolm, Cleve
                        B. Moler, Stan-Cs-73-334, January 1973, Computer Science
                        Department, School Of Humanities And Sciences, Stanford
                        University. Это самый быстрый генератор из данного списка, однако
                        его статистические качества менее удовлетворительны по сравнению с
                        другими генераторами.
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
        <para>
            Различные действия, общие для всех генераторов:
        </para>
        <variablelist>
            <varlistentry>
                <term>действие = "getgen"</term>
                <listitem>
                    <para>
                        <code>S = grand("getgen")</code> возвращает текущий основной
                        генератор. В данном случае <varname>S</varname> является одной
                        строкой из <literal>"mt"</literal>, <literal>"kiss"</literal>,
                        <literal>"clcg2"</literal>, <literal>"clcg4"</literal>,
                        <literal>"urand"</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "setgen"</term>
                <listitem>
                    <para>
                        <code>grand("setgen",gen)</code> устанавливает текущий основной
                        генератор. В данном случае <varname>gen</varname> может быть одной
                        строкой из <literal>"mt"</literal>, <literal>"kiss"</literal>,
                        <literal>"clcg2"</literal>, <literal>"clcg4"</literal>,
                        <literal>"urand"</literal>.
                        Заметьте, что этот вызов возвращает новый текущий генератор, т.е.
                        <varname>gen</varname>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "getsd"</term>
                <listitem>
                    <para>
                        <code>S = grand("getsd")</code> получает текущее состояние
                        (текущие семена) текущего основного генератора.
                        <varname>S</varname> задаётся в виде вектор-столбца (целочисленных
                        значений) с количеством элементов <literal>625</literal> для
                        <literal>"mt"</literal> (первое значение является индексом в
                        интервале <literal>[1,624]</literal>),  <literal>4</literal> для
                        <literal>"kiss"</literal>,  <literal>2</literal> для
                        <literal>"clcg2"</literal>, <literal>4</literal> для
                        <literal>"clcg4"</literal> (для последнего вы получите текущее
                        состояние текущего виртуального генератора) и
                        <literal>1</literal> для <literal>"urand"</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "setsd"</term>
                <listitem>
                    <para>
                        <code>grand("setsd", S)</code> и
                        <code>grand("setsd", s1[, s2, s3, s4])</code>  устанавливают состояние
                        текущего основного генератора (несколько семян):
                    </para>
                    <variablelist>
                        <varlistentry>
                            <term>для mt</term>
                            <listitem>
                                <para>
                                    <varname>S</varname>является вектор-столбцом целых чисел с
                                    количеством элементов <literal>625</literal>
                                    (значение первого элемента вектора является индексом и должно
                                    быть в интервале <literal>[1,624]</literal>, а
                                    значения остальных <literal>624</literal> элементов должны
                                    лежать в интервале <literal>[0,2^32)</literal>), но не должны
                                    быть все нулями); более простая инициализация может быть
                                    сделана с помощью только одного целого числа <varname>s1</varname>
                                    (<varname>s1</varname> должно
                                    лежать в интервале <literal>[0,2^32)</literal>);
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>для kiss</term>
                            <listitem>
                                <para>
                                    должны быть указаны четыре целых числа <varname>s1</varname>,
                                    <varname>s2</varname>, <varname>s3</varname>, <varname>s4</varname>
                                    на интервале <literal>[0,2^32)</literal>;
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>для clcg2</term>
                            <listitem>
                                <para>
                                    должны быть указаны два целых числа <varname>s1</varname> на
                                    интервале <literal>[1,2^31-86]</literal> и <varname>s2</varname>
                                    на интервале  <literal>[1,2^31-250]</literal>;
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>для clcg4</term>
                            <listitem>
                                <para>
                                    требуются четыре целых числа <varname>s1</varname> на
                                    интервале <literal>[1,2^31-2]</literal>, <varname>s2</varname>
                                    на интервале <literal>[1,2^31-106]</literal>, <varname>s3</varname>
                                    на интервале <literal>[1,2^31-226]</literal>, <varname>s4</varname>
                                    на интервале
                                    <literal>[1,2^31-326]</literal>;
                                </para>
                                <para>
                                    <caution>
                                        Предостережение: с clcg4 вы устанавливаете семена текущего
                                        виртуального генератора, но вы можете потерять синхронизацию
                                        между ним и другими виртуальными генераторами (т.е. не
                                        гарантируется, что генерируемая последовательность не
                                        перекрывается с генерируемой последовательностью другого
                                        виртуального генератора) ≥ вместо этого используйте опцию "setall".
                                    </caution>
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>для urand</term>
                            <listitem>
                                <para>
                                    должно быть указано одно целое число <varname>s1</varname>
                                    на интервале <literal>[0,2^31)</literal>.
                                </para>
                            </listitem>
                        </varlistentry>
                    </variablelist>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "phr2sd"</term>
                <listitem>
                    <para>
                        для заданной фразы <varname>phrase</varname> (символьной строки)
                        <code>Sd = grand("phr2sd", phrase)</code> генерирует вектор
                        <varname>Sd</varname> размером 1 x 2, который может
                        использоваться в качестве семени для изменения состояния
                        основного генератора (изначально подходил для clcg2).
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Опции, специфичные для clcg4</title>
        <para>
            Генератор clcg4 может использоваться как и остальные генераторы, но у него
            есть то преимущество, что он может быть разделён на несколько
            (<literal>101</literal>) виртуальных генераторов последовательности которых не
            перекрываются (когда вы используете классический генератор, то вы можете
            изменить исходное состояние (семена) для того, чтобы получить другую
            последовательность, но не гарантируется, что вы получите абсолютно другую
            последовательность). Каждому виртуальному генератору соответствует
            последовательность из  <literal>2^72</literal> значений, которая далее делится
            на <literal>V=2^31</literal> сегментов (или блоков) длиной
            <literal>W=2^41</literal>. Есть возможность вернуть заданный виртуальный
            генератор в начало последовательности или в начало текущего сегмента или
            перейти прямо к следующему сегменту. Можно также изменить исходное состояние
            (семя) генератора <literal>0</literal> с помощью опции
            <literal>"setall"</literal>, которая затем изменит также исходное состояние
            остальных виртуальных генераторов так, чтобы получить синхронизацию, т.е. в
            функции нескольких исходных состояний генератора <literal>0</literal> исходные
            состояния генераторов <literal>1...100</literal> пересчитываются так, чтобы
            получить <literal>101</literal> неперекрывающуюся последовательность.
        </para>
        <variablelist>
            <varlistentry>
                <term>действие = "setcgn"</term>
                <listitem>
                    <para>
                        <code>grand("setcgn",G)</code> устанавливает текущий виртуальный
                        генератор для clcg4 (когда clcg4 установлен, то есть используется
                        виртуальный генератор (clcg4) номер  <varname>G</varname>);
                        виртуальные генераторы clcg4 пронумерованы <literal>0, 1, ..., 100</literal>
                        (а поэтому <varname>G</varname> должно быть целым
                        числом на интервале <literal>[0,100]</literal>); по умолчанию
                        текущим виртуальным генератором является <literal>0</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "getcgn"</term>
                <listitem>
                    <para>
                        <code>S = grand("getcgn")</code> возвращает номер текущего
                        виртуального генератора clcg4.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "initgn"</term>
                <listitem>
                    <para>
                        <code>grand("initgn", I)</code> заново инициализирует состояние
                        текущего виртуального генератора.
                    </para>
                    <variablelist>
                        <varlistentry>
                            <term>I = -1</term>
                            <listitem>
                                <para>
                                    устанавливает состояние в его исходное семя.
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>I = 0</term>
                            <listitem>
                                <para>
                                    устанавливает состояние в его последнее (предыдущее) семя
                                    (т. е. в начало текущего сегмента).
                                </para>
                            </listitem>
                        </varlistentry>
                        <varlistentry>
                            <term>I = 1</term>
                            <listitem>
                                <para>
                                    устанавливает состояние на <literal>W</literal> значений нового
                                    семени от его последнего семени (т.е. в начало следующего сегмента)
                                    и сбрасывает параметры текущего сегмента.
                                </para>
                            </listitem>
                        </varlistentry>
                    </variablelist>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "setall"</term>
                <listitem>
                    <para>
                        <code>grand("setall", s1, s2, s3, s4)</code> устанавливает
                        исходное состояние генератора <literal>0</literal> в
                        <varname>s1</varname>, <varname>s2</varname>,
                        <varname>s3</varname>, <varname>s4</varname>. Исходные семена
                        других генераторов устанавливаются так, чтобы была синхронизация.
                        Об ограничениях на <varname>s1</varname>, <varname>s2</varname>,
                        <varname>s3</varname>, <varname>s4</varname> смотри действие
                        <literal>"setsd"</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>действие = "advnst"</term>
                <listitem>
                    <para>
                        <code>grand("advnst", K)</code>  перемещает состояние текущего
                        генератора вперёд на <literal>2^K</literal> значений и сбрасывает
                        исходное семя в это значение.
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Примеры</title>
        <para>
            В следующем примере мы генерируем случайные числа по различным законам
            распределения и строим соответствующие гистограммы.
        </para>
        <programlisting role="example"><![CDATA[
// Возвращает матрицу размером 400 x 800 случайных чисел
// по нормальному распределению, с матожиданием 0 и дисперсией 1.
R = grand(400,800,"nor",0,1);
scf();
histplot(10,R);
xtitle("Случайные числа по нормальному закону распределения из функции grand","X","Частота");
]]></programlisting>
        <scilab:image localized="true">
            R = grand(400,800,"nor",0,1);
            histplot(10,R);
            xtitle("Случайные числа по нормальному закону распределения из функции grand","X","Частота");
        </scilab:image>

        <programlisting role="example"><![CDATA[
// Возвращает матрицу размером 400 x 800 случайных чисел
// с равномерным распределением в [0,1).
R = grand(400,800,"def");
scf();
histplot(10,R);
xtitle("Случайные числа с равномерным распределением из функции grand","X","Частота");
 ]]></programlisting>
        <scilab:image localized="true">
            R = grand(400,800,"def");
            histplot(10,R);
            xtitle("Случайные числа с равномерным распределением из функции grand","X","Частота");
        </scilab:image>

        <programlisting role="example"><![CDATA[
// Возвращает матрицу размером 400 x 800 случайных чисел
// по распределению Пуассона и матожиданием, равным 5.
R = grand(400,800,"poi",5);
scf();
histplot(10,R);
xtitle("Случайные числа по закону распределения Пуассона из grand","X","Частота");
 ]]></programlisting>
        <scilab:image localized="true">
            R = grand(400,800,"poi",5);
            histplot(10,R);
            xtitle("Случайные числа по закону распределения Пуассона из grand","X","Частота");
        </scilab:image>

        <para>
            В следующем примере мы генерируем случайные числа по экспоненциальному распределению,
            а затем сравниваем эмпирическое распределение с теоретическим.
        </para>
        <programlisting role="example"><![CDATA[
lambda=1.6;
N=100000;
X = grand(1,N,"exp",lambda);
scf();
classes = linspace(0,12,25);
histplot(classes,X);
x=linspace(0,12,25);
y = (1/lambda)*exp(-(1/lambda)*x);
plot(x,y,"ro-");
legend(["Эксперимент" "Теория"]);
xtitle("Случайные числа по экспоненциальному закону распределения из функции grand","X","Частота");
 ]]></programlisting>
        <scilab:image localized="true">
            lambda=1.6;
            N=100000;
            X = grand(1,N,"exp",lambda);
            classes = linspace(0,12,25);
            histplot(classes,X)
            x=linspace(0,12,25);
            y = (1/lambda)*exp(-(1/lambda)*x);
            plot(x,y,"ro-");
            legend(["Эксперимент" "Теория"]);
            xtitle("Случайные числа по экспоненциальному закону распределения из функции grand","X","Частота");
        </scilab:image>
        <para>
            В следующем примере мы генерируем случайные числа по закону гамма-
            распределения, а затем сравниваем эмпирическое распределение с теоретическим.
        </para>
        <programlisting role="example"><![CDATA[
N=10000;
A=10;
B=4;
R=grand(1,N,"gam",A,B);
XS=gsort(R,"g","i")';
PS=(1:N)'/N;
P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
scf();
plot(XS,PS,"b-"); // Эмпирическое распределение
plot(XS,P,"r-"); // Теоретическое распределение
legend(["Эксперимент" "Теория"]);
xtitle("Интегральная функция распределения случайных чисел по закону гамма-распределения","X","F");
]]></programlisting>
        <scilab:image localized="true">
            N=10000;
            A=10;
            B=4;
            R=grand(1,N,"gam",A,B);
            XS=gsort(R,"g","i")';
            PS=(1:N)'/N;
            P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
            scf();
            plot(XS,PS,"b-"); // Эмпирическое распределение
            plot(XS,P,"r-"); // Теоретическое распределение
            legend(["Эксперимент" "Теория"]);
            xtitle("Интегральная функция распределения случайных чисел по закону гамма-распределения","X","F");
        </scilab:image>
        <para>
            В следующем примере мы генерируем 10 случайных целых чисел в интервале
            <literal>[1,365]</literal>.
        </para>
        <programlisting role="example"><![CDATA[
grand(10,1,"uin",1,365)
 ]]></programlisting>
        <para>
            В следующем примере мы генерируем <literal>12</literal> перестановок набора
            чисел <literal>[1, 2, ..., 7]</literal>. Эти <literal>12</literal>
            перестановок сохраняются столбец за столбцом.
        </para>
        <programlisting role="example"><![CDATA[
grand(12,"prm",(1:7)')
 ]]></programlisting>
        <para>
            В следующем примере мы формируем гиперматрицу случайных чисел с "нормальным"
            распределением размерами
            <varname>10</varname> x <varname>10</varname> x <varname>10</varname>
            и строим гистограммы. Показываются первый и последний слои.
        </para>
        <programlisting role="example"><![CDATA[
// Возвращает гиперматрицу случайных чисел с нормальным
// распределением, мат. ожидание 0 и среднеквадратичное отклонение 1,
// размерами 10 x 10 x 10.
// Показаны только первый и последний слои.
R = grand(10,10,10,"nor",0,1);

subplot(1,2,1)
bar3d(R(:,:,1));
xtitle("Слой 1");
subplot(1,2,2)
bar3d(R(:,:,10));
xtitle("Слой 10");
 ]]></programlisting>
        <scilab:image localized="true">
            R = grand(10,10,10,"nor",0,1);
            subplot(1,2,1)
            bar3d(R(:,:,1));
            xtitle("Слой 1");
            subplot(1,2,2)
            bar3d(R(:,:,10));
            xtitle("Слой 10");
        </scilab:image>
    </refsection>
    <refsection>
        <title>Получение более или менее предсказуемых чисел</title>
        <para>
            Генераторы псевдослучайных чисел основаны на детерминированных
            последовательностях. Для того, чтобы получить повторное воспроизведение
            моделирования, исходное семя генератора равно такой константе, что
            последовательность будет оставаться одной и той же от одной сессии к другой.
            Следовательно, по умолчанию, первые числа, производимые функцией
            <function>grand</function>, всегда одни и те же.
        </para>
        <para>
            В некоторых ситуациях мы можем захотеть инициализировать семя генератора для
            того, чтобы получить менее предсказуемые числа. В этом случае мы можем
            инициализировать семя с помощью выходного значения функции
            <function>getdate</function>:
        </para>
        <programlisting role="example"><![CDATA[
n = getdate("s");
grand("setsd", n)
    ]]></programlisting>
    </refsection>
    <refsection>
        <title>Тестовый пример для clcg4</title>
        <para>
            Пример необходимости возможности разделения clcg4 следующий. Сравниваются два
            статистических метода по данным разного размера. Первый является
            бутстреп-методом и считается точным при использовании меньшего количества данных,
            чем второй метод, который использует только грубую силу. Для первого метода будет
            генерироваться набор данных размером равномерно распределённым между
            <literal>25</literal> и <literal>50</literal>. Затем будет генерироваться и
            анализироваться набор данных определённого размера. Второй метод будет
            выбирать размер набора данных между <literal>100</literal> и
            <literal>200</literal>, генерировать данные и анализировать их. Этот процесс
            будет повторяться <literal>1000</literal> раз. Для уменьшения разброса мы
            хотим, чтобы числа, используемые в этих двух методах были одинаковыми для
            каждого из <literal>1000</literal> сравнений. Но второй метод будет
            использовать больше случайных чисел, чем первый метод и без этого пакета
            синхронизация была бы затруднительна. С clcg4 это легко. Используем генератор
            <literal>0</literal> для получения размера выборки для метода один и генератор
            <literal>1</literal> для получения данных. Затем сбрасываем состояние  к
            начальному текущего блока и делаем то же самое для второго метода. Это
            гарантирует, что исходные данные для второго метода те же, что использовались
            в первом методе. Когда они оба закончатся, передвигаем вперёд блок для обоих
            генераторов.
        </para>
    </refsection>
    <refsection role="see also">
        <title>Смотрите также</title>
        <simplelist type="inline">
            <member>
                <link linkend="rand">rand</link>
            </member>
            <member>
                <link linkend="sprand">sprand</link>
            </member>
            <member>
                <link linkend="ssrand">ssrand</link>
            </member>
            <member>
                <link linkend="randpencil">randpencil</link>
            </member>
            <member>
                <link linkend="genmarkov">genmarkov</link>
            </member>
        </simplelist>
    </refsection>
</refentry>
