SpatialMathT

Documentation

class Floating a => ArcTan2 a where

doesn't require RealFloat, used for overloading symbolics

Minimal complete definition

arctan2

Methods

arctan2 :: a -> a -> a

arctan2 y x computes the arctangent from two arguments. The Double and Float instances call out to a sufficiently recent version of libm to compute this.

The following test cases are the full set of recommended function properties specified for function atan2Pi() on page 45 of the IEEE Std 754-2008 document.

>>> arctan2 0 (-0) :: Double
3.141592653589793
>>> arctan2 (-0) (-0) :: Double
-3.141592653589793
>>> arctan2 0 0 :: Double
0.0
>>> arctan2 (-0) 0 :: Double
-0.0

\x -> x < 0 ==> arctan2 (-0) x == (-pi :: Double)

\x -> x < 0 ==> arctan2 0 x == (pi :: Double)

\x -> x > 0 ==> arctan2 (-0) x == (-0 :: Double)

\x -> x > 0 ==> arctan2 0 x == (0 :: Double)

\y -> y < 0 ==> arctan2 y (-0) == (-pi / 2 :: Double)

\y -> y > 0 ==> arctan2 y 0 == (pi / 2 :: Double)

\y -> y > 0 && not (isNaN y || isInfinite y) ==> arctan2 y (negate $ 1/0) == (pi :: Double)

\y -> y < 0 && not (isNaN y || isInfinite y) ==> arctan2 y (negate $ 1/0) == (-pi :: Double)

\y -> y > 0 && not (isNaN y || isInfinite y) ==> arctan2 y (1/0) == (0 :: Double)

\y -> y < 0 && not (isNaN y || isInfinite y) ==> arctan2 y (1/0) == (-0 :: Double)

\x -> not (isNaN x || isInfinite x) ==> arctan2 (negate $ 1/0) x == (-pi/2 :: Double)

\x -> not (isNaN x || isInfinite x) ==> arctan2 (1/0) x == (pi/2 :: Double)

>>> arctan2 neginf neginf :: Double
-2.356194490192345
>>> arctan2 inf neginf :: Double
2.356194490192345
>>> arctan2 neginf inf :: Double
-0.7853981633974483
>>> arctan2 inf inf :: Double
0.7853981633974483

Instances

ArcTan2 Double

Methods

arctan2 :: Double -> Double -> Double

ArcTan2 Float

Methods

arctan2 :: Float -> Float -> Float

data Euler a

3-2-1 Euler angle rotation sequence

Constructors

Euler

Fields

• eYaw :: a
• ePitch :: a
• eRoll :: a

Instances

Functor Euler

Methods

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

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

Applicative Euler

Methods

pure :: a -> Euler a

(<*>) :: Euler (a -> b) -> Euler a -> Euler b

(*>) :: Euler a -> Euler b -> Euler b

(<*) :: Euler a -> Euler b -> Euler a

Foldable Euler

Methods

fold :: Monoid m => Euler m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Euler a -> a

foldl1 :: (a -> a -> a) -> Euler a -> a

toList :: Euler a -> [a]

null :: Euler a -> Bool

length :: Euler a -> Int

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

maximum :: Ord a => Euler a -> a

minimum :: Ord a => Euler a -> a

sum :: Num a => Euler a -> a

product :: Num a => Euler a -> a

Traversable Euler

Methods

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

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

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

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

Generic1 Euler

Associated Types

type Rep1 (Euler :: * -> *) :: * -> *

Methods

from1 :: Euler a -> Rep1 Euler a

to1 :: Rep1 Euler a -> Euler a

(ArcTan2 a, Floating a, Ord a) => Rotation Euler a

Methods

compose :: Rot f1 f2 Euler a -> Rot f2 f3 Euler a -> Rot f1 f3 Euler a

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

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

transpose :: Rot f1 f2 Euler a -> Rot f2 f1 Euler a

identity :: Rot f1 f2 Euler a

Eq a => Eq (Euler a)

Methods

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

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

Data a => Data (Euler a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Euler a -> c (Euler a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Euler a)

toConstr :: Euler a -> Constr

dataTypeOf :: Euler a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Euler a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Euler a))

gmapT :: (forall b. Data b => b -> b) -> Euler a -> Euler a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Euler a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Euler a -> r

gmapQ :: (forall d. Data d => d -> u) -> Euler a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Euler a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Euler a -> m (Euler a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Euler a -> m (Euler a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Euler a -> m (Euler a)

Ord a => Ord (Euler a)

Methods

compare :: Euler a -> Euler a -> Ordering

(<) :: Euler a -> Euler a -> Bool

(<=) :: Euler a -> Euler a -> Bool

(>) :: Euler a -> Euler a -> Bool

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

max :: Euler a -> Euler a -> Euler a

min :: Euler a -> Euler a -> Euler a

Show a => Show (Euler a)

Methods

showsPrec :: Int -> Euler a -> ShowS

show :: Euler a -> String

showList :: [Euler a] -> ShowS

Generic (Euler a)

Associated Types

type Rep (Euler a) :: * -> *

Methods

from :: Euler a -> Rep (Euler a) x

to :: Rep (Euler a) x -> Euler a

Binary a => Binary (Euler a)

Methods

put :: Euler a -> Put

get :: Get (Euler a)

putList :: [Euler a] -> Put

Serialize a => Serialize (Euler a)

Methods

put :: Putter (Euler a)

get :: Get (Euler a)

type Rep1 Euler

type Rep1 Euler = D1 (MetaData "Euler" "Types" "spatial-math-0.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" False) (C1 (MetaCons "Euler" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "eYaw") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1) ((:*:) (S1 (MetaSel (Just Symbol "ePitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1) (S1 (MetaSel (Just Symbol "eRoll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep (Euler a)

type Rep (Euler a) = D1 (MetaData "Euler" "Types" "spatial-math-0.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" False) (C1 (MetaCons "Euler" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "eYaw") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Just Symbol "ePitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Just Symbol "eRoll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))))

data Quaternion a :: * -> *

Quaternions

Constructors

Quaternion ~a ~(V3 a)

Instances

Monad Quaternion

Methods

(>>=) :: Quaternion a -> (a -> Quaternion b) -> Quaternion b

(>>) :: Quaternion a -> Quaternion b -> Quaternion b

return :: a -> Quaternion a

fail :: String -> Quaternion a

Functor Quaternion

Methods

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

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

MonadFix Quaternion

Methods

mfix :: (a -> Quaternion a) -> Quaternion a

Applicative Quaternion

Methods

pure :: a -> Quaternion a

(<*>) :: Quaternion (a -> b) -> Quaternion a -> Quaternion b

(*>) :: Quaternion a -> Quaternion b -> Quaternion b

(<*) :: Quaternion a -> Quaternion b -> Quaternion a

Foldable Quaternion

Methods

fold :: Monoid m => Quaternion m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Quaternion a -> a

foldl1 :: (a -> a -> a) -> Quaternion a -> a

toList :: Quaternion a -> [a]

null :: Quaternion a -> Bool

length :: Quaternion a -> Int

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

maximum :: Ord a => Quaternion a -> a

minimum :: Ord a => Quaternion a -> a

sum :: Num a => Quaternion a -> a

product :: Num a => Quaternion a -> a

Traversable Quaternion

Methods

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

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

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

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

Generic1 Quaternion

Associated Types

type Rep1 (Quaternion :: * -> *) :: * -> *

Methods

from1 :: Quaternion a -> Rep1 Quaternion a

to1 :: Rep1 Quaternion a -> Quaternion a

Distributive Quaternion

Methods

distribute :: Functor f => f (Quaternion a) -> Quaternion (f a)

collect :: Functor f => (a -> Quaternion b) -> f a -> Quaternion (f b)

distributeM :: Monad m => m (Quaternion a) -> Quaternion (m a)

collectM :: Monad m => (a -> Quaternion b) -> m a -> Quaternion (m b)

Representable Quaternion

Associated Types

type Rep (Quaternion :: * -> *) :: *

Methods

tabulate :: (Rep Quaternion -> a) -> Quaternion a

index :: Quaternion a -> Rep Quaternion -> a

Eq1 Quaternion

Methods

liftEq :: (a -> b -> Bool) -> Quaternion a -> Quaternion b -> Bool

Ord1 Quaternion

Methods

liftCompare :: (a -> b -> Ordering) -> Quaternion a -> Quaternion b -> Ordering

Read1 Quaternion

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Quaternion a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Quaternion a]

Show1 Quaternion

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Quaternion a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Quaternion a] -> ShowS

MonadZip Quaternion

Methods

mzip :: Quaternion a -> Quaternion b -> Quaternion (a, b)

mzipWith :: (a -> b -> c) -> Quaternion a -> Quaternion b -> Quaternion c

munzip :: Quaternion (a, b) -> (Quaternion a, Quaternion b)

Serial1 Quaternion

Methods

serializeWith :: MonadPut m => (a -> m ()) -> Quaternion a -> m ()

deserializeWith :: MonadGet m => m a -> m (Quaternion a)

Apply Quaternion

Methods

(<.>) :: Quaternion (a -> b) -> Quaternion a -> Quaternion b

(.>) :: Quaternion a -> Quaternion b -> Quaternion b

(<.) :: Quaternion a -> Quaternion b -> Quaternion a

liftF2 :: (a -> b -> c) -> Quaternion a -> Quaternion b -> Quaternion c

Complicated Quaternion

Methods

_e :: Functor f => (a -> f a) -> Quaternion a -> f (Quaternion a)

_i :: Functor f => (a -> f a) -> Quaternion a -> f (Quaternion a)

Hamiltonian Quaternion

Methods

_j :: Functor f => (a -> f a) -> Quaternion a -> f (Quaternion a)

_k :: Functor f => (a -> f a) -> Quaternion a -> f (Quaternion a)

_ijk :: Functor f => (V3 a -> f (V3 a)) -> Quaternion a -> f (Quaternion a)

Finite Quaternion

Associated Types

type Size (Quaternion :: * -> *) :: Nat

Methods

toV :: Quaternion a -> V Nat (Size Quaternion) a

fromV :: V Nat (Size Quaternion) a -> Quaternion a

Metric Quaternion

Methods

dot :: Num a => Quaternion a -> Quaternion a -> a

quadrance :: Num a => Quaternion a -> a

qd :: Num a => Quaternion a -> Quaternion a -> a

distance :: Floating a => Quaternion a -> Quaternion a -> a

norm :: Floating a => Quaternion a -> a

signorm :: Floating a => Quaternion a -> Quaternion a

Additive Quaternion

Methods

zero :: Num a => Quaternion a

(^+^) :: Num a => Quaternion a -> Quaternion a -> Quaternion a

(^-^) :: Num a => Quaternion a -> Quaternion a -> Quaternion a

lerp :: Num a => a -> Quaternion a -> Quaternion a -> Quaternion a

liftU2 :: (a -> a -> a) -> Quaternion a -> Quaternion a -> Quaternion a

liftI2 :: (a -> b -> c) -> Quaternion a -> Quaternion b -> Quaternion c

Bind Quaternion

Methods

(>>-) :: Quaternion a -> (a -> Quaternion b) -> Quaternion b

join :: Quaternion (Quaternion a) -> Quaternion a

Num a => Rotation Quaternion 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

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

identity :: Rot f1 f2 Quaternion a

Unbox a => Vector Vector (Quaternion a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Quaternion a) -> m (Vector (Quaternion a))

basicUnsafeThaw :: PrimMonad m => Vector (Quaternion a) -> m (Mutable Vector (PrimState m) (Quaternion a))

basicLength :: Vector (Quaternion a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Quaternion a) -> Vector (Quaternion a)

basicUnsafeIndexM :: Monad m => Vector (Quaternion a) -> Int -> m (Quaternion a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Quaternion a) -> Vector (Quaternion a) -> m ()

elemseq :: Vector (Quaternion a) -> Quaternion a -> b -> b

Unbox a => MVector MVector (Quaternion a)

Methods

basicLength :: MVector s (Quaternion a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Quaternion a) -> MVector s (Quaternion a)

basicOverlaps :: MVector s (Quaternion a) -> MVector s (Quaternion a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Quaternion a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Quaternion a -> m (MVector (PrimState m) (Quaternion a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> Int -> m (Quaternion a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> Int -> Quaternion a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> Quaternion a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> MVector (PrimState m) (Quaternion a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> MVector (PrimState m) (Quaternion a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Quaternion a) -> Int -> m (MVector (PrimState m) (Quaternion a))

Eq a => Eq (Quaternion a)

Methods

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

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

RealFloat a => Floating (Quaternion a)

Methods

pi :: Quaternion a

exp :: Quaternion a -> Quaternion a

log :: Quaternion a -> Quaternion a

sqrt :: Quaternion a -> Quaternion a

(**) :: Quaternion a -> Quaternion a -> Quaternion a

logBase :: Quaternion a -> Quaternion a -> Quaternion a

sin :: Quaternion a -> Quaternion a

cos :: Quaternion a -> Quaternion a

tan :: Quaternion a -> Quaternion a

asin :: Quaternion a -> Quaternion a

acos :: Quaternion a -> Quaternion a

atan :: Quaternion a -> Quaternion a

sinh :: Quaternion a -> Quaternion a

cosh :: Quaternion a -> Quaternion a

tanh :: Quaternion a -> Quaternion a

asinh :: Quaternion a -> Quaternion a

acosh :: Quaternion a -> Quaternion a

atanh :: Quaternion a -> Quaternion a

log1p :: Quaternion a -> Quaternion a

expm1 :: Quaternion a -> Quaternion a

log1pexp :: Quaternion a -> Quaternion a

log1mexp :: Quaternion a -> Quaternion a

RealFloat a => Fractional (Quaternion a)

Methods

(/) :: Quaternion a -> Quaternion a -> Quaternion a

recip :: Quaternion a -> Quaternion a

fromRational :: Rational -> Quaternion a

Data a => Data (Quaternion a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Quaternion a -> c (Quaternion a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Quaternion a)

toConstr :: Quaternion a -> Constr

dataTypeOf :: Quaternion a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Quaternion a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Quaternion a))

gmapT :: (forall b. Data b => b -> b) -> Quaternion a -> Quaternion a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Quaternion a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Quaternion a -> r

gmapQ :: (forall d. Data d => d -> u) -> Quaternion a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Quaternion a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Quaternion a -> m (Quaternion a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Quaternion a -> m (Quaternion a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Quaternion a -> m (Quaternion a)

RealFloat a => Num (Quaternion a)

Methods

(+) :: Quaternion a -> Quaternion a -> Quaternion a

(-) :: Quaternion a -> Quaternion a -> Quaternion a

(*) :: Quaternion a -> Quaternion a -> Quaternion a

negate :: Quaternion a -> Quaternion a

abs :: Quaternion a -> Quaternion a

signum :: Quaternion a -> Quaternion a

fromInteger :: Integer -> Quaternion a

Ord a => Ord (Quaternion a)

Methods

compare :: Quaternion a -> Quaternion a -> Ordering

(<) :: Quaternion a -> Quaternion a -> Bool

(<=) :: Quaternion a -> Quaternion a -> Bool

(>) :: Quaternion a -> Quaternion a -> Bool

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

max :: Quaternion a -> Quaternion a -> Quaternion a

min :: Quaternion a -> Quaternion a -> Quaternion a

Read a => Read (Quaternion a)

Methods

readsPrec :: Int -> ReadS (Quaternion a)

readList :: ReadS [Quaternion a]

readPrec :: ReadPrec (Quaternion a)

readListPrec :: ReadPrec [Quaternion a]

Show a => Show (Quaternion a)

Methods

showsPrec :: Int -> Quaternion a -> ShowS

show :: Quaternion a -> String

showList :: [Quaternion a] -> ShowS

Ix a => Ix (Quaternion a)

Methods

range :: (Quaternion a, Quaternion a) -> [Quaternion a]

index :: (Quaternion a, Quaternion a) -> Quaternion a -> Int

unsafeIndex :: (Quaternion a, Quaternion a) -> Quaternion a -> Int

inRange :: (Quaternion a, Quaternion a) -> Quaternion a -> Bool

rangeSize :: (Quaternion a, Quaternion a) -> Int

unsafeRangeSize :: (Quaternion a, Quaternion a) -> Int

Generic (Quaternion a)

Associated Types

type Rep (Quaternion a) :: * -> *

Methods

from :: Quaternion a -> Rep (Quaternion a) x

to :: Rep (Quaternion a) x -> Quaternion a

Storable a => Storable (Quaternion a)

Methods

sizeOf :: Quaternion a -> Int

alignment :: Quaternion a -> Int

peekElemOff :: Ptr (Quaternion a) -> Int -> IO (Quaternion a)

pokeElemOff :: Ptr (Quaternion a) -> Int -> Quaternion a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Quaternion a)

pokeByteOff :: Ptr b -> Int -> Quaternion a -> IO ()

peek :: Ptr (Quaternion a) -> IO (Quaternion a)

poke :: Ptr (Quaternion a) -> Quaternion a -> IO ()

Binary a => Binary (Quaternion a)

Methods

put :: Quaternion a -> Put

get :: Get (Quaternion a)

putList :: [Quaternion a] -> Put

Serial a => Serial (Quaternion a)

Methods

serialize :: MonadPut m => Quaternion a -> m ()

deserialize :: MonadGet m => m (Quaternion a)

Serialize a => Serialize (Quaternion a)

Methods

put :: Putter (Quaternion a)

get :: Get (Quaternion a)

NFData a => NFData (Quaternion a)

Methods

rnf :: Quaternion a -> ()

Hashable a => Hashable (Quaternion a)

Methods

hashWithSalt :: Int -> Quaternion a -> Int

hash :: Quaternion a -> Int

Unbox a => Unbox (Quaternion a)

Ixed (Quaternion a)

Methods

ix :: Index (Quaternion a) -> Traversal' (Quaternion a) (IxValue (Quaternion a))

(Conjugate a, RealFloat a) => Conjugate (Quaternion a)

Methods

conjugate :: Quaternion a -> Quaternion a

(RealFloat a, Epsilon a) => Epsilon (Quaternion a)

Methods

nearZero :: Quaternion a -> Bool

FunctorWithIndex (E Quaternion) Quaternion

Methods

imap :: (E Quaternion -> a -> b) -> Quaternion a -> Quaternion b

imapped :: (Indexable (E Quaternion) p, Settable f) => p a (f b) -> Quaternion a -> f (Quaternion b)

FoldableWithIndex (E Quaternion) Quaternion

Methods

ifoldMap :: Monoid m => (E Quaternion -> a -> m) -> Quaternion a -> m

ifolded :: (Indexable (E Quaternion) p, Contravariant f, Applicative f) => p a (f a) -> Quaternion a -> f (Quaternion a)

ifoldr :: (E Quaternion -> a -> b -> b) -> b -> Quaternion a -> b

ifoldl :: (E Quaternion -> b -> a -> b) -> b -> Quaternion a -> b

ifoldr' :: (E Quaternion -> a -> b -> b) -> b -> Quaternion a -> b

ifoldl' :: (E Quaternion -> b -> a -> b) -> b -> Quaternion a -> b

TraversableWithIndex (E Quaternion) Quaternion

Methods

itraverse :: Applicative f => (E Quaternion -> a -> f b) -> Quaternion a -> f (Quaternion b)

itraversed :: (Indexable (E Quaternion) p, Applicative f) => p a (f b) -> Quaternion a -> f (Quaternion b)

Each (Quaternion a) (Quaternion b) a b

Methods

each :: Traversal (Quaternion a) (Quaternion b) a b

type Rep1 Quaternion

type Rep1 Quaternion = D1 (MetaData "Quaternion" "Linear.Quaternion" "linear-1.20.7-6g23dYWbMGQ6XuUlU2qazP" False) (C1 (MetaCons "Quaternion" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec1 V3))))

type Rep Quaternion

type Rep Quaternion = E Quaternion

type Size Quaternion

type Size Quaternion = 4

data MVector s (Quaternion a)

data MVector s (Quaternion a) = MV_Quaternion ~Int (MVector s a)

type Rep (Quaternion a)

type Rep (Quaternion a) = D1 (MetaData "Quaternion" "Linear.Quaternion" "linear-1.20.7-6g23dYWbMGQ6XuUlU2qazP" False) (C1 (MetaCons "Quaternion" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 (V3 a)))))

data Vector (Quaternion a)

data Vector (Quaternion a) = V_Quaternion ~Int (Vector a)

type Index (Quaternion a)

type Index (Quaternion a) = E Quaternion

type IxValue (Quaternion a)

type IxValue (Quaternion a) = a

data V3 a :: * -> *

A 3-dimensional vector

Constructors

V3 ~a ~a ~a

Instances

Monad V3

Methods

(>>=) :: V3 a -> (a -> V3 b) -> V3 b

(>>) :: V3 a -> V3 b -> V3 b

return :: a -> V3 a

fail :: String -> V3 a

Functor V3

Methods

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

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

MonadFix V3

Methods

mfix :: (a -> V3 a) -> V3 a

Applicative V3

Methods

pure :: a -> V3 a

(<*>) :: V3 (a -> b) -> V3 a -> V3 b

(*>) :: V3 a -> V3 b -> V3 b

(<*) :: V3 a -> V3 b -> V3 a

Foldable V3

Methods

fold :: Monoid m => V3 m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> V3 a -> a

foldl1 :: (a -> a -> a) -> V3 a -> a

toList :: V3 a -> [a]

null :: V3 a -> Bool

length :: V3 a -> Int

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

maximum :: Ord a => V3 a -> a

minimum :: Ord a => V3 a -> a

sum :: Num a => V3 a -> a

product :: Num a => V3 a -> a

Traversable V3

Methods

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

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

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

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

Generic1 V3

Associated Types

type Rep1 (V3 :: * -> *) :: * -> *

Methods

from1 :: V3 a -> Rep1 V3 a

to1 :: Rep1 V3 a -> V3 a

Distributive V3

Methods

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

collect :: Functor f => (a -> V3 b) -> f a -> V3 (f b)

distributeM :: Monad m => m (V3 a) -> V3 (m a)

collectM :: Monad m => (a -> V3 b) -> m a -> V3 (m b)

Representable V3

Associated Types

type Rep (V3 :: * -> *) :: *

Methods

tabulate :: (Rep V3 -> a) -> V3 a

index :: V3 a -> Rep V3 -> a

Eq1 V3

Methods

liftEq :: (a -> b -> Bool) -> V3 a -> V3 b -> Bool

Ord1 V3

Methods

liftCompare :: (a -> b -> Ordering) -> V3 a -> V3 b -> Ordering

Read1 V3

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (V3 a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [V3 a]

Show1 V3

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> V3 a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [V3 a] -> ShowS

MonadZip V3

Methods

mzip :: V3 a -> V3 b -> V3 (a, b)

mzipWith :: (a -> b -> c) -> V3 a -> V3 b -> V3 c

munzip :: V3 (a, b) -> (V3 a, V3 b)

Serial1 V3

Methods

serializeWith :: MonadPut m => (a -> m ()) -> V3 a -> m ()

deserializeWith :: MonadGet m => m a -> m (V3 a)

Apply V3

Methods

(<.>) :: V3 (a -> b) -> V3 a -> V3 b

(.>) :: V3 a -> V3 b -> V3 b

(<.) :: V3 a -> V3 b -> V3 a

liftF2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c

Traversable1 V3

Methods

traverse1 :: Apply f => (a -> f b) -> V3 a -> f (V3 b)

sequence1 :: Apply f => V3 (f b) -> f (V3 b)

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)

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)

R1 V3

Methods

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

Finite V3

Associated Types

type Size (V3 :: * -> *) :: Nat

Methods

toV :: V3 a -> V Nat (Size V3) a

fromV :: V Nat (Size V3) a -> V3 a

Metric V3

Methods

dot :: Num a => V3 a -> V3 a -> a

quadrance :: Num a => V3 a -> a

qd :: Num a => V3 a -> V3 a -> a

distance :: Floating a => V3 a -> V3 a -> a

norm :: Floating a => V3 a -> a

signorm :: Floating a => V3 a -> V3 a

Additive V3

Methods

zero :: Num a => V3 a

(^+^) :: Num a => V3 a -> V3 a -> V3 a

(^-^) :: Num a => V3 a -> V3 a -> V3 a

lerp :: Num a => a -> V3 a -> V3 a -> V3 a

liftU2 :: (a -> a -> a) -> V3 a -> V3 a -> V3 a

liftI2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c

Bind V3

Methods

(>>-) :: V3 a -> (a -> V3 b) -> V3 b

join :: V3 (V3 a) -> V3 a

Foldable1 V3

Methods

fold1 :: Semigroup m => V3 m -> m

foldMap1 :: Semigroup m => (a -> m) -> V3 a -> m

toNonEmpty :: V3 a -> NonEmpty a

Unbox a => Vector Vector (V3 a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V3 a) -> m (Vector (V3 a))

basicUnsafeThaw :: PrimMonad m => Vector (V3 a) -> m (Mutable Vector (PrimState m) (V3 a))

basicLength :: Vector (V3 a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (V3 a) -> Vector (V3 a)

basicUnsafeIndexM :: Monad m => Vector (V3 a) -> Int -> m (V3 a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V3 a) -> Vector (V3 a) -> m ()

elemseq :: Vector (V3 a) -> V3 a -> b -> b

Unbox a => MVector MVector (V3 a)

Methods

basicLength :: MVector s (V3 a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (V3 a) -> MVector s (V3 a)

basicOverlaps :: MVector s (V3 a) -> MVector s (V3 a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V3 a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (V3 a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> V3 a -> m (MVector (PrimState m) (V3 a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> m (V3 a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> V3 a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (V3 a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (V3 a) -> V3 a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V3 a) -> MVector (PrimState m) (V3 a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V3 a) -> MVector (PrimState m) (V3 a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> m (MVector (PrimState m) (V3 a))

Bounded a => Bounded (V3 a)

Methods

minBound :: V3 a

maxBound :: V3 a

Eq a => Eq (V3 a)

Methods

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

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

Floating a => Floating (V3 a)

Methods

pi :: V3 a

exp :: V3 a -> V3 a

log :: V3 a -> V3 a

sqrt :: V3 a -> V3 a

(**) :: V3 a -> V3 a -> V3 a

logBase :: V3 a -> V3 a -> V3 a

sin :: V3 a -> V3 a

cos :: V3 a -> V3 a

tan :: V3 a -> V3 a

asin :: V3 a -> V3 a

acos :: V3 a -> V3 a

atan :: V3 a -> V3 a

sinh :: V3 a -> V3 a

cosh :: V3 a -> V3 a

tanh :: V3 a -> V3 a

asinh :: V3 a -> V3 a

acosh :: V3 a -> V3 a

atanh :: V3 a -> V3 a

log1p :: V3 a -> V3 a

expm1 :: V3 a -> V3 a

log1pexp :: V3 a -> V3 a

log1mexp :: V3 a -> V3 a

Fractional a => Fractional (V3 a)

Methods

(/) :: V3 a -> V3 a -> V3 a

recip :: V3 a -> V3 a

fromRational :: Rational -> V3 a

Data a => Data (V3 a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V3 a -> c (V3 a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V3 a)

toConstr :: V3 a -> Constr

dataTypeOf :: V3 a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (V3 a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a))

gmapT :: (forall b. Data b => b -> b) -> V3 a -> V3 a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r

gmapQ :: (forall d. Data d => d -> u) -> V3 a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> V3 a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)

Num a => Num (V3 a)

Methods

(+) :: V3 a -> V3 a -> V3 a

(-) :: V3 a -> V3 a -> V3 a

(*) :: V3 a -> V3 a -> V3 a

negate :: V3 a -> V3 a

abs :: V3 a -> V3 a

signum :: V3 a -> V3 a

fromInteger :: Integer -> V3 a

Ord a => Ord (V3 a)

Methods

compare :: V3 a -> V3 a -> Ordering

(<) :: V3 a -> V3 a -> Bool

(<=) :: V3 a -> V3 a -> Bool

(>) :: V3 a -> V3 a -> Bool

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

max :: V3 a -> V3 a -> V3 a

min :: V3 a -> V3 a -> V3 a

Read a => Read (V3 a)

Methods

readsPrec :: Int -> ReadS (V3 a)

readList :: ReadS [V3 a]

readPrec :: ReadPrec (V3 a)

readListPrec :: ReadPrec [V3 a]

Show a => Show (V3 a)

Methods

showsPrec :: Int -> V3 a -> ShowS

show :: V3 a -> String

showList :: [V3 a] -> ShowS

Ix a => Ix (V3 a)

Methods

range :: (V3 a, V3 a) -> [V3 a]

index :: (V3 a, V3 a) -> V3 a -> Int

unsafeIndex :: (V3 a, V3 a) -> V3 a -> Int

inRange :: (V3 a, V3 a) -> V3 a -> Bool

rangeSize :: (V3 a, V3 a) -> Int

unsafeRangeSize :: (V3 a, V3 a) -> Int

Generic (V3 a)

Associated Types

type Rep (V3 a) :: * -> *

Methods

from :: V3 a -> Rep (V3 a) x

to :: Rep (V3 a) x -> V3 a

Storable a => Storable (V3 a)

Methods

sizeOf :: V3 a -> Int

alignment :: V3 a -> Int

peekElemOff :: Ptr (V3 a) -> Int -> IO (V3 a)

pokeElemOff :: Ptr (V3 a) -> Int -> V3 a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (V3 a)

pokeByteOff :: Ptr b -> Int -> V3 a -> IO ()

peek :: Ptr (V3 a) -> IO (V3 a)

poke :: Ptr (V3 a) -> V3 a -> IO ()

Binary a => Binary (V3 a)

Methods

put :: V3 a -> Put

get :: Get (V3 a)

putList :: [V3 a] -> Put

Serial a => Serial (V3 a)

Methods

serialize :: MonadPut m => V3 a -> m ()

deserialize :: MonadGet m => m (V3 a)

Serialize a => Serialize (V3 a)

Methods

put :: Putter (V3 a)

get :: Get (V3 a)

NFData a => NFData (V3 a)

Methods

rnf :: V3 a -> ()

Hashable a => Hashable (V3 a)

Methods

hashWithSalt :: Int -> V3 a -> Int

hash :: V3 a -> Int

Unbox a => Unbox (V3 a)

Ixed (V3 a)

Methods

ix :: Index (V3 a) -> Traversal' (V3 a) (IxValue (V3 a))

Epsilon a => Epsilon (V3 a)

Methods

nearZero :: V3 a -> Bool

FunctorWithIndex (E V3) V3

Methods

imap :: (E V3 -> a -> b) -> V3 a -> V3 b

imapped :: (Indexable (E V3) p, Settable f) => p a (f b) -> V3 a -> f (V3 b)

FoldableWithIndex (E V3) V3

Methods

ifoldMap :: Monoid m => (E V3 -> a -> m) -> V3 a -> m

ifolded :: (Indexable (E V3) p, Contravariant f, Applicative f) => p a (f a) -> V3 a -> f (V3 a)

ifoldr :: (E V3 -> a -> b -> b) -> b -> V3 a -> b

ifoldl :: (E V3 -> b -> a -> b) -> b -> V3 a -> b

ifoldr' :: (E V3 -> a -> b -> b) -> b -> V3 a -> b

ifoldl' :: (E V3 -> b -> a -> b) -> b -> V3 a -> b

TraversableWithIndex (E V3) V3

Methods

itraverse :: Applicative f => (E V3 -> a -> f b) -> V3 a -> f (V3 b)

itraversed :: (Indexable (E V3) p, Applicative f) => p a (f b) -> V3 a -> f (V3 b)

Each (V3 a) (V3 b) a b

Methods

each :: Traversal (V3 a) (V3 b) a b

Num a => Rotation ((:.) V3 V3) a

Methods

compose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f3 (V3 :. V3) a -> Rot f1 f3 (V3 :. V3) a

rot :: Rot f1 f2 (V3 :. V3) a -> V3T f1 a -> V3T f2 a

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

transpose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f1 (V3 :. V3) a

identity :: Rot f1 f2 (V3 :. V3) a

type Rep1 V3

type Rep1 V3 = D1 (MetaData "V3" "Linear.V3" "linear-1.20.7-6g23dYWbMGQ6XuUlU2qazP" False) (C1 (MetaCons "V3" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1))))

type Rep V3

type Rep V3 = E V3

type Size V3

type Size V3 = 3

data MVector s (V3 a)

data MVector s (V3 a) = MV_V3 ~Int ~(MVector s a)

type Rep (V3 a)

type Rep (V3 a) = D1 (MetaData "V3" "Linear.V3" "linear-1.20.7-6g23dYWbMGQ6XuUlU2qazP" False) (C1 (MetaCons "V3" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))))

data Vector (V3 a)

data Vector (V3 a) = V_V3 ~Int ~(Vector a)

type Index (V3 a)

type Index (V3 a) = E V3

type IxValue (V3 a)

type IxValue (V3 a) = a

class Rotation g a where

Minimal complete definition

compose, rot, rot', transpose, identity

Methods

compose :: Rot f1 f2 g a -> Rot f2 f3 g a -> Rot f1 f3 g a

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

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

transpose :: Rot f1 f2 g a -> Rot f2 f1 g a

identity :: Rot f1 f2 g a

Instances

Num a => Rotation Quaternion 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

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

identity :: Rot f1 f2 Quaternion a

(ArcTan2 a, Floating a, Ord a) => Rotation Euler a

Methods

compose :: Rot f1 f2 Euler a -> Rot f2 f3 Euler a -> Rot f1 f3 Euler a

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

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

transpose :: Rot f1 f2 Euler a -> Rot f2 f1 Euler a

identity :: Rot f1 f2 Euler a

Num a => Rotation ((:.) V3 V3) a

Methods

compose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f3 (V3 :. V3) a -> Rot f1 f3 (V3 :. V3) a

rot :: Rot f1 f2 (V3 :. V3) a -> V3T f1 a -> V3T f2 a

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

transpose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f1 (V3 :. V3) a

identity :: Rot f1 f2 (V3 :. V3) a

newtype Rot f1 f2 r a

Constructors

Rot

Fields

• unRot :: r a

Instances

Functor r => Functor (Rot f1 f2 r)

Methods

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

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

Applicative r => Applicative (Rot f1 f2 r)

Methods

pure :: a -> Rot f1 f2 r a

(<*>) :: Rot f1 f2 r (a -> b) -> Rot f1 f2 r a -> Rot f1 f2 r b

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

(<*) :: Rot f1 f2 r a -> Rot f1 f2 r b -> Rot f1 f2 r a

Foldable r => Foldable (Rot f1 f2 r)

Methods

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

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

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

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

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

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

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

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

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

null :: Rot f1 f2 r a -> Bool

length :: Rot f1 f2 r a -> Int

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

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

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

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

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

Traversable r => Traversable (Rot f1 f2 r)

Methods

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

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

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

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

Generic1 (Rot f1 f2 r)

Associated Types

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

Methods

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

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

Eq (r a) => Eq (Rot f1 f2 r a)

Methods

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

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

Fractional (r a) => Fractional (Rot f1 f2 r a)

Methods

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

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

fromRational :: Rational -> Rot f1 f2 r a

Num (r a) => Num (Rot f1 f2 r a)

Methods

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

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

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

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

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

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

fromInteger :: Integer -> Rot f1 f2 r a

Ord (r a) => Ord (Rot f1 f2 r a)

Methods

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

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

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

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

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

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

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

Show (r a) => Show (Rot f1 f2 r a)

Methods

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

show :: Rot f1 f2 r a -> String

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

Generic (Rot f1 f2 r a)

Associated Types

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

Methods

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

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

Storable (r a) => Storable (Rot f1 f2 r a)

Methods

sizeOf :: Rot f1 f2 r a -> Int

alignment :: Rot f1 f2 r a -> Int

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

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

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

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

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

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

Binary (r a) => Binary (Rot f1 f2 r a)

Methods

put :: Rot f1 f2 r a -> Put

get :: Get (Rot f1 f2 r a)

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

Serialize (r a) => Serialize (Rot f1 f2 r a)

Methods

put :: Putter (Rot f1 f2 r a)

get :: Get (Rot f1 f2 r a)

type Rep1 (Rot f1 f2 r)

type Rep1 (Rot f1 f2 r) = D1 (MetaData "Rot" "SpatialMathT" "spatial-math-0.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" True) (C1 (MetaCons "Rot" PrefixI True) (S1 (MetaSel (Just Symbol "unRot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 r)))

type Rep (Rot f1 f2 r a)

type Rep (Rot f1 f2 r a) = D1 (MetaData "Rot" "SpatialMathT" "spatial-math-0.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" True) (C1 (MetaCons "Rot" PrefixI True) (S1 (MetaSel (Just Symbol "unRot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (r a))))

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.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" 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.5.0.0-7ZmyCvzLJtEFsuUgx5dFbW" 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)

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

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

dcmOfQuat :: Num a => Rot f g Quaternion a -> Rot f g (V3 :. V3) a

dcmOfEuler321 :: Floating a => Rot f g Euler a -> Rot f g (V3 :. V3) a

quatOfDcm :: (Floating a, Ord a) => Rot f g (V3 :. V3) a -> Rot f g Quaternion a

quatOfEuler321 :: Floating a => Rot f g Euler a -> Rot f g Quaternion a

euler321OfDcm :: (ArcTan2 a, Ord a) => Rot f g (V3 :. V3) a -> Rot f g Euler a

unsafeEuler321OfDcm :: ArcTan2 a => Rot f g (V3 :. V3) a -> Rot f g Euler a

euler321OfQuat :: (ArcTan2 a, Ord a) => Rot f g Quaternion a -> Rot f g Euler a

unsafeEuler321OfQuat :: ArcTan2 a => Rot f g Quaternion a -> Rot f g Euler a

re-export for convenience

newtype (g :. f) a :: (* -> *) -> (* -> *) -> * -> * infixl 9

Composition of unary type constructors

There are (at least) two useful Monoid instances, so you'll have to pick one and type-specialize it (filling in all or parts of g and/or f).

    -- standard Monoid instance for Applicative applied to Monoid
    instance (Applicative (g :. f), Monoid a) => Monoid ((g :. f) a) where
      { mempty = pure mempty; mappend = liftA2 mappend }
    -- Especially handy when g is a Monoid_f.
    instance Monoid (g (f a)) => Monoid ((g :. f) a) where
      { mempty = O mempty; mappend = inO2 mappend }

Corresponding to the first and second definitions above,

    instance (Applicative g, Monoid_f f) => Monoid_f (g :. f) where
      { mempty_f = O (pure mempty_f); mappend_f = inO2 (liftA2 mappend_f) }
    instance Monoid_f g => Monoid_f (g :. f) where
      { mempty_f = O mempty_f; mappend_f = inO2 mappend_f }

Similarly, there are two useful Functor instances and two useful ContraFunctor instances.

    instance (      Functor g,       Functor f) => Functor (g :. f) where fmap = fmapFF
    instance (ContraFunctor g, ContraFunctor f) => Functor (g :. f) where fmap = fmapCC

    instance (      Functor g, ContraFunctor f) => ContraFunctor (g :. f) where contraFmap = contraFmapFC
    instance (ContraFunctor g,       Functor f) => ContraFunctor (g :. f) where contraFmap = contraFmapCF

However, it's such a bother to define the Functor instances per composition type, I've left the fmapFF case in. If you want the fmapCC one, you're out of luck for now. I'd love to hear a good solution. Maybe someday Haskell will do Prolog-style search for instances, subgoaling the constraints, rather than just matching instance heads.

Constructors

O (g (f a))

Instances

(Functor g, Functor f) => Functor ((:.) g f)

Methods

fmap :: (a -> b) -> (g :. f) a -> (g :. f) b

(<$) :: a -> (g :. f) b -> (g :. f) a

(Applicative g, Applicative f) => Applicative ((:.) g f)

Methods

pure :: a -> (g :. f) a

(<*>) :: (g :. f) (a -> b) -> (g :. f) a -> (g :. f) b

(*>) :: (g :. f) a -> (g :. f) b -> (g :. f) b

(<*) :: (g :. f) a -> (g :. f) b -> (g :. f) a

(Foldable g, Foldable f, Functor g) => Foldable ((:.) g f)

Methods

fold :: Monoid m => (g :. f) m -> m

foldMap :: Monoid m => (a -> m) -> (g :. f) a -> m

foldr :: (a -> b -> b) -> b -> (g :. f) a -> b

foldr' :: (a -> b -> b) -> b -> (g :. f) a -> b

foldl :: (b -> a -> b) -> b -> (g :. f) a -> b

foldl' :: (b -> a -> b) -> b -> (g :. f) a -> b

foldr1 :: (a -> a -> a) -> (g :. f) a -> a

foldl1 :: (a -> a -> a) -> (g :. f) a -> a

toList :: (g :. f) a -> [a]

null :: (g :. f) a -> Bool

length :: (g :. f) a -> Int

elem :: Eq a => a -> (g :. f) a -> Bool

maximum :: Ord a => (g :. f) a -> a

minimum :: Ord a => (g :. f) a -> a

sum :: Num a => (g :. f) a -> a

product :: Num a => (g :. f) a -> a

(Traversable g, Traversable f) => Traversable ((:.) g f)

Methods

traverse :: Applicative f => (a -> f b) -> (g :. f) a -> f ((g :. f) b)

sequenceA :: Applicative f => (g :. f) (f a) -> f ((g :. f) a)

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

sequence :: Monad m => (g :. f) (m a) -> m ((g :. f) a)

Functor g => Generic1 ((:.) g f)

Associated Types

type Rep1 ((:.) g f :: * -> *) :: * -> *

Methods

from1 :: (g :. f) a -> Rep1 (g :. f) a

to1 :: Rep1 (g :. f) a -> (g :. f) a

Num a => Rotation ((:.) V3 V3) a

Methods

compose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f3 (V3 :. V3) a -> Rot f1 f3 (V3 :. V3) a

rot :: Rot f1 f2 (V3 :. V3) a -> V3T f1 a -> V3T f2 a

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

transpose :: Rot f1 f2 (V3 :. V3) a -> Rot f2 f1 (V3 :. V3) a

identity :: Rot f1 f2 (V3 :. V3) a

Eq (g (f a)) => Eq ((:.) g f a)

Methods

(==) :: (g :. f) a -> (g :. f) a -> Bool

(/=) :: (g :. f) a -> (g :. f) a -> Bool

Ord (g (f a)) => Ord ((:.) g f a)

Methods

compare :: (g :. f) a -> (g :. f) a -> Ordering

(<) :: (g :. f) a -> (g :. f) a -> Bool

(<=) :: (g :. f) a -> (g :. f) a -> Bool

(>) :: (g :. f) a -> (g :. f) a -> Bool

(>=) :: (g :. f) a -> (g :. f) a -> Bool

max :: (g :. f) a -> (g :. f) a -> (g :. f) a

min :: (g :. f) a -> (g :. f) a -> (g :. f) a

Show (g (f a)) => Show ((:.) g f a)

Methods

showsPrec :: Int -> (g :. f) a -> ShowS

show :: (g :. f) a -> String

showList :: [(g :. f) a] -> ShowS

Generic ((:.) g f a)

Associated Types

type Rep ((:.) g f a) :: * -> *

Methods

from :: (g :. f) a -> Rep ((g :. f) a) x

to :: Rep ((g :. f) a) x -> (g :. f) a

type Rep1 ((:.) g f)

type Rep1 ((:.) g f) = D1 (MetaData ":." "Control.Compose" "TypeCompose-0.9.12-8pdvuVL5uEI3bN8tD5X8fm" True) (C1 (MetaCons "O" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) g (Rec1 f))))

type Rep ((:.) g f a)

type Rep ((:.) g f a) = D1 (MetaData ":." "Control.Compose" "TypeCompose-0.9.12-8pdvuVL5uEI3bN8tD5X8fm" True) (C1 (MetaCons "O" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g (f a)))))

unO :: (:.) g f a -> g (f a)

Unwrap a '(:.)'.