{-# LANGUAGE CPP                   #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds             #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeInType            #-}
{-# LANGUAGE TypeOperators         #-}
module Numeric.Subroutine.Sort
  ( SortBy (..), sortBy, sort
  , SortableDataFrame
  ) where


import Control.Monad
import Control.Monad.ST
import Control.Monad.ST.Unsafe
import Data.Kind
import Data.Type.Lits
import Numeric.DataFrame.Internal.PrimArray
import Numeric.DataFrame.ST
import Numeric.DataFrame.Type
import Numeric.Dimensions
import Unsafe.Coerce

-- | Sort a @DataFrame@ along the first dimension.
--
--   Note: the elements (which are of type @DataFrame t ns@) are compared
--         lexicographically.
sort :: forall (t :: Type) n ns
      . ( SortableDataFrame t (n ': ns), Ord t, SortBy n)
     => DataFrame t (n ': ns)
     -> DataFrame t (n ': ns)
sort :: DataFrame t (n : ns) -> DataFrame t (n : ns)
sort DataFrame t (n : ns)
df = case KnownDimKind k => DimKind k
forall k. KnownDimKind k => DimKind k
dimKind @(KindOf n) of
    DimKind k
DimKNat  -> case DataFrame t (n : ns) -> Either t CumulDims
forall t a. PrimArray t a => a -> Either t CumulDims
uniqueOrCumulDims DataFrame t (n : ns)
df of
      Left t
_ -> DataFrame t (n : ns)
df -- all equal, no need for sorting.
      Right CumulDims
steps
        | SomeDims (Dims ns
Dims :: Dims ms) <- CumulDims -> SomeDims
fromSteps CumulDims
steps
        , Dict (ns ~ ns)
Dict <- (Dict (ns ~ ns) -> Dict (ns ~ ns)
forall a b. a -> b
unsafeCoerce ((ns ~ ns) => Dict (ns ~ ns)
forall (a :: Constraint). a => Dict a
Dict @(ns ~ ns)) :: Dict (ns ~ ms))
          -> (DataFrame t ns -> DataFrame t ns -> Ordering)
-> DataFrame t (n : ns) -> DataFrame t (n : ns)
forall k t (n :: k) (ns :: [k]).
(SortableDataFrame t (n : ns), SortBy n) =>
(DataFrame t ns -> DataFrame t ns -> Ordering)
-> DataFrame t (n : ns) -> DataFrame t (n : ns)
sortBy DataFrame t ns -> DataFrame t ns -> Ordering
forall a. Ord a => a -> a -> Ordering
compare DataFrame t (n : ns)
df
        | Bool
otherwise
          -> [Char] -> DataFrame t (n : ns)
forall a. HasCallStack => [Char] -> a
error [Char]
"sort/DimNat/uniqueOrCumulDims -- impossible pattern"
    DimKind k
DimKXNat
        | XFrame (df' :: DataFrame t ms) <- DataFrame t (n : ns)
df
        , Dim y
D :* Dims ys
Dims <- Dimensions ns => TypedList Dim ns
forall k (ds :: [k]). Dimensions ds => Dims ds
dims @ms
          -> DataFrame t (Head ns : Tail ns) -> DataFrame t (n : ns)
forall l (ts :: l) (xns :: [XNat]) (ns :: [Nat]).
(All KnownDimType xns, FixedDims xns ns, Dimensions ns,
 KnownBackends ts ns) =>
DataFrame ts ns -> DataFrame ts xns
XFrame ((DataFrame t (Tail ns) -> DataFrame t (Tail ns) -> Ordering)
-> DataFrame t (Head ns : Tail ns)
-> DataFrame t (Head ns : Tail ns)
forall k t (n :: k) (ns :: [k]).
(SortableDataFrame t (n : ns), SortBy n) =>
(DataFrame t ns -> DataFrame t ns -> Ordering)
-> DataFrame t (n : ns) -> DataFrame t (n : ns)
sortBy DataFrame t (Tail ns) -> DataFrame t (Tail ns) -> Ordering
forall a. Ord a => a -> a -> Ordering
compare DataFrame t ns
DataFrame t (Head ns : Tail ns)
df')
        | Bool
otherwise
          -> [Char] -> DataFrame t (n : ns)
forall a. HasCallStack => [Char] -> a
error [Char]
"sort/DimXNat -- impossible pattern"
{-# ANN sort "HLint: ignore Use sort" #-}

-- | Sort a @DataFrame@ along the first dimension using given comparison function.
sortBy :: forall (t :: Type) n ns
        . ( SortableDataFrame t (n ': ns)
          , SortBy n)
       => (DataFrame t ns -> DataFrame t ns -> Ordering)
       -> DataFrame t (n ': ns)
       -> DataFrame t (n ': ns)
sortBy :: (DataFrame t ns -> DataFrame t ns -> Ordering)
-> DataFrame t (n : ns) -> DataFrame t (n : ns)
sortBy DataFrame t ns -> DataFrame t ns -> Ordering
cmp DataFrame t (n : ns)
df = case KnownDimKind k => DimKind k
forall k. KnownDimKind k => DimKind k
dimKind @(KindOf n) of
    DimKind k
DimKNat -> (forall s. ST s (DataFrame t (n : ns))) -> DataFrame t (n : ns)
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (DataFrame t (n : ns))) -> DataFrame t (n : ns))
-> (forall s. ST s (DataFrame t (n : ns))) -> DataFrame t (n : ns)
forall a b. (a -> b) -> a -> b
$
      ((STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns)))
 -> DataFrame t (n : ns) -> ST s (DataFrame t (n : ns)))
-> DataFrame t (n : ns)
-> (STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns)))
-> ST s (DataFrame t (n : ns))
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((t -> ST s (DataFrame t (n : ns)))
-> (STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns)))
-> DataFrame t (n : ns)
-> ST s (DataFrame t (n : ns))
forall k t (ns :: [k]) r s.
PrimArray t (DataFrame t ns) =>
(t -> ST s r)
-> (STDataFrame s t ns -> ST s r) -> DataFrame t ns -> ST s r
withThawDataFrame (ST s (DataFrame t (n : ns)) -> t -> ST s (DataFrame t (n : ns))
forall a b. a -> b -> a
const (ST s (DataFrame t (n : ns)) -> t -> ST s (DataFrame t (n : ns)))
-> ST s (DataFrame t (n : ns)) -> t -> ST s (DataFrame t (n : ns))
forall a b. (a -> b) -> a -> b
$ DataFrame t (n : ns) -> ST s (DataFrame t (n : ns))
forall (f :: * -> *) a. Applicative f => a -> f a
pure DataFrame t (n : ns)
df)) DataFrame t (n : ns)
df ((STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns)))
 -> ST s (DataFrame t (n : ns)))
-> (STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns)))
-> ST s (DataFrame t (n : ns))
forall a b. (a -> b) -> a -> b
$ \STDataFrame s t (n : ns)
mdf -> do
        (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (n : ns) -> ST s ()
forall k (n :: k) t s (ns :: [k]).
(SortBy n, PrimBytes t) =>
(STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (n : ns) -> ST s ()
sortByInplace
          (\STDataFrame s t ns
x STDataFrame s t ns
y -> DataFrame t ns -> DataFrame t ns -> Ordering
cmp (DataFrame t ns -> DataFrame t ns -> Ordering)
-> ST s (DataFrame t ns) -> ST s (DataFrame t ns -> Ordering)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> STDataFrame s t ns -> ST s (DataFrame t ns)
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
unsafeFreezeDataFrame STDataFrame s t ns
x ST s (DataFrame t ns -> Ordering)
-> ST s (DataFrame t ns) -> ST s Ordering
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> STDataFrame s t ns -> ST s (DataFrame t ns)
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
unsafeFreezeDataFrame STDataFrame s t ns
y)
          STDataFrame s t (n : ns)
mdf
        STDataFrame s t (n : ns) -> ST s (DataFrame t (n : ns))
forall k t (ns :: [k]) s.
PrimArray t (DataFrame t ns) =>
STDataFrame s t ns -> ST s (DataFrame t ns)
unsafeFreezeDataFrame STDataFrame s t (n : ns)
mdf
    DimKind k
DimKXNat
      | XFrame dfN <- DataFrame t (n : ns)
df
      , Dim y
D :* Dims ys
Dims <- TypedList Dim ns
forall k (ds :: [k]). Dimensions ds => Dims ds
dims TypedList Dim ns -> DataFrame t ns -> TypedList Dim ns
forall k (ds :: k) (p :: k -> *) (q :: k -> *).
p ds -> q ds -> p ds
`inSpaceOf` DataFrame t ns
dfN
        -> DataFrame t (Head ns : Tail ns) -> DataFrame t (n : ns)
forall l (ts :: l) (xns :: [XNat]) (ns :: [Nat]).
(All KnownDimType xns, FixedDims xns ns, Dimensions ns,
 KnownBackends ts ns) =>
DataFrame ts ns -> DataFrame ts xns
XFrame ((DataFrame t (Tail ns) -> DataFrame t (Tail ns) -> Ordering)
-> DataFrame t (Head ns : Tail ns)
-> DataFrame t (Head ns : Tail ns)
forall k t (n :: k) (ns :: [k]).
(SortableDataFrame t (n : ns), SortBy n) =>
(DataFrame t ns -> DataFrame t ns -> Ordering)
-> DataFrame t (n : ns) -> DataFrame t (n : ns)
sortBy (\DataFrame t (Tail ns)
a DataFrame t (Tail ns)
b -> DataFrame t ns -> DataFrame t ns -> Ordering
cmp (DataFrame t (Tail ns) -> DataFrame t ns
forall l (ts :: l) (xns :: [XNat]) (ns :: [Nat]).
(All KnownDimType xns, FixedDims xns ns, Dimensions ns,
 KnownBackends ts ns) =>
DataFrame ts ns -> DataFrame ts xns
XFrame DataFrame t (Tail ns)
a) (DataFrame t (Tail ns) -> DataFrame t ns
forall l (ts :: l) (xns :: [XNat]) (ns :: [Nat]).
(All KnownDimType xns, FixedDims xns ns, Dimensions ns,
 KnownBackends ts ns) =>
DataFrame ts ns -> DataFrame ts xns
XFrame DataFrame t (Tail ns)
b)) DataFrame t ns
DataFrame t (Head ns : Tail ns)
dfN)
      | Bool
otherwise
        -> [Char] -> DataFrame t (n : ns)
forall a. HasCallStack => [Char] -> a
error [Char]
"sortBy/DimXNat -- impossible pattern"

-- | The required context for sorting a DataFrame is slightly different
--   for @Nat@ and @XNat@ indexed arrays.
--   This type family abstracts away the difference.
type family SortableDataFrame (t :: Type) (ns :: [k]) :: Constraint where
    SortableDataFrame t ((n ': ns) :: [Nat])
      = (PrimArray t (DataFrame t ns), PrimArray t (DataFrame t (n ': ns)))
    SortableDataFrame t ((n ': ns) :: [XNat])
      = PrimBytes t


class BoundedDim n => SortBy n where
    -- | Note, "Inplace" here means the input frame is modified.
    --   It does not mean the algorithm does not use extra space (it does use).
    sortByInplace :: PrimBytes t
                  => (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
                      -- ^ must not modify state!
                  -> STDataFrame s t (n ': ns)
                  -> ST s ()


instance SortBy 0 where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (0 : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
_ STDataFrame s t (0 : ns)
_ = () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance SortBy 1 where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (1 : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
_ STDataFrame s t (1 : ns)
_ = () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance SortBy 2 where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (2 : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t (2 : ns)
xs = STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t ns
a STDataFrame s t ns
b ST s Ordering -> (Ordering -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Ordering
GT -> do
          STDataFrame s t ns
tmp <- STDataFrame s t ns -> ST s (STDataFrame s t ns)
forall k t (ns :: [k]) s.
STDataFrame s t ns -> ST s (STDataFrame s t ns)
oneMoreDataFrame STDataFrame s t ns
a
          STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b
        Ordering
_  -> () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      where
        a :: STDataFrame s t ns
a = Idxs '[2] -> STDataFrame s t (2 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 2
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
0 Idx 2 -> TypedList Idx '[] -> Idxs '[2]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (2 : ns)
xs
        b :: STDataFrame s t ns
b = Idxs '[2] -> STDataFrame s t (2 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 2
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
1 Idx 2 -> TypedList Idx '[] -> Idxs '[2]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (2 : ns)
xs

instance SortBy 3 where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (3 : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t (3 : ns)
xs = ST s (ST s ()) -> ST s ()
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (ST s (ST s ()) -> ST s ()) -> ST s (ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$
        STDataFrame s t ns -> Ordering -> Ordering -> Ordering -> ST s ()
go (STDataFrame s t ns -> Ordering -> Ordering -> Ordering -> ST s ())
-> ST s (STDataFrame s t ns)
-> ST s (Ordering -> Ordering -> Ordering -> ST s ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ST s (STDataFrame s t ns) -> ST s (STDataFrame s t ns)
forall s a. ST s a -> ST s a
unsafeDupableInterleaveST (STDataFrame s t ns -> ST s (STDataFrame s t ns)
forall k t (ns :: [k]) s.
STDataFrame s t ns -> ST s (STDataFrame s t ns)
oneMoreDataFrame STDataFrame s t ns
a)
           ST s (Ordering -> Ordering -> Ordering -> ST s ())
-> ST s Ordering -> ST s (Ordering -> Ordering -> ST s ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t ns
a STDataFrame s t ns
b ST s (Ordering -> Ordering -> ST s ())
-> ST s Ordering -> ST s (Ordering -> ST s ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t ns
b STDataFrame s t ns
c ST s (Ordering -> ST s ()) -> ST s Ordering -> ST s (ST s ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t ns
a STDataFrame s t ns
c
      where
        a :: STDataFrame s t ns
a = Idxs '[3] -> STDataFrame s t (3 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 3
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
0 Idx 3 -> TypedList Idx '[] -> Idxs '[3]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (3 : ns)
xs
        b :: STDataFrame s t ns
b = Idxs '[3] -> STDataFrame s t (3 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 3
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
1 Idx 3 -> TypedList Idx '[] -> Idxs '[3]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (3 : ns)
xs
        c :: STDataFrame s t ns
c = Idxs '[3] -> STDataFrame s t (3 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 3
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
2 Idx 3 -> TypedList Idx '[] -> Idxs '[3]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (3 : ns)
xs
        go :: STDataFrame s t ns -> Ordering -> Ordering -> Ordering -> ST s ()
go STDataFrame s t ns
tmp Ordering
GT Ordering
LT Ordering
GT -- b < c < a
          = STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> ST s ()
swap3DF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b STDataFrame s t ns
c
        go STDataFrame s t ns
tmp Ordering
LT Ordering
GT Ordering
GT -- c < a < b
          = STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> ST s ()
swap3DF STDataFrame s t ns
tmp STDataFrame s t ns
b STDataFrame s t ns
a STDataFrame s t ns
c
        go STDataFrame s t ns
tmp Ordering
GT Ordering
bc Ordering
ac | Ordering
bc Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT Bool -> Bool -> Bool
&& Ordering
ac Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT
          = STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b
        go STDataFrame s t ns
tmp Ordering
ab Ordering
GT Ordering
ac | Ordering
ab Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT Bool -> Bool -> Bool
&& Ordering
ac Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT
          = STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
b STDataFrame s t ns
c
        go STDataFrame s t ns
tmp Ordering
ab Ordering
bc Ordering
GT | Ordering
ab Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& Ordering
bc Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT
          = STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
c
        go STDataFrame s t ns
_ Ordering
_ Ordering
_ Ordering
_ = () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance SortBy 4 where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (4 : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t (4 : ns)
xs = do
        STDataFrame s t ns
tmp <- ST s (STDataFrame s t ns) -> ST s (STDataFrame s t ns)
forall s a. ST s a -> ST s a
unsafeDupableInterleaveST (STDataFrame s t ns -> ST s (STDataFrame s t ns)
forall k t (ns :: [k]) s.
STDataFrame s t ns -> ST s (STDataFrame s t ns)
oneMoreDataFrame STDataFrame s t ns
a)
        STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
c
        STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
b STDataFrame s t ns
d
        STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b
        STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
c STDataFrame s t ns
d
        STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
b STDataFrame s t ns
c
      where
        a :: STDataFrame s t ns
a = Idxs '[4] -> STDataFrame s t (4 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 4
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
0 Idx 4 -> TypedList Idx '[] -> Idxs '[4]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (4 : ns)
xs
        b :: STDataFrame s t ns
b = Idxs '[4] -> STDataFrame s t (4 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 4
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
1 Idx 4 -> TypedList Idx '[] -> Idxs '[4]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (4 : ns)
xs
        c :: STDataFrame s t ns
c = Idxs '[4] -> STDataFrame s t (4 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 4
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
2 Idx 4 -> TypedList Idx '[] -> Idxs '[4]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (4 : ns)
xs
        d :: STDataFrame s t ns
d = Idxs '[4] -> STDataFrame s t (4 : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx 4
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
3 Idx 4 -> TypedList Idx '[] -> Idxs '[4]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (4 : ns)
xs
        cmpSwap :: STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
cmpSwap STDataFrame s t ns
tmp STDataFrame s t ns
x STDataFrame s t ns
y = STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp STDataFrame s t ns
x STDataFrame s t ns
y ST s Ordering -> (Ordering -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
          Ordering
GT -> STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall s t (ns :: [Nat]).
PrimBytes t =>
STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
x STDataFrame s t ns
y
          Ordering
_  -> () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance {-# INCOHERENT #-}
         KnownDim n => SortBy (n :: Nat) where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (n : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp (STDataFrame s t (n : ns)
xs :: STDataFrame s t (n ': ns)) = do
        STDataFrame s t (n : ns)
tmp <- STDataFrame s t (n : ns) -> ST s (STDataFrame s t (n : ns))
forall k t (ns :: [k]) s.
STDataFrame s t ns -> ST s (STDataFrame s t ns)
oneMoreDataFrame STDataFrame s t (n : ns)
xs
        TypedList Idx '[]
-> STDataFrame s t (n : ns) -> STDataFrame s t (n : ns) -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t (n : ns)
xs STDataFrame s t (n : ns)
tmp
        Dim n
-> STDataFrame s t (n : ns) -> STDataFrame s t (n : ns) -> ST s ()
forall (d :: Nat).
Dim d
-> STDataFrame s t (d : ns) -> STDataFrame s t (d : ns) -> ST s ()
mergeSort Dim n
forall k (d :: k). (KnownDimType d, k ~ Nat, KnownDim d) => Dim d
D STDataFrame s t (n : ns)
tmp STDataFrame s t (n : ns)
xs
      where
        mergeSort :: Dim (d :: Nat)
                  -> STDataFrame s t (d ': ns)
                  -> STDataFrame s t (d ': ns)
                  -> ST s ()
        mergeSort :: Dim d
-> STDataFrame s t (d : ns) -> STDataFrame s t (d : ns) -> ST s ()
mergeSort Dim d
D0 STDataFrame s t (d : ns)
_ STDataFrame s t (d : ns)
_ = () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
        mergeSort Dim d
D1 STDataFrame s t (d : ns)
_ STDataFrame s t (d : ns)
_ = () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
        mergeSort (d :: Dim d
d@Dim d
D :: Dim d) STDataFrame s t (d : ns)
b STDataFrame s t (d : ns)
a = do
          d2l :: Dim (Div d 2)
d2l@Dim (Div d 2)
D <- Dim (Div d 2) -> ST s (Dim (Div d 2))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Dim (Div d 2) -> ST s (Dim (Div d 2)))
-> Dim (Div d 2) -> ST s (Dim (Div d 2))
forall a b. (a -> b) -> a -> b
$ Dim d -> Dim 2 -> Dim (Div d 2)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (Div n m)
divDim Dim d
d Dim 2
forall (n :: Nat). (n ~ 2) => Dim n
D2
          Just d2r :: Dim (d - Div d 2)
d2r@Dim (d - Div d 2)
D <- Maybe (Dim (d - Div d 2)) -> ST s (Maybe (Dim (d - Div d 2)))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Dim (d - Div d 2)) -> ST s (Maybe (Dim (d - Div d 2))))
-> Maybe (Dim (d - Div d 2)) -> ST s (Maybe (Dim (d - Div d 2)))
forall a b. (a -> b) -> a -> b
$ Dim d -> Dim (Div d 2) -> Maybe (Dim (d - Div d 2))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Maybe (Dim (n - m))
minusDimM Dim d
d Dim (Div d 2)
d2l
          d2li :: Dim (Div d 2 + 1)
d2li@Dim (Div d 2 + 1)
D <- Dim (Div d 2 + 1) -> ST s (Dim (Div d 2 + 1))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Dim (Div d 2 + 1) -> ST s (Dim (Div d 2 + 1)))
-> Dim (Div d 2 + 1) -> ST s (Dim (Div d 2 + 1))
forall a b. (a -> b) -> a -> b
$ Dim (Div d 2) -> Dim 1 -> Dim (Div d 2 + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim (Div d 2)
d2l Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1
          d2ri :: Dim ((d - Div d 2) + 1)
d2ri@Dim ((d - Div d 2) + 1)
D <- Dim ((d - Div d 2) + 1) -> ST s (Dim ((d - Div d 2) + 1))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Dim ((d - Div d 2) + 1) -> ST s (Dim ((d - Div d 2) + 1)))
-> Dim ((d - Div d 2) + 1) -> ST s (Dim ((d - Div d 2) + 1))
forall a b. (a -> b) -> a -> b
$ Dim (d - Div d 2) -> Dim 1 -> Dim ((d - Div d 2) + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim (d - Div d 2)
d2r Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1
          Just Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2)))
Dict <- Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2))))
-> ST s (Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2)))))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2))))
 -> ST s (Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2))))))
-> Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2))))
-> ST s (Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2)))))
forall a b. (a -> b) -> a -> b
$ Dim (d + 1)
-> Dim ((Div d 2 + 1) + (d - Div d 2))
-> Maybe (Dict ((d + 1) ~ ((Div d 2 + 1) + (d - Div d 2))))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim d -> Dim 1 -> Dim (d + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim d
d Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim (Div d 2 + 1)
-> Dim (d - Div d 2) -> Dim ((Div d 2 + 1) + (d - Div d 2))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim (Div d 2 + 1)
d2li Dim (d - Div d 2)
d2r)
          Just Dict
  (((Div d 2 + 1) + (d - Div d 2)) ~ (((d - Div d 2) + 1) + Div d 2))
Dict <- Maybe
  (Dict
     (((Div d 2 + 1) + (d - Div d 2))
      ~ (((d - Div d 2) + 1) + Div d 2)))
-> ST
     s
     (Maybe
        (Dict
           (((Div d 2 + 1) + (d - Div d 2))
            ~ (((d - Div d 2) + 1) + Div d 2))))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe
   (Dict
      (((Div d 2 + 1) + (d - Div d 2))
       ~ (((d - Div d 2) + 1) + Div d 2)))
 -> ST
      s
      (Maybe
         (Dict
            (((Div d 2 + 1) + (d - Div d 2))
             ~ (((d - Div d 2) + 1) + Div d 2)))))
-> Maybe
     (Dict
        (((Div d 2 + 1) + (d - Div d 2))
         ~ (((d - Div d 2) + 1) + Div d 2)))
-> ST
     s
     (Maybe
        (Dict
           (((Div d 2 + 1) + (d - Div d 2))
            ~ (((d - Div d 2) + 1) + Div d 2))))
forall a b. (a -> b) -> a -> b
$ Dim ((Div d 2 + 1) + (d - Div d 2))
-> Dim (((d - Div d 2) + 1) + Div d 2)
-> Maybe
     (Dict
        (((Div d 2 + 1) + (d - Div d 2))
         ~ (((d - Div d 2) + 1) + Div d 2)))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim d -> Dim 1 -> Dim (d + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim d
d Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim ((d - Div d 2) + 1)
-> Dim (Div d 2) -> Dim (((d - Div d 2) + 1) + Div d 2)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ((d - Div d 2) + 1)
d2ri Dim (Div d 2)
d2l)
          let leA :: STDataFrame s t (Div d 2 :+ ns)
leA = Idxs ('[] +: ((d - Div d 2) + 1))
-> STDataFrame s t (d : ns) -> STDataFrame s t (Div d 2 :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @d @(d - Div d 2 + 1) @(Div d 2) @'[]
                                     (Word -> Idx ((d - Div d 2) + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
0 Idx ((d - Div d 2) + 1)
-> TypedList Idx '[] -> TypedList Idx '[(d - Div d 2) + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (d : ns)
a
              riA :: STDataFrame s t ((d - Div d 2) :+ ns)
riA = Idxs ('[] +: (Div d 2 + 1))
-> STDataFrame s t (d : ns)
-> STDataFrame s t ((d - Div d 2) :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @d @(Div d 2 + 1) @(d - Div d 2) @'[]
                                     (Word -> Idx (Div d 2 + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx (Dim (Div d 2) -> Word
forall k (x :: k). Dim x -> Word
dimVal Dim (Div d 2)
d2l) Idx (Div d 2 + 1)
-> TypedList Idx '[] -> TypedList Idx '[Div d 2 + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (d : ns)
a
              leB :: STDataFrame s t (Div d 2 :+ ns)
leB = Idxs ('[] +: ((d - Div d 2) + 1))
-> STDataFrame s t (d : ns) -> STDataFrame s t (Div d 2 :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @d @(d - Div d 2 + 1) @(Div d 2) @'[]
                                     (Word -> Idx ((d - Div d 2) + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
0 Idx ((d - Div d 2) + 1)
-> TypedList Idx '[] -> TypedList Idx '[(d - Div d 2) + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (d : ns)
b
              riB :: STDataFrame s t ((d - Div d 2) :+ ns)
riB = Idxs ('[] +: (Div d 2 + 1))
-> STDataFrame s t (d : ns)
-> STDataFrame s t ((d - Div d 2) :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @d @(Div d 2 + 1) @(d - Div d 2) @'[]
                                     (Word -> Idx (Div d 2 + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx (Dim (Div d 2) -> Word
forall k (x :: k). Dim x -> Word
dimVal Dim (Div d 2)
d2l) Idx (Div d 2 + 1)
-> TypedList Idx '[] -> TypedList Idx '[Div d 2 + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (d : ns)
b
          Dim (Div d 2)
-> STDataFrame s t (Div d 2 :+ ns)
-> STDataFrame s t (Div d 2 :+ ns)
-> ST s ()
forall (d :: Nat).
Dim d
-> STDataFrame s t (d : ns) -> STDataFrame s t (d : ns) -> ST s ()
mergeSort Dim (Div d 2)
d2l STDataFrame s t (Div d 2 :+ ns)
leA STDataFrame s t (Div d 2 :+ ns)
leB
          Dim (d - Div d 2)
-> STDataFrame s t ((d - Div d 2) :+ ns)
-> STDataFrame s t ((d - Div d 2) :+ ns)
-> ST s ()
forall (d :: Nat).
Dim d
-> STDataFrame s t (d : ns) -> STDataFrame s t (d : ns) -> ST s ()
mergeSort Dim (d - Div d 2)
d2r STDataFrame s t ((d - Div d 2) :+ ns)
riA STDataFrame s t ((d - Div d 2) :+ ns)
riB
          Dim (Div d 2)
-> Dim (d - Div d 2)
-> Dim d
-> STDataFrame s t (Div d 2 :+ ns)
-> STDataFrame s t ((d - Div d 2) :+ ns)
-> STDataFrame s t (d : ns)
-> ST s ()
forall (a :: Nat) (b :: Nat) (ab :: Nat).
Dim a
-> Dim b
-> Dim ab
-> STDataFrame s t (a : ns)
-> STDataFrame s t (b : ns)
-> STDataFrame s t (ab : ns)
-> ST s ()
merge Dim (Div d 2)
d2l Dim (d - Div d 2)
d2r Dim d
d STDataFrame s t (Div d 2 :+ ns)
leB STDataFrame s t ((d - Div d 2) :+ ns)
riB STDataFrame s t (d : ns)
a
        merge :: forall (a :: Nat) (b :: Nat) (ab :: Nat)
               . Dim a -> Dim b -> Dim ab
              -> STDataFrame s t (a ': ns)
              -> STDataFrame s t (b ': ns)
              -> STDataFrame s t (ab ': ns)
              -> ST s ()
        merge :: Dim a
-> Dim b
-> Dim ab
-> STDataFrame s t (a : ns)
-> STDataFrame s t (b : ns)
-> STDataFrame s t (ab : ns)
-> ST s ()
merge da :: Dim a
da@Dim a
D db :: Dim b
db@Dim b
D dab :: Dim ab
dab@Dim ab
D STDataFrame s t (a : ns)
a STDataFrame s t (b : ns)
b STDataFrame s t (ab : ns)
ab = (Maybe (Word, Word) -> Word -> ST s (Maybe (Word, Word)))
-> Maybe (Word, Word) -> [Word] -> ST s ()
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m ()
foldM_ Maybe (Word, Word) -> Word -> ST s (Maybe (Word, Word))
f ((Word, Word) -> Maybe (Word, Word)
forall a. a -> Maybe a
Just (Word
0,Word
0)) [Word
0 .. Dim ab -> Word
forall k (x :: k). Dim x -> Word
dimVal Dim ab
dab Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1]
          where
            f :: Maybe (Word, Word) -> Word -> ST s (Maybe (Word, Word))
f Maybe (Word, Word)
Nothing Word
_ = Maybe (Word, Word) -> ST s (Maybe (Word, Word))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Word, Word)
forall a. Maybe a
Nothing
            f (Just (Word
i,Word
j)) Word
k
              | Word
i Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
>= Dim a -> Word
forall k (x :: k). Dim x -> Word
dimVal Dim a
da
              , Dx dj :: Dim n
dj@(Dim n
D :: Dim j) <- Word -> Dim (XN 0)
someDimVal Word
j
              , Dim (n + 1)
D <- Dim n -> Dim 1 -> Dim (n + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim n
dj Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1
              , Just bmj :: Dim (b - n)
bmj@Dim (b - n)
D <- Dim b -> Dim n -> Maybe (Dim (b - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Maybe (Dim (n - m))
minusDimM Dim b
db Dim n
dj
              , Just bmji :: Dim ((ab + 1) - (b - n))
bmji@Dim ((ab + 1) - (b - n))
D <- Dim (ab + 1) -> Dim (b - n) -> Maybe (Dim ((ab + 1) - (b - n)))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Maybe (Dim (n - m))
minusDimM (Dim ab -> Dim 1 -> Dim (ab + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ab
dab Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) Dim (b - n)
bmj
              , Just Dict ((ab + 1) ~ (((ab + 1) - (b - n)) + (b - n)))
Dict <- Dim (ab + 1)
-> Dim (((ab + 1) - (b - n)) + (b - n))
-> Maybe (Dict ((ab + 1) ~ (((ab + 1) - (b - n)) + (b - n))))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim ab -> Dim 1 -> Dim (ab + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ab
dab Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim ((ab + 1) - (b - n))
-> Dim (b - n) -> Dim (((ab + 1) - (b - n)) + (b - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ((ab + 1) - (b - n))
bmji Dim (b - n)
bmj)
              , Just Dict ((b + 1) ~ ((n + 1) + (b - n)))
Dict <- Dim (b + 1)
-> Dim ((n + 1) + (b - n))
-> Maybe (Dict ((b + 1) ~ ((n + 1) + (b - n))))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim b -> Dim 1 -> Dim (b + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim b
db Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim n
dj Dim n -> Dim 1 -> Dim (n + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
`plusDim` Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1 Dim (n + 1) -> Dim (b - n) -> Dim ((n + 1) + (b - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
`plusDim` Dim (b - n)
bmj)
                = Maybe (Word, Word)
forall a. Maybe a
Nothing Maybe (Word, Word) -> ST s () -> ST s (Maybe (Word, Word))
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Idxs ('[] +: ((ab + 1) - (b - n)))
-> STDataFrame s t ((b - n) :+ ns)
-> STDataFrame s t (ab : ns)
-> ST s ()
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, ExactDims bs, PrimBytes t,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t (bd :+ bs) -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame @t @ab @(ab + 1 - (b - j))
                                                            @(b - j) (Word -> Idx ((ab + 1) - (b - n))
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
k Idx ((ab + 1) - (b - n))
-> TypedList Idx '[] -> TypedList Idx '[(ab + 1) - (b - n)]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U)
                    (Idxs ('[] +: (n + 1))
-> STDataFrame s t (b : ns) -> STDataFrame s t ((b - n) :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @b @(j + 1) @(b - j) (Word -> Idx (n + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
j Idx (n + 1) -> TypedList Idx '[] -> TypedList Idx '[n + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (b : ns)
b) STDataFrame s t (ab : ns)
ab
              | Word
j Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
>= Dim b -> Word
forall k (x :: k). Dim x -> Word
dimVal Dim b
db
              , Dx di :: Dim n
di@(Dim n
D :: Dim i) <- Word -> Dim (XN 0)
someDimVal Word
i
              , Dim (n + 1)
D <- Dim n -> Dim 1 -> Dim (n + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim n
di Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1
              , Just bmi :: Dim (a - n)
bmi@Dim (a - n)
D <- Dim a -> Dim n -> Maybe (Dim (a - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Maybe (Dim (n - m))
minusDimM Dim a
da Dim n
di
              , Just bmii :: Dim ((ab + 1) - (a - n))
bmii@Dim ((ab + 1) - (a - n))
D <- Dim (ab + 1) -> Dim (a - n) -> Maybe (Dim ((ab + 1) - (a - n)))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Maybe (Dim (n - m))
minusDimM (Dim ab -> Dim 1 -> Dim (ab + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ab
dab Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) Dim (a - n)
bmi
              , Just Dict ((ab + 1) ~ (((ab + 1) - (a - n)) + (a - n)))
Dict <- Dim (ab + 1)
-> Dim (((ab + 1) - (a - n)) + (a - n))
-> Maybe (Dict ((ab + 1) ~ (((ab + 1) - (a - n)) + (a - n))))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim ab -> Dim 1 -> Dim (ab + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ab
dab Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim ((ab + 1) - (a - n))
-> Dim (a - n) -> Dim (((ab + 1) - (a - n)) + (a - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim ((ab + 1) - (a - n))
bmii Dim (a - n)
bmi)
              , Just Dict ((a + 1) ~ ((n + 1) + (a - n)))
Dict <- Dim (a + 1)
-> Dim ((n + 1) + (a - n))
-> Maybe (Dict ((a + 1) ~ ((n + 1) + (a - n))))
forall (x :: Nat) (y :: Nat).
Dim x -> Dim y -> Maybe (Dict (x ~ y))
sameDim (Dim a -> Dim 1 -> Dim (a + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
plusDim Dim a
da Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1) (Dim n
di Dim n -> Dim 1 -> Dim (n + 1)
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
`plusDim` Dim 1
forall (n :: Nat). (n ~ 1) => Dim n
D1 Dim (n + 1) -> Dim (a - n) -> Dim ((n + 1) + (a - n))
forall (n :: Nat) (m :: Nat). Dim n -> Dim m -> Dim (n + m)
`plusDim` Dim (a - n)
bmi)
                = Maybe (Word, Word)
forall a. Maybe a
Nothing Maybe (Word, Word) -> ST s () -> ST s (Maybe (Word, Word))
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Idxs ('[] +: ((ab + 1) - (a - n)))
-> STDataFrame s t ((a - n) :+ ns)
-> STDataFrame s t (ab : ns)
-> ST s ()
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, ExactDims bs, PrimBytes t,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t (bd :+ bs) -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame (Word -> Idx ((ab + 1) - (a - n))
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
k Idx ((ab + 1) - (a - n))
-> TypedList Idx '[] -> TypedList Idx '[(ab + 1) - (a - n)]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U)
                    (Idxs ('[] +: (n + 1))
-> STDataFrame s t (a : ns) -> STDataFrame s t ((a - n) :+ ns)
forall k t (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k])
       (asbs :: [k]) s.
(SubFrameIndexCtx b bi bd, KnownDim bd,
 ConcatList as (b :+ bs) asbs) =>
Idxs (as +: bi)
-> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)
subDataFrameView @t @a @(i + 1) @(a - i) (Word -> Idx (n + 1)
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
i Idx (n + 1) -> TypedList Idx '[] -> TypedList Idx '[n + 1]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (a : ns)
a) STDataFrame s t (ab : ns)
ab
              | Bool
otherwise
                = STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp (Idxs '[a] -> STDataFrame s t (a : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx a
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
i Idx a -> TypedList Idx '[] -> Idxs '[a]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (a : ns)
a)
                      (Idxs '[b] -> STDataFrame s t (b : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx b
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
j Idx b -> TypedList Idx '[] -> Idxs '[b]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (b : ns)
b) ST s Ordering
-> (Ordering -> ST s (Maybe (Word, Word)))
-> ST s (Maybe (Word, Word))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                    Ordering
GT -> (Word, Word) -> Maybe (Word, Word)
forall a. a -> Maybe a
Just (Word
i, Word
j Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
1)
                          Maybe (Word, Word) -> ST s () -> ST s (Maybe (Word, Word))
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Idxs '[ab]
-> STDataFrame s t ns -> STDataFrame s t (ab : ns) -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' (Word -> Idx ab
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
k Idx ab -> TypedList Idx '[] -> Idxs '[ab]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U)
                                         (Idxs '[b] -> STDataFrame s t (b : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx b
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
j Idx b -> TypedList Idx '[] -> Idxs '[b]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (b : ns)
b) STDataFrame s t (ab : ns)
ab
                    Ordering
_ -> (Word, Word) -> Maybe (Word, Word)
forall a. a -> Maybe a
Just (Word
i Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
1, Word
j)
                          Maybe (Word, Word) -> ST s () -> ST s (Maybe (Word, Word))
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Idxs '[ab]
-> STDataFrame s t ns -> STDataFrame s t (ab : ns) -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' (Word -> Idx ab
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
k Idx ab -> TypedList Idx '[] -> Idxs '[ab]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U)
                                         (Idxs '[a] -> STDataFrame s t (a : ns) -> STDataFrame s t ns
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
ConcatList as bs asbs =>
Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs
subDataFrameView' (Word -> Idx a
forall k (d :: k). BoundedDim d => Word -> Idx d
Idx Word
i Idx a -> TypedList Idx '[] -> Idxs '[a]
forall k (f :: k -> *) (xs :: [k]) (y :: k) (ys :: [k]).
(xs ~ (y : ys)) =>
f y -> TypedList f ys -> TypedList f xs
:* TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U) STDataFrame s t (a : ns)
a) STDataFrame s t (ab : ns)
ab


instance BoundedDim xn => SortBy (xn :: XNat) where
    sortByInplace :: (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (xn : ns) -> ST s ()
sortByInplace STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp (XSTFrame STDataFrame s t ns
xs)
      | Dim y
D :* TypedList Dim ys
_ <- TypedList Dim ns
forall k (ds :: [k]). Dimensions ds => Dims ds
dims TypedList Dim ns -> STDataFrame s t ns -> TypedList Dim ns
forall k (ds :: k) (p :: k -> *) (q :: k -> *).
p ds -> q ds -> p ds
`inSpaceOf` STDataFrame s t ns
xs
        = (STDataFrame s t (Tail ns)
 -> STDataFrame s t (Tail ns) -> ST s Ordering)
-> STDataFrame s t (Head ns : Tail ns) -> ST s ()
forall k (n :: k) t s (ns :: [k]).
(SortBy n, PrimBytes t) =>
(STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering)
-> STDataFrame s t (n : ns) -> ST s ()
sortByInplace (\STDataFrame s t (Tail ns)
x STDataFrame s t (Tail ns)
y -> STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering
cmp (STDataFrame s t (Tail ns) -> STDataFrame s t ns
forall t (xns :: [XNat]) (ns :: [Nat]) s.
FixedDims xns ns =>
STDataFrame s t ns -> STDataFrame s t xns
castDataFrame STDataFrame s t (Tail ns)
x) (STDataFrame s t (Tail ns) -> STDataFrame s t ns
forall t (xns :: [XNat]) (ns :: [Nat]) s.
FixedDims xns ns =>
STDataFrame s t ns -> STDataFrame s t xns
castDataFrame STDataFrame s t (Tail ns)
y)) STDataFrame s t ns
STDataFrame s t (Head ns : Tail ns)
xs
#if !MIN_VERSION_GLASGOW_HASKELL(9,0,0,0)
      | Bool
otherwise = [Char] -> ST s ()
forall a. HasCallStack => [Char] -> a
error [Char]
"sortByInplace: impossible pattern"
#endif


-- | Swap contents of two DataFrames
swapDF :: forall (s :: Type) (t :: Type) (ns :: [Nat])
        . PrimBytes t
       => STDataFrame s t ns -- ^ Temporary buffer
       -> STDataFrame s t ns
       -> STDataFrame s t ns
       -> ST s ()
swapDF :: STDataFrame s t ns
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
swapDF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b = do
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
a STDataFrame s t ns
tmp
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
b STDataFrame s t ns
a
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
tmp STDataFrame s t ns
b

-- | Rotate left contents of three DataFrames
swap3DF :: forall (s :: Type) (t :: Type) (ns :: [Nat])
        . PrimBytes t
       => STDataFrame s t ns -- ^ Temporary buffer
       -> STDataFrame s t ns
       -> STDataFrame s t ns
       -> STDataFrame s t ns
       -> ST s ()
swap3DF :: STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> STDataFrame s t ns
-> ST s ()
swap3DF STDataFrame s t ns
tmp STDataFrame s t ns
a STDataFrame s t ns
b STDataFrame s t ns
c = do
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
a STDataFrame s t ns
tmp
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
b STDataFrame s t ns
a
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
c STDataFrame s t ns
b
  TypedList Idx '[]
-> STDataFrame s t ns -> STDataFrame s t ns -> ST s ()
forall k t (as :: [k]) (bs :: [k]) (asbs :: [k]) s.
(ExactDims bs, PrimBytes t, ConcatList as bs asbs) =>
Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()
copyMutableDataFrame' TypedList Idx '[]
forall k (f :: k -> *) (xs :: [k]). (xs ~ '[]) => TypedList f xs
U STDataFrame s t ns
tmp STDataFrame s t ns
c