Tests are parameterized by the size of the randomly-generated data. The meaning of a Size value depends on the particular generator used, but it must always be a number between 0 and 99 inclusive.

A range describes the bounds of a number to generate, which may or may not be dependent on a Size .

The constructor takes an origin between the lower and upper bound, and a function from Size to bounds. As the size goes towards 0 , the values go towards the origin.

Get the origin of a range. This might be the mid-point or the lower bound, depending on what the range represents.

The bounds of a range are scaled around this value when using the linear family of combinators.

When using a Range to generate numbers, the shrinking function will shrink towards the origin.

Get the extents of a range, for a given size.

Get the lower bound of a range for the given size.

Get the upper bound of a range for the given size.

Construct a range which represents a constant single value.

>>> bounds x $ singleton 5
(5,5)

>>> origin $ singleton 5
5

Construct a range which is unaffected by the size parameter.

A range from 0 to 10 , with the origin at 0 :

>>> bounds x $ constant 0 10
(0,10)

>>> origin $ constant 0 10
0

Construct a range which is unaffected by the size parameter with a origin point which may differ from the bounds.

A range from -10 to 10 , with the origin at 0 :

>>> bounds x $ constantFrom 0 (-10) 10
(-10,10)

>>> origin $ constantFrom 0 (-10) 10
0

A range from 1970 to 2100 , with the origin at 2000 :

>>> bounds x $ constantFrom 2000 1970 2100
(1970,2100)

>>> origin $ constantFrom 2000 1970 2100
2000

Construct a range which is unaffected by the size parameter using the full range of a data type.

A range from -128 to 127 , with the origin at 0 :

>>> bounds x (constantBounded :: Range Int8)
(-128,127)

>>> origin (constantBounded :: Range Int8)
0

Construct a range which scales the second bound relative to the size parameter.

>>> bounds 0 $ linear 0 10
(0,0)

>>> bounds 50 $ linear 0 10
(0,5)

>>> bounds 99 $ linear 0 10
(0,10)

Construct a range which scales the bounds relative to the size parameter.

>>> bounds 0 $ linearFrom 0 (-10) 10
(0,0)

>>> bounds 50 $ linearFrom 0 (-10) 20
(-5,10)

>>> bounds 99 $ linearFrom 0 (-10) 20
(-10,20)

Construct a range which scales the second bound relative to the size parameter.

This works the same as linear , but for fractional values.

Construct a range which scales the bounds relative to the size parameter.

This works the same as linearFrom , but for fractional values.

Construct a range which is scaled relative to the size parameter and uses the full range of a data type.

>>> bounds 0 (linearBounded :: Range Int8)
(0,0)

>>> bounds 50 (linearBounded :: Range Int8)
(-64,64)

>>> bounds 99 (linearBounded :: Range Int8)
(-128,127)

Construct a range which scales the second bound exponentially relative to the size parameter.

>>> bounds 0 $ exponential 1 512
(1,1)

>>> bounds 11 $ exponential 1 512
(1,2)

>>> bounds 22 $ exponential 1 512
(1,4)

>>> bounds 77 $ exponential 1 512
(1,128)

>>> bounds 88 $ exponential 1 512
(1,256)

>>> bounds 99 $ exponential 1 512
(1,512)

Construct a range which scales the bounds exponentially relative to the size parameter.

>>> bounds 0 $ exponentialFrom 0 (-128) 512
(0,0)

>>> bounds 25 $ exponentialFrom 0 (-128) 512
(-2,4)

>>> bounds 50 $ exponentialFrom 0 (-128) 512
(-11,22)

>>> bounds 75 $ exponentialFrom 0 (-128) 512
(-39,112)

>>> bounds 99 $ exponentialFrom x (-128) 512
(-128,512)

Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type.

>>> bounds 0 (exponentialBounded :: Range Int8)
(0,0)

>>> bounds 50 (exponentialBounded :: Range Int8)
(-11,11)

>>> bounds 99 (exponentialBounded :: Range Int8)
(-128,127)

Construct a range which scales the second bound exponentially relative to the size parameter.

This works the same as exponential , but for floating-point values.

>>> bounds 0 $ exponentialFloat 0 10
(0.0,0.0)

>>> bounds 50 $ exponentialFloat 0 10
(0.0,2.357035250656098)

>>> bounds 99 $ exponentialFloat 0 10
(0.0,10.0)

Construct a range which scales the bounds exponentially relative to the size parameter.

This works the same as exponentialFrom , but for floating-point values.

>>> bounds 0 $ exponentialFloatFrom 0 (-10) 20
(0.0,0.0)

>>> bounds 50 $ exponentialFloatFrom 0 (-10) 20
(-2.357035250656098,3.6535836249197002)

>>> bounds 99 $ exponentialFloatFrom x (-10) 20
(-10.0,20.0)

Truncate a value so it stays within some range.

>>> clamp 5 10 15
10

>>> clamp 5 10 0
5

Scale an integral linearly with the size parameter.

Scale a fractional number linearly with the size parameter.

Scale an integral exponentially with the size parameter.

Scale a floating-point number exponentially with the size parameter.