2000-01-06 07:40:54 +01:00
|
|
|
--
|
|
|
|
-- RANDOM
|
2023-01-10 02:30:25 +01:00
|
|
|
-- Test random() and allies
|
2000-01-06 07:40:54 +01:00
|
|
|
--
|
2023-01-10 02:30:25 +01:00
|
|
|
-- Tests in this file may have a small probability of failure,
|
|
|
|
-- since we are dealing with randomness. Try to keep the failure
|
|
|
|
-- risk for any one test case under 1e-9.
|
|
|
|
--
|
|
|
|
-- There should be no duplicates in 1000 random() values.
|
|
|
|
-- (Assuming 52 random bits in the float8 results, we could
|
|
|
|
-- take as many as 3000 values and still have less than 1e-9 chance
|
|
|
|
-- of failure, per https://en.wikipedia.org/wiki/Birthday_problem)
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random() r FROM generate_series(1, 1000)) ss
|
|
|
|
GROUP BY r HAVING count(*) > 1;
|
|
|
|
r | count
|
|
|
|
---+-------
|
2004-03-15 16:46:25 +01:00
|
|
|
(0 rows)
|
|
|
|
|
2023-01-10 02:30:25 +01:00
|
|
|
-- The range should be [0, 1). We can expect that at least one out of 2000
|
|
|
|
-- random values is in the lowest or highest 1% of the range with failure
|
|
|
|
-- probability less than about 1e-9.
|
|
|
|
SELECT count(*) FILTER (WHERE r < 0 OR r >= 1) AS out_of_range,
|
|
|
|
(count(*) FILTER (WHERE r < 0.01)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 0.99)) > 0 AS has_large
|
|
|
|
FROM (SELECT random() r FROM generate_series(1, 2000)) ss;
|
|
|
|
out_of_range | has_small | has_large
|
|
|
|
--------------+-----------+-----------
|
|
|
|
0 | t | t
|
|
|
|
(1 row)
|
1997-04-29 16:23:51 +02:00
|
|
|
|
2023-01-10 02:30:25 +01:00
|
|
|
-- Check for uniform distribution using the Kolmogorov-Smirnov test.
|
|
|
|
CREATE FUNCTION ks_test_uniform_random()
|
|
|
|
RETURNS boolean AS
|
|
|
|
$$
|
|
|
|
DECLARE
|
|
|
|
n int := 1000; -- Number of samples
|
|
|
|
c float8 := 1.94947; -- Critical value for 99.9% confidence
|
|
|
|
ok boolean;
|
|
|
|
BEGIN
|
|
|
|
ok := (
|
|
|
|
WITH samples AS (
|
|
|
|
SELECT random() r FROM generate_series(1, n) ORDER BY 1
|
|
|
|
), indexed_samples AS (
|
|
|
|
SELECT (row_number() OVER())-1.0 i, r FROM samples
|
|
|
|
)
|
|
|
|
SELECT max(abs(i/n-r)) < c / sqrt(n) FROM indexed_samples
|
|
|
|
);
|
|
|
|
RETURN ok;
|
|
|
|
END
|
|
|
|
$$
|
|
|
|
LANGUAGE plpgsql;
|
|
|
|
-- As written, ks_test_uniform_random() returns true about 99.9%
|
|
|
|
-- of the time. To get down to a roughly 1e-9 test failure rate,
|
|
|
|
-- just run it 3 times and accept if any one of them passes.
|
|
|
|
SELECT ks_test_uniform_random() OR
|
|
|
|
ks_test_uniform_random() OR
|
|
|
|
ks_test_uniform_random() AS uniform;
|
|
|
|
uniform
|
|
|
|
---------
|
|
|
|
t
|
|
|
|
(1 row)
|
1997-04-29 16:23:51 +02:00
|
|
|
|
2023-01-09 18:44:00 +01:00
|
|
|
-- now test random_normal()
|
2023-01-10 02:30:25 +01:00
|
|
|
-- As above, there should be no duplicates in 1000 random_normal() values.
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random_normal() r FROM generate_series(1, 1000)) ss
|
|
|
|
GROUP BY r HAVING count(*) > 1;
|
|
|
|
r | count
|
|
|
|
---+-------
|
2023-01-09 18:44:00 +01:00
|
|
|
(0 rows)
|
|
|
|
|
2023-01-10 02:30:25 +01:00
|
|
|
-- ... unless we force the range (standard deviation) to zero.
|
|
|
|
-- This is a good place to check that the mean input does something, too.
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random_normal(10, 0) r FROM generate_series(1, 100)) ss
|
|
|
|
GROUP BY r;
|
|
|
|
r | count
|
|
|
|
----+-------
|
|
|
|
10 | 100
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random_normal(-10, 0) r FROM generate_series(1, 100)) ss
|
|
|
|
GROUP BY r;
|
|
|
|
r | count
|
|
|
|
-----+-------
|
|
|
|
-10 | 100
|
|
|
|
(1 row)
|
|
|
|
|
2023-03-14 10:17:36 +01:00
|
|
|
-- Check standard normal distribution using the Kolmogorov-Smirnov test.
|
|
|
|
CREATE FUNCTION ks_test_normal_random()
|
|
|
|
RETURNS boolean AS
|
|
|
|
$$
|
|
|
|
DECLARE
|
|
|
|
n int := 1000; -- Number of samples
|
|
|
|
c float8 := 1.94947; -- Critical value for 99.9% confidence
|
|
|
|
ok boolean;
|
|
|
|
BEGIN
|
|
|
|
ok := (
|
|
|
|
WITH samples AS (
|
|
|
|
SELECT random_normal() r FROM generate_series(1, n) ORDER BY 1
|
|
|
|
), indexed_samples AS (
|
|
|
|
SELECT (row_number() OVER())-1.0 i, r FROM samples
|
|
|
|
)
|
|
|
|
SELECT max(abs((1+erf(r/sqrt(2)))/2 - i/n)) < c / sqrt(n)
|
|
|
|
FROM indexed_samples
|
|
|
|
);
|
|
|
|
RETURN ok;
|
|
|
|
END
|
|
|
|
$$
|
|
|
|
LANGUAGE plpgsql;
|
|
|
|
-- As above, ks_test_normal_random() returns true about 99.9%
|
|
|
|
-- of the time, so try it 3 times and accept if any test passes.
|
|
|
|
SELECT ks_test_normal_random() OR
|
|
|
|
ks_test_normal_random() OR
|
|
|
|
ks_test_normal_random() AS standard_normal;
|
|
|
|
standard_normal
|
|
|
|
-----------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
Add functions to generate random numbers in a specified range.
This adds 3 new variants of the random() function:
random(min integer, max integer) returns integer
random(min bigint, max bigint) returns bigint
random(min numeric, max numeric) returns numeric
Each returns a random number x in the range min <= x <= max.
For the numeric function, the number of digits after the decimal point
is equal to the number of digits that "min" or "max" has after the
decimal point, whichever has more.
The main entry points for these functions are in a new C source file.
The existing random(), random_normal(), and setseed() functions are
moved there too, so that they can all share the same PRNG state, which
is kept private to that file.
Dean Rasheed, reviewed by Jian He, David Zhang, Aleksander Alekseev,
and Tomas Vondra.
Discussion: https://postgr.es/m/CAEZATCV89Vxuq93xQdmc0t-0Y2zeeNQTdsjbmV7dyFBPykbV4Q@mail.gmail.com
2024-03-27 11:12:39 +01:00
|
|
|
-- Test random(min, max)
|
|
|
|
-- invalid range bounds
|
|
|
|
SELECT random(1, 0);
|
|
|
|
ERROR: lower bound must be less than or equal to upper bound
|
|
|
|
SELECT random(1000000000001, 1000000000000);
|
|
|
|
ERROR: lower bound must be less than or equal to upper bound
|
|
|
|
SELECT random(-2.0, -3.0);
|
|
|
|
ERROR: lower bound must be less than or equal to upper bound
|
|
|
|
SELECT random('NaN'::numeric, 10);
|
|
|
|
ERROR: lower bound cannot be NaN
|
|
|
|
SELECT random('-Inf'::numeric, 0);
|
|
|
|
ERROR: lower bound cannot be infinity
|
|
|
|
SELECT random(0, 'NaN'::numeric);
|
|
|
|
ERROR: upper bound cannot be NaN
|
|
|
|
SELECT random(0, 'Inf'::numeric);
|
|
|
|
ERROR: upper bound cannot be infinity
|
|
|
|
-- empty range is OK
|
|
|
|
SELECT random(101, 101);
|
|
|
|
random
|
|
|
|
--------
|
|
|
|
101
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT random(1000000000001, 1000000000001);
|
|
|
|
random
|
|
|
|
---------------
|
|
|
|
1000000000001
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT random(3.14, 3.14);
|
|
|
|
random
|
|
|
|
--------
|
|
|
|
3.14
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- There should be no triple duplicates in 1000 full-range 32-bit random()
|
|
|
|
-- values. (Each of the C(1000, 3) choices of triplets from the 1000 values
|
|
|
|
-- has a probability of 1/(2^32)^2 of being a triple duplicate, so the
|
|
|
|
-- average number of triple duplicates is 1000 * 999 * 998 / 6 / 2^64, which
|
|
|
|
-- is roughly 9e-12.)
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random(-2147483648, 2147483647) r
|
|
|
|
FROM generate_series(1, 1000)) ss
|
|
|
|
GROUP BY r HAVING count(*) > 2;
|
|
|
|
r | count
|
|
|
|
---+-------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
-- There should be no duplicates in 1000 full-range 64-bit random() values.
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random_normal(-9223372036854775808, 9223372036854775807) r
|
|
|
|
FROM generate_series(1, 1000)) ss
|
|
|
|
GROUP BY r HAVING count(*) > 1;
|
|
|
|
r | count
|
|
|
|
---+-------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
-- There should be no duplicates in 1000 15-digit random() numeric values.
|
|
|
|
SELECT r, count(*)
|
|
|
|
FROM (SELECT random_normal(0, 1 - 1e-15) r
|
|
|
|
FROM generate_series(1, 1000)) ss
|
|
|
|
GROUP BY r HAVING count(*) > 1;
|
|
|
|
r | count
|
|
|
|
---+-------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
-- Expect at least one out of 2000 random values to be in the lowest and
|
|
|
|
-- highest 1% of the range.
|
|
|
|
SELECT (count(*) FILTER (WHERE r < -2104533975)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 2104533974)) > 0 AS has_large
|
|
|
|
FROM (SELECT random(-2147483648, 2147483647) r FROM generate_series(1, 2000)) ss;
|
|
|
|
has_small | has_large
|
|
|
|
-----------+-----------
|
|
|
|
t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) FILTER (WHERE r < -1500000000 OR r > 1500000000) AS out_of_range,
|
|
|
|
(count(*) FILTER (WHERE r < -1470000000)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 1470000000)) > 0 AS has_large
|
|
|
|
FROM (SELECT random(-1500000000, 1500000000) r FROM generate_series(1, 2000)) ss;
|
|
|
|
out_of_range | has_small | has_large
|
|
|
|
--------------+-----------+-----------
|
|
|
|
0 | t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT (count(*) FILTER (WHERE r < -9038904596117680292)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 9038904596117680291)) > 0 AS has_large
|
|
|
|
FROM (SELECT random(-9223372036854775808, 9223372036854775807) r
|
|
|
|
FROM generate_series(1, 2000)) ss;
|
|
|
|
has_small | has_large
|
|
|
|
-----------+-----------
|
|
|
|
t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) FILTER (WHERE r < -1500000000000000 OR r > 1500000000000000) AS out_of_range,
|
|
|
|
(count(*) FILTER (WHERE r < -1470000000000000)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 1470000000000000)) > 0 AS has_large
|
|
|
|
FROM (SELECT random(-1500000000000000, 1500000000000000) r
|
|
|
|
FROM generate_series(1, 2000)) ss;
|
|
|
|
out_of_range | has_small | has_large
|
|
|
|
--------------+-----------+-----------
|
|
|
|
0 | t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) FILTER (WHERE r < -1.5 OR r > 1.5) AS out_of_range,
|
|
|
|
(count(*) FILTER (WHERE r < -1.47)) > 0 AS has_small,
|
|
|
|
(count(*) FILTER (WHERE r > 1.47)) > 0 AS has_large
|
|
|
|
FROM (SELECT random(-1.500000000000000, 1.500000000000000) r
|
|
|
|
FROM generate_series(1, 2000)) ss;
|
|
|
|
out_of_range | has_small | has_large
|
|
|
|
--------------+-----------+-----------
|
|
|
|
0 | t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- Every possible value should occur at least once in 2500 random() values
|
|
|
|
-- chosen from a range with 100 distinct values.
|
|
|
|
SELECT min(r), max(r), count(r) FROM (
|
|
|
|
SELECT DISTINCT random(-50, 49) r FROM generate_series(1, 2500));
|
|
|
|
min | max | count
|
|
|
|
-----+-----+-------
|
|
|
|
-50 | 49 | 100
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT min(r), max(r), count(r) FROM (
|
|
|
|
SELECT DISTINCT random(123000000000, 123000000099) r
|
|
|
|
FROM generate_series(1, 2500));
|
|
|
|
min | max | count
|
|
|
|
--------------+--------------+-------
|
|
|
|
123000000000 | 123000000099 | 100
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT min(r), max(r), count(r) FROM (
|
|
|
|
SELECT DISTINCT random(-0.5, 0.49) r FROM generate_series(1, 2500));
|
|
|
|
min | max | count
|
|
|
|
-------+------+-------
|
|
|
|
-0.50 | 0.49 | 100
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- Check for uniform distribution using the Kolmogorov-Smirnov test.
|
|
|
|
CREATE FUNCTION ks_test_uniform_random_int_in_range()
|
|
|
|
RETURNS boolean AS
|
|
|
|
$$
|
|
|
|
DECLARE
|
|
|
|
n int := 1000; -- Number of samples
|
|
|
|
c float8 := 1.94947; -- Critical value for 99.9% confidence
|
|
|
|
ok boolean;
|
|
|
|
BEGIN
|
|
|
|
ok := (
|
|
|
|
WITH samples AS (
|
|
|
|
SELECT random(0, 999999) / 1000000.0 r FROM generate_series(1, n) ORDER BY 1
|
|
|
|
), indexed_samples AS (
|
|
|
|
SELECT (row_number() OVER())-1.0 i, r FROM samples
|
|
|
|
)
|
|
|
|
SELECT max(abs(i/n-r)) < c / sqrt(n) FROM indexed_samples
|
|
|
|
);
|
|
|
|
RETURN ok;
|
|
|
|
END
|
|
|
|
$$
|
|
|
|
LANGUAGE plpgsql;
|
|
|
|
SELECT ks_test_uniform_random_int_in_range() OR
|
|
|
|
ks_test_uniform_random_int_in_range() OR
|
|
|
|
ks_test_uniform_random_int_in_range() AS uniform_int;
|
|
|
|
uniform_int
|
|
|
|
-------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
CREATE FUNCTION ks_test_uniform_random_bigint_in_range()
|
|
|
|
RETURNS boolean AS
|
|
|
|
$$
|
|
|
|
DECLARE
|
|
|
|
n int := 1000; -- Number of samples
|
|
|
|
c float8 := 1.94947; -- Critical value for 99.9% confidence
|
|
|
|
ok boolean;
|
|
|
|
BEGIN
|
|
|
|
ok := (
|
|
|
|
WITH samples AS (
|
|
|
|
SELECT random(0, 999999999999) / 1000000000000.0 r FROM generate_series(1, n) ORDER BY 1
|
|
|
|
), indexed_samples AS (
|
|
|
|
SELECT (row_number() OVER())-1.0 i, r FROM samples
|
|
|
|
)
|
|
|
|
SELECT max(abs(i/n-r)) < c / sqrt(n) FROM indexed_samples
|
|
|
|
);
|
|
|
|
RETURN ok;
|
|
|
|
END
|
|
|
|
$$
|
|
|
|
LANGUAGE plpgsql;
|
|
|
|
SELECT ks_test_uniform_random_bigint_in_range() OR
|
|
|
|
ks_test_uniform_random_bigint_in_range() OR
|
|
|
|
ks_test_uniform_random_bigint_in_range() AS uniform_bigint;
|
|
|
|
uniform_bigint
|
|
|
|
----------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
CREATE FUNCTION ks_test_uniform_random_numeric_in_range()
|
|
|
|
RETURNS boolean AS
|
|
|
|
$$
|
|
|
|
DECLARE
|
|
|
|
n int := 1000; -- Number of samples
|
|
|
|
c float8 := 1.94947; -- Critical value for 99.9% confidence
|
|
|
|
ok boolean;
|
|
|
|
BEGIN
|
|
|
|
ok := (
|
|
|
|
WITH samples AS (
|
|
|
|
SELECT random(0, 0.999999) r FROM generate_series(1, n) ORDER BY 1
|
|
|
|
), indexed_samples AS (
|
|
|
|
SELECT (row_number() OVER())-1.0 i, r FROM samples
|
|
|
|
)
|
|
|
|
SELECT max(abs(i/n-r)) < c / sqrt(n) FROM indexed_samples
|
|
|
|
);
|
|
|
|
RETURN ok;
|
|
|
|
END
|
|
|
|
$$
|
|
|
|
LANGUAGE plpgsql;
|
|
|
|
SELECT ks_test_uniform_random_numeric_in_range() OR
|
|
|
|
ks_test_uniform_random_numeric_in_range() OR
|
|
|
|
ks_test_uniform_random_numeric_in_range() AS uniform_numeric;
|
|
|
|
uniform_numeric
|
|
|
|
-----------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
2023-01-10 02:30:25 +01:00
|
|
|
-- setseed() should produce a reproducible series of random() values.
|
|
|
|
SELECT setseed(0.5);
|
|
|
|
setseed
|
|
|
|
---------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT random() FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
---------------------
|
|
|
|
0.9851677175347999
|
|
|
|
0.825301858027981
|
|
|
|
0.12974610012450416
|
|
|
|
0.16356291958601088
|
|
|
|
0.6476186144084
|
|
|
|
0.8822771983038762
|
|
|
|
0.1404566845227775
|
|
|
|
0.15619865764623442
|
|
|
|
0.5145227426983392
|
|
|
|
0.7712969548127826
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
-- Likewise for random_normal(); however, since its implementation relies
|
|
|
|
-- on libm functions that have different roundoff behaviors on different
|
|
|
|
-- machines, we have to round off the results a bit to get consistent output.
|
2023-01-10 04:44:16 +01:00
|
|
|
SET extra_float_digits = -1;
|
2023-01-10 02:30:25 +01:00
|
|
|
SELECT random_normal() FROM generate_series(1, 10);
|
2023-01-10 04:44:16 +01:00
|
|
|
random_normal
|
|
|
|
-------------------
|
|
|
|
0.20853464493838
|
|
|
|
0.26453024054096
|
|
|
|
-0.60675246790043
|
|
|
|
0.82579942785265
|
|
|
|
1.7011161173536
|
|
|
|
-0.22344546371619
|
|
|
|
0.249712419191
|
|
|
|
-1.2494722990669
|
|
|
|
0.12562715204368
|
|
|
|
0.47539161454401
|
2023-01-10 02:30:25 +01:00
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random_normal(mean => 1, stddev => 0.1) r FROM generate_series(1, 10);
|
2023-01-10 04:44:16 +01:00
|
|
|
r
|
|
|
|
------------------
|
|
|
|
1.0060597281173
|
|
|
|
1.09685453015
|
|
|
|
1.0286920613201
|
|
|
|
0.90947567671234
|
|
|
|
0.98372476313426
|
|
|
|
0.93934454957762
|
|
|
|
1.1871350020636
|
|
|
|
0.96225768429293
|
|
|
|
0.91444120680041
|
|
|
|
0.96403105557543
|
2023-01-10 02:30:25 +01:00
|
|
|
(10 rows)
|
2023-01-09 18:44:00 +01:00
|
|
|
|
Add functions to generate random numbers in a specified range.
This adds 3 new variants of the random() function:
random(min integer, max integer) returns integer
random(min bigint, max bigint) returns bigint
random(min numeric, max numeric) returns numeric
Each returns a random number x in the range min <= x <= max.
For the numeric function, the number of digits after the decimal point
is equal to the number of digits that "min" or "max" has after the
decimal point, whichever has more.
The main entry points for these functions are in a new C source file.
The existing random(), random_normal(), and setseed() functions are
moved there too, so that they can all share the same PRNG state, which
is kept private to that file.
Dean Rasheed, reviewed by Jian He, David Zhang, Aleksander Alekseev,
and Tomas Vondra.
Discussion: https://postgr.es/m/CAEZATCV89Vxuq93xQdmc0t-0Y2zeeNQTdsjbmV7dyFBPykbV4Q@mail.gmail.com
2024-03-27 11:12:39 +01:00
|
|
|
-- Reproducible random(min, max) values.
|
|
|
|
SELECT random(1, 6) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
--------
|
|
|
|
5
|
|
|
|
4
|
|
|
|
5
|
|
|
|
1
|
|
|
|
6
|
|
|
|
1
|
|
|
|
1
|
|
|
|
3
|
|
|
|
6
|
|
|
|
5
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random(-2147483648, 2147483647) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
-------------
|
|
|
|
-84380014
|
|
|
|
1287883594
|
|
|
|
-1927252904
|
|
|
|
13516867
|
|
|
|
-1902961616
|
|
|
|
-1824286201
|
|
|
|
-871264469
|
|
|
|
-1225880415
|
|
|
|
229836730
|
|
|
|
-116039023
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random(-9223372036854775808, 9223372036854775807) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
----------------------
|
|
|
|
-6205280962992680052
|
|
|
|
-3583519428011353337
|
|
|
|
511801786318122700
|
|
|
|
4672737727839409655
|
|
|
|
-6674868801536280768
|
|
|
|
-7816052100626646489
|
|
|
|
-4340613370136007199
|
|
|
|
-5873174504107419786
|
|
|
|
-2249910101649817824
|
|
|
|
-4493828993910792325
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random(-1e30, 1e30) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
---------------------------------
|
|
|
|
-732116469803315942112255539315
|
|
|
|
794641423514877972798449289857
|
|
|
|
-576932746026123093304638334719
|
|
|
|
420625067723533225139761854757
|
|
|
|
-339227806779403187811001078919
|
|
|
|
-77667951539418104959241732636
|
|
|
|
239810941795708162629328071599
|
|
|
|
820784371155896967052141946697
|
|
|
|
-377084684544126871150439048352
|
|
|
|
-979773225250716295007225086726
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random(-0.4, 0.4) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
--------
|
|
|
|
0.1
|
|
|
|
0.0
|
|
|
|
0.4
|
|
|
|
-0.2
|
|
|
|
0.1
|
|
|
|
0.2
|
|
|
|
0.3
|
|
|
|
0.0
|
|
|
|
-0.2
|
|
|
|
0.2
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT random(0, 1 - 1e-30) FROM generate_series(1, 10);
|
|
|
|
random
|
|
|
|
----------------------------------
|
|
|
|
0.676442053784930109917469287265
|
|
|
|
0.221310454098356723569995592911
|
|
|
|
0.060101338174419259555193956224
|
|
|
|
0.509960354695248239243002172364
|
|
|
|
0.248680813394555793693952296993
|
|
|
|
0.353262552880008646603494668901
|
|
|
|
0.760692600450339509843044233719
|
|
|
|
0.554987655310094483449494782510
|
|
|
|
0.330890988458592995280347745733
|
|
|
|
0.665435298280470361228607881507
|
|
|
|
(10 rows)
|
|
|
|
|
|
|
|
SELECT n, random(0, trim_scale(abs(1 - 10.0^(-n)))) FROM generate_series(-20, 20) n;
|
|
|
|
n | random
|
|
|
|
-----+------------------------
|
|
|
|
-20 | 94174615760837282445
|
|
|
|
-19 | 6692559888531296894
|
|
|
|
-18 | 801114552709125931
|
|
|
|
-17 | 44091460959939971
|
|
|
|
-16 | 2956109297383113
|
|
|
|
-15 | 783332278684523
|
|
|
|
-14 | 81534303241440
|
|
|
|
-13 | 2892623140500
|
|
|
|
-12 | 269397605141
|
|
|
|
-11 | 13027512296
|
|
|
|
-10 | 9178377775
|
|
|
|
-9 | 323534150
|
|
|
|
-8 | 91897803
|
|
|
|
-7 | 6091383
|
|
|
|
-6 | 13174
|
|
|
|
-5 | 92714
|
|
|
|
-4 | 8079
|
|
|
|
-3 | 429
|
|
|
|
-2 | 30
|
|
|
|
-1 | 3
|
|
|
|
0 | 0
|
|
|
|
1 | 0.1
|
|
|
|
2 | 0.69
|
|
|
|
3 | 0.492
|
|
|
|
4 | 0.7380
|
|
|
|
5 | 0.77078
|
|
|
|
6 | 0.738142
|
|
|
|
7 | 0.1808815
|
|
|
|
8 | 0.14908933
|
|
|
|
9 | 0.222654042
|
|
|
|
10 | 0.2281295170
|
|
|
|
11 | 0.73655782966
|
|
|
|
12 | 0.056357256884
|
|
|
|
13 | 0.8998407524375
|
|
|
|
14 | 0.28198400530206
|
|
|
|
15 | 0.713478222805230
|
|
|
|
16 | 0.0415046850936909
|
|
|
|
17 | 0.45946350291315119
|
|
|
|
18 | 0.310966980367873753
|
|
|
|
19 | 0.4967623661709676512
|
|
|
|
20 | 0.60795101234744211935
|
|
|
|
(41 rows)
|
|
|
|
|