Savage.Internal.Range

Size

newtype Size

Tests are parameterized by the size of the randomly-generated data, the meaning of which depends on the particular generator used.

Constructors

Size

Fields

• unSize :: Int

Instances

Enum Size

Methods

succ :: Size -> Size

pred :: Size -> Size

toEnum :: Int -> Size

fromEnum :: Size -> Int

enumFrom :: Size -> [Size]

enumFromThen :: Size -> Size -> [Size]

enumFromTo :: Size -> Size -> [Size]

enumFromThenTo :: Size -> Size -> Size -> [Size]

Eq Size

Methods

(==) :: Size -> Size -> Bool

(/=) :: Size -> Size -> Bool

Integral Size

Methods

quot :: Size -> Size -> Size

rem :: Size -> Size -> Size

div :: Size -> Size -> Size

mod :: Size -> Size -> Size

quotRem :: Size -> Size -> (Size, Size)

divMod :: Size -> Size -> (Size, Size)

toInteger :: Size -> Integer

Num Size

Methods

(+) :: Size -> Size -> Size

(-) :: Size -> Size -> Size

(*) :: Size -> Size -> Size

negate :: Size -> Size

abs :: Size -> Size

signum :: Size -> Size

fromInteger :: Integer -> Size

Ord Size

Methods

compare :: Size -> Size -> Ordering

(<) :: Size -> Size -> Bool

(<=) :: Size -> Size -> Bool

(>) :: Size -> Size -> Bool

(>=) :: Size -> Size -> Bool

max :: Size -> Size -> Size

min :: Size -> Size -> Size

Read Size

Methods

readsPrec :: Int -> ReadS Size

readList :: ReadS [Size]

readPrec :: ReadPrec Size

readListPrec :: ReadPrec [Size]

Real Size

Methods

toRational :: Size -> Rational

Show Size

Methods

showsPrec :: Int -> Size -> ShowS

show :: Size -> String

showList :: [Size] -> ShowS

Range

data Range a

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

Constructors

Range !a (Size -> (a, a))

Instances

Functor Range

Methods

fmap :: (a -> b) -> Range a -> Range b

(<$) :: a -> Range b -> Range a

origin :: Range a -> a

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.

bounds :: Size -> Range a -> (a, a)

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

lowerBound :: Ord a => Size -> Range a -> a

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

upperBound :: Ord a => Size -> Range a -> a

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

Constant

singleton :: a -> Range a

Construct a range which represents a constant single value.

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

>>> origin $ singleton 5
5

constant :: a -> a -> Range a

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

constantFrom :: a -> a -> a -> Range a

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

constantBounded :: (Bounded a, Num a) => Range a

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

Linear

linear :: Integral a => a -> a -> Range a

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)

linearFrom :: Integral a => a -> a -> a -> Range a

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)

linearFrac :: (Fractional a, Ord a) => a -> a -> Range a

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

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

linearFracFrom :: (Fractional a, Ord a) => a -> a -> a -> Range a

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

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

linearBounded :: (Bounded a, Integral a) => Range a

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)

Exponential

exponential :: Integral a => a -> a -> Range a

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)

exponentialFrom :: Integral a => a -> a -> a -> Range a

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)

exponentialBounded :: (Bounded a, Integral a) => Range a

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)

exponentialFloat :: (Floating a, Ord a) => a -> a -> Range a

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)

exponentialFloatFrom :: (Floating a, Ord a) => a -> a -> a -> Range a

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)

Internal

These functions are exported in case you need them in a pinch, but are not part of the public API and may change at any time, even as part of a minor update.

clamp :: Ord a => a -> a -> a -> a

Truncate a value so it stays within some range.

>>> clamp 5 10 15
10

>>> clamp 5 10 0
5

scaleLinear :: Integral a => Size -> a -> a -> a

Scale an integral linearly with the size parameter.

scaleLinearFrac :: Fractional a => Size -> a -> a -> a

Scale a fractional number linearly with the size parameter.

scaleExponential :: Integral a => Size -> a -> a -> a

Scale an integral exponentially with the size parameter.

scaleExponentialFloat :: Floating a => Size -> a -> a -> a

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