f-dimensional intervals with coordinates in a.

Access the infimum of an interval.

Access the supremum of an interval.

Construct a square interval in f dimensions from the given coordinates.

>>> 0...1 :: Interval Identity Int
Identity 0...Identity 1

>>> 0...1 :: Interval V2 Int
V2 0 0...V2 1 1

Construct a point (or degenerate) interval from the given endpoint.

>>> point (V2 0 1)
V2 0 1...V2 0 1

Compute the diameter of an interval, in f dimensions, defined as the absolute difference between the endpoints.

Note that the diameter of closed point intervals is zero, so this is not the interval’s cardinality.

Compute the midpoint of an interval, halfway between the endpoints.

midpoint (point x) = x

Apply a function to the endpoints of an interval.

>>> uncurryI (,) (Interval a b)
(a, b)

Lift a function over the coordinates in each dimension of f.

>>> liftI (+) (Interval (V2 1 2) (V2 3 4))
V2 4 6

Enumerate the points in f between the interval’s endpoints.

>>> enum (0...1 :: Interval Identity Int)
[Identity 0, Identity 1]

Enumerate the coordinates in a between the interval’s endpoints along each dimension of f.

>>> liftEnum (Interval (V2 1 2) (V2 1 3))
V2 [1] [2, 3]

Linearly transform a point in f from a non-point interval of f to the unit interval.

toUnit = (`transform` 0...1)

toUnit i . fromUnit i = id

Linearly transform a point in f from the unit interval to an interval of f.

fromUnit = transform (0...1)

fromUnit i . toUnit i = id

Transform a point linearly between the subspaces described by non-point intervals.

transform i j (inf i) = inf j

transform i j (midpoint i) = midpoint j

transform i j (sup i) = sup j

transform i i = id

transform i j . transform j i = id

transform (0...1) = fromUnit

(`transform` 0...1) = toUnit

Linearly interpolate between the endpoints of an interval.

lerp 0 = inf

lerp 0.5 = midpoint

lerp 1 = sup

lerp t i = fromUnit i (pure t)

Clamp a point in f to the given interval, wrapping out-of-bounds values around.

e.g. to wrap angles in radians to the interval [-pi, pi]:

>>> wrap (-pi...pi) (pi + x)
Identity (-pi + x)

wrap i (lerp t i) = lerp (snd (properFraction t)) i

Map and fold over an interval’s endpoints.

Where foldMap only folds over the individual coordinates, foldMapInterval can interpret the structure of the space as well.

>>> foldMapInterval (\ p -> [p]) (Interval a b)
[a, b]

foldMap f = foldMapInterval (foldMap f)

Map over an interval’s endpoints.

Where fmap only maps over the individual coordinates, mapInterval can change the space as well.

>>> mapInterval (\ (V2 x y) -> V3 x y 0) (Interval (V2 1 2) (V2 3 4))
V3 1 2 0...V3 3 4 0

fmap f = mapInterval (fmap f)

Traverse over an interval’s endpoints.

Where traverse only traverses over the individual coordinates, traverseInterval can change the space as well.

>>> :t traverseInterval (\ (V2 x y) -> V3 x y)
traverseInterval (\ (V2 x y) -> V3 x y) :: Interval V2 a -> a -> Interval V3 a

>>> traverseInterval (\ (V2 x y) -> V3 x y) (Interval (V2 1 2) (V2 3 4)) 0
V3 1 2 0...V3 3 4 0

traverse f = traverseInterval (traverse f)

foldMapInterval f ≅ getConst . traverseInterval (Const . f)

mapInterval f = runIdentity . traverseInterval (Identity . f)

Test a point for inclusion within an interval.

Test an interval for validity, i.e. non-emptiness.

Test an interval for validity, i.e. non-emptiness.

Test whether an interval is a singleton.

Test whether one interval is a subinterval of another.

i `isSubintervalOf` i = True

i `isSubintervalOf` j && j `isSubintervalOf` k => i `isSubintervalOf` k

Test whether one interval is a superinterval of another.

i `isSuperintervalOf` i = True

i `isSuperintervalOf` j && j `isSuperintervalOf` k => i `isSuperintervalOf` k

Test whether one interval is a proper subinterval of another (i.e. a subinterval, but not equal).

i `isProperSubintervalOf` i = False

i `isProperSubintervalOf` j && j `isProperSubintervalOf` k => i `isProperSubintervalOf` k

Test whether one interval is a proper superinterval of another (i.e. a superinterval, but not equal).

i `isProperSuperintervalOf` i = False

i `isProperSuperintervalOf` j && j `isProperSuperintervalOf` k => i `isProperSuperintervalOf` k

Test whether two intervals intersect.

i `intersects` i = True

i `intersects` j = j `intersects` i

Intervals form a Semigroup under the union.

Take the union of two intervals.

This is equivalent to the Semigroup instance for Interval (and for Union), and is provided for clarity and convenience.

Intervals form a Semigroup under intersection.

Take the intersection of two intervals.

This is equivalent to the Semigroup instance for Intersection, and is provided for clarity and convenience.