SpatialMathT

Documentation

class Rotation p a | p -> a where

Minimal complete definition

compose, rot, rot', toDcm, transpose

Methods

compose :: Rot f1 f2 p -> Rot f2 f3 p -> Rot f1 f3 p

rot :: Rot f1 f2 p -> V3T f1 a -> V3T f2 a

rot' :: Rot f1 f2 p -> V3T f2 a -> V3T f1 a

toDcm :: Rot f1 f2 p -> Rot f1 f2 (M33 a)

transpose :: Rot f1 f2 p -> Rot f2 f1 p

Instances

Num a => Rotation (M33 a) a

Methods

compose :: Rot f1 f2 (M33 a) -> Rot f2 f3 (M33 a) -> Rot f1 f3 (M33 a)

rot :: Rot f1 f2 (M33 a) -> V3T f1 a -> V3T f2 a

rot' :: Rot f1 f2 (M33 a) -> V3T f2 a -> V3T f1 a

toDcm :: Rot f1 f2 (M33 a) -> Rot f1 f2 (M33 a)

transpose :: Rot f1 f2 (M33 a) -> Rot f2 f1 (M33 a)

Num a => Rotation (Quaternion a) a

Methods

compose :: Rot f1 f2 (Quaternion a) -> Rot f2 f3 (Quaternion a) -> Rot f1 f3 (Quaternion a)

rot :: Rot f1 f2 (Quaternion a) -> V3T f1 a -> V3T f2 a

rot' :: Rot f1 f2 (Quaternion a) -> V3T f2 a -> V3T f1 a

toDcm :: Rot f1 f2 (Quaternion a) -> Rot f1 f2 (M33 a)

transpose :: Rot f1 f2 (Quaternion a) -> Rot f2 f1 (Quaternion a)

newtype Rot f1 f2 r

Constructors

Rot

Fields

• unR :: r

Instances

Functor (Rot f1 f2)

Methods

fmap :: (a -> b) -> Rot f1 f2 a -> Rot f1 f2 b

(<$) :: a -> Rot f1 f2 b -> Rot f1 f2 a

Foldable (Rot f1 f2)

Methods

fold :: Monoid m => Rot f1 f2 m -> m

foldMap :: Monoid m => (a -> m) -> Rot f1 f2 a -> m

foldr :: (a -> b -> b) -> b -> Rot f1 f2 a -> b

foldr' :: (a -> b -> b) -> b -> Rot f1 f2 a -> b

foldl :: (b -> a -> b) -> b -> Rot f1 f2 a -> b

foldl' :: (b -> a -> b) -> b -> Rot f1 f2 a -> b

foldr1 :: (a -> a -> a) -> Rot f1 f2 a -> a

foldl1 :: (a -> a -> a) -> Rot f1 f2 a -> a

toList :: Rot f1 f2 a -> [a]

null :: Rot f1 f2 a -> Bool

length :: Rot f1 f2 a -> Int

elem :: Eq a => a -> Rot f1 f2 a -> Bool

maximum :: Ord a => Rot f1 f2 a -> a

minimum :: Ord a => Rot f1 f2 a -> a

sum :: Num a => Rot f1 f2 a -> a

product :: Num a => Rot f1 f2 a -> a

Traversable (Rot f1 f2)

Methods

traverse :: Applicative f => (a -> f b) -> Rot f1 f2 a -> f (Rot f1 f2 b)

sequenceA :: Applicative f => Rot f1 f2 (f a) -> f (Rot f1 f2 a)

mapM :: Monad m => (a -> m b) -> Rot f1 f2 a -> m (Rot f1 f2 b)

sequence :: Monad m => Rot f1 f2 (m a) -> m (Rot f1 f2 a)

Generic1 (Rot f1 f2)

Associated Types

type Rep1 (Rot f1 f2 :: * -> *) :: * -> *

Methods

from1 :: Rot f1 f2 a -> Rep1 (Rot f1 f2) a

to1 :: Rep1 (Rot f1 f2) a -> Rot f1 f2 a

Eq r => Eq (Rot f1 f2 r)

Methods

(==) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

(/=) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

Fractional r => Fractional (Rot f1 f2 r)

Methods

(/) :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

recip :: Rot f1 f2 r -> Rot f1 f2 r

fromRational :: Rational -> Rot f1 f2 r

Num r => Num (Rot f1 f2 r)

Methods

(+) :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

(-) :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

(*) :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

negate :: Rot f1 f2 r -> Rot f1 f2 r

abs :: Rot f1 f2 r -> Rot f1 f2 r

signum :: Rot f1 f2 r -> Rot f1 f2 r

fromInteger :: Integer -> Rot f1 f2 r

Ord r => Ord (Rot f1 f2 r)

Methods

compare :: Rot f1 f2 r -> Rot f1 f2 r -> Ordering

(<) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

(<=) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

(>) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

(>=) :: Rot f1 f2 r -> Rot f1 f2 r -> Bool

max :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

min :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r

Show r => Show (Rot f1 f2 r)

Methods

showsPrec :: Int -> Rot f1 f2 r -> ShowS

show :: Rot f1 f2 r -> String

showList :: [Rot f1 f2 r] -> ShowS

Generic (Rot f1 f2 r)

Associated Types

type Rep (Rot f1 f2 r) :: * -> *

Methods

from :: Rot f1 f2 r -> Rep (Rot f1 f2 r) x

to :: Rep (Rot f1 f2 r) x -> Rot f1 f2 r

Storable r => Storable (Rot f1 f2 r)

Methods

sizeOf :: Rot f1 f2 r -> Int

alignment :: Rot f1 f2 r -> Int

peekElemOff :: Ptr (Rot f1 f2 r) -> Int -> IO (Rot f1 f2 r)

pokeElemOff :: Ptr (Rot f1 f2 r) -> Int -> Rot f1 f2 r -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Rot f1 f2 r)

pokeByteOff :: Ptr b -> Int -> Rot f1 f2 r -> IO ()

peek :: Ptr (Rot f1 f2 r) -> IO (Rot f1 f2 r)

poke :: Ptr (Rot f1 f2 r) -> Rot f1 f2 r -> IO ()

Binary r => Binary (Rot f1 f2 r)

Methods

put :: Rot f1 f2 r -> Put

get :: Get (Rot f1 f2 r)

putList :: [Rot f1 f2 r] -> Put

Serialize r => Serialize (Rot f1 f2 r)

Methods

put :: Putter (Rot f1 f2 r)

get :: Get (Rot f1 f2 r)

type Rep1 (Rot f1 f2)

type Rep1 (Rot f1 f2) = D1 (MetaData "Rot" "SpatialMathT" "spatial-math-0.2.7.0-HAAjPq9IesrLBjt7CWTbNk" True) (C1 (MetaCons "Rot" PrefixI True) (S1 (MetaSel (Just Symbol "unR") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Rot f1 f2 r)

type Rep (Rot f1 f2 r) = D1 (MetaData "Rot" "SpatialMathT" "spatial-math-0.2.7.0-HAAjPq9IesrLBjt7CWTbNk" True) (C1 (MetaCons "Rot" PrefixI True) (S1 (MetaSel (Just Symbol "unR") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 r)))

newtype V3T f a

Constructors

V3T

Fields

• unV :: V3 a

Instances

Functor (V3T f)

Methods

fmap :: (a -> b) -> V3T f a -> V3T f b

(<$) :: a -> V3T f b -> V3T f a

Applicative (V3T f)

Methods

pure :: a -> V3T f a

(<*>) :: V3T f (a -> b) -> V3T f a -> V3T f b

(*>) :: V3T f a -> V3T f b -> V3T f b

(<*) :: V3T f a -> V3T f b -> V3T f a

Foldable (V3T f)

Methods

fold :: Monoid m => V3T f m -> m

foldMap :: Monoid m => (a -> m) -> V3T f a -> m

foldr :: (a -> b -> b) -> b -> V3T f a -> b

foldr' :: (a -> b -> b) -> b -> V3T f a -> b

foldl :: (b -> a -> b) -> b -> V3T f a -> b

foldl' :: (b -> a -> b) -> b -> V3T f a -> b

foldr1 :: (a -> a -> a) -> V3T f a -> a

foldl1 :: (a -> a -> a) -> V3T f a -> a

toList :: V3T f a -> [a]

null :: V3T f a -> Bool

length :: V3T f a -> Int

elem :: Eq a => a -> V3T f a -> Bool

maximum :: Ord a => V3T f a -> a

minimum :: Ord a => V3T f a -> a

sum :: Num a => V3T f a -> a

product :: Num a => V3T f a -> a

Traversable (V3T f)

Methods

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

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

mapM :: Monad m => (a -> m b) -> V3T f a -> m (V3T f b)

sequence :: Monad m => V3T f (m a) -> m (V3T f a)

Generic1 (V3T f)

Associated Types

type Rep1 (V3T f :: * -> *) :: * -> *

Methods

from1 :: V3T f a -> Rep1 (V3T f) a

to1 :: Rep1 (V3T f) a -> V3T f a

R3 (V3T f)

Methods

_z :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

_xyz :: Functor f => (V3 a -> f (V3 a)) -> V3T f a -> f (V3T f a)

R2 (V3T f)

Methods

_y :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> V3T f a -> f (V3T f a)

R1 (V3T f)

Methods

_x :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

Metric (V3T f)

Methods

dot :: Num a => V3T f a -> V3T f a -> a

quadrance :: Num a => V3T f a -> a

qd :: Num a => V3T f a -> V3T f a -> a

distance :: Floating a => V3T f a -> V3T f a -> a

norm :: Floating a => V3T f a -> a

signorm :: Floating a => V3T f a -> V3T f a

Additive (V3T f)

Methods

zero :: Num a => V3T f a

(^+^) :: Num a => V3T f a -> V3T f a -> V3T f a

(^-^) :: Num a => V3T f a -> V3T f a -> V3T f a

lerp :: Num a => a -> V3T f a -> V3T f a -> V3T f a

liftU2 :: (a -> a -> a) -> V3T f a -> V3T f a -> V3T f a

liftI2 :: (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c

Eq a => Eq (V3T f a)

Methods

(==) :: V3T f a -> V3T f a -> Bool

(/=) :: V3T f a -> V3T f a -> Bool

Fractional a => Fractional (V3T f a)

Methods

(/) :: V3T f a -> V3T f a -> V3T f a

recip :: V3T f a -> V3T f a

fromRational :: Rational -> V3T f a

Num a => Num (V3T f a)

Methods

(+) :: V3T f a -> V3T f a -> V3T f a

(-) :: V3T f a -> V3T f a -> V3T f a

(*) :: V3T f a -> V3T f a -> V3T f a

negate :: V3T f a -> V3T f a

abs :: V3T f a -> V3T f a

signum :: V3T f a -> V3T f a

fromInteger :: Integer -> V3T f a

Ord a => Ord (V3T f a)

Methods

compare :: V3T f a -> V3T f a -> Ordering

(<) :: V3T f a -> V3T f a -> Bool

(<=) :: V3T f a -> V3T f a -> Bool

(>) :: V3T f a -> V3T f a -> Bool

(>=) :: V3T f a -> V3T f a -> Bool

max :: V3T f a -> V3T f a -> V3T f a

min :: V3T f a -> V3T f a -> V3T f a

Show a => Show (V3T f a)

Methods

showsPrec :: Int -> V3T f a -> ShowS

show :: V3T f a -> String

showList :: [V3T f a] -> ShowS

Generic (V3T f a)

Associated Types

type Rep (V3T f a) :: * -> *

Methods

from :: V3T f a -> Rep (V3T f a) x

to :: Rep (V3T f a) x -> V3T f a

Storable a => Storable (V3T f a)

Methods

sizeOf :: V3T f a -> Int

alignment :: V3T f a -> Int

peekElemOff :: Ptr (V3T f a) -> Int -> IO (V3T f a)

pokeElemOff :: Ptr (V3T f a) -> Int -> V3T f a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (V3T f a)

pokeByteOff :: Ptr b -> Int -> V3T f a -> IO ()

peek :: Ptr (V3T f a) -> IO (V3T f a)

poke :: Ptr (V3T f a) -> V3T f a -> IO ()

Binary a => Binary (V3T f a)

Methods

put :: V3T f a -> Put

get :: Get (V3T f a)

putList :: [V3T f a] -> Put

Serialize a => Serialize (V3T f a)

Methods

put :: Putter (V3T f a)

get :: Get (V3T f a)

type Rep1 (V3T f)

type Rep1 (V3T f) = D1 (MetaData "V3T" "SpatialMathT" "spatial-math-0.2.7.0-HAAjPq9IesrLBjt7CWTbNk" True) (C1 (MetaCons "V3T" PrefixI True) (S1 (MetaSel (Just Symbol "unV") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 V3)))

type Rep (V3T f a)

type Rep (V3T f a) = D1 (MetaData "V3T" "SpatialMathT" "spatial-math-0.2.7.0-HAAjPq9IesrLBjt7CWTbNk" True) (C1 (MetaCons "V3T" PrefixI True) (S1 (MetaSel (Just Symbol "unV") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (V3 a))))

class R1 t where

A space that has at least 1 basis vector _x.

Methods

_x :: Functor f => (a -> f a) -> t a -> f (t a)

>>> V1 2 ^._x
2

>>> V1 2 & _x .~ 3
V1 3

Instances

R1 Identity

Methods

_x :: Functor f => (a -> f a) -> Identity a -> f (Identity a)

R1 V4

Methods

_x :: Functor f => (a -> f a) -> V4 a -> f (V4 a)

R1 V3

Methods

_x :: Functor f => (a -> f a) -> V3 a -> f (V3 a)

R1 V2

Methods

_x :: Functor f => (a -> f a) -> V2 a -> f (V2 a)

R1 V1

Methods

_x :: Functor f => (a -> f a) -> V1 a -> f (V1 a)

R1 (V3T f)

Methods

_x :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

class R1 t => R2 t where

A space that distinguishes 2 orthogonal basis vectors _x and _y, but may have more.

Methods

_y :: Functor f => (a -> f a) -> t a -> f (t a)

>>> V2 1 2 ^._y
2

>>> V2 1 2 & _y .~ 3
V2 1 3

_xy :: Functor f => (V2 a -> f (V2 a)) -> t a -> f (t a)

Instances

R2 V4

Methods

_y :: Functor f => (a -> f a) -> V4 a -> f (V4 a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> V4 a -> f (V4 a)

R2 V3

Methods

_y :: Functor f => (a -> f a) -> V3 a -> f (V3 a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> V3 a -> f (V3 a)

R2 V2

Methods

_y :: Functor f => (a -> f a) -> V2 a -> f (V2 a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> V2 a -> f (V2 a)

R2 (V3T f)

Methods

_y :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> V3T f a -> f (V3T f a)

class R2 t => R3 t where

A space that distinguishes 3 orthogonal basis vectors: _x, _y, and _z. (It may have more)

Methods

_z :: Functor f => (a -> f a) -> t a -> f (t a)

>>> V3 1 2 3 ^. _z
3

_xyz :: Functor f => (V3 a -> f (V3 a)) -> t a -> f (t a)

Instances

R3 V4

Methods

_z :: Functor f => (a -> f a) -> V4 a -> f (V4 a)

_xyz :: Functor f => (V3 a -> f (V3 a)) -> V4 a -> f (V4 a)

R3 V3

Methods

_z :: Functor f => (a -> f a) -> V3 a -> f (V3 a)

_xyz :: Functor f => (V3 a -> f (V3 a)) -> V3 a -> f (V3 a)

R3 (V3T f)

Methods

_z :: Functor f => (a -> f a) -> V3T f a -> f (V3T f a)

_xyz :: Functor f => (V3 a -> f (V3 a)) -> V3T f a -> f (V3T f a)

type M33T f1 f2 a = V3T f1 (V3T f2 a)

cross :: Num a => V3T f a -> V3T f a -> V3T f a

orthonormalize :: Floating a => Rot f1 f2 (M33 a) -> Rot f1 f2 (M33 a)