easytensor 1.0.1.0 → 2.0.0.0

raw patch · 73 files changed

+12413/−8879 lines, 73 filesdep +constraints-derivingdep +template-haskelldep ~basedep ~dimensionsPVP ok

version bump matches the API change (PVP)

Dependencies added: constraints-deriving, template-haskell

Dependency ranges changed: base, dimensions

API changes (from Hackage documentation)

Files

• bench/misc.hs +54/−51
• bench/subspacefolds.hs +19/−19
• easytensor.cabal +127/−124
• src-base/Numeric/DataFrame/Internal/Backend/Family.hs +183/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family.hs-boot +28/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/ArrayBase.hs +587/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/DoubleX2.hs +401/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/DoubleX3.hs +436/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/DoubleX4.hs +467/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/FloatX2.hs +401/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/FloatX3.hs +437/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/FloatX4.hs +498/−0
• src-base/Numeric/DataFrame/Internal/Backend/Family/ScalarBase.hs +50/−0
• src/Numeric/DataFrame.hs +7/−11
• src/Numeric/DataFrame/Contraction.hs +40/−19
• src/Numeric/DataFrame/Family.hs +0/−9
• src/Numeric/DataFrame/IO.hs +79/−43
• src/Numeric/DataFrame/Internal/Array.hs +0/−26
• src/Numeric/DataFrame/Internal/Array/Class.hs +0/−51
• src/Numeric/DataFrame/Internal/Array/Family.hs +0/−216
• src/Numeric/DataFrame/Internal/Array/Family/ArrayBase.hs +0/−498
• src/Numeric/DataFrame/Internal/Array/Family/DoubleX2.hs +0/−333
• src/Numeric/DataFrame/Internal/Array/Family/DoubleX3.hs +0/−362
• src/Numeric/DataFrame/Internal/Array/Family/DoubleX4.hs +0/−391
• src/Numeric/DataFrame/Internal/Array/Family/FloatX2.hs +0/−333
• src/Numeric/DataFrame/Internal/Array/Family/FloatX3.hs +0/−362
• src/Numeric/DataFrame/Internal/Array/Family/FloatX4.hs +0/−420
• src/Numeric/DataFrame/Internal/Array/Family/ScalarBase.hs +0/−51
• src/Numeric/DataFrame/Internal/Array/PrimOps.hs +0/−94
• src/Numeric/DataFrame/Internal/Backend.hs +221/−0
• src/Numeric/DataFrame/Internal/Backend.hs-boot +117/−0
• src/Numeric/DataFrame/Internal/BackendI.hs +197/−0
• src/Numeric/DataFrame/Internal/BackendI.hs-boot +9/−0
• src/Numeric/DataFrame/Internal/Mutable.hs +108/−51
• src/Numeric/DataFrame/Internal/PrimArray.hs +140/−0
• src/Numeric/DataFrame/ST.hs +66/−30
• src/Numeric/DataFrame/Shape.hs +0/−238
• src/Numeric/DataFrame/SubSpace.hs +342/−248
• src/Numeric/DataFrame/Type.hs +1140/−464
• src/Numeric/Matrix.hs +4/−326
• src/Numeric/Matrix/Class.hs +0/−151
• src/Numeric/Matrix/Internal.hs +473/−0
• src/Numeric/Matrix/Internal/Mat44d.hs +186/−0
• src/Numeric/Matrix/Internal/Mat44f.hs +186/−0
• src/Numeric/Matrix/Mat44d.hs +0/−196
• src/Numeric/Matrix/Mat44f.hs +0/−196
• src/Numeric/PrimBytes.hs +1792/−1428
• src/Numeric/ProductOrd.hs +128/−0
• src/Numeric/ProductOrd/NonTransitive.hs +315/−0
• src/Numeric/ProductOrd/Partial.hs +318/−0
• src/Numeric/Quaternion.hs +12/−14
• src/Numeric/Quaternion/Class.hs +0/−85
• src/Numeric/Quaternion/Internal.hs +154/−0
• src/Numeric/Quaternion/Internal/QDouble.hs +478/−0
• src/Numeric/Quaternion/Internal/QFloat.hs +478/−0
• src/Numeric/Quaternion/QDouble.hs +0/−559
• src/Numeric/Quaternion/QFloat.hs +0/−579
• src/Numeric/Scalar.hs +2/−35
• src/Numeric/Scalar/Internal.hs +43/−0
• src/Numeric/Semigroup.hs +0/−219
• src/Numeric/Vector.hs +6/−172
• src/Numeric/Vector/Internal.hs +229/−0
• test/Numeric/DataFrame/Arbitraries.hs +178/−62
• test/Numeric/DataFrame/BasicTest.hs +104/−31
• test/Numeric/DataFrame/SubSpaceTest.hs +19/−18
• test/Numeric/MatrixDoubleTest.hs +130/−114
• test/Numeric/MatrixFloatTest.hs +136/−114
• test/Numeric/PrimBytesTest.hs +411/−0
• test/Numeric/QuaterDoubleTest.hs +152/−0
• test/Numeric/QuaterFloatTest.hs +152/−0
• test/Numeric/QuaternionTest.hs +0/−124
• test/Spec.hs +19/−12
• test/Spec/Util.hs +154/−0

@@ -5,70 +5,73 @@  module Main (main) where -import           Numeric.DataFrame-import           Numeric.Dimensions+import Numeric.DataFrame+import Numeric.Dimensions -import qualified Control.Monad.ST as ST+import qualified Control.Monad.ST     as ST import qualified Numeric.DataFrame.ST as ST--- import qualified Numeric.Dimensions.Traverse.ST as ST    main :: IO () main = do     putStrLn "Hello world!"-    print (D @3 :* D @2 :* U)+    print (D3 :* D2 :* U) -    print (fromList D [vec2 1 0, vec2 2 3, vec2 3 4, vec2 5 6]-             :: Maybe (DataFrame Int '[N 2, XN 2]))-    print (fromList D [vec4 1 0 2 11, vec4 2 22 3 0, vec4 3 4 0 0]-             :: Maybe (DataFrame Double '[N 4, XN 0]))-    print (fromList D [vec2 0 0, vec2 2 22, vec2 2 22]-             :: Maybe (DataFrame Float '[N 2, XN 4]))-    print $ fromList (D @3) [0 :: Scf, 1, 3, 5, 7]-    print ( fromList D [9, 13, 2]-             :: Maybe (DataFrame Float '[N 5, N 2, XN 2]))+    print (fromList [vec2 1 0, vec2 2 3, vec2 3 4, vec2 5 6]+             :: DataFrame Int '[XN 0, N 2])+    print (fromList [vec4 1 0 2 11, vec4 2 22 3 0, vec4 3 4 0 0]+             :: DataFrame Double '[XN 0, N 4])+    print (fromList [vec2 0 0, vec2 2 22, vec2 2 22]+             :: DataFrame Float '[XN 0, N 2])+    print $ fromList [0 :: Scf, 1, 3, 5, 7]+    print ( fromList [9, 13, 2]+             :: DataFrame Float '[XN 0, N 5, N 2])     print $ vec2 1 1 %* mat22 1 (vec2 2 (3 :: Float))-    print (toList (42 :: DataFrame Int '[4,3,2]))+     -- Seems like I have to specify known dimension explicitly,     -- because the inference process within the pattern match     -- cannot escape the case expression.     -- On the other hand, if I type wrong dimension it will throw a nice type-level error.-    () <- case fromList D [10, 100, 1000] :: Maybe (DataFrame Double '[N 4, N 2, XN 2]) of-        Just (XFrame m)+    () <- case (fromList [10, 100, 1000] :: DataFrame Double '[XN 0, N 2, N 4]) of+        XFrame m           | KnownDims <- dims `inSpaceOf` m               -- Amazing inference!-              -- m :: KnownNat k => DataFrame '[4,2,k]-            -> print $ vec4 1 2.25 3 0.162 %* m-        Nothing -> print "Failed to construct a DataFrame!"+              -- m :: KnownNat k => DataFrame '[k,2,4]+            -> print $ m %* vec4 1 2.25 3 0.162+        _ -> print "Failed to construct a DataFrame!"     putStrLn "Constructing larger matrices"-    let x :: DataFrame Double '[2,5,4]-        x =   transpose ( (56707.4   <::> 73558.41  <+:> 47950.074  <+:> 83394.61  <+:> 25611.629 )-                     <::> (53704.516 <::> -3277.478 <+:> 99479.92   <+:> 18915.17  <+:> 59666.938 ) )-         <::> transpose ( (-3035.543 <::> 15831.447 <+:> 73256.625  <+:> 80709.38  <+:> 72695.04  )-                     <::> (50932.49  <::> 7865.496  <+:> -4050.5957 <+:> 99839.41  <+:> 10834.297 ) )-         <+:> transpose ( (21961.227 <::> 29640.914 <+:> 39657.19   <+:> 81469.64  <+:> 17815.506 )-                     <::> (-8484.239 <::> 16877.531 <+:> 65145.742  <+:> 80219.67  <+:> 81508.87  ) )-         <+:> transpose ( (53105.71  <::> 16255.646 <+:> 23324.957  <+:> -4438.164 <+:> 35369.824 )-                     <::> (67930.45  <::> 8950.834  <+:> 64451.71   <+:> 76685.57  <+:> 6728.465  ) )-        y :: DataFrame Double '[3,7]-        y = transpose $-               (70096.85  <::> 34332.492 <+:> 3642.8867 <+:> 25242.25  <+:> 59776.234 <+:> 12092.57 <+:> 10708.498)-          <::> (46447.965 <::> 37145.668 <+:> 56899.656 <+:> 85367.56  <+:> 15872.262 <+:> 87466.24 <+:> 82506.76 )-          <+:> (50458.848 <::> 31650.453 <+:> 71432.78  <+:> 53073.203 <+:> 59267.883 <+:> 82369.89 <+:> 78171.56 )-        z = ewgen x :: DataFrame Double '[2,5,4,3,7]-    print $ ewfoldl @_ @'[2] (+) 10 z-    print $ ewfoldr @_ @'[2,5] (+) 0 z + 10-    print $ ewfoldl (+) 10 z - ewfoldr @_ @'[2,5,4] (+) 0 z - 10+    let x :: DataFrame Double '[4,5,2]+        x =  DF4 (transpose $ DF2+                    (DF5  56707.4     73558.41    47950.074  83394.61    25611.629)+                    (DF5  53704.516  (-3277.478)  99479.92   18915.17    59666.938))+                 (transpose $ DF2+                    (DF5 (-3035.543)  15831.447   73256.625   80709.38   72695.04)+                    (DF5  50932.49    7865.496   (-4050.5957) 99839.41   10834.297))+                 (transpose $ DF2+                    (DF5  21961.227   29640.914   39657.19    81469.64   17815.506 )+                    (DF5 (-8484.239)  16877.531  65145.742    80219.67   81508.87  ))+                 (transpose $ DF2+                    (DF5  53105.71    16255.646   23324.957  (-4438.164) 35369.824 )+                    (DF5  67930.45    8950.834    64451.71    76685.57   6728.465  ))+        y :: DataFrame Double '[7,3]+        y = transpose $ DF3+          (DF7 70096.85  34332.492 3642.8867 25242.25  59776.234 12092.57 10708.498)+          (DF7 46447.965 37145.668 56899.656 85367.56  15872.262 87466.24 82506.76 )+          (DF7 50458.848 31650.453 71432.78  53073.203 59267.883 82369.89 78171.56 )+        z = ewgen x :: DataFrame Double '[7,3,4,5,2]+    print $ ewfoldl @_ @_ @'[2] (+) 10 z+    print $ ewfoldr @_ @_ @'[5,2] (+) 0 z + 10+    print $ ewfoldl (+) 10 z - ewfoldr @_ @_ @'[4,5,2] (+) 0 z - 10 -    -- We can map arbitrary prefix dimension over the dataframe,-    -- indexing by suffix dimensions.+    -- We can map arbitrary suffix dimension over the dataframe,+    -- indexing by prefix dimensions.     -- At the same time, we can transform underlying element type-    --  or prefix dimensionality.+    --  or suffix dimensionality.     -- For example, we can do tensor produt of every sub-tensor.     putStrLn "\nConversions between element types and frame sizes."-    print $ iwmap @Int @'[2,2] @'[7] @_-                  (\(Idx i:*U) v -> fromScalar . (scalar (fromIntegral i) +) . round+    print $ iwmap @Int @'[7] @'[2,2] @_+                  (\(i:*U) v -> fromScalar . (scalar (fromIntegral i) +) . round                                      $ vec3 0.02 (-0.01) 0.001 %* v                   ) y @@ -77,27 +80,27 @@     -- This means we can even do arbitrary IO for each subtensor     -- indexed by suffix dimensions.     putStrLn "\nWelement-wise IO!"-    rVec <- elementWise @Double @_ @'[4] @_+    rVec <- elementWise @Double @'[4] @_  @_               (\v -> print v >> return (sqrt . trace $ v %* transpose v)) x     putStrLn "\nTraces for each matrix element:"     print rVec      -- Updating existing frames     print $ update (2:*U) (scalar 777) rVec-    print $ update (2:*3:*U) (vec2 999 999) x+    print $ update (1:*3:*U) (vec2 999 555) x -    let matX = iwgen (scalar . fromEnum) :: DataFrame Int '[2,5,4]+    let matX = iwgen (scalar . fromEnum) :: DataFrame Int '[2,6,4]         matY = iwgen (scalar . fromEnum) :: DataFrame Int '[5,4]     putStrLn "Check carefully that this returns no garbage"     print matX-    print (ewmap (<+:> scalar 111) matX :: DataFrame Int '[3,5,4])+    print (ewmap @_ @'[2,6] (`snocDF` scalar 111) matX :: DataFrame Int '[2,6,5])     print matY-    print (ewmap fromScalar matY :: DataFrame Int '[3,5,4])+    print (ewmap fromScalar matY :: DataFrame Int '[5,4,3])      -- Working with mutable frames     print $ ST.runST $ do       sdf <- ST.thawDataFrame matY-      ST.writeDataFrame sdf (1:*1:*U) 900101-      ST.writeDataFrame sdf (3:*3:*U) 900303-      ST.writeDataFrame sdf (5:*3:*U) 900503+      ST.writeDataFrame sdf (0:*0:*U) 900101+      ST.writeDataFrame sdf (2:*2:*U) 900303+      ST.writeDataFrame sdf (4:*2:*U) 900503       ST.unsafeFreezeDataFrame sdf

@@ -5,58 +5,58 @@  module Main (main) where -import           Data.Maybe (fromMaybe)-import           Data.Time.Clock+import Data.Maybe      (fromMaybe)+import Data.Time.Clock -import           Numeric.DataFrame-import           Numeric.Dimensions+import Numeric.DataFrame+import Numeric.Dimensions  -type DList = [6,4,10,7,35,8,12] -- [6,26,8,10,35,8,12]+type DList = [6,14,10,7,2,8,5]  main :: IO () main = do     t0 <- getCurrentTime     putStrLn $ "\nStarting benchmarks, current time is " ++ show t0-    let df = iwgen @Float @'[] @DList (fromIntegral . fromEnum)+    let df = iwgen @Float @DList @'[] (fromIntegral . fromEnum)     t1 <- df `seq` getCurrentTime     seq t1 putStrLn $ "Created DataFrame, elapsed time is " ++ show (diffUTCTime t1 t0)      putStrLn "\nRunning a ewfoldl on scalar elements..."-    let rezEwf = ewfoldl @Float @'[] @DList (\a x -> return $! fromMaybe x a + fromMaybe 0 a / (x+1)) (Just 1)  df+    let rezEwf = ewfoldl @Float @DList @'[] (\a x -> return $! fromMaybe x a + fromMaybe 0 a / (x+1)) (Just 1)  df     t2 <- rezEwf `seq` getCurrentTime     seq t2 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t2 t1)     print rezEwf      putStrLn "\nRunning a iwfoldl on scalar elements (not using idx)..."-    let rezIwf = iwfoldl @Float @'[] @DList (\_ a x -> a +  a / (x+1)) 1 df+    let rezIwf = iwfoldl @Float  @DList @'[] (\_ a x -> a +  a / (x+1)) 1 df     t3 <- rezIwf `seq` getCurrentTime     seq t3 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t3 t2)     print rezIwf      putStrLn "\nRunning a iwfoldr on scalar elements (using fromEnum idx)..."-    let rezIwf2 = iwfoldr @Float @'[] @DList (\i x a -> return $! fromMaybe 0 a + x / ((1+) . fromIntegral $ fromEnum i)) (Just 0) df+    let rezIwf2 = iwfoldr @Float @DList @'[] (\i x a -> return $! fromMaybe 0 a + x / ((1+) . fromIntegral $ fromEnum i)) (Just 0) df     t4 <- rezIwf2 `seq` getCurrentTime     seq t4 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t4 t3)     print rezIwf2      putStrLn "\nRunning a iwfoldl on scalar elements (enforcing idx)..."-    let rezIwf3 = iwfoldl @Float @'[] @DList (\i a x -> i `seq` return $! fromMaybe 0 a + fromMaybe x a / (x+1)) (Just 1) df+    let rezIwf3 = iwfoldl @Float @DList @'[] (\i a x -> i `seq` return $! fromMaybe 0 a + fromMaybe x a / (x+1)) (Just 1) df     t5 <- rezIwf3 `seq` getCurrentTime     seq t5 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t5 t4)     print rezIwf3 -    putStrLn "\nRunning a ewfoldl on vector5 elements..."-    let rezEwv1 = ewfoldl @Float @'[Head DList] @(Tail DList)-                          (\a x -> return $! fromMaybe 2 a + fromMaybe 0 a / (1 + iwgen @_ @'[] (\(Idx i:*U) -> Idx (i+1) :* U !. x )) )-                          (Just (3 :: DataFrame Float '[5])) df+    putStrLn "\nRunning a ewfoldl on vector4 elements..."+    let rezEwv1 = ewfoldl @Float @(Init DList) @'[Last DList]+                          (\a x -> return $! fromMaybe 2 a + fromMaybe 0 a / (1 + iwgen @_ @_ @'[] (\(Idx i:*U) -> x ! Idx (i+1) :* U )) )+                          (Just (3 :: DataFrame Float '[4])) df     t6 <- rezEwv1 `seq` getCurrentTime     seq t6 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t6 t5)     print rezEwv1      putStrLn "\nRunning a ewfoldr on vector3 elements..."-    let rezEwv2 = ewfoldr @Float @'[Head DList] @(Tail DList)-                          (\x a -> return $! fromMaybe 2 a + fromMaybe 1 a / (1 + iwgen @_ @'[] (\(Idx i:*U) -> Idx (i+1):* U !. x )))+    let rezEwv2 = ewfoldr @Float @(Init DList) @'[Last DList]+                          (\x a -> return $! fromMaybe 2 a + fromMaybe 1 a / (1 + iwgen @_ @_ @'[] (\(Idx i:*U) -> x ! Idx (i+1):* U )))                           (Just (3 :: DataFrame Float '[3])) df     t7 <- rezEwv2 `seq` getCurrentTime     seq t7 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t7 t6)@@ -64,8 +64,8 @@      putStrLn "\nRunning a ewfoldr with matrix products..."     let rezEwm = ewfoldr @Float @(Take 3 DList) @(Drop 3 DList)-                          (\x a ->  a + x %* (1 <::> 0.5 <:> 0.1)  )-                          (1 :: DataFrame Float (Take 2 DList +: 3)) df+                          (\x a ->  a + x %* (DF5 1 0.5 0.1 0.01 0.001)  )+                          (1 :: DataFrame Float (Init (Drop 3 DList) +: 3)) df     t8 <- rezEwm `seq` getCurrentTime     seq t8 putStrLn $ "Done; elapsed time = " ++ show (diffUTCTime t8 t7)     print rezEwm@@ -74,4 +74,4 @@       putStrLn "Checking indexes"-    print $ 2:*1:*1:*3:*1:*U !. df+    print $ df ! (2:*1:*1:*3:*1:*U :: Idxs (Take 5 DList))

@@ -1,136 +1,139 @@-name: easytensor-version: 1.0.1.0-cabal-version: >=1.22-build-type: Simple-license: BSD3-license-file: LICENSE-copyright: (c) Artem Chirkin-maintainer: chirkin@arch.ethz.ch-homepage: https://github.com/achirkin/easytensor#readme-synopsis: Pure, type-indexed haskell vector, matrix, and tensor library.-description:-    Pure, type-indexed haskell vector, matrix, and tensor library.-    Features dimensionality type-checking for all operations.-    Generic n-dimensional versions are implemented using low-level prim ops.-    Allows ad-hoc replacement with fixed low-dimensionality vectors and matrices without changing user interface.-category: Math, Geometry-author: Artem Chirkin+cabal-version: 1.12 -source-repository head-    type: git-    location: https://github.com/achirkin/easytensor.git-    subdir: easytensor+-- This file has been generated from package.yaml by hpack version 0.31.1.+--+-- see: https://github.com/sol/hpack+--+-- hash: 295fd017e3f09157b9e9a28d1db9beb6ecb080f0612228ac49f18e78ee08d01b +name:           easytensor+version:        2.0.0.0+synopsis:       Pure, type-indexed haskell vector, matrix, and tensor library.+description:    Pure, type-indexed haskell vector, matrix, and tensor library. Features dimensionality type-checking for all operations. Generic n-dimensional versions are implemented using low-level prim ops. Allows ad-hoc replacement with fixed low-dimensionality vectors and matrices without changing user interface. Please see the README on GitHub at <https://github.com/achirkin/easytensor#readme>+category:       math, geometry+homepage:       https://github.com/achirkin/easytensor#readme+bug-reports:    https://github.com/achirkin/easytensor/issues+author:         Artem Chirkin+maintainer:     achirkin@users.noreply.github.com+copyright:      Copyright: (c) 2019 Artem Chirkin+license:        BSD3+license-file:   LICENSE+build-type:     Simple -flag unsafeindices-    description:-        Disable bound checks when accessing elements of a tensor, matrix, or vector.-    default: False+source-repository head+  type: git+  location: https://github.com/achirkin/easytensor+  subdir: easytensor +flag unsafeindices+  description: Disable bound checks when accessing elements of a tensor, matrix, or vector.+  manual: True+  default: False  library--    if flag(unsafeindices)-        cpp-options: -DUNSAFE_INDICES-    exposed-modules:-        Numeric.DataFrame-        Numeric.DataFrame.IO-        Numeric.DataFrame.ST-        Numeric.Matrix-        Numeric.Matrix.Class-        Numeric.Vector-        Numeric.Scalar-        Numeric.Quaternion-        Numeric.Semigroup-        Numeric.PrimBytes-        Numeric.DataFrame.Type-        Numeric.DataFrame.Family-        Numeric.DataFrame.Shape-        Numeric.DataFrame.SubSpace-        Numeric.DataFrame.Contraction-        Numeric.DataFrame.Internal.Mutable-        Numeric.DataFrame.Internal.Array-        Numeric.DataFrame.Internal.Array.Class-        Numeric.DataFrame.Internal.Array.Family-        Numeric.DataFrame.Internal.Array.Family.ArrayBase-        Numeric.DataFrame.Internal.Array.Family.ScalarBase-        Numeric.DataFrame.Internal.Array.Family.FloatX2-        Numeric.DataFrame.Internal.Array.Family.FloatX3-        Numeric.DataFrame.Internal.Array.Family.FloatX4-        Numeric.DataFrame.Internal.Array.Family.DoubleX2-        Numeric.DataFrame.Internal.Array.Family.DoubleX3-        Numeric.DataFrame.Internal.Array.Family.DoubleX4-        Numeric.DataFrame.Internal.Array.PrimOps-    build-depends:-        base >=4.10 && <5,-        dimensions >=1.0.0.0-    default-language: Haskell2010-    if impl(ghc >= 8.6)-        default-extensions: NoStarIsType-    hs-source-dirs: src-    other-modules:-        Numeric.Matrix.Mat44d-        Numeric.Matrix.Mat44f-        Numeric.Quaternion.Class-        Numeric.Quaternion.QDouble-        Numeric.Quaternion.QFloat-    ghc-options:-      -Wall-      -fwarn-tabs-      -fwarn-unused-do-bind-      -fwarn-monomorphism-restriction-+  exposed-modules:+      Numeric.DataFrame+      Numeric.DataFrame.Contraction+      Numeric.DataFrame.Internal.Backend+      Numeric.DataFrame.Internal.Mutable+      Numeric.DataFrame.Internal.PrimArray+      Numeric.DataFrame.IO+      Numeric.DataFrame.ST+      Numeric.DataFrame.SubSpace+      Numeric.DataFrame.Type+      Numeric.Matrix+      Numeric.PrimBytes+      Numeric.ProductOrd+      Numeric.ProductOrd.NonTransitive+      Numeric.ProductOrd.Partial+      Numeric.Quaternion+      Numeric.Scalar+      Numeric.Vector+  other-modules:+      Numeric.Matrix.Internal+      Numeric.Matrix.Internal.Mat44d+      Numeric.Matrix.Internal.Mat44f+      Numeric.Scalar.Internal+      Numeric.Vector.Internal+      Numeric.Quaternion.Internal+      Numeric.Quaternion.Internal.QDouble+      Numeric.Quaternion.Internal.QFloat+      Numeric.DataFrame.Internal.Backend.Family+      Numeric.DataFrame.Internal.Backend.Family.ArrayBase+      Numeric.DataFrame.Internal.Backend.Family.DoubleX2+      Numeric.DataFrame.Internal.Backend.Family.DoubleX3+      Numeric.DataFrame.Internal.Backend.Family.DoubleX4+      Numeric.DataFrame.Internal.Backend.Family.FloatX2+      Numeric.DataFrame.Internal.Backend.Family.FloatX3+      Numeric.DataFrame.Internal.Backend.Family.FloatX4+      Numeric.DataFrame.Internal.Backend.Family.ScalarBase+      Numeric.DataFrame.Internal.BackendI+  hs-source-dirs:+      src+      src-base+  ghc-options: -Wall -Wcompat -Wtabs -Wmonomorphism-restriction -Wmissing-local-signatures -Wmissing-home-modules -Widentities -Wredundant-constraints+  build-depends:+      base >=4.11 && <5+    , constraints-deriving >=1.0.4.0 && <2+    , dimensions >=2 && <3+  if flag(unsafeindices)+    cpp-options: -DUNSAFE_INDICES+  default-language: Haskell2010  test-suite et-test--    type: exitcode-stdio-1.0-    main-is: Spec.hs-    other-modules:-        Numeric.DataFrame.Arbitraries-        Numeric.DataFrame.SubSpaceTest-        Numeric.DataFrame.BasicTest-        Numeric.MatrixDoubleTest-        Numeric.MatrixFloatTest-        Numeric.QuaternionTest-    build-depends:-        base -any,-        Cabal -any,-        QuickCheck -any,-        easytensor -any,-        dimensions -any-    default-language: Haskell2010-    if impl(ghc >= 8.6)-        default-extensions: NoStarIsType, NoMonadFailDesugaring-    hs-source-dirs: test-    ghc-options: -Wall -fwarn-tabs -O2-+  type: exitcode-stdio-1.0+  main-is: Spec.hs+  other-modules:+      Numeric.DataFrame.Arbitraries+      Numeric.DataFrame.BasicTest+      Numeric.DataFrame.SubSpaceTest+      Numeric.MatrixDoubleTest+      Numeric.MatrixFloatTest+      Numeric.PrimBytesTest+      Numeric.QuaterDoubleTest+      Numeric.QuaterFloatTest+      Spec.Util+      Paths_easytensor+  hs-source-dirs:+      test+  ghc-options: -Wall -Wcompat -Wtabs -Wmonomorphism-restriction -Wmissing-local-signatures -Wmissing-home-modules -Widentities -Wredundant-constraints+  build-depends:+      Cabal+    , QuickCheck+    , base >=4.11 && <5+    , constraints-deriving >=1.0.4.0 && <2+    , dimensions >=2 && <3+    , easytensor+    , template-haskell+  default-language: Haskell2010  benchmark et-bench-misc--    type: exitcode-stdio-1.0-    main-is: misc.hs-    build-depends:-        base -any,-        easytensor -any,-        dimensions -any-    default-language: Haskell2010-    if impl(ghc >= 8.6)-        default-extensions: NoStarIsType, NoMonadFailDesugaring-    hs-source-dirs: bench-    ghc-options: -Wall -fwarn-tabs -O2-+  type: exitcode-stdio-1.0+  main-is: misc.hs+  other-modules:+      Paths_easytensor+  hs-source-dirs:+      bench+  ghc-options: -Wall -Wcompat -Wtabs -Wmonomorphism-restriction -Wmissing-local-signatures -Wmissing-home-modules -Widentities -Wredundant-constraints+  build-depends:+      base >=4.11 && <5+    , constraints-deriving >=1.0.4.0 && <2+    , dimensions >=2 && <3+    , easytensor+  default-language: Haskell2010  benchmark et-bench-spfolds--    type: exitcode-stdio-1.0-    main-is: subspacefolds.hs-    build-depends:-        base -any,-        easytensor -any,-        dimensions -any,-        time -any-    default-language: Haskell2010-    if impl(ghc >= 8.6)-        default-extensions: NoStarIsType, NoMonadFailDesugaring-    hs-source-dirs: bench-    ghc-options: -Wall -fwarn-tabs -O2+  type: exitcode-stdio-1.0+  main-is: subspacefolds.hs+  other-modules:+      Paths_easytensor+  hs-source-dirs:+      bench+  ghc-options: -Wall -Wcompat -Wtabs -Wmonomorphism-restriction -Wmissing-local-signatures -Wmissing-home-modules -Widentities -Wredundant-constraints+  build-depends:+      base >=4.11 && <5+    , constraints-deriving >=1.0.4.0 && <2+    , dimensions >=2 && <3+    , easytensor+    , time+  default-language: Haskell2010

@@ -0,0 +1,183 @@+{-# LANGUAGE CPP                    #-}+{-# LANGUAGE ConstraintKinds        #-}+{-# LANGUAGE DataKinds              #-}+{-# LANGUAGE FlexibleContexts       #-}+{-# LANGUAGE FlexibleInstances      #-}+{-# LANGUAGE GADTs                  #-}+{-# LANGUAGE MagicHash              #-}+{-# LANGUAGE MultiParamTypeClasses  #-}+{-# LANGUAGE PolyKinds              #-}+{-# LANGUAGE RankNTypes             #-}+{-# LANGUAGE RoleAnnotations        #-}+{-# LANGUAGE ScopedTypeVariables    #-}+{-# LANGUAGE TypeApplications       #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType             #-}+{-# LANGUAGE TypeOperators          #-}+-- Constraints @b ~ BackendFamily t ds@ is not redundant; they allows to avoid AllowAmbigousTypes.+{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}+{- |+This module is to be reimplemented multiple times based on a platform capabilities.+For example, I can add a SIMD implementation in a separate folder and use AVX+processsor extensions to make faster 4D vector operations.++Various implementations would be picked by activating corresponding cabal flags.++The following export list must be the same for every implementation+ -}+module Numeric.DataFrame.Internal.Backend.Family+  ( BackendFamily, KnownBackend ()+  , inferKnownBackend, inferPrimElem, inferPrimArray, inferBackendInstance+  ) where+++import Data.Constraint+import GHC.Base++import Numeric.DataFrame.Internal.Backend.Family.ArrayBase+import Numeric.DataFrame.Internal.Backend.Family.DoubleX2+import Numeric.DataFrame.Internal.Backend.Family.DoubleX3+import Numeric.DataFrame.Internal.Backend.Family.DoubleX4+import Numeric.DataFrame.Internal.Backend.Family.FloatX2+import Numeric.DataFrame.Internal.Backend.Family.FloatX3+import Numeric.DataFrame.Internal.Backend.Family.FloatX4+import Numeric.DataFrame.Internal.Backend.Family.ScalarBase+import Numeric.DataFrame.Internal.PrimArray+import Numeric.Dimensions+import Numeric.PrimBytes+++-- | This type family aggregates all types used for arrays with different+--   dimensioinality.+--   The family is injective; thus, it is possible to get type family instance+--   given the data constructor (and vice versa).+--   If GHC knows the dimensionality of a backend at compile time, it chooses+--   a more efficient specialized instance of @BackendFamily@, e.g. Scalar newtype wrapper.+--   Otherwise, it falls back to the generic ArrayBase implementation.+--+--   Data family would not work here, because it would give overlapping instances.+type family BackendFamily (t :: Type) (ds :: [Nat]) = (v :: Type) | v -> t ds where+    BackendFamily t      '[]    = ScalarBase t+    BackendFamily Float  '[2]   = FloatX2+    BackendFamily Float  '[3]   = FloatX3+    BackendFamily Float  '[4]   = FloatX4+    BackendFamily Double '[2]   = DoubleX2+    BackendFamily Double '[3]   = DoubleX3+    BackendFamily Double '[4]   = DoubleX4+    BackendFamily t       ds    = ArrayBase t ds++-- | Promise that we are sure the backend is ArrayBase.+unsafeDefault :: forall t ds . Dict (BackendFamily t ds ~ ArrayBase t ds)+unsafeDefault = unsafeCoerce# (Dict @(ArrayBase t ds ~ ArrayBase t ds))++-- | Singleton type used to determine the currently used DataFrame backend;+--   establishes a good bijection @b <~> t ds@ (better than just using @BackendFamily@ everywhere).+data BackendSing (t :: Type) (ds :: [Nat]) (backend :: Type) where+    BSC :: BackendSing t      '[]  (ScalarBase t)+    BF2 :: BackendSing Float  '[2]  FloatX2+    BF3 :: BackendSing Float  '[3]  FloatX3+    BF4 :: BackendSing Float  '[4]  FloatX4+    BD2 :: BackendSing Double '[2]  DoubleX2+    BD3 :: BackendSing Double '[3]  DoubleX3+    BD4 :: BackendSing Double '[4]  DoubleX4+    BPB :: ( PrimBytes t, BackendFamily t ds ~ ArrayBase t ds )+        => BackendSing t ds (ArrayBase t ds)++-- | A framework for using DataFrame type family instances.+class KnownBackend (t :: Type) (ds :: [Nat]) (backend :: Type) where+    -- | Get DataFrame backend type family instance+    bSing :: BackendSing t ds backend++-- When compiled for haddock, some of the modules complain about missing KnownBackend+-- instance. To workaround this, I add an instance stub.+--+-- Also note, these may be related issues:+--+-- https://github.com/haskell/haddock/issues/680+-- https://github.com/haskell/cabal/issues/4513+--+#if defined(__HADDOCK__) || defined(__HADDOCK_VERSION__)+instance KnownBackend t ds b where bSing = undefined+#else+instance KnownBackend t      '[]  (ScalarBase t)   where bSing = BSC+instance KnownBackend Float  '[2]  FloatX2         where bSing = BF2+instance KnownBackend Float  '[3]  FloatX3         where bSing = BF3+instance KnownBackend Float  '[4]  FloatX4         where bSing = BF4+instance KnownBackend Double '[2]  DoubleX2        where bSing = BD2+instance KnownBackend Double '[3]  DoubleX3        where bSing = BD3+instance KnownBackend Double '[4]  DoubleX4        where bSing = BD4+instance PrimBytes t+      => KnownBackend t       ds  (ArrayBase t ds) where+    bSing = case unsafeDefault @t @ds of Dict -> BPB+#endif++-- | Find an instance of `KnownBackend` class using `PrimBytes` and `Dimensions`.+inferKnownBackend :: forall t ds b+                  . (PrimBytes t, Dimensions ds, b ~ BackendFamily t ds)+                  => Dict (KnownBackend t ds b)+inferKnownBackend = case (dims @ds, primTag @t undefined) of+  (U, _) -> Dict+  (d :* U, PTagFloat)+      | Just Dict <- sameDim (D @2) d -> Dict+      | Just Dict <- sameDim (D @3) d -> Dict+      | Just Dict <- sameDim (D @4) d -> Dict+  (d :* U, PTagDouble)+      | Just Dict <- sameDim (D @2) d -> Dict+      | Just Dict <- sameDim (D @3) d -> Dict+      | Just Dict <- sameDim (D @4) d -> Dict+  _ -> case unsafeDefault @t @ds of Dict -> Dict+{-# INLINE inferKnownBackend #-}+++-- This function determines the logic of instance selection+-- for the type family+inferBackendInstance+  :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (c :: Type -> Constraint)+   . ( KnownBackend t ds b+     , c (ScalarBase t)+     , c FloatX2,  c FloatX3,  c FloatX4+     , c DoubleX2, c DoubleX3, c DoubleX4+     , c (ArrayBase t ds)+     , b ~ BackendFamily t ds+     )+  => Dict (c b)+inferBackendInstance = case bSing @t @ds @b of+    BSC -> Dict+    BF2 -> Dict+    BF3 -> Dict+    BF4 -> Dict+    BD2 -> Dict+    BD3 -> Dict+    BD4 -> Dict+    BPB -> Dict+{-# INLINE inferBackendInstance #-}++inferPrimElem :: forall (t :: Type) (d :: Nat) (ds :: [Nat]) (b :: Type)+               . ( KnownBackend t (d ': ds) b+                 , b ~ BackendFamily t (d ': ds)+                 )+              => b -> Dict (PrimBytes t)+inferPrimElem _ = case bSing @t @(d ': ds) @b of+    BF2 -> Dict+    BF3 -> Dict+    BF4 -> Dict+    BD2 -> Dict+    BD3 -> Dict+    BD4 -> Dict+    BPB -> Dict++-- Need a separate function for this one due to a functional dependency+inferPrimArray+  :: forall (t :: Type) (ds :: [Nat]) (b :: Type)+   . (PrimBytes t, KnownBackend t ds b, b ~ BackendFamily t ds)+  => Dict (PrimArray t b)+inferPrimArray = case bSing @t @ds @b of+    BSC -> Dict+    BF2 -> Dict+    BF3 -> Dict+    BF4 -> Dict+    BD2 -> Dict+    BD3 -> Dict+    BD4 -> Dict+    BPB -> Dict+{-# INLINE inferPrimArray #-}

@@ -0,0 +1,28 @@+{-# LANGUAGE CPP                    #-}+{-# LANGUAGE DataKinds              #-}+{-# LANGUAGE FlexibleInstances      #-}+{-# LANGUAGE MultiParamTypeClasses  #-}+{-# LANGUAGE TypeFamilyDependencies #-}++module Numeric.DataFrame.Internal.Backend.Family+  ( BackendFamily, KnownBackend ()+  ) where++import Data.Kind    (Type)+import GHC.TypeLits (Nat)+++type family BackendFamily (t :: Type) (ds :: [Nat]) = (v :: Type) | v -> t ds where ..+class KnownBackend (t :: Type) (ds :: [Nat]) (backend :: Type)++-- When compiled for haddock, some of the modules complain about missing KnownBackend+-- instance. To workaround this, I add an instance stub.+--+-- Also note, these may be related issues:+--+-- https://github.com/haskell/haddock/issues/680+-- https://github.com/haskell/cabal/issues/4513+--+#if defined(__HADDOCK__) || defined(__HADDOCK_VERSION__)+instance KnownBackend t ds b+#endif

@@ -0,0 +1,587 @@+{-# LANGUAGE ConstraintKinds           #-}+{-# LANGUAGE DataKinds                 #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE FlexibleContexts          #-}+{-# LANGUAGE FlexibleInstances         #-}+{-# LANGUAGE GADTs                     #-}+{-# LANGUAGE MagicHash                 #-}+{-# LANGUAGE MultiParamTypeClasses     #-}+{-# LANGUAGE PolyKinds                 #-}+{-# LANGUAGE RankNTypes                #-}+{-# LANGUAGE ScopedTypeVariables       #-}+{-# LANGUAGE TypeApplications          #-}+{-# LANGUAGE TypeFamilyDependencies    #-}+{-# LANGUAGE TypeInType                #-}+{-# LANGUAGE TypeOperators             #-}+{-# LANGUAGE UnboxedSums               #-}+{-# LANGUAGE UnboxedTuples             #-}++module Numeric.DataFrame.Internal.Backend.Family.ArrayBase+  ( ArrayBase (..)+  ) where++import           Data.Coerce+import           Data.Int+import           Data.Word+import           GHC.Base                             hiding (foldr)+import           Numeric.DataFrame.Internal.PrimArray+import           Numeric.Dimensions+import           Numeric.PrimBytes+import           Numeric.ProductOrd+import qualified Numeric.ProductOrd.NonTransitive     as NonTransitive+import qualified Numeric.ProductOrd.Partial           as Partial++-- | Generic Array implementation.+--   This array can reside in plain `ByteArray#` and can share the @ByteArray#@+--   with other arrays.+--   However, byte offset in the @ByteArray#@ must be multiple of the element size.+data ArrayBase (t :: Type) (ds :: [Nat])+  = ArrayBase+    (# t --  Same value for each element;+         --  this is the cheapest way to initialize an array.+         --  It is also used for Num instances to avoid dependency on Dimensions.+     | (# Int#  -- Offset in Content array (measured in elements)+        , ByteArray# -- Content;+                     -- elements are stored row-by-row, plane-by-plane;+                     -- (C-style, rather than Fortran-style);+                     -- similar to C, OpenCV, etc.+                     -- The data must be contiguous!+                     -- (i.e. stride must be the same size as the element size).+        , CumulDims  -- Steps array; [Word]+                     -- similar to steps in OpenCV::Mat, but counted in elements+                     --        rather than in bytes.+                     -- e.g. 0th element is the size of the content in elements+                     --      (data must be contiguous)+                     --      1th element is the size of subspace data minus outer dim.+        , Dict (PrimBytes t)+        #)+     #)+++instance (PrimBytes t, Dimensions ds) => PrimBytes (ArrayBase t ds) where+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word64 ds) #-}++    getBytes (ArrayBase a ) = case a of+        (# t | #)+          | W# nw <- totalDim' @ds+          , n <- word2Int# nw+          , tbs <- byteSize t -> go tbs (tbs *# n) t+        (# | (# _, arr, _, _ #) #) ->+          -- very weird trick with touch# allows to workaround GHC bug+          --  "internal error: ARR_WORDS object entered!"+          -- TODO: report this+          case runRW# (\s -> (# touch# arr s, arr #)) of (# _, ba #) -> ba+      where+        go :: Int# -> Int# -> t -> ByteArray#+        go tbs bsize t = case runRW#+         ( \s0 -> case newByteArray# bsize s0 of+             (# s1, mba #) -> unsafeFreezeByteArray# mba+               ( loop# 0# tbs bsize (\i -> writeBytes mba i t) s1 )+         ) of (# _, ba #) -> ba+        {-# NOINLINE go #-}+    {-# INLINE getBytes #-}++    getBytesPinned (ArrayBase a) = case a of+        (# t | #)+          | W# nw <- totalDim' @ds+          , n <- word2Int# nw+          , tbs <- byteSize t -> go tbs (tbs *# n) t+        (# | (# off, arr, steps, _ #) #) ->+          if isTrue# (isByteArrayPinned# arr)+          then case runRW# (\s -> (# touch# arr s, arr #)) of (# _, ba #) -> ba+          else case runRW#+           ( \s0 -> case (# cdTotalDim# steps+                          , byteSize @t undefined+                          , byteAlign @t undefined+                          #) of+               (# n, tbs, tba #)+                 | bsize <- tbs *# n+                 , (# s1, mba #) <- newAlignedPinnedByteArray# bsize tba s0+                 , s2 <- copyByteArray# arr off mba 0# bsize s1+                   -> unsafeFreezeByteArray# mba s2+           ) of (# _, ba #) -> ba+      where+        go :: Int# -> Int# -> t -> ByteArray#+        go tbs bsize t = case runRW#+         ( \s0 -> case newAlignedPinnedByteArray# bsize (byteAlign t) s0 of+             (# s1, mba #) -> unsafeFreezeByteArray# mba+               ( loop# 0# tbs bsize (\i -> writeBytes mba i t) s1 )+         ) of (# _, ba #) -> ba+        {-# NOINLINE go #-}+    {-# INLINE getBytesPinned #-}+++    fromBytes bOff ba+      | tbs <- byteSize (undefined :: t)+      , (# offN, offRem #) <- quotRemInt# bOff tbs+      = case offRem of+          0# -> ArrayBase (# | (#  offN, ba, steps, Dict #) #)+          _  -> case cdTotalDim# steps of n -> go (tbs *# n)+      where+        steps = cumulDims $ dims @ds+        go bsize = case runRW#+         ( \s0 -> case ( if isTrue# (isByteArrayPinned# ba)+                         then newAlignedPinnedByteArray# bsize+                                (byteAlign @t undefined)+                         else newByteArray# bsize+                       ) s0+                  of+            (# s1, mba #) -> unsafeFreezeByteArray# mba+                              (copyByteArray# ba bOff mba 0# bsize s1)+         ) of (# _, r #) -> ArrayBase (# | (# 0#, r, steps, Dict #) #)+        {-# NOINLINE go #-}+    {-# INLINE fromBytes #-}++    readBytes mba bOff s0+      | steps <- cumulDims $ dims @ds+      , n <- cdTotalDim# steps+      , tbs <- byteSize (undefined :: t)+      , bsize <- tbs *# n+      = case newByteArray# bsize s0 of+         (# s1, mba1 #) -> case unsafeFreezeByteArray# mba1+                                (copyMutableByteArray# mba bOff mba1 0# bsize s1) of+           (# s2, ba #) -> (# s2, ArrayBase (# | (# 0#, ba, steps, Dict #) #) #)+    {-# INLINE readBytes #-}++    writeBytes mba bOff (ArrayBase c)+      | tbs <- byteSize (undefined :: t) = case c of+        (# t | #) | W# n <- totalDim' @ds ->+          loop# bOff tbs (bOff +# word2Int# n *# tbs) (\i -> writeBytes mba i t)+        (# | (# offContent, arrContent, steps, _ #) #)+           | n <- cdTotalDim# steps->+          copyByteArray# arrContent (offContent *# tbs) mba bOff (n *# tbs)+    {-# INLINE writeBytes #-}++    readAddr addr s0+      | steps <- cumulDims $ dims @ds+      , n <- cdTotalDim# steps+      , tbs <- byteSize (undefined :: t)+      , bsize <- tbs *# n+      = case newByteArray# bsize s0 of+         (# s1, mba1 #) -> case unsafeFreezeByteArray# mba1+                                (copyAddrToByteArray# addr mba1 0# bsize s1) of+           (# s2, ba #) -> (# s2, ArrayBase (# | (# 0# , ba, steps, Dict #) #) #)+    {-# INLINE readAddr #-}++    writeAddr (ArrayBase c) addr+      | tbs <- byteSize (undefined :: t) = case c of+        (# t | #) | W# n <- totalDim' @ds ->+          loop# 0# tbs (word2Int# n *# tbs) (\i -> writeAddr t (plusAddr# addr i))+        (# | (# offContent, arrContent, steps, _ #) #)+           | n <- cdTotalDim# steps ->+          copyByteArrayToAddr# arrContent (offContent *# tbs) addr (n *# tbs)+    {-# INLINE writeAddr #-}+++    byteSize  _ = case totalDim' @ds of -- WARNING: slow!+      W# n -> byteSize (undefined :: t) *# word2Int# n+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign (undefined :: t)+    {-# INLINE byteAlign #-}++    byteOffset (ArrayBase a) = case a of+      (# _ | #)                  -> 0#+      (# | (# off, _, _, _ #) #) -> off *# byteSize (undefined :: t)+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | steps <- cumulDims $ dims @ds+      , n <- cdTotalDim# steps+      = ArrayBase (# | (# off *# n, ba, steps, Dict #) #)+    {-# INLINE indexArray #-}++++-- | Accumulates only idempotent operations!+--   Being applied to FromScalars, executes only once!+--   Here, idempotance means: assuming @f a b = g x@, @g (g x) = g x@+--+--   Also, I assume the sizes of arrays are the same.+--+--   Inside, this function uses foldr; thus, if the combining function is+--   lazy in the second argument, it may avoid some unnecessary work.+accumV2Idempotent :: a+                  -> (t -> t -> a)+                  -> (a -> a -> a)+                  -> ArrayBase t ds -> ArrayBase t ds -> a+accumV2Idempotent x f comb+  (ArrayBase (# a | #))+  (ArrayBase (# b | #))+    = comb x (f a b)+accumV2Idempotent x f comb+  a@(ArrayBase (# | (# _, _, steps, Dict #) #))+  b@(ArrayBase (# | _ #))+    = foldr (comb . (\i -> f (ixOff i a) (ixOff i b))) x+                          [0 .. fromIntegral (cdTotalDim steps) - 1]+accumV2Idempotent x f comb+    (ArrayBase (# a | #))+  b@(ArrayBase (# | (# _, _, steps, Dict #) #))+    = foldr (comb . (\i -> f a (ixOff i b))) x+                          [0 .. fromIntegral (cdTotalDim steps) - 1]+accumV2Idempotent x f comb+  a@(ArrayBase (# | (# _, _, steps, Dict #) #))+    (ArrayBase (# b | #))+    = foldr (comb . (\i -> f (ixOff i a) b)) x+                          [0 .. fromIntegral (cdTotalDim steps) - 1]+{-# INLINE accumV2Idempotent #-}+++mapV :: (t -> t) -> ArrayBase t ds -> ArrayBase t ds+mapV f (ArrayBase (# t | #))+    = ArrayBase (# f t | #)+mapV f x@(ArrayBase (# | (# offN, ba, steps, Dict #) #))+    | tbs <- byteSize (undefEl x)+    , n <- cdTotalDim# steps+    = case runRW#+     ( \s0 -> case newByteArray# (tbs *# n) s0 of+         (# s1, mba #) -> unsafeFreezeByteArray# mba+           ( loop1# n+               (\i -> writeArray mba i (f (indexArray ba (offN +# i)))) s1+           )+     ) of (# _, r #) -> ArrayBase (# | (# 0#, r, steps, Dict #) #)+{-# INLINE mapV #-}+++zipV :: (t -> t -> t)+     -> ArrayBase t ds -> ArrayBase t ds -> ArrayBase t ds+zipV f (ArrayBase (# x | #)) b = mapV (f x) b+zipV f a (ArrayBase (# y | #)) = mapV (`f` y) a+zipV f a@(ArrayBase (# | (# oa, ba, steps, Dict #) #))+         (ArrayBase (# | (# ob, bb, _, _ #) #))+    | n <- cdTotalDim# steps+    = case runRW#+     ( \s0 -> case newByteArray# (byteSize (undefEl a) *# n) s0 of+         (# s1, mba #) -> unsafeFreezeByteArray# mba+           ( loop1# n+               (\i -> writeArray mba i+                        (f (indexArray ba (oa +# i))+                           (indexArray bb (ob +# i))+                        )+               ) s1+           )+     ) of (# _, r #) -> ArrayBase (# | (# 0#, r, steps, Dict #) #)+{-# INLINE zipV #-}+++-- TODO: to improve performance, I can either compare bytearrays using memcmp+--       or implement early termination if the first elements do not match.+--       On the other hand, hopefully @(&&)@ and @(||)@ ops take care of that.+instance Eq t => Eq (ArrayBase t ds) where+    {-# SPECIALIZE instance Eq (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Eq (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance Eq (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance Eq (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance Eq (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance Eq (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance Eq (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance Eq (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance Eq (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance Eq (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance Eq (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance Eq (ArrayBase Word64 ds) #-}+    (==) = accumV2Idempotent True (==) (&&)+    (/=) = accumV2Idempotent False (/=) (||)++instance Ord t => ProductOrder (ArrayBase t ds) where+    {-# SPECIALIZE instance ProductOrder (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance ProductOrder (ArrayBase Word64 ds) #-}+    cmp = accumV2Idempotent PEQ (\x y -> fromOrdering (compare x y)) (<>)+    {-# INLINE cmp #-}++instance Ord t => Ord (NonTransitive.ProductOrd (ArrayBase t ds)) where+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Float ds))  #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Double ds)) #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Int ds))    #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Word ds))   #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Int8 ds))   #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Int16 ds))  #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Int32 ds))  #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Int64 ds))  #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Word8 ds))  #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Word16 ds)) #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Word32 ds)) #-}+    {-# SPECIALIZE instance Ord (NonTransitive.ProductOrd (ArrayBase Word64 ds)) #-}+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) = coerce (accumV2Idempotent True (>=) (&&))+    {-# INLINE (>=) #-}+    (<=) = coerce (accumV2Idempotent True (<=) (&&))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min = coerce (zipV min)+    {-# INLINE min #-}+    max = coerce (zipV max)+    {-# INLINE max #-}++instance Ord t => Ord (Partial.ProductOrd (ArrayBase t ds)) where+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Float ds))  #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Double ds)) #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Int ds))    #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Word ds))   #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Int8 ds))   #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Int16 ds))  #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Int32 ds))  #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Int64 ds))  #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Word8 ds))  #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Word16 ds)) #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Word32 ds)) #-}+    {-# SPECIALIZE instance Ord (Partial.ProductOrd (ArrayBase Word64 ds)) #-}+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) = coerce (accumV2Idempotent True (>=) (&&))+    {-# INLINE (>=) #-}+    (<=) = coerce (accumV2Idempotent True (<=) (&&))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min = coerce (zipV min)+    {-# INLINE min #-}+    max = coerce (zipV max)+    {-# INLINE max #-}++-- | Lexicographical ordering+instance Ord t => Ord (ArrayBase t ds) where+    {-# SPECIALIZE instance Ord (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Ord (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance Ord (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance Ord (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance Ord (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance Ord (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance Ord (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance Ord (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance Ord (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance Ord (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance Ord (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance Ord (ArrayBase Word64 ds) #-}+    compare = accumV2Idempotent EQ compare (<>)+    {-# INLINE compare #-}++instance Bounded t => Bounded (ArrayBase t ds) where+    {-# SPECIALIZE instance Bounded (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance Bounded (ArrayBase Word64 ds) #-}+    maxBound = ArrayBase (# maxBound | #)+    minBound = ArrayBase (# minBound | #)++instance Num t => Num (ArrayBase t ds)  where+    {-# SPECIALIZE instance Num (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Num (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance Num (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance Num (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance Num (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance Num (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance Num (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance Num (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance Num (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance Num (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance Num (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance Num (ArrayBase Word64 ds) #-}+    (+) = zipV (+)+    {-# INLINE (+) #-}+    (-) = zipV (-)+    {-# INLINE (-) #-}+    (*) = zipV (*)+    {-# INLINE (*) #-}+    negate = mapV negate+    {-# INLINE negate #-}+    abs = mapV abs+    {-# INLINE abs #-}+    signum = mapV signum+    {-# INLINE signum #-}+    fromInteger i = ArrayBase (# fromInteger i | #)+    {-# INLINE fromInteger #-}++instance Fractional t => Fractional (ArrayBase t ds)  where+    {-# SPECIALIZE instance Fractional (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Fractional (ArrayBase Double ds) #-}+    (/) = zipV (/)+    {-# INLINE (/) #-}+    recip = mapV recip+    {-# INLINE recip #-}+    fromRational r = ArrayBase (# fromRational r | #)+    {-# INLINE fromRational #-}+++instance Floating t => Floating (ArrayBase t ds) where+    {-# SPECIALIZE instance Floating (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance Floating (ArrayBase Double ds) #-}+    pi = ArrayBase (# pi | #)+    {-# INLINE pi #-}+    exp = mapV exp+    {-# INLINE exp #-}+    log = mapV log+    {-# INLINE log #-}+    sqrt = mapV sqrt+    {-# INLINE sqrt #-}+    sin = mapV sin+    {-# INLINE sin #-}+    cos = mapV cos+    {-# INLINE cos #-}+    tan = mapV tan+    {-# INLINE tan #-}+    asin = mapV asin+    {-# INLINE asin #-}+    acos = mapV acos+    {-# INLINE acos #-}+    atan = mapV atan+    {-# INLINE atan #-}+    sinh = mapV sinh+    {-# INLINE sinh #-}+    cosh = mapV cosh+    {-# INLINE cosh #-}+    tanh = mapV tanh+    {-# INLINE tanh #-}+    (**) = zipV (**)+    {-# INLINE (**) #-}+    logBase = zipV logBase+    {-# INLINE logBase #-}+    asinh = mapV asinh+    {-# INLINE asinh #-}+    acosh = mapV acosh+    {-# INLINE acosh #-}+    atanh = mapV atanh+    {-# INLINE atanh #-}++instance PrimBytes t => PrimArray t (ArrayBase t ds) where+    {-# SPECIALIZE instance PrimArray Float  (ArrayBase Float ds)  #-}+    {-# SPECIALIZE instance PrimArray Double (ArrayBase Double ds) #-}+    {-# SPECIALIZE instance PrimArray Int    (ArrayBase Int ds)    #-}+    {-# SPECIALIZE instance PrimArray Word   (ArrayBase Word ds)   #-}+    {-# SPECIALIZE instance PrimArray Int8   (ArrayBase Int8 ds)   #-}+    {-# SPECIALIZE instance PrimArray Int16  (ArrayBase Int16 ds)  #-}+    {-# SPECIALIZE instance PrimArray Int32  (ArrayBase Int32 ds)  #-}+    {-# SPECIALIZE instance PrimArray Int64  (ArrayBase Int64 ds)  #-}+    {-# SPECIALIZE instance PrimArray Word8  (ArrayBase Word8 ds)  #-}+    {-# SPECIALIZE instance PrimArray Word16 (ArrayBase Word16 ds) #-}+    {-# SPECIALIZE instance PrimArray Word32 (ArrayBase Word32 ds) #-}+    {-# SPECIALIZE instance PrimArray Word64 (ArrayBase Word64 ds) #-}++    broadcast t = ArrayBase (# t | #)+    {-# INLINE broadcast #-}++    ix# i (ArrayBase a) = case a of+      (# t | #)                    -> t+      (# | (# off, arr, _, _ #) #) -> indexArray arr (off +# i)+    {-# INLINE ix# #-}++    gen# steps f z0 = go (byteSize @t undefined *# n)+      where+        n = cdTotalDim# steps+        go bsize = case runRW#+         ( \s0 -> case newByteArray# bsize s0 of+             (# s1, mba #) -> case loop0 mba 0# z0 s1 of+               (# s2, z1 #) -> case unsafeFreezeByteArray# mba s2 of+                 (# s3, ba #) -> (# s3, (# z1, ba #) #)+         ) of (# _, (# z1, ba #) #)+                   -> (# z1, ArrayBase (# | (# 0# , ba, steps, Dict #) #) #)+        {-# NOINLINE go #-}+        loop0 mba i z s+          | isTrue# (i ==# n) = (# s, z #)+          | otherwise = case f z of+              (# z', x #) -> loop0 mba (i +# 1#) z' (writeArray mba i x s)+    {-# INLINE gen# #-}++    upd# steps i x (ArrayBase (# a | #)) = go (byteSize x)+      where+        n = cdTotalDim# steps+        go tbs = case runRW#+         ( \s0 -> case newByteArray# (tbs *# n) s0 of+             (# s1, mba #) -> unsafeFreezeByteArray# mba+               (writeArray mba i x+                 (loop1# n (\j -> writeArray mba j a) s1)+               )+         ) of (# _, r #) -> ArrayBase (# |  (# 0# , r, steps, Dict #) #)+        {-# NOINLINE go #-}+    upd# _ i x (ArrayBase (# | (# offN, ba, steps, Dict #) #))+        = go (byteSize x)+      where+        n = cdTotalDim# steps+        go tbs = case runRW#+         ( \s0 -> case newByteArray# (tbs *# n) s0 of+             (# s1, mba #) -> unsafeFreezeByteArray# mba+               (writeArray mba i x+                 (copyByteArray# ba (offN *# tbs) mba 0# (tbs *# n) s1)+               )+         ) of (# _, r #) -> ArrayBase (# | (# 0#, r, steps, Dict #) #)+        {-# NOINLINE go #-}+    {-# INLINE upd# #-}++    arrayContent# (ArrayBase a) = case a of+      (# x | #)                     -> (# x | #)+      (# | (# off, arr, cd, _ #) #) -> (# | (# cd, off, arr #) #)+    {-# INLINE arrayContent# #-}++    offsetElems (ArrayBase a) = case a of+      (# _ | #)                  -> 0#+      (# | (# off, _, _, _ #) #) -> off+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims (ArrayBase a) = case a of+      (# t | #)                    -> Left t+      (# | (# _, _, steps, _ #) #) -> Right steps+    {-# INLINE uniqueOrCumulDims #-}++    fromElems steps off ba = ArrayBase (# | (# off, ba, steps, Dict #) #)+    {-# INLINE fromElems #-}+++loop# :: Int# -- ^ initial value+      -> Int# -- ^ step+      -> Int# -- ^ final value (LESS THAN condition)+      -> (Int# -> State# s -> State# s) -> State# s -> State# s+loop# n0 di n1 f = loop0 n0+  where+    loop0 i s | isTrue# (i >=# n1) = s+              | otherwise = loop0 (i +# di) (f i s)+{-# INLINE loop# #-}+++-- | Do something in a loop for int i from 0 to (n-1)+loop1# :: Int# -> (Int# -> State# s -> State# s) -> State# s -> State# s+loop1# n f = loop0 0#+  where+    loop0 i s | isTrue# (i ==# n) = s+              | otherwise = loop0 (i +# 1#) (f i s)+{-# INLINE loop1# #-}++undefEl :: ArrayBase t ds -> t+undefEl = const undefined

@@ -0,0 +1,401 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# LANGUAGE UnboxedTuples         #-}+{-# LANGUAGE UndecidableInstances  #-}+module Numeric.DataFrame.Internal.Backend.Family.DoubleX2 (DoubleX2 (..)) 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 DoubleX2 = DoubleX2# Double# Double#++-- | 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 Double => Bounded DoubleX2 where+    maxBound = case maxBound of D# x -> DoubleX2# x x+    minBound = case minBound of D# x -> DoubleX2# x x+++instance Eq DoubleX2 where++    DoubleX2# a1 a2 == DoubleX2# b1 b2 =+      isTrue#+      (       (a1 ==## b1)+      `andI#` (a2 ==## b2)+      )+    {-# INLINE (==) #-}++    DoubleX2# a1 a2 /= DoubleX2# b1 b2 =+      isTrue#+      (      (a1 /=## b1)+      `orI#` (a2 /=## b2)+      )+    {-# INLINE (/=) #-}++++cmp' :: Double# -> Double# -> PartialOrdering+cmp' a b+  | isTrue# (a >## b) = PGT+  | isTrue# (a <## b) = PLT+  | otherwise  = PEQ++instance ProductOrder DoubleX2 where+    cmp (DoubleX2# a1 a2) (DoubleX2# b1 b2)+      = cmp' a1 b1 <> cmp' a2 b2+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd DoubleX2) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (DoubleX2# a1 a2))+         (NonTransitive.ProductOrd (DoubleX2# b1 b2)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (DoubleX2# a1 a2))+         (NonTransitive.ProductOrd (DoubleX2# b1 b2)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (DoubleX2# a1 a2))+        (NonTransitive.ProductOrd (DoubleX2# b1 b2))+      = NonTransitive.ProductOrd+        ( DoubleX2#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (DoubleX2# a1 a2))+        (NonTransitive.ProductOrd (DoubleX2# b1 b2))+      = NonTransitive.ProductOrd+        ( DoubleX2#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd DoubleX2) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (DoubleX2# a1 a2))+         (Partial.ProductOrd (DoubleX2# b1 b2)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (DoubleX2# a1 a2))+         (Partial.ProductOrd (DoubleX2# b1 b2)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (DoubleX2# a1 a2))+        (Partial.ProductOrd (DoubleX2# b1 b2))+      = Partial.ProductOrd+        ( DoubleX2#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (DoubleX2# a1 a2))+        (Partial.ProductOrd (DoubleX2# b1 b2))+      = Partial.ProductOrd+        ( DoubleX2#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+        )+    {-# INLINE max #-}++instance Ord DoubleX2 where+    DoubleX2# a1 a2 > DoubleX2# b1 b2+      | isTrue# (a1 >## b1) = True+      | isTrue# (a1 <## b1) = False+      | isTrue# (a2 >## b2) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    DoubleX2# a1 a2 < DoubleX2# b1 b2+      | isTrue# (a1 <## b1) = True+      | isTrue# (a1 >## b1) = False+      | isTrue# (a2 <## b2) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    DoubleX2# a1 a2 >= DoubleX2# b1 b2+      | isTrue# (a1 <## b1) = False+      | isTrue# (a1 >## b1) = True+      | isTrue# (a2 <## b2) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    DoubleX2# a1 a2 <= DoubleX2# b1 b2+      | isTrue# (a1 >## b1) = False+      | isTrue# (a1 <## b1) = True+      | isTrue# (a2 >## b2) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (DoubleX2# a1 a2) (DoubleX2# b1 b2)+      | isTrue# (a1 >## b1) = GT+      | isTrue# (a1 <## b1) = LT+      | isTrue# (a2 >## b2) = GT+      | isTrue# (a2 <## b2) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}++++-- | element-wise operations for vectors+instance Num DoubleX2 where++    DoubleX2# a1 a2 + DoubleX2# b1 b2+      = DoubleX2# ((+##) a1 b1) ((+##) a2 b2)+    {-# INLINE (+) #-}++    DoubleX2# a1 a2 - DoubleX2# b1 b2+      = DoubleX2# ((-##) a1 b1) ((-##) a2 b2)+    {-# INLINE (-) #-}++    DoubleX2# a1 a2 * DoubleX2# b1 b2+      = DoubleX2# ((*##) a1 b1) ((*##) a2 b2)+    {-# INLINE (*) #-}++    negate (DoubleX2# a1 a2) = DoubleX2#+      (negateDouble# a1) (negateDouble# a2)+    {-# INLINE negate #-}++    abs (DoubleX2# a1 a2)+      = DoubleX2#+      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)+      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)+    {-# INLINE abs #-}++    signum (DoubleX2# a1 a2)+      = DoubleX2# (if isTrue# (a1 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a2 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of D# x -> DoubleX2# x x+    {-# INLINE fromInteger #-}++++instance Fractional DoubleX2 where++    DoubleX2# a1 a2 / DoubleX2# b1 b2 = DoubleX2#+      ((/##) a1 b1) ((/##) a2 b2)+    {-# INLINE (/) #-}++    recip (DoubleX2# a1 a2) = DoubleX2#+      ((/##) 1.0## a1) ((/##) 1.0## a2)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of D# x -> DoubleX2# x x+    {-# INLINE fromRational #-}++++instance Floating DoubleX2 where++    pi = DoubleX2#+      3.141592653589793238##+      3.141592653589793238##+    {-# INLINE pi #-}++    exp (DoubleX2# a1 a2) = DoubleX2#+      (expDouble# a1) (expDouble# a2)+    {-# INLINE exp #-}++    log (DoubleX2# a1 a2) = DoubleX2#+      (logDouble# a1) (logDouble# a2)+    {-# INLINE log #-}++    sqrt (DoubleX2# a1 a2) = DoubleX2#+      (sqrtDouble# a1) (sqrtDouble# a2)+    {-# INLINE sqrt #-}++    sin (DoubleX2# a1 a2) = DoubleX2#+      (sinDouble# a1) (sinDouble# a2)+    {-# INLINE sin #-}++    cos (DoubleX2# a1 a2) = DoubleX2#+      (cosDouble# a1) (cosDouble# a2)+    {-# INLINE cos #-}++    tan (DoubleX2# a1 a2) = DoubleX2#+      (tanDouble# a1) (tanDouble# a2)+    {-# INLINE tan #-}++    asin (DoubleX2# a1 a2) = DoubleX2#+      (asinDouble# a1) (asinDouble# a2)+    {-# INLINE asin #-}++    acos (DoubleX2# a1 a2) = DoubleX2#+      (acosDouble# a1) (acosDouble# a2)+    {-# INLINE acos #-}++    atan (DoubleX2# a1 a2) = DoubleX2#+      (atanDouble# a1) (atanDouble# a2)+    {-# INLINE atan #-}++    sinh (DoubleX2# a1 a2) = DoubleX2#+      (sinhDouble# a1) (sinhDouble# a2)+    {-# INLINE sinh #-}++    cosh (DoubleX2# a1 a2) = DoubleX2#+      (coshDouble# a1) (coshDouble# a2)+    {-# INLINE cosh #-}++    tanh (DoubleX2# a1 a2) = DoubleX2#+      (tanhDouble# a1) (tanhDouble# a2)+    {-# INLINE tanh #-}++    DoubleX2# a1 a2 ** DoubleX2# b1 b2 = DoubleX2#+      ((**##) a1 b1) ((**##) a2 b2)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#+#define ELEM_N 2++instance PrimBytes DoubleX2 where++    getBytes (DoubleX2# a1 a2) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @DoubleX2 undefined) s0 of+           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of+             s2 -> case writeDoubleArray# marr 1# a2 s2 of+               s3 -> unsafeFreezeByteArray# marr s3+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = DoubleX2#+      (indexDoubleArray# arr i)+      (indexDoubleArray# arr (i +# 1#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (DoubleX2# a1 a2) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s )+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readDoubleOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of+        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)+    {-# INLINE readAddr #-}++    writeAddr (DoubleX2# a1 a2) addr s+      = writeDoubleOffAddr# addr 1# a2+      ( writeDoubleOffAddr# addr 0# a1 s )+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Double undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Double undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = DoubleX2#+      (indexDoubleArray# ba i)+      (indexDoubleArray# ba (i +# 1#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)+    {-# INLINE readArray #-}++    writeArray mba off (DoubleX2# a1 a2) s+      | i <- off *# ELEM_N#+      = writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s )+    {-# INLINE writeArray #-}+++instance PrimArray Double DoubleX2 where++    broadcast (D# x) = DoubleX2# x x+    {-# INLINE broadcast #-}++    ix# 0# (DoubleX2# a1 _) = D# a1+    ix# 1# (DoubleX2# _ a2) = D# a2+    ix# _   _               = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, D# a1 #) -> case f s1 of+        (# s2, D# a2 #) -> (# s2, DoubleX2# a1 a2 #)+++    upd# _ 0# (D# q) (DoubleX2# _ y) = DoubleX2# q y+    upd# _ 1# (D# q) (DoubleX2# x _) = DoubleX2# x q+    upd# _ _ _ x                     = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = DoubleX2#+      (indexDoubleArray# ba off)+      (indexDoubleArray# ba (off +# 1#))+    {-# INLINE fromElems #-}

@@ -0,0 +1,436 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# LANGUAGE UnboxedTuples         #-}+{-# LANGUAGE UndecidableInstances  #-}+module Numeric.DataFrame.Internal.Backend.Family.DoubleX3 (DoubleX3 (..)) 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 DoubleX3 = DoubleX3# Double# Double# Double#++-- | 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 Double => Bounded DoubleX3 where+    maxBound = case maxBound of D# x -> DoubleX3# x x x+    minBound = case minBound of D# x -> DoubleX3# x x x+++instance Eq DoubleX3 where++    DoubleX3# a1 a2 a3 == DoubleX3# b1 b2 b3 =+      isTrue#+      (       (a1 ==## b1)+      `andI#` (a2 ==## b2)+      `andI#` (a3 ==## b3)+      )+    {-# INLINE (==) #-}++    DoubleX3# a1 a2 a3 /= DoubleX3# b1 b2 b3 =+      isTrue#+      (      (a1 /=## b1)+      `orI#` (a2 /=## b2)+      `orI#` (a3 /=## b3)+      )+    {-# INLINE (/=) #-}++++cmp' :: Double# -> Double# -> PartialOrdering+cmp' a b+  | isTrue# (a >## b) = PGT+  | isTrue# (a <## b) = PLT+  | otherwise  = PEQ++instance ProductOrder DoubleX3 where+    cmp (DoubleX3# a1 a2 a3) (DoubleX3# b1 b2 b3)+      = cmp' a1 b1 <> cmp' a2 b2 <> cmp' a3 b3+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd DoubleX3) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (DoubleX3# a1 a2 a3))+         (NonTransitive.ProductOrd (DoubleX3# b1 b2 b3)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2) `andI#` (a3 >=## b3))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (DoubleX3# a1 a2 a3))+         (NonTransitive.ProductOrd (DoubleX3# b1 b2 b3)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2) `andI#` (a3 <=## b3))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (DoubleX3# a1 a2 a3))+        (NonTransitive.ProductOrd (DoubleX3# b1 b2 b3))+      = NonTransitive.ProductOrd+        ( DoubleX3#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+          (if isTrue# (a3 >## b3) then b3 else a3)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (DoubleX3# a1 a2 a3))+        (NonTransitive.ProductOrd (DoubleX3# b1 b2 b3))+      = NonTransitive.ProductOrd+        ( DoubleX3#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+          (if isTrue# (a3 <## b3) then b3 else a3)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd DoubleX3) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (DoubleX3# a1 a2 a3))+         (Partial.ProductOrd (DoubleX3# b1 b2 b3)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2) `andI#` (a3 >=## b3))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (DoubleX3# a1 a2 a3))+         (Partial.ProductOrd (DoubleX3# b1 b2 b3)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2) `andI#` (a3 <=## b3))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (DoubleX3# a1 a2 a3))+        (Partial.ProductOrd (DoubleX3# b1 b2 b3))+      = Partial.ProductOrd+        ( DoubleX3#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+          (if isTrue# (a3 >## b3) then b3 else a3)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (DoubleX3# a1 a2 a3))+        (Partial.ProductOrd (DoubleX3# b1 b2 b3))+      = Partial.ProductOrd+        ( DoubleX3#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+          (if isTrue# (a3 <## b3) then b3 else a3)+        )+    {-# INLINE max #-}++instance Ord DoubleX3 where+    DoubleX3# a1 a2 a3 > DoubleX3# b1 b2 b3+      | isTrue# (a1 >## b1) = True+      | isTrue# (a1 <## b1) = False+      | isTrue# (a2 >## b2) = True+      | isTrue# (a2 <## b2) = False+      | isTrue# (a3 >## b3) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    DoubleX3# a1 a2 a3 < DoubleX3# b1 b2 b3+      | isTrue# (a1 <## b1) = True+      | isTrue# (a1 >## b1) = False+      | isTrue# (a2 <## b2) = True+      | isTrue# (a2 >## b2) = False+      | isTrue# (a3 <## b3) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    DoubleX3# a1 a2 a3 >= DoubleX3# b1 b2 b3+      | isTrue# (a1 <## b1) = False+      | isTrue# (a1 >## b1) = True+      | isTrue# (a2 <## b2) = False+      | isTrue# (a2 >## b2) = True+      | isTrue# (a3 <## b3) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    DoubleX3# a1 a2 a3 <= DoubleX3# b1 b2 b3+      | isTrue# (a1 >## b1) = False+      | isTrue# (a1 <## b1) = True+      | isTrue# (a2 >## b2) = False+      | isTrue# (a2 <## b2) = True+      | isTrue# (a3 >## b3) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (DoubleX3# a1 a2 a3) (DoubleX3# b1 b2 b3)+      | isTrue# (a1 >## b1) = GT+      | isTrue# (a1 <## b1) = LT+      | isTrue# (a2 >## b2) = GT+      | isTrue# (a2 <## b2) = LT+      | isTrue# (a3 >## b3) = GT+      | isTrue# (a3 <## b3) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}+++++-- | element-wise operations for vectors+instance Num DoubleX3 where++    DoubleX3# a1 a2 a3 + DoubleX3# b1 b2 b3+      = DoubleX3# ((+##) a1 b1) ((+##) a2 b2) ((+##) a3 b3)+    {-# INLINE (+) #-}++    DoubleX3# a1 a2 a3 - DoubleX3# b1 b2 b3+      = DoubleX3# ((-##) a1 b1) ((-##) a2 b2) ((-##) a3 b3)+    {-# INLINE (-) #-}++    DoubleX3# a1 a2 a3 * DoubleX3# b1 b2 b3+      = DoubleX3# ((*##) a1 b1) ((*##) a2 b2) ((*##) a3 b3)+    {-# INLINE (*) #-}++    negate (DoubleX3# a1 a2 a3) = DoubleX3#+      (negateDouble# a1) (negateDouble# a2) (negateDouble# a3)+    {-# INLINE negate #-}++    abs (DoubleX3# a1 a2 a3)+      = DoubleX3#+      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)+      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)+      (if isTrue# (a3 >=## 0.0##) then a3 else negateDouble# a3)+    {-# INLINE abs #-}++    signum (DoubleX3# a1 a2 a3)+      = DoubleX3# (if isTrue# (a1 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a2 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a3 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a3 <## 0.0##) then -1.0## else 0.0## )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of D# x -> DoubleX3# x x x+    {-# INLINE fromInteger #-}++++instance Fractional DoubleX3 where++    DoubleX3# a1 a2 a3 / DoubleX3# b1 b2 b3 = DoubleX3#+      ((/##) a1 b1) ((/##) a2 b2) ((/##) a3 b3)+    {-# INLINE (/) #-}++    recip (DoubleX3# a1 a2 a3) = DoubleX3#+      ((/##) 1.0## a1) ((/##) 1.0## a2) ((/##) 1.0## a3)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of D# x -> DoubleX3# x x x+    {-# INLINE fromRational #-}++++instance Floating DoubleX3 where++    pi = DoubleX3#+      3.141592653589793238##+      3.141592653589793238##+      3.141592653589793238##+    {-# INLINE pi #-}++    exp (DoubleX3# a1 a2 a3) = DoubleX3#+      (expDouble# a1) (expDouble# a2) (expDouble# a3)+    {-# INLINE exp #-}++    log (DoubleX3# a1 a2 a3) = DoubleX3#+      (logDouble# a1) (logDouble# a2) (logDouble# a3)+    {-# INLINE log #-}++    sqrt (DoubleX3# a1 a2 a3) = DoubleX3#+      (sqrtDouble# a1) (sqrtDouble# a2) (sqrtDouble# a3)+    {-# INLINE sqrt #-}++    sin (DoubleX3# a1 a2 a3) = DoubleX3#+      (sinDouble# a1) (sinDouble# a2) (sinDouble# a3)+    {-# INLINE sin #-}++    cos (DoubleX3# a1 a2 a3) = DoubleX3#+      (cosDouble# a1) (cosDouble# a2) (cosDouble# a3)+    {-# INLINE cos #-}++    tan (DoubleX3# a1 a2 a3) = DoubleX3#+      (tanDouble# a1) (tanDouble# a2) (tanDouble# a3)+    {-# INLINE tan #-}++    asin (DoubleX3# a1 a2 a3) = DoubleX3#+      (asinDouble# a1) (asinDouble# a2) (asinDouble# a3)+    {-# INLINE asin #-}++    acos (DoubleX3# a1 a2 a3) = DoubleX3#+      (acosDouble# a1) (acosDouble# a2) (acosDouble# a3)+    {-# INLINE acos #-}++    atan (DoubleX3# a1 a2 a3) = DoubleX3#+      (atanDouble# a1) (atanDouble# a2) (atanDouble# a3)+    {-# INLINE atan #-}++    sinh (DoubleX3# a1 a2 a3) = DoubleX3#+      (sinhDouble# a1) (sinhDouble# a2) (sinhDouble# a3)+    {-# INLINE sinh #-}++    cosh (DoubleX3# a1 a2 a3) = DoubleX3#+      (coshDouble# a1) (coshDouble# a2) (coshDouble# a3)+    {-# INLINE cosh #-}++    tanh (DoubleX3# a1 a2 a3) = DoubleX3#+      (tanhDouble# a1) (tanhDouble# a2) (tanhDouble# a3)+    {-# INLINE tanh #-}++    DoubleX3# a1 a2 a3 ** DoubleX3# b1 b2 b3 = DoubleX3#+      ((**##) a1 b1) ((**##) a2 b2) ((**##) a3 b3)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#+#define ELEM_N 3++instance PrimBytes DoubleX3 where++    getBytes (DoubleX3# a1 a2 a3) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @DoubleX3 undefined) s0 of+           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of+             s2 -> case writeDoubleArray# marr 1# a2 s2 of+               s3 -> case writeDoubleArray# marr 2# a3 s3 of+                 s4 -> unsafeFreezeByteArray# marr s4+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = DoubleX3#+      (indexDoubleArray# arr i)+      (indexDoubleArray# arr (i +# 1#))+      (indexDoubleArray# arr (i +# 2#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (DoubleX3# a1 a2 a3) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeDoubleArray# mba (i +# 2#) a3+      ( writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s ))+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readDoubleOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of+        (# s2, a2 #) -> case readDoubleOffAddr# addr 2# s2 of+          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)+    {-# INLINE readAddr #-}++    writeAddr (DoubleX3# a1 a2 a3) addr s+      = writeDoubleOffAddr# addr 2# a3+      ( writeDoubleOffAddr# addr 1# a2+      ( writeDoubleOffAddr# addr 0# a1 s ))+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Double undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Double undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = DoubleX3#+      (indexDoubleArray# ba i)+      (indexDoubleArray# ba (i +# 1#))+      (indexDoubleArray# ba (i +# 2#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)+    {-# INLINE readArray #-}++    writeArray mba off (DoubleX3# a1 a2 a3) s+      | i <- off *# ELEM_N#+      = writeDoubleArray# mba (i +# 2#) a3+      ( writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s ))+    {-# INLINE writeArray #-}+++instance PrimArray Double DoubleX3 where++    broadcast (D# x) = DoubleX3# x x x+    {-# INLINE broadcast #-}++    ix# 0# (DoubleX3# a1 _ _) = D# a1+    ix# 1# (DoubleX3# _ a2 _) = D# a2+    ix# 2# (DoubleX3# _ _ a3) = D# a3+    ix# _   _                 = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, D# a1 #) -> case f s1 of+        (# s2, D# a2 #) -> case f s2 of+          (# s3, D# a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)+++    upd# _ 0# (D# q) (DoubleX3# _ y z) = DoubleX3# q y z+    upd# _ 1# (D# q) (DoubleX3# x _ z) = DoubleX3# x q z+    upd# _ 2# (D# q) (DoubleX3# x y _) = DoubleX3# x y q+    upd# _ _ _ x                       = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = DoubleX3#+      (indexDoubleArray# ba off)+      (indexDoubleArray# ba (off +# 1#))+      (indexDoubleArray# ba (off +# 2#))+    {-# INLINE fromElems #-}

@@ -0,0 +1,467 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# LANGUAGE UnboxedTuples         #-}+{-# LANGUAGE UndecidableInstances  #-}+module Numeric.DataFrame.Internal.Backend.Family.DoubleX4 (DoubleX4 (..)) 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 DoubleX4 = DoubleX4# Double# Double# Double# Double#++-- | 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 Double => Bounded DoubleX4 where+    maxBound = case maxBound of D# x -> DoubleX4# x x x x+    minBound = case minBound of D# x -> DoubleX4# x x x x+++instance Eq DoubleX4 where++    DoubleX4# a1 a2 a3 a4 == DoubleX4# b1 b2 b3 b4 =+      isTrue#+      (       (a1 ==## b1)+      `andI#` (a2 ==## b2)+      `andI#` (a3 ==## b3)+      `andI#` (a4 ==## b4)+      )+    {-# INLINE (==) #-}++    DoubleX4# a1 a2 a3 a4 /= DoubleX4# b1 b2 b3 b4 =+      isTrue#+      (      (a1 /=## b1)+      `orI#` (a2 /=## b2)+      `orI#` (a3 /=## b3)+      `orI#` (a4 /=## b4)+      )+    {-# INLINE (/=) #-}++cmp' :: Double# -> Double# -> PartialOrdering+cmp' a b+  | isTrue# (a >## b) = PGT+  | isTrue# (a <## b) = PLT+  | otherwise  = PEQ++instance ProductOrder DoubleX4 where+    cmp (DoubleX4# a1 a2 a3 a4) (DoubleX4# b1 b2 b3 b4)+      = cmp' a1 b1 <> cmp' a2 b2 <> cmp' a3 b3 <> cmp' a4 b4+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd DoubleX4) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (DoubleX4# a1 a2 a3 a4))+         (NonTransitive.ProductOrd (DoubleX4# b1 b2 b3 b4)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2) `andI#` (a3 >=## b3) `andI#` (a4 >=## b4))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (DoubleX4# a1 a2 a3 a4))+         (NonTransitive.ProductOrd (DoubleX4# b1 b2 b3 b4)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2) `andI#` (a3 <=## b3) `andI#` (a4 <=## b4))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (DoubleX4# a1 a2 a3 a4))+        (NonTransitive.ProductOrd (DoubleX4# b1 b2 b3 b4))+      = NonTransitive.ProductOrd+        ( DoubleX4#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+          (if isTrue# (a3 >## b3) then b3 else a3)+          (if isTrue# (a4 >## b4) then b4 else a4)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (DoubleX4# a1 a2 a3 a4))+        (NonTransitive.ProductOrd (DoubleX4# b1 b2 b3 b4))+      = NonTransitive.ProductOrd+        ( DoubleX4#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+          (if isTrue# (a3 <## b3) then b3 else a3)+          (if isTrue# (a4 <## b4) then b4 else a4)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd DoubleX4) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (DoubleX4# a1 a2 a3 a4))+         (Partial.ProductOrd (DoubleX4# b1 b2 b3 b4)) = isTrue#+      ((a1 >=## b1) `andI#` (a2 >=## b2) `andI#` (a3 >=## b3) `andI#` (a4 >=## b4))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (DoubleX4# a1 a2 a3 a4))+         (Partial.ProductOrd (DoubleX4# b1 b2 b3 b4)) = isTrue#+      ((a1 <=## b1) `andI#` (a2 <=## b2) `andI#` (a3 <=## b3) `andI#` (a4 <=## b4))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (DoubleX4# a1 a2 a3 a4))+        (Partial.ProductOrd (DoubleX4# b1 b2 b3 b4))+      = Partial.ProductOrd+        ( DoubleX4#+          (if isTrue# (a1 >## b1) then b1 else a1)+          (if isTrue# (a2 >## b2) then b2 else a2)+          (if isTrue# (a3 >## b3) then b3 else a3)+          (if isTrue# (a4 >## b4) then b4 else a4)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (DoubleX4# a1 a2 a3 a4))+        (Partial.ProductOrd (DoubleX4# b1 b2 b3 b4))+      = Partial.ProductOrd+        ( DoubleX4#+          (if isTrue# (a1 <## b1) then b1 else a1)+          (if isTrue# (a2 <## b2) then b2 else a2)+          (if isTrue# (a3 <## b3) then b3 else a3)+          (if isTrue# (a4 <## b4) then b4 else a4)+        )+    {-# INLINE max #-}++instance Ord DoubleX4 where+    DoubleX4# a1 a2 a3 a4 > DoubleX4# b1 b2 b3 b4+      | isTrue# (a1 >## b1) = True+      | isTrue# (a1 <## b1) = False+      | isTrue# (a2 >## b2) = True+      | isTrue# (a2 <## b2) = False+      | isTrue# (a3 >## b3) = True+      | isTrue# (a3 <## b3) = False+      | isTrue# (a4 >## b4) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    DoubleX4# a1 a2 a3 a4 < DoubleX4# b1 b2 b3 b4+      | isTrue# (a1 <## b1) = True+      | isTrue# (a1 >## b1) = False+      | isTrue# (a2 <## b2) = True+      | isTrue# (a2 >## b2) = False+      | isTrue# (a3 <## b3) = True+      | isTrue# (a3 >## b3) = False+      | isTrue# (a4 <## b4) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    DoubleX4# a1 a2 a3 a4 >= DoubleX4# b1 b2 b3 b4+      | isTrue# (a1 <## b1) = False+      | isTrue# (a1 >## b1) = True+      | isTrue# (a2 <## b2) = False+      | isTrue# (a2 >## b2) = True+      | isTrue# (a3 <## b3) = False+      | isTrue# (a3 >## b3) = True+      | isTrue# (a4 <## b4) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    DoubleX4# a1 a2 a3 a4 <= DoubleX4# b1 b2 b3 b4+      | isTrue# (a1 >## b1) = False+      | isTrue# (a1 <## b1) = True+      | isTrue# (a2 >## b2) = False+      | isTrue# (a2 <## b2) = True+      | isTrue# (a3 >## b3) = False+      | isTrue# (a3 <## b3) = True+      | isTrue# (a4 >## b4) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (DoubleX4# a1 a2 a3 a4) (DoubleX4# b1 b2 b3 b4)+      | isTrue# (a1 >## b1) = GT+      | isTrue# (a1 <## b1) = LT+      | isTrue# (a2 >## b2) = GT+      | isTrue# (a2 <## b2) = LT+      | isTrue# (a3 >## b3) = GT+      | isTrue# (a3 <## b3) = LT+      | isTrue# (a4 >## b4) = GT+      | isTrue# (a4 <## b4) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}++++-- | element-wise operations for vectors+instance Num DoubleX4 where++    DoubleX4# a1 a2 a3 a4 + DoubleX4# b1 b2 b3 b4+      = DoubleX4# ((+##) a1 b1) ((+##) a2 b2) ((+##) a3 b3) ((+##) a4 b4)+    {-# INLINE (+) #-}++    DoubleX4# a1 a2 a3 a4 - DoubleX4# b1 b2 b3 b4+      = DoubleX4# ((-##) a1 b1) ((-##) a2 b2) ((-##) a3 b3) ((-##) a4 b4)+    {-# INLINE (-) #-}++    DoubleX4# a1 a2 a3 a4 * DoubleX4# b1 b2 b3 b4+      = DoubleX4# ((*##) a1 b1) ((*##) a2 b2) ((*##) a3 b3) ((*##) a4 b4)+    {-# INLINE (*) #-}++    negate (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (negateDouble# a1) (negateDouble# a2) (negateDouble# a3) (negateDouble# a4)+    {-# INLINE negate #-}++    abs (DoubleX4# a1 a2 a3 a4)+      = DoubleX4#+      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)+      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)+      (if isTrue# (a3 >=## 0.0##) then a3 else negateDouble# a3)+      (if isTrue# (a4 >=## 0.0##) then a4 else negateDouble# a4)+    {-# INLINE abs #-}++    signum (DoubleX4# a1 a2 a3 a4)+      = DoubleX4# (if isTrue# (a1 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a2 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a3 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a3 <## 0.0##) then -1.0## else 0.0## )+                 (if isTrue# (a4 >## 0.0##)+                  then 1.0##+                  else if isTrue# (a4 <## 0.0##) then -1.0## else 0.0## )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of D# x -> DoubleX4# x x x x+    {-# INLINE fromInteger #-}++++instance Fractional DoubleX4 where++    DoubleX4# a1 a2 a3 a4 / DoubleX4# b1 b2 b3 b4 = DoubleX4#+      ((/##) a1 b1) ((/##) a2 b2) ((/##) a3 b3) ((/##) a4 b4)+    {-# INLINE (/) #-}++    recip (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      ((/##) 1.0## a1) ((/##) 1.0## a2) ((/##) 1.0## a3) ((/##) 1.0## a4)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of D# x -> DoubleX4# x x x x+    {-# INLINE fromRational #-}++++instance Floating DoubleX4 where++    pi = DoubleX4#+      3.141592653589793238##+      3.141592653589793238##+      3.141592653589793238##+      3.141592653589793238##+    {-# INLINE pi #-}++    exp (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (expDouble# a1) (expDouble# a2) (expDouble# a3) (expDouble# a4)+    {-# INLINE exp #-}++    log (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (logDouble# a1) (logDouble# a2) (logDouble# a3) (logDouble# a4)+    {-# INLINE log #-}++    sqrt (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (sqrtDouble# a1) (sqrtDouble# a2) (sqrtDouble# a3) (sqrtDouble# a4)+    {-# INLINE sqrt #-}++    sin (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (sinDouble# a1) (sinDouble# a2) (sinDouble# a3) (sinDouble# a4)+    {-# INLINE sin #-}++    cos (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (cosDouble# a1) (cosDouble# a2) (cosDouble# a3) (cosDouble# a4)+    {-# INLINE cos #-}++    tan (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (tanDouble# a1) (tanDouble# a2) (tanDouble# a3) (tanDouble# a4)+    {-# INLINE tan #-}++    asin (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (asinDouble# a1) (asinDouble# a2) (asinDouble# a3) (asinDouble# a4)+    {-# INLINE asin #-}++    acos (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (acosDouble# a1) (acosDouble# a2) (acosDouble# a3) (acosDouble# a4)+    {-# INLINE acos #-}++    atan (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (atanDouble# a1) (atanDouble# a2) (atanDouble# a3) (atanDouble# a4)+    {-# INLINE atan #-}++    sinh (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (sinhDouble# a1) (sinhDouble# a2) (sinhDouble# a3) (sinhDouble# a4)+    {-# INLINE sinh #-}++    cosh (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (coshDouble# a1) (coshDouble# a2) (coshDouble# a3) (coshDouble# a4)+    {-# INLINE cosh #-}++    tanh (DoubleX4# a1 a2 a3 a4) = DoubleX4#+      (tanhDouble# a1) (tanhDouble# a2) (tanhDouble# a3) (tanhDouble# a4)+    {-# INLINE tanh #-}++    DoubleX4# a1 a2 a3 a4 ** DoubleX4# b1 b2 b3 b4 = DoubleX4#+      ((**##) a1 b1) ((**##) a2 b2) ((**##) a3 b3) ((**##) a4 b4)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#+#define ELEM_N 4++instance PrimBytes DoubleX4 where++    getBytes (DoubleX4# a1 a2 a3 a4) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @DoubleX4 undefined) s0 of+           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of+             s2 -> case writeDoubleArray# marr 1# a2 s2 of+               s3 -> case writeDoubleArray# marr 2# a3 s3 of+                 s4 -> case writeDoubleArray# marr 3# a4 s4 of+                   s5 -> unsafeFreezeByteArray# marr s5+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = DoubleX4#+      (indexDoubleArray# arr i)+      (indexDoubleArray# arr (i +# 1#))+      (indexDoubleArray# arr (i +# 2#))+      (indexDoubleArray# arr (i +# 3#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> case readDoubleArray# mba (i +# 3#) s3 of+            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (DoubleX4# a1 a2 a3 a4) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeDoubleArray# mba (i +# 3#) a4+      ( writeDoubleArray# mba (i +# 2#) a3+      ( writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s )))+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readDoubleOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of+        (# s2, a2 #) -> case readDoubleOffAddr# addr 2# s2 of+          (# s3, a3 #) -> case readDoubleOffAddr# addr 3# s3 of+            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)+    {-# INLINE readAddr #-}++    writeAddr (DoubleX4# a1 a2 a3 a4) addr s+      = writeDoubleOffAddr# addr 3# a4+      ( writeDoubleOffAddr# addr 2# a3+      ( writeDoubleOffAddr# addr 1# a2+      ( writeDoubleOffAddr# addr 0# a1 s )))+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Double undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Double undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = DoubleX4#+      (indexDoubleArray# ba i)+      (indexDoubleArray# ba (i +# 1#))+      (indexDoubleArray# ba (i +# 2#))+      (indexDoubleArray# ba (i +# 3#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readDoubleArray# mba i s0 of+      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> case readDoubleArray# mba (i +# 3#) s3 of+            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)+    {-# INLINE readArray #-}++    writeArray mba off (DoubleX4# a1 a2 a3 a4) s+      | i <- off *# ELEM_N#+      = writeDoubleArray# mba (i +# 3#) a4+      ( writeDoubleArray# mba (i +# 2#) a3+      ( writeDoubleArray# mba (i +# 1#) a2+      ( writeDoubleArray# mba  i        a1 s )))+    {-# INLINE writeArray #-}+++instance PrimArray Double DoubleX4 where++    broadcast (D# x) = DoubleX4# x x x x+    {-# INLINE broadcast #-}++    ix# 0# (DoubleX4# a1 _ _ _) = D# a1+    ix# 1# (DoubleX4# _ a2 _ _) = D# a2+    ix# 2# (DoubleX4# _ _ a3 _) = D# a3+    ix# 3# (DoubleX4# _ _ _ a4) = D# a4+    ix# _   _                   = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, D# a1 #) -> case f s1 of+        (# s2, D# a2 #) -> case f s2 of+          (# s3, D# a3 #) -> case f s3 of+            (# s4, D# a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)+++    upd# _ 0# (D# q) (DoubleX4# _ y z w) = DoubleX4# q y z w+    upd# _ 1# (D# q) (DoubleX4# x _ z w) = DoubleX4# x q z w+    upd# _ 2# (D# q) (DoubleX4# x y _ w) = DoubleX4# x y q w+    upd# _ 3# (D# q) (DoubleX4# x y z _) = DoubleX4# x y z q+    upd# _ _ _ x                         = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = DoubleX4#+      (indexDoubleArray# ba off)+      (indexDoubleArray# ba (off +# 1#))+      (indexDoubleArray# ba (off +# 2#))+      (indexDoubleArray# ba (off +# 3#))+    {-# INLINE fromElems #-}

@@ -0,0 +1,401 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# 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 = case maxBound of F# x -> FloatX2# x x+    minBound = case minBound of F# x -> FloatX2# x x+++instance Eq FloatX2 where++    FloatX2# a1 a2 == FloatX2# b1 b2 =+      isTrue#+      (       (a1 `eqFloat#` b1)+      `andI#` (a2 `eqFloat#` b2)+      )+    {-# INLINE (==) #-}++    FloatX2# a1 a2 /= FloatX2# b1 b2 =+      isTrue#+      (      (a1 `neFloat#` b1)+      `orI#` (a2 `neFloat#` b2)+      )+    {-# INLINE (/=) #-}++++cmp' :: Float# -> Float# -> PartialOrdering+cmp' a b+  | isTrue# (a `gtFloat#` b) = PGT+  | isTrue# (a `ltFloat#` b) = PLT+  | otherwise  = PEQ++instance ProductOrder FloatX2 where+    cmp (FloatX2# a1 a2) (FloatX2# b1 b2)+      = cmp' a1 b1 <> cmp' a2 b2+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd FloatX2) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (FloatX2# a1 a2))+         (NonTransitive.ProductOrd (FloatX2# b1 b2)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (FloatX2# a1 a2))+         (NonTransitive.ProductOrd (FloatX2# b1 b2)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (FloatX2# a1 a2))+        (NonTransitive.ProductOrd (FloatX2# b1 b2))+      = NonTransitive.ProductOrd+        ( FloatX2#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (FloatX2# a1 a2))+        (NonTransitive.ProductOrd (FloatX2# b1 b2))+      = NonTransitive.ProductOrd+        ( FloatX2#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd FloatX2) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (FloatX2# a1 a2))+         (Partial.ProductOrd (FloatX2# b1 b2)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (FloatX2# a1 a2))+         (Partial.ProductOrd (FloatX2# b1 b2)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (FloatX2# a1 a2))+        (Partial.ProductOrd (FloatX2# b1 b2))+      = Partial.ProductOrd+        ( FloatX2#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (FloatX2# a1 a2))+        (Partial.ProductOrd (FloatX2# b1 b2))+      = Partial.ProductOrd+        ( FloatX2#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+        )+    {-# INLINE max #-}++instance Ord FloatX2 where+    FloatX2# a1 a2 > FloatX2# b1 b2+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a2 `gtFloat#` b2) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    FloatX2# a1 a2 < FloatX2# b1 b2+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a2 `ltFloat#` b2) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    FloatX2# a1 a2 >= FloatX2# b1 b2+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a2 `ltFloat#` b2) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    FloatX2# a1 a2 <= FloatX2# b1 b2+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a2 `gtFloat#` b2) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (FloatX2# a1 a2) (FloatX2# b1 b2)+      | isTrue# (a1 `gtFloat#` b1) = GT+      | isTrue# (a1 `ltFloat#` b1) = LT+      | isTrue# (a2 `gtFloat#` b2) = GT+      | isTrue# (a2 `ltFloat#` b2) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}++++-- | element-wise operations for vectors+instance Num FloatX2 where++    FloatX2# a1 a2 + FloatX2# b1 b2+      = FloatX2# (plusFloat# a1 b1) (plusFloat# a2 b2)+    {-# INLINE (+) #-}++    FloatX2# a1 a2 - FloatX2# b1 b2+      = FloatX2# (minusFloat# a1 b1) (minusFloat# a2 b2)+    {-# INLINE (-) #-}++    FloatX2# a1 a2 * FloatX2# b1 b2+      = FloatX2# (timesFloat# a1 b1) (timesFloat# a2 b2)+    {-# INLINE (*) #-}++    negate (FloatX2# a1 a2) = FloatX2#+      (negateFloat# a1) (negateFloat# a2)+    {-# INLINE negate #-}++    abs (FloatX2# a1 a2)+      = FloatX2#+      (if isTrue# (a1 `geFloat#` 0.0#) then a1 else negateFloat# a1)+      (if isTrue# (a2 `geFloat#` 0.0#) then a2 else negateFloat# a2)+    {-# INLINE abs #-}++    signum (FloatX2# a1 a2)+      = FloatX2# (if isTrue# (a1 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a1 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a2 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a2 `ltFloat#` 0.0#) then -1.0# else 0.0# )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of F# x -> FloatX2# x x+    {-# INLINE fromInteger #-}++++instance Fractional FloatX2 where++    FloatX2# a1 a2 / FloatX2# b1 b2 = FloatX2#+      (divideFloat# a1 b1) (divideFloat# a2 b2)+    {-# INLINE (/) #-}++    recip (FloatX2# a1 a2) = FloatX2#+      (divideFloat# 1.0# a1) (divideFloat# 1.0# a2)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of F# x -> FloatX2# x x+    {-# INLINE fromRational #-}++++instance Floating FloatX2 where++    pi = FloatX2#+      3.141592653589793238#+      3.141592653589793238#+    {-# INLINE pi #-}++    exp (FloatX2# a1 a2) = FloatX2#+      (expFloat# a1) (expFloat# a2)+    {-# INLINE exp #-}++    log (FloatX2# a1 a2) = FloatX2#+      (logFloat# a1) (logFloat# a2)+    {-# INLINE log #-}++    sqrt (FloatX2# a1 a2) = FloatX2#+      (sqrtFloat# a1) (sqrtFloat# a2)+    {-# INLINE sqrt #-}++    sin (FloatX2# a1 a2) = FloatX2#+      (sinFloat# a1) (sinFloat# a2)+    {-# INLINE sin #-}++    cos (FloatX2# a1 a2) = FloatX2#+      (cosFloat# a1) (cosFloat# a2)+    {-# INLINE cos #-}++    tan (FloatX2# a1 a2) = FloatX2#+      (tanFloat# a1) (tanFloat# a2)+    {-# INLINE tan #-}++    asin (FloatX2# a1 a2) = FloatX2#+      (asinFloat# a1) (asinFloat# a2)+    {-# INLINE asin #-}++    acos (FloatX2# a1 a2) = FloatX2#+      (acosFloat# a1) (acosFloat# a2)+    {-# INLINE acos #-}++    atan (FloatX2# a1 a2) = FloatX2#+      (atanFloat# a1) (atanFloat# a2)+    {-# INLINE atan #-}++    sinh (FloatX2# a1 a2) = FloatX2#+      (sinhFloat# a1) (sinhFloat# a2)+    {-# INLINE sinh #-}++    cosh (FloatX2# a1 a2) = FloatX2#+      (coshFloat# a1) (coshFloat# a2)+    {-# INLINE cosh #-}++    tanh (FloatX2# a1 a2) = FloatX2#+      (tanhFloat# a1) (tanhFloat# a2)+    {-# INLINE tanh #-}++    FloatX2# a1 a2 ** FloatX2# b1 b2 = FloatX2#+      (powerFloat# a1 b1) (powerFloat# a2 b2)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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# a1 a2) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @FloatX2 undefined) s0 of+           (# s1, marr #) -> case writeFloatArray# marr 0# a1 s1 of+             s2 -> case writeFloatArray# marr 1# a2 s2 of+               s3 -> unsafeFreezeByteArray# marr s3+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = FloatX2#+      (indexFloatArray# arr i)+      (indexFloatArray# arr (i +# 1#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (FloatX2# a1 a2) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s )+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readFloatOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readFloatOffAddr# addr 1# s1 of+        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)+    {-# INLINE readAddr #-}++    writeAddr (FloatX2# a1 a2) addr s+      = writeFloatOffAddr# addr 1# a2+      ( writeFloatOffAddr# addr 0# a1 s )+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Float undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Float undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = FloatX2#+      (indexFloatArray# ba i)+      (indexFloatArray# ba (i +# 1#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)+    {-# INLINE readArray #-}++    writeArray mba off (FloatX2# a1 a2) s+      | i <- off *# ELEM_N#+      = writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s )+    {-# INLINE writeArray #-}+++instance PrimArray Float FloatX2 where++    broadcast (F# x) = FloatX2# x x+    {-# INLINE broadcast #-}++    ix# 0# (FloatX2# a1 _) = F# a1+    ix# 1# (FloatX2# _ a2) = F# a2+    ix# _   _              = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, F# a1 #) -> case f s1 of+        (# s2, F# a2 #) -> (# s2, FloatX2# a1 a2 #)+++    upd# _ 0# (F# q) (FloatX2# _ y) = FloatX2# q y+    upd# _ 1# (F# q) (FloatX2# x _) = FloatX2# x q+    upd# _ _ _ x                    = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = FloatX2#+      (indexFloatArray# ba off)+      (indexFloatArray# ba (off +# 1#))+    {-# INLINE fromElems #-}

@@ -0,0 +1,437 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# 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#++-- | 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 FloatX3 where+    maxBound = case maxBound of F# x -> FloatX3# x x x+    minBound = case minBound of F# x -> FloatX3# x x x+++instance Eq FloatX3 where++    FloatX3# a1 a2 a3 == FloatX3# b1 b2 b3 =+      isTrue#+      (       (a1 `eqFloat#` b1)+      `andI#` (a2 `eqFloat#` b2)+      `andI#` (a3 `eqFloat#` b3)+      )+    {-# INLINE (==) #-}++    FloatX3# a1 a2 a3 /= FloatX3# b1 b2 b3 =+      isTrue#+      (      (a1 `neFloat#` b1)+      `orI#` (a2 `neFloat#` b2)+      `orI#` (a3 `neFloat#` b3)+      )+    {-# INLINE (/=) #-}+++++cmp' :: Float# -> Float# -> PartialOrdering+cmp' a b+  | isTrue# (a `gtFloat#` b) = PGT+  | isTrue# (a `ltFloat#` b) = PLT+  | otherwise  = PEQ++instance ProductOrder FloatX3 where+    cmp (FloatX3# a1 a2 a3) (FloatX3# b1 b2 b3)+      = cmp' a1 b1 <> cmp' a2 b2 <> cmp' a3 b3+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd FloatX3) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (FloatX3# a1 a2 a3))+         (NonTransitive.ProductOrd (FloatX3# b1 b2 b3)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2) `andI#` (a3 `geFloat#` b3))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (FloatX3# a1 a2 a3))+         (NonTransitive.ProductOrd (FloatX3# b1 b2 b3)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2) `andI#` (a3 `leFloat#` b3))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (FloatX3# a1 a2 a3))+        (NonTransitive.ProductOrd (FloatX3# b1 b2 b3))+      = NonTransitive.ProductOrd+        ( FloatX3#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `gtFloat#` b3) then b3 else a3)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (FloatX3# a1 a2 a3))+        (NonTransitive.ProductOrd (FloatX3# b1 b2 b3))+      = NonTransitive.ProductOrd+        ( FloatX3#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `ltFloat#` b3) then b3 else a3)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd FloatX3) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (FloatX3# a1 a2 a3))+         (Partial.ProductOrd (FloatX3# b1 b2 b3)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2) `andI#` (a3 `geFloat#` b3))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (FloatX3# a1 a2 a3))+         (Partial.ProductOrd (FloatX3# b1 b2 b3)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2) `andI#` (a3 `leFloat#` b3))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (FloatX3# a1 a2 a3))+        (Partial.ProductOrd (FloatX3# b1 b2 b3))+      = Partial.ProductOrd+        ( FloatX3#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `gtFloat#` b3) then b3 else a3)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (FloatX3# a1 a2 a3))+        (Partial.ProductOrd (FloatX3# b1 b2 b3))+      = Partial.ProductOrd+        ( FloatX3#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `ltFloat#` b3) then b3 else a3)+        )+    {-# INLINE max #-}++instance Ord FloatX3 where+    FloatX3# a1 a2 a3 > FloatX3# b1 b2 b3+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a2 `gtFloat#` b2) = True+      | isTrue# (a2 `ltFloat#` b2) = False+      | isTrue# (a3 `gtFloat#` b3) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    FloatX3# a1 a2 a3 < FloatX3# b1 b2 b3+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a2 `ltFloat#` b2) = True+      | isTrue# (a2 `gtFloat#` b2) = False+      | isTrue# (a3 `ltFloat#` b3) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    FloatX3# a1 a2 a3 >= FloatX3# b1 b2 b3+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a2 `ltFloat#` b2) = False+      | isTrue# (a2 `gtFloat#` b2) = True+      | isTrue# (a3 `ltFloat#` b3) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    FloatX3# a1 a2 a3 <= FloatX3# b1 b2 b3+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a2 `gtFloat#` b2) = False+      | isTrue# (a2 `ltFloat#` b2) = True+      | isTrue# (a3 `gtFloat#` b3) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (FloatX3# a1 a2 a3) (FloatX3# b1 b2 b3)+      | isTrue# (a1 `gtFloat#` b1) = GT+      | isTrue# (a1 `ltFloat#` b1) = LT+      | isTrue# (a2 `gtFloat#` b2) = GT+      | isTrue# (a2 `ltFloat#` b2) = LT+      | isTrue# (a3 `gtFloat#` b3) = GT+      | isTrue# (a3 `ltFloat#` b3) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}+++++-- | element-wise operations for vectors+instance Num FloatX3 where++    FloatX3# a1 a2 a3 + FloatX3# b1 b2 b3+      = FloatX3# (plusFloat# a1 b1) (plusFloat# a2 b2) (plusFloat# a3 b3)+    {-# INLINE (+) #-}++    FloatX3# a1 a2 a3 - FloatX3# b1 b2 b3+      = FloatX3# (minusFloat# a1 b1) (minusFloat# a2 b2) (minusFloat# a3 b3)+    {-# INLINE (-) #-}++    FloatX3# a1 a2 a3 * FloatX3# b1 b2 b3+      = FloatX3# (timesFloat# a1 b1) (timesFloat# a2 b2) (timesFloat# a3 b3)+    {-# INLINE (*) #-}++    negate (FloatX3# a1 a2 a3) = FloatX3#+      (negateFloat# a1) (negateFloat# a2) (negateFloat# a3)+    {-# INLINE negate #-}++    abs (FloatX3# a1 a2 a3)+      = FloatX3#+      (if isTrue# (a1 `geFloat#` 0.0#) then a1 else negateFloat# a1)+      (if isTrue# (a2 `geFloat#` 0.0#) then a2 else negateFloat# a2)+      (if isTrue# (a3 `geFloat#` 0.0#) then a3 else negateFloat# a3)+    {-# INLINE abs #-}++    signum (FloatX3# a1 a2 a3)+      = FloatX3# (if isTrue# (a1 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a1 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a2 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a2 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a3 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a3 `ltFloat#` 0.0#) then -1.0# else 0.0# )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of F# x -> FloatX3# x x x+    {-# INLINE fromInteger #-}++++instance Fractional FloatX3 where++    FloatX3# a1 a2 a3 / FloatX3# b1 b2 b3 = FloatX3#+      (divideFloat# a1 b1) (divideFloat# a2 b2) (divideFloat# a3 b3)+    {-# INLINE (/) #-}++    recip (FloatX3# a1 a2 a3) = FloatX3#+      (divideFloat# 1.0# a1) (divideFloat# 1.0# a2) (divideFloat# 1.0# a3)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of F# x -> FloatX3# x x x+    {-# INLINE fromRational #-}++++instance Floating FloatX3 where++    pi = FloatX3#+      3.141592653589793238#+      3.141592653589793238#+      3.141592653589793238#+    {-# INLINE pi #-}++    exp (FloatX3# a1 a2 a3) = FloatX3#+      (expFloat# a1) (expFloat# a2) (expFloat# a3)+    {-# INLINE exp #-}++    log (FloatX3# a1 a2 a3) = FloatX3#+      (logFloat# a1) (logFloat# a2) (logFloat# a3)+    {-# INLINE log #-}++    sqrt (FloatX3# a1 a2 a3) = FloatX3#+      (sqrtFloat# a1) (sqrtFloat# a2) (sqrtFloat# a3)+    {-# INLINE sqrt #-}++    sin (FloatX3# a1 a2 a3) = FloatX3#+      (sinFloat# a1) (sinFloat# a2) (sinFloat# a3)+    {-# INLINE sin #-}++    cos (FloatX3# a1 a2 a3) = FloatX3#+      (cosFloat# a1) (cosFloat# a2) (cosFloat# a3)+    {-# INLINE cos #-}++    tan (FloatX3# a1 a2 a3) = FloatX3#+      (tanFloat# a1) (tanFloat# a2) (tanFloat# a3)+    {-# INLINE tan #-}++    asin (FloatX3# a1 a2 a3) = FloatX3#+      (asinFloat# a1) (asinFloat# a2) (asinFloat# a3)+    {-# INLINE asin #-}++    acos (FloatX3# a1 a2 a3) = FloatX3#+      (acosFloat# a1) (acosFloat# a2) (acosFloat# a3)+    {-# INLINE acos #-}++    atan (FloatX3# a1 a2 a3) = FloatX3#+      (atanFloat# a1) (atanFloat# a2) (atanFloat# a3)+    {-# INLINE atan #-}++    sinh (FloatX3# a1 a2 a3) = FloatX3#+      (sinhFloat# a1) (sinhFloat# a2) (sinhFloat# a3)+    {-# INLINE sinh #-}++    cosh (FloatX3# a1 a2 a3) = FloatX3#+      (coshFloat# a1) (coshFloat# a2) (coshFloat# a3)+    {-# INLINE cosh #-}++    tanh (FloatX3# a1 a2 a3) = FloatX3#+      (tanhFloat# a1) (tanhFloat# a2) (tanhFloat# a3)+    {-# INLINE tanh #-}++    FloatX3# a1 a2 a3 ** FloatX3# b1 b2 b3 = FloatX3#+      (powerFloat# a1 b1) (powerFloat# a2 b2) (powerFloat# a3 b3)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3++instance PrimBytes FloatX3 where++    getBytes (FloatX3# a1 a2 a3) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @FloatX3 undefined) s0 of+           (# s1, marr #) -> case writeFloatArray# marr 0# a1 s1 of+             s2 -> case writeFloatArray# marr 1# a2 s2 of+               s3 -> case writeFloatArray# marr 2# a3 s3 of+                 s4 -> unsafeFreezeByteArray# marr s4+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = FloatX3#+      (indexFloatArray# arr i)+      (indexFloatArray# arr (i +# 1#))+      (indexFloatArray# arr (i +# 2#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (FloatX3# a1 a2 a3) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeFloatArray# mba (i +# 2#) a3+      ( writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s ))+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readFloatOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readFloatOffAddr# addr 1# s1 of+        (# s2, a2 #) -> case readFloatOffAddr# addr 2# s2 of+          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)+    {-# INLINE readAddr #-}++    writeAddr (FloatX3# a1 a2 a3) addr s+      = writeFloatOffAddr# addr 2# a3+      ( writeFloatOffAddr# addr 1# a2+      ( writeFloatOffAddr# addr 0# a1 s ))+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Float undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Float undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = FloatX3#+      (indexFloatArray# ba i)+      (indexFloatArray# ba (i +# 1#))+      (indexFloatArray# ba (i +# 2#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)+    {-# INLINE readArray #-}++    writeArray mba off (FloatX3# a1 a2 a3) s+      | i <- off *# ELEM_N#+      = writeFloatArray# mba (i +# 2#) a3+      ( writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s ))+    {-# INLINE writeArray #-}+++instance PrimArray Float FloatX3 where++    broadcast (F# x) = FloatX3# x x x+    {-# INLINE broadcast #-}++    ix# 0# (FloatX3# a1 _ _) = F# a1+    ix# 1# (FloatX3# _ a2 _) = F# a2+    ix# 2# (FloatX3# _ _ a3) = F# a3+    ix# _   _                = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, F# a1 #) -> case f s1 of+        (# s2, F# a2 #) -> case f s2 of+          (# s3, F# a3 #) -> (# s3, FloatX3# a1 a2 a3 #)+++    upd# _ 0# (F# q) (FloatX3# _ y z) = FloatX3# q y z+    upd# _ 1# (F# q) (FloatX3# x _ z) = FloatX3# x q z+    upd# _ 2# (F# q) (FloatX3# x y _) = FloatX3# x y q+    upd# _ _ _ x                      = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = FloatX3#+      (indexFloatArray# ba off)+      (indexFloatArray# ba (off +# 1#))+      (indexFloatArray# ba (off +# 2#))+    {-# INLINE fromElems #-}

@@ -0,0 +1,498 @@+{-# LANGUAGE CPP                   #-}+{-# LANGUAGE DataKinds             #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MagicHash             #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE UnboxedSums           #-}+{-# 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+++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 = case maxBound of F# x -> FloatX4# x x x x+    minBound = case minBound of F# x -> FloatX4# x x x x+++instance Eq FloatX4 where++    FloatX4# a1 a2 a3 a4 == FloatX4# b1 b2 b3 b4 =+      isTrue#+      (       (a1 `eqFloat#` b1)+      `andI#` (a2 `eqFloat#` b2)+      `andI#` (a3 `eqFloat#` b3)+      `andI#` (a4 `eqFloat#` b4)+      )+    {-# INLINE (==) #-}++    FloatX4# a1 a2 a3 a4 /= FloatX4# b1 b2 b3 b4 =+      isTrue#+      (      (a1 `neFloat#` b1)+      `orI#` (a2 `neFloat#` b2)+      `orI#` (a3 `neFloat#` b3)+      `orI#` (a4 `neFloat#` b4)+      )+    {-# INLINE (/=) #-}+++++cmp' :: Float# -> Float# -> PartialOrdering+cmp' a b+  | isTrue# (a `gtFloat#` b) = PGT+  | isTrue# (a `ltFloat#` b) = PLT+  | otherwise  = PEQ++instance ProductOrder FloatX4 where+    cmp (FloatX4# a1 a2 a3 a4) (FloatX4# b1 b2 b3 b4)+      = cmp' a1 b1 <> cmp' a2 b2 <> cmp' a3 b3 <> cmp' a4 b4+    {-# INLINE cmp #-}++instance Ord (NonTransitive.ProductOrd FloatX4) where+    NonTransitive.ProductOrd x > NonTransitive.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    NonTransitive.ProductOrd x < NonTransitive.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (NonTransitive.ProductOrd (FloatX4# a1 a2 a3 a4))+         (NonTransitive.ProductOrd (FloatX4# b1 b2 b3 b4)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2) `andI#` (a3 `geFloat#` b3) `andI#` (a4 `geFloat#` b4))+    {-# INLINE (>=) #-}+    (<=) (NonTransitive.ProductOrd (FloatX4# a1 a2 a3 a4))+         (NonTransitive.ProductOrd (FloatX4# b1 b2 b3 b4)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2) `andI#` (a3 `leFloat#` b3) `andI#` (a4 `leFloat#` b4))+    {-# INLINE (<=) #-}+    compare (NonTransitive.ProductOrd a) (NonTransitive.ProductOrd b)+      = NonTransitive.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (NonTransitive.ProductOrd (FloatX4# a1 a2 a3 a4))+        (NonTransitive.ProductOrd (FloatX4# b1 b2 b3 b4))+      = NonTransitive.ProductOrd+        ( FloatX4#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `gtFloat#` b3) then b3 else a3)+          (if isTrue# (a4 `gtFloat#` b4) then b4 else a4)+        )+    {-# INLINE min #-}+    max (NonTransitive.ProductOrd (FloatX4# a1 a2 a3 a4))+        (NonTransitive.ProductOrd (FloatX4# b1 b2 b3 b4))+      = NonTransitive.ProductOrd+        ( FloatX4#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `ltFloat#` b3) then b3 else a3)+          (if isTrue# (a4 `ltFloat#` b4) then b4 else a4)+        )+    {-# INLINE max #-}++instance Ord (Partial.ProductOrd FloatX4) where+    Partial.ProductOrd x > Partial.ProductOrd y = cmp x y == PGT+    {-# INLINE (>) #-}+    Partial.ProductOrd x < Partial.ProductOrd y = cmp x y == PLT+    {-# INLINE (<) #-}+    (>=) (Partial.ProductOrd (FloatX4# a1 a2 a3 a4))+         (Partial.ProductOrd (FloatX4# b1 b2 b3 b4)) = isTrue#+      ((a1 `geFloat#` b1) `andI#` (a2 `geFloat#` b2) `andI#` (a3 `geFloat#` b3) `andI#` (a4 `geFloat#` b4))+    {-# INLINE (>=) #-}+    (<=) (Partial.ProductOrd (FloatX4# a1 a2 a3 a4))+         (Partial.ProductOrd (FloatX4# b1 b2 b3 b4)) = isTrue#+      ((a1 `leFloat#` b1) `andI#` (a2 `leFloat#` b2) `andI#` (a3 `leFloat#` b3) `andI#` (a4 `leFloat#` b4))+    {-# INLINE (<=) #-}+    compare (Partial.ProductOrd a) (Partial.ProductOrd b)+      = Partial.toOrdering $ cmp a b+    {-# INLINE compare #-}+    min (Partial.ProductOrd (FloatX4# a1 a2 a3 a4))+        (Partial.ProductOrd (FloatX4# b1 b2 b3 b4))+      = Partial.ProductOrd+        ( FloatX4#+          (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `gtFloat#` b3) then b3 else a3)+          (if isTrue# (a4 `gtFloat#` b4) then b4 else a4)+        )+    {-# INLINE min #-}+    max (Partial.ProductOrd (FloatX4# a1 a2 a3 a4))+        (Partial.ProductOrd (FloatX4# b1 b2 b3 b4))+      = Partial.ProductOrd+        ( FloatX4#+          (if isTrue# (a1 `ltFloat#` b1) then b1 else a1)+          (if isTrue# (a2 `ltFloat#` b2) then b2 else a2)+          (if isTrue# (a3 `ltFloat#` b3) then b3 else a3)+          (if isTrue# (a4 `ltFloat#` b4) then b4 else a4)+        )+    {-# INLINE max #-}++instance Ord FloatX4 where+    FloatX4# a1 a2 a3 a4 > FloatX4# b1 b2 b3 b4+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a2 `gtFloat#` b2) = True+      | isTrue# (a2 `ltFloat#` b2) = False+      | isTrue# (a3 `gtFloat#` b3) = True+      | isTrue# (a3 `ltFloat#` b3) = False+      | isTrue# (a4 `gtFloat#` b4) = True+      | otherwise           = False+    {-# INLINE (>) #-}++    FloatX4# a1 a2 a3 a4 < FloatX4# b1 b2 b3 b4+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a2 `ltFloat#` b2) = True+      | isTrue# (a2 `gtFloat#` b2) = False+      | isTrue# (a3 `ltFloat#` b3) = True+      | isTrue# (a3 `gtFloat#` b3) = False+      | isTrue# (a4 `ltFloat#` b4) = True+      | otherwise           = False+    {-# INLINE (<) #-}++    FloatX4# a1 a2 a3 a4 >= FloatX4# b1 b2 b3 b4+      | isTrue# (a1 `ltFloat#` b1) = False+      | isTrue# (a1 `gtFloat#` b1) = True+      | isTrue# (a2 `ltFloat#` b2) = False+      | isTrue# (a2 `gtFloat#` b2) = True+      | isTrue# (a3 `ltFloat#` b3) = False+      | isTrue# (a3 `gtFloat#` b3) = True+      | isTrue# (a4 `ltFloat#` b4) = False+      | otherwise           = True+    {-# INLINE (>=) #-}++    FloatX4# a1 a2 a3 a4 <= FloatX4# b1 b2 b3 b4+      | isTrue# (a1 `gtFloat#` b1) = False+      | isTrue# (a1 `ltFloat#` b1) = True+      | isTrue# (a2 `gtFloat#` b2) = False+      | isTrue# (a2 `ltFloat#` b2) = True+      | isTrue# (a3 `gtFloat#` b3) = False+      | isTrue# (a3 `ltFloat#` b3) = True+      | isTrue# (a4 `gtFloat#` b4) = False+      | otherwise           = True+    {-# INLINE (<=) #-}++    compare (FloatX4# a1 a2 a3 a4) (FloatX4# b1 b2 b3 b4)+      | isTrue# (a1 `gtFloat#` b1) = GT+      | isTrue# (a1 `ltFloat#` b1) = LT+      | isTrue# (a2 `gtFloat#` b2) = GT+      | isTrue# (a2 `ltFloat#` b2) = LT+      | isTrue# (a3 `gtFloat#` b3) = GT+      | isTrue# (a3 `ltFloat#` b3) = LT+      | isTrue# (a4 `gtFloat#` b4) = GT+      | isTrue# (a4 `ltFloat#` b4) = LT+      | otherwise           = EQ+    {-# INLINE compare #-}+++-- | element-wise operations for vectors+instance Num FloatX4 where++    FloatX4# a1 a2 a3 a4 + FloatX4# b1 b2 b3 b4+      = FloatX4# (plusFloat# a1 b1) (plusFloat# a2 b2) (plusFloat# a3 b3) (plusFloat# a4 b4)+    {-# INLINE (+) #-}++    FloatX4# a1 a2 a3 a4 - FloatX4# b1 b2 b3 b4+      = FloatX4# (minusFloat# a1 b1) (minusFloat# a2 b2) (minusFloat# a3 b3) (minusFloat# a4 b4)+    {-# INLINE (-) #-}++    FloatX4# a1 a2 a3 a4 * FloatX4# b1 b2 b3 b4+      = FloatX4# (timesFloat# a1 b1) (timesFloat# a2 b2) (timesFloat# a3 b3) (timesFloat# a4 b4)+    {-# INLINE (*) #-}++    negate (FloatX4# a1 a2 a3 a4) = FloatX4#+      (negateFloat# a1) (negateFloat# a2) (negateFloat# a3) (negateFloat# a4)+    {-# INLINE negate #-}++    abs (FloatX4# a1 a2 a3 a4)+      = FloatX4#+      (if isTrue# (a1 `geFloat#` 0.0#) then a1 else negateFloat# a1)+      (if isTrue# (a2 `geFloat#` 0.0#) then a2 else negateFloat# a2)+      (if isTrue# (a3 `geFloat#` 0.0#) then a3 else negateFloat# a3)+      (if isTrue# (a4 `geFloat#` 0.0#) then a4 else negateFloat# a4)+    {-# INLINE abs #-}++    signum (FloatX4# a1 a2 a3 a4)+      = FloatX4# (if isTrue# (a1 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a1 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a2 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a2 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a3 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a3 `ltFloat#` 0.0#) then -1.0# else 0.0# )+                 (if isTrue# (a4 `gtFloat#` 0.0#)+                  then 1.0#+                  else if isTrue# (a4 `ltFloat#` 0.0#) then -1.0# else 0.0# )+    {-# INLINE signum #-}++    fromInteger n = case fromInteger n of F# x -> FloatX4# x x x x+    {-# INLINE fromInteger #-}++++instance Fractional FloatX4 where++    FloatX4# a1 a2 a3 a4 / FloatX4# b1 b2 b3 b4 = FloatX4#+      (divideFloat# a1 b1) (divideFloat# a2 b2) (divideFloat# a3 b3) (divideFloat# a4 b4)+    {-# INLINE (/) #-}++    recip (FloatX4# a1 a2 a3 a4) = FloatX4#+      (divideFloat# 1.0# a1) (divideFloat# 1.0# a2) (divideFloat# 1.0# a3) (divideFloat# 1.0# a4)+    {-# INLINE recip #-}++    fromRational r = case fromRational r of F# x -> FloatX4# x x x x+    {-# INLINE fromRational #-}++++instance Floating FloatX4 where++    pi = FloatX4#+      3.141592653589793238#+      3.141592653589793238#+      3.141592653589793238#+      3.141592653589793238#+    {-# INLINE pi #-}++    exp (FloatX4# a1 a2 a3 a4) = FloatX4#+      (expFloat# a1) (expFloat# a2) (expFloat# a3) (expFloat# a4)+    {-# INLINE exp #-}++    log (FloatX4# a1 a2 a3 a4) = FloatX4#+      (logFloat# a1) (logFloat# a2) (logFloat# a3) (logFloat# a4)+    {-# INLINE log #-}++    sqrt (FloatX4# a1 a2 a3 a4) = FloatX4#+      (sqrtFloat# a1) (sqrtFloat# a2) (sqrtFloat# a3) (sqrtFloat# a4)+    {-# INLINE sqrt #-}++    sin (FloatX4# a1 a2 a3 a4) = FloatX4#+      (sinFloat# a1) (sinFloat# a2) (sinFloat# a3) (sinFloat# a4)+    {-# INLINE sin #-}++    cos (FloatX4# a1 a2 a3 a4) = FloatX4#+      (cosFloat# a1) (cosFloat# a2) (cosFloat# a3) (cosFloat# a4)+    {-# INLINE cos #-}++    tan (FloatX4# a1 a2 a3 a4) = FloatX4#+      (tanFloat# a1) (tanFloat# a2) (tanFloat# a3) (tanFloat# a4)+    {-# INLINE tan #-}++    asin (FloatX4# a1 a2 a3 a4) = FloatX4#+      (asinFloat# a1) (asinFloat# a2) (asinFloat# a3) (asinFloat# a4)+    {-# INLINE asin #-}++    acos (FloatX4# a1 a2 a3 a4) = FloatX4#+      (acosFloat# a1) (acosFloat# a2) (acosFloat# a3) (acosFloat# a4)+    {-# INLINE acos #-}++    atan (FloatX4# a1 a2 a3 a4) = FloatX4#+      (atanFloat# a1) (atanFloat# a2) (atanFloat# a3) (atanFloat# a4)+    {-# INLINE atan #-}++    sinh (FloatX4# a1 a2 a3 a4) = FloatX4#+      (sinhFloat# a1) (sinhFloat# a2) (sinhFloat# a3) (sinhFloat# a4)+    {-# INLINE sinh #-}++    cosh (FloatX4# a1 a2 a3 a4) = FloatX4#+      (coshFloat# a1) (coshFloat# a2) (coshFloat# a3) (coshFloat# a4)+    {-# INLINE cosh #-}++    tanh (FloatX4# a1 a2 a3 a4) = FloatX4#+      (tanhFloat# a1) (tanhFloat# a2) (tanhFloat# a3) (tanhFloat# a4)+    {-# INLINE tanh #-}++    FloatX4# a1 a2 a3 a4 ** FloatX4# b1 b2 b3 b4 = FloatX4#+      (powerFloat# a1 b1) (powerFloat# a2 b2) (powerFloat# a3 b3) (powerFloat# a4 b4)+    {-# INLINE (**) #-}++    logBase x y         =  log y / log x+    {-# INLINE logBase #-}++    asinh x = log (x + sqrt (1.0+x*x))+    {-# INLINE asinh #-}++    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))+    {-# INLINE acosh #-}++    atanh x = 0.5 * log ((1.0+x) / (1.0-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# a1 a2 a3 a4) = case runRW#+       ( \s0 -> case newByteArray# (byteSize @FloatX4 undefined) s0 of+           (# s1, marr #) -> case writeFloatArray# marr 0# a1 s1 of+             s2 -> case writeFloatArray# marr 1# a2 s2 of+               s3 -> case writeFloatArray# marr 2# a3 s3 of+                 s4 -> case writeFloatArray# marr 3# a4 s4 of+                   s5 -> unsafeFreezeByteArray# marr s5+       ) of (# _, a #) -> a+    {-# INLINE getBytes #-}++    fromBytes off arr+      | i <- BOFF_TO_PRIMOFF(off)+      = FloatX4#+      (indexFloatArray# arr i)+      (indexFloatArray# arr (i +# 1#))+      (indexFloatArray# arr (i +# 2#))+      (indexFloatArray# arr (i +# 3#))+    {-# INLINE fromBytes #-}++    readBytes mba off s0+      | i <- BOFF_TO_PRIMOFF(off)+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> case readFloatArray# mba (i +# 3#) s3 of+            (# s4, a4 #) -> (# s4, FloatX4# a1 a2 a3 a4 #)+    {-# INLINE readBytes #-}++    writeBytes mba off (FloatX4# a1 a2 a3 a4) s+      | i <- BOFF_TO_PRIMOFF(off)+      = writeFloatArray# mba (i +# 3#) a4+      ( writeFloatArray# mba (i +# 2#) a3+      ( writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s )))+    {-# INLINE writeBytes #-}++    readAddr addr s0+      = case readFloatOffAddr# addr 0# s0 of+      (# s1, a1 #) -> case readFloatOffAddr# addr 1# s1 of+        (# s2, a2 #) -> case readFloatOffAddr# addr 2# s2 of+          (# s3, a3 #) -> case readFloatOffAddr# addr 3# s3 of+            (# s4, a4 #) -> (# s4, FloatX4# a1 a2 a3 a4 #)+    {-# INLINE readAddr #-}++    writeAddr (FloatX4# a1 a2 a3 a4) addr s+      = writeFloatOffAddr# addr 3# a4+      ( writeFloatOffAddr# addr 2# a3+      ( writeFloatOffAddr# addr 1# a2+      ( writeFloatOffAddr# addr 0# a1 s )))+    {-# INLINE writeAddr #-}++    byteSize _ = byteSize @Float undefined *# ELEM_N#+    {-# INLINE byteSize #-}++    byteAlign _ = byteAlign @Float undefined+    {-# INLINE byteAlign #-}++    byteOffset _ = 0#+    {-# INLINE byteOffset #-}++    byteFieldOffset _ _ = negateInt# 1#+    {-# INLINE byteFieldOffset #-}++    indexArray ba off+      | i <- off *# ELEM_N#+      = FloatX4#+      (indexFloatArray# ba i)+      (indexFloatArray# ba (i +# 1#))+      (indexFloatArray# ba (i +# 2#))+      (indexFloatArray# ba (i +# 3#))+    {-# INLINE indexArray #-}++    readArray mba off s0+      | i <- off *# ELEM_N#+      = case readFloatArray# mba i s0 of+      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of+        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of+          (# s3, a3 #) -> case readFloatArray# mba (i +# 3#) s3 of+            (# s4, a4 #) -> (# s4, FloatX4# a1 a2 a3 a4 #)+    {-# INLINE readArray #-}++    writeArray mba off (FloatX4# a1 a2 a3 a4) s+      | i <- off *# ELEM_N#+      = writeFloatArray# mba (i +# 3#) a4+      ( writeFloatArray# mba (i +# 2#) a3+      ( writeFloatArray# mba (i +# 1#) a2+      ( writeFloatArray# mba  i        a1 s )))+    {-# INLINE writeArray #-}+++instance PrimArray Float FloatX4 where++    broadcast (F# x) = FloatX4# x x x x+    {-# INLINE broadcast #-}++    ix# 0# (FloatX4# a1 _ _ _) = F# a1+    ix# 1# (FloatX4# _ a2 _ _) = F# a2+    ix# 2# (FloatX4# _ _ a3 _) = F# a3+    ix# 3# (FloatX4# _ _ _ a4) = F# a4+    ix# _   _                  = undefined+    {-# INLINE ix# #-}++    gen# _ f s0 = case f s0 of+      (# s1, F# a1 #) -> case f s1 of+        (# s2, F# a2 #) -> case f s2 of+          (# s3, F# a3 #) -> case f s3 of+            (# s4, F# a4 #) -> (# s4, FloatX4# a1 a2 a3 a4 #)+++    upd# _ 0# (F# q) (FloatX4# _ y z w) = FloatX4# q y z w+    upd# _ 1# (F# q) (FloatX4# x _ z w) = FloatX4# x q z w+    upd# _ 2# (F# q) (FloatX4# x y _ w) = FloatX4# x y q w+    upd# _ 3# (F# q) (FloatX4# x y z _) = FloatX4# x y z q+    upd# _ _ _ x                        = x+    {-# INLINE upd# #-}++    arrayContent# x = (# | (# CumulDims [ELEM_N, 1], 0#, getBytes x #) #)+    {-# INLINE arrayContent# #-}++    offsetElems _ = 0#+    {-# INLINE offsetElems #-}++    uniqueOrCumulDims _ = Right (CumulDims [ELEM_N, 1])+    {-# INLINE uniqueOrCumulDims #-}++    fromElems _ off ba = FloatX4#+      (indexFloatArray# ba off)+      (indexFloatArray# ba (off +# 1#))+      (indexFloatArray# ba (off +# 2#))+      (indexFloatArray# ba (off +# 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 is = case unsafeCoerce# is of+  [W# i] -> word2Int# i+  _      -> 0#+{-# INLINE getIdxOffset #-}+++{-# RULES+"index/FloatX4" forall i . index @Float @'[4] i+  = unsafeCoerce# (ix# @Float @FloatX4 (getIdxOffset i))++  #-}

@@ -0,0 +1,50 @@+{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MagicHash                  #-}+{-# LANGUAGE MultiParamTypeClasses      #-}+{-# LANGUAGE StandaloneDeriving         #-}+{-# LANGUAGE TypeInType                 #-}+{-# LANGUAGE UnboxedSums                #-}+{-# LANGUAGE UnboxedTuples              #-}+module Numeric.DataFrame.Internal.Backend.Family.ScalarBase (ScalarBase (..)) 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++-- | Specialize ScalarBase type without any arrays+newtype ScalarBase t = ScalarBase { _unScalarBase :: t }+  deriving ( Enum, Eq, Bounded, Integral+           , Num, Fractional, Floating, Ord, Real, RealFrac, RealFloat+           , PrimBytes)++instance Ord t => ProductOrder (ScalarBase t) where+  cmp a b = fromOrdering (compare (_unScalarBase a) (_unScalarBase b))+deriving instance Ord t => Ord (NonTransitive.ProductOrd (ScalarBase t))+deriving instance Ord t => Ord (Partial.ProductOrd (ScalarBase t))++instance PrimBytes t => PrimArray t (ScalarBase t) where+  broadcast = unsafeCoerce#+  {-# INLINE broadcast #-}+  ix# _ = unsafeCoerce#+  {-# INLINE ix# #-}+  gen# _ = unsafeCoerce#+  {-# INLINE gen# #-}+  upd# _ 0# = const . ScalarBase+  upd# _ _  = const id+  {-# INLINE upd# #-}+  arrayContent# x = (# _unScalarBase x | #)+  {-# INLINE arrayContent# #-}+  offsetElems _ = 0#+  {-# INLINE offsetElems #-}+  uniqueOrCumulDims = Left . _unScalarBase+  {-# INLINE uniqueOrCumulDims #-}+  fromElems _ off ba = indexArray ba off+  {-# INLINE fromElems #-}++_suppressHlintUnboxedTuplesWarning :: () -> (# (), () #)+_suppressHlintUnboxedTuplesWarning = undefined

@@ -1,5 +1,3 @@-{-# LANGUAGE PatternSynonyms #-}- module Numeric.DataFrame   ( module Numeric.DataFrame.Type     -- * Simplified type aliases@@ -9,16 +7,14 @@     -- * Functionality   , module Numeric.DataFrame.SubSpace   , module Numeric.DataFrame.Contraction-  , module Numeric.DataFrame.Shape   ) where -import           Numeric.DataFrame.Internal.Array ()+import Numeric.DataFrame.Internal.Backend () -import           Numeric.DataFrame.Contraction-import           Numeric.DataFrame.Shape-import           Numeric.DataFrame.SubSpace-import           Numeric.DataFrame.Type+import Numeric.DataFrame.Contraction+import Numeric.DataFrame.SubSpace+import Numeric.DataFrame.Type -import           Numeric.Matrix-import           Numeric.Scalar-import           Numeric.Vector+import Numeric.Matrix+import Numeric.Scalar+import Numeric.Vector

@@ -30,11 +30,11 @@   ( Contraction (..), (%*)   ) where -import           GHC.Base+import GHC.Base -import           Numeric.DataFrame.Family-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.Dimensions+import Numeric.DataFrame.Internal.PrimArray+import Numeric.DataFrame.Type+import Numeric.Dimensions   @@ -55,13 +55,12 @@ --     1. matrix-matrix product --     2. matrix-vector or vector-matrix product --     3. dot product of two vectors.-(%*) :: ( ConcatList as bs (as ++ bs)-        , Contraction t as bs asbs+(%*) :: ( Contraction t as bs asbs         , KnownDim m         , PrimArray t (DataFrame t (as +: m))         , PrimArray t (DataFrame t (m :+ bs))-        , PrimArray t (DataFrame t (as ++ bs))-        )  => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t (as ++ bs)+        , PrimArray t (DataFrame t asbs)+        )  => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs (%*) = contract {-# INLINE (%*) #-} infixl 7 %*@@ -73,6 +72,7 @@          , Dimensions bs          , Num t          ) => Contraction t as bs asbs where+     contract :: forall m .                 ( KnownDim m                 , PrimArray t (DataFrame t (as +: m))@@ -80,19 +80,40 @@                 , PrimArray t (DataFrame t asbs)                 )              => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs-    contract x y-        | I# m <- fromIntegral $ dimVal' @m-        , I# n <- fromIntegral $ totalDim' @as-        , I# k <- fromIntegral $ totalDim' @bs-        , nk <- n *# k-        = let loop i j l r | isTrue# (l ==# m) = r+    contract x y = case (# uniqueOrCumulDims x, uniqueOrCumulDims y #) of+      (# Left x0, Left y0 #) -> broadcast (x0 * y0)+      (# ux, uy #)+        | dm <- dim @m+        , (ixX, xs) <- getStepsAndIx (Snoc dims dm) x ux+        , (ixY, ys) <- getStepsAndIx (Cons dm dims) y uy+        , (# n, m, k, steps #) <- conSteps xs ys ->+          let loop i j l r | isTrue# (l ==# m) = r                            | otherwise = loop i j (l +# 1#)-                              (r + ix# (i +# n *# l) x * ix# (l +# m *# j) y)+                              (r + ixX (i *# m +# l) * ixY (l *# k +# j)) -              loop2 (T# i j) | isTrue# (j ==# k) = (# T# i j, 0 #)-                             | isTrue# (i ==# n) = loop2 (T# 0# (j +# 1#))-                             | otherwise = (# T# (i +# 1#) j, loop i j 0# 0 #)-          in case gen# nk loop2 (T# 0# 0#) of+              loop2 (T# i j) | isTrue# (i ==# n) = (# T# i j, 0 #)+                             | isTrue# (j ==# k) = loop2 (T# (i +# 1#) 0#)+                             | otherwise = (# T# i (j +# 1#), loop i j 0# 0 #)+          in case gen# steps loop2 (T# 0# 0#) of               (# _, r #) -> r+      where+        getStepsAndIx :: forall (ns :: [Nat])+                       . PrimArray t (DataFrame t ns)+                      => Dims ns+                      -> DataFrame t ns+                      -> Either t CumulDims+                      -> (Int# -> t, CumulDims)+        getStepsAndIx _  df (Right cds) = ((`ix#` df), cds)+        getStepsAndIx ds _  (Left  e)   = (\_ -> e, cumulDims ds)+        conSteps (CumulDims xs) (CumulDims ys) = case conSteps' xs ys of+          (W# n, W# m, W# k, zs)+            -> (# word2Int# n, word2Int# m, word2Int# k, CumulDims zs #)+        conSteps' :: [Word] -> [Word] -> (Word, Word, Word, [Word])+        conSteps' [m, _] (_:ys@(k:_)) = (1, m, k, ys)+        conSteps' (nm:ns) cys+          | (_, m, k, ys) <- conSteps' ns cys+          , n <- nm `quot` m+            = (n, m, k, n*k : ys )+        conSteps' _ _ = error "Numeric.DataFrame.Contraction: impossible match"  data T# = T# Int# Int#

@@ -1,9 +0,0 @@-{-# LANGUAGE DataKinds    #-}-{-# LANGUAGE PolyKinds    #-}-{-# LANGUAGE TypeFamilies #-}--- | The very core of DataFrame: definition of the data family.-module Numeric.DataFrame.Family ( DataFrame ) where---- | Keep data in a primitive data frame---    and maintain information about Dimensions in the type system-data family DataFrame (t :: l) (xs :: [k])

@@ -2,7 +2,6 @@ {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE FlexibleContexts          #-} {-# LANGUAGE FlexibleInstances         #-}-{-# LANGUAGE KindSignatures            #-} {-# LANGUAGE MagicHash                 #-} {-# LANGUAGE MultiParamTypeClasses     #-} {-# LANGUAGE PolyKinds                 #-}@@ -17,8 +16,6 @@ -- Copyright   :  (c) Artem Chirkin -- License     :  BSD3 ----- Maintainer  :  chirkin@arch.ethz.ch--- -- Mutable DataFrames living in IO. -- -----------------------------------------------------------------------------@@ -27,6 +24,7 @@     ( IODataFrame (XIOFrame), SomeIODataFrame (..)     , newDataFrame, newPinnedDataFrame     , copyDataFrame, copyMutableDataFrame+    , copyDataFrame', copyMutableDataFrame'     , freezeDataFrame, unsafeFreezeDataFrame     , thawDataFrame, thawPinDataFrame, unsafeThawDataFrame     , writeDataFrame, writeDataFrameOff@@ -35,15 +33,14 @@     ) where  -import           GHC.Base-import           GHC.IO                                 (IO (..))-import           GHC.Ptr                                (Ptr (..))+import GHC.Base+import GHC.IO   (IO (..))+import GHC.Ptr  (Ptr (..)) -import           Numeric.DataFrame.Family-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Mutable-import           Numeric.Dimensions-import           Numeric.PrimBytes+import Numeric.DataFrame.Internal.Mutable+import Numeric.DataFrame.Internal.PrimArray+import Numeric.DataFrame.Type+import Numeric.Dimensions   -- | Mutable DataFrame that lives in IO.@@ -80,31 +77,69 @@   -- | Copy one DataFrame into another mutable DataFrame at specified position.-copyDataFrame :: forall (t :: Type) (as :: [Nat]) (b' :: Nat) (b :: Nat)-                                    (bs :: [Nat]) (asbs :: [Nat])-               . ( PrimBytes t-                 , PrimBytes (DataFrame t (as +: b'))+--+--   In contrast to @copyMDataFrame'@, this function allows to copy over a range of contiguous+--   indices over a single dimension.+--   For example, you can write a 3x4 matrix into a 7x4 matrix, starting at indices 0..3.+copyDataFrame :: forall (t :: Type)+                        (b :: Nat) (bi :: Nat) (bd :: Nat)+                        (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat])+               . ( b ~ (bi + bd - 1)+                 , PrimBytes t+                 , PrimBytes (DataFrame t (bd :+ bs))                  , ConcatList as (b :+ bs) asbs-                 , Dimensions (b :+ bs)                  )-               => DataFrame t (as +: b') -> Idxs (b :+ bs) -> IODataFrame t asbs -> IO ()-copyDataFrame df ei (IODataFrame mdf) = IO (copyDataFrame# df ei mdf)+              => Idxs (as +: bi) -> DataFrame t (bd :+ bs)+              -> IODataFrame t asbs -> IO ()+copyDataFrame ei df (IODataFrame mdf) = IO (copyDataFrame# ei df mdf) {-# INLINE copyDataFrame #-}  -- | Copy one mutable DataFrame into another mutable DataFrame at specified position.-copyMutableDataFrame :: forall (t :: Type) (as :: [Nat]) (b' :: Nat) (b :: Nat)-                               (bs :: [Nat]) (asbs :: [Nat])-                      . ( PrimBytes t+--+--   In contrast to @copyMDataFrame'@, this function allows to copy over a range of contiguous+--   indices over a single dimension.+--   For example, you can write a 3x4 matrix into a 7x4 matrix, starting at indices 0..3.+copyMutableDataFrame :: forall (t :: Type)+                               (b :: Nat) (bi :: Nat) (bd :: Nat)+                               (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat])+                      . ( b ~ (bi + bd - 1)+                        , PrimBytes t                         , ConcatList as (b :+ bs) asbs-                        , Dimensions (b :+ bs)                         )-                     => IODataFrame t (as +: b') -> Idxs (b :+ bs)+                     => Idxs (as +: bi) -> IODataFrame t (bd :+ bs)                      -> IODataFrame t asbs -> IO ()-copyMutableDataFrame (IODataFrame mdfA) ei (IODataFrame mdfB)-    = IO (copyMDataFrame# mdfA ei mdfB)+copyMutableDataFrame ei (IODataFrame mdfA) (IODataFrame mdfB)+    = IO (copyMDataFrame# ei mdfA mdfB) {-# INLINE copyMutableDataFrame #-} +-- | Copy one DataFrame into another mutable DataFrame at specified position.+--+--   This is a simpler version of @copyDataFrame@ that allows to copy over one index at a time.+copyDataFrame' :: forall (t :: Type)+                         (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat])+                . ( PrimBytes t+                  , PrimBytes (DataFrame t bs)+                  , ConcatList as bs asbs+                 )+               => Idxs as -> DataFrame t bs+               -> IODataFrame t asbs -> IO ()+copyDataFrame' ei df (IODataFrame mdf) = IO (copyDataFrame'# ei df mdf)+{-# INLINE copyDataFrame' #-} +-- | Copy one mutable DataFrame into another mutable DataFrame at specified position.+--+--   This is a simpler version of @copyDataFrame@ that allows to copy over one index at a time.+copyMutableDataFrame' :: forall (t :: Type)+                                (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat])+                       . ( PrimBytes t+                         , ConcatList as bs asbs+                         )+                      => Idxs as -> IODataFrame t bs+                      -> IODataFrame t asbs -> IO ()+copyMutableDataFrame' ei (IODataFrame mdfA) (IODataFrame mdfB)+  = IO (copyMDataFrame'# ei mdfA mdfB)+{-# INLINE copyMutableDataFrame' #-}+ -- | Make a mutable DataFrame immutable, without copying. unsafeFreezeDataFrame :: forall (t :: Type) (ns :: [Nat])                        . PrimArray t (DataFrame t ns)@@ -122,7 +157,7 @@  -- | Create a new mutable DataFrame and copy content of immutable one in there. thawDataFrame :: forall (t :: Type) (ns :: [Nat])-               . (PrimBytes (DataFrame t ns), PrimBytes t)+               . (Dimensions ns, PrimBytes (DataFrame t ns))               => DataFrame t ns -> IO (IODataFrame t ns) thawDataFrame df = IODataFrame <$> IO (thawDataFrame# df) {-# INLINE thawDataFrame #-}@@ -130,14 +165,15 @@ -- | Create a new mutable DataFrame and copy content of immutable one in there. --   The result array is pinned and aligned. thawPinDataFrame :: forall (t :: Type) (ns :: [Nat])-                  . (PrimBytes (DataFrame t ns), PrimBytes t)+                  . (Dimensions ns, PrimBytes (DataFrame t ns))                  => DataFrame t ns -> IO (IODataFrame t ns) thawPinDataFrame df = IODataFrame <$> IO (thawPinDataFrame# df) {-# INLINE thawPinDataFrame #-}  -- | UnsafeCoerces an underlying byte array. unsafeThawDataFrame :: forall (t :: Type) (ns :: [Nat])-                     . (PrimBytes (DataFrame t ns), PrimBytes t)+                     . ( Dimensions ns+                       , PrimBytes (DataFrame t ns), PrimBytes t)                     => DataFrame t ns -> IO (IODataFrame t ns) unsafeThawDataFrame df = IODataFrame <$> IO (unsafeThawDataFrame# df) {-# INLINE unsafeThawDataFrame #-}@@ -145,7 +181,7 @@  -- | Write a single element at the specified index writeDataFrame :: forall t (ns :: [Nat])-                . ( PrimBytes t, Dimensions ns )+                . PrimBytes t                => IODataFrame t ns -> Idxs ns -> DataFrame t ('[] :: [Nat]) -> IO () writeDataFrame (IODataFrame mdf) ei = IO . writeDataFrame# mdf ei . unsafeCoerce# {-# INLINE writeDataFrame #-}@@ -153,7 +189,7 @@  -- | Read a single element at the specified index readDataFrame :: forall (t :: Type) (ns :: [Nat])-               . ( PrimBytes t, Dimensions ns )+               . PrimBytes t               => IODataFrame t ns -> Idxs ns -> IO (DataFrame t ('[] :: [Nat])) readDataFrame (IODataFrame mdf) = unsafeCoerce# . IO . readDataFrame# mdf {-# INLINE readDataFrame #-}@@ -177,6 +213,18 @@ {-# INLINE readDataFrameOff #-}  +-- | Check if the byte array wrapped by this DataFrame is pinned,+--   which means cannot be relocated by GC.+isDataFramePinned :: forall (k :: Type) (t :: Type) (ns :: [k])+                   . KnownDimKind k+                  => IODataFrame t ns -> Bool+isDataFramePinned df = case dimKind @k of+    DimNat -> case df of+      IODataFrame x -> isDataFramePinned# x+    DimXNat -> case df of+      XIOFrame (IODataFrame x) -> isDataFramePinned# x++ -- | Allow arbitrary IO operations on a pointer to the beginning of the data --   keeping the data from garbage collecting until the arg function returns. --@@ -185,7 +233,7 @@ -- --   Warning: use this function on a pinned DataFrame only; --            otherwise, the data may be relocated before the arg fun finishes.-withDataFramePtr :: forall (t :: Type) (ns :: [k]) (r :: Type)+withDataFramePtr :: forall (k :: Type) (t :: Type) (ns :: [k]) (r :: Type)                   . (PrimBytes t, KnownDimKind k)                  => IODataFrame t ns                  -> ( Ptr t -> IO r )@@ -197,15 +245,3 @@     DimXNat -> case df of       XIOFrame (IODataFrame x)         -> IO $ withDataFramePtr# x (\p -> case k (Ptr p) of IO f -> f)----- | Check if the byte array wrapped by this DataFrame is pinned,---   which means cannot be relocated by GC.-isDataFramePinned :: forall (t :: Type) (ns :: [k])-                   . KnownDimKind k-                  => IODataFrame t ns -> Bool-isDataFramePinned df = case dimKind @k of-    DimNat -> case df of-      IODataFrame x -> isDataFramePinned# x-    DimXNat -> case df of-      XIOFrame (IODataFrame x) -> isDataFramePinned# x

@@ -1,26 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Numeric.DataFrame.Internal.Array--- Copyright   :  (c) Artem Chirkin--- License     :  BSD3------ Maintainer  :  chirkin@arch.ethz.ch------ Low-level implementations of data frames-----------------------------------------------------------------------------------module Numeric.DataFrame.Internal.Array-  ( module Numeric.DataFrame.Internal.Array.Family-  ) where--import           Numeric.DataFrame.Internal.Array.Family--- import           Numeric.DataFrame.Internal.Array.Family.ArrayBase ()---- import           Numeric.DataFrame.Internal.Array.Family.FloatX2   ()--- import           Numeric.DataFrame.Internal.Array.Family.FloatX3   ()--- import           Numeric.DataFrame.Internal.Array.Family.FloatX4   ()------ import           Numeric.DataFrame.Internal.Array.Family.DoubleX2  ()--- import           Numeric.DataFrame.Internal.Array.Family.DoubleX3  ()--- import           Numeric.DataFrame.Internal.Array.Family.DoubleX4  ()

@@ -1,51 +0,0 @@-{-# LANGUAGE DataKinds              #-}-{-# LANGUAGE FunctionalDependencies #-}-{-# LANGUAGE MagicHash              #-}-{-# LANGUAGE MultiParamTypeClasses  #-}-{-# LANGUAGE UnboxedTuples          #-}-module Numeric.DataFrame.Internal.Array.Class-  ( PrimArray (..)-  , ixOff, unsafeFromFlatList-  ) where--import           GHC.Base          (ByteArray#, Int#, Int (..))-import           Numeric.PrimBytes---class PrimBytes t => PrimArray t a | a -> t where-    -- | Broadcast element into array-    broadcast :: t -> a-    -- | Index an array given an offset-    ix# :: Int# -> a -> t-    -- | Generate an array using an accumulator funtion-    gen# :: Int# -- ^ number of elements, not checked!-                 --   Avoid using this argument if possible.-         -> (s -> (# s, t #))-         -> s -> (# s, a #)-    -- | update a single element in an array given an offset-    upd# :: Int# -- ^ number of elements, not checked!-                 --   Avoid using this argument if possible.-         -> Int# -> t -> a -> a--    -- | Offset of an array in number of elements-    elemOffset :: a -> Int#--    -- | Number of elements in an array.-    --   Returns zero if this information is not available at runtime.-    --   This is possible only if all elements are same in an array.-    elemSize0 :: a -> Int#--    -- | Get array by its offset and size in a ByteArray.-    --   Both offset and size are given in element number.-    fromElems :: Int# -> Int# -> ByteArray# -> a---- | Index array by an integer offset (starting from 0).-ixOff :: PrimArray t a => Int -> a -> t-ixOff (I# i) = ix# i---- | Construct an array from a flat list and length-unsafeFromFlatList :: PrimArray t a => Int -> [t] -> a-unsafeFromFlatList (I# n) vs = case gen# n f vs of (# _, r #) -> r-  where-    f [] = (# [], undefined #)-    f (x:xs) = (# xs, x #)

@@ -1,216 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes    #-}-{-# LANGUAGE CPP                    #-}-{-# LANGUAGE ConstraintKinds        #-}-{-# LANGUAGE DataKinds              #-}-{-# LANGUAGE FlexibleContexts       #-}-{-# LANGUAGE FlexibleInstances      #-}-{-# LANGUAGE GADTs                  #-}-{-# LANGUAGE MagicHash              #-}-{-# LANGUAGE MultiParamTypeClasses  #-}-{-# LANGUAGE PolyKinds              #-}-{-# LANGUAGE Rank2Types             #-}-{-# LANGUAGE ScopedTypeVariables    #-}-{-# LANGUAGE StandaloneDeriving     #-}-{-# LANGUAGE TypeApplications       #-}-{-# LANGUAGE TypeFamilies           #-}-{-# LANGUAGE TypeFamilyDependencies #-}-{-# LANGUAGE TypeInType             #-}-{-# LANGUAGE TypeOperators          #-}--------------------------------------------------------------------------------- |--- Module      :  Numeric.DataFrame.Internal.Array.Family--- Copyright   :  (c) Artem Chirkin--- License     :  BSD3------ Maintainer  :  chirkin@arch.ethz.ch--------------------------------------------------------------------------------------module Numeric.DataFrame.Internal.Array.Family-  ( Array, ScalarBase (..), ArrayBase (..)-  , ArraySingleton (..)-  , ArraySing (..), aSingEv, inferASing-  , inferPrimElem, inferPrim, inferEq, inferShow, inferOrd, inferNum-  , inferFractional, inferFloating-  ) where---import           GHC.Base---import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.Family.ArrayBase-import           Numeric.DataFrame.Internal.Array.Family.DoubleX2-import           Numeric.DataFrame.Internal.Array.Family.DoubleX3-import           Numeric.DataFrame.Internal.Array.Family.DoubleX4-import           Numeric.DataFrame.Internal.Array.Family.FloatX2-import           Numeric.DataFrame.Internal.Array.Family.FloatX3-import           Numeric.DataFrame.Internal.Array.Family.FloatX4-import           Numeric.DataFrame.Internal.Array.Family.ScalarBase-import           Numeric.Dimensions-import           Numeric.PrimBytes----- | This type family aggregates all types used for arrays with different---   dimensioinality.---   The family is injective; thus, it is possible to get type family instance---   given the data constructor (and vice versa).---   If GHC knows the dimensionality of an array at compile time, it chooses---   a more efficient specialized instance of Array, e.g. Scalar newtype wrapper.---   Otherwise, it falls back to the generic ArrayBase implementation.------   Data family would not work here, because it would give overlapping instances.-type family Array (t :: Type) (ds :: [Nat]) = (v :: Type) | v -> t ds where-    Array t      '[]    = ScalarBase t-    Array Float  '[2]   = FloatX2-    Array Float  '[3]   = FloatX3-    Array Float  '[4]   = FloatX4-    Array Double '[2]   = DoubleX2-    Array Double '[3]   = DoubleX3-    Array Double '[4]   = DoubleX4-    Array t       ds    = ArrayBase t ds---- | A framework for using Array type family instances.-class ArraySingleton (t :: Type) (ds :: [Nat]) where-    -- | Get Array type family instance-    aSing :: ArraySing t ds--data ArraySing t (ds :: [Nat]) where-    AScalar :: (Array t ds ~ ScalarBase t)   => ArraySing t      '[]-    AF2     :: (Array t ds ~ FloatX2)        => ArraySing Float  '[2]-    AF3     :: (Array t ds ~ FloatX3)        => ArraySing Float  '[3]-    AF4     :: (Array t ds ~ FloatX4)        => ArraySing Float  '[4]-    AD2     :: (Array t ds ~ DoubleX2)       => ArraySing Double '[2]-    AD3     :: (Array t ds ~ DoubleX3)       => ArraySing Double '[3]-    AD4     :: (Array t ds ~ DoubleX4)       => ArraySing Double '[4]-    ABase   :: ( Array t ds ~ ArrayBase t ds-               , PrimBytes t-               ) => ArraySing t ds--deriving instance Eq (ArraySing t ds)-deriving instance Ord (ArraySing t ds)-deriving instance Show (ArraySing t ds)------ | This function does GHC's magic to convert user-supplied `aSing` function---   to create an instance of `ArraySingleton` typeclass at runtime.---   The trick is taken from Edward Kmett's reflection library explained---   in https://www.schoolofhaskell.com/user/thoughtpolice/using-reflection-reifyArraySing :: forall r t ds-                . ArraySing t ds -> ( ArraySingleton t ds => r) -> r-reifyArraySing as k-  = unsafeCoerce# (MagicArraySing k :: MagicArraySing t ds r) as-{-# INLINE reifyArraySing #-}-newtype MagicArraySing t (ds :: [Nat]) r-  = MagicArraySing (ArraySingleton t ds => r)---- | Use `ArraySing` GADT to construct an `ArraySingleton` dictionary.---   In other words, bring an evidence of `ArraySingleton` instance into---   a scope at runtime.-aSingEv :: ArraySing t ds -> Evidence (ArraySingleton t ds)-aSingEv ds = reifyArraySing ds E-{-# INLINE aSingEv #-}---- | Use `ArraySing` GADT to construct an `ArraySingleton` dictionary.---   The same as `aSingEv`, but relies on `PrimBytes` and `Dimensions`.-inferASing :: forall t ds-            . (PrimBytes t, Dimensions ds)-           => Evidence (ArraySingleton t ds)-inferASing = case (dims @_ @ds, primTag @t undefined) of-  (U, _) -> E-  (d :* U, PTagFloat)-      | Just E <- sameDim (D @2) d -> E-      | Just E <- sameDim (D @3) d -> E-      | Just E <- sameDim (D @4) d -> E-  (d :* U, PTagDouble)-      | Just E <- sameDim (D @2) d -> E-      | Just E <- sameDim (D @3) d -> E-      | Just E <- sameDim (D @4) d -> E-  _ -> case (unsafeCoerce# (E @(ds ~ ds)) :: Evidence (ds ~ '[0])) of E -> E-{-# INLINE inferASing #-}---instance {-# OVERLAPPABLE #-}-         (Array t ds ~ ArrayBase t ds, PrimBytes t)-         => ArraySingleton t ds where-    aSing = ABase-instance {-# OVERLAPPING #-}  ArraySingleton t      '[]    where-    aSing = AScalar-instance {-# OVERLAPPING #-}  ArraySingleton Float  '[2]   where-    aSing = AF2-instance {-# OVERLAPPING #-}  ArraySingleton Float  '[3]   where-    aSing = AF3-instance {-# OVERLAPPING #-}  ArraySingleton Float  '[4]   where-    aSing = AF4-instance {-# OVERLAPPING #-}  ArraySingleton Double '[2]   where-    aSing = AD2-instance {-# OVERLAPPING #-}  ArraySingleton Double '[3]   where-    aSing = AD3-instance {-# OVERLAPPING #-}  ArraySingleton Double '[4]   where-    aSing = AD4---- | This is a special function, because Scalar does not require PrimBytes.---   That is why the dimension list in the argument is not empty.-inferPrimElem :: forall t d ds-               . ArraySingleton t (d ': ds)-              => Evidence (PrimBytes t)-inferPrimElem = case (aSing :: ArraySing t (d ': ds)) of-  AF2   -> E-  AF3   -> E-  AF4   -> E-  AD2   -> E-  AD3   -> E-  AD4   -> E-  ABase -> E---- Rather verbose way to show that there is an instance of a required type class--- for every instance of the type family.-#define WITNESS case (aSing :: ArraySing t ds) of {\-  AScalar -> E;\-  AF2     -> E;\-  AF3     -> E;\-  AF4     -> E;\-  AD2     -> E;\-  AD3     -> E;\-  AD4     -> E;\-  ABase   -> E}--inferPrim :: forall t ds-           . ( PrimBytes t-             , ArraySingleton t ds-             , Dimensions ds-             )-          => Evidence (PrimBytes (Array t ds), PrimArray t (Array t ds))-inferPrim = WITNESS--inferEq :: forall t ds-         . (Eq t, ArraySingleton t ds)-        => Evidence (Eq (Array t ds))-inferEq = WITNESS--inferOrd :: forall t ds-            . (Ord t, ArraySingleton t ds)-           => Evidence (Ord (Array t ds))-inferOrd = WITNESS--inferNum :: forall t ds-          . (Num t, ArraySingleton t ds)-         => Evidence (Num (Array t ds))-inferNum = WITNESS--inferFractional :: forall t ds-                 . (Fractional t, ArraySingleton t ds)-                => Evidence (Fractional (Array t ds))-inferFractional = WITNESS--inferFloating :: forall t ds-               . (Floating t, ArraySingleton t ds)-              => Evidence (Floating (Array t ds))-inferFloating = WITNESS--inferShow :: forall t ds-           . (Show t, Dimensions ds, ArraySingleton t ds)-          => Evidence (Show (Array t ds))-inferShow = WITNESS

@@ -1,498 +0,0 @@-{-# LANGUAGE ConstraintKinds           #-}-{-# LANGUAGE DataKinds                 #-}-{-# LANGUAGE ExistentialQuantification #-}-{-# LANGUAGE FlexibleContexts          #-}-{-# LANGUAGE FlexibleInstances         #-}-{-# LANGUAGE GADTs                     #-}-{-# LANGUAGE MagicHash                 #-}-{-# LANGUAGE MultiParamTypeClasses     #-}-{-# LANGUAGE PolyKinds                 #-}-{-# LANGUAGE Rank2Types                #-}-{-# LANGUAGE ScopedTypeVariables       #-}-{-# LANGUAGE TypeApplications          #-}-{-# LANGUAGE TypeFamilies              #-}-{-# LANGUAGE TypeFamilyDependencies    #-}-{-# LANGUAGE TypeInType                #-}-{-# LANGUAGE TypeOperators             #-}-{-# LANGUAGE UnboxedSums               #-}-{-# LANGUAGE UnboxedTuples             #-}--module Numeric.DataFrame.Internal.Array.Family.ArrayBase-  ( ArrayBase (..)-  ) where--import           Data.Int-import           Data.Word-import           GHC.Base                                 hiding (foldr)-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.Dimensions-import           Numeric.PrimBytes---- | Generic Array implementation.---   This array can reside in plain `ByteArray#` and can share the @ByteArray#@---   with other arrays.---   However, byte offset in the @ByteArray#@ must be multiple of the element size.-data ArrayBase (t :: Type) (ds :: [Nat])-  = ArrayBase-    (# t-       --  Same value for each element;-       --  this is the cheapest way to initialize an array.-       --  It is also used for Num instances to avoid dependency on Dimensions.-     | (# Int#  -- Offset measured in elements.-        , Int#  -- Number of elements.-        , ByteArray# -- Content.-        , Evidence (PrimBytes t)-        #)-     #)---instance (PrimBytes t, Dimensions ds) => PrimBytes (ArrayBase t ds) where-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Double ds) #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance Dimensions ds => PrimBytes (ArrayBase Word64 ds) #-}--    getBytes (ArrayBase a ) = case a of-        (# t | #)-          | W# nw <- totalDim' @ds-          , n <- word2Int# nw-          , tbs <- byteSize t   -> go tbs (tbs *# n) t-        (# | (# _, _, arr, _ #) #) ->-          -- very weird trick with touch# allows to workaround GHC bug-          --  "internal error: ARR_WORDS object entered!"-          -- TODO: report this-          case runRW# (\s -> (# touch# arr s, arr #)) of (# _, ba #) -> ba-      where-        go tbs bsize t = case runRW#-         ( \s0 -> case newByteArray# bsize s0 of-             (# s1, mba #) -> unsafeFreezeByteArray# mba-               ( loop# 0# tbs bsize (\i -> writeBytes mba i t) s1 )-         ) of (# _, ba #) -> ba-        {-# NOINLINE go #-}-    {-# INLINE getBytes #-}--    fromBytes bOff ba-      | W# nw <- totalDim' @ds-      , n <- word2Int# nw-      , tbs <- byteSize (undefined :: t)-      , (# offN, offRem #) <- quotRemInt# bOff tbs-      = case offRem of-          0# -> ArrayBase (# | (# offN, n , ba, E #) #)-          _  -> go n (tbs *# n)-      where-        go n bsize = case runRW#-         ( \s0 -> case ( if isTrue# (isByteArrayPinned# ba)-                         then newAlignedPinnedByteArray# bsize-                                (byteAlign @t undefined)-                         else newByteArray# bsize-                       ) s0-                  of-            (# s1, mba #) -> unsafeFreezeByteArray# mba-                              (copyByteArray# ba bOff mba 0# bsize s1)-         ) of (# _, r #) -> ArrayBase (# | (# 0# , n , r, E #) #)-        {-# NOINLINE go #-}-    {-# INLINE fromBytes #-}--    readBytes mba bOff s0-      | W# nw <- totalDim' @ds-      , n <- word2Int# nw-      , tbs <- byteSize (undefined :: t)-      , bsize <- tbs *# n-      = case newByteArray# bsize s0 of-         (# s1, mba1 #) -> case unsafeFreezeByteArray# mba1-                                (copyMutableByteArray# mba bOff mba1 0# bsize s1) of-           (# s2, ba #) -> (# s2, ArrayBase (# | (# 0# , n , ba, E #) #) #)-    {-# INLINE readBytes #-}--    writeBytes mba bOff (ArrayBase c)-      | tbs <- byteSize (undefined :: t) = case c of-        (# t | #) | W# n <- totalDim' @ds ->-          loop# bOff tbs (bOff +# word2Int# n *# tbs) (\i -> writeBytes mba i t)-        (# | (# offN, n, arr, _ #) #) ->-          copyByteArray# arr (offN *# tbs) mba bOff (n *# tbs)-    {-# INLINE writeBytes #-}--    readAddr addr s0-      | W# nw <- totalDim' @ds-      , n <- word2Int# nw-      , tbs <- byteSize (undefined :: t)-      , bsize <- tbs *# n-      = case newByteArray# bsize s0 of-         (# s1, mba1 #) -> case unsafeFreezeByteArray# mba1-                                (copyAddrToByteArray# addr mba1 0# bsize s1) of-           (# s2, ba #) -> (# s2, ArrayBase (# | (# 0# , n , ba, E #) #) #)-    {-# INLINE readAddr #-}--    writeAddr (ArrayBase c) addr-      | tbs <- byteSize (undefined :: t) = case c of-        (# t | #) | W# n <- totalDim' @ds ->-          loop# 0# tbs (word2Int# n *# tbs) (\i -> writeAddr t (plusAddr# addr i))-        (# | (# offN, n, arr, _ #) #) ->-          copyByteArrayToAddr# arr (offN *# tbs) addr (n *# tbs)-    {-# INLINE writeAddr #-}---    byteSize  _ = case totalDim' @ds of -- WARNING: slow!-      W# n -> byteSize (undefined :: t) *# word2Int# n-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign (undefined :: t)-    {-# INLINE byteAlign #-}--    byteOffset (ArrayBase a) = case a of-      (# _ | #)                  -> 0#-      (# | (# off, _, _, _ #) #) -> off *# byteSize (undefined :: t)-    {-# INLINE byteOffset #-}--    indexArray ba off-      | W# nw <- totalDim' @ds-      , n <- word2Int# nw-      = ArrayBase (# | (# off *# n, n, ba, E #) #)-    {-# INLINE indexArray #-}------ | Accumulates only idempotent operations!---   Being applied to FromScalars, executes only once!---   Here, idempotance means: assuming @f a b = g x@, @g (g x) = g x@------   Also, I assume the sizes of arrays are the same-accumV2Idempotent :: a-                  -> (t -> t -> a -> a)-                  -> ArrayBase t ds -> ArrayBase t ds -> a-accumV2Idempotent x f-  (ArrayBase (# a | #))-  (ArrayBase (# b | #))-    = f a b x-accumV2Idempotent x f-  a@(ArrayBase (# | (# _, nA, _, E #) #))-  b@(ArrayBase (# | (# _, nB, _, _ #) #))-    = loop1a# (minInt# nA nB) (\i -> f (ix# i a) (ix# i b)) x-accumV2Idempotent x f-    (ArrayBase (# a | #))-  b@(ArrayBase (# | (# _, n, _, E #) #))-    = loop1a# n (\i -> f a (ix# i b)) x-accumV2Idempotent x f-  a@(ArrayBase (# | (# _, n, _, E #) #))-    (ArrayBase (# b | #))-    = loop1a# n (\i -> f (ix# i a) b) x-{-# INLINE accumV2Idempotent #-}--mapV :: (t -> t) -> ArrayBase t ds -> ArrayBase t ds-mapV f (ArrayBase (# t | #))-    = ArrayBase (# f t | #)-mapV f x@(ArrayBase (# | (# offN, n, ba, E #) #))-    | tbs <- byteSize (undefEl x)-    = go (tbs *# n)-  where-    go bsize = case runRW#-     ( \s0 -> case newByteArray# bsize s0 of-         (# s1, mba #) -> unsafeFreezeByteArray# mba-           ( loop1# n-               (\i -> writeArray mba i (f (indexArray ba (offN +# i)))) s1-           )-     ) of (# _, r #) -> ArrayBase (# | (# 0#, n, r, E #) #)-    {-# NOINLINE go #-}-{-# INLINE mapV #-}---zipV :: (t -> t -> t)-     -> ArrayBase t ds -> ArrayBase t ds -> ArrayBase t ds-zipV f (ArrayBase (# x | #)) b = mapV (f x) b-zipV f a (ArrayBase (# y | #)) = mapV (`f` y) a-zipV f a@(ArrayBase (# | (# oa, na, ba, E #) #))-         (ArrayBase (# | (# ob, nb, bb, _ #) #))-    | n <- minInt# na nb-    = go n (byteSize (undefEl a) *# n)-  where-    go n bsize = case runRW#-     ( \s0 -> case newByteArray# bsize s0 of-         (# s1, mba #) -> unsafeFreezeByteArray# mba-           ( loop1# n-               (\i -> writeArray mba i-                        (f (indexArray ba (oa +# i))-                           (indexArray bb (ob +# i))-                        )-               ) s1-           )-     ) of (# _, r #) -> ArrayBase (# | (# 0#, n, r, E #) #)-    {-# NOINLINE go #-}-{-# INLINE zipV #-}----- TODO: to improve performance, I can either compare bytearrays using memcmp---       or implement early termination if the first elements do not match.---       On the other hand, hopefully @(&&)@ and @(||)@ ops take care of that.-instance Eq t => Eq (ArrayBase t ds) where-    {-# SPECIALIZE instance Eq (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Eq (ArrayBase Double ds) #-}-    {-# SPECIALIZE instance Eq (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance Eq (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance Eq (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance Eq (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance Eq (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance Eq (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance Eq (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance Eq (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance Eq (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance Eq (ArrayBase Word64 ds) #-}-    (==) = accumV2Idempotent True  (\x y r -> r && x == y)-    (/=) = accumV2Idempotent False (\x y r -> r || x /= y)---- | Implement partial ordering for `>`, `<`, `>=`, `<=`---     and lexicographical ordering for `compare`-instance Ord t => Ord (ArrayBase t ds)  where-    {-# SPECIALIZE instance Ord (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Ord (ArrayBase Double ds) #-}-    {-# SPECIALIZE instance Ord (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance Ord (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance Ord (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance Ord (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance Ord (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance Ord (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance Ord (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance Ord (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance Ord (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance Ord (ArrayBase Word64 ds) #-}-    -- | Partiall ordering: all elements GT-    (>)  = accumV2Idempotent True (\x y r -> r && x > y)-    {-# INLINE (>) #-}-    -- | Partiall ordering: all elements LT-    (<)  = accumV2Idempotent True (\x y r -> r && x < y)-    {-# INLINE (<) #-}-    -- | Partiall ordering: all elements GE-    (>=) = accumV2Idempotent True (\x y r -> r && x >= y)-    {-# INLINE (>=) #-}-    -- | Partiall ordering: all elements LE-    (<=) = accumV2Idempotent True (\x y r -> r && x <= y)-    {-# INLINE (<=) #-}-    -- | Compare lexicographically-    compare = accumV2Idempotent EQ (\x y  -> flip mappend (compare x y))-    {-# INLINE compare #-}-    -- | Element-wise minimum-    min = zipV min-    {-# INLINE min #-}-    -- | Element-wise maximum-    max = zipV max-    {-# INLINE max #-}--instance (Dimensions ds, Show t)-      => Show (ArrayBase t ds) where-  show x = case dims @_ @ds of-    U -> "{ " ++ show (ix U x) ++ " }"-    Dim :* U -> ('{' :) . drop 1 $-                    foldr (\i s -> ", " ++ show (ix i x) ++ s) " }"-                            [minBound .. maxBound]-    (Dim :: Dim n) :* (Dim :: Dim m) :* (Dims :: Dims dss) ->-      let loopInner :: Idxs dss -> Idxs '[n,m] -> String-          loopInner ods (n:*m:*_) = ('{' :) . drop 2 $-                          foldr (\i ss -> '\n':-                                  foldr (\j s ->-                                           ", " ++ show (ix (i :* j :* ods) x) ++ s-                                        ) ss [1..m]-                                ) " }" [1..n]-          loopOuter ::  Idxs dss -> String -> String-          loopOuter U s  = "\n" ++ loopInner U maxBound ++ s-          loopOuter ds s = "\n(i j" ++ drop 4 (show ds) ++ "):\n"-                                ++ loopInner ds maxBound ++ s-      in drop 1 $ foldr loopOuter "" [minBound..maxBound]--instance {-# OVERLAPPING #-} Bounded (ArrayBase Double ds) where-    maxBound = ArrayBase (# inftyD | #)-    minBound = ArrayBase (# negate inftyD | #)--instance {-# OVERLAPPING #-} Bounded (ArrayBase Float ds) where-    maxBound = ArrayBase (# inftyF | #)-    minBound = ArrayBase (# negate inftyF | #)--instance {-# OVERLAPPABLE #-} Bounded t => Bounded (ArrayBase t ds) where-    {-# SPECIALIZE instance Bounded (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance Bounded (ArrayBase Word64 ds) #-}-    maxBound = ArrayBase (# maxBound | #)-    minBound = ArrayBase (# minBound | #)--instance Num t => Num (ArrayBase t ds)  where-    {-# SPECIALIZE instance Num (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Num (ArrayBase Double ds) #-}-    {-# SPECIALIZE instance Num (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance Num (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance Num (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance Num (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance Num (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance Num (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance Num (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance Num (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance Num (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance Num (ArrayBase Word64 ds) #-}-    (+) = zipV (+)-    {-# INLINE (+) #-}-    (-) = zipV (-)-    {-# INLINE (-) #-}-    (*) = zipV (*)-    {-# INLINE (*) #-}-    negate = mapV negate-    {-# INLINE negate #-}-    abs = mapV abs-    {-# INLINE abs #-}-    signum = mapV signum-    {-# INLINE signum #-}-    fromInteger i = ArrayBase (# fromInteger i | #)-    {-# INLINE fromInteger #-}--instance Fractional t => Fractional (ArrayBase t ds)  where-    {-# SPECIALIZE instance Fractional (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Fractional (ArrayBase Double ds) #-}-    (/) = zipV (/)-    {-# INLINE (/) #-}-    recip = mapV recip-    {-# INLINE recip #-}-    fromRational r = ArrayBase (# fromRational r | #)-    {-# INLINE fromRational #-}---instance Floating t => Floating (ArrayBase t ds) where-    {-# SPECIALIZE instance Floating (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance Floating (ArrayBase Double ds) #-}-    pi = ArrayBase (# pi | #)-    {-# INLINE pi #-}-    exp = mapV exp-    {-# INLINE exp #-}-    log = mapV log-    {-# INLINE log #-}-    sqrt = mapV sqrt-    {-# INLINE sqrt #-}-    sin = mapV sin-    {-# INLINE sin #-}-    cos = mapV cos-    {-# INLINE cos #-}-    tan = mapV tan-    {-# INLINE tan #-}-    asin = mapV asin-    {-# INLINE asin #-}-    acos = mapV acos-    {-# INLINE acos #-}-    atan = mapV atan-    {-# INLINE atan #-}-    sinh = mapV sinh-    {-# INLINE sinh #-}-    cosh = mapV cosh-    {-# INLINE cosh #-}-    tanh = mapV tanh-    {-# INLINE tanh #-}-    (**) = zipV (**)-    {-# INLINE (**) #-}-    logBase = zipV logBase-    {-# INLINE logBase #-}-    asinh = mapV asinh-    {-# INLINE asinh #-}-    acosh = mapV acosh-    {-# INLINE acosh #-}-    atanh = mapV atanh-    {-# INLINE atanh #-}--instance PrimBytes t => PrimArray t (ArrayBase t ds) where-    {-# SPECIALIZE instance PrimArray Float  (ArrayBase Float ds)  #-}-    {-# SPECIALIZE instance PrimArray Double (ArrayBase Double ds) #-}-    {-# SPECIALIZE instance PrimArray Int    (ArrayBase Int ds)    #-}-    {-# SPECIALIZE instance PrimArray Word   (ArrayBase Word ds)   #-}-    {-# SPECIALIZE instance PrimArray Int8   (ArrayBase Int8 ds)   #-}-    {-# SPECIALIZE instance PrimArray Int16  (ArrayBase Int16 ds)  #-}-    {-# SPECIALIZE instance PrimArray Int32  (ArrayBase Int32 ds)  #-}-    {-# SPECIALIZE instance PrimArray Int64  (ArrayBase Int64 ds)  #-}-    {-# SPECIALIZE instance PrimArray Word8  (ArrayBase Word8 ds)  #-}-    {-# SPECIALIZE instance PrimArray Word16 (ArrayBase Word16 ds) #-}-    {-# SPECIALIZE instance PrimArray Word32 (ArrayBase Word32 ds) #-}-    {-# SPECIALIZE instance PrimArray Word64 (ArrayBase Word64 ds) #-}--    broadcast t = ArrayBase (# t | #)-    {-# INLINE broadcast #-}--    ix# i (ArrayBase a) = case a of-      (# t | #)                    -> t-      (# | (# off, _, arr, _ #) #) -> indexArray arr (off +# i)-    {-# INLINE ix# #-}--    gen# n f z0 = go (byteSize @t undefined *# n)-      where-        go bsize = case runRW#-         ( \s0 -> case newByteArray# bsize s0 of-             (# s1, mba #) -> case loop0 mba 0# z0 s1 of-               (# s2, z1 #) -> case unsafeFreezeByteArray# mba s2 of-                 (# s3, ba #) -> (# s3, (# z1, ba #) #)-         ) of (# _, (# z1, ba #) #) -> (# z1, ArrayBase (# | (# 0# , n , ba, E #) #) #)-        {-# NOINLINE go #-}-        loop0 mba i z s-          | isTrue# (i ==# n) = (# s, z #)-          | otherwise = case f z of-              (# z', x #) -> loop0 mba (i +# 1#) z' (writeArray mba i x s)-    {-# INLINE gen# #-}--    upd# n i x (ArrayBase (# a | #)) = go (byteSize x)-      where-        go tbs = case runRW#-         ( \s0 -> case newByteArray# (tbs *# n) s0 of-             (# s1, mba #) -> unsafeFreezeByteArray# mba-               (writeArray mba i x-                 (loop1# n (\j -> writeArray mba j a) s1)-               )-         ) of (# _, r #) -> ArrayBase (# | (# 0# , n , r, E #) #)-        {-# NOINLINE go #-}-    upd# _ i x (ArrayBase (# | (# offN , n , ba, E #) #)) = go (byteSize x)-      where-        go tbs = case runRW#-         ( \s0 -> case newByteArray# (tbs *# n) s0 of-             (# s1, mba #) -> unsafeFreezeByteArray# mba-               (writeArray mba i x-                 (copyByteArray# ba (offN *# tbs) mba 0# (tbs *# n) s1)-               )-         ) of (# _, r #) -> ArrayBase (# | (# 0# , n , r, E #) #)-        {-# NOINLINE go #-}-    {-# INLINE upd# #-}--    elemOffset (ArrayBase a) = case a of-      (# _ | #)                  -> 0#-      (# | (# off, _, _, _ #) #) -> off-    {-# INLINE elemOffset #-}--    elemSize0 (ArrayBase a) = case a of-      (# _ | #)                -> 0#-      (# | (# _, n, _, _ #) #) -> n-    {-# INLINE elemSize0 #-}--    fromElems off n ba = ArrayBase (# | (# off , n , ba, E #) #)-    {-# INLINE fromElems #-}--------------------------------------------------------------------------------------- * Utility functions------------------------------------------------------------------------------------ix :: Dimensions ds => Idxs ds -> ArrayBase t ds -> t-ix i (ArrayBase a) = case a of-  (# t | #)  -> t-  (# | (# off, _, arr, E #) #) -> case fromEnum i of-    I# i# -> indexArray arr (off +# i#)-{-# INLINE ix #-}---undefEl :: ArrayBase t ds -> t-undefEl = const undefined

@@ -1,333 +0,0 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE MagicHash             #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UnboxedTuples         #-}-module Numeric.DataFrame.Internal.Array.Family.DoubleX2 (DoubleX2 (..)) where---import           GHC.Base-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.PrimBytes---data DoubleX2 = DoubleX2# Double# Double#---instance Bounded DoubleX2 where-    maxBound = case inftyD of D# x -> DoubleX2# x x-    minBound = case negate inftyD of D# x -> DoubleX2# x x---instance Show DoubleX2 where-    show (DoubleX2# a1 a2)-      =  "{ " ++ show (D# a1)-      ++ ", " ++ show (D# a2)-      ++ " }"----instance Eq DoubleX2 where--    DoubleX2# a1 a2 == DoubleX2# b1 b2 =-      isTrue#-      (       (a1 ==## b1)-      `andI#` (a2 ==## b2)-      )-    {-# INLINE (==) #-}--    DoubleX2# a1 a2 /= DoubleX2# b1 b2 =-      isTrue#-      (      (a1 /=## b1)-      `orI#` (a2 /=## b2)-      )-    {-# INLINE (/=) #-}------ | Implement partial ordering for `>`, `<`, `>=`, `<=`---           and lexicographical ordering for `compare`-instance Ord DoubleX2 where-    DoubleX2# a1 a2 > DoubleX2# b1 b2 =-      isTrue#-      (       (a1 >## b1)-      `andI#` (a2 >## b2)-      )-    {-# INLINE (>) #-}--    DoubleX2# a1 a2 < DoubleX2# b1 b2 =-      isTrue#-      (       (a1 <## b1)-      `andI#` (a2 <## b2)-      )-    {-# INLINE (<) #-}--    DoubleX2# a1 a2 >= DoubleX2# b1 b2 =-      isTrue#-      (       (a1 >=## b1)-      `andI#` (a2 >=## b2)-      )-    {-# INLINE (>=) #-}--    DoubleX2# a1 a2 <= DoubleX2# b1 b2 =-      isTrue#-      (       (a1 <=## b1)-      `andI#` (a2 <=## b2)-      )-    {-# INLINE (<=) #-}--    -- | Compare lexicographically-    compare (DoubleX2# a1 a2) (DoubleX2# b1 b2)-      | isTrue# (a1 >## b1) = GT-      | isTrue# (a1 <## b1) = LT-      | isTrue# (a2 >## b2) = GT-      | isTrue# (a2 <## b2) = LT-      | otherwise = EQ-    {-# INLINE compare #-}--    -- | Element-wise minimum-    min (DoubleX2# a1 a2) (DoubleX2# b1 b2) = DoubleX2#-      (if isTrue# (a1 >## b1) then b1 else a1)-      (if isTrue# (a2 >## b2) then b2 else a2)-    {-# INLINE min #-}--    -- | Element-wise maximum-    max (DoubleX2# a1 a2) (DoubleX2# b1 b2) = DoubleX2#-      (if isTrue# (a1 >## b1) then a1 else b1)-      (if isTrue# (a2 >## b2) then a2 else b2)-    {-# INLINE max #-}------ | element-wise operations for vectors-instance Num DoubleX2 where--    DoubleX2# a1 a2 + DoubleX2# b1 b2-      = DoubleX2# ((+##) a1 b1) ((+##) a2 b2)-    {-# INLINE (+) #-}--    DoubleX2# a1 a2 - DoubleX2# b1 b2-      = DoubleX2# ((-##) a1 b1) ((-##) a2 b2)-    {-# INLINE (-) #-}--    DoubleX2# a1 a2 * DoubleX2# b1 b2-      = DoubleX2# ((*##) a1 b1) ((*##) a2 b2)-    {-# INLINE (*) #-}--    negate (DoubleX2# a1 a2) = DoubleX2#-      (negateDouble# a1) (negateDouble# a2)-    {-# INLINE negate #-}--    abs (DoubleX2# a1 a2)-      = DoubleX2#-      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)-      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)-    {-# INLINE abs #-}--    signum (DoubleX2# a1 a2)-      = DoubleX2# (if isTrue# (a1 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a2 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )-    {-# INLINE signum #-}--    fromInteger n = case fromInteger n of D# x -> DoubleX2# x x-    {-# INLINE fromInteger #-}----instance Fractional DoubleX2 where--    DoubleX2# a1 a2 / DoubleX2# b1 b2 = DoubleX2#-      ((/##) a1 b1) ((/##) a2 b2)-    {-# INLINE (/) #-}--    recip (DoubleX2# a1 a2) = DoubleX2#-      ((/##) 1.0## a1) ((/##) 1.0## a2)-    {-# INLINE recip #-}--    fromRational r = case fromRational r of D# x -> DoubleX2# x x-    {-# INLINE fromRational #-}----instance Floating DoubleX2 where--    pi = DoubleX2#-      3.141592653589793238##-      3.141592653589793238##-    {-# INLINE pi #-}--    exp (DoubleX2# a1 a2) = DoubleX2#-      (expDouble# a1) (expDouble# a2)-    {-# INLINE exp #-}--    log (DoubleX2# a1 a2) = DoubleX2#-      (logDouble# a1) (logDouble# a2)-    {-# INLINE log #-}--    sqrt (DoubleX2# a1 a2) = DoubleX2#-      (sqrtDouble# a1) (sqrtDouble# a2)-    {-# INLINE sqrt #-}--    sin (DoubleX2# a1 a2) = DoubleX2#-      (sinDouble# a1) (sinDouble# a2)-    {-# INLINE sin #-}--    cos (DoubleX2# a1 a2) = DoubleX2#-      (cosDouble# a1) (cosDouble# a2)-    {-# INLINE cos #-}--    tan (DoubleX2# a1 a2) = DoubleX2#-      (tanDouble# a1) (tanDouble# a2)-    {-# INLINE tan #-}--    asin (DoubleX2# a1 a2) = DoubleX2#-      (asinDouble# a1) (asinDouble# a2)-    {-# INLINE asin #-}--    acos (DoubleX2# a1 a2) = DoubleX2#-      (acosDouble# a1) (acosDouble# a2)-    {-# INLINE acos #-}--    atan (DoubleX2# a1 a2) = DoubleX2#-      (atanDouble# a1) (atanDouble# a2)-    {-# INLINE atan #-}--    sinh (DoubleX2# a1 a2) = DoubleX2#-      (sinhDouble# a1) (sinhDouble# a2)-    {-# INLINE sinh #-}--    cosh (DoubleX2# a1 a2) = DoubleX2#-      (coshDouble# a1) (coshDouble# a2)-    {-# INLINE cosh #-}--    tanh (DoubleX2# a1 a2) = DoubleX2#-      (tanhDouble# a1) (tanhDouble# a2)-    {-# INLINE tanh #-}--    DoubleX2# a1 a2 ** DoubleX2# b1 b2 = DoubleX2#-      ((**##) a1 b1) ((**##) a2 b2)-    {-# INLINE (**) #-}--    logBase x y         =  log y / log x-    {-# INLINE logBase #-}--    asinh x = log (x + sqrt (1.0+x*x))-    {-# INLINE asinh #-}--    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    {-# INLINE acosh #-}--    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#-#define ELEM_N 2--instance PrimBytes DoubleX2 where--    getBytes (DoubleX2# a1 a2) = case runRW#-       ( \s0 -> case newByteArray# (byteSize @DoubleX2 undefined) s0 of-           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of-             s2 -> case writeDoubleArray# marr 1# a2 s2 of-               s3 -> unsafeFreezeByteArray# marr s3-       ) of (# _, a #) -> a-    {-# INLINE getBytes #-}--    fromBytes off arr-      | i <- BOFF_TO_PRIMOFF(off)-      = DoubleX2#-      (indexDoubleArray# arr i)-      (indexDoubleArray# arr (i +# 1#))-    {-# INLINE fromBytes #-}--    readBytes mba off s0-      | i <- BOFF_TO_PRIMOFF(off)-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)-    {-# INLINE readBytes #-}--    writeBytes mba off (DoubleX2# a1 a2) s-      | i <- BOFF_TO_PRIMOFF(off)-      = writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s )-    {-# INLINE writeBytes #-}--    readAddr addr s0-      = case readDoubleOffAddr# addr 0# s0 of-      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of-        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)-    {-# INLINE readAddr #-}--    writeAddr (DoubleX2# a1 a2) addr s-      = writeDoubleOffAddr# addr 1# a2-      ( writeDoubleOffAddr# addr 0# a1 s )-    {-# INLINE writeAddr #-}--    byteSize _ = byteSize @Double undefined *# ELEM_N#-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign @Double undefined-    {-# INLINE byteAlign #-}--    byteOffset _ = 0#-    {-# INLINE byteOffset #-}--    indexArray ba off-      | i <- off *# ELEM_N#-      = DoubleX2#-      (indexDoubleArray# ba i)-      (indexDoubleArray# ba (i +# 1#))-    {-# INLINE indexArray #-}--    readArray mba off s0-      | i <- off *# ELEM_N#-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> (# s2, DoubleX2# a1 a2 #)-    {-# INLINE readArray #-}--    writeArray mba off (DoubleX2# a1 a2) s-      | i <- off *# ELEM_N#-      = writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s )-    {-# INLINE writeArray #-}---instance PrimArray Double DoubleX2 where--    broadcast (D# x) = DoubleX2# x x-    {-# INLINE broadcast #-}--    ix# 0# (DoubleX2# a1 _) = D# a1-    ix# 1# (DoubleX2# _ a2) = D# a2-    ix# _   _               = undefined-    {-# INLINE ix# #-}--    gen# _ f s0 = case f s0 of-      (# s1, D# a1 #) -> case f s1 of-        (# s2, D# a2 #) -> (# s2, DoubleX2# a1 a2 #)---    upd# _ 0# (D# q) (DoubleX2# _ y) = DoubleX2# q y-    upd# _ 1# (D# q) (DoubleX2# x _) = DoubleX2# x q-    upd# _ _ _ x                     = x-    {-# INLINE upd# #-}--    elemOffset _ = 0#-    {-# INLINE elemOffset #-}--    elemSize0 _  = ELEM_N#-    {-# INLINE elemSize0 #-}--    fromElems off _ ba = DoubleX2#-      (indexDoubleArray# ba off)-      (indexDoubleArray# ba (off +# 1#))-    {-# INLINE fromElems #-}

@@ -1,362 +0,0 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE MagicHash             #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UnboxedTuples         #-}-module Numeric.DataFrame.Internal.Array.Family.DoubleX3 (DoubleX3 (..)) where---import           GHC.Base-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.PrimBytes---data DoubleX3 = DoubleX3# Double# Double# Double#---instance Bounded DoubleX3 where-    maxBound = case inftyD of D# x -> DoubleX3# x x x-    minBound = case negate inftyD of D# x -> DoubleX3# x x x---instance Show DoubleX3 where-    show (DoubleX3# a1 a2 a3)-      =  "{ " ++ show (D# a1)-      ++ ", " ++ show (D# a2)-      ++ ", " ++ show (D# a3)-      ++ " }"----instance Eq DoubleX3 where--    DoubleX3# a1 a2 a3 == DoubleX3# b1 b2 b3 =-      isTrue#-      (       (a1 ==## b1)-      `andI#` (a2 ==## b2)-      `andI#` (a3 ==## b3)-      )-    {-# INLINE (==) #-}--    DoubleX3# a1 a2 a3 /= DoubleX3# b1 b2 b3 =-      isTrue#-      (      (a1 /=## b1)-      `orI#` (a2 /=## b2)-      `orI#` (a3 /=## b3)-      )-    {-# INLINE (/=) #-}------ | Implement partial ordering for `>`, `<`, `>=`, `<=`---           and lexicographical ordering for `compare`-instance Ord DoubleX3 where-    DoubleX3# a1 a2 a3 > DoubleX3# b1 b2 b3 =-      isTrue#-      (       (a1 >## b1)-      `andI#` (a2 >## b2)-      `andI#` (a3 >## b3)-      )-    {-# INLINE (>) #-}--    DoubleX3# a1 a2 a3 < DoubleX3# b1 b2 b3 =-      isTrue#-      (       (a1 <## b1)-      `andI#` (a2 <## b2)-      `andI#` (a3 <## b3)-      )-    {-# INLINE (<) #-}--    DoubleX3# a1 a2 a3 >= DoubleX3# b1 b2 b3 =-      isTrue#-      (       (a1 >=## b1)-      `andI#` (a2 >=## b2)-      `andI#` (a3 >=## b3)-      )-    {-# INLINE (>=) #-}--    DoubleX3# a1 a2 a3 <= DoubleX3# b1 b2 b3 =-      isTrue#-      (       (a1 <=## b1)-      `andI#` (a2 <=## b2)-      `andI#` (a3 <=## b3)-      )-    {-# INLINE (<=) #-}--    -- | Compare lexicographically-    compare (DoubleX3# a1 a2 a3) (DoubleX3# b1 b2 b3)-      | isTrue# (a1 >## b1) = GT-      | isTrue# (a1 <## b1) = LT-      | isTrue# (a2 >## b2) = GT-      | isTrue# (a2 <## b2) = LT-      | isTrue# (a3 >## b3) = GT-      | isTrue# (a3 <## b3) = LT-      | otherwise = EQ-    {-# INLINE compare #-}--    -- | Element-wise minimum-    min (DoubleX3# a1 a2 a3) (DoubleX3# b1 b2 b3) = DoubleX3#-      (if isTrue# (a1 >## b1) then b1 else a1)-      (if isTrue# (a2 >## b2) then b2 else a2)-      (if isTrue# (a3 >## b3) then b3 else a3)-    {-# INLINE min #-}--    -- | Element-wise maximum-    max (DoubleX3# a1 a2 a3) (DoubleX3# b1 b2 b3) = DoubleX3#-      (if isTrue# (a1 >## b1) then a1 else b1)-      (if isTrue# (a2 >## b2) then a2 else b2)-      (if isTrue# (a3 >## b3) then a3 else b3)-    {-# INLINE max #-}------ | element-wise operations for vectors-instance Num DoubleX3 where--    DoubleX3# a1 a2 a3 + DoubleX3# b1 b2 b3-      = DoubleX3# ((+##) a1 b1) ((+##) a2 b2) ((+##) a3 b3)-    {-# INLINE (+) #-}--    DoubleX3# a1 a2 a3 - DoubleX3# b1 b2 b3-      = DoubleX3# ((-##) a1 b1) ((-##) a2 b2) ((-##) a3 b3)-    {-# INLINE (-) #-}--    DoubleX3# a1 a2 a3 * DoubleX3# b1 b2 b3-      = DoubleX3# ((*##) a1 b1) ((*##) a2 b2) ((*##) a3 b3)-    {-# INLINE (*) #-}--    negate (DoubleX3# a1 a2 a3) = DoubleX3#-      (negateDouble# a1) (negateDouble# a2) (negateDouble# a3)-    {-# INLINE negate #-}--    abs (DoubleX3# a1 a2 a3)-      = DoubleX3#-      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)-      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)-      (if isTrue# (a3 >=## 0.0##) then a3 else negateDouble# a3)-    {-# INLINE abs #-}--    signum (DoubleX3# a1 a2 a3)-      = DoubleX3# (if isTrue# (a1 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a2 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a3 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a3 <## 0.0##) then -1.0## else 0.0## )-    {-# INLINE signum #-}--    fromInteger n = case fromInteger n of D# x -> DoubleX3# x x x-    {-# INLINE fromInteger #-}----instance Fractional DoubleX3 where--    DoubleX3# a1 a2 a3 / DoubleX3# b1 b2 b3 = DoubleX3#-      ((/##) a1 b1) ((/##) a2 b2) ((/##) a3 b3)-    {-# INLINE (/) #-}--    recip (DoubleX3# a1 a2 a3) = DoubleX3#-      ((/##) 1.0## a1) ((/##) 1.0## a2) ((/##) 1.0## a3)-    {-# INLINE recip #-}--    fromRational r = case fromRational r of D# x -> DoubleX3# x x x-    {-# INLINE fromRational #-}----instance Floating DoubleX3 where--    pi = DoubleX3#-      3.141592653589793238##-      3.141592653589793238##-      3.141592653589793238##-    {-# INLINE pi #-}--    exp (DoubleX3# a1 a2 a3) = DoubleX3#-      (expDouble# a1) (expDouble# a2) (expDouble# a3)-    {-# INLINE exp #-}--    log (DoubleX3# a1 a2 a3) = DoubleX3#-      (logDouble# a1) (logDouble# a2) (logDouble# a3)-    {-# INLINE log #-}--    sqrt (DoubleX3# a1 a2 a3) = DoubleX3#-      (sqrtDouble# a1) (sqrtDouble# a2) (sqrtDouble# a3)-    {-# INLINE sqrt #-}--    sin (DoubleX3# a1 a2 a3) = DoubleX3#-      (sinDouble# a1) (sinDouble# a2) (sinDouble# a3)-    {-# INLINE sin #-}--    cos (DoubleX3# a1 a2 a3) = DoubleX3#-      (cosDouble# a1) (cosDouble# a2) (cosDouble# a3)-    {-# INLINE cos #-}--    tan (DoubleX3# a1 a2 a3) = DoubleX3#-      (tanDouble# a1) (tanDouble# a2) (tanDouble# a3)-    {-# INLINE tan #-}--    asin (DoubleX3# a1 a2 a3) = DoubleX3#-      (asinDouble# a1) (asinDouble# a2) (asinDouble# a3)-    {-# INLINE asin #-}--    acos (DoubleX3# a1 a2 a3) = DoubleX3#-      (acosDouble# a1) (acosDouble# a2) (acosDouble# a3)-    {-# INLINE acos #-}--    atan (DoubleX3# a1 a2 a3) = DoubleX3#-      (atanDouble# a1) (atanDouble# a2) (atanDouble# a3)-    {-# INLINE atan #-}--    sinh (DoubleX3# a1 a2 a3) = DoubleX3#-      (sinhDouble# a1) (sinhDouble# a2) (sinhDouble# a3)-    {-# INLINE sinh #-}--    cosh (DoubleX3# a1 a2 a3) = DoubleX3#-      (coshDouble# a1) (coshDouble# a2) (coshDouble# a3)-    {-# INLINE cosh #-}--    tanh (DoubleX3# a1 a2 a3) = DoubleX3#-      (tanhDouble# a1) (tanhDouble# a2) (tanhDouble# a3)-    {-# INLINE tanh #-}--    DoubleX3# a1 a2 a3 ** DoubleX3# b1 b2 b3 = DoubleX3#-      ((**##) a1 b1) ((**##) a2 b2) ((**##) a3 b3)-    {-# INLINE (**) #-}--    logBase x y         =  log y / log x-    {-# INLINE logBase #-}--    asinh x = log (x + sqrt (1.0+x*x))-    {-# INLINE asinh #-}--    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    {-# INLINE acosh #-}--    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#-#define ELEM_N 3--instance PrimBytes DoubleX3 where--    getBytes (DoubleX3# a1 a2 a3) = case runRW#-       ( \s0 -> case newByteArray# (byteSize @DoubleX3 undefined) s0 of-           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of-             s2 -> case writeDoubleArray# marr 1# a2 s2 of-               s3 -> case writeDoubleArray# marr 2# a3 s3 of-                 s4 -> unsafeFreezeByteArray# marr s4-       ) of (# _, a #) -> a-    {-# INLINE getBytes #-}--    fromBytes off arr-      | i <- BOFF_TO_PRIMOFF(off)-      = DoubleX3#-      (indexDoubleArray# arr i)-      (indexDoubleArray# arr (i +# 1#))-      (indexDoubleArray# arr (i +# 2#))-    {-# INLINE fromBytes #-}--    readBytes mba off s0-      | i <- BOFF_TO_PRIMOFF(off)-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)-    {-# INLINE readBytes #-}--    writeBytes mba off (DoubleX3# a1 a2 a3) s-      | i <- BOFF_TO_PRIMOFF(off)-      = writeDoubleArray# mba (i +# 2#) a3-      ( writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s ))-    {-# INLINE writeBytes #-}--    readAddr addr s0-      = case readDoubleOffAddr# addr 0# s0 of-      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of-        (# s2, a2 #) -> case readDoubleOffAddr# addr 2# s2 of-          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)-    {-# INLINE readAddr #-}--    writeAddr (DoubleX3# a1 a2 a3) addr s-      = writeDoubleOffAddr# addr 2# a3-      ( writeDoubleOffAddr# addr 1# a2-      ( writeDoubleOffAddr# addr 0# a1 s ))-    {-# INLINE writeAddr #-}--    byteSize _ = byteSize @Double undefined *# ELEM_N#-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign @Double undefined-    {-# INLINE byteAlign #-}--    byteOffset _ = 0#-    {-# INLINE byteOffset #-}--    indexArray ba off-      | i <- off *# ELEM_N#-      = DoubleX3#-      (indexDoubleArray# ba i)-      (indexDoubleArray# ba (i +# 1#))-      (indexDoubleArray# ba (i +# 2#))-    {-# INLINE indexArray #-}--    readArray mba off s0-      | i <- off *# ELEM_N#-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)-    {-# INLINE readArray #-}--    writeArray mba off (DoubleX3# a1 a2 a3) s-      | i <- off *# ELEM_N#-      = writeDoubleArray# mba (i +# 2#) a3-      ( writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s ))-    {-# INLINE writeArray #-}---instance PrimArray Double DoubleX3 where--    broadcast (D# x) = DoubleX3# x x x-    {-# INLINE broadcast #-}--    ix# 0# (DoubleX3# a1 _ _) = D# a1-    ix# 1# (DoubleX3# _ a2 _) = D# a2-    ix# 2# (DoubleX3# _ _ a3) = D# a3-    ix# _   _                 = undefined-    {-# INLINE ix# #-}--    gen# _ f s0 = case f s0 of-      (# s1, D# a1 #) -> case f s1 of-        (# s2, D# a2 #) -> case f s2 of-          (# s3, D# a3 #) -> (# s3, DoubleX3# a1 a2 a3 #)---    upd# _ 0# (D# q) (DoubleX3# _ y z) = DoubleX3# q y z-    upd# _ 1# (D# q) (DoubleX3# x _ z) = DoubleX3# x q z-    upd# _ 2# (D# q) (DoubleX3# x y _) = DoubleX3# x y q-    upd# _ _ _ x                       = x-    {-# INLINE upd# #-}--    elemOffset _ = 0#-    {-# INLINE elemOffset #-}--    elemSize0 _  = ELEM_N#-    {-# INLINE elemSize0 #-}--    fromElems off _ ba = DoubleX3#-      (indexDoubleArray# ba off)-      (indexDoubleArray# ba (off +# 1#))-      (indexDoubleArray# ba (off +# 2#))-    {-# INLINE fromElems #-}

@@ -1,391 +0,0 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE MagicHash             #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UnboxedTuples         #-}-module Numeric.DataFrame.Internal.Array.Family.DoubleX4 (DoubleX4 (..)) where---import           GHC.Base-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.PrimBytes---data DoubleX4 = DoubleX4# Double# Double# Double# Double#---instance Bounded DoubleX4 where-    maxBound = case inftyD of D# x -> DoubleX4# x x x x-    minBound = case negate inftyD of D# x -> DoubleX4# x x x x---instance Show DoubleX4 where-    show (DoubleX4# a1 a2 a3 a4)-      =  "{ " ++ show (D# a1)-      ++ ", " ++ show (D# a2)-      ++ ", " ++ show (D# a3)-      ++ ", " ++ show (D# a4)-      ++ " }"----instance Eq DoubleX4 where--    DoubleX4# a1 a2 a3 a4 == DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (       (a1 ==## b1)-      `andI#` (a2 ==## b2)-      `andI#` (a3 ==## b3)-      `andI#` (a4 ==## b4)-      )-    {-# INLINE (==) #-}--    DoubleX4# a1 a2 a3 a4 /= DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (      (a1 /=## b1)-      `orI#` (a2 /=## b2)-      `orI#` (a3 /=## b3)-      `orI#` (a4 /=## b4)-      )-    {-# INLINE (/=) #-}------ | Implement partial ordering for `>`, `<`, `>=`, `<=`---           and lexicographical ordering for `compare`-instance Ord DoubleX4 where-    DoubleX4# a1 a2 a3 a4 > DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (       (a1 >## b1)-      `andI#` (a2 >## b2)-      `andI#` (a3 >## b3)-      `andI#` (a4 >## b4)-      )-    {-# INLINE (>) #-}--    DoubleX4# a1 a2 a3 a4 < DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (       (a1 <## b1)-      `andI#` (a2 <## b2)-      `andI#` (a3 <## b3)-      `andI#` (a4 <## b4)-      )-    {-# INLINE (<) #-}--    DoubleX4# a1 a2 a3 a4 >= DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (       (a1 >=## b1)-      `andI#` (a2 >=## b2)-      `andI#` (a3 >=## b3)-      `andI#` (a4 >=## b4)-      )-    {-# INLINE (>=) #-}--    DoubleX4# a1 a2 a3 a4 <= DoubleX4# b1 b2 b3 b4 =-      isTrue#-      (       (a1 <=## b1)-      `andI#` (a2 <=## b2)-      `andI#` (a3 <=## b3)-      `andI#` (a4 <=## b4)-      )-    {-# INLINE (<=) #-}--    -- | Compare lexicographically-    compare (DoubleX4# a1 a2 a3 a4) (DoubleX4# b1 b2 b3 b4)-      | isTrue# (a1 >## b1) = GT-      | isTrue# (a1 <## b1) = LT-      | isTrue# (a2 >## b2) = GT-      | isTrue# (a2 <## b2) = LT-      | isTrue# (a3 >## b3) = GT-      | isTrue# (a3 <## b3) = LT-      | isTrue# (a4 >## b4) = GT-      | isTrue# (a4 <## b4) = LT-      | otherwise = EQ-    {-# INLINE compare #-}--    -- | Element-wise minimum-    min (DoubleX4# a1 a2 a3 a4) (DoubleX4# b1 b2 b3 b4) = DoubleX4#-      (if isTrue# (a1 >## b1) then b1 else a1)-      (if isTrue# (a2 >## b2) then b2 else a2)-      (if isTrue# (a3 >## b3) then b3 else a3)-      (if isTrue# (a4 >## b4) then b4 else a4)-    {-# INLINE min #-}--    -- | Element-wise maximum-    max (DoubleX4# a1 a2 a3 a4) (DoubleX4# b1 b2 b3 b4) = DoubleX4#-      (if isTrue# (a1 >## b1) then a1 else b1)-      (if isTrue# (a2 >## b2) then a2 else b2)-      (if isTrue# (a3 >## b3) then a3 else b3)-      (if isTrue# (a4 >## b4) then a4 else b4)-    {-# INLINE max #-}------ | element-wise operations for vectors-instance Num DoubleX4 where--    DoubleX4# a1 a2 a3 a4 + DoubleX4# b1 b2 b3 b4-      = DoubleX4# ((+##) a1 b1) ((+##) a2 b2) ((+##) a3 b3) ((+##) a4 b4)-    {-# INLINE (+) #-}--    DoubleX4# a1 a2 a3 a4 - DoubleX4# b1 b2 b3 b4-      = DoubleX4# ((-##) a1 b1) ((-##) a2 b2) ((-##) a3 b3) ((-##) a4 b4)-    {-# INLINE (-) #-}--    DoubleX4# a1 a2 a3 a4 * DoubleX4# b1 b2 b3 b4-      = DoubleX4# ((*##) a1 b1) ((*##) a2 b2) ((*##) a3 b3) ((*##) a4 b4)-    {-# INLINE (*) #-}--    negate (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (negateDouble# a1) (negateDouble# a2) (negateDouble# a3) (negateDouble# a4)-    {-# INLINE negate #-}--    abs (DoubleX4# a1 a2 a3 a4)-      = DoubleX4#-      (if isTrue# (a1 >=## 0.0##) then a1 else negateDouble# a1)-      (if isTrue# (a2 >=## 0.0##) then a2 else negateDouble# a2)-      (if isTrue# (a3 >=## 0.0##) then a3 else negateDouble# a3)-      (if isTrue# (a4 >=## 0.0##) then a4 else negateDouble# a4)-    {-# INLINE abs #-}--    signum (DoubleX4# a1 a2 a3 a4)-      = DoubleX4# (if isTrue# (a1 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a1 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a2 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a2 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a3 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a3 <## 0.0##) then -1.0## else 0.0## )-                 (if isTrue# (a4 >## 0.0##)-                  then 1.0##-                  else if isTrue# (a4 <## 0.0##) then -1.0## else 0.0## )-    {-# INLINE signum #-}--    fromInteger n = case fromInteger n of D# x -> DoubleX4# x x x x-    {-# INLINE fromInteger #-}----instance Fractional DoubleX4 where--    DoubleX4# a1 a2 a3 a4 / DoubleX4# b1 b2 b3 b4 = DoubleX4#-      ((/##) a1 b1) ((/##) a2 b2) ((/##) a3 b3) ((/##) a4 b4)-    {-# INLINE (/) #-}--    recip (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      ((/##) 1.0## a1) ((/##) 1.0## a2) ((/##) 1.0## a3) ((/##) 1.0## a4)-    {-# INLINE recip #-}--    fromRational r = case fromRational r of D# x -> DoubleX4# x x x x-    {-# INLINE fromRational #-}----instance Floating DoubleX4 where--    pi = DoubleX4#-      3.141592653589793238##-      3.141592653589793238##-      3.141592653589793238##-      3.141592653589793238##-    {-# INLINE pi #-}--    exp (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (expDouble# a1) (expDouble# a2) (expDouble# a3) (expDouble# a4)-    {-# INLINE exp #-}--    log (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (logDouble# a1) (logDouble# a2) (logDouble# a3) (logDouble# a4)-    {-# INLINE log #-}--    sqrt (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (sqrtDouble# a1) (sqrtDouble# a2) (sqrtDouble# a3) (sqrtDouble# a4)-    {-# INLINE sqrt #-}--    sin (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (sinDouble# a1) (sinDouble# a2) (sinDouble# a3) (sinDouble# a4)-    {-# INLINE sin #-}--    cos (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (cosDouble# a1) (cosDouble# a2) (cosDouble# a3) (cosDouble# a4)-    {-# INLINE cos #-}--    tan (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (tanDouble# a1) (tanDouble# a2) (tanDouble# a3) (tanDouble# a4)-    {-# INLINE tan #-}--    asin (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (asinDouble# a1) (asinDouble# a2) (asinDouble# a3) (asinDouble# a4)-    {-# INLINE asin #-}--    acos (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (acosDouble# a1) (acosDouble# a2) (acosDouble# a3) (acosDouble# a4)-    {-# INLINE acos #-}--    atan (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (atanDouble# a1) (atanDouble# a2) (atanDouble# a3) (atanDouble# a4)-    {-# INLINE atan #-}--    sinh (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (sinhDouble# a1) (sinhDouble# a2) (sinhDouble# a3) (sinhDouble# a4)-    {-# INLINE sinh #-}--    cosh (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (coshDouble# a1) (coshDouble# a2) (coshDouble# a3) (coshDouble# a4)-    {-# INLINE cosh #-}--    tanh (DoubleX4# a1 a2 a3 a4) = DoubleX4#-      (tanhDouble# a1) (tanhDouble# a2) (tanhDouble# a3) (tanhDouble# a4)-    {-# INLINE tanh #-}--    DoubleX4# a1 a2 a3 a4 ** DoubleX4# b1 b2 b3 b4 = DoubleX4#-      ((**##) a1 b1) ((**##) a2 b2) ((**##) a3 b3) ((**##) a4 b4)-    {-# INLINE (**) #-}--    logBase x y         =  log y / log x-    {-# INLINE logBase #-}--    asinh x = log (x + sqrt (1.0+x*x))-    {-# INLINE asinh #-}--    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    {-# INLINE acosh #-}--    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3#-#define ELEM_N 4--instance PrimBytes DoubleX4 where--    getBytes (DoubleX4# a1 a2 a3 a4) = case runRW#-       ( \s0 -> case newByteArray# (byteSize @DoubleX4 undefined) s0 of-           (# s1, marr #) -> case writeDoubleArray# marr 0# a1 s1 of-             s2 -> case writeDoubleArray# marr 1# a2 s2 of-               s3 -> case writeDoubleArray# marr 2# a3 s3 of-                 s4 -> case writeDoubleArray# marr 3# a4 s4 of-                   s5 -> unsafeFreezeByteArray# marr s5-       ) of (# _, a #) -> a-    {-# INLINE getBytes #-}--    fromBytes off arr-      | i <- BOFF_TO_PRIMOFF(off)-      = DoubleX4#-      (indexDoubleArray# arr i)-      (indexDoubleArray# arr (i +# 1#))-      (indexDoubleArray# arr (i +# 2#))-      (indexDoubleArray# arr (i +# 3#))-    {-# INLINE fromBytes #-}--    readBytes mba off s0-      | i <- BOFF_TO_PRIMOFF(off)-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> case readDoubleArray# mba (i +# 3#) s3 of-            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)-    {-# INLINE readBytes #-}--    writeBytes mba off (DoubleX4# a1 a2 a3 a4) s-      | i <- BOFF_TO_PRIMOFF(off)-      = writeDoubleArray# mba (i +# 3#) a4-      ( writeDoubleArray# mba (i +# 2#) a3-      ( writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s )))-    {-# INLINE writeBytes #-}--    readAddr addr s0-      = case readDoubleOffAddr# addr 0# s0 of-      (# s1, a1 #) -> case readDoubleOffAddr# addr 1# s1 of-        (# s2, a2 #) -> case readDoubleOffAddr# addr 2# s2 of-          (# s3, a3 #) -> case readDoubleOffAddr# addr 3# s3 of-            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)-    {-# INLINE readAddr #-}--    writeAddr (DoubleX4# a1 a2 a3 a4) addr s-      = writeDoubleOffAddr# addr 3# a4-      ( writeDoubleOffAddr# addr 2# a3-      ( writeDoubleOffAddr# addr 1# a2-      ( writeDoubleOffAddr# addr 0# a1 s )))-    {-# INLINE writeAddr #-}--    byteSize _ = byteSize @Double undefined *# ELEM_N#-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign @Double undefined-    {-# INLINE byteAlign #-}--    byteOffset _ = 0#-    {-# INLINE byteOffset #-}--    indexArray ba off-      | i <- off *# ELEM_N#-      = DoubleX4#-      (indexDoubleArray# ba i)-      (indexDoubleArray# ba (i +# 1#))-      (indexDoubleArray# ba (i +# 2#))-      (indexDoubleArray# ba (i +# 3#))-    {-# INLINE indexArray #-}--    readArray mba off s0-      | i <- off *# ELEM_N#-      = case readDoubleArray# mba i s0 of-      (# s1, a1 #) -> case readDoubleArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readDoubleArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> case readDoubleArray# mba (i +# 3#) s3 of-            (# s4, a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)-    {-# INLINE readArray #-}--    writeArray mba off (DoubleX4# a1 a2 a3 a4) s-      | i <- off *# ELEM_N#-      = writeDoubleArray# mba (i +# 3#) a4-      ( writeDoubleArray# mba (i +# 2#) a3-      ( writeDoubleArray# mba (i +# 1#) a2-      ( writeDoubleArray# mba  i        a1 s )))-    {-# INLINE writeArray #-}---instance PrimArray Double DoubleX4 where--    broadcast (D# x) = DoubleX4# x x x x-    {-# INLINE broadcast #-}--    ix# 0# (DoubleX4# a1 _ _ _) = D# a1-    ix# 1# (DoubleX4# _ a2 _ _) = D# a2-    ix# 2# (DoubleX4# _ _ a3 _) = D# a3-    ix# 3# (DoubleX4# _ _ _ a4) = D# a4-    ix# _   _                   = undefined-    {-# INLINE ix# #-}--    gen# _ f s0 = case f s0 of-      (# s1, D# a1 #) -> case f s1 of-        (# s2, D# a2 #) -> case f s2 of-          (# s3, D# a3 #) -> case f s3 of-            (# s4, D# a4 #) -> (# s4, DoubleX4# a1 a2 a3 a4 #)---    upd# _ 0# (D# q) (DoubleX4# _ y z w) = DoubleX4# q y z w-    upd# _ 1# (D# q) (DoubleX4# x _ z w) = DoubleX4# x q z w-    upd# _ 2# (D# q) (DoubleX4# x y _ w) = DoubleX4# x y q w-    upd# _ 3# (D# q) (DoubleX4# x y z _) = DoubleX4# x y z q-    upd# _ _ _ x                         = x-    {-# INLINE upd# #-}--    elemOffset _ = 0#-    {-# INLINE elemOffset #-}--    elemSize0 _  = ELEM_N#-    {-# INLINE elemSize0 #-}--    fromElems off _ ba = DoubleX4#-      (indexDoubleArray# ba off)-      (indexDoubleArray# ba (off +# 1#))-      (indexDoubleArray# ba (off +# 2#))-      (indexDoubleArray# ba (off +# 3#))-    {-# INLINE fromElems #-}

@@ -1,333 +0,0 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE MagicHash             #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UnboxedTuples         #-}-module Numeric.DataFrame.Internal.Array.Family.FloatX2 (FloatX2 (..)) where---import           GHC.Base-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.PrimBytes---data FloatX2 = FloatX2# Float# Float#---instance Bounded FloatX2 where-    maxBound = case inftyF of F# x -> FloatX2# x x-    minBound = case negate inftyF of F# x -> FloatX2# x x---instance Show FloatX2 where-    show (FloatX2# a1 a2)-      =  "{ " ++ show (F# a1)-      ++ ", " ++ show (F# a2)-      ++ " }"----instance Eq FloatX2 where--    FloatX2# a1 a2 == FloatX2# b1 b2 =-      isTrue#-      (       (a1 `eqFloat#` b1)-      `andI#` (a2 `eqFloat#` b2)-      )-    {-# INLINE (==) #-}--    FloatX2# a1 a2 /= FloatX2# b1 b2 =-      isTrue#-      (      (a1 `neFloat#` b1)-      `orI#` (a2 `neFloat#` b2)-      )-    {-# INLINE (/=) #-}------ | Implement partial ordering for `>`, `<`, `>=`, `<=`---           and lexicographical ordering for `compare`-instance Ord FloatX2 where-    FloatX2# a1 a2 > FloatX2# b1 b2 =-      isTrue#-      (       (a1 `gtFloat#` b1)-      `andI#` (a2 `gtFloat#` b2)-      )-    {-# INLINE (>) #-}--    FloatX2# a1 a2 < FloatX2# b1 b2 =-      isTrue#-      (       (a1 `ltFloat#` b1)-      `andI#` (a2 `ltFloat#` b2)-      )-    {-# INLINE (<) #-}--    FloatX2# a1 a2 >= FloatX2# b1 b2 =-      isTrue#-      (       (a1 `geFloat#` b1)-      `andI#` (a2 `geFloat#` b2)-      )-    {-# INLINE (>=) #-}--    FloatX2# a1 a2 <= FloatX2# b1 b2 =-      isTrue#-      (       (a1 `leFloat#` b1)-      `andI#` (a2 `leFloat#` b2)-      )-    {-# INLINE (<=) #-}--    -- | Compare lexicographically-    compare (FloatX2# a1 a2) (FloatX2# b1 b2)-      | isTrue# (a1 `gtFloat#` b1) = GT-      | isTrue# (a1 `ltFloat#` b1) = LT-      | isTrue# (a2 `gtFloat#` b2) = GT-      | isTrue# (a2 `ltFloat#` b2) = LT-      | otherwise = EQ-    {-# INLINE compare #-}--    -- | Element-wise minimum-    min (FloatX2# a1 a2) (FloatX2# b1 b2) = FloatX2#-      (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)-      (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)-    {-# INLINE min #-}--    -- | Element-wise maximum-    max (FloatX2# a1 a2) (FloatX2# b1 b2) = FloatX2#-      (if isTrue# (a1 `gtFloat#` b1) then a1 else b1)-      (if isTrue# (a2 `gtFloat#` b2) then a2 else b2)-    {-# INLINE max #-}------ | element-wise operations for vectors-instance Num FloatX2 where--    FloatX2# a1 a2 + FloatX2# b1 b2-      = FloatX2# (plusFloat# a1 b1) (plusFloat# a2 b2)-    {-# INLINE (+) #-}--    FloatX2# a1 a2 - FloatX2# b1 b2-      = FloatX2# (minusFloat# a1 b1) (minusFloat# a2 b2)-    {-# INLINE (-) #-}--    FloatX2# a1 a2 * FloatX2# b1 b2-      = FloatX2# (timesFloat# a1 b1) (timesFloat# a2 b2)-    {-# INLINE (*) #-}--    negate (FloatX2# a1 a2) = FloatX2#-      (negateFloat# a1) (negateFloat# a2)-    {-# INLINE negate #-}--    abs (FloatX2# a1 a2)-      = FloatX2#-      (if isTrue# (a1 `geFloat#` 0.0#) then a1 else negateFloat# a1)-      (if isTrue# (a2 `geFloat#` 0.0#) then a2 else negateFloat# a2)-    {-# INLINE abs #-}--    signum (FloatX2# a1 a2)-      = FloatX2# (if isTrue# (a1 `gtFloat#` 0.0#)-                  then 1.0#-                  else if isTrue# (a1 `ltFloat#` 0.0#) then -1.0# else 0.0# )-                 (if isTrue# (a2 `gtFloat#` 0.0#)-                  then 1.0#-                  else if isTrue# (a2 `ltFloat#` 0.0#) then -1.0# else 0.0# )-    {-# INLINE signum #-}--    fromInteger n = case fromInteger n of F# x -> FloatX2# x x-    {-# INLINE fromInteger #-}----instance Fractional FloatX2 where--    FloatX2# a1 a2 / FloatX2# b1 b2 = FloatX2#-      (divideFloat# a1 b1) (divideFloat# a2 b2)-    {-# INLINE (/) #-}--    recip (FloatX2# a1 a2) = FloatX2#-      (divideFloat# 1.0# a1) (divideFloat# 1.0# a2)-    {-# INLINE recip #-}--    fromRational r = case fromRational r of F# x -> FloatX2# x x-    {-# INLINE fromRational #-}----instance Floating FloatX2 where--    pi = FloatX2#-      3.141592653589793238#-      3.141592653589793238#-    {-# INLINE pi #-}--    exp (FloatX2# a1 a2) = FloatX2#-      (expFloat# a1) (expFloat# a2)-    {-# INLINE exp #-}--    log (FloatX2# a1 a2) = FloatX2#-      (logFloat# a1) (logFloat# a2)-    {-# INLINE log #-}--    sqrt (FloatX2# a1 a2) = FloatX2#-      (sqrtFloat# a1) (sqrtFloat# a2)-    {-# INLINE sqrt #-}--    sin (FloatX2# a1 a2) = FloatX2#-      (sinFloat# a1) (sinFloat# a2)-    {-# INLINE sin #-}--    cos (FloatX2# a1 a2) = FloatX2#-      (cosFloat# a1) (cosFloat# a2)-    {-# INLINE cos #-}--    tan (FloatX2# a1 a2) = FloatX2#-      (tanFloat# a1) (tanFloat# a2)-    {-# INLINE tan #-}--    asin (FloatX2# a1 a2) = FloatX2#-      (asinFloat# a1) (asinFloat# a2)-    {-# INLINE asin #-}--    acos (FloatX2# a1 a2) = FloatX2#-      (acosFloat# a1) (acosFloat# a2)-    {-# INLINE acos #-}--    atan (FloatX2# a1 a2) = FloatX2#-      (atanFloat# a1) (atanFloat# a2)-    {-# INLINE atan #-}--    sinh (FloatX2# a1 a2) = FloatX2#-      (sinhFloat# a1) (sinhFloat# a2)-    {-# INLINE sinh #-}--    cosh (FloatX2# a1 a2) = FloatX2#-      (coshFloat# a1) (coshFloat# a2)-    {-# INLINE cosh #-}--    tanh (FloatX2# a1 a2) = FloatX2#-      (tanhFloat# a1) (tanhFloat# a2)-    {-# INLINE tanh #-}--    FloatX2# a1 a2 ** FloatX2# b1 b2 = FloatX2#-      (powerFloat# a1 b1) (powerFloat# a2 b2)-    {-# INLINE (**) #-}--    logBase x y         =  log y / log x-    {-# INLINE logBase #-}--    asinh x = log (x + sqrt (1.0+x*x))-    {-# INLINE asinh #-}--    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    {-# INLINE acosh #-}--    atanh x = 0.5 * log ((1.0+x) / (1.0-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# a1 a2) = case runRW#-       ( \s0 -> case newByteArray# (byteSize @FloatX2 undefined) s0 of-           (# s1, marr #) -> case writeFloatArray# marr 0# a1 s1 of-             s2 -> case writeFloatArray# marr 1# a2 s2 of-               s3 -> unsafeFreezeByteArray# marr s3-       ) of (# _, a #) -> a-    {-# INLINE getBytes #-}--    fromBytes off arr-      | i <- BOFF_TO_PRIMOFF(off)-      = FloatX2#-      (indexFloatArray# arr i)-      (indexFloatArray# arr (i +# 1#))-    {-# INLINE fromBytes #-}--    readBytes mba off s0-      | i <- BOFF_TO_PRIMOFF(off)-      = case readFloatArray# mba i s0 of-      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)-    {-# INLINE readBytes #-}--    writeBytes mba off (FloatX2# a1 a2) s-      | i <- BOFF_TO_PRIMOFF(off)-      = writeFloatArray# mba (i +# 1#) a2-      ( writeFloatArray# mba  i        a1 s )-    {-# INLINE writeBytes #-}--    readAddr addr s0-      = case readFloatOffAddr# addr 0# s0 of-      (# s1, a1 #) -> case readFloatOffAddr# addr 1# s1 of-        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)-    {-# INLINE readAddr #-}--    writeAddr (FloatX2# a1 a2) addr s-      = writeFloatOffAddr# addr 1# a2-      ( writeFloatOffAddr# addr 0# a1 s )-    {-# INLINE writeAddr #-}--    byteSize _ = byteSize @Float undefined *# ELEM_N#-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign @Float undefined-    {-# INLINE byteAlign #-}--    byteOffset _ = 0#-    {-# INLINE byteOffset #-}--    indexArray ba off-      | i <- off *# ELEM_N#-      = FloatX2#-      (indexFloatArray# ba i)-      (indexFloatArray# ba (i +# 1#))-    {-# INLINE indexArray #-}--    readArray mba off s0-      | i <- off *# ELEM_N#-      = case readFloatArray# mba i s0 of-      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> (# s2, FloatX2# a1 a2 #)-    {-# INLINE readArray #-}--    writeArray mba off (FloatX2# a1 a2) s-      | i <- off *# ELEM_N#-      = writeFloatArray# mba (i +# 1#) a2-      ( writeFloatArray# mba  i        a1 s )-    {-# INLINE writeArray #-}---instance PrimArray Float FloatX2 where--    broadcast (F# x) = FloatX2# x x-    {-# INLINE broadcast #-}--    ix# 0# (FloatX2# a1 _) = F# a1-    ix# 1# (FloatX2# _ a2) = F# a2-    ix# _   _              = undefined-    {-# INLINE ix# #-}--    gen# _ f s0 = case f s0 of-      (# s1, F# a1 #) -> case f s1 of-        (# s2, F# a2 #) -> (# s2, FloatX2# a1 a2 #)---    upd# _ 0# (F# q) (FloatX2# _ y) = FloatX2# q y-    upd# _ 1# (F# q) (FloatX2# x _) = FloatX2# x q-    upd# _ _ _ x                    = x-    {-# INLINE upd# #-}--    elemOffset _ = 0#-    {-# INLINE elemOffset #-}--    elemSize0 _  = ELEM_N#-    {-# INLINE elemSize0 #-}--    fromElems off _ ba = FloatX2#-      (indexFloatArray# ba off)-      (indexFloatArray# ba (off +# 1#))-    {-# INLINE fromElems #-}

@@ -1,362 +0,0 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE MagicHash             #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UnboxedTuples         #-}-module Numeric.DataFrame.Internal.Array.Family.FloatX3 (FloatX3 (..)) where---import           GHC.Base-import           Numeric.DataFrame.Internal.Array.Class-import           Numeric.DataFrame.Internal.Array.PrimOps-import           Numeric.PrimBytes---data FloatX3 = FloatX3# Float# Float# Float#---instance Bounded FloatX3 where-    maxBound = case inftyF of F# x -> FloatX3# x x x-    minBound = case negate inftyF of F# x -> FloatX3# x x x---instance Show FloatX3 where-    show (FloatX3# a1 a2 a3)-      =  "{ " ++ show (F# a1)-      ++ ", " ++ show (F# a2)-      ++ ", " ++ show (F# a3)-      ++ " }"----instance Eq FloatX3 where--    FloatX3# a1 a2 a3 == FloatX3# b1 b2 b3 =-      isTrue#-      (       (a1 `eqFloat#` b1)-      `andI#` (a2 `eqFloat#` b2)-      `andI#` (a3 `eqFloat#` b3)-      )-    {-# INLINE (==) #-}--    FloatX3# a1 a2 a3 /= FloatX3# b1 b2 b3 =-      isTrue#-      (      (a1 `neFloat#` b1)-      `orI#` (a2 `neFloat#` b2)-      `orI#` (a3 `neFloat#` b3)-      )-    {-# INLINE (/=) #-}------ | Implement partial ordering for `>`, `<`, `>=`, `<=`---           and lexicographical ordering for `compare`-instance Ord FloatX3 where-    FloatX3# a1 a2 a3 > FloatX3# b1 b2 b3 =-      isTrue#-      (       (a1 `gtFloat#` b1)-      `andI#` (a2 `gtFloat#` b2)-      `andI#` (a3 `gtFloat#` b3)-      )-    {-# INLINE (>) #-}--    FloatX3# a1 a2 a3 < FloatX3# b1 b2 b3 =-      isTrue#-      (       (a1 `ltFloat#` b1)-      `andI#` (a2 `ltFloat#` b2)-      `andI#` (a3 `ltFloat#` b3)-      )-    {-# INLINE (<) #-}--    FloatX3# a1 a2 a3 >= FloatX3# b1 b2 b3 =-      isTrue#-      (       (a1 `geFloat#` b1)-      `andI#` (a2 `geFloat#` b2)-      `andI#` (a3 `geFloat#` b3)-      )-    {-# INLINE (>=) #-}--    FloatX3# a1 a2 a3 <= FloatX3# b1 b2 b3 =-      isTrue#-      (       (a1 `leFloat#` b1)-      `andI#` (a2 `leFloat#` b2)-      `andI#` (a3 `leFloat#` b3)-      )-    {-# INLINE (<=) #-}--    -- | Compare lexicographically-    compare (FloatX3# a1 a2 a3) (FloatX3# b1 b2 b3)-      | isTrue# (a1 `gtFloat#` b1) = GT-      | isTrue# (a1 `ltFloat#` b1) = LT-      | isTrue# (a2 `gtFloat#` b2) = GT-      | isTrue# (a2 `ltFloat#` b2) = LT-      | isTrue# (a3 `gtFloat#` b3) = GT-      | isTrue# (a3 `ltFloat#` b3) = LT-      | otherwise = EQ-    {-# INLINE compare #-}--    -- | Element-wise minimum-    min (FloatX3# a1 a2 a3) (FloatX3# b1 b2 b3) = FloatX3#-      (if isTrue# (a1 `gtFloat#` b1) then b1 else a1)-      (if isTrue# (a2 `gtFloat#` b2) then b2 else a2)-      (if isTrue# (a3 `gtFloat#` b3) then b3 else a3)-    {-# INLINE min #-}--    -- | Element-wise maximum-    max (FloatX3# a1 a2 a3) (FloatX3# b1 b2 b3) = FloatX3#-      (if isTrue# (a1 `gtFloat#` b1) then a1 else b1)-      (if isTrue# (a2 `gtFloat#` b2) then a2 else b2)-      (if isTrue# (a3 `gtFloat#` b3) then a3 else b3)-    {-# INLINE max #-}------ | element-wise operations for vectors-instance Num FloatX3 where--    FloatX3# a1 a2 a3 + FloatX3# b1 b2 b3-      = FloatX3# (plusFloat# a1 b1) (plusFloat# a2 b2) (plusFloat# a3 b3)-    {-# INLINE (+) #-}--    FloatX3# a1 a2 a3 - FloatX3# b1 b2 b3-      = FloatX3# (minusFloat# a1 b1) (minusFloat# a2 b2) (minusFloat# a3 b3)-    {-# INLINE (-) #-}--    FloatX3# a1 a2 a3 * FloatX3# b1 b2 b3-      = FloatX3# (timesFloat# a1 b1) (timesFloat# a2 b2) (timesFloat# a3 b3)-    {-# INLINE (*) #-}--    negate (FloatX3# a1 a2 a3) = FloatX3#-      (negateFloat# a1) (negateFloat# a2) (negateFloat# a3)-    {-# INLINE negate #-}--    abs (FloatX3# a1 a2 a3)-      = FloatX3#-      (if isTrue# (a1 `geFloat#` 0.0#) then a1 else negateFloat# a1)-      (if isTrue# (a2 `geFloat#` 0.0#) then a2 else negateFloat# a2)-      (if isTrue# (a3 `geFloat#` 0.0#) then a3 else negateFloat# a3)-    {-# INLINE abs #-}--    signum (FloatX3# a1 a2 a3)-      = FloatX3# (if isTrue# (a1 `gtFloat#` 0.0#)-                  then 1.0#-                  else if isTrue# (a1 `ltFloat#` 0.0#) then -1.0# else 0.0# )-                 (if isTrue# (a2 `gtFloat#` 0.0#)-                  then 1.0#-                  else if isTrue# (a2 `ltFloat#` 0.0#) then -1.0# else 0.0# )-                 (if isTrue# (a3 `gtFloat#` 0.0#)-                  then 1.0#-                  else if isTrue# (a3 `ltFloat#` 0.0#) then -1.0# else 0.0# )-    {-# INLINE signum #-}--    fromInteger n = case fromInteger n of F# x -> FloatX3# x x x-    {-# INLINE fromInteger #-}----instance Fractional FloatX3 where--    FloatX3# a1 a2 a3 / FloatX3# b1 b2 b3 = FloatX3#-      (divideFloat# a1 b1) (divideFloat# a2 b2) (divideFloat# a3 b3)-    {-# INLINE (/) #-}--    recip (FloatX3# a1 a2 a3) = FloatX3#-      (divideFloat# 1.0# a1) (divideFloat# 1.0# a2) (divideFloat# 1.0# a3)-    {-# INLINE recip #-}--    fromRational r = case fromRational r of F# x -> FloatX3# x x x-    {-# INLINE fromRational #-}----instance Floating FloatX3 where--    pi = FloatX3#-      3.141592653589793238#-      3.141592653589793238#-      3.141592653589793238#-    {-# INLINE pi #-}--    exp (FloatX3# a1 a2 a3) = FloatX3#-      (expFloat# a1) (expFloat# a2) (expFloat# a3)-    {-# INLINE exp #-}--    log (FloatX3# a1 a2 a3) = FloatX3#-      (logFloat# a1) (logFloat# a2) (logFloat# a3)-    {-# INLINE log #-}--    sqrt (FloatX3# a1 a2 a3) = FloatX3#-      (sqrtFloat# a1) (sqrtFloat# a2) (sqrtFloat# a3)-    {-# INLINE sqrt #-}--    sin (FloatX3# a1 a2 a3) = FloatX3#-      (sinFloat# a1) (sinFloat# a2) (sinFloat# a3)-    {-# INLINE sin #-}--    cos (FloatX3# a1 a2 a3) = FloatX3#-      (cosFloat# a1) (cosFloat# a2) (cosFloat# a3)-    {-# INLINE cos #-}--    tan (FloatX3# a1 a2 a3) = FloatX3#-      (tanFloat# a1) (tanFloat# a2) (tanFloat# a3)-    {-# INLINE tan #-}--    asin (FloatX3# a1 a2 a3) = FloatX3#-      (asinFloat# a1) (asinFloat# a2) (asinFloat# a3)-    {-# INLINE asin #-}--    acos (FloatX3# a1 a2 a3) = FloatX3#-      (acosFloat# a1) (acosFloat# a2) (acosFloat# a3)-    {-# INLINE acos #-}--    atan (FloatX3# a1 a2 a3) = FloatX3#-      (atanFloat# a1) (atanFloat# a2) (atanFloat# a3)-    {-# INLINE atan #-}--    sinh (FloatX3# a1 a2 a3) = FloatX3#-      (sinhFloat# a1) (sinhFloat# a2) (sinhFloat# a3)-    {-# INLINE sinh #-}--    cosh (FloatX3# a1 a2 a3) = FloatX3#-      (coshFloat# a1) (coshFloat# a2) (coshFloat# a3)-    {-# INLINE cosh #-}--    tanh (FloatX3# a1 a2 a3) = FloatX3#-      (tanhFloat# a1) (tanhFloat# a2) (tanhFloat# a3)-    {-# INLINE tanh #-}--    FloatX3# a1 a2 a3 ** FloatX3# b1 b2 b3 = FloatX3#-      (powerFloat# a1 b1) (powerFloat# a2 b2) (powerFloat# a3 b3)-    {-# INLINE (**) #-}--    logBase x y         =  log y / log x-    {-# INLINE logBase #-}--    asinh x = log (x + sqrt (1.0+x*x))-    {-# INLINE asinh #-}--    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    {-# INLINE acosh #-}--    atanh x = 0.5 * log ((1.0+x) / (1.0-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 3--instance PrimBytes FloatX3 where--    getBytes (FloatX3# a1 a2 a3) = case runRW#-       ( \s0 -> case newByteArray# (byteSize @FloatX3 undefined) s0 of-           (# s1, marr #) -> case writeFloatArray# marr 0# a1 s1 of-             s2 -> case writeFloatArray# marr 1# a2 s2 of-               s3 -> case writeFloatArray# marr 2# a3 s3 of-                 s4 -> unsafeFreezeByteArray# marr s4-       ) of (# _, a #) -> a-    {-# INLINE getBytes #-}--    fromBytes off arr-      | i <- BOFF_TO_PRIMOFF(off)-      = FloatX3#-      (indexFloatArray# arr i)-      (indexFloatArray# arr (i +# 1#))-      (indexFloatArray# arr (i +# 2#))-    {-# INLINE fromBytes #-}--    readBytes mba off s0-      | i <- BOFF_TO_PRIMOFF(off)-      = case readFloatArray# mba i s0 of-      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)-    {-# INLINE readBytes #-}--    writeBytes mba off (FloatX3# a1 a2 a3) s-      | i <- BOFF_TO_PRIMOFF(off)-      = writeFloatArray# mba (i +# 2#) a3-      ( writeFloatArray# mba (i +# 1#) a2-      ( writeFloatArray# mba  i        a1 s ))-    {-# INLINE writeBytes #-}--    readAddr addr s0-      = case readFloatOffAddr# addr 0# s0 of-      (# s1, a1 #) -> case readFloatOffAddr# addr 1# s1 of-        (# s2, a2 #) -> case readFloatOffAddr# addr 2# s2 of-          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)-    {-# INLINE readAddr #-}--    writeAddr (FloatX3# a1 a2 a3) addr s-      = writeFloatOffAddr# addr 2# a3-      ( writeFloatOffAddr# addr 1# a2-      ( writeFloatOffAddr# addr 0# a1 s ))-    {-# INLINE writeAddr #-}--    byteSize _ = byteSize @Float undefined *# ELEM_N#-    {-# INLINE byteSize #-}--    byteAlign _ = byteAlign @Float undefined-    {-# INLINE byteAlign #-}--    byteOffset _ = 0#-    {-# INLINE byteOffset #-}--    indexArray ba off-      | i <- off *# ELEM_N#-      = FloatX3#-      (indexFloatArray# ba i)-      (indexFloatArray# ba (i +# 1#))-      (indexFloatArray# ba (i +# 2#))-    {-# INLINE indexArray #-}--    readArray mba off s0-      | i <- off *# ELEM_N#-      = case readFloatArray# mba i s0 of-      (# s1, a1 #) -> case readFloatArray# mba (i +# 1#) s1 of-        (# s2, a2 #) -> case readFloatArray# mba (i +# 2#) s2 of-          (# s3, a3 #) -> (# s3, FloatX3# a1 a2 a3 #)-    {-# INLINE readArray #-}--    writeArray mba off (FloatX3# a1 a2 a3) s-      | i <- off *# ELEM_N#-      = writeFloatArray# mba (i +# 2#) a3-      ( writeFloatArray# mba (i +# 1#) a2-      ( writeFloatArray# mba  i        a1 s ))-    {-# INLINE writeArray #-}---instance PrimArray Float FloatX3 where--    broadcast (F# x) = FloatX3# x x x-    {-# INLINE broadcast #-}--    ix# 0# (FloatX3# a1 _ _) = F# a1-    ix# 1# (FloatX3# _ a2 _) = F# a2-    ix# 2# (FloatX3# _ _ a3) = F# a3-    ix# _   _                = undefined-    {-# INLINE ix# #-}--    gen# _ f s0 = case f s0 of-      (# s1, F# a1 #) -> case f s1 of-        (# s2, F# a2 #) -> case f s2 of-          (# s3, F# a3 #) -> (# s3, FloatX3# a1 a2 a3 #)---    upd# _ 0# (F# q) (FloatX3# _ y z) = FloatX3# q y z-    upd# _ 1# (F# q) (FloatX3# x _ z) = FloatX3# x q z-    upd# _ 2# (F# q) (FloatX3# x y _) = FloatX3# x y q-    upd# _ _ _ x                      = x-    {-# INLINE upd# #-}--    elemOffset _ = 0#-    {-# INLINE elemOffset #-}--    elemSize0 _  = ELEM_N#-    {-# INLINE elemSize0 #-}--    fromElems off _ ba = FloatX3#-      (indexFloatArray# ba off)-      (indexFloatArray# ba (off +# 1#))-      (indexFloatArray# ba (off +# 2#))-    {-# INLINE fromElems #-}