NumHask.Space

Mathematics does not rigorously define a space, leaving library devs free to explore.

“But who can quantify the algebra of space, or weigh those worlds that swim each in its place? Who can outdo the dark? And what computer knows how beauty comes to birth - shell star and rose?

~ Technicians by Jean Kenward” ~ John Foster

Usage

>>> :m -Prelude
>>> :set -XRebindableSyntax
>>> import NumHask.Prelude
>>> import NumHask.Space
>>> Point 1 1
Point 1 1

>>> one :: Range Double
Range -0.5 0.5

>>> grid OuterPos (Range 0 50 :: Range Double) 5
[0.0,10.0,20.0,30.0,40.0,50.0]

Space

Space is an interesting cross-section of many programming domains.

• A Range is a Space of numbers.
• A Rect is a Space of Points. It can also be a Space of Rects (but this is not yet coded up here).
• A time span is a Space containing moments of time.
• A Histogram is a divided Range with a count of elements within each division.

class Space s where

A Space is a continuous set of numbers. Continuous here means that the set has an upper and lower bound, and an element that is between these two bounds is a member of the Space.

a `union` b == b `union` a
a `intersection` b == b `intersection` a
(a `union` b) `intersection` c == (a `intersection` b) `union` (a `intersection` c)
(a `intersection` b) `union` c == (a `union` b) `intersection` (a `union` c)
norm (norm a) = norm a
a |>| b == b |<| a
a |.| singleton a

Minimal complete definition

lower, upper, (>.<)

Associated Types

type Element s :: Type

the underlying element in the space

Methods

lower :: s -> Element s

lower boundary

upper :: s -> Element s

upper boundary

singleton :: Element s -> s

space containing a single element

intersection :: s -> s -> s

the intersection of two spaces

default intersection :: Ord (Element s) => s -> s -> s

union :: s -> s -> s

the union of two spaces

default union :: Ord (Element s) => s -> s -> s

normalise :: s -> s

Normalise a space so that

lower a \/ upper a == lower a
lower a /\ upper a == upper a

(...) :: Element s -> Element s -> s infix 3

create a normalised space from two elements

default (...) :: Ord (Element s) => Element s -> Element s -> s

(>.<) :: Element s -> Element s -> s infix 3

create a space from two elements without normalising

(|.|) :: Element s -> s -> Bool infixl 7

is an element in the space

default (|.|) :: Ord (Element s) => Element s -> s -> Bool

(|>|) :: s -> s -> Bool infixl 7

is one space completely above the other

default (|>|) :: Ord (Element s) => s -> s -> Bool

(|<|) :: s -> s -> Bool infixl 7

is one space completely below the other

default (|<|) :: Ord (Element s) => s -> s -> Bool

Instances

Ord a => Space (Range a)

Defined in NumHask.Space.Range

Associated Types

type Element (Range a)

Methods

lower :: Range a -> Element (Range a)

upper :: Range a -> Element (Range a)

singleton :: Element (Range a) -> Range a

intersection :: Range a -> Range a -> Range a

union :: Range a -> Range a -> Range a

normalise :: Range a -> Range a

(...) :: Element (Range a) -> Element (Range a) -> Range a

(>.<) :: Element (Range a) -> Element (Range a) -> Range a

(|.|) :: Element (Range a) -> Range a -> Bool

(|>|) :: Range a -> Range a -> Bool

(|<|) :: Range a -> Range a -> Bool

Ord a => Space (Rect a)

Defined in NumHask.Space.Rect

Associated Types

type Element (Rect a)

Methods

lower :: Rect a -> Element (Rect a)

upper :: Rect a -> Element (Rect a)

singleton :: Element (Rect a) -> Rect a

intersection :: Rect a -> Rect a -> Rect a

union :: Rect a -> Rect a -> Rect a

normalise :: Rect a -> Rect a

(...) :: Element (Rect a) -> Element (Rect a) -> Rect a

(>.<) :: Element (Rect a) -> Element (Rect a) -> Rect a

(|.|) :: Element (Rect a) -> Rect a -> Bool

(|>|) :: Rect a -> Rect a -> Bool

(|<|) :: Rect a -> Rect a -> Bool

newtype Union a

a convex hull

Constructors

Union

Fields

• getUnion :: a

Instances

Space a => Semigroup (Union a)

Defined in NumHask.Space.Types

Methods

(<>) :: Union a -> Union a -> Union a

sconcat :: NonEmpty (Union a) -> Union a

stimes :: Integral b => b -> Union a -> Union a

newtype Intersection a

https://en.wikipedia.org/wiki/Intersection_(set_theory)

Constructors

Intersection

Fields

• getIntersection :: a

Instances

Space a => Semigroup (Intersection a)

Defined in NumHask.Space.Types

Methods

(<>) :: Intersection a -> Intersection a -> Intersection a

sconcat :: NonEmpty (Intersection a) -> Intersection a

stimes :: Integral b => b -> Intersection a -> Intersection a

class (Space s, Field (Element s)) => FieldSpace s where

a space that can be divided neatly

unsafeSpace1 (grid OuterPos s g) == s
getUnion (sconcat (Union <$> (gridSpace s g))) == s

Associated Types

type Grid s :: Type

the type that divides or quotients the space

Methods

grid :: Pos -> s -> Grid s -> [Element s]

create equally-spaced elements across a space

gridSpace :: s -> Grid s -> [s]

create equally-spaced spaces from a space

Instances

(Field a, Ord a, FromIntegral a Int) => FieldSpace (Range a)

Defined in NumHask.Space.Range

Associated Types

type Grid (Range a)

Methods

grid :: Pos -> Range a -> Grid (Range a) -> [Element (Range a)]

gridSpace :: Range a -> Grid (Range a) -> [Range a]

(FromIntegral a Int, Field a, Ord a) => FieldSpace (Rect a)

Defined in NumHask.Space.Rect

Associated Types

type Grid (Rect a)

Methods

grid :: Pos -> Rect a -> Grid (Rect a) -> [Element (Rect a)]

gridSpace :: Rect a -> Grid (Rect a) -> [Rect a]

mid :: (Space s, Field (Element s)) => s -> Element s

middle element of the space

interpolate :: (Space s, Ring (Element s)) => s -> Element s -> Element s

interpolate a space

interpolate s x == project s (zero ... one) x

project :: (Space s, Field (Element s)) => s -> s -> Element s -> Element s

project an element from one space to another, preserving relative position.

project o n (lower o) = lower n
project o n (upper o) = upper n
project o n (mid o) = mid n
project a a x = x

data Pos

Pos suggests where points should be placed in forming a grid across a field space.

Constructors

OuterPos

include boundaries

InnerPos

don't include boundaries

LowerPos

include the lower boundary

UpperPos

include the upper boundary

MidPos

use the mid-point of the space

Instances

Show Pos

Defined in NumHask.Space.Types

Methods

showsPrec :: Int -> Pos -> ShowS

show :: Pos -> String

showList :: [Pos] -> ShowS

Eq Pos

Defined in NumHask.Space.Types

Methods

(==) :: Pos -> Pos -> Bool

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

space1 :: (Space s, Traversable f) => f (Element s) -> Maybe s

Maybe containing space of a traversable.

unsafeSpace1 :: (Space s, Traversable f) => f (Element s) -> s

the containing space of a non-empty Traversable.

partial function.

all $ unsafeSpace1 a `contains` <$> a

randomS :: (Space s, RandomGen g, UniformRange (Element s)) => s -> g -> (Element s, g)

supply a random element within a Space

>>> randomS (one :: Range Double) g
(0.43085240252163404,StdGen {unStdGen = SMGen 4530528345362647137 13679457532755275413})

randomSM :: (UniformRange (Element s), StatefulGen g m, Space s) => s -> g -> m (Element s)

StatefulGen version of randomS

>>> import Control.Monad
>>> runStateGen_ g (randomSM (one :: Range Double))
0.43085240252163404

randomSs :: (Space s, RandomGen g, UniformRange (Element s)) => Int -> s -> g -> ([Element s], g)

list of n random elements within a Space

>>> let g = mkStdGen 42
>>> fst (randomSs 3 (one :: Range Double) g)
[0.43085240252163404,-6.472345419562497e-2,0.3854692674681801]

>>> fst (randomSs 3 (Rect 0 10 0 10 :: Rect Int) g)
[Point 0 7,Point 0 2,Point 1 7]

memberOf :: Space s => Element s -> s -> Bool

is an element contained within a space

contains :: Space s => s -> s -> Bool

is a space contained within another?

(a `union` b) `contains` a
(a `union` b) `contains` b

disjoint :: Space s => s -> s -> Bool

are two spaces disjoint?

width :: (Space s, Subtractive (Element s)) => s -> Element s

distance between boundaries

(+/-) :: (Space s, Subtractive (Element s)) => Element s -> Element s -> s infixl 6

create a space centered on a plus or minus b

monotone :: (Space a, Space b) => (Element a -> Element b) -> a -> b

lift a monotone function (increasing or decreasing) over a given space

eps :: (Space s, FromRational (Element s), Field (Element s)) => Element s -> Element s -> s

a small space

widen :: (Space s, Ring (Element s)) => Element s -> s -> s

widen a space

widenEps :: (Space s, FromRational (Element s), Ring (Element s)) => Element s -> s -> s

widen by a small amount

scale :: (Multiplicative (Element s), Space s) => Element s -> s -> s

Scale a Space. (scalar multiplication)

move :: (Additive (Element s), Space s) => Element s -> s -> s

Move a Space. (scalar addition)

data Transform a

linear transform + translate of a point-like number

(x, y) -> (ax + by + c, dx + ey + d)

or

\[ \begin{pmatrix} a & b & c\\ d & e & f\\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} x\\ y\\ 1 \end{pmatrix} \]

Constructors

Transform

Fields

• ta :: !a
• tb :: !a
• tc :: !a
• td :: !a
• te :: !a
• tf :: !a

Instances

Foldable Transform

Defined in NumHask.Space.Types

Methods

fold :: Monoid m => Transform m -> m

foldMap :: Monoid m => (a -> m) -> Transform a -> m

foldMap' :: Monoid m => (a -> m) -> Transform a -> m

foldr :: (a -> b -> b) -> b -> Transform a -> b

foldr' :: (a -> b -> b) -> b -> Transform a -> b

foldl :: (b -> a -> b) -> b -> Transform a -> b

foldl' :: (b -> a -> b) -> b -> Transform a -> b

foldr1 :: (a -> a -> a) -> Transform a -> a

foldl1 :: (a -> a -> a) -> Transform a -> a

toList :: Transform a -> [a]

null :: Transform a -> Bool

length :: Transform a -> Int

elem :: Eq a => a -> Transform a -> Bool

maximum :: Ord a => Transform a -> a

minimum :: Ord a => Transform a -> a

sum :: Num a => Transform a -> a

product :: Num a => Transform a -> a

Traversable Transform

Defined in NumHask.Space.Types

Methods

traverse :: Applicative f => (a -> f b) -> Transform a -> f (Transform b)

sequenceA :: Applicative f => Transform (f a) -> f (Transform a)

mapM :: Monad m => (a -> m b) -> Transform a -> m (Transform b)

sequence :: Monad m => Transform (m a) -> m (Transform a)

Functor Transform

Defined in NumHask.Space.Types

Methods

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

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

Show a => Show (Transform a)

Defined in NumHask.Space.Types

Methods

showsPrec :: Int -> Transform a -> ShowS

show :: Transform a -> String

showList :: [Transform a] -> ShowS

Eq a => Eq (Transform a)

Defined in NumHask.Space.Types

Methods

(==) :: Transform a -> Transform a -> Bool

(/=) :: Transform a -> Transform a -> Bool

(Multiplicative a, Additive a) => Affinity (Transform a) a

Defined in NumHask.Space.Types

Methods

transform :: Transform a -> Transform a -> Transform a

inverseTransform :: (Eq a, Field a) => Transform a -> Maybe (Transform a)

Calculate the inverse of a transformation.

class Affinity a b | a -> b where

An Affinity is something that can be subjected to an affine transformation in 2-dimensional space, where affine means a linear matrix operation or a translation (+).

https://en.wikipedia.org/wiki/Affine_transformation

Methods

transform :: Transform b -> a -> a

Instances

(Multiplicative a, Additive a) => Affinity (Line a) a

Defined in NumHask.Space.Point

Methods

transform :: Transform a -> Line a -> Line a

(Multiplicative a, Additive a) => Affinity (Point a) a

Defined in NumHask.Space.Point

Methods

transform :: Transform a -> Point a -> Point a

(Multiplicative a, Additive a) => Affinity (Transform a) a

Defined in NumHask.Space.Types

Methods

transform :: Transform a -> Transform a -> Transform a

(|.) :: Affinity a b => Transform b -> a -> a infix 3

Apply a Transform to an Affinity

rotate :: TrigField a => a -> Transform a

Rotate an Affinity (counter-clockwise)

Instances

module NumHask.Space.Point

module NumHask.Space.Range

module NumHask.Space.Rect

module NumHask.Space.Time

module NumHask.Space.Histogram