Как написать рандомайзер на паскале

Рандом в Паскале — это опция с помощью, которой программа может генерировать и получать для своей деятельности случайные числа. Чаще всего данную функцию используют в Паскале для работы с массивами. При этом диапазон заданного числа можно отрегулировать, самостоятельно посчитав разницу между диапазоном и обязательно добавив к результату 1.

Также в Pascal используют randomize, зачастую происходит это совместно с рандом. Так как отдельно опция randomize будет давать постоянно одинаковое число. Данный процесс позволяет нам провести инициализацию датчика.

Цикл for уместно использовать, когда будете заполнять массив. Так как мы уже знаем, сколько в нем элементов. Индексом элементов может стать счетчик цикла.

В Паскале используют вообще два типа массивов одномерные и двумерные. Одномерные массивы, о которых и пойдет речь несут, в себе информацию о разных элементах, которые будут иметь отношение к одному типу данных. Random Pascal необходим, чтобы не приходилось постоянно задавать значение массиву.

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

Работа генератора случайных чисел

Для того чтобы рандом в Паскале работал программисту необходимо задать промежуток из чисел, который будет актуальным при его работе. Перед началом работы программы, необходимо описать программе функцию рандом. Random и randomize в Паскале всегда работают в совокупности, как и было это указано выше в статье. Randomize в описание вставляют сразу после begin, делают это для того, чтобы упростить считываемость кодов.

Теперь перейдем сразу к самому интересному и разберемся, как запустить генератор случайных чисел в Паскале. Примеры прописанных программ можно просмотреть в интернете и потренироваться на задачах. Нужно быть внимательным и не забыть описать randomize для генерации поистине случайного числа.

Простой пример:

var
n, i, x: integer;   
begin
randomize;  
n := random (7) + 5;  
for i := 1 to n do
begin
x := random (100) — 50;
write (x:5) end;  
readln
end.

Иначе просто от функции рандом число, полученное по итогу, будет совсем неслучайным. Часто новички прописывают команду randomize при каждой вставке random, а это является грубейшей ошибкой.

Задавать эту опцию необходимо 1 раз в самом начале написания программы.

С одномерными массивами производят сортировку. Есть три способа, как это выполнить. Рассмотрим каждый детально.

«Пузырек»:

• Работает это по принципу – массив это вода, а его элементы пузырьки. Чем легче элемент, тем быстрее поднимается на поверхность.
• Парные примерно одинаковые по размеру элементы сравниваются между собой. Тот который больше производит замену над напарником.
• Так происходит в работе всего цикла, до его конца.

Метод выбора – следующий способ:

• Элементы выстраиваются по принципу от большего к меньшему.
• Далее минимальный элемент становиться на второе место после самого большого.
• Так происходит и дальше с оставшимися элементами.

Последний способ – быстрая сортировка:

• Находим средний элемент массива;
• Добавляем к L и находим первый элемент (он должен быть больше).
• Делаем R меньше и находим последний элемент ( он должен быть меньше).
• Если пункт 2 меньше или равен пункту 3, то меняем их местами.

Завершение работы с рандом в Паскале

В программе Pascal есть такое понятие числа фибоначчи, подразумевает это ряд последовательности цифр, по принципу следующее число состоит из суммы двух чисел перед ним. Формулу фибоначчи необходимо применять в цикле for, в самом начале, когда прописываем элементы массива.

Функция рандом помогает нам сгенерировать ряд чисел в диапазоне от 0 до 1. Для того чтобы задать свой диапазон, нужно в скобках, сразу после 0 прописать эти значения цифр. Без данной опции у вас наверняка не выйдет сгенерировать число случайным способом, и точно так же каждое последующее. Потому программа Паскаль не может работать без возможности генерации незапланированных чисел.

Объявление массива несет в себе некий синтаксис. Это помогает определить число элементов в массиве. Для многомерного массива может быть использована только начальная размерность.

Получить многомерный массив можно с помощью определенной последовательности константных выражений, которые указаны в программе в квадратных скобках.

Для того чтобы работать с программой Pascal, нужно понимать значение и принцип работы рандом. На первый взгляд, выучить это достаточно легко. Но поскольку случайные числа это очень важно, нужно быть внимательным, дабы не допустить ошибку в написании программы. Генерация чисел очень увлекательна и непредсказуема, в правильно написанной программе вы никогда не сможете предугадать результат.

│




Deutsch (de) │
English (en) │



suomi (fi) │
français (fr) │







polski (pl) │


русский (ru) │

Random numbers are important resources for a diverse field of applications, including scientific analysis, technology, medicine, economy, education, game development and visualization. They play a key role in numeric simulation.

Algorithm-generated random numbers are pseudo-random numbers. They belong to a (large) set of repeating numbers, whose sequence is impossible or at least difficult to predict. Unlike Delphi, that uses a linear congruential generator.(See Delphi compatible LCG Random), Free Pascal uses a MersenneTwister algorithm for its standard random function as defined in RTL. Before its first use, FPC’s random number generator has to be initialized with a single call of the randomize function, which sets the seed of the generator. Preferably this is done in the launch phase of the program.

Alternatively, on Unix- and Linux-based systems, the virtual devices /dev/random and /dev/urandom are available. They generate (pseudo) random numbers based on hardware.

A third option is to use random numbers from external sources, either from specialised hardware devices or from public sources, e.g. based on radioactive decay data.

Uniform Distribution

The continuous uniform distribution (also referred to as rectangular distribution) represents a family of symmetric probability distributions. Here, for each member of the family all intervals of the same length on the distribution’s support are equally probable.

The standard RTL function random generates random numbers that fulfill a uniform distribution. If called without parameter random delivers a floating point pseudorandom number in the interval [0, 1), i.e. 0 <= result < 1. if random is called with a longint argument L it delivers a longint random in the interval [0, L).

Normal (Gaussian) Distribution

One of the more common algorithms to produce normally distributed random numbers from uniformly distributed random numbers is the Box-Müller approach. The following function calculates Gaussian-distributed random numbers:

 function rnorm (mean, sd: real): real;
 {Calculates Gaussian random numbers according to the Box-Müller approach}
  var
   u1, u2: real;
 begin
   u1 := random;
   u2 := random;
   rnorm := mean * abs(1 + sqrt(-2 * (ln(u1))) * cos(2 * pi * u2) * sd);
  end;

The same algorithm is used by the randg randg function from the RTL math unit:

function randg(mean,stddev: float): float;

Exponential Distribution

An exponential distribution occurs frequently in real-world problems. A classical example is the distribution of waiting times between independent Poisson-random events, e.g. the radioactive decay of nuclei [Press et al. 1989].

The following function delivers a single real random number out of an exponential distribution. Rate is the inverse of the mean, and the constant RESOLUTION determines the granularity of generated random numbers.

function randomExp(a, rate: real): real;
const
  RESOLUTION = 1000;
var
  unif: real;
begin
  if rate = 0 then
    randomExp := NaN
  else
  begin
    repeat
      unif := random(RESOLUTION) / RESOLUTION;
    until unif <> 0;
    randomExp := a - rate * ln(unif);
  end;
end;

Gamma Distribution

The gamma distribution is a two-parameter family of continuous random distributions. It is a generalization of both the exponential distribution and the Erlang distribution. Possible applications of the gamma distribution include modelling and simulation of waiting lines, or queues, and actuarial science.

The following function delivers a single real random number out of a gamma distribution. The shape of the distribution is defined by the parameters a, b and c. The function makes use of the function randomExp as defined above.

function randomGamma(a, b, c: real): real;
const
  RESOLUTION = 1000;
  T = 4.5;
  D = 1 + ln(T);
var
  unif: real;
  A2, B2, C2, Q, p, y: real;
  p1, p2, v, w, z: real;
  found: boolean;
begin
  A2 := 1 / sqrt(2 * c - 1);
  B2 := c - ln(4);
  Q := c + 1 / A2;
  C2 := 1 + c / exp(1);
  found := False;
  if c < 1 then
  begin
    repeat
      repeat
        unif := random(RESOLUTION) / RESOLUTION;
      until unif > 0;
      p := C2 * unif;
      if p > 1 then
      begin
        repeat
          unif := random(RESOLUTION) / RESOLUTION;
        until unif > 0;
        y := -ln((C2 - p) / c);
        if unif <= power(y, c - 1) then
        begin
          randomGamma := a + b * y;
          found := True;
        end;
      end
      else
      begin
        y := power(p, 1 / c);
        if unif <= exp(-y) then
        begin
          randomGamma := a + b * y;
          found := True;
        end;
      end;
    until found;
  end
  else if c = 1 then
    { Gamma distribution becomes exponential distribution, if c = 1 }
  begin
    randomGamma := randomExp(a, b);
  end
  else
  begin
    repeat
      repeat
        p1 := random(RESOLUTION) / RESOLUTION;
      until p1 > 0;
      repeat
        p2 := random(RESOLUTION) / RESOLUTION;
      until p2 > 0;
      v := A2 * ln(p1 / (1 - p1));
      y := c * exp(v);
      z := p1 * p1 * p2;
      w := B2 + Q * v - y;
      if (w + D - T * z >= 0) or (w >= ln(z)) then
      begin
        randomGamma := a + b * y;
        found := True;
      end;
    until found;
  end;
end;

Erlang Distribution

The Erlang distribution is a two parameter family of continuous probability distributions. It is a generalization of the exponential distribution and a special case of the gamma distribution, where c is an integer. The Erlang distribution has been first described by Agner Krarup Erlang in order to model the time interval between telephone calls. It is used for queuing theory and for simulating waiting lines.

  function randomErlang(mean: real; k: integer): real;
  const
    RESOLUTION = 1000;
  var
    i: integer;
    unif, prod: real;
  begin
    if (mean <= 0) or (k < 1) then
      randomErlang := NaN
    else
    begin
      prod := 1;
      for i := 1 to k do
      begin
        repeat
          unif := random(RESOLUTION) / RESOLUTION;
        until unif <> 0;
        prod := prod * unif;
      end;
      randomErlang := -mean * ln(prod);
    end;
  end;

Poisson Distribution

The Poisson distribution applies to integer values. It represents the probability of k successes, when the probability of a success in each trial is small and the rate of occurrence (the mean value) is constant.

function randomPoisson(mean: integer): integer;
{ Generator for Poisson distribution (Donald Knuth's algorithm) }
const
  RESOLUTION = 1000;
var
  k: integer;
  b, l: real;
begin
  assert(mean > 0, 'mean < 1');
  k := 0;
  b := 1;
  l := exp(-mean);
  while b > l do
  begin
    k := k + 1;
    b := b * random(RESOLUTION) / RESOLUTION;
  end;
  randomPoisson := k - 1;
end;

t Distribution

The t distribution (also referred to a Student’s t distribution, since it was published by William Sealy Gosset in 1908 under the pseudonym Student) is a continuous probability distribution. Its shape is defined by one parameter, the degrees of freedom (df). In statistics, many estimators are t distributed. Therefore, Student’s t-distribution plays a major role in a number of widely used statistical analyses, including Student’s t-test for assessing the statistical significance of the difference between two sample means, the construction of confidence intervals for the difference between two population means, and in linear regression analysis. The t-distribution also arises in Bayesian analysis of data from a normal family.

The following algorithm depends on the RTL function random and on the randomChisq function

function randomT(df: integer): real;
{ Generator for Student's t distribution }
begin
  if df < 1 then 
    randomT := NaN
  else begin
    randomT := randg(0, 1) / sqrt(randomChisq(df) / df);
  end;
end;

Chi Squared Distribution

The chi squared distribution is a continuous distribution of random numbers with df degrees of freedom. It is the distribution of a sum of the squares of df independent standard normal random variables. The chi squared distribution has numerous applications in inferential statistics, e.g. in estimating variances and for chi-squared tests. It is a special gamma distribution with c = df/ 2 and b = 2. Therefore the following function depends on the function randomGamma.

function randomChisq(df: integer): real;
begin
  if df < 1 then 
    randomChisq := NaN
  else
    randomChisq := randomGamma(0, 2, 0.5 * df);
end;

F Distribution

The F distribution, also referred to as Fisher-Snedecor distribution, is a continuous probability distribution. It is used for F Test and ANOVA. It has two degrees of freedom that serve as shape parameters v and w and that are positive integers. The following function randomF makes use of randomChisq.

function randomF(v, w: integer): real;
begin
  if (v < 1) or (w < 1) then
    randomF := NaN
  else
    randomF := randomChisq(v) / v / (randomChisq(w) / w);
end;

See also

• Dev random
• Functions for descriptive statistics
• Samples and permutations
• Marsaglia’s pseudo random number generators
• A simple implementation of the Mersenne twister
• Delphi compatible LCG Random
• EverettRandom

References

1. G. E. P. Box and Mervin E. Muller, A Note on the Generation of Random Normal Deviates, The Annals of Mathematical Statistics (1958), Vol. 29, No. 2 pp. 610–611
2. Dietrich, J. W. (2002). Der Hypophysen-Schilddrüsen-Regelkreis. Berlin, Germany: Logos-Verlag Berlin. ISBN 978-3-89722-850-4. OCLC 50451543.
3. Press, W. H., B. P. Flannery, S. A. Teukolsky, W. T. Vetterling (1989). Numerical Recipes in Pascal. The Art of Scientific Computing, Cambridge University Press, ISBN 0-521-37516-9.
4. Richard Saucier, Computer Generation of Statistical Distributions, ARL-TR-2168, US Army Research Laboratory, Aberdeen Proving Ground, MD, 21005-5068, March 2000.
5. R.U. Seydel, Generating Random Numbers with Specified Distributions. In: Tools for Computational Finance, Universitext, DOI 10.1007/978-1-4471-2993-6_2, © Springer-Verlag London Limited 2012
6. Christian Walck, Hand-book on STATISTICAL DISTRIBUTIONS for experimentalists, Internal Report SUF–PFY/96–01, University of Stockholm 2007

Процедура Randomize используется в Паскаль для включения генератора случайных чисел. Функция Random определяет диапазон случайных чисел. Процедура Randomize и функция Random очень часто используются для демонстрации работы массивов в Паскаль.

Randomize и Random в Паскаль.

program massiv4;
uses crt;
var a:integer;
begin
clrscr;
randomize;
repeat
a:=random(1000);
writeln(a);
until a=256;
readln
end.

Строка №6. Инициализируем (включаем) генератор случайных чисел с помощью процедуры Randomize.

Строка №8. Присваиваем переменной «a» случайные числа в диапазоне от 0 до 999 (т.е. от 0 до 1000, но, не включая число 1000) с помощью функции Random. Т.е. запись (1000) означает, что все сгенерированные числа будут не меньше 0 и не больше 999. Предположим, что нам необходимо записать другой диапазон чисел, например от -1000 до 1000. В этом случае строка №8 будет иметь вид: a:= -1000 random(2001). Т.е. сначала записываем минимальное число диапазона (-1000), а в функции Random записываем сумму модуля минимального и максимального числа и прибавляем к ней 1. |-1000|+|1000|+1=2001. Таким образом, переменной «a» будут присвоены случайные числа в диапазоне от -1000 до 1000.

В строке №9 выводим сгенерированные числа на экран.

Строки №8 и №9 включены в цикл (строка №7 и №10). Случайные числа будут генерироваться и выводиться на экран до тех пор пока не выполнится условие цикла (строка №10), т.е. когда очередное сгенерированное число окажется числом 256.

Дополнение к материалу.

• Если бы мы записали функцию Random без цикла (т.е. если убрать строки №7 и №10), то у нас будет сгенерировано только одно число и только оно будет выведено на экран.
• Если убрать из программы процедуру Randomize (т.е. строку №6), то каждый раз при запуске программы у нас будут генерироваться одни и те же числа. Например, при первом запуске программы у нас сгенерировалось 50 случайных чисел. Последним числом оказалось число 256. Программа остановилась. Если закрыть программу, и запустить ее по новой, то у нас сгенерируются те же самые 50 чисел.
• Строку «a:= -1000 random(2001)» можно записать и таким способом: «a:= random(2001) — 1000».
• Если для функции Random не указывать диапазон (т.е. строку №8 записать как: a:=random, то переменной «a» будут присвоены случайные значения от 0 до 1, но не включая 1 (например, 0.3, 0.5, 0.9 и т.д.). В этом случае переменная «a» должна иметь не целый тип (integer), а вещественный тип (например, real).

Предыдущая статья : Использование массивов (продолжение).

Оглавление : Уроки Паскаль. Массивы.

Следующая статья : Нахождение максимального элемента массива.

Раздел: Стандартные функции Паскаля

Функция Random генерирует и возвращает случайное число. Синтаксис функции следующий:

function Random(L: LongInt) : LongInt;

function Random(L: Int64) : Int64;

function Random : extended;

Функция возвращает случайное число большее или равное 0 и строго меньше L (то есть L не входит в диапазон возвращаемых значений). Если параметр опущен (последний вариант из трёх приведённых выше), то возвращается вещественное число между 0 и 1 (0 включительно, 1 не входит в диапазон возвращаемых значений).

Математически это можно записать так:

0 <= Random < L, если L передаётся
0 <= Random < 1, если L опущен

ПРИМЕЧАНИЕ
FreePascal использует в процедуре Random имитацию случайностей Мерсенна Твистера. Эта реализация имеет большее статистическое распределение, чем, например, алгоритм Линейного Конгруэнтного генератора, но работает значительно медленнее, чем последний. Если скорость выполнения программы критична, то должны быть рассмотрены альтернативные генераторы случайных чисел.

Процедура Randomize в Паскале запускает генератор случайных чисел. Синтаксис:


procedure Randomize;

Процедура Randomize инициализирует генератор случайных чисел FreePascal, задавая
значение переменной Randseed, вычисленное с помощью системных часов.

Как запустить генератор случайных чисел в Паскале

Пример программы, где используются разные варианты получения случайных чисел, приведён ниже:

program funcrand;

var x : integer;
    z : real;

begin
  Randomize;          //Запустить генератор случайных чисел
  x := Random(100);   //х - случайное число от 0 до 99
  WriteLn(x);

  z := Random(100);   //х - случайное число от 0 до 99
  WriteLn(z:0:4);

  z := Random;        //х - случайное число от 0 до 0,9999...
  WriteLn(z:0:4);

  ReadLn;
end.

ВАЖНО!
Перед использованием функции Random надо обязательно
вызвать процедуру Randomize, чтобы запустить генератор случайных чисел. Иначе функция Random будет возвращать НЕ случайное число.

Процедура Randomize вызывается ТОЛЬКО ОДИН РАЗ в начале программы. Типичная ошибка новичков заключается в том, что они вызывают Randomize перед каждым вызовом Random. Этого делать не надо.

Что такое Randseed

Давайте сначала попробуем не использовать процедуру Randomize. Например, так:

x := Random(100);   
WriteLn(x);

z := Random(100);   
WriteLn(z:0:4);

В этом примере функция Random будет возвращать какое-то значение, но оно НЕ будет случайным числом. Сколько бы раз вы не запускали программу, она всегда будет выводить одинаковые числа.

В моём случае это были числа 54 и 59. В вашем случае это могут быть другие числа, но суть не в этом, а в том, что они будут всегда одинаковыми.

Теперь попробуем сделать так:

Randseed := 500;

x := Random(100);   //х - случайное число от 0 до 99
WriteLn(x);

z := Random(100);   //х - случайное число от 0 до 99
WriteLn(z:0:4);

Теперь числа будут другими. В моём случае 69 и 7. Правда, они тоже не будут изменяться, то есть не будут случайными.

Однако эти числа изменились. Потому что мы изменили значение глобальной переменной Randseed.

Переменная Randseed — это глобальная предопределённая переменная в FreePascal.
Она также есть и в Делфи. Так что всё сказанное будет справедливо и для Делфи.

Эта переменная задаёт начальное значение для генератора случайных чисел. Опираясь на это значение функция Random генерирует случайное число. Но, если значение переменной Randseed будет всегда одинаковым, то никаких случайных чисел мы не получим.

Поэтому при запуске программы надо хотя бы один раз вызвать процедуру Randomize, которая устанавливает начальное значение переменной Randseed, получая системное время и из этих данных формируя значение для переменной Randseed.

Так как программа запускается в какое-то случайное время, то и значение переменной Randseed будет случайным. А, следовательно, и функция Random будет возвращать случайные значения.

Давайте попробуем написать свою процедуру Randomize. Она может быть, например, такой:

//**************************************
// Процедура, которая имитирует работу 
// стандартной процедуры Randomize
//***************************************
procedure MyRandomize;
var h, m, s, ms : Word;
begin
  DecodeTime(Now, h, m, s, ms);
  Randseed := ms;
end;

Я не буду в подробностях разъяснять работу процедуры DecodeTime. Скажу только, то она возвращает, час, минуту, секунду и миллисекунду текущего времени компьютера. Мы используем миллисекунду, значение которой и присваиваем переменной Randseed.

Можете попробовать использовать эту процедуру вместо стандартной процедуры Randomize и
убедиться, что функция Random возвращает случайные значения. Не забудьте подключить к
программе модуль SysUtils, в котором объявлена процедура DecodeTime, иначе программа не откомпилируется.

ПРИМЕЧАНИЕ
Исходя из того, что процедура Randomize задаёт начальное значение переменной Randseed на основе текущего времени компьютера, можно предположить, что, например, если запустить программу сегодня в 12:00:00 и завтра в это же время, то функция Random вернёт одинаковые числа.

К сожалению, проверить это очень трудно, так как запустить программу в одно и то же время с точностью до миллисекунды будет практически невозможно.