{-# LANGUAGE CPP                   #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MagicHash             #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE UnboxedTuples         #-}
{-# LANGUAGE UndecidableInstances  #-}
module Numeric.DataFrame.Internal.Backend.Family.FloatX2 (FloatX2 (..)) 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 FloatX2 = FloatX2# Float# Float#

-- | Since @Bounded@ is not implemented for floating point types, this instance
--   has an unresolvable constraint.
--   Nevetheless, it is good to have it here for nicer error messages.
instance Bounded Float => Bounded FloatX2 where
    maxBound :: FloatX2
maxBound = case Float
forall a. Bounded a => a
maxBound of F# Float#
x -> Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
x
    minBound :: FloatX2
minBound = case Float
forall a. Bounded a => a
minBound of F# Float#
x -> Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
x


instance Eq FloatX2 where

    FloatX2# Float#
a1 Float#
a2 == :: FloatX2 -> FloatX2 -> Bool
== FloatX2# Float#
b1 Float#
b2 =
      Int# -> Bool
isTrue#
      (       (Float#
a1 Float# -> Float# -> Int#
`eqFloat#` Float#
b1)
      Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`eqFloat#` Float#
b2)
      )
    {-# INLINE (==) #-}

    FloatX2# Float#
a1 Float#
a2 /= :: FloatX2 -> FloatX2 -> Bool
/= FloatX2# Float#
b1 Float#
b2 =
      Int# -> Bool
isTrue#
      (      (Float#
a1 Float# -> Float# -> Int#
`neFloat#` Float#
b1)
      Int# -> Int# -> Int#
`orI#` (Float#
a2 Float# -> Float# -> Int#
`neFloat#` Float#
b2)
      )
    {-# 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 FloatX2 where
    cmp :: FloatX2 -> FloatX2 -> PartialOrdering
cmp (FloatX2# Float#
a1 Float#
a2) (FloatX2# Float#
b1 Float#
b2)
      = 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
    {-# INLINE cmp #-}

instance Ord (NonTransitive.ProductOrd FloatX2) where
    NonTransitive.ProductOrd FloatX2
x > :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
> NonTransitive.ProductOrd FloatX2
y = FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
x FloatX2
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PGT
    {-# INLINE (>) #-}
    NonTransitive.ProductOrd FloatX2
x < :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
< NonTransitive.ProductOrd FloatX2
y = FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
x FloatX2
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PLT
    {-# INLINE (<) #-}
    >= :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
(>=) (NonTransitive.ProductOrd (FloatX2# Float#
a1 Float#
a2))
         (NonTransitive.ProductOrd (FloatX2# Float#
b1 Float#
b2)) = Int# -> Bool
isTrue#
      ((Float#
a1 Float# -> Float# -> Int#
`geFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`geFloat#` Float#
b2))
    {-# INLINE (>=) #-}
    <= :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
(<=) (NonTransitive.ProductOrd (FloatX2# Float#
a1 Float#
a2))
         (NonTransitive.ProductOrd (FloatX2# Float#
b1 Float#
b2)) = Int# -> Bool
isTrue#
      ((Float#
a1 Float# -> Float# -> Int#
`leFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`leFloat#` Float#
b2))
    {-# INLINE (<=) #-}
    compare :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Ordering
compare (NonTransitive.ProductOrd FloatX2
a) (NonTransitive.ProductOrd FloatX2
b)
      = PartialOrdering -> Ordering
NonTransitive.toOrdering (PartialOrdering -> Ordering) -> PartialOrdering -> Ordering
forall a b. (a -> b) -> a -> b
$ FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
a FloatX2
b
    {-# INLINE compare #-}
    min :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> ProductOrd FloatX2
min (NonTransitive.ProductOrd (FloatX2# Float#
a1 Float#
a2))
        (NonTransitive.ProductOrd (FloatX2# Float#
b1 Float#
b2))
      = FloatX2 -> ProductOrd FloatX2
forall a. a -> ProductOrd a
NonTransitive.ProductOrd
        ( Float# -> Float# -> FloatX2
FloatX2#
          (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)
        )
    {-# INLINE min #-}
    max :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> ProductOrd FloatX2
max (NonTransitive.ProductOrd (FloatX2# Float#
a1 Float#
a2))
        (NonTransitive.ProductOrd (FloatX2# Float#
b1 Float#
b2))
      = FloatX2 -> ProductOrd FloatX2
forall a. a -> ProductOrd a
NonTransitive.ProductOrd
        ( Float# -> Float# -> FloatX2
FloatX2#
          (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)
        )
    {-# INLINE max #-}

instance Ord (Partial.ProductOrd FloatX2) where
    Partial.ProductOrd FloatX2
x > :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
> Partial.ProductOrd FloatX2
y = FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
x FloatX2
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PGT
    {-# INLINE (>) #-}
    Partial.ProductOrd FloatX2
x < :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
< Partial.ProductOrd FloatX2
y = FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
x FloatX2
y PartialOrdering -> PartialOrdering -> Bool
forall a. Eq a => a -> a -> Bool
== PartialOrdering
PLT
    {-# INLINE (<) #-}
    >= :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
(>=) (Partial.ProductOrd (FloatX2# Float#
a1 Float#
a2))
         (Partial.ProductOrd (FloatX2# Float#
b1 Float#
b2)) = Int# -> Bool
isTrue#
      ((Float#
a1 Float# -> Float# -> Int#
`geFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`geFloat#` Float#
b2))
    {-# INLINE (>=) #-}
    <= :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Bool
(<=) (Partial.ProductOrd (FloatX2# Float#
a1 Float#
a2))
         (Partial.ProductOrd (FloatX2# Float#
b1 Float#
b2)) = Int# -> Bool
isTrue#
      ((Float#
a1 Float# -> Float# -> Int#
`leFloat#` Float#
b1) Int# -> Int# -> Int#
`andI#` (Float#
a2 Float# -> Float# -> Int#
`leFloat#` Float#
b2))
    {-# INLINE (<=) #-}
    compare :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> Ordering
compare (Partial.ProductOrd FloatX2
a) (Partial.ProductOrd FloatX2
b)
      = PartialOrdering -> Ordering
Partial.toOrdering (PartialOrdering -> Ordering) -> PartialOrdering -> Ordering
forall a b. (a -> b) -> a -> b
$ FloatX2 -> FloatX2 -> PartialOrdering
forall a. ProductOrder a => a -> a -> PartialOrdering
cmp FloatX2
a FloatX2
b
    {-# INLINE compare #-}
    min :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> ProductOrd FloatX2
min (Partial.ProductOrd (FloatX2# Float#
a1 Float#
a2))
        (Partial.ProductOrd (FloatX2# Float#
b1 Float#
b2))
      = FloatX2 -> ProductOrd FloatX2
forall a. a -> ProductOrd a
Partial.ProductOrd
        ( Float# -> Float# -> FloatX2
FloatX2#
          (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)
        )
    {-# INLINE min #-}
    max :: ProductOrd FloatX2 -> ProductOrd FloatX2 -> ProductOrd FloatX2
max (Partial.ProductOrd (FloatX2# Float#
a1 Float#
a2))
        (Partial.ProductOrd (FloatX2# Float#
b1 Float#
b2))
      = FloatX2 -> ProductOrd FloatX2
forall a. a -> ProductOrd a
Partial.ProductOrd
        ( Float# -> Float# -> FloatX2
FloatX2#
          (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)
        )
    {-# INLINE max #-}

instance Ord FloatX2 where
    FloatX2# Float#
a1 Float#
a2 > :: FloatX2 -> FloatX2 -> Bool
> FloatX2# Float#
b1 Float#
b2
      | 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
      | Bool
otherwise           = Bool
False
    {-# INLINE (>) #-}

    FloatX2# Float#
a1 Float#
a2 < :: FloatX2 -> FloatX2 -> Bool
< FloatX2# Float#
b1 Float#
b2
      | 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
      | Bool
otherwise           = Bool
False
    {-# INLINE (<) #-}

    FloatX2# Float#
a1 Float#
a2 >= :: FloatX2 -> FloatX2 -> Bool
>= FloatX2# Float#
b1 Float#
b2
      | 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
      | Bool
otherwise           = Bool
True
    {-# INLINE (>=) #-}

    FloatX2# Float#
a1 Float#
a2 <= :: FloatX2 -> FloatX2 -> Bool
<= FloatX2# Float#
b1 Float#
b2
      | 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
      | Bool
otherwise           = Bool
True
    {-# INLINE (<=) #-}

    compare :: FloatX2 -> FloatX2 -> Ordering
compare (FloatX2# Float#
a1 Float#
a2) (FloatX2# Float#
b1 Float#
b2)
      | 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
      | Bool
otherwise           = Ordering
EQ
    {-# INLINE compare #-}



-- | element-wise operations for vectors
instance Num FloatX2 where

    FloatX2# Float#
a1 Float#
a2 + :: FloatX2 -> FloatX2 -> FloatX2
+ FloatX2# Float#
b1 Float#
b2
      = Float# -> Float# -> FloatX2
FloatX2# (Float# -> Float# -> Float#
plusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
plusFloat# Float#
a2 Float#
b2)
    {-# INLINE (+) #-}

    FloatX2# Float#
a1 Float#
a2 - :: FloatX2 -> FloatX2 -> FloatX2
- FloatX2# Float#
b1 Float#
b2
      = Float# -> Float# -> FloatX2
FloatX2# (Float# -> Float# -> Float#
minusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
minusFloat# Float#
a2 Float#
b2)
    {-# INLINE (-) #-}

    FloatX2# Float#
a1 Float#
a2 * :: FloatX2 -> FloatX2 -> FloatX2
* FloatX2# Float#
b1 Float#
b2
      = Float# -> Float# -> FloatX2
FloatX2# (Float# -> Float# -> Float#
timesFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
timesFloat# Float#
a2 Float#
b2)
    {-# INLINE (*) #-}

    negate :: FloatX2 -> FloatX2
negate (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
negateFloat# Float#
a1) (Float# -> Float#
negateFloat# Float#
a2)
    {-# INLINE negate #-}

    abs :: FloatX2 -> FloatX2
abs (FloatX2# Float#
a1 Float#
a2)
      = Float# -> Float# -> FloatX2
FloatX2#
      (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)
    {-# INLINE abs #-}

    signum :: FloatX2 -> FloatX2
signum (FloatX2# Float#
a1 Float#
a2)
      = Float# -> Float# -> FloatX2
FloatX2# (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# )
    {-# INLINE signum #-}

    fromInteger :: Integer -> FloatX2
fromInteger Integer
n = case Integer -> Float
forall a. Num a => Integer -> a
fromInteger Integer
n of F# Float#
x -> Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
x
    {-# INLINE fromInteger #-}



instance Fractional FloatX2 where

    FloatX2# Float#
a1 Float#
a2 / :: FloatX2 -> FloatX2 -> FloatX2
/ FloatX2# Float#
b1 Float#
b2 = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float# -> Float#
divideFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
divideFloat# Float#
a2 Float#
b2)
    {-# INLINE (/) #-}

    recip :: FloatX2 -> FloatX2
recip (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a1) (Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a2)
    {-# INLINE recip #-}

    fromRational :: Rational -> FloatX2
fromRational Rational
r = case Rational -> Float
forall a. Fractional a => Rational -> a
fromRational Rational
r of F# Float#
x -> Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
x
    {-# INLINE fromRational #-}



instance Floating FloatX2 where

    pi :: FloatX2
pi = Float# -> Float# -> FloatX2
FloatX2#
      Float#
3.141592653589793238#
      Float#
3.141592653589793238#
    {-# INLINE pi #-}

    exp :: FloatX2 -> FloatX2
exp (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
expFloat# Float#
a1) (Float# -> Float#
expFloat# Float#
a2)
    {-# INLINE exp #-}

    log :: FloatX2 -> FloatX2
log (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
logFloat# Float#
a1) (Float# -> Float#
logFloat# Float#
a2)
    {-# INLINE log #-}

    sqrt :: FloatX2 -> FloatX2
sqrt (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
sqrtFloat# Float#
a1) (Float# -> Float#
sqrtFloat# Float#
a2)
    {-# INLINE sqrt #-}

    sin :: FloatX2 -> FloatX2
sin (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
sinFloat# Float#
a1) (Float# -> Float#
sinFloat# Float#
a2)
    {-# INLINE sin #-}

    cos :: FloatX2 -> FloatX2
cos (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
cosFloat# Float#
a1) (Float# -> Float#
cosFloat# Float#
a2)
    {-# INLINE cos #-}

    tan :: FloatX2 -> FloatX2
tan (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
tanFloat# Float#
a1) (Float# -> Float#
tanFloat# Float#
a2)
    {-# INLINE tan #-}

    asin :: FloatX2 -> FloatX2
asin (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
asinFloat# Float#
a1) (Float# -> Float#
asinFloat# Float#
a2)
    {-# INLINE asin #-}

    acos :: FloatX2 -> FloatX2
acos (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
acosFloat# Float#
a1) (Float# -> Float#
acosFloat# Float#
a2)
    {-# INLINE acos #-}

    atan :: FloatX2 -> FloatX2
atan (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
atanFloat# Float#
a1) (Float# -> Float#
atanFloat# Float#
a2)
    {-# INLINE atan #-}

    sinh :: FloatX2 -> FloatX2
sinh (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
sinhFloat# Float#
a1) (Float# -> Float#
sinhFloat# Float#
a2)
    {-# INLINE sinh #-}

    cosh :: FloatX2 -> FloatX2
cosh (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
coshFloat# Float#
a1) (Float# -> Float#
coshFloat# Float#
a2)
    {-# INLINE cosh #-}

    tanh :: FloatX2 -> FloatX2
tanh (FloatX2# Float#
a1 Float#
a2) = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float#
tanhFloat# Float#
a1) (Float# -> Float#
tanhFloat# Float#
a2)
    {-# INLINE tanh #-}

    FloatX2# Float#
a1 Float#
a2 ** :: FloatX2 -> FloatX2 -> FloatX2
** FloatX2# Float#
b1 Float#
b2 = Float# -> Float# -> FloatX2
FloatX2#
      (Float# -> Float# -> Float#
powerFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
powerFloat# Float#
a2 Float#
b2)
    {-# INLINE (**) #-}

    logBase :: FloatX2 -> FloatX2 -> FloatX2
logBase FloatX2
x FloatX2
y         =  FloatX2 -> FloatX2
forall a. Floating a => a -> a
log FloatX2
y FloatX2 -> FloatX2 -> FloatX2
forall a. Fractional a => a -> a -> a
/ FloatX2 -> FloatX2
forall a. Floating a => a -> a
log FloatX2
x
    {-# INLINE logBase #-}

    asinh :: FloatX2 -> FloatX2
asinh FloatX2
x = FloatX2 -> FloatX2
forall a. Floating a => a -> a
log (FloatX2
x FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+ FloatX2 -> FloatX2
forall a. Floating a => a -> a
sqrt (FloatX2
1.0FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+FloatX2
xFloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
*FloatX2
x))
    {-# INLINE asinh #-}

    acosh :: FloatX2 -> FloatX2
acosh FloatX2
x = FloatX2 -> FloatX2
forall a. Floating a => a -> a
log (FloatX2
x FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+ (FloatX2
xFloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+FloatX2
1.0) FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
* FloatX2 -> FloatX2
forall a. Floating a => a -> a
sqrt ((FloatX2
xFloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
-FloatX2
1.0)FloatX2 -> FloatX2 -> FloatX2
forall a. Fractional a => a -> a -> a
/(FloatX2
xFloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+FloatX2
1.0)))
    {-# INLINE acosh #-}

    atanh :: FloatX2 -> FloatX2
atanh FloatX2
x = FloatX2
0.5 FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
* FloatX2 -> FloatX2
forall a. Floating a => a -> a
log ((FloatX2
1.0FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
+FloatX2
x) FloatX2 -> FloatX2 -> FloatX2
forall a. Fractional a => a -> a -> a
/ (FloatX2
1.0FloatX2 -> FloatX2 -> FloatX2
forall a. Num a => a -> a -> a
-FloatX2
x))
    {-# INLINE atanh #-}

-- offset in bytes is S times bigger than offset in prim elements,
-- when S is power of two, this is equal to shift
#define BOFF_TO_PRIMOFF(off) uncheckedIShiftRL# off 2#
#define ELEM_N 2

instance PrimBytes FloatX2 where

    getBytes :: FloatX2 -> ByteArray#
getBytes (FloatX2# Float#
a1 Float#
a2) = 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# (FloatX2 -> Int#
forall a. PrimBytes a => a -> Int#
byteSize @FloatX2 FloatX2
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 -> MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
marr State# RealWorld
s3
       ) of (# State# RealWorld
_, ByteArray#
a #) -> ByteArray#
a
    {-# INLINE getBytes #-}

    fromBytes :: Int# -> ByteArray# -> FloatX2
fromBytes Int#
off ByteArray#
arr
      | Int#
i <- BOFF_TO_PRIMOFF(off)
      = Float# -> Float# -> FloatX2
FloatX2#
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
i)
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr (Int#
i Int# -> Int# -> Int#
+# Int#
1#))
    {-# INLINE fromBytes #-}

    readBytes :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX2 #)
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 #) -> (# State# s
s2, Float# -> Float# -> FloatX2
FloatX2# Float#
a1 Float#
a2 #)
    {-# INLINE readBytes #-}

    writeBytes :: MutableByteArray# s -> Int# -> FloatX2 -> State# s -> State# s
writeBytes MutableByteArray# s
mba Int#
off (FloatX2# Float#
a1 Float#
a2) 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#
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, FloatX2 #)
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 #) -> (# State# s
s2, Float# -> Float# -> FloatX2
FloatX2# Float#
a1 Float#
a2 #)
    {-# INLINE readAddr #-}

    writeAddr :: FloatX2 -> Addr# -> State# s -> State# s
writeAddr (FloatX2# Float#
a1 Float#
a2) 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#
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 :: FloatX2 -> Int#
byteSize FloatX2
_ = Float -> Int#
forall a. PrimBytes a => a -> Int#
byteSize @Float Float
forall a. HasCallStack => a
undefined Int# -> Int# -> Int#
*# ELEM_N#
    {-# INLINE byteSize #-}

    byteAlign :: FloatX2 -> Int#
byteAlign FloatX2
_ = Float -> Int#
forall a. PrimBytes a => a -> Int#
byteAlign @Float Float
forall a. HasCallStack => a
undefined
    {-# INLINE byteAlign #-}

    byteOffset :: FloatX2 -> Int#
byteOffset FloatX2
_ = Int#
0#
    {-# INLINE byteOffset #-}

    byteFieldOffset :: Proxy# name -> FloatX2 -> Int#
byteFieldOffset Proxy# name
_ FloatX2
_ = Int# -> Int#
negateInt# Int#
1#
    {-# INLINE byteFieldOffset #-}

    indexArray :: ByteArray# -> Int# -> FloatX2
indexArray ByteArray#
ba Int#
off
      | Int#
i <- Int#
off Int# -> Int# -> Int#
*# ELEM_N#
      = Float# -> Float# -> FloatX2
FloatX2#
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba Int#
i)
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
i Int# -> Int# -> Int#
+# Int#
1#))
    {-# INLINE indexArray #-}

    readArray :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX2 #)
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 #) -> (# State# s
s2, Float# -> Float# -> FloatX2
FloatX2# Float#
a1 Float#
a2 #)
    {-# INLINE readArray #-}

    writeArray :: MutableByteArray# s -> Int# -> FloatX2 -> State# s -> State# s
writeArray MutableByteArray# s
mba Int#
off (FloatX2# Float#
a1 Float#
a2) 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#
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 FloatX2 where

    broadcast# :: Float -> FloatX2
broadcast# (F# Float#
x) = Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
x
    {-# INLINE broadcast# #-}

    ix# :: Int# -> FloatX2 -> Float
ix# Int#
0# (FloatX2# Float#
a1 Float#
_) = Float# -> Float
F# Float#
a1
    ix# Int#
1# (FloatX2# Float#
_ Float#
a2) = Float# -> Float
F# Float#
a2
    ix# Int#
_   FloatX2
_              = Float
forall a. HasCallStack => a
undefined
    {-# INLINE ix# #-}

    gen# :: CumulDims -> (s -> (# s, Float #)) -> s -> (# s, FloatX2 #)
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 #) -> (# s
s2, Float# -> Float# -> FloatX2
FloatX2# Float#
a1 Float#
a2 #)


    upd# :: CumulDims -> Int# -> Float -> FloatX2 -> FloatX2
upd# CumulDims
_ Int#
0# (F# Float#
q) (FloatX2# Float#
_ Float#
y) = Float# -> Float# -> FloatX2
FloatX2# Float#
q Float#
y
    upd# CumulDims
_ Int#
1# (F# Float#
q) (FloatX2# Float#
x Float#
_) = Float# -> Float# -> FloatX2
FloatX2# Float#
x Float#
q
    upd# CumulDims
_ Int#
_ Float
_ FloatX2
x                    = FloatX2
x
    {-# INLINE upd# #-}

    withArrayContent# :: (Float -> r)
-> (CumulDims -> Int# -> ByteArray# -> r) -> FloatX2 -> r
withArrayContent# Float -> r
_ CumulDims -> Int# -> ByteArray# -> r
g FloatX2
x = CumulDims -> Int# -> ByteArray# -> r
g ([Word] -> CumulDims
CumulDims [ELEM_N, 1]) 0# (getBytes x)
    {-# INLINE withArrayContent# #-}

    offsetElems :: FloatX2 -> Int#
offsetElems FloatX2
_ = Int#
0#
    {-# INLINE offsetElems #-}

    uniqueOrCumulDims :: FloatX2 -> Either Float CumulDims
uniqueOrCumulDims FloatX2
_ = CumulDims -> Either Float CumulDims
forall a b. b -> Either a b
Right ([Word] -> CumulDims
CumulDims [ELEM_N, 1])
    {-# INLINE uniqueOrCumulDims #-}

    fromElems# :: CumulDims -> Int# -> ByteArray# -> FloatX2
fromElems# CumulDims
_ Int#
off ByteArray#
ba = Float# -> Float# -> FloatX2
FloatX2#
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba Int#
off)
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
off Int# -> Int# -> Int#
+# Int#
1#))
    {-# INLINE fromElems# #-}