{-# LANGUAGE CPP                   #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MagicHash             #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE UnboxedTuples         #-}
{-# LANGUAGE UndecidableInstances  #-}
{-# OPTIONS_GHC -fno-warn-orphans  #-}
module Numeric.DataFrame.Internal.Backend.Family.FloatX4 (FloatX4 (..)) where


import           GHC.Base
import           Numeric.DataFrame.Internal.PrimArray
import           Numeric.DataFrame.SubSpace
import           Numeric.Dimensions
import           Numeric.PrimBytes
import           Numeric.ProductOrd
import qualified Numeric.ProductOrd.NonTransitive     as NonTransitive
import qualified Numeric.ProductOrd.Partial           as Partial
import           Unsafe.Coerce                        (unsafeCoerce)


data FloatX4 = FloatX4# Float# Float# 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 FloatX4 where
    maxBound :: FloatX4
maxBound = case Float
forall a. Bounded a => a
maxBound of F# Float#
x -> Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
x Float#
x Float#
x Float#
x
    minBound :: FloatX4
minBound = case Float
forall a. Bounded a => a
minBound of F# Float#
x -> Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
x Float#
x Float#
x Float#
x


instance Eq FloatX4 where

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 == :: FloatX4 -> FloatX4 -> Bool
== FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4 =
      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)
      Int# -> Int# -> Int#
`andI#` (Float#
a4 Float# -> Float# -> Int#
`eqFloat#` Float#
b4)
      )
    {-# INLINE (==) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 /= :: FloatX4 -> FloatX4 -> Bool
/= FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4 =
      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)
      Int# -> Int# -> Int#
`orI#` (Float#
a4 Float# -> Float# -> Int#
`neFloat#` Float#
b4)
      )
    {-# 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 FloatX4 where
    cmp :: FloatX4 -> FloatX4 -> PartialOrdering
cmp (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) (FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4)
      = 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 PartialOrdering -> PartialOrdering -> PartialOrdering
forall a. Semigroup a => a -> a -> a
<> Float# -> Float# -> PartialOrdering
cmp' Float#
a4 Float#
b4
    {-# INLINE cmp #-}

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

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

instance Ord FloatX4 where
    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 > :: FloatX4 -> FloatX4 -> Bool
> FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      | 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
      | Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) = Bool
False
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`gtFloat#` Float#
b4) = Bool
True
      | Bool
otherwise           = Bool
False
    {-# INLINE (>) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 < :: FloatX4 -> FloatX4 -> Bool
< FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      | 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
      | Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) = Bool
False
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`ltFloat#` Float#
b4) = Bool
True
      | Bool
otherwise           = Bool
False
    {-# INLINE (<) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 >= :: FloatX4 -> FloatX4 -> Bool
>= FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      | 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
      | Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`gtFloat#` Float#
b3) = Bool
True
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`ltFloat#` Float#
b4) = Bool
False
      | Bool
otherwise           = Bool
True
    {-# INLINE (>=) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 <= :: FloatX4 -> FloatX4 -> Bool
<= FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      | 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
      | Int# -> Bool
isTrue# (Float#
a3 Float# -> Float# -> Int#
`ltFloat#` Float#
b3) = Bool
True
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`gtFloat#` Float#
b4) = Bool
False
      | Bool
otherwise           = Bool
True
    {-# INLINE (<=) #-}

    compare :: FloatX4 -> FloatX4 -> Ordering
compare (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) (FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4)
      | 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
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`gtFloat#` Float#
b4) = Ordering
GT
      | Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`ltFloat#` Float#
b4) = Ordering
LT
      | Bool
otherwise           = Ordering
EQ
    {-# INLINE compare #-}


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

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 + :: FloatX4 -> FloatX4 -> FloatX4
+ FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# (Float# -> Float# -> Float#
plusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
plusFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
plusFloat# Float#
a3 Float#
b3) (Float# -> Float# -> Float#
plusFloat# Float#
a4 Float#
b4)
    {-# INLINE (+) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 - :: FloatX4 -> FloatX4 -> FloatX4
- FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# (Float# -> Float# -> Float#
minusFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
minusFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
minusFloat# Float#
a3 Float#
b3) (Float# -> Float# -> Float#
minusFloat# Float#
a4 Float#
b4)
    {-# INLINE (-) #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 * :: FloatX4 -> FloatX4 -> FloatX4
* FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# (Float# -> Float# -> Float#
timesFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
timesFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
timesFloat# Float#
a3 Float#
b3) (Float# -> Float# -> Float#
timesFloat# Float#
a4 Float#
b4)
    {-# INLINE (*) #-}

    negate :: FloatX4 -> FloatX4
negate (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
negateFloat# Float#
a1) (Float# -> Float#
negateFloat# Float#
a2) (Float# -> Float#
negateFloat# Float#
a3) (Float# -> Float#
negateFloat# Float#
a4)
    {-# INLINE negate #-}

    abs :: FloatX4 -> FloatX4
abs (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4)
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (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)
      (if Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`geFloat#` Float#
0.0#) then Float#
a4 else Float# -> Float#
negateFloat# Float#
a4)
    {-# INLINE abs #-}

    signum :: FloatX4 -> FloatX4
signum (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4)
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# (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# )
                 (if Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`gtFloat#` Float#
0.0#)
                  then Float#
1.0#
                  else if Int# -> Bool
isTrue# (Float#
a4 Float# -> Float# -> Int#
`ltFloat#` Float#
0.0#) then Float#
-1.0# else Float#
0.0# )
    {-# INLINE signum #-}

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



instance Fractional FloatX4 where

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 / :: FloatX4 -> FloatX4 -> FloatX4
/ FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4 = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float# -> Float#
divideFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
divideFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
divideFloat# Float#
a3 Float#
b3) (Float# -> Float# -> Float#
divideFloat# Float#
a4 Float#
b4)
    {-# INLINE (/) #-}

    recip :: FloatX4 -> FloatX4
recip (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (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) (Float# -> Float# -> Float#
divideFloat# Float#
1.0# Float#
a4)
    {-# INLINE recip #-}

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



instance Floating FloatX4 where

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

    exp :: FloatX4 -> FloatX4
exp (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
expFloat# Float#
a1) (Float# -> Float#
expFloat# Float#
a2) (Float# -> Float#
expFloat# Float#
a3) (Float# -> Float#
expFloat# Float#
a4)
    {-# INLINE exp #-}

    log :: FloatX4 -> FloatX4
log (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
logFloat# Float#
a1) (Float# -> Float#
logFloat# Float#
a2) (Float# -> Float#
logFloat# Float#
a3) (Float# -> Float#
logFloat# Float#
a4)
    {-# INLINE log #-}

    sqrt :: FloatX4 -> FloatX4
sqrt (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
sqrtFloat# Float#
a1) (Float# -> Float#
sqrtFloat# Float#
a2) (Float# -> Float#
sqrtFloat# Float#
a3) (Float# -> Float#
sqrtFloat# Float#
a4)
    {-# INLINE sqrt #-}

    sin :: FloatX4 -> FloatX4
sin (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
sinFloat# Float#
a1) (Float# -> Float#
sinFloat# Float#
a2) (Float# -> Float#
sinFloat# Float#
a3) (Float# -> Float#
sinFloat# Float#
a4)
    {-# INLINE sin #-}

    cos :: FloatX4 -> FloatX4
cos (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
cosFloat# Float#
a1) (Float# -> Float#
cosFloat# Float#
a2) (Float# -> Float#
cosFloat# Float#
a3) (Float# -> Float#
cosFloat# Float#
a4)
    {-# INLINE cos #-}

    tan :: FloatX4 -> FloatX4
tan (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
tanFloat# Float#
a1) (Float# -> Float#
tanFloat# Float#
a2) (Float# -> Float#
tanFloat# Float#
a3) (Float# -> Float#
tanFloat# Float#
a4)
    {-# INLINE tan #-}

    asin :: FloatX4 -> FloatX4
asin (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
asinFloat# Float#
a1) (Float# -> Float#
asinFloat# Float#
a2) (Float# -> Float#
asinFloat# Float#
a3) (Float# -> Float#
asinFloat# Float#
a4)
    {-# INLINE asin #-}

    acos :: FloatX4 -> FloatX4
acos (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
acosFloat# Float#
a1) (Float# -> Float#
acosFloat# Float#
a2) (Float# -> Float#
acosFloat# Float#
a3) (Float# -> Float#
acosFloat# Float#
a4)
    {-# INLINE acos #-}

    atan :: FloatX4 -> FloatX4
atan (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
atanFloat# Float#
a1) (Float# -> Float#
atanFloat# Float#
a2) (Float# -> Float#
atanFloat# Float#
a3) (Float# -> Float#
atanFloat# Float#
a4)
    {-# INLINE atan #-}

    sinh :: FloatX4 -> FloatX4
sinh (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
sinhFloat# Float#
a1) (Float# -> Float#
sinhFloat# Float#
a2) (Float# -> Float#
sinhFloat# Float#
a3) (Float# -> Float#
sinhFloat# Float#
a4)
    {-# INLINE sinh #-}

    cosh :: FloatX4 -> FloatX4
cosh (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
coshFloat# Float#
a1) (Float# -> Float#
coshFloat# Float#
a2) (Float# -> Float#
coshFloat# Float#
a3) (Float# -> Float#
coshFloat# Float#
a4)
    {-# INLINE cosh #-}

    tanh :: FloatX4 -> FloatX4
tanh (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float#
tanhFloat# Float#
a1) (Float# -> Float#
tanhFloat# Float#
a2) (Float# -> Float#
tanhFloat# Float#
a3) (Float# -> Float#
tanhFloat# Float#
a4)
    {-# INLINE tanh #-}

    FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 ** :: FloatX4 -> FloatX4 -> FloatX4
** FloatX4# Float#
b1 Float#
b2 Float#
b3 Float#
b4 = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (Float# -> Float# -> Float#
powerFloat# Float#
a1 Float#
b1) (Float# -> Float# -> Float#
powerFloat# Float#
a2 Float#
b2) (Float# -> Float# -> Float#
powerFloat# Float#
a3 Float#
b3) (Float# -> Float# -> Float#
powerFloat# Float#
a4 Float#
b4)
    {-# INLINE (**) #-}

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

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

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

    atanh :: FloatX4 -> FloatX4
atanh FloatX4
x = FloatX4
0.5 FloatX4 -> FloatX4 -> FloatX4
forall a. Num a => a -> a -> a
* FloatX4 -> FloatX4
forall a. Floating a => a -> a
log ((FloatX4
1.0FloatX4 -> FloatX4 -> FloatX4
forall a. Num a => a -> a -> a
+FloatX4
x) FloatX4 -> FloatX4 -> FloatX4
forall a. Fractional a => a -> a -> a
/ (FloatX4
1.0FloatX4 -> FloatX4 -> FloatX4
forall a. Num a => a -> a -> a
-FloatX4
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 4

instance PrimBytes FloatX4 where

    getBytes :: FloatX4 -> ByteArray#
getBytes (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) = 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# (FloatX4 -> Int#
forall a. PrimBytes a => a -> Int#
byteSize @FloatX4 FloatX4
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 -> case MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
marr Int#
3# Float#
a4 State# RealWorld
s4 of
                   State# RealWorld
s5 -> MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
marr State# RealWorld
s5
       ) of (# State# RealWorld
_, ByteArray#
a #) -> ByteArray#
a
    {-# INLINE getBytes #-}

    fromBytes :: Int# -> ByteArray# -> FloatX4
fromBytes Int#
off ByteArray#
arr
      | Int#
i <- BOFF_TO_PRIMOFF(off)
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (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#))
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr (Int#
i Int# -> Int# -> Int#
+# Int#
3#))
    {-# INLINE fromBytes #-}

    readBytes :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX4 #)
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 #) -> 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#
3#) State# s
s3 of
            (# State# s
s4, Float#
a4 #) -> (# State# s
s4, Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 #)
    {-# INLINE readBytes #-}

    writeBytes :: MutableByteArray# s -> Int# -> FloatX4 -> State# s -> State# s
writeBytes MutableByteArray# s
mba Int#
off (FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4) 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#
3#) Float#
a4
      ( 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, FloatX4 #)
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 #) -> case Addr# -> Int# -> State# s -> (# State# s, Float# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
readFloatOffAddr# Addr#
addr Int#
3# State# s
s3 of
            (# State# s
s4, Float#
a4 #) -> (# State# s
s4, Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 #)
    {-# INLINE readAddr #-}

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

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

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

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

    indexArray :: ByteArray# -> Int# -> FloatX4
indexArray ByteArray#
ba Int#
off
      | Int#
i <- Int#
off Int# -> Int# -> Int#
*# ELEM_N#
      = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (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#))
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
i Int# -> Int# -> Int#
+# Int#
3#))
    {-# INLINE indexArray #-}

    readArray :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX4 #)
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 #) -> 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#
3#) State# s
s3 of
            (# State# s
s4, Float#
a4 #) -> (# State# s
s4, Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 #)
    {-# INLINE readArray #-}

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

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

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

    gen# :: CumulDims -> (s -> (# s, Float #)) -> s -> (# s, FloatX4 #)
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 #) -> case s -> (# s, Float #)
f s
s3 of
            (# s
s4, F# Float#
a4 #) -> (# s
s4, Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
a1 Float#
a2 Float#
a3 Float#
a4 #)


    upd# :: CumulDims -> Int# -> Float -> FloatX4 -> FloatX4
upd# CumulDims
_ Int#
0# (F# Float#
q) (FloatX4# Float#
_ Float#
y Float#
z Float#
w) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
q Float#
y Float#
z Float#
w
    upd# CumulDims
_ Int#
1# (F# Float#
q) (FloatX4# Float#
x Float#
_ Float#
z Float#
w) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
x Float#
q Float#
z Float#
w
    upd# CumulDims
_ Int#
2# (F# Float#
q) (FloatX4# Float#
x Float#
y Float#
_ Float#
w) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
x Float#
y Float#
q Float#
w
    upd# CumulDims
_ Int#
3# (F# Float#
q) (FloatX4# Float#
x Float#
y Float#
z Float#
_) = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4# Float#
x Float#
y Float#
z Float#
q
    upd# CumulDims
_ Int#
_ Float
_ FloatX4
x                        = FloatX4
x
    {-# INLINE upd# #-}

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

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

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

    fromElems# :: CumulDims -> Int# -> ByteArray# -> FloatX4
fromElems# CumulDims
_ Int#
off ByteArray#
ba = Float# -> Float# -> Float# -> Float# -> FloatX4
FloatX4#
      (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#))
      (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
ba (Int#
off Int# -> Int# -> Int#
+# Int#
3#))
    {-# INLINE fromElems# #-}

--------------------------------------------------------------------------------
-- Rewrite rules to improve efficiency of algorithms
--
-- Here we don't have access to DataFrame constructors, because we cannot import
-- Numeric.DataFrame.Type module.
-- However, we know that all DataFrame instances are just newtype wrappers
-- (as well as Scalar). Thus, we can use unsafeCoerce# to get access to Arrays
-- inside DataFrames.
--
--------------------------------------------------------------------------------

getIdxOffset :: Idxs '[4] -> Int#
getIdxOffset :: Idxs '[4] -> Int#
getIdxOffset Idxs '[4]
is = case Idxs '[4] -> [Word]
forall a b. a -> b
unsafeCoerce Idxs '[4]
is of
  ~[Word
w] -> case Word
w of W# Word#
i -> Word# -> Int#
word2Int# Word#
i
{-# INLINE getIdxOffset #-}


{-# RULES
"index/FloatX4" forall i . index @Float @'[4] @'[] @'[4] i
  = unsafeCoerce (ix# @Float @FloatX4 (getIdxOffset i))

  #-}