{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash                  #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE TypeFamilies               #-}
{-# LANGUAGE TypeInType                 #-}
{-# LANGUAGE UnboxedTuples              #-}
{-# LANGUAGE UndecidableInstances       #-}
{-# LANGUAGE ViewPatterns               #-}
{-# OPTIONS_GHC -fno-warn-orphans       #-}
module Numeric.Quaternion.Internal.QDouble
    ( QDouble, Quater (..)
    ) where

import qualified Control.Monad.ST                     as ST
import           Data.Coerce                          (coerce)
import           Numeric.Basics
import           Numeric.DataFrame.Internal.PrimArray
import qualified Numeric.DataFrame.ST                 as ST
import           Numeric.DataFrame.Type
import           Numeric.Quaternion.Internal
import           Numeric.Vector.Internal

type QDouble = Quater Double

deriving instance PrimBytes (Quater Double)
deriving instance PrimArray Double (Quater Double)

instance Quaternion Double where
    newtype Quater Double = QDouble (Vector Double 4)
    {-# INLINE packQ #-}
    packQ :: Double -> Double -> Double -> Double -> Quater Double
packQ = (Double -> Double -> Double -> Double -> Vector Double 4)
-> Double -> Double -> Double -> Double -> Quater Double
coerce (Double -> Double -> Double -> Double -> Vector Double 4
forall t. Vector4 t => t -> t -> t -> t -> Vector t 4
vec4 :: Double -> Double -> Double -> Double -> Vector Double 4)
    {-# INLINE unpackQ# #-}
    unpackQ# :: Quater Double -> (# Double, Double, Double, Double #)
unpackQ# = (Vector Double 4 -> (# Double, Double, Double, Double #))
-> Quater Double -> (# Double, Double, Double, Double #)
coerce (Vector Double 4 -> (# Double, Double, Double, Double #)
forall t. Vector4 t => Vector t 4 -> (# t, t, t, t #)
unpackV4# :: Vector Double 4 -> (# Double, Double, Double, Double #))
    {-# INLINE fromVecNum #-}
    fromVecNum :: Vector Double 3 -> Double -> Quater Double
fromVecNum (Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# -> (# Double
x, Double
y, Double
z #))  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z
    {-# INLINE fromVec4 #-}
    fromVec4 :: Vector Double 4 -> Quater Double
fromVec4 = Vector Double 4 -> Quater Double
coerce
    {-# INLINE toVec4 #-}
    toVec4 :: Quater Double -> Vector Double 4
toVec4 = Quater Double -> Vector Double 4
coerce
    {-# INLINE square #-}
    square :: Quater Double -> Double
square (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #)) = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w)
    {-# INLINE im #-}
    im :: Quater Double -> Quater Double
im (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
_ #)) = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z Double
0.0
    {-# INLINE re #-}
    re :: Quater Double -> Quater Double
re (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
_, Double
_, Double
_, Double
w #)) = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 Double
w
    {-# INLINE imVec #-}
    imVec :: Quater Double -> Vector Double 3
imVec (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
_ #)) = Double -> Double -> Double -> Vector Double 3
forall t. Vector3 t => t -> t -> t -> Vector t 3
vec3 Double
x Double
y Double
z
    {-# INLINE taker #-}
    taker :: Quater Double -> Double
taker (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
_, Double
_, Double
_, Double
w #)) = Double
w
    {-# INLINE takei #-}
    takei :: Quater Double -> Double
takei (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
_, Double
_, Double
_ #)) = Double
x
    {-# INLINE takej #-}
    takej :: Quater Double -> Double
takej (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
_, Double
y, Double
_, Double
_ #)) = Double
y
    {-# INLINE takek #-}
    takek :: Quater Double -> Double
takek (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
_, Double
_, Double
z, Double
_ #)) = Double
z
    {-# INLINE conjugate #-}
    conjugate :: Quater Double -> Quater Double
conjugate (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double -> Double
forall a. Num a => a -> a
negate Double
x) (Double -> Double
forall a. Num a => a -> a
negate Double
y) (Double -> Double
forall a. Num a => a -> a
negate Double
z) Double
w
    {-# INLINE rotScale #-}
    rotScale :: Quater Double -> Vector Double 3 -> Vector Double 3
rotScale (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
i, Double
j, Double
k, Double
t #))
             (Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# -> (# Double
x, Double
y, Double
z #))
      = let l :: Double
l = Double
tDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
t Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
iDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
i Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
jDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
j Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
kDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
k
            d :: Double
d = Double
2.0 Double -> Double -> Double
forall a. Num a => a -> a -> a
* ( Double
iDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
jDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
kDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
z)
            t2 :: Double
t2 = Double
t Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
2.0
        in Double -> Double -> Double -> Vector Double 3
forall t. Vector3 t => t -> t -> t -> Vector t 3
vec3 (Double
lDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
dDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
i Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
t2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
j Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
k))
                (Double
lDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
dDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
j Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
t2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
k Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
i))
                (Double
lDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
dDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
k Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
t2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
i Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
j))
    {-# INLINE getRotScale #-}
    getRotScale :: Vector Double 3 -> Vector Double 3 -> Quater Double
getRotScale Vector Double 3
a Vector Double 3
b = case (# Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# Vector Double 3
a, Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# Vector Double 3
b #) of
      (# (# Double, Double, Double #)
_, (# Double
0, Double
0, Double
0 #) #) -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 Double
0
      (# (# Double
0, Double
0, Double
0 #), (# Double, Double, Double #)
_ #) -> let x :: Double
x = (Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 :: Double) in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
x Double
x Double
x
      (# (# Double
a1, Double
a2, Double
a3 #), (# Double
b1, Double
b2, Double
b3 #) #) ->
        let ma :: Double
ma = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
a1Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
a1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
a2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
a2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
a3Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
a3)
            mb :: Double
mb = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
b1Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
b2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
b3Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b3)
            d :: Double
d  = Double
a1Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
a2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
a3Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b3
            c :: Double
c  = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
maDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
mb Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
d)
            ma2 :: Double
ma2 = Double
ma Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
1.4142135623730951 -- sqrt 2.0
            r :: Double
r  = Double -> Double
forall a. Fractional a => a -> a
recip (Double
ma2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c)
            c' :: Double
c' = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
mb Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
ma) -- ratio of a and b for corner cases
            r' :: Double
r' = Double -> Double
forall a. Fractional a => a -> a
recip (Double -> Double
forall a. Floating a => a -> a
sqrt ( Double -> Double
forall a. Num a => a -> a
negate (Double
a1Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
a2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b2) ))
        in case Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# (Vector Double 3 -> Vector Double 3 -> Vector Double 3
forall t.
(Num t, PrimBytes t) =>
Vector t 3 -> Vector t 3 -> Vector t 3
cross Vector Double 3
a Vector Double 3
b) of
          (# Double
0, Double
0, Double
0 #)
              -- if a and b face the same direction, q is fully real
            | Double
d Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0       -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 Double
c'
              -- if a and b face opposite directions, find an orthogonal vector
              -- prerequisites: w == 0  and  a·(x,y,z) == 0
              -- corner cases: only one vector component is non-zero
            | Double
b1 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0      -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
c' Double
0 Double
0 Double
0
              -- otherwise set the last component to zero,
              -- and get an orthogonal vector in 2D.
            | Bool
otherwise    -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (-Double
b2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
r') (Double
b1Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
r') Double
0 Double
0
              -- NB: here we have some precision troubles
              --     when a and b are close to parallel and opposite.
          (# Double
t1, Double
t2, Double
t3 #) -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
t1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
r) (Double
t2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
r) (Double
t3 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
r) (Double
c Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
ma2)
    {-# INLINE axisRotation #-}
    axisRotation :: Vector Double 3 -> Double -> Quater Double
axisRotation Vector Double 3
v Double
a = case Vector Double 3 -> (# Double, Double, Double #)
forall t. Vector3 t => Vector t 3 -> (# t, t, t #)
unpackV3# Vector Double 3
v of
      (# Double
0, Double
0, Double
0 #) -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Bool -> Double -> Double
forall t. Num t => Bool -> t -> t
negateUnless (Double -> Double
forall a. Num a => a -> a
abs Double
a Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PI) Double
1)
      (# Double
x, Double
y, Double
z #) ->
        let c :: Double
c = Double -> Double
forall a. Floating a => a -> a
cos (Double
a Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
0.5)
            s :: Double
s = Double -> Double
forall a. Floating a => a -> a
sin (Double
a Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
0.5)
                Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double -> Double
forall a. Floating a => a -> a
sqrt (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
z)
        in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
s) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
s) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
s) Double
c
    {-# INLINE qArg #-}
    qArg :: Quater Double -> Double
qArg (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #)) = Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 (Double -> Double
forall a. Floating a => a -> a
sqrt (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
z)) Double
w
    {-# INLINE fromMatrix33 #-}
    fromMatrix33 :: Matrix Double 3 3 -> Quater Double
fromMatrix33 Matrix Double 3 3
m = Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Quater Double
fromM Double
1
      (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
0# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
1# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
2# Matrix Double 3 3
m)
      (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
3# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
4# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
5# Matrix Double 3 3
m)
      (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
6# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
7# Matrix Double 3 3
m) (Int# -> Matrix Double 3 3 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
8# Matrix Double 3 3
m)

    {-# INLINE fromMatrix44 #-}
    fromMatrix44 :: Matrix Double 4 4 -> Quater Double
fromMatrix44 Matrix Double 4 4
m = Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Quater Double
fromM (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
15# Matrix Double 4 4
m)
      (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
0# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
1# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
2# Matrix Double 4 4
m)
      (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
4# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
5# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
6# Matrix Double 4 4
m)
      (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
8# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
9# Matrix Double 4 4
m) (Int# -> Matrix Double 4 4 -> Double
forall t a. PrimArray t a => Int# -> a -> t
ix# Int#
10# Matrix Double 4 4
m)

    {-# INLINE toMatrix33 #-}
    toMatrix33 :: Quater Double -> Matrix Double 3 3
toMatrix33 (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
0.0, Double
0.0, Double
0.0, Double
w #))
      = let x :: Double
x = Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w
            f :: Int -> (# Int, Double #)
f Int
0 = (# Int
3 :: Int , Double
x #)
            f Int
k = (# Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1, Double
0 #)
        in case CumulDims
-> (Int -> (# Int, Double #))
-> Int
-> (# Int, Matrix Double 3 3 #)
forall t a s.
PrimArray t a =>
CumulDims -> (s -> (# s, t #)) -> s -> (# s, a #)
gen# ([Word] -> CumulDims
CumulDims [Word
9,Word
3,Word
1]) Int -> (# Int, Double #)
f Int
0 of
            (# Int
_, Matrix Double 3 3
m #) -> Matrix Double 3 3
m -- diag (scalar (w * w))
    toMatrix33 (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x', Double
y', Double
z', Double
w' #)) =
      let x :: DataFrame Double '[]
x = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
x'
          y :: DataFrame Double '[]
y = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
y'
          z :: DataFrame Double '[]
z = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
z'
          w :: DataFrame Double '[]
w = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
w'
          x2 :: DataFrame Double '[]
x2 = DataFrame Double '[]
x DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
x
          y2 :: DataFrame Double '[]
y2 = DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
y
          z2 :: DataFrame Double '[]
z2 = DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
z
          w2 :: DataFrame Double '[]
w2 = DataFrame Double '[]
w DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
w
          l2 :: DataFrame Double '[]
l2 = DataFrame Double '[]
x2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
y2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
w2
      in (forall s. ST s (Matrix Double 3 3)) -> Matrix Double 3 3
forall a. (forall s. ST s a) -> a
ST.runST ((forall s. ST s (Matrix Double 3 3)) -> Matrix Double 3 3)
-> (forall s. ST s (Matrix Double 3 3)) -> Matrix Double 3 3
forall a b. (a -> b) -> a -> b
$ do
        STDataFrame s Double '[3, 3]
df <- ST s (STDataFrame s Double '[3, 3])
forall k t (ns :: [k]) s.
(PrimBytes t, Dimensions ns) =>
ST s (STDataFrame s t ns)
ST.newDataFrame
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
0 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
y2)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
1 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
zDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
2 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
3 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
zDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
4 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
x2)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
5 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
6 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
7 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[3, 3]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[3, 3]
df Int
8 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
y2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
x2)
        STDataFrame s Double '[3, 3] -> ST s (Matrix Double 3 3)
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
ST.unsafeFreezeDataFrame STDataFrame s Double '[3, 3]
df
    {-# INLINE toMatrix44 #-}
    toMatrix44 :: Quater Double -> Matrix Double 4 4
toMatrix44 (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
0.0, Double
0.0, Double
0.0, Double
w #)) = (forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4
forall a. (forall s. ST s a) -> a
ST.runST ((forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4)
-> (forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4
forall a b. (a -> b) -> a -> b
$ do
      STDataFrame s Double '[4, 4]
df <- ST s (STDataFrame s Double '[4, 4])
forall k t (ns :: [k]) s.
(PrimBytes t, Dimensions ns) =>
ST s (STDataFrame s t ns)
ST.newDataFrame
      (Int -> ST s ()) -> [Int] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((Int -> DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> Int -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df) DataFrame Double '[]
0) [Int
0..Int
15]
      let w2 :: DataFrame Double '[]
w2 = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w)
      STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
0 DataFrame Double '[]
w2
      STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
5 DataFrame Double '[]
w2
      STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
10 DataFrame Double '[]
w2
      STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
15 DataFrame Double '[]
1
      STDataFrame s Double '[4, 4] -> ST s (Matrix Double 4 4)
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
ST.unsafeFreezeDataFrame STDataFrame s Double '[4, 4]
df
    toMatrix44 (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x', Double
y', Double
z', Double
w' #)) =
      let x :: DataFrame Double '[]
x = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
x'
          y :: DataFrame Double '[]
y = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
y'
          z :: DataFrame Double '[]
z = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
z'
          w :: DataFrame Double '[]
w = Double -> DataFrame Double '[]
forall t. t -> DataFrame t '[]
scalar Double
w'
          x2 :: DataFrame Double '[]
x2 = DataFrame Double '[]
x DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
x
          y2 :: DataFrame Double '[]
y2 = DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
y
          z2 :: DataFrame Double '[]
z2 = DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
z
          w2 :: DataFrame Double '[]
w2 = DataFrame Double '[]
w DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
* DataFrame Double '[]
w
          l2 :: DataFrame Double '[]
l2 = DataFrame Double '[]
x2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
y2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
w2
      in (forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4
forall a. (forall s. ST s a) -> a
ST.runST ((forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4)
-> (forall s. ST s (Matrix Double 4 4)) -> Matrix Double 4 4
forall a b. (a -> b) -> a -> b
$ do
        STDataFrame s Double '[4, 4]
df <- ST s (STDataFrame s Double '[4, 4])
forall k t (ns :: [k]) s.
(PrimBytes t, Dimensions ns) =>
ST s (STDataFrame s t ns)
ST.newDataFrame
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
0 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
y2)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
1 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
zDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
2 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
3 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
4 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
y DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
zDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
5 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
z2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
x2)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
6 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
7 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
8 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
9 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
yDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
z DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
xDataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*DataFrame Double '[]
w)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
10 (DataFrame Double '[] -> ST s ())
-> DataFrame Double '[] -> ST s ()
forall a b. (a -> b) -> a -> b
$ DataFrame Double '[]
l2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
- DataFrame Double '[]
2DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
*(DataFrame Double '[]
y2 DataFrame Double '[]
-> DataFrame Double '[] -> DataFrame Double '[]
forall a. Num a => a -> a -> a
+ DataFrame Double '[]
x2)
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
11 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
12 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
13 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
14 DataFrame Double '[]
0
        STDataFrame s Double '[4, 4]
-> Int -> DataFrame Double '[] -> ST s ()
forall k t (ns :: [k]) s.
PrimBytes (DataFrame t '[]) =>
STDataFrame s t ns -> Int -> DataFrame t '[] -> ST s ()
ST.writeDataFrameOff STDataFrame s Double '[4, 4]
df Int
15 DataFrame Double '[]
1
        STDataFrame s Double '[4, 4] -> ST s (Matrix Double 4 4)
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
ST.unsafeFreezeDataFrame STDataFrame s Double '[4, 4]
df


{- Calculate quaternion from a 3x3 matrix.

   First argument is a constant; it is either 1 for a 3x3 matrix,
   or m44 for a 4x4 matrix. I just need to multiply all components by
   this number.

   Further NB for the formulae:

   d == square q == det m ** (1/3)
   t == trace m  == 4 w w - d
   m01 - m10 == 4 z w
   m20 - m02 == 4 y w
   m12 - m21 == 4 x w
   m01 + m10 == 4 x y
   m20 + m02 == 4 x z
   m12 + m21 == 4 y z
   m00 == + x x - y y - z z + w w
   m11 == - x x + y y - z z + w w
   m22 == - x x - y y + z z + w w
   4 x x == d + m00 - m11 - m22
   4 y y == d - m00 + m11 - m22
   4 z z == d - m00 - m11 + m22
   4 w w == d + m00 + m11 + m22
 -}
fromM :: Double
      -> Double -> Double -> Double
      -> Double -> Double -> Double
      -> Double -> Double -> Double
      -> QDouble
fromM :: Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> Quater Double
fromM Double
c'
  Double
m00 Double
m01 Double
m02
  Double
m10 Double
m11 Double
m12
  Double
m20 Double
m21 Double
m22
    | Double
t Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
0
      = let dd :: Double
dd = Double -> Double
forall a. Floating a => a -> a
sqrt ( Double
d Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
t )
            is :: Double
is = Double
c Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
dd
        in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ ((Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m21)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m20 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m02)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m01 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m10)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) (Double
cDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
dd)
    | Double
m00 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
m11 Bool -> Bool -> Bool
&& Double
m00 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
m22
      = let dd :: Double
dd = Double -> Double
forall a. Floating a => a -> a
sqrt ( Double
d Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m00 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m22 )
            is :: Double
is = Double
c Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
dd
        in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
cDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
dd) ((Double
m01 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m10)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m02 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m20)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m21)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is)
    | Double
m11 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
m22
      = let dd :: Double
dd = Double -> Double
forall a. Floating a => a -> a
sqrt ( Double
d Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m00 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m22 )
            is :: Double
is = Double
c Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
dd
        in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ ((Double
m01 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m10)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) (Double
cDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
dd) ((Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m21)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m20 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m02)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is)
    | Bool
otherwise
      = let dd :: Double
dd = Double -> Double
forall a. Floating a => a -> a
sqrt ( Double
d Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m00 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m22 )
            is :: Double
is = Double
c Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
dd
        in Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ ((Double
m02 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m20)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) ((Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m21)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is) (Double
cDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
dd) ((Double
m01 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m10)Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
is)

  where
    -- normalizing constant
    c :: Double
c = Double -> Double
forall a. Fractional a => a -> a
recip (Double -> Double) -> Double -> Double
forall a b. (a -> b) -> a -> b
$ Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sqrt Double
c'
    -- trace
    t :: Double
t = Double
m00 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m22
    -- cubic root of determinant
    d :: Double
d = ( Double
m00 Double -> Double -> Double
forall a. Num a => a -> a -> a
* ( Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m22 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m21 )
        Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m01 Double -> Double -> Double
forall a. Num a => a -> a -> a
* ( Double
m10 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m22 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m12 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m20 )
        Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
m02 Double -> Double -> Double
forall a. Num a => a -> a -> a
* ( Double
m10 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m21 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
m11 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
m20 )
        ) Double -> Double -> Double
forall a. Floating a => a -> a -> a
** Double
0.33333333333333333333333333333333




instance Num QDouble where
    QDouble a + :: Quater Double -> Quater Double -> Quater Double
+ QDouble b
      = Vector Double 4 -> Quater Double
QDouble (Vector Double 4
a Vector Double 4 -> Vector Double 4 -> Vector Double 4
forall a. Num a => a -> a -> a
+ Vector Double 4
b)
    {-# INLINE (+) #-}
    QDouble a - :: Quater Double -> Quater Double -> Quater Double
- QDouble b
      = Vector Double 4 -> Quater Double
QDouble (Vector Double 4
a Vector Double 4 -> Vector Double 4 -> Vector Double 4
forall a. Num a => a -> a -> a
- Vector Double 4
b)
    {-# INLINE (-) #-}
    (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
a1, Double
a2, Double
a3, Double
a4 #)) * :: Quater Double -> Quater Double -> Quater Double
* (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
b1, Double
b2, Double
b3, Double
b4 #))
      = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ ((Double
a4 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b1) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b4) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b3) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a3 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b2))
              ((Double
a4 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b2) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b3) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b4) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a3 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b1))
              ((Double
a4 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b3) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b2) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b1) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
a3 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b4))
              ((Double
a4 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b4) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b1) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b2) Double -> Double -> Double
forall a. Num a => a -> a -> a
- (Double
a3 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
b3))
    {-# INLINE (*) #-}
    negate :: Quater Double -> Quater Double
negate (QDouble a) = Vector Double 4 -> Quater Double
QDouble (Vector Double 4 -> Vector Double 4
forall a. Num a => a -> a
negate Vector Double 4
a)
    {-# INLINE negate #-}
    abs :: Quater Double -> Quater Double
abs = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Quater Double)
-> (Quater Double -> Double) -> Quater Double -> Quater Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double)
-> (Quater Double -> Double) -> Quater Double -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Quater Double -> Double
forall t. Quaternion t => Quater t -> t
square
    {-# INLINE abs #-}
    signum :: Quater Double -> Quater Double
signum q :: Quater Double
q@(Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
qd Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0   = Quater Double
q
      | Bool
otherwise = case Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
iy Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
iz Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
iw Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
nn of
        Int
0 -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l)
        Int
1 -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign Double
1 Double
x) Double
0 Double
0 Double
0
        Int
2 -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 (Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign Double
1 Double
y) Double
0 Double
0
        Int
4 -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 (Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign Double
1 Double
z) Double
0
        Int
8 -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign Double
1 Double
w)
        Int
_ -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
n Double
n Double
n Double
n
      where
        n :: Double
n  = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 :: Double
        qd :: Double
qd = Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        ix :: Int
ix = if Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
x then Int
1 else Int
0 :: Int
        iy :: Int
iy = if Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
y then Int
2 else Int
0 :: Int
        iz :: Int
iz = if Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
z then Int
4 else Int
0 :: Int
        iw :: Int
iw = if Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
w then Int
8 else Int
0 :: Int
        nn :: Int
nn = if Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
x Bool -> Bool -> Bool
|| Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
y Bool -> Bool -> Bool
|| Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
z Bool -> Bool -> Bool
|| Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
w then Int
16 else Int
0 :: Int
        l :: Double
l  = Double -> Double
forall a. Fractional a => a -> a
recip (Double -> Double
forall a. Floating a => a -> a
sqrt Double
qd)
    {-# INLINE signum #-}
    fromInteger :: Integer -> Quater Double
fromInteger = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Quater Double)
-> (Integer -> Double) -> Integer -> Quater Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a. Num a => Integer -> a
fromInteger
    {-# INLINE fromInteger #-}


instance Fractional QDouble where
    {-# INLINE recip #-}
    recip :: Quater Double -> Quater Double
recip q :: Quater Double
q@(Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #)) = case Double -> Double
forall a. Num a => a -> a
negate (Double -> Double
forall a. Fractional a => a -> a
recip (Quater Double -> Double
forall t. Quaternion t => Quater t -> t
square Quater Double
q)) of
      Double
c -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) (Double -> Double
forall a. Num a => a -> a
negate (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c))
    {-# INLINE (/) #-}
    Quater Double
a / :: Quater Double -> Quater Double -> Quater Double
/ Quater Double
b = Quater Double
a Quater Double -> Quater Double -> Quater Double
forall a. Num a => a -> a -> a
* Quater Double -> Quater Double
forall a. Fractional a => a -> a
recip Quater Double
b
    {-# INLINE fromRational #-}
    fromRational :: Rational -> Quater Double
fromRational = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Quater Double)
-> (Rational -> Double) -> Rational -> Quater Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational


instance Floating QDouble where
    {-# INLINE pi #-}
    pi :: Quater Double
pi = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PI
    {-# INLINE exp #-}
    exp :: Quater Double -> Quater Double
exp (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z Double
ew
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv  = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        ew :: Double
ew  = Double -> Double
forall a. Floating a => a -> a
exp Double
w
        l :: Double
l   = Double
ew Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sin Double
mv Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv
        arg :: Double
arg = Double
ew Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cos Double
mv
    {-# INLINE log #-}
    log :: Quater Double -> Quater Double
log = Vector Double 3 -> Quater Double -> Quater Double
log' (Double -> Double -> Double -> Vector Double 3
forall t. Vector3 t => t -> t -> t -> Vector t 3
Vec3 Double
1 Double
0 Double
0)
    {-# INLINE sqrt #-}
    sqrt :: Quater Double -> Quater Double
sqrt = Vector Double 3 -> Quater Double -> Quater Double
sqrt' (Double -> Double -> Double -> Vector Double 3
forall t. Vector3 t => t -> t -> t -> Vector t 3
Vec3 Double
1 Double
0 Double
0)
    {-# INLINE sin #-}
    sin :: Quater Double -> Quater Double
sin (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
sin Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv  = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        l :: Double
l   = Double -> Double
forall a. Floating a => a -> a
cos Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sinh Double
mv Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv
        arg :: Double
arg = Double -> Double
forall a. Floating a => a -> a
sin Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cosh Double
mv
    {-# INLINE cos #-}
    cos :: Quater Double -> Quater Double
cos (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
cos Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv  = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        l :: Double
l   = Double -> Double
forall a. Floating a => a -> a
sin Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sinh Double
mv Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double -> Double
forall a. Num a => a -> a
negate Double
mv
        arg :: Double
arg = Double -> Double
forall a. Floating a => a -> a
cos Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cosh Double
mv
    {-# INLINE tan #-}
    tan :: Quater Double -> Quater Double
tan (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0       = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
tan Double
w)
      | Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
mv2 = Quater Double -> Quater Double
forall a. Num a => a -> a
signum (Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z Double
0)
      | Bool
otherwise      = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        b :: Double
b = Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
mv
        a :: Double
a = Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        sina :: Double
sina = Double -> Double
forall a. Floating a => a -> a
sin Double
a
        eb :: Double
eb = Double -> Double
forall a. Floating a => a -> a
exp (-Double
b)
        eb2 :: Double
eb2 = Double
ebDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
eb
        d :: Double
d = Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
eb2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
eb Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cos Double
a
        rd :: Double
rd = Double -> Double
forall a. Fractional a => a -> a
recip Double
d
        pa :: Double
pa = Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PI Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double -> Double
forall a. Num a => a -> a
abs Double
a
        rd' :: Double
rd' = Double
2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
bDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
paDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
pa)
        (Double
l, Double
arg) =
          if Double
d Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
forall a. Epsilon a => a
M_EPS
          then ((Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
eb2) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv, Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
sina Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
eb Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd)
          else (Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd' , Double -> Double
forall a. Num a => a -> a
negate Double
sina Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd')
    {-# INLINE sinh #-}
    sinh :: Quater Double -> Quater Double
sinh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
sinh Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv  = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        l :: Double
l   = Double -> Double
forall a. Floating a => a -> a
cosh Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sin Double
mv Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv
        arg :: Double
arg = Double -> Double
forall a. Floating a => a -> a
sinh Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cos Double
mv
    {-# INLINE cosh #-}
    cosh :: Quater Double -> Quater Double
cosh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
cosh Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv  = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        l :: Double
l   = Double -> Double
forall a. Floating a => a -> a
sinh Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sin Double
mv Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv
        arg :: Double
arg = Double -> Double
forall a. Floating a => a -> a
cosh Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cos Double
mv
    {-# INLINE tanh #-}
    tanh :: Quater Double -> Quater Double
tanh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
mv2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0       = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
tanh Double
w)
      | Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
mv2 = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Double
forall a. Num a => a -> a
signum Double
w)
      | Bool
otherwise      = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) Double
arg
      where
        mv2 :: Double
mv2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        mv :: Double
mv = Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2
        b :: Double
b = Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        a :: Double
a = Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
mv
        eb :: Double
eb = Double -> Double
forall a. Floating a => a -> a
exp (- Double -> Double
forall a. Num a => a -> a
abs Double
b)
        eb2 :: Double
eb2 = Double
ebDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
eb
        d :: Double
d = Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
eb2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
eb Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
cos Double
a
        rd :: Double
rd = Double -> Double
forall a. Fractional a => a -> a
recip Double
d
        pa :: Double
pa = Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PI Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
a
        rd' :: Double
rd' = Double
2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
bDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
paDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
pa)
        (Double
l, Double
arg) =
          if Double
d Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
forall a. Epsilon a => a
M_EPS
          then (Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sin Double
a Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
eb Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv, Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
eb2) Double
b Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd)
          else (Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd' , Double
b Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
rd')
    {-# INLINE asin #-}
    -- The original formula:
    -- asin q = -i * log (i*q + sqrt (1 - q*q))
    -- below is a more numerically stable version.
    asin :: Quater Double -> Quater Double
asin (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0   = if Double
w2 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
1
                    then Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
asin Double
w)
                    else Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
l Double
0 Double
0 Double
arg
      | Bool
otherwise  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) Double
arg
      where
        v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        v :: Double
v = Double -> Double
forall a. Floating a => a -> a
sqrt Double
v2
        w2 :: Double
w2 = Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        w1qq :: Double
w1qq = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v2)       -- real part of (1 - q*q)/2
        l1qq :: Double
l1qq = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
w1qqDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v2) -- length of (1 - q*q)/2
        sp2 :: Double
sp2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w1qq
        sn2 :: Double
sn2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w1qq
        sp :: Double
sp = Double -> Double
forall a. Floating a => a -> a
sqrt Double
sp2
        sn :: Double
sn = Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign (Double -> Double
forall a. Floating a => a -> a
sqrt Double
sn2) Double
w
        -- choose a more stable (symbolically equiv) version
        dp :: Double
dp = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
v2 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
sp2 then Double
sp Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
v else Double
v2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
sp Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
sn2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v2))
        dn :: Double
dn = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w2 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
sn2 then Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
sn else Double
w2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
sn Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
sp2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2))
        (Double
wD, Double
vD) = case Double -> Double -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Double
w1qq Double
0 of
            Ordering
GT -> (Double
dp, Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dp Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sp)
            Ordering
LT -> (Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dn Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sn, Double
dn)
            Ordering
EQ -> (-Double
v, Double
w)
        l :: Double
l = -Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
log (Double
wDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
wD Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
vDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
vD)
        c :: Double
c = Double
l Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v
        arg :: Double
arg = Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 Double
vD Double
wD
    {-# INLINE acos #-}
    acos :: Quater Double -> Quater Double
acos Quater Double
q = Quater Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PI_2 Quater Double -> Quater Double -> Quater Double
forall a. Num a => a -> a -> a
- Quater Double -> Quater Double
forall a. Floating a => a -> a
asin Quater Double
q
    {-# INLINE atan #-}
    -- atan q = i / 2 * log ( (i + q) / (i - q) )
    atan :: Quater Double -> Quater Double
atan (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0   = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
atan Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) Double
arg
      where
        v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        v :: Double
v = Double -> Double
forall a. Floating a => a -> a
sqrt Double
v2
        w2 :: Double
w2 = Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        q2 :: Double
q2 = Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v2
        v' :: Double
v' = Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
1
        mzero :: Double
mzero = Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v'Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v'
        (Double
c, Double
arg) =
          if Double
mzero Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0
          then ( Double -> Double
forall a. Floating a => a -> a
sqrt Double
forall a. RealFloatExtras a => a
maxFinite Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v, Double
0)
          else ( Double
0.25 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double -> Double
forall a. Floating a => a -> a
log (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
q2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v) Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double -> Double
forall a. Floating a => a -> a
log Double
mzero) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v
               , Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 (Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w) (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
q2) )
    {-# INLINE asinh #-}
    -- The original formula:
    -- asinh q = log (q + sqrt (q*q + 1))
    -- below is a more numerically stable version.
    asinh :: Quater Double -> Quater Double
asinh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0   = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
asinh Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) Double
arg
      where
        v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        v :: Double
v = Double -> Double
forall a. Floating a => a -> a
sqrt Double
v2
        w2 :: Double
w2 = Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        w1qq :: Double
w1qq = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
v2)       -- real part of (1 + q*q)/2
        l1qq :: Double
l1qq = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
w1qqDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v2) -- length of (1 + q*q)/2
        sp2 :: Double
sp2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w1qq
        sn2 :: Double
sn2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w1qq
        sp :: Double
sp = Double -> Double
forall a. Floating a => a -> a
sqrt Double
sp2
        sn :: Double
sn = Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign (Double -> Double
forall a. Floating a => a -> a
sqrt Double
sn2) Double
w
        -- choose a more stable (symbolically equiv) version
        dp :: Double
dp = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= - Double
sp then Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sp else Double
w2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
sp Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sn2))
        dn :: Double
dn = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
v Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= - Double
sn Bool -> Bool -> Bool
|| Double
sn Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0
                              then Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sn else Double
v2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
sn)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
v2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sp2))
        (Double
wD, Double
vD) = case Double -> Double -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Double
w1qq Double
0 of
            Ordering
GT -> (Double
dp, Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dp Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sp)
            Ordering
LT -> (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dn Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sn, Double
dn)
            Ordering
EQ -> (Double
w, Double
v)
        c :: Double
c = Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 Double
vD Double
wD Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v
        arg :: Double
arg = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
log (Double
wDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
wD Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
vDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
vD)
    {-# INLINE acosh #-}
    -- The original formula:
    -- asinh q = log (q + sqrt (q + 1) * sqrt (q - 1))
    -- below is a more numerically stable version.
    -- note, log (q + sqrt (q*q - 1)) would not work, because that would not
    -- be the principal value.
    acosh :: Quater Double -> Quater Double
acosh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0   = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
acosh Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) Double
arg
      where
        v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        v :: Double
v = Double -> Double
forall a. Floating a => a -> a
sqrt Double
v2
        w2 :: Double
w2 = Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        w1qq :: Double
w1qq = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
v2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
1)       -- real part of (q*q - 1)/2
        l1qq :: Double
l1qq = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
w1qqDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v2) -- length of (q*q - 1)/2
        sp2 :: Double
sp2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w1qq
        sn2 :: Double
sn2 = Double
l1qq Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w1qq
        sp :: Double
sp = Double -> Double
forall a. Floating a => a -> a
sqrt Double
sp2
        sn :: Double
sn = Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign (Double -> Double
forall a. Floating a => a -> a
sqrt Double
sn2) Double
w
        -- choose a more stable (symbolically equiv) version
        dp :: Double
dp = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= - Double
sp then Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sp else Double
w2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
sp)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sn2))
        dn :: Double
dn = if Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
v Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= - Double
sn Bool -> Bool -> Bool
|| Double
sn Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0
                              then Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sn else Double
v2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ ((Double
sn Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
v)Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
v2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sp2))
        (Double
wD, Double
vD) = case Double -> Double -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Double
w1qq Double
0 of
            Ordering
GT -> (Double
dp, Double
v Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dp Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sp)
            Ordering
LT -> (Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
dn Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sn, Double
dn)
            Ordering
EQ -> (Double
w, Double
v)
        c :: Double
c = Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 Double
vD Double
wD Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v
        arg :: Double
arg = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
log (Double
wDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
wD Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
vDDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
vD)
    {-# INLINE atanh #-}
    -- atanh q = 0.5 * log ( (1 + q) / (1 - q) )
    atanh :: Quater Double -> Quater Double
atanh (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
      | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
==  Double
0  = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
atanh Double
w)
      | Bool
otherwise = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
yDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double
zDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
c) (Double -> Double -> Double
forall a. RealExtras a => a -> a -> a
copysign Double
arg Double
w)
      where
        v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
        v :: Double
v = Double -> Double
forall a. Floating a => a -> a
sqrt Double
v2
        w2 :: Double
w2 = Double
wDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w
        q2 :: Double
q2 = Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
v2
        w' :: Double
w' = Double -> Double
forall a. Num a => a -> a
abs Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
1
        c :: Double
c  = Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 (Double
2Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
v) (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
q2) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
v
        arg :: Double
arg = if Double
w' Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0
              then (Double
1Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
0)
              else Double
0.25 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double -> Double
forall a. Floating a => a -> a
log (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
q2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Num a => a -> a
abs Double
w) Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double -> Double
forall a. Floating a => a -> a
log (Double
v2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w'Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
w'))


-- If q is negative real, provide a fallback axis to align log.
log' :: Vector Double 3 -> QDouble -> QDouble
log' :: Vector Double 3 -> Quater Double -> Quater Double
log' Vector Double 3
r (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
  = case (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z) of
    Double
0.0 | Double
w Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0
           -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
0 Double
0 Double
0 (Double -> Double
forall a. Floating a => a -> a
log Double
w)
        | Vec3 Double
rx Double
ry Double
rz <- Vector Double 3
r
           ->  Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PIDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
rx) (Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PIDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
ry) (Double
forall a. (Eq a, Fractional a, Fractional a) => a
M_PIDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
rz) (Double -> Double
forall a. Floating a => a -> a
log (Double -> Double
forall a. Num a => a -> a
negate Double
w))
    Double
mv2 -> case (# Double
mv2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w, Double -> Double
forall a. Floating a => a -> a
sqrt Double
mv2 #) of
      (# Double
q2, Double
mv #) -> case Double -> Double -> Double
forall a. RealFloat a => a -> a -> a
atan2 Double
mv Double
w Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
mv of
        Double
l -> Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
l) (Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
log Double
q2)


-- If q is negative real, provide a fallback axis to align sqrt.
sqrt' :: Vector Double 3 -> QDouble -> QDouble
sqrt' :: Vector Double 3 -> Quater Double -> Quater Double
sqrt' Vector Double 3
r (Quater Double -> (# Double, Double, Double, Double #)
forall t. Quaternion t => Quater t -> (# t, t, t, t #)
unpackQ# -> (# Double
x, Double
y, Double
z, Double
w #))
  | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0 Bool -> Bool -> Bool
&& Double
w Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0
    = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ Double
x Double
y Double
z (Double -> Double
forall a. Floating a => a -> a
sqrt Double
w)
  | Double
v2 Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
0
  , Vec3 Double
rx Double
ry Double
rz <- Vector Double 3
r
  , Double
sw <- Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double
forall a. Num a => a -> a
negate Double
w)
    = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
swDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
rx) (Double
swDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
ry) (Double
swDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
rz) Double
0
  | Bool
otherwise
    = Double -> Double -> Double -> Double -> Quater Double
forall t. Quaternion t => t -> t -> t -> t -> Quater t
packQ (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
c) Double
arg
  where
    v2 :: Double
v2 = (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
y) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
z Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
z)
    mq :: Double
mq = Double -> Double
forall a. Floating a => a -> a
sqrt (Double
v2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
w)
    arg :: Double
arg = Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double) -> Double -> Double
forall a b. (a -> b) -> a -> b
$ Double
0.5 Double -> Double -> Double
forall a. Num a => a -> a -> a
* if Double
w Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 then Double
mq Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w else Double
v2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
mq Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
w)
    c :: Double
c = Double
0.5 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
arg

instance Eq QDouble where
    {-# INLINE (==) #-}
    QDouble a == :: Quater Double -> Quater Double -> Bool
== QDouble b = Vector Double 4
a Vector Double 4 -> Vector Double 4 -> Bool
forall a. Eq a => a -> a -> Bool
== Vector Double 4
b
    {-# INLINE (/=) #-}
    QDouble a /= :: Quater Double -> Quater Double -> Bool
/= QDouble b = Vector Double 4
a Vector Double 4 -> Vector Double 4 -> Bool
forall a. Eq a => a -> a -> Bool
/= Vector Double 4
b