NumHask.Analysis.Space

Documentation

class Spaceable (Element s) => Space s where

a continuous set of numbers mathematics does not define a space, so library devs are free to experiment.

a `contains` union a b && b `contains` union a b
lower a \/ upper a == lower a
lower a /\ upper a == upper a

Minimal complete definition

lower, upper, (>.<)

Associated Types

type Element s :: *

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

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

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

create a space from two elements witjout normalising

Instances

Lattice a => Space (Range a)

Defined in NumHask.Data.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

Lattice a => Space (Rect a)

Defined in NumHask.Data.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

type Spaceable a = (Eq a, JoinSemiLattice a, MeetSemiLattice a)

newtype Union a

Constructors

Union

Fields

• getUnion :: a

Instances

Space a => Semigroup (Union a)

Defined in NumHask.Analysis.Space

Methods

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

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

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

(BoundedJoinSemiLattice a, Space a) => Monoid (Union a)

Defined in NumHask.Analysis.Space

Methods

mempty :: Union a

mappend :: Union a -> Union a -> Union a

mconcat :: [Union a] -> Union a

newtype Intersection a

Constructors

Intersection

Fields

• getIntersection :: a

Instances

Space a => Semigroup (Intersection a)

Defined in NumHask.Analysis.Space

Methods

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

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

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

(BoundedMeetSemiLattice a, Space a) => Monoid (Intersection a)

Defined in NumHask.Analysis.Space

Methods

mempty :: Intersection a

mappend :: Intersection a -> Intersection a -> Intersection a

mconcat :: [Intersection a] -> Intersection a

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

a space that can be divided neatly

Associated Types

type Grid s :: *

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

(Lattice a, Field a, Subtractive a, FromInteger a) => FieldSpace (Range a)

Defined in NumHask.Data.Range

Associated Types

type Grid (Range a) :: Type

Methods

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

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

(Lattice a, Field a, Subtractive a, FromInteger a) => FieldSpace (Rect a)

Defined in NumHask.Data.Rect

Associated Types

type Grid (Rect a) :: Type

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

mid-point of the space

project :: (Space s, Field (Element s), Subtractive (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 a a x = x

data Pos

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

Constructors

OuterPos

InnerPos

LowerPos

UpperPos

MidPos

Instances

Eq Pos

Defined in NumHask.Analysis.Space

Methods

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

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

Show Pos

Defined in NumHask.Analysis.Space

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 Foldable

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

is an element in the space

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

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

is a space contained within another?

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

are two spaces disjoint?

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

is one space completely above the other

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

is one space completely below the other

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

whole :: (Space s, BoundedJoinSemiLattice (Element s), BoundedMeetSemiLattice (Element s)) => s

a big, big space

negWhole :: (Space s, BoundedJoinSemiLattice (Element s), BoundedMeetSemiLattice (Element s)) => s

a negative space

eps :: (Space s, Epsilon (Element s), Multiplicative (Element s)) => Element s -> Element s -> s

a small space

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

widen a space

widenEps :: (Space s, Epsilon (Element s), Multiplicative (Element s)) => Element s -> s -> s

widen by a small amount