NumHask.Space

A continuous set of numbers.

Mathematics does not define a space, leaving library devs to experiment.

https://en.wikipedia.org/wiki/Space_(mathematics)

Space

The final frontier.

class Space s where

Space is a continuous range of numbers that contains elements and has an upper and lower value.

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

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

the intersection of two spaces

union :: s -> s -> s

the union of two spaces

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

the union of two spaces

norm :: 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

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

create a normalised space from two elements

(>.<) :: 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

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

is an element in the space

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

is one space completely above the other

(|>|) :: Ord (Element s) => s -> s -> Bool infixl 7

is one space completely above the other

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

is one space completely below the other

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

is one space completely below the other

Instances

(Eq a, Ord a) => Space (Range a)

Defined in NumHask.Space.Range

Associated Types

type Element (Range a) :: Type

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

norm :: 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) :: Type

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

norm :: 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

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

Associated Types

type Grid s :: Type

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

FieldSpace (Range Double)

Defined in NumHask.Space.Range

Associated Types

type Grid (Range Double) :: Type

Methods

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

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

FieldSpace (Rect Double)

Defined in NumHask.Space.Rect

Associated Types

type Grid (Rect Double) :: Type

Methods

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

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

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

middle element of the space

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

project a data point 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

Eq Pos

Defined in NumHask.Space.Types

Methods

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

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

Show Pos

Defined in NumHask.Space.Types

Methods

showsPrec :: Int -> Pos -> ShowS

show :: Pos -> String

showList :: [Pos] -> ShowS

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

the containing space of a non-empty Traversable

all $ space1 a `contains` <$> a

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), Field (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)

Instances

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

• A Range is a Space of numbers.
• A Rect is a Space of Points.
• A time span is a space containing moments of time.
• A histogram is a divided Range with a count of elements within each division.

module NumHask.Space.Point

module NumHask.Space.Range

module NumHask.Space.Rect

module NumHask.Space.Time

module NumHask.Space.Histogram

module NumHask.Space.XY