{-# OPTIONS_GHC -Wall #-}
{-# Language MultiParamTypeClasses #-}
{-# Language FunctionalDependencies #-}
{-# Language FlexibleInstances #-}
{-# Language GeneralizedNewtypeDeriving #-}
{-# Language DeriveFunctor #-}
{-# Language DeriveFoldable #-}
{-# Language DeriveTraversable #-}
{-# Language DeriveGeneric #-}

module SpatialMathT
       ( Rotation(..)
       , Rot(..)
       , V3T(..)
       , R1(..), R2(..), R3(..)
       , M33T
       , cross
       , orthonormalize
       ) where

import Control.Applicative ( Applicative )
import Data.Foldable ( Foldable )
import Data.Binary ( Binary(..) )
import Data.Serialize ( Serialize(..) )
import Data.Traversable ( Traversable )
import Foreign.Storable ( Storable )
import GHC.Generics ( Generic, Generic1 )

import Linear hiding ( cross )
import qualified Linear as L

import SpatialMath

newtype V3T f a = V3T {forall f a. V3T f a -> V3 a
unV :: V3 a}
                deriving ( forall a b. a -> V3T f b -> V3T f a
forall a b. (a -> b) -> V3T f a -> V3T f b
forall f a b. a -> V3T f b -> V3T f a
forall f a b. (a -> b) -> V3T f a -> V3T f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> V3T f b -> V3T f a
$c<$ :: forall f a b. a -> V3T f b -> V3T f a
fmap :: forall a b. (a -> b) -> V3T f a -> V3T f b
$cfmap :: forall f a b. (a -> b) -> V3T f a -> V3T f b
Functor, forall a. Eq a => a -> V3T f a -> Bool
forall a. Num a => V3T f a -> a
forall a. Ord a => V3T f a -> a
forall m. Monoid m => V3T f m -> m
forall a. V3T f a -> Bool
forall a. V3T f a -> Int
forall a. V3T f a -> [a]
forall a. (a -> a -> a) -> V3T f a -> a
forall f a. Eq a => a -> V3T f a -> Bool
forall f a. Num a => V3T f a -> a
forall f a. Ord a => V3T f a -> a
forall m a. Monoid m => (a -> m) -> V3T f a -> m
forall f m. Monoid m => V3T f m -> m
forall f a. V3T f a -> Bool
forall f a. V3T f a -> Int
forall f a. V3T f a -> [a]
forall b a. (b -> a -> b) -> b -> V3T f a -> b
forall a b. (a -> b -> b) -> b -> V3T f a -> b
forall f a. (a -> a -> a) -> V3T f a -> a
forall f m a. Monoid m => (a -> m) -> V3T f a -> m
forall f b a. (b -> a -> b) -> b -> V3T f a -> b
forall f a b. (a -> b -> b) -> b -> V3T f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => V3T f a -> a
$cproduct :: forall f a. Num a => V3T f a -> a
sum :: forall a. Num a => V3T f a -> a
$csum :: forall f a. Num a => V3T f a -> a
minimum :: forall a. Ord a => V3T f a -> a
$cminimum :: forall f a. Ord a => V3T f a -> a
maximum :: forall a. Ord a => V3T f a -> a
$cmaximum :: forall f a. Ord a => V3T f a -> a
elem :: forall a. Eq a => a -> V3T f a -> Bool
$celem :: forall f a. Eq a => a -> V3T f a -> Bool
length :: forall a. V3T f a -> Int
$clength :: forall f a. V3T f a -> Int
null :: forall a. V3T f a -> Bool
$cnull :: forall f a. V3T f a -> Bool
toList :: forall a. V3T f a -> [a]
$ctoList :: forall f a. V3T f a -> [a]
foldl1 :: forall a. (a -> a -> a) -> V3T f a -> a
$cfoldl1 :: forall f a. (a -> a -> a) -> V3T f a -> a
foldr1 :: forall a. (a -> a -> a) -> V3T f a -> a
$cfoldr1 :: forall f a. (a -> a -> a) -> V3T f a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> V3T f a -> b
$cfoldl' :: forall f b a. (b -> a -> b) -> b -> V3T f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> V3T f a -> b
$cfoldl :: forall f b a. (b -> a -> b) -> b -> V3T f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> V3T f a -> b
$cfoldr' :: forall f a b. (a -> b -> b) -> b -> V3T f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> V3T f a -> b
$cfoldr :: forall f a b. (a -> b -> b) -> b -> V3T f a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> V3T f a -> m
$cfoldMap' :: forall f m a. Monoid m => (a -> m) -> V3T f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> V3T f a -> m
$cfoldMap :: forall f m a. Monoid m => (a -> m) -> V3T f a -> m
fold :: forall m. Monoid m => V3T f m -> m
$cfold :: forall f m. Monoid m => V3T f m -> m
Foldable, forall f. Functor (V3T f)
forall f. Foldable (V3T f)
forall f (m :: * -> *) a. Monad m => V3T f (m a) -> m (V3T f a)
forall f (f :: * -> *) a.
Applicative f =>
V3T f (f a) -> f (V3T f a)
forall f (m :: * -> *) a b.
Monad m =>
(a -> m b) -> V3T f a -> m (V3T f b)
forall f (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V3T f a -> f (V3T f b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V3T f a -> f (V3T f b)
sequence :: forall (m :: * -> *) a. Monad m => V3T f (m a) -> m (V3T f a)
$csequence :: forall f (m :: * -> *) a. Monad m => V3T f (m a) -> m (V3T f a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> V3T f a -> m (V3T f b)
$cmapM :: forall f (m :: * -> *) a b.
Monad m =>
(a -> m b) -> V3T f a -> m (V3T f b)
sequenceA :: forall (f :: * -> *) a. Applicative f => V3T f (f a) -> f (V3T f a)
$csequenceA :: forall f (f :: * -> *) a.
Applicative f =>
V3T f (f a) -> f (V3T f a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V3T f a -> f (V3T f b)
$ctraverse :: forall f (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V3T f a -> f (V3T f b)
Traversable
                         , forall f. Functor (V3T f)
forall a. a -> V3T f a
forall f a. a -> V3T f a
forall a b. V3T f a -> V3T f b -> V3T f a
forall a b. V3T f a -> V3T f b -> V3T f b
forall a b. V3T f (a -> b) -> V3T f a -> V3T f b
forall f a b. V3T f a -> V3T f b -> V3T f a
forall f a b. V3T f a -> V3T f b -> V3T f b
forall f a b. V3T f (a -> b) -> V3T f a -> V3T f b
forall a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
forall f a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b. V3T f a -> V3T f b -> V3T f a
$c<* :: forall f a b. V3T f a -> V3T f b -> V3T f a
*> :: forall a b. V3T f a -> V3T f b -> V3T f b
$c*> :: forall f a b. V3T f a -> V3T f b -> V3T f b
liftA2 :: forall a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
$cliftA2 :: forall f a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
<*> :: forall a b. V3T f (a -> b) -> V3T f a -> V3T f b
$c<*> :: forall f a b. V3T f (a -> b) -> V3T f a -> V3T f b
pure :: forall a. a -> V3T f a
$cpure :: forall f a. a -> V3T f a
Applicative
                         , forall f. Functor (V3T f)
forall a. Num a => V3T f a
forall a. Num a => a -> V3T f a -> V3T f a -> V3T f a
forall a. Num a => V3T f a -> V3T f a -> V3T f a
forall a. (a -> a -> a) -> V3T f a -> V3T f a -> V3T f a
forall f a. Num a => V3T f a
forall f a. Num a => a -> V3T f a -> V3T f a -> V3T f a
forall f a. Num a => V3T f a -> V3T f a -> V3T f a
forall f a. (a -> a -> a) -> V3T f a -> V3T f a -> V3T f a
forall a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
forall f a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
forall (f :: * -> *).
Functor f
-> (forall a. Num a => f a)
-> (forall a. Num a => f a -> f a -> f a)
-> (forall a. Num a => f a -> f a -> f a)
-> (forall a. Num a => a -> f a -> f a -> f a)
-> (forall a. (a -> a -> a) -> f a -> f a -> f a)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> Additive f
liftI2 :: forall a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
$cliftI2 :: forall f a b c. (a -> b -> c) -> V3T f a -> V3T f b -> V3T f c
liftU2 :: forall a. (a -> a -> a) -> V3T f a -> V3T f a -> V3T f a
$cliftU2 :: forall f a. (a -> a -> a) -> V3T f a -> V3T f a -> V3T f a
lerp :: forall a. Num a => a -> V3T f a -> V3T f a -> V3T f a
$clerp :: forall f a. Num a => a -> V3T f a -> V3T f a -> V3T f a
^-^ :: forall a. Num a => V3T f a -> V3T f a -> V3T f a
$c^-^ :: forall f a. Num a => V3T f a -> V3T f a -> V3T f a
^+^ :: forall a. Num a => V3T f a -> V3T f a -> V3T f a
$c^+^ :: forall f a. Num a => V3T f a -> V3T f a -> V3T f a
zero :: forall a. Num a => V3T f a
$czero :: forall f a. Num a => V3T f a
Additive, forall f. Additive (V3T f)
forall a. Floating a => V3T f a -> a
forall a. Floating a => V3T f a -> V3T f a
forall a. Floating a => V3T f a -> V3T f a -> a
forall a. Num a => V3T f a -> a
forall a. Num a => V3T f a -> V3T f a -> a
forall f a. Floating a => V3T f a -> a
forall f a. Floating a => V3T f a -> V3T f a
forall f a. Floating a => V3T f a -> V3T f a -> a
forall f a. Num a => V3T f a -> a
forall f a. Num a => V3T f a -> V3T f a -> a
forall (f :: * -> *).
Additive f
-> (forall a. Num a => f a -> f a -> a)
-> (forall a. Num a => f a -> a)
-> (forall a. Num a => f a -> f a -> a)
-> (forall a. Floating a => f a -> f a -> a)
-> (forall a. Floating a => f a -> a)
-> (forall a. Floating a => f a -> f a)
-> Metric f
signorm :: forall a. Floating a => V3T f a -> V3T f a
$csignorm :: forall f a. Floating a => V3T f a -> V3T f a
norm :: forall a. Floating a => V3T f a -> a
$cnorm :: forall f a. Floating a => V3T f a -> a
distance :: forall a. Floating a => V3T f a -> V3T f a -> a
$cdistance :: forall f a. Floating a => V3T f a -> V3T f a -> a
qd :: forall a. Num a => V3T f a -> V3T f a -> a
$cqd :: forall f a. Num a => V3T f a -> V3T f a -> a
quadrance :: forall a. Num a => V3T f a -> a
$cquadrance :: forall f a. Num a => V3T f a -> a
dot :: forall a. Num a => V3T f a -> V3T f a -> a
$cdot :: forall f a. Num a => V3T f a -> V3T f a -> a
Metric, Ptr (V3T f a) -> IO (V3T f a)
Ptr (V3T f a) -> Int -> IO (V3T f a)
Ptr (V3T f a) -> Int -> V3T f a -> IO ()
Ptr (V3T f a) -> V3T f a -> IO ()
V3T f a -> Int
forall b. Ptr b -> Int -> IO (V3T f a)
forall b. Ptr b -> Int -> V3T f a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall f a. Storable a => Ptr (V3T f a) -> IO (V3T f a)
forall f a. Storable a => Ptr (V3T f a) -> Int -> IO (V3T f a)
forall f a. Storable a => Ptr (V3T f a) -> Int -> V3T f a -> IO ()
forall f a. Storable a => Ptr (V3T f a) -> V3T f a -> IO ()
forall f a. Storable a => V3T f a -> Int
forall f a b. Storable a => Ptr b -> Int -> IO (V3T f a)
forall f a b. Storable a => Ptr b -> Int -> V3T f a -> IO ()
poke :: Ptr (V3T f a) -> V3T f a -> IO ()
$cpoke :: forall f a. Storable a => Ptr (V3T f a) -> V3T f a -> IO ()
peek :: Ptr (V3T f a) -> IO (V3T f a)
$cpeek :: forall f a. Storable a => Ptr (V3T f a) -> IO (V3T f a)
pokeByteOff :: forall b. Ptr b -> Int -> V3T f a -> IO ()
$cpokeByteOff :: forall f a b. Storable a => Ptr b -> Int -> V3T f a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (V3T f a)
$cpeekByteOff :: forall f a b. Storable a => Ptr b -> Int -> IO (V3T f a)
pokeElemOff :: Ptr (V3T f a) -> Int -> V3T f a -> IO ()
$cpokeElemOff :: forall f a. Storable a => Ptr (V3T f a) -> Int -> V3T f a -> IO ()
peekElemOff :: Ptr (V3T f a) -> Int -> IO (V3T f a)
$cpeekElemOff :: forall f a. Storable a => Ptr (V3T f a) -> Int -> IO (V3T f a)
alignment :: V3T f a -> Int
$calignment :: forall f a. Storable a => V3T f a -> Int
sizeOf :: V3T f a -> Int
$csizeOf :: forall f a. Storable a => V3T f a -> Int
Storable
                         , Integer -> V3T f a
V3T f a -> V3T f a
V3T f a -> V3T f a -> V3T f a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall f a. Num a => Integer -> V3T f a
forall f a. Num a => V3T f a -> V3T f a
forall f a. Num a => V3T f a -> V3T f a -> V3T f a
fromInteger :: Integer -> V3T f a
$cfromInteger :: forall f a. Num a => Integer -> V3T f a
signum :: V3T f a -> V3T f a
$csignum :: forall f a. Num a => V3T f a -> V3T f a
abs :: V3T f a -> V3T f a
$cabs :: forall f a. Num a => V3T f a -> V3T f a
negate :: V3T f a -> V3T f a
$cnegate :: forall f a. Num a => V3T f a -> V3T f a
* :: V3T f a -> V3T f a -> V3T f a
$c* :: forall f a. Num a => V3T f a -> V3T f a -> V3T f a
- :: V3T f a -> V3T f a -> V3T f a
$c- :: forall f a. Num a => V3T f a -> V3T f a -> V3T f a
+ :: V3T f a -> V3T f a -> V3T f a
$c+ :: forall f a. Num a => V3T f a -> V3T f a -> V3T f a
Num, Rational -> V3T f a
V3T f a -> V3T f a
V3T f a -> V3T f a -> V3T f a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall {f} {a}. Fractional a => Num (V3T f a)
forall f a. Fractional a => Rational -> V3T f a
forall f a. Fractional a => V3T f a -> V3T f a
forall f a. Fractional a => V3T f a -> V3T f a -> V3T f a
fromRational :: Rational -> V3T f a
$cfromRational :: forall f a. Fractional a => Rational -> V3T f a
recip :: V3T f a -> V3T f a
$crecip :: forall f a. Fractional a => V3T f a -> V3T f a
/ :: V3T f a -> V3T f a -> V3T f a
$c/ :: forall f a. Fractional a => V3T f a -> V3T f a -> V3T f a
Fractional, V3T f a -> V3T f a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall f a. Eq a => V3T f a -> V3T f a -> Bool
/= :: V3T f a -> V3T f a -> Bool
$c/= :: forall f a. Eq a => V3T f a -> V3T f a -> Bool
== :: V3T f a -> V3T f a -> Bool
$c== :: forall f a. Eq a => V3T f a -> V3T f a -> Bool
Eq, Int -> V3T f a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall f a. Show a => Int -> V3T f a -> ShowS
forall f a. Show a => [V3T f a] -> ShowS
forall f a. Show a => V3T f a -> String
showList :: [V3T f a] -> ShowS
$cshowList :: forall f a. Show a => [V3T f a] -> ShowS
show :: V3T f a -> String
$cshow :: forall f a. Show a => V3T f a -> String
showsPrec :: Int -> V3T f a -> ShowS
$cshowsPrec :: forall f a. Show a => Int -> V3T f a -> ShowS
Show, V3T f a -> V3T f a -> Bool
V3T f a -> V3T f a -> Ordering
V3T f a -> V3T f a -> V3T f a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {f} {a}. Ord a => Eq (V3T f a)
forall f a. Ord a => V3T f a -> V3T f a -> Bool
forall f a. Ord a => V3T f a -> V3T f a -> Ordering
forall f a. Ord a => V3T f a -> V3T f a -> V3T f a
min :: V3T f a -> V3T f a -> V3T f a
$cmin :: forall f a. Ord a => V3T f a -> V3T f a -> V3T f a
max :: V3T f a -> V3T f a -> V3T f a
$cmax :: forall f a. Ord a => V3T f a -> V3T f a -> V3T f a
>= :: V3T f a -> V3T f a -> Bool
$c>= :: forall f a. Ord a => V3T f a -> V3T f a -> Bool
> :: V3T f a -> V3T f a -> Bool
$c> :: forall f a. Ord a => V3T f a -> V3T f a -> Bool
<= :: V3T f a -> V3T f a -> Bool
$c<= :: forall f a. Ord a => V3T f a -> V3T f a -> Bool
< :: V3T f a -> V3T f a -> Bool
$c< :: forall f a. Ord a => V3T f a -> V3T f a -> Bool
compare :: V3T f a -> V3T f a -> Ordering
$ccompare :: forall f a. Ord a => V3T f a -> V3T f a -> Ordering
Ord
                         , forall f a. Rep1 (V3T f) a -> V3T f a
forall f a. V3T f a -> Rep1 (V3T f) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall f a. Rep1 (V3T f) a -> V3T f a
$cfrom1 :: forall f a. V3T f a -> Rep1 (V3T f) a
Generic1, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f a x. Rep (V3T f a) x -> V3T f a
forall f a x. V3T f a -> Rep (V3T f a) x
$cto :: forall f a x. Rep (V3T f a) x -> V3T f a
$cfrom :: forall f a x. V3T f a -> Rep (V3T f a) x
Generic
                         , Get (V3T f a)
Putter (V3T f a)
forall t. Putter t -> Get t -> Serialize t
forall f a. Serialize a => Get (V3T f a)
forall f a. Serialize a => Putter (V3T f a)
get :: Get (V3T f a)
$cget :: forall f a. Serialize a => Get (V3T f a)
put :: Putter (V3T f a)
$cput :: forall f a. Serialize a => Putter (V3T f a)
Serialize, Get (V3T f a)
[V3T f a] -> Put
V3T f a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall f a. Binary a => Get (V3T f a)
forall f a. Binary a => [V3T f a] -> Put
forall f a. Binary a => V3T f a -> Put
putList :: [V3T f a] -> Put
$cputList :: forall f a. Binary a => [V3T f a] -> Put
get :: Get (V3T f a)
$cget :: forall f a. Binary a => Get (V3T f a)
put :: V3T f a -> Put
$cput :: forall f a. Binary a => V3T f a -> Put
Binary
                         )

instance R1 (V3T f) where
  _x :: forall a. Lens' (V3T f a) a
_x a -> f a
f (V3T V3 a
v) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall f a. V3 a -> V3T f a
V3T forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. R1 t => Lens' (t a) a
_x a -> f a
f V3 a
v
  {-# INLINE _x #-}
instance R2 (V3T f) where
  _y :: forall a. Lens' (V3T f a) a
_y a -> f a
f (V3T V3 a
v) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall f a. V3 a -> V3T f a
V3T forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. R2 t => Lens' (t a) a
_y a -> f a
f V3 a
v
  {-# INLINE _y #-}
  _xy :: forall a. Lens' (V3T f a) (V2 a)
_xy V2 a -> f (V2 a)
f (V3T V3 a
v) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall f a. V3 a -> V3T f a
V3T forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. R2 t => Lens' (t a) (V2 a)
_xy V2 a -> f (V2 a)
f V3 a
v
  {-# INLINE _xy #-}
instance R3 (V3T f) where
  _z :: forall a. Lens' (V3T f a) a
_z a -> f a
f (V3T V3 a
v) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall f a. V3 a -> V3T f a
V3T forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. R3 t => Lens' (t a) a
_z a -> f a
f V3 a
v
  {-# INLINE _z #-}
  _xyz :: forall a. Lens' (V3T f a) (V3 a)
_xyz V3 a -> f (V3 a)
f (V3T V3 a
v) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall f a. V3 a -> V3T f a
V3T forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. R3 t => Lens' (t a) (V3 a)
_xyz V3 a -> f (V3 a)
f V3 a
v
  {-# INLINE _xyz #-}

cross :: Num a => V3T f a -> V3T f a -> V3T f a
cross :: forall a f. Num a => V3T f a -> V3T f a -> V3T f a
cross (V3T V3 a
vx) (V3T V3 a
vy) = forall f a. V3 a -> V3T f a
V3T (V3 a
vx forall a. Num a => V3 a -> V3 a -> V3 a
`L.cross` V3 a
vy)

newtype Rot f1 f2 r =
  Rot { forall f1 f2 r. Rot f1 f2 r -> r
unR :: r }
  deriving ( forall a b. a -> Rot f1 f2 b -> Rot f1 f2 a
forall a b. (a -> b) -> Rot f1 f2 a -> Rot f1 f2 b
forall f1 f2 a b. a -> Rot f1 f2 b -> Rot f1 f2 a
forall f1 f2 a b. (a -> b) -> Rot f1 f2 a -> Rot f1 f2 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Rot f1 f2 b -> Rot f1 f2 a
$c<$ :: forall f1 f2 a b. a -> Rot f1 f2 b -> Rot f1 f2 a
fmap :: forall a b. (a -> b) -> Rot f1 f2 a -> Rot f1 f2 b
$cfmap :: forall f1 f2 a b. (a -> b) -> Rot f1 f2 a -> Rot f1 f2 b
Functor, forall a. Rot f1 f2 a -> Bool
forall m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
forall a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
forall f1 f2 a. Eq a => a -> Rot f1 f2 a -> Bool
forall f1 f2 a. Num a => Rot f1 f2 a -> a
forall f1 f2 a. Ord a => Rot f1 f2 a -> a
forall f1 f2 m. Monoid m => Rot f1 f2 m -> m
forall f1 f2 a. Rot f1 f2 a -> Bool
forall f1 f2 a. Rot f1 f2 a -> Int
forall f1 f2 a. Rot f1 f2 a -> [a]
forall f1 f2 a. (a -> a -> a) -> Rot f1 f2 a -> a
forall f1 f2 m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
forall f1 f2 b a. (b -> a -> b) -> b -> Rot f1 f2 a -> b
forall f1 f2 a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Rot f1 f2 a -> a
$cproduct :: forall f1 f2 a. Num a => Rot f1 f2 a -> a
sum :: forall a. Num a => Rot f1 f2 a -> a
$csum :: forall f1 f2 a. Num a => Rot f1 f2 a -> a
minimum :: forall a. Ord a => Rot f1 f2 a -> a
$cminimum :: forall f1 f2 a. Ord a => Rot f1 f2 a -> a
maximum :: forall a. Ord a => Rot f1 f2 a -> a
$cmaximum :: forall f1 f2 a. Ord a => Rot f1 f2 a -> a
elem :: forall a. Eq a => a -> Rot f1 f2 a -> Bool
$celem :: forall f1 f2 a. Eq a => a -> Rot f1 f2 a -> Bool
length :: forall a. Rot f1 f2 a -> Int
$clength :: forall f1 f2 a. Rot f1 f2 a -> Int
null :: forall a. Rot f1 f2 a -> Bool
$cnull :: forall f1 f2 a. Rot f1 f2 a -> Bool
toList :: forall a. Rot f1 f2 a -> [a]
$ctoList :: forall f1 f2 a. Rot f1 f2 a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Rot f1 f2 a -> a
$cfoldl1 :: forall f1 f2 a. (a -> a -> a) -> Rot f1 f2 a -> a
foldr1 :: forall a. (a -> a -> a) -> Rot f1 f2 a -> a
$cfoldr1 :: forall f1 f2 a. (a -> a -> a) -> Rot f1 f2 a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Rot f1 f2 a -> b
$cfoldl' :: forall f1 f2 b a. (b -> a -> b) -> b -> Rot f1 f2 a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Rot f1 f2 a -> b
$cfoldl :: forall f1 f2 b a. (b -> a -> b) -> b -> Rot f1 f2 a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
$cfoldr' :: forall f1 f2 a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
$cfoldr :: forall f1 f2 a b. (a -> b -> b) -> b -> Rot f1 f2 a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
$cfoldMap' :: forall f1 f2 m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
$cfoldMap :: forall f1 f2 m a. Monoid m => (a -> m) -> Rot f1 f2 a -> m
fold :: forall m. Monoid m => Rot f1 f2 m -> m
$cfold :: forall f1 f2 m. Monoid m => Rot f1 f2 m -> m
Foldable, forall f1 f2. Functor (Rot f1 f2)
forall f1 f2. Foldable (Rot f1 f2)
forall f1 f2 (m :: * -> *) a.
Monad m =>
Rot f1 f2 (m a) -> m (Rot f1 f2 a)
forall f1 f2 (f :: * -> *) a.
Applicative f =>
Rot f1 f2 (f a) -> f (Rot f1 f2 a)
forall f1 f2 (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rot f1 f2 a -> m (Rot f1 f2 b)
forall f1 f2 (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rot f1 f2 a -> f (Rot f1 f2 b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rot f1 f2 a -> f (Rot f1 f2 b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Rot f1 f2 (m a) -> m (Rot f1 f2 a)
$csequence :: forall f1 f2 (m :: * -> *) a.
Monad m =>
Rot f1 f2 (m a) -> m (Rot f1 f2 a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rot f1 f2 a -> m (Rot f1 f2 b)
$cmapM :: forall f1 f2 (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rot f1 f2 a -> m (Rot f1 f2 b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Rot f1 f2 (f a) -> f (Rot f1 f2 a)
$csequenceA :: forall f1 f2 (f :: * -> *) a.
Applicative f =>
Rot f1 f2 (f a) -> f (Rot f1 f2 a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rot f1 f2 a -> f (Rot f1 f2 b)
$ctraverse :: forall f1 f2 (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rot f1 f2 a -> f (Rot f1 f2 b)
Traversable
           , Ptr (Rot f1 f2 r) -> IO (Rot f1 f2 r)
Ptr (Rot f1 f2 r) -> Int -> IO (Rot f1 f2 r)
Ptr (Rot f1 f2 r) -> Int -> Rot f1 f2 r -> IO ()
Ptr (Rot f1 f2 r) -> Rot f1 f2 r -> IO ()
Rot f1 f2 r -> Int
forall b. Ptr b -> Int -> IO (Rot f1 f2 r)
forall b. Ptr b -> Int -> Rot f1 f2 r -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall f1 f2 r. Storable r => Ptr (Rot f1 f2 r) -> IO (Rot f1 f2 r)
forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Int -> IO (Rot f1 f2 r)
forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Int -> Rot f1 f2 r -> IO ()
forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Rot f1 f2 r -> IO ()
forall f1 f2 r. Storable r => Rot f1 f2 r -> Int
forall f1 f2 r b. Storable r => Ptr b -> Int -> IO (Rot f1 f2 r)
forall f1 f2 r b.
Storable r =>
Ptr b -> Int -> Rot f1 f2 r -> IO ()
poke :: Ptr (Rot f1 f2 r) -> Rot f1 f2 r -> IO ()
$cpoke :: forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Rot f1 f2 r -> IO ()
peek :: Ptr (Rot f1 f2 r) -> IO (Rot f1 f2 r)
$cpeek :: forall f1 f2 r. Storable r => Ptr (Rot f1 f2 r) -> IO (Rot f1 f2 r)
pokeByteOff :: forall b. Ptr b -> Int -> Rot f1 f2 r -> IO ()
$cpokeByteOff :: forall f1 f2 r b.
Storable r =>
Ptr b -> Int -> Rot f1 f2 r -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (Rot f1 f2 r)
$cpeekByteOff :: forall f1 f2 r b. Storable r => Ptr b -> Int -> IO (Rot f1 f2 r)
pokeElemOff :: Ptr (Rot f1 f2 r) -> Int -> Rot f1 f2 r -> IO ()
$cpokeElemOff :: forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Int -> Rot f1 f2 r -> IO ()
peekElemOff :: Ptr (Rot f1 f2 r) -> Int -> IO (Rot f1 f2 r)
$cpeekElemOff :: forall f1 f2 r.
Storable r =>
Ptr (Rot f1 f2 r) -> Int -> IO (Rot f1 f2 r)
alignment :: Rot f1 f2 r -> Int
$calignment :: forall f1 f2 r. Storable r => Rot f1 f2 r -> Int
sizeOf :: Rot f1 f2 r -> Int
$csizeOf :: forall f1 f2 r. Storable r => Rot f1 f2 r -> Int
Storable
           , Integer -> Rot f1 f2 r
Rot f1 f2 r -> Rot f1 f2 r
Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall f1 f2 r. Num r => Integer -> Rot f1 f2 r
forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r
forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
fromInteger :: Integer -> Rot f1 f2 r
$cfromInteger :: forall f1 f2 r. Num r => Integer -> Rot f1 f2 r
signum :: Rot f1 f2 r -> Rot f1 f2 r
$csignum :: forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r
abs :: Rot f1 f2 r -> Rot f1 f2 r
$cabs :: forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r
negate :: Rot f1 f2 r -> Rot f1 f2 r
$cnegate :: forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r
* :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
$c* :: forall f1 f2 r. Num 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
$c- :: forall f1 f2 r. Num 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
$c+ :: forall f1 f2 r. Num r => Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
Num, Rational -> Rot f1 f2 r
Rot f1 f2 r -> Rot f1 f2 r
Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall {f1} {f2} {r}. Fractional r => Num (Rot f1 f2 r)
forall f1 f2 r. Fractional r => Rational -> Rot f1 f2 r
forall f1 f2 r. Fractional r => Rot f1 f2 r -> Rot f1 f2 r
forall f1 f2 r.
Fractional r =>
Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
fromRational :: Rational -> Rot f1 f2 r
$cfromRational :: forall f1 f2 r. Fractional r => Rational -> Rot f1 f2 r
recip :: Rot f1 f2 r -> Rot f1 f2 r
$crecip :: forall f1 f2 r. Fractional r => Rot f1 f2 r -> Rot f1 f2 r
/ :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
$c/ :: forall f1 f2 r.
Fractional r =>
Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
Fractional, Rot f1 f2 r -> Rot f1 f2 r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall f1 f2 r. Eq r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
/= :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c/= :: forall f1 f2 r. Eq r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
== :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c== :: forall f1 f2 r. Eq r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
Eq, Int -> Rot f1 f2 r -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall f1 f2 r. Show r => Int -> Rot f1 f2 r -> ShowS
forall f1 f2 r. Show r => [Rot f1 f2 r] -> ShowS
forall f1 f2 r. Show r => Rot f1 f2 r -> String
showList :: [Rot f1 f2 r] -> ShowS
$cshowList :: forall f1 f2 r. Show r => [Rot f1 f2 r] -> ShowS
show :: Rot f1 f2 r -> String
$cshow :: forall f1 f2 r. Show r => Rot f1 f2 r -> String
showsPrec :: Int -> Rot f1 f2 r -> ShowS
$cshowsPrec :: forall f1 f2 r. Show r => Int -> Rot f1 f2 r -> ShowS
Show, Rot f1 f2 r -> Rot f1 f2 r -> Bool
Rot f1 f2 r -> Rot f1 f2 r -> Ordering
Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {f1} {f2} {r}. Ord r => Eq (Rot f1 f2 r)
forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Ordering
forall f1 f2 r. Ord r => 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
$cmin :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
max :: Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
$cmax :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Rot f1 f2 r
>= :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c>= :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
> :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c> :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
<= :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c<= :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
< :: Rot f1 f2 r -> Rot f1 f2 r -> Bool
$c< :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Bool
compare :: Rot f1 f2 r -> Rot f1 f2 r -> Ordering
$ccompare :: forall f1 f2 r. Ord r => Rot f1 f2 r -> Rot f1 f2 r -> Ordering
Ord
           , forall f1 f2 a. Rep1 (Rot f1 f2) a -> Rot f1 f2 a
forall f1 f2 a. Rot f1 f2 a -> Rep1 (Rot f1 f2) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall f1 f2 a. Rep1 (Rot f1 f2) a -> Rot f1 f2 a
$cfrom1 :: forall f1 f2 a. Rot f1 f2 a -> Rep1 (Rot f1 f2) a
Generic1, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f1 f2 r x. Rep (Rot f1 f2 r) x -> Rot f1 f2 r
forall f1 f2 r x. Rot f1 f2 r -> Rep (Rot f1 f2 r) x
$cto :: forall f1 f2 r x. Rep (Rot f1 f2 r) x -> Rot f1 f2 r
$cfrom :: forall f1 f2 r x. Rot f1 f2 r -> Rep (Rot f1 f2 r) x
Generic
           , Get (Rot f1 f2 r)
Putter (Rot f1 f2 r)
forall t. Putter t -> Get t -> Serialize t
forall f1 f2 r. Serialize r => Get (Rot f1 f2 r)
forall f1 f2 r. Serialize r => Putter (Rot f1 f2 r)
get :: Get (Rot f1 f2 r)
$cget :: forall f1 f2 r. Serialize r => Get (Rot f1 f2 r)
put :: Putter (Rot f1 f2 r)
$cput :: forall f1 f2 r. Serialize r => Putter (Rot f1 f2 r)
Serialize, Get (Rot f1 f2 r)
[Rot f1 f2 r] -> Put
Rot f1 f2 r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall f1 f2 r. Binary r => Get (Rot f1 f2 r)
forall f1 f2 r. Binary r => [Rot f1 f2 r] -> Put
forall f1 f2 r. Binary r => Rot f1 f2 r -> Put
putList :: [Rot f1 f2 r] -> Put
$cputList :: forall f1 f2 r. Binary r => [Rot f1 f2 r] -> Put
get :: Get (Rot f1 f2 r)
$cget :: forall f1 f2 r. Binary r => Get (Rot f1 f2 r)
put :: Rot f1 f2 r -> Put
$cput :: forall f1 f2 r. Binary r => Rot f1 f2 r -> Put
Binary
           )

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

class Rotation p a | p -> a where
  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)
--  fromDcm :: Rot f1 f2 (M33 a) -> Rot f1 f2 (p a)
  transpose :: Rot f1 f2 p -> Rot f2 f1 p

instance Num a => Rotation (Quaternion a) a where
  compose :: forall f1 f2 f3.
Rot f1 f2 (Quaternion a)
-> Rot f2 f3 (Quaternion a) -> Rot f1 f3 (Quaternion a)
compose (Rot Quaternion a
q_a2b) (Rot Quaternion a
q_b2c) = forall f1 f2 r. r -> Rot f1 f2 r
Rot (Quaternion a
q_a2b forall a. Num a => Quaternion a -> Quaternion a -> Quaternion a
`quatMult` Quaternion a
q_b2c)
  rot :: forall f1 f2. Rot f1 f2 (Quaternion a) -> V3T f1 a -> V3T f2 a
rot  (Rot Quaternion a
q_a2b) (V3T V3 a
va) = forall f a. V3 a -> V3T f a
V3T (forall a. Num a => Quaternion a -> V3 a -> V3 a
rotVecByQuat    Quaternion a
q_a2b V3 a
va)
  rot' :: forall f1 f2. Rot f1 f2 (Quaternion a) -> V3T f2 a -> V3T f1 a
rot' (Rot Quaternion a
q_a2b) (V3T V3 a
vb) = forall f a. V3 a -> V3T f a
V3T (forall a. Num a => Quaternion a -> V3 a -> V3 a
rotVecByQuatB2A Quaternion a
q_a2b V3 a
vb)
  toDcm :: forall f1 f2. Rot f1 f2 (Quaternion a) -> Rot f1 f2 (M33 a)
toDcm (Rot Quaternion a
q_a2b) = forall f1 f2 r. r -> Rot f1 f2 r
Rot (forall a. Num a => Quaternion a -> M33 a
dcmOfQuat Quaternion a
q_a2b)
--  fromDcm (Rot dcm_a2b) = Rot (quatOfDcm dcm_a2b)
  transpose :: forall f1 f2. Rot f1 f2 (Quaternion a) -> Rot f2 f1 (Quaternion a)
transpose (Rot (Quaternion a
q0 V3 a
qxyz)) = forall f1 f2 r. r -> Rot f1 f2 r
Rot (forall a. a -> V3 a -> Quaternion a
Quaternion a
q0 (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Num a => a -> a
negate V3 a
qxyz))

-- quaternion multiplication which doesn't require RealFrac
quatMult :: Num a => Quaternion a -> Quaternion a -> Quaternion a
quatMult :: forall a. Num a => Quaternion a -> Quaternion a -> Quaternion a
quatMult (Quaternion a
s1 V3 a
v1) (Quaternion a
s2 V3 a
v2) =
  forall a. a -> V3 a -> Quaternion a
Quaternion (a
s1forall a. Num a => a -> a -> a
*a
s2 forall a. Num a => a -> a -> a
- (V3 a
v1 forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
`dot` V3 a
v2)) forall a b. (a -> b) -> a -> b
$
  (V3 a
v1 forall a. Num a => V3 a -> V3 a -> V3 a
`L.cross` V3 a
v2) forall a. Num a => a -> a -> a
+ a
s1forall (f :: * -> *) a. (Functor f, Num a) => a -> f a -> f a
*^V3 a
v2 forall a. Num a => a -> a -> a
+ a
s2forall (f :: * -> *) a. (Functor f, Num a) => a -> f a -> f a
*^V3 a
v1

instance Num a => Rotation (M33 a) a where
  compose :: forall f1 f2 f3.
Rot f1 f2 (M33 a) -> Rot f2 f3 (M33 a) -> Rot f1 f3 (M33 a)
compose (Rot M33 a
dcm_a2b) (Rot M33 a
dcm_b2c) = forall f1 f2 r. r -> Rot f1 f2 r
Rot (M33 a
dcm_b2c forall (m :: * -> *) (t :: * -> *) (n :: * -> *) a.
(Functor m, Foldable t, Additive t, Additive n, Num a) =>
m (t a) -> t (n a) -> m (n a)
!*! M33 a
dcm_a2b)
  rot :: forall f1 f2. Rot f1 f2 (M33 a) -> V3T f1 a -> V3T f2 a
rot  (Rot M33 a
dcm_a2b) (V3T V3 a
va) = forall f a. V3 a -> V3T f a
V3T (forall a. Num a => M33 a -> V3 a -> V3 a
rotVecByDcm    M33 a
dcm_a2b V3 a
va)
  rot' :: forall f1 f2. Rot f1 f2 (M33 a) -> V3T f2 a -> V3T f1 a
rot' (Rot M33 a
dcm_a2b) (V3T V3 a
vb) = forall f a. V3 a -> V3T f a
V3T (forall a. Num a => M33 a -> V3 a -> V3 a
rotVecByDcmB2A M33 a
dcm_a2b V3 a
vb)
  toDcm :: forall f1 f2. Rot f1 f2 (M33 a) -> Rot f1 f2 (M33 a)
toDcm = forall a. a -> a
id
  transpose :: forall f1 f2. Rot f1 f2 (M33 a) -> Rot f2 f1 (M33 a)
transpose (Rot (V3
                  (V3 a
e11 a
e12 a
e13)
                  (V3 a
e21 a
e22 a
e23)
                  (V3 a
e31 a
e32 a
e33))) =
    forall f1 f2 r. r -> Rot f1 f2 r
Rot (forall a. a -> a -> a -> V3 a
V3
         (forall a. a -> a -> a -> V3 a
V3 a
e11 a
e21 a
e31)
         (forall a. a -> a -> a -> V3 a
V3 a
e12 a
e22 a
e32)
         (forall a. a -> a -> a -> V3 a
V3 a
e13 a
e23 a
e33))

orthonormalize :: Floating a => Rot f1 f2 (M33 a) -> Rot f1 f2 (M33 a)
orthonormalize :: forall a f1 f2.
Floating a =>
Rot f1 f2 (M33 a) -> Rot f1 f2 (M33 a)
orthonormalize (Rot (V3
                     (V3 a
m00 a
m01 a
m02)
                     (V3 a
m10 a
m11 a
m12)
                     (V3 a
m20 a
m21 a
m22))) = forall f1 f2 r. r -> Rot f1 f2 r
Rot M33 a
ret
  where
    -- compute q0
    fInvLength0 :: a
fInvLength0 = a
1.0forall a. Fractional a => a -> a -> a
/forall a. Floating a => a -> a
sqrt(a
m00forall a. Num a => a -> a -> a
*a
m00 forall a. Num a => a -> a -> a
+ a
m10forall a. Num a => a -> a -> a
*a
m10 forall a. Num a => a -> a -> a
+ a
m20forall a. Num a => a -> a -> a
*a
m20)

    m00' :: a
m00' = a
m00forall a. Num a => a -> a -> a
*a
fInvLength0
    m10' :: a
m10' = a
m10forall a. Num a => a -> a -> a
*a
fInvLength0
    m20' :: a
m20' = a
m20forall a. Num a => a -> a -> a
*a
fInvLength0

    -- compute q1
    fDot0' :: a
fDot0' = a
m00'forall a. Num a => a -> a -> a
*a
m01 forall a. Num a => a -> a -> a
+ a
m10'forall a. Num a => a -> a -> a
*a
m11 forall a. Num a => a -> a -> a
+ a
m20'forall a. Num a => a -> a -> a
*a
m21

    m01' :: a
m01' = a
m01 forall a. Num a => a -> a -> a
- a
fDot0'forall a. Num a => a -> a -> a
*a
m00'
    m11' :: a
m11' = a
m11 forall a. Num a => a -> a -> a
- a
fDot0'forall a. Num a => a -> a -> a
*a
m10'
    m21' :: a
m21' = a
m21 forall a. Num a => a -> a -> a
- a
fDot0'forall a. Num a => a -> a -> a
*a
m20'

    fInvLength1 :: a
fInvLength1 = a
1.0forall a. Fractional a => a -> a -> a
/forall a. Floating a => a -> a
sqrt(a
m01'forall a. Num a => a -> a -> a
*a
m01' forall a. Num a => a -> a -> a
+ a
m11'forall a. Num a => a -> a -> a
*a
m11' forall a. Num a => a -> a -> a
+ a
m21'forall a. Num a => a -> a -> a
*a
m21')

    m01'' :: a
m01'' = a
m01' forall a. Num a => a -> a -> a
* a
fInvLength1
    m11'' :: a
m11'' = a
m11' forall a. Num a => a -> a -> a
* a
fInvLength1
    m21'' :: a
m21'' = a
m21' forall a. Num a => a -> a -> a
* a
fInvLength1

    -- compute q2
    fDot1 :: a
fDot1 = a
m01''forall a. Num a => a -> a -> a
*a
m02 forall a. Num a => a -> a -> a
+ a
m11''forall a. Num a => a -> a -> a
*a
m12 forall a. Num a => a -> a -> a
+ a
m21''forall a. Num a => a -> a -> a
*a
m22
    fDot0 :: a
fDot0 = a
m00'forall a. Num a => a -> a -> a
*a
m02 forall a. Num a => a -> a -> a
+ a
m10'forall a. Num a => a -> a -> a
*a
m12 forall a. Num a => a -> a -> a
+ a
m20'forall a. Num a => a -> a -> a
*a
m22

    m02' :: a
m02' = a
m02 forall a. Num a => a -> a -> a
- (a
fDot0forall a. Num a => a -> a -> a
*a
m00' forall a. Num a => a -> a -> a
+ a
fDot1forall a. Num a => a -> a -> a
*a
m01'')
    m12' :: a
m12' = a
m12 forall a. Num a => a -> a -> a
- (a
fDot0forall a. Num a => a -> a -> a
*a
m10' forall a. Num a => a -> a -> a
+ a
fDot1forall a. Num a => a -> a -> a
*a
m11'')
    m22' :: a
m22' = a
m22 forall a. Num a => a -> a -> a
- (a
fDot0forall a. Num a => a -> a -> a
*a
m20' forall a. Num a => a -> a -> a
+ a
fDot1forall a. Num a => a -> a -> a
*a
m21'')

    fInvLength2 :: a
fInvLength2 = a
1.0forall a. Fractional a => a -> a -> a
/forall a. Floating a => a -> a
sqrt(a
m02'forall a. Num a => a -> a -> a
*a
m02' forall a. Num a => a -> a -> a
+ a
m12'forall a. Num a => a -> a -> a
*a
m12' forall a. Num a => a -> a -> a
+ a
m22'forall a. Num a => a -> a -> a
*a
m22')

    m02'' :: a
m02'' = a
m02' forall a. Num a => a -> a -> a
* a
fInvLength2
    m12'' :: a
m12'' = a
m12' forall a. Num a => a -> a -> a
* a
fInvLength2
    m22'' :: a
m22'' = a
m22' forall a. Num a => a -> a -> a
* a
fInvLength2

    ret :: M33 a
ret = (forall a. a -> a -> a -> V3 a
V3
           (forall a. a -> a -> a -> V3 a
V3 a
m00' a
m01'' a
m02'')
           (forall a. a -> a -> a -> V3 a
V3 a
m10' a
m11'' a
m12'')
           (forall a. a -> a -> a -> V3 a
V3 a
m20' a
m21'' a
m22''))