{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}
module Numeric.DataFrame.Internal.Backend.Family.FloatX3 (FloatX3 (..)) where
import GHC.Base
import Numeric.DataFrame.Internal.PrimArray
import Numeric.PrimBytes
import Numeric.ProductOrd
import qualified Numeric.ProductOrd.NonTransitive as NonTransitive
import qualified Numeric.ProductOrd.Partial as Partial
data FloatX3 = FloatX3# Float# Float# Float#
instance Bounded Float => Bounded FloatX3 where
maxBound :: FloatX3
maxBound = case Float
forall a. Bounded a => a
maxBound of F# Float#
x -> Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
x Float#
x
minBound :: FloatX3
minBound = case Float
forall a. Bounded a => a
minBound of F# Float#
x -> Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
x Float#
x
instance Eq FloatX3 where
FloatX3# Float#
a1 Float#
a2 Float#
a3 == :: FloatX3 -> FloatX3 -> Bool
== FloatX3# Float#
b1 Float#
b2 Float#
b3 =
Int# -> Bool
isTrue#
( (Float#
a1 Float# -> Float# -> Int#
`eqFloat#` Float#
b1)
Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`eqFloat#` Float#
b2)
Int# -> Int# -> Int#
`andI#` (Float#
a3 Float# -> Float# -> Int#
`eqFloat#` Float#
b3)
)
{-# INLINE (==) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 /= :: FloatX3 -> FloatX3 -> Bool
/= FloatX3# Float#
b1 Float#
b2 Float#
b3 =
Int# -> Bool
isTrue#
( (Float#
a1 Float# -> Float# -> Int#
`neFloat#` Float#
b1)
Int# -> Int# -> Int#
`orI#` (Float#
a2 Float# -> Float# -> Int#
`neFloat#` Float#
b2)
Int# -> Int# -> Int#
`orI#` (Float#
a3 Float# -> Float# -> Int#
`neFloat#` Float#
b3)
)
{-# INLINE (/=) #-}
cmp' :: Float# -> Float# -> PartialOrdering
cmp' :: Float# -> Float# -> PartialOrdering
cmp' Float#
a Float#
b
| Int# -> Bool
isTrue# (Float#
a Float# -> Float# -> Int#
`gtFloat#` Float#
b) = PartialOrdering
PGT
| Int# -> Bool
isTrue# (Float#
a Float# -> Float# -> Int#
`ltFloat#` Float#
b) = PartialOrdering
PLT
| Bool
otherwise = PartialOrdering
PEQ
instance ProductOrder FloatX3 where
cmp :: FloatX3 -> FloatX3 -> PartialOrdering
cmp (FloatX3# Float#
a1 Float#
a2 Float#
a3) (FloatX3# Float#
b1 Float#
b2 Float#
b3)
= Float# -> Float# -> PartialOrdering
cmp' Float#
a1 Float#
b1 PartialOrdering -> PartialOrdering -> PartialOrdering
forall a. Semigroup a => a -> a -> a
<> Float# -> Float# -> PartialOrdering
cmp' Float#
a2 Float#
b2 PartialOrdering -> PartialOrdering -> PartialOrdering
forall a. Semigroup a => a -> a -> a
<> Float# -> Float# -> PartialOrdering
cmp' Float#
a3 Float#
b3
{-# INLINE cmp #-}
instance Ord (NonTransitive.ProductOrd FloatX3) where
NonTransitive.ProductOrd FloatX3
x > :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
> NonTransitive.ProductOrd FloatX3
y = FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
x FloatX3
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PGT
{-# INLINE (>) #-}
NonTransitive.ProductOrd FloatX3
x < :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
< NonTransitive.ProductOrd FloatX3
y = FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
x FloatX3
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PLT
{-# INLINE (<) #-}
>= :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
(>=) (NonTransitive.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(NonTransitive.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3)) = Int# -> Bool
isTrue#
((Float#
a1 Float# -> Float# -> Int#
`geFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`geFloat#` Float#
b2) Int# -> Int# -> Int#
`andI#` (Float#
a3 Float# -> Float# -> Int#
`geFloat#` Float#
b3))
{-# INLINE (>=) #-}
<= :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
(<=) (NonTransitive.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(NonTransitive.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3)) = Int# -> Bool
isTrue#
((Float#
a1 Float# -> Float# -> Int#
`leFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`leFloat#` Float#
b2) Int# -> Int# -> Int#
`andI#` (Float#
a3 Float# -> Float# -> Int#
`leFloat#` Float#
b3))
{-# INLINE (<=) #-}
compare :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Ordering
compare (NonTransitive.ProductOrd FloatX3
a) (NonTransitive.ProductOrd FloatX3
b)
= PartialOrdering -> Ordering
NonTransitive.toOrdering (PartialOrdering -> Ordering) -> PartialOrdering -> Ordering
forall a b. (a -> b) -> a -> b
$ FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
a FloatX3
b
{-# INLINE compare #-}
min :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> ProductOrd FloatX3
min (NonTransitive.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(NonTransitive.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3))
= FloatX3 -> ProductOrd FloatX3
forall a. a -> ProductOrd a
NonTransitive.ProductOrd
( Float# -> Float# -> Float# -> FloatX3
FloatX3#
(if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) then Float#
b1 else Float#
a1)
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) then Float#
b2 else Float#
a2)
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) then Float#
b3 else Float#
a3)
)
{-# INLINE min #-}
max :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> ProductOrd FloatX3
max (NonTransitive.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(NonTransitive.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3))
= FloatX3 -> ProductOrd FloatX3
forall a. a -> ProductOrd a
NonTransitive.ProductOrd
( Float# -> Float# -> Float# -> FloatX3
FloatX3#
(if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) then Float#
b1 else Float#
a1)
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) then Float#
b2 else Float#
a2)
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) then Float#
b3 else Float#
a3)
)
{-# INLINE max #-}
instance Ord (Partial.ProductOrd FloatX3) where
Partial.ProductOrd FloatX3
x > :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
> Partial.ProductOrd FloatX3
y = FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
x FloatX3
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PGT
{-# INLINE (>) #-}
Partial.ProductOrd FloatX3
x < :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
< Partial.ProductOrd FloatX3
y = FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
x FloatX3
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PLT
{-# INLINE (<) #-}
>= :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
(>=) (Partial.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(Partial.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3)) = Int# -> Bool
isTrue#
((Float#
a1 Float# -> Float# -> Int#
`geFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`geFloat#` Float#
b2) Int# -> Int# -> Int#
`andI#` (Float#
a3 Float# -> Float# -> Int#
`geFloat#` Float#
b3))
{-# INLINE (>=) #-}
<= :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Bool
(<=) (Partial.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(Partial.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3)) = Int# -> Bool
isTrue#
((Float#
a1 Float# -> Float# -> Int#
`leFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`leFloat#` Float#
b2) Int# -> Int# -> Int#
`andI#` (Float#
a3 Float# -> Float# -> Int#
`leFloat#` Float#
b3))
{-# INLINE (<=) #-}
compare :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> Ordering
compare (Partial.ProductOrd FloatX3
a) (Partial.ProductOrd FloatX3
b)
= PartialOrdering -> Ordering
Partial.toOrdering (PartialOrdering -> Ordering) -> PartialOrdering -> Ordering
forall a b. (a -> b) -> a -> b
$ FloatX3 -> FloatX3 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX3
a FloatX3
b
{-# INLINE compare #-}
min :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> ProductOrd FloatX3
min (Partial.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(Partial.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3))
= FloatX3 -> ProductOrd FloatX3
forall a. a -> ProductOrd a
Partial.ProductOrd
( Float# -> Float# -> Float# -> FloatX3
FloatX3#
(if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) then Float#
b1 else Float#
a1)
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) then Float#
b2 else Float#
a2)
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) then Float#
b3 else Float#
a3)
)
{-# INLINE min #-}
max :: ProductOrd FloatX3 -> ProductOrd FloatX3 -> ProductOrd FloatX3
max (Partial.ProductOrd (FloatX3# Float#
a1 Float#
a2 Float#
a3))
(Partial.ProductOrd (FloatX3# Float#
b1 Float#
b2 Float#
b3))
= FloatX3 -> ProductOrd FloatX3
forall a. a -> ProductOrd a
Partial.ProductOrd
( Float# -> Float# -> Float# -> FloatX3
FloatX3#
(if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) then Float#
b1 else Float#
a1)
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) then Float#
b2 else Float#
a2)
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) then Float#
b3 else Float#
a3)
)
{-# INLINE max #-}
instance Ord FloatX3 where
FloatX3# Float#
a1 Float#
a2 Float#
a3 > :: FloatX3 -> FloatX3 -> Bool
> FloatX3# Float#
b1 Float#
b2 Float#
b3
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) = Bool
True
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) = Bool
False
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) = Bool
True
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) = Bool
False
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) = Bool
True
| Bool
otherwise = Bool
False
{-# INLINE (>) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 < :: FloatX3 -> FloatX3 -> Bool
< FloatX3# Float#
b1 Float#
b2 Float#
b3
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) = Bool
True
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) = Bool
False
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) = Bool
True
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) = Bool
False
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) = Bool
True
| Bool
otherwise = Bool
False
{-# INLINE (<) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 >= :: FloatX3 -> FloatX3 -> Bool
>= FloatX3# Float#
b1 Float#
b2 Float#
b3
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) = Bool
False
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) = Bool
True
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) = Bool
False
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) = Bool
True
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) = Bool
False
| Bool
otherwise = Bool
True
{-# INLINE (>=) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 <= :: FloatX3 -> FloatX3 -> Bool
<= FloatX3# Float#
b1 Float#
b2 Float#
b3
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) = Bool
False
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) = Bool
True
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) = Bool
False
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) = Bool
True
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) = Bool
False
| Bool
otherwise = Bool
True
{-# INLINE (<=) #-}
compare :: FloatX3 -> FloatX3 -> Ordering
compare (FloatX3# Float#
a1 Float#
a2 Float#
a3) (FloatX3# Float#
b1 Float#
b2 Float#
b3)
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
b1) = Ordering
GT
| Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
b1) = Ordering
LT
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
b2) = Ordering
GT
| Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
b2) = Ordering
LT
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) = Ordering
GT
| Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) = Ordering
LT
| Bool
otherwise = Ordering
EQ
{-# INLINE compare #-}
instance Num FloatX3 where
FloatX3# Float#
a1 Float#
a2 Float#
a3 + :: FloatX3 -> FloatX3 -> FloatX3
+ FloatX3# Float#
b1 Float#
b2 Float#
b3
= Float# -> Float# -> Float# -> FloatX3
FloatX3# (Float# -> Float# -> Float#
plusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
plusFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
plusFloat# Float#
a3 Float#
b3)
{-# INLINE (+) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 - :: FloatX3 -> FloatX3 -> FloatX3
- FloatX3# Float#
b1 Float#
b2 Float#
b3
= Float# -> Float# -> Float# -> FloatX3
FloatX3# (Float# -> Float# -> Float#
minusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
minusFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
minusFloat# Float#
a3 Float#
b3)
{-# INLINE (-) #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 * :: FloatX3 -> FloatX3 -> FloatX3
* FloatX3# Float#
b1 Float#
b2 Float#
b3
= Float# -> Float# -> Float# -> FloatX3
FloatX3# (Float# -> Float# -> Float#
timesFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
timesFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
timesFloat# Float#
a3 Float#
b3)
{-# INLINE (*) #-}
negate :: FloatX3 -> FloatX3
negate (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
negateFloat# Float#
a1) (Float# -> Float#
negateFloat# Float#
a2) (Float# -> Float#
negateFloat# Float#
a3)
{-# INLINE negate #-}
abs :: FloatX3 -> FloatX3
abs (FloatX3# Float#
a1 Float#
a2 Float#
a3)
= Float# -> Float# -> Float# -> FloatX3
FloatX3#
(if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`geFloat#` Float#
0.0#) then Float#
a1 else Float# -> Float#
negateFloat# Float#
a1)
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`geFloat#` Float#
0.0#) then Float#
a2 else Float# -> Float#
negateFloat# Float#
a2)
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`geFloat#` Float#
0.0#) then Float#
a3 else Float# -> Float#
negateFloat# Float#
a3)
{-# INLINE abs #-}
signum :: FloatX3 -> FloatX3
signum (FloatX3# Float#
a1 Float#
a2 Float#
a3)
= Float# -> Float# -> Float# -> FloatX3
FloatX3# (if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`gtFloat#` Float#
0.0#)
then Float#
1.0#
else if Int# -> Bool
isTrue# (Float#
a1 Float# -> Float# -> Int#
`ltFloat#` Float#
0.0#) then Float#
-1.0# else Float#
0.0# )
(if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`gtFloat#` Float#
0.0#)
then Float#
1.0#
else if Int# -> Bool
isTrue# (Float#
a2 Float# -> Float# -> Int#
`ltFloat#` Float#
0.0#) then Float#
-1.0# else Float#
0.0# )
(if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
0.0#)
then Float#
1.0#
else if Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
0.0#) then Float#
-1.0# else Float#
0.0# )
{-# INLINE signum #-}
fromInteger :: Integer -> FloatX3
fromInteger Integer
n = case Integer -> Float
forall a. Num a => Integer -> a
fromInteger Integer
n of F# Float#
x -> Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
x Float#
x
{-# INLINE fromInteger #-}
instance Fractional FloatX3 where
FloatX3# Float#
a1 Float#
a2 Float#
a3 / :: FloatX3 -> FloatX3 -> FloatX3
/ FloatX3# Float#
b1 Float#
b2 Float#
b3 = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float# -> Float#
divideFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
divideFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
divideFloat# Float#
a3 Float#
b3)
{-# INLINE (/) #-}
recip :: FloatX3 -> FloatX3
recip (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a1) (Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a2) (Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a3)
{-# INLINE recip #-}
fromRational :: Rational -> FloatX3
fromRational Rational
r = case Rational -> Float
forall a. Fractional a => Rational -> a
fromRational Rational
r of F# Float#
x -> Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
x Float#
x
{-# INLINE fromRational #-}
instance Floating FloatX3 where
pi :: FloatX3
pi = Float# -> Float# -> Float# -> FloatX3
FloatX3#
Float#
3.141592653589793238#
Float#
3.141592653589793238#
Float#
3.141592653589793238#
{-# INLINE pi #-}
exp :: FloatX3 -> FloatX3
exp (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
expFloat# Float#
a1) (Float# -> Float#
expFloat# Float#
a2) (Float# -> Float#
expFloat# Float#
a3)
{-# INLINE exp #-}
log :: FloatX3 -> FloatX3
log (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
logFloat# Float#
a1) (Float# -> Float#
logFloat# Float#
a2) (Float# -> Float#
logFloat# Float#
a3)
{-# INLINE log #-}
sqrt :: FloatX3 -> FloatX3
sqrt (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
sqrtFloat# Float#
a1) (Float# -> Float#
sqrtFloat# Float#
a2) (Float# -> Float#
sqrtFloat# Float#
a3)
{-# INLINE sqrt #-}
sin :: FloatX3 -> FloatX3
sin (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
sinFloat# Float#
a1) (Float# -> Float#
sinFloat# Float#
a2) (Float# -> Float#
sinFloat# Float#
a3)
{-# INLINE sin #-}
cos :: FloatX3 -> FloatX3
cos (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
cosFloat# Float#
a1) (Float# -> Float#
cosFloat# Float#
a2) (Float# -> Float#
cosFloat# Float#
a3)
{-# INLINE cos #-}
tan :: FloatX3 -> FloatX3
tan (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
tanFloat# Float#
a1) (Float# -> Float#
tanFloat# Float#
a2) (Float# -> Float#
tanFloat# Float#
a3)
{-# INLINE tan #-}
asin :: FloatX3 -> FloatX3
asin (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
asinFloat# Float#
a1) (Float# -> Float#
asinFloat# Float#
a2) (Float# -> Float#
asinFloat# Float#
a3)
{-# INLINE asin #-}
acos :: FloatX3 -> FloatX3
acos (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
acosFloat# Float#
a1) (Float# -> Float#
acosFloat# Float#
a2) (Float# -> Float#
acosFloat# Float#
a3)
{-# INLINE acos #-}
atan :: FloatX3 -> FloatX3
atan (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
atanFloat# Float#
a1) (Float# -> Float#
atanFloat# Float#
a2) (Float# -> Float#
atanFloat# Float#
a3)
{-# INLINE atan #-}
sinh :: FloatX3 -> FloatX3
sinh (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
sinhFloat# Float#
a1) (Float# -> Float#
sinhFloat# Float#
a2) (Float# -> Float#
sinhFloat# Float#
a3)
{-# INLINE sinh #-}
cosh :: FloatX3 -> FloatX3
cosh (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
coshFloat# Float#
a1) (Float# -> Float#
coshFloat# Float#
a2) (Float# -> Float#
coshFloat# Float#
a3)
{-# INLINE cosh #-}
tanh :: FloatX3 -> FloatX3
tanh (FloatX3# Float#
a1 Float#
a2 Float#
a3) = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float#
tanhFloat# Float#
a1) (Float# -> Float#
tanhFloat# Float#
a2) (Float# -> Float#
tanhFloat# Float#
a3)
{-# INLINE tanh #-}
FloatX3# Float#
a1 Float#
a2 Float#
a3 ** :: FloatX3 -> FloatX3 -> FloatX3
** FloatX3# Float#
b1 Float#
b2 Float#
b3 = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(Float# -> Float# -> Float#
powerFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
powerFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
powerFloat# Float#
a3 Float#
b3)
{-# INLINE (**) #-}
logBase :: FloatX3 -> FloatX3 -> FloatX3
logBase FloatX3
x FloatX3
y = FloatX3 -> FloatX3
forall a. Floating a => a -> a
log FloatX3
y FloatX3 -> FloatX3 -> FloatX3
forall a. Fractional a => a -> a -> a
/ FloatX3 -> FloatX3
forall a. Floating a => a -> a
log FloatX3
x
{-# INLINE logBase #-}
asinh :: FloatX3 -> FloatX3
asinh FloatX3
x = FloatX3 -> FloatX3
forall a. Floating a => a -> a
log (FloatX3
x FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+ FloatX3 -> FloatX3
forall a. Floating a => a -> a
sqrt (FloatX3
1.0FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+FloatX3
xFloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
*FloatX3
x))
{-# INLINE asinh #-}
acosh :: FloatX3 -> FloatX3
acosh FloatX3
x = FloatX3 -> FloatX3
forall a. Floating a => a -> a
log (FloatX3
x FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+ (FloatX3
xFloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+FloatX3
1.0) FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
* FloatX3 -> FloatX3
forall a. Floating a => a -> a
sqrt ((FloatX3
xFloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
-FloatX3
1.0)FloatX3 -> FloatX3 -> FloatX3
forall a. Fractional a => a -> a -> a
/(FloatX3
xFloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+FloatX3
1.0)))
{-# INLINE acosh #-}
atanh :: FloatX3 -> FloatX3
atanh FloatX3
x = FloatX3
0.5 FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
* FloatX3 -> FloatX3
forall a. Floating a => a -> a
log ((FloatX3
1.0FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
+FloatX3
x) FloatX3 -> FloatX3 -> FloatX3
forall a. Fractional a => a -> a -> a
/ (FloatX3
1.0FloatX3 -> FloatX3 -> FloatX3
forall a. Num a => a -> a -> a
-FloatX3
x))
{-# INLINE atanh #-}
#define BOFF_TO_PRIMOFF(off) uncheckedIShiftRL# off 2#
#define ELEM_N 3
instance PrimBytes FloatX3 where
getBytes :: FloatX3 -> ByteArray#
getBytes (FloatX3# Float#
a1 Float#
a2 Float#
a3) = case (State# RealWorld -> (# State# RealWorld, ByteArray# #))
-> (# State# RealWorld, ByteArray# #)
forall o. (State# RealWorld -> o) -> o
runRW#
( \State# RealWorld
s0 -> case Int#
-> State# RealWorld
-> (# State# RealWorld, MutableByteArray# RealWorld #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# (FloatX3 -> Int#
forall a. PrimBytes a => a -> Int#
byteSize @FloatX3 FloatX3
forall a. HasCallStack => a
undefined) State# RealWorld
s0 of
(# State# RealWorld
s1, MutableByteArray# RealWorld
marr #) -> case MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
marr Int#
0# Float#
a1 State# RealWorld
s1 of
State# RealWorld
s2 -> case MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
marr Int#
1# Float#
a2 State# RealWorld
s2 of
State# RealWorld
s3 -> case MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
marr Int#
2# Float#
a3 State# RealWorld
s3 of
State# RealWorld
s4 -> MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
marr State# RealWorld
s4
) of (# State# RealWorld
_, ByteArray#
a #) -> ByteArray#
a
{-# INLINE getBytes #-}
fromBytes :: Int# -> ByteArray# -> FloatX3
fromBytes Int#
off ByteArray#
arr
| Int#
i <- BOFF_TO_PRIMOFF(off)
= Float# -> Float# -> Float# -> FloatX3
FloatX3#
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
i)
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr (Int#
i Int# -> Int# -> Int#
+# Int#
1#))
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr (Int#
i Int# -> Int# -> Int#
+# Int#
2#))
{-# INLINE fromBytes #-}
readBytes :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX3 #)
readBytes MutableByteArray# s
mba Int#
off State# s
s0
| Int#
i <- BOFF_TO_PRIMOFF(off)
= case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba Int#
i State# s
s0 of
(# State# s
s1, Float#
a1 #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
1#) State# s
s1 of
(# State# s
s2, Float#
a2 #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
2#) State# s
s2 of
(# State# s
s3, Float#
a3 #) -> (# State# s
s3, Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
a1 Float#
a2 Float#
a3 #)
{-# INLINE readBytes #-}
writeBytes :: MutableByteArray# s -> Int# -> FloatX3 -> State# s -> State# s
writeBytes MutableByteArray# s
mba Int#
off (FloatX3# Float#
a1 Float#
a2 Float#
a3) State# s
s
| Int#
i <- BOFF_TO_PRIMOFF(off)
= MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
2#) Float#
a3
( MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
1#) Float#
a2
( MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba Int#
i Float#
a1 State# s
s ))
{-# INLINE writeBytes #-}
readAddr :: Addr# -> State# s -> (# State# s, FloatX3 #)
readAddr Addr#
addr State# s
s0
= case Addr# -> Int# -> State# s -> (# State# s, Float# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
readFloatOffAddr# Addr#
addr Int#
0# State# s
s0 of
(# State# s
s1, Float#
a1 #) -> case Addr# -> Int# -> State# s -> (# State# s, Float# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
readFloatOffAddr# Addr#
addr Int#
1# State# s
s1 of
(# State# s
s2, Float#
a2 #) -> case Addr# -> Int# -> State# s -> (# State# s, Float# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
readFloatOffAddr# Addr#
addr Int#
2# State# s
s2 of
(# State# s
s3, Float#
a3 #) -> (# State# s
s3, Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
a1 Float#
a2 Float#
a3 #)
{-# INLINE readAddr #-}
writeAddr :: FloatX3 -> Addr# -> State# s -> State# s
writeAddr (FloatX3# Float#
a1 Float#
a2 Float#
a3) Addr#
addr State# s
s
= Addr# -> Int# -> Float# -> State# s -> State# s
forall d. Addr# -> Int# -> Float# -> State# d -> State# d
writeFloatOffAddr# Addr#
addr Int#
2# Float#
a3
( Addr# -> Int# -> Float# -> State# s -> State# s
forall d. Addr# -> Int# -> Float# -> State# d -> State# d
writeFloatOffAddr# Addr#
addr Int#
1# Float#
a2
( Addr# -> Int# -> Float# -> State# s -> State# s
forall d. Addr# -> Int# -> Float# -> State# d -> State# d
writeFloatOffAddr# Addr#
addr Int#
0# Float#
a1 State# s
s ))
{-# INLINE writeAddr #-}
byteSize :: FloatX3 -> Int#
byteSize FloatX3
_ = Float -> Int#
forall a. PrimBytes a => a -> Int#
byteSize @Float Float
forall a. HasCallStack => a
undefined Int# -> Int# -> Int#
*# ELEM_N#
{-# INLINE byteSize #-}
byteAlign :: FloatX3 -> Int#
byteAlign FloatX3
_ = Float -> Int#
forall a. PrimBytes a => a -> Int#
byteAlign @Float Float
forall a. HasCallStack => a
undefined
{-# INLINE byteAlign #-}
byteOffset :: FloatX3 -> Int#
byteOffset FloatX3
_ = Int#
0#
{-# INLINE byteOffset #-}
byteFieldOffset :: Proxy# name -> FloatX3 -> Int#
byteFieldOffset Proxy# name
_ FloatX3
_ = Int# -> Int#
negateInt# Int#
1#
{-# INLINE byteFieldOffset #-}
indexArray :: ByteArray# -> Int# -> FloatX3
indexArray ByteArray#
ba Int#
off
| Int#
i <- Int#
off Int# -> Int# -> Int#
*# ELEM_N#
= Float# -> Float# -> Float# -> FloatX3
FloatX3#
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba Int#
i)
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
i Int# -> Int# -> Int#
+# Int#
1#))
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
i Int# -> Int# -> Int#
+# Int#
2#))
{-# INLINE indexArray #-}
readArray :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX3 #)
readArray MutableByteArray# s
mba Int#
off State# s
s0
| Int#
i <- Int#
off Int# -> Int# -> Int#
*# ELEM_N#
= case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba Int#
i State# s
s0 of
(# State# s
s1, Float#
a1 #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
1#) State# s
s1 of
(# State# s
s2, Float#
a2 #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
2#) State# s
s2 of
(# State# s
s3, Float#
a3 #) -> (# State# s
s3, Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
a1 Float#
a2 Float#
a3 #)
{-# INLINE readArray #-}
writeArray :: MutableByteArray# s -> Int# -> FloatX3 -> State# s -> State# s
writeArray MutableByteArray# s
mba Int#
off (FloatX3# Float#
a1 Float#
a2 Float#
a3) State# s
s
| Int#
i <- Int#
off Int# -> Int# -> Int#
*# ELEM_N#
= MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
2#) Float#
a3
( MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba (Int#
i Int# -> Int# -> Int#
+# Int#
1#) Float#
a2
( MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
mba Int#
i Float#
a1 State# s
s ))
{-# INLINE writeArray #-}
instance PrimArray Float FloatX3 where
broadcast# :: Float -> FloatX3
broadcast# (F# Float#
x) = Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
x Float#
x
{-# INLINE broadcast# #-}
ix# :: Int# -> FloatX3 -> Float
ix# Int#
0# (FloatX3# Float#
a1 Float#
_ Float#
_) = Float# -> Float
F# Float#
a1
ix# Int#
1# (FloatX3# Float#
_ Float#
a2 Float#
_) = Float# -> Float
F# Float#
a2
ix# Int#
2# (FloatX3# Float#
_ Float#
_ Float#
a3) = Float# -> Float
F# Float#
a3
ix# Int#
_ FloatX3
_ = Float
forall a. HasCallStack => a
undefined
{-# INLINE ix# #-}
gen# :: CumulDims -> (s -> (# s, Float #)) -> s -> (# s, FloatX3 #)
gen# CumulDims
_ s -> (# s, Float #)
f s
s0 = case s -> (# s, Float #)
f s
s0 of
(# s
s1, F# Float#
a1 #) -> case s -> (# s, Float #)
f s
s1 of
(# s
s2, F# Float#
a2 #) -> case s -> (# s, Float #)
f s
s2 of
(# s
s3, F# Float#
a3 #) -> (# s
s3, Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
a1 Float#
a2 Float#
a3 #)
upd# :: CumulDims -> Int# -> Float -> FloatX3 -> FloatX3
upd# CumulDims
_ Int#
0# (F# Float#
q) (FloatX3# Float#
_ Float#
y Float#
z) = Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
q Float#
y Float#
z
upd# CumulDims
_ Int#
1# (F# Float#
q) (FloatX3# Float#
x Float#
_ Float#
z) = Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
q Float#
z
upd# CumulDims
_ Int#
2# (F# Float#
q) (FloatX3# Float#
x Float#
y Float#
_) = Float# -> Float# -> Float# -> FloatX3
FloatX3# Float#
x Float#
y Float#
q
upd# CumulDims
_ Int#
_ Float
_ FloatX3
x = FloatX3
x
{-# INLINE upd# #-}
withArrayContent# :: (Float -> r)
-> (CumulDims -> Int# -> ByteArray# -> r) -> FloatX3 -> r
withArrayContent# Float -> r
_ CumulDims -> Int# -> ByteArray# -> r
g FloatX3
x = CumulDims -> Int# -> ByteArray# -> r
g ([Word] -> CumulDims
CumulDims [ELEM_N, 1]) 0# (getBytes x)
{-# INLINE withArrayContent# #-}
offsetElems :: FloatX3 -> Int#
offsetElems FloatX3
_ = Int#
0#
{-# INLINE offsetElems #-}
uniqueOrCumulDims :: FloatX3 -> Either Float CumulDims
uniqueOrCumulDims FloatX3
_ = CumulDims -> Either Float CumulDims
forall a b. b -> Either a b
Right ([Word] -> CumulDims
CumulDims [ELEM_N, 1])
{-# INLINE uniqueOrCumulDims #-}
fromElems# :: CumulDims -> Int# -> ByteArray# -> FloatX3
fromElems# CumulDims
_ Int#
off ByteArray#
ba = Float# -> Float# -> Float# -> FloatX3
FloatX3#
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba Int#
off)
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
off Int# -> Int# -> Int#
+# Int#
1#))
(ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
off Int# -> Int# -> Int#
+# Int#
2#))
{-# INLINE fromElems# #-}