Изучаем math random javascript
Содержание:
- Math.Random() Example
- Генератор псевдослучайных чисел в V8
- Генерирование целочисленных псевдослучайных значений
- Класс Random
- Extending
- API
- Генерация случайных чисел с помощью класса Math
- Random Number Generation Using the Random Class
- Random Number Generation Features in Java 8
- How can this be useful ?
- Using ThreadLocalRandom.current.nextInt() to generate random number between 1 and 10
- Использование сторонних API
- Что такое генераторы псевдослучайных чисел?
- Java Math.random() between 1 to N
- Math и метод random
- Random Numbers Using the Math Class
- Alternate API
- Using Math.random() to generate random number between 1 and 10
- Альтернатива в виде CSPRNG
Math.Random() Example
Here’s an example of the method in action:
import java.lang.Math; class Main { public static void main(String[] args) { double number = Math.random(); System.out.println("Random number: " + number); } }
Our code returns:
As you can see, our program has returned a random number between 0 and 1. However, this number is not very useful in its current form. If we want to generate a random number for a guessing game, for instance, we would not want to have a decimal number.
In order to produce a whole number with our pseudorandom number generator, we can multiply our random number by another number and round it to the nearest whole number. For instance, suppose we wanted to generate a random number between 1 and 10. We could do so using this code:
class Main {
public static void main(String[] args) {
int number = (int)(Math.random() * 10);
System.out.println("Random number: " + number);
}
}
Here is the result of our program after running it three times:
4
6
2
As you can see, our program returns a random integer, or whole number.
Let’s break down our code. First, we declared a class called Main which stores the code for our program.
Then we used the method to generate a random number, and we multiplied that number by 10. After we multiplied the result by 10, we converted it to an integer, which rounds it to the nearest decimal place and gives us a whole number.
Then, on the final line, we print out the message “Random number: “ to the console, followed by the random number our program generated.
If we wanted to generate a larger number, we could replace the * 10 parts of our code with another number. For instance, say we wanted to generate a number between 1 and 1000. We could do so by replacing * 10 with * 1000 like this:
class Main {
public static void main(String[] args) {
int number = (int)(Math.random() * 1000);
System.out.println("Random number: " + number);
}
}
After executing our program three times, the following response was returned:
181
914
939
Генератор псевдослучайных чисел в V8
Выглядит малопонятно, будем разбираться.
Есть одна подсказка. В старых версиях V8 был комментарий: «генератор случайных чисел использует алгоритм MWC Джорджа Марсальи (George Marsaglia)». В поисковике нашлось следующее:
Так что если вам нужен PRNG, то MWC кажется неплохим выбором.
Но реализованный в V8 алгоритм непохож на типичный MWC. Вероятно, причина в том, что это не MWC, а сразу два MWC-генератора — один в строке 5, второй в строке 6, — совместно генерирующих одно случайное число в строке 9. Не стану выкладывать тут все расчёты, но каждый из этих подгенераторов имеет длину цикла примерно 230, что даёт суммарную длину генерируемой последовательности примерно 260.
Но у нас, как вы помните, 2132 возможных идентификаторов. Допустим, что соблюдается условие равномерного распределения. Тогда вероятность коллизии после случайно сгенерированных 100 млн идентификаторов должна быть менее 0,4%. Но коллизии стали возникать гораздо раньше. Наверное, мы где-то ошиблись с нашим анализом. Возможно, проблема заключается в равномерном распределении — вероятно, есть какая-то дополнительная структура в генерируемой последовательности.
Генерирование целочисленных псевдослучайных значений
Для генерирования целочисленных псевдослучайных значений используется представленное выше выражение, в котором
произведение «приводится» к целочисленному значению. Например, попробуем получить псевдослучайное значение в диапазоне
Обратите внимание, что закрывающаяся скобка квадратная, т.е. 20 входит в диапазон
В этом случае к разности
между максимальным и минимальным значениями следует добавить 1, т.е. определить диапазон целочисленных значений [5,21),
где 21 не попадает в желаемый диапазон :
// после подстановки значений int i = (int)Math.random() * (20 - 5 + 1) + 5; // получаем int i = (int)Math.random() * 16 + 5;
Класс Random
В качестве генератора псевдослучайных чисел можно также использовать класс java.util.Random, имеющий два
конструктора :
public Random(); public Random(long);
Поскольку Random создаёт псевдослучайное число, то определив начальное число, устанавливается начальная точка
случайной последовательности, способствующая получению одинаковых случайных последовательностей. Чтобы избежать такого
совпадения, обычно применяют второй конструктор с использованием в качестве инициирующего значения текущего времени.
В таблице представлены наиболее часто используемые методы генератора Random :
| Метод | Описание |
|---|---|
| boolean nextBoolean() | получение следующего случайного значения типа boolean |
| double nextDouble() | получение следующего случайного значения типа double |
| float nextFloat() | получение следующего случайного значения типа float |
| int nextInt() | получение следующего случайного значения типа int |
| int nextInt(int n) | получение следующего случайного значения типа int в диапазоне от 0 до n |
| long nextLong() | получение следующего случайного значения типа long |
| void nextBytes(byte[] buf) | формирование массива из случайно генерируемых значений |
Пример получения псевдослучайного целочисленного значения с использованием класса Random :
Random random = new Random(); int i = random.nextInt();
С классом Random алгоритм получения псевдослучайного числа такой же, как и у метода random класса
Math. Допустим, что нам необходимо получить случайное число в диапазоне , 100 включительно. В этом случае
код может выглядеть следующим образом :
int min = 5; int max = 100; int diff = max - min; Random random = new Random(); int i = random.nextInt(diff + 1) + min;
Класс SecureRandom
В следующем примере формируется массив псевдослучайных значений типа byte :
SecureRandom random = new SecureRandom(); byte bytes[] = new byte; random.nextBytes(bytes);
Этот же массив можно сформировать методом generateSeed :
byte seed[] = random.generateSeed(8);
Пример использования SecureRandom представлен на странице
Симметричного шифрования.
Класс ThreadLocalRandom
В JDK 7 включен класс ThreadLocalRandom из многопоточного пакета
java.util.concurrent, который следует использовать для получения псевдослучайных
значений в многопоточных приложениях. Для получения экземпляра ThreadLocalRandom следует использовать
статический метод current() данного класса. Пример :
ThreadLocalRandom random = ThreadLocalRandom.current();
System.out.println("Random values : ");
System.out.println("boolean : " + random.nextBoolean());
System.out.println("int : " + random.nextInt ());
System.out.println("float : " + random.nextFloat ());
System.out.println("long : " + random.nextLong ());
System.out.println("int from 0 to 5 : " +
random.nextInt(5));
System.out.println("long from 5 to 15 : " +
random.nextLong(5, 15));
Extending
You can add your own methods to instances, as such:
var random =newRandom();random.bark=function(){if(this.bool()){return"arf!";}else{return"woof!";}};random.bark();
This is the recommended approach, especially if you only use one instance of .
Or you could even make your own subclass of Random:
functionMyRandom(engine){returnRandom.call(this, engine);}MyRandom.prototype=Object.create(Random.prototype);MyRandom.prototype.constructor= MyRandom;MyRandom.prototype.mood=function(){switch(this.integer(,2)){casereturn"Happy";case1return"Content";case2return"Sad";}};var random =newMyRandom();random.mood();
Or, if you have a build tool are are in an ES6+ environment:
classMyRandomextendsRandom{mood(){switch(this.integer(,2)){casereturn"Happy";case1return"Content";case2return"Sad";}}}constrandom=newMyRandom();random.mood();
API
- : Utilizes
- : Utilizes
- : Utilizes
- : Produces a new Mersenne Twister. Must be seeded before use.
Or you can make your own!
interfaceEngine{next()number;}
Any object that fulfills that interface is an .
- : Seed the twister with an initial 32-bit integer.
- : Seed the twister with an array of 32-bit integers.
- : Seed the twister with automatic information. This uses the current Date and other entropy sources.
- : Produce a 32-bit signed integer.
- : Discard random values. More efficient than running repeatedly.
- : Return the number of times the engine has been used plus the number of discarded values.
One can seed a Mersenne Twister with the same value () or values () and discard the number of uses () to achieve the exact same state.
If you wish to know the initial seed of , it is recommended to use the function to create the seed manually (this is what does under-the-hood).
constseed=createEntropy();constmt=MersenneTwister19937.seedWithArray(seed);useTwisterALot(mt);constclone=MersenneTwister19937.seedWithArray(seed).discard(mt.getUseCount());
Random.js also provides a set of methods for producing useful data from an engine.
- : Produce an integer within the inclusive range . can be at its minimum -9007199254740992 (-2 ** 53). can be at its maximum 9007199254740992 (2 ** 53).
- : Produce a floating point number within the range . Uses 53 bits of randomness.
- : Produce a boolean with a 50% chance of it being .
- : Produce a boolean with the specified chance causing it to be .
- : Produce a boolean with / chance of it being true.
- : Return a random value within the provided within the sliced bounds of and .
- : Same as .
- : Shuffle the provided (in-place). Similar to .
- : From the array, produce an array with elements that are randomly chosen without repeats.
- : Same as
- : Produce an array of length with as many rolls.
- : Produce a random string using numbers, uppercase and lowercase letters, , and of length .
- : Produce a random string using the provided string as the possible characters to choose from of length .
- or : Produce a random string comprised of numbers or the characters of length .
- : Produce a random string comprised of numbers or the characters of length .
- : Produce a random within the inclusive range of . and must both be s.
An example of using would be as such:
constengine=MersenneTwister19937.autoSeed();constdistribution=integer(,99);functiongenerateNaturalLessThan100(){returndistribution(engine);}
Producing a distribution should be considered a cheap operation, but producing a new Mersenne Twister can be expensive.
An example of producing a random SHA1 hash:
var engine = nativeMath;var distribution =hex(false);functiongenerateSHA1(){returndistribution(engine,40);}
Генерация случайных чисел с помощью класса Math
Чтобы сгенерировать случайное число Java предоставляет класс Math, доступный в пакете java.util. Этот класс содержит статичный метод Math.random(), предназначенный для генерации случайных чисел типа double .
Метод random( ) возвращает положительное число большее или равное 0,0 и меньшее 1,0. При вызове данного метода создается объект генератора псевдослучайных чисел java.util.Random.
Math.random() можно использовать с параметрами и без. В параметрах задается диапазон чисел, в пределах которого будут генерироваться случайные значения.
Пример использования Math.random():
public static double getRandomNumber(){
double x = Math.random();
return x;
}
Метод getRandomNumber( ) использует Math.random() для возврата положительного числа, которое больше или равно 0,0 или меньше 1,0 .
Результат выполнения кода:
Double between 0.0 and 1.0: SimpleRandomNumber = 0.21753313144345698
Случайные числа в заданном диапазоне
Для генерации случайных чисел в заданном диапазоне необходимо указать диапазон. Синтаксис:
(Math.random() * ((max - min) + 1)) + min
Разобьем это выражение на части:
- Сначала умножаем диапазон значений на результат, который генерирует метод random().Math.random() * (max — min)возвращает значение в диапазоне , где max не входит в заданные рамки. Например, выражение Math.random()*5 вернет значение в диапазоне , в который 5 не входит.
- Расширяем охват до нужного диапазона. Это делается с помощью минимального значения.
(Math.random() * ( max - min )) + min
Но выражение по-прежнему не охватывает максимальное значение.
Чтобы получить максимальное значение, прибавьте 1 к параметру диапазона (max — min). Это вернет случайное число в указанном диапазоне.
double x = (Math.random()*((max-min)+1))+min;
Существуют различные способы реализации приведенного выше выражения. Рассмотрим некоторые из них.
Случайное двойное число в заданном диапазоне
По умолчанию метод Math.random() при каждом вызове возвращает случайное число типа double . Например:
public static double getRandomDoubleBetweenRange(double min, double max){
double x = (Math.random()*((max-min)+1))+min;
return x;
}
Вы можете вызвать предыдущий метод из метода main, передав аргументы, подобные этому.
System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber =
"+getRandomDoubleBetweenRange(5.0, 10.00));
Результат.
System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber =
"+getRandomDoubleBetweenRange(5.0, 10.00));
Случайное целое число в заданном диапазоне
Пример генерации случайного целочисленного значения в указанном диапазоне:
public static double getRandomIntegerBetweenRange(double min, double max){
double x = (int)(Math.random()*((max-min)+1))+min;
return x;
}
Метод getRandomIntegerBetweenRange() создает случайное целое число в указанном диапазоне. Так как Math.random() генерирует случайные числа с плавающей запятой, то нужно привести полученное значение к типу int. Этот метод можно вызвать из метода main, передав ему аргументы следующим образом:
System.out.println("Integer between 2 and 6: RandomIntegerNumber
= "+getRandomIntegerBetweenRange(2,6));
Результат.
Integer between 2 and 6: RandomIntegerNumber = 5
Примечание. В аргументах также можно передать диапазон отрицательных значений, чтобы сгенерировать случайное отрицательное число в этом диапазоне.
Random Number Generation Using the Random Class
You can use the java.util.Random class to generate random numbers of different types, such as int, float, double, long, and boolean.
To generate random numbers, first, create an instance of the Random class and then call one of the random value generator methods, such as nextInt(), nextDouble(), or nextLong().
The nextInt() method of Random accepts a bound integer and returns a random integer from 0 (inclusive) to the specified bound (exclusive).
The code to use the nextInt() method is this.
The code to use the nextInt() method to generate an integer within a range is:
The nextFloat() and nextDouble() methods allow generating float and double values between 0.0 and 1.0.
The code to use both the methods is:
Random Number Generation Features in Java 8
Java 8 introduced a new method, ints(), in the java.util.Random class. The ints() method returns an unlimited stream of pseudorandom int values. You can limit the random numbers between a specified range by providing the minimum and the maximum values.
The code to use the Random.ints() method to generate random integer values within a specified range is this.
The getRandomNumberInts() method generates a stream of random integers between the min (inclusive) and max (exclusive). As ints() method produces an IntStream, the code calls the findFirst() method that returns an OptionalInt object that describes the first element of this stream. The code then calls the getAsInt()method to return the int value in OptionalInt.
The code to use the Random.ints() method to generate a stream of specified random integer values is:
The code to call the preceding method is:
The output of the preceding code is:
The code to use the Random.ints() method to generate a stream of a specified number of random integer values between a range is:
The code to call the preceding method is:
The output of the preceding code is:
In addition to ints(), some other frequently used methods that Java 8 introduced to the Random class — which can return a sequential stream of random numbers — are:
- LongStream longs()
- DoubleStream doubles()
How can this be useful ?
Sometimes, the test fixture does not really matter to the test logic. For example, if we want to test the result of a new sorting algorithm, we can generate random input data and assert the output is sorted, regardless of the data itself:
@org.junit.Test
public void testSortAlgorithm() {
// Given
int[] ints = easyRandom.nextObject(int[].class);
// When
int[] sortedInts = myAwesomeSortAlgo.sort(ints);
// Then
assertThat(sortedInts).isSorted(); // fake assertion
}
Another example is testing the persistence of a domain object, we can generate a random domain object, persist it and assert the database contains the same values:
@org.junit.Test
public void testPersistPerson() throws Exception {
// Given
Person person = easyRandom.nextObject(Person.class);
// When
personDao.persist(person);
// Then
assertThat("person_table").column("name").value().isEqualTo(person.getName()); // assretj db
}
There are many other uses cases where Easy Random can be useful, you can find a non exhaustive list in the wiki.
Using ThreadLocalRandom.current.nextInt() to generate random number between 1 and 10
If you want to generate random number in current thread, you can use to generate random number between 1 and 10.
was introducted in JDK 7 for managing multiple threads.
Let’s see with the help of example:
|
1 |
import java.util.concurrent.ThreadLocalRandom; publicclassThreadLocalRandomNextIntMain { publicstaticvoidmain(Stringargs){ intmin=1; intmax=10; System.out.println(«============================»); System.out.println(«Generating 10 random integer in range of 1 to 10 using Math.random»); System.out.println(«============================»); for(inti=;i<5;i++){ intrandomNumber=ThreadLocalRandom.current().nextInt(min,max)+min; System.out.println(randomNumber); } } } |
============================
Generating 10 random integer in range of 1 to 10 using Math.random
============================
7
7
4
10
4
That’s all about java random number between 1 and 10.
Использование сторонних API
Как мы уже видели, Java предоставляет нам множество классов и методов для генерации случайных чисел. Однако для этой цели существуют также сторонние API-интерфейсы.
Мы собираемся взглянуть на некоторые из них.
3.1. org.apache.commons.math3.случайный.Генератор случайных чисел
В математической библиотеке commons есть много генераторов из проекта Apache Commons. Самый простой и, вероятно, самый полезный-это Генератор случайных данных . Он использует алгоритм Well19937c для случайной генерации. Однако мы можем предоставить реализацию нашего алгоритма.
Давайте посмотрим, как им пользоваться. Во-первых, мы должны добавить зависимость:
org.apache.commonscommons-math33.6.1
Последнюю версию commons-math3 можно найти на Maven Central .
Тогда мы сможем начать с ним работать:
RandomDataGenerator randomDataGenerator = new RandomDataGenerator(); int randomWithRandomDataGenerator = randomDataGenerator.nextInt(min, max);
3.2. it.unimi.dsi.util.XoRoShiRo128ПлюсРандом
Безусловно, это одна из самых быстрых реализаций генератора случайных чисел. Он был разработан на факультете информационных наук Миланского университета.
Библиотека также доступна в репозиториях Maven Central . Итак, давайте добавим зависимость:
it.unimi.dsidsiutils2.6.0
Этот генератор наследуется от java.util.Случайный . Однако, если мы взглянем на JavaDoc , мы поймем, что есть только один способ его использования — с помощью метода nextInt . Прежде всего, этот метод доступен только с вызовами с нулевым и одним параметром. Любой из других вызовов будет напрямую использовать java.util.Случайные Методы.
Например, если мы хотим получить случайное число в пределах диапазона, мы бы написали:
XoRoShiRo128PlusRandom xoroRandom = new XoRoShiRo128PlusRandom(); int randomWithXoRoShiRo128PlusRandom = xoroRandom.nextInt(max - min) + min;
Что такое генераторы псевдослучайных чисел?
Эта иллюстрация поясняет мысль фон Неймана: очевидно, что сгенерированная последовательность чисел не является случайной. Для многих задач этого вполне достаточно. Но нам нужен алгоритм, генерирующий числа, которые кажутся случайными. Технически они должны казаться независимыми и одинаково распределёнными случайными переменными, равномерно распределёнными по всему диапазону генератора. Другими словами, нам нужно безопасно притвориться, что наши псевдослучайные числа являются истинно случайными.
Если результат работы генератора очень трудно отличить от истинно случайной последовательности, то его называют высококачественным генератором. В противном случае — низкокачественным. По большей части качество определяется эмпирически, путём прогона статистических тестов на уровень случайности. Например, оценивается количество нулей и единиц, вычисляется число коллизий, применяется метод Монте-Карло для вычисления π и т. д. Другой, более прагматичный метод оценки качества PRNG заключается в анализе его работы на практике и сравнении с истинно случайными числами.
Помимо неслучайности результата, рассматриваемый нами простой алгоритм демонстрирует и другие важные особенности, свойственные всем PRNG. Если долго генерировать числа, то рано или поздно начнёт повторяться одна и та же последовательность. Это свойство называется периодичностью, и ею «страдают» все PRNG.
Период, или длина цикла, — это длина последовательности чисел, создаваемых генератором до первого повторения.
Можно рассматривать PRNG как сильно сжатую шифровальную книгу, содержащую последовательность чисел. Какой-нибудь шпион мог бы использовать его в качестве одноразового блокнота. Начальной позицией в этой «книге» является seed(). Постепенно вы дойдёте до её конца и вернётесь к началу, завершив цикл.
Большая длина цикла не гарантирует высокое качество, но весьма ему способствует. Часто он гарантируется каким-то математическим доказательством. Даже когда мы не можем точно вычислить длину цикла, нам вполне по силам определить его верхнюю границу. Поскольку следующее состояние PRNG и его результат являются детерминистическими функциями текущего состояния, то длина цикла не может быть больше количества возможных состояний. Для достижения максимальной длины генератор должен пройти через все возможные состояния, прежде чем вернуться в текущее.
Если состояние PRNG описывается как k-бит, то длина цикла ≤ 2k. Если она действительно достигает этого значения, то такой генератор называют генератором полного цикла. В хороших PRNG длина цикла близка к этой верхней границе. В противном случае вы будете зря тратить память.
Давайте теперь проанализируем количество уникальных случайных значений, генерируемых PRNG с помощью некой детерминистической трансформации выходных данных. Допустим, нам надо сгенерировать три случайных числа от 0 до 15, вроде 2, 13, 4 или 5, 12, 15. У нас может быть 163 = 4096 таких тройных комбинаций, но рассматриваемый нами простой генератор может выдать лишь 16 комбинаций:
Так мы приходим к ещё одному свойству всех PRNG: количество уникальных значений, которые могут быть сгенерированы из псевдослучайной последовательности, ограничивается длиной цикла последовательности.
Неважно, какие значения мы генерируем в данном случае. Их может быть 16 комбинаций из четырёх значений (или любой другой длины), 16 уникальных матричных массивов и т
д. Не более 16 уникальных значений любого типа.
Вспомните наш алгоритм для генерирования случайных идентификаторов, состоящих из 22 символов, берущихся из 64-символьного словаря. Получается, что мы генерируем комбинации из 22 чисел от 0 до 63. И здесь мы сталкиваемся с той же проблемой: количество возможных уникальных идентификаторов ограничено размером внутреннего состояния PRNG и длиной его цикла.
Java Math.random() between 1 to N
By default Math.random() always generates numbers between 0.0 to 1.0, but if we want to get numbers within a specific range then we have to multiple the return value with the magnitude of the range.
Example:- If we want to generate number between 1 to 100 using the Math.random() then we must multiply the returned value by 100.
Java program to generate floating-point numbers between 1 to 100.
Output:-
10.48550810115520481.26887023085449
The above program generates floating-point numbers but if we want to generate integer numbers then we must type cast the result value.
Java program to generate integer numbers between 1 to 100.
Output:-
2070
Math и метод random
Вроде бы всё просто, вызвал свойство у объекта и вот тебе числа. Но не всё так просто, это конечно не чистый природный рандом а эмулятор, псевдо-рандом. Но и он поможет написать вам интересную программу, например русское лото.
Но генерирует он числа от 0 до 1, так что разберём нюансы написания скрипта и вызова random, так же наполним массив случайными числами.
JavaScript
<script>
var rand = Math.random(); //Но минус в том что генерирует он от нуля до единицы
document.write(rand);
document.write(«<br /><hr />»);
var rand2 = Math.random() * 100; //Так мы получим случайное число в диапазоне от 0 до 100
document.write(rand2);
document.write(«<br /><hr />»);
var rand3 = Math.round(Math.random() * 100); //Наконец то нормальное человеческое число))
document.write(rand3);
document.write(«<br /><hr />»);
//Теперь нам надо задать диапазон в котором числа будут рандомизировать, здесь вам пришлось бы повозиться если бы всё ещё до вас не придумали
function myRandom(from, to){
return Math.floor((Math.random() * (to — from + 1)) + from); //Тут уже нужны математические мозги
}
document.write(myRandom(50,60));
/**********************************************************************************************************************/
//Заполняем массив рандомными числами
var randArr = new Array(10);
var start = 40;
var fin = 80;
function myRandom2(from, to){
return Math.floor((Math.random() * (to — from + 1)) + from); //Тут уже нужны математические мозги
}
function randomArray(arr,begin,end){
for(var i = 0; i < arr.length; i++){
arr = myRandom2(begin,end); //Так просто 0_о!!! В смысле я думал понадобиться метод типа push
document.write(arr + «<br />»);
}
}
document.write(«<br /><hr />Значения в массиве формируются от » + start + » и до » + fin + «<br />»);
randomArray(randArr,start,fin); //Можно спрограммировать игру «русское лото» какие числа будут выпадать
</script>
|
1 |
<script> varrand=Math.random();//Но минус в том что генерирует он от нуля до единицы document.write(rand); document.write(«<br /><hr />»); varrand2=Math.random()*100;//Так мы получим случайное число в диапазоне от 0 до 100 document.write(rand2); document.write(«<br /><hr />»); varrand3=Math.round(Math.random()*100);//Наконец то нормальное человеческое число)) document.write(rand3); document.write(«<br /><hr />»); //Теперь нам надо задать диапазон в котором числа будут рандомизировать, здесь вам пришлось бы повозиться если бы всё ещё до вас не придумали functionmyRandom(from,to){ returnMath.floor((Math.random()*(to-from+1))+from);//Тут уже нужны математические мозги } document.write(myRandom(50,60)); varrandArr=newArray(10); varstart=40; varfin=80; functionmyRandom2(from,to){ returnMath.floor((Math.random()*(to-from+1))+from);//Тут уже нужны математические мозги } functionrandomArray(arr,begin,end){ for(vari=;i<arr.length;i++){ arri=myRandom2(begin,end);//Так просто 0_о!!! В смысле я думал понадобиться метод типа push document.write(arri+»<br />»); } } document.write(«<br /><hr />Значения в массиве формируются от «+start+» и до «+fin+»<br />»); randomArray(randArr,start,fin);//Можно спрограммировать игру «русское лото» какие числа будут выпадать </script> |
Количество просмотров: 393
| Категория: JavaScript | Тэги: JavaScript / random / основы / числа
Random Numbers Using the Math Class
Java provides the Math class in the java.util package to generate random numbers.
The Math class contains the static Math.random() method to generate random numbers of the double type.
The random() method returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. When you call Math.random(), under the hood, a java.util.Random pseudorandom-number generator object is created and used.
You can use the Math.random() method with or without passing parameters. If you provide parameters, the method produces random numbers within the given parameters.
The code to use the Math.random() method:
The getRandomNumber() method uses the Math.random() method to return a positive double value that is greater than or equal to 0.0 and less than 1.0.
The output of running the code is:
Random Numbers Within a Given Range
For generating random numbers between a given a range, you need to specify the range. A standard expression for accomplishing this is:
Let us break this expression into steps:
- First, multiply the magnitude of the range of values you want to cover by the result that Math.random() produces.returns a value in the range ,max–min where max is excluded. For example, if you want 5,10], you need to cover 5 integer values so you can use Math.random()*5. This would return a value in the range ,5, where 5 is not included.
- Next, shift this range up to the range that you are targeting. You do this by adding the min value.
But this still does not include the maximum value.
To get the max value included, you need to add 1 to your range parameter (max — min). This will return a random double within the specified range.
There are different ways of implementing the above expression. Let us look at a couple of them.
Random Double Within a Given Range
By default, the Math.random() method returns a random number of the type double whenever it is called. The code to generate a random double value between a specified range is:
You can call the preceding method from the main method by passing the arguments like this.
The output is this.
Random Integer Within a Given Range
The code to generate a random integer value between a specified range is this.
The preceding getRandomIntegerBetweenRange() method produces a random integer between the given range. As Math.random() method generates random numbers of double type, you need to truncate the decimal part and cast it to int in order to get the integer random number. You can call this method from the main method by passing the arguments as follows:
The output is this.
Note: You can pass a range of negative values to generate a random negative number within the range.
Alternate API
There is an alternate API which may be easier to use, but may be less performant. In scenarios where performance is paramount, it is recommended to use the aforementioned API.
constrandom=newRandom(MersenneTwister19937.seedWithArray(0x12345678,0x90abcdef));constvalue=r.integer(,99);constotherRandom=newRandom();
This abstracts the concepts of engines and distributions.
- : Produce an integer within the inclusive range . can be at its minimum -9007199254740992 (2 ** 53). can be at its maximum 9007199254740992 (2 ** 53). The special number is never returned.
- : Produce a floating point number within the range . Uses 53 bits of randomness.
- : Produce a boolean with a 50% chance of it being .
- : Produce a boolean with the specified chance causing it to be .
- : Produce a boolean with / chance of it being true.
- : Return a random value within the provided within the sliced bounds of and .
- : Shuffle the provided (in-place). Similar to .
- : From the array, produce an array with elements that are randomly chosen without repeats.
- : Same as
- : Produce an array of length with as many rolls.
- : Produce a random string using numbers, uppercase and lowercase letters, , and of length .
- : Produce a random string using the provided string as the possible characters to choose from of length .
- or : Produce a random string comprised of numbers or the characters of length .
- : Produce a random string comprised of numbers or the characters of length .
- : Produce a random within the inclusive range of . and must both be s.
Using Math.random() to generate random number between 1 and 10
You can also use method to random number between 1 and 10. You can iterate from min to max and use Math.ran
Here is formula for the same:
|
1 |
intrandomNumber=(int)(Math.random()*(max-min))+min;
|
Let’s see with the help of example:
|
1 |
publicclassMathRandomExample { publicstaticvoidmain(Stringargs){ intmin=1; intmax=10; System.out.println(«============================»); System.out.println(«Generating 10 random integer in range of 1 to 10 using Math.random»); System.out.println(«============================»); for(inti=;i<5;i++){ intrandomNumber=(int)(Math.random()*(max-min))+min; System.out.println(randomNumber); } } } |
============================
Generating 10 random integer in range of 1 to 10 using Math.random
============================
9
6
5
6
2
Альтернатива в виде CSPRNG
Итак, нам надо было чем-то быстро заменить Math.random(). Для JavaScript существует множество других PRNG, но у нас было два условия:
- У генератора должен быть достаточно долгий период, чтобы нагенерировать 2132 идентификаторов.
- Он должен быть тщательно протестирован и иметь хорошую поддержку.
У этого решения есть три недостатка:
- В CSPRNG почти всегда используются нелинейные трансформации, и поэтому они работают медленнее, чем некриптографические альтернативы.
- Многие CSPRNG-системы нельзя рандомизировать (seed), что делает невозможным создание воспроизводимой последовательности (например, для целей тестирования).
- CSPRNG могут непредсказуемо выделяться на фоне всех остальных мер качества, отдельные из которых могут оказаться важнее для вашего проекта.
Однако есть и преимущества:
- В большинстве случаев производительности CSPRNG вполне достаточно (на моей машине я могу с помощью crypto.getRandomValues() получить в Chrome около 100 Мб/с случайных данных).
- В определённых пределах непредсказуемость подразумевает невозможность отличить результат работы генератора от истинно случайных данных. Значит, мы можем получить всё, что нам нужно, от псевдослучайной последовательности.
- Если генератор позиционируется как «криптографически безопасный», то можно предположить, что его код анализировался более тщательно и подвергался многим практическим тестам на случайность.
Я не знаю, какова длина цикла в crypto.randomBytes(). Насколько мне известно, у этой проблемы не существует решения в замкнутой форме. Могу сказать лишь, что при большом пространстве состояния и длительном потоке входящей энтропии алгоритм должен быть достаточно безопасен. Раз уж вы доверяете OpenSSL генерирование пар публичных/личных ключей, то какой смысл беспокоиться по этому поводу? После того как мы заменили Math.random() на crypto.randomBytes(), проблема коллизий исчезла.
