diff options
Diffstat (limited to 'third_party/bazel/rules_haskell/examples/vector/internal')
| -rw-r--r-- | third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs | 239 | ||||
| -rw-r--r-- | third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances | 1134 |
2 files changed, 0 insertions, 1373 deletions
diff --git a/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs b/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs deleted file mode 100644 index 8debff23a975..000000000000 --- a/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs +++ /dev/null @@ -1,239 +0,0 @@ -{-# LANGUAGE ParallelListComp #-} -module Main where - -import Text.PrettyPrint - -import System.Environment ( getArgs ) - -main = do - [s] <- getArgs - let n = read s - mapM_ (putStrLn . render . generate) [2..n] - -generate :: Int -> Doc -generate n = - vcat [ text "#ifdef DEFINE_INSTANCES" - , data_instance "MVector s" "MV" - , data_instance "Vector" "V" - , class_instance "Unbox" - , class_instance "M.MVector MVector" <+> text "where" - , nest 2 $ vcat $ map method methods_MVector - , class_instance "G.Vector Vector" <+> text "where" - , nest 2 $ vcat $ map method methods_Vector - , text "#endif" - , text "#ifdef DEFINE_MUTABLE" - , define_zip "MVector s" "MV" - , define_unzip "MVector s" "MV" - , text "#endif" - , text "#ifdef DEFINE_IMMUTABLE" - , define_zip "Vector" "V" - , define_zip_rule - , define_unzip "Vector" "V" - , text "#endif" - ] - - where - vars = map (\c -> text ['_',c]) $ take n ['a'..] - varss = map (<> char 's') vars - tuple xs = parens $ hsep $ punctuate comma xs - vtuple xs = parens $ sep $ punctuate comma xs - con s = text s <> char '_' <> int n - var c = text ('_' : c : "_") - - data_instance ty c - = hang (hsep [text "data instance", text ty, tuple vars]) - 4 - (hsep [char '=', con c, text "{-# UNPACK #-} !Int" - , vcat $ map (\v -> char '!' <> parens (text ty <+> v)) vars]) - - class_instance cls - = text "instance" <+> vtuple [text "Unbox" <+> v | v <- vars] - <+> text "=>" <+> text cls <+> tuple vars - - - define_zip ty c - = sep [text "-- | /O(1)/ Zip" <+> int n <+> text "vectors" - ,name <+> text "::" - <+> vtuple [text "Unbox" <+> v | v <- vars] - <+> text "=>" - <+> sep (punctuate (text " ->") [text ty <+> v | v <- vars]) - <+> text "->" - <+> text ty <+> tuple vars - ,text "{-# INLINE_FUSED" <+> name <+> text "#-}" - ,name <+> sep varss - <+> text "=" - <+> con c - <+> text "len" - <+> sep [parens $ text "unsafeSlice" - <+> char '0' - <+> text "len" - <+> vs | vs <- varss] - ,nest 2 $ hang (text "where") - 2 - $ text "len =" - <+> sep (punctuate (text " `delayed_min`") - [text "length" <+> vs | vs <- varss]) - ] - where - name | n == 2 = text "zip" - | otherwise = text "zip" <> int n - - define_zip_rule - = hang (text "{-# RULES" <+> text "\"stream/" <> name "zip" - <> text " [Vector.Unboxed]\" forall" <+> sep varss <+> char '.') - 2 $ - text "G.stream" <+> parens (name "zip" <+> sep varss) - <+> char '=' - <+> text "Bundle." <> name "zipWith" <+> tuple (replicate n empty) - <+> sep [parens $ text "G.stream" <+> vs | vs <- varss] - $$ text "#-}" - where - name s | n == 2 = text s - | otherwise = text s <> int n - - - define_unzip ty c - = sep [text "-- | /O(1)/ Unzip" <+> int n <+> text "vectors" - ,name <+> text "::" - <+> vtuple [text "Unbox" <+> v | v <- vars] - <+> text "=>" - <+> text ty <+> tuple vars - <+> text "->" <+> vtuple [text ty <+> v | v <- vars] - ,text "{-# INLINE" <+> name <+> text "#-}" - ,name <+> pat c <+> text "=" - <+> vtuple varss - ] - where - name | n == 2 = text "unzip" - | otherwise = text "unzip" <> int n - - pat c = parens $ con c <+> var 'n' <+> sep varss - patn c n = parens $ con c <+> (var 'n' <> int n) - <+> sep [v <> int n | v <- varss] - - qM s = text "M." <> text s - qG s = text "G." <> text s - - gen_length c _ = (pat c, var 'n') - - gen_unsafeSlice mod c rec - = (var 'i' <+> var 'm' <+> pat c, - con c <+> var 'm' - <+> vcat [parens - $ text mod <> char '.' <> text rec - <+> var 'i' <+> var 'm' <+> vs - | vs <- varss]) - - - gen_overlaps rec = (patn "MV" 1 <+> patn "MV" 2, - vcat $ r : [text "||" <+> r | r <- rs]) - where - r : rs = [qM rec <+> v <> char '1' <+> v <> char '2' | v <- varss] - - gen_unsafeNew rec - = (var 'n', - mk_do [v <+> text "<-" <+> qM rec <+> var 'n' | v <- varss] - $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss) - - gen_unsafeReplicate rec - = (var 'n' <+> tuple vars, - mk_do [vs <+> text "<-" <+> qM rec <+> var 'n' <+> v - | v <- vars | vs <- varss] - $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss) - - gen_unsafeRead rec - = (pat "MV" <+> var 'i', - mk_do [v <+> text "<-" <+> qM rec <+> vs <+> var 'i' | v <- vars - | vs <- varss] - $ text "return" <+> tuple vars) - - gen_unsafeWrite rec - = (pat "MV" <+> var 'i' <+> tuple vars, - mk_do [qM rec <+> vs <+> var 'i' <+> v | v <- vars | vs <- varss] - empty) - - gen_clear rec - = (pat "MV", mk_do [qM rec <+> vs | vs <- varss] empty) - - gen_set rec - = (pat "MV" <+> tuple vars, - mk_do [qM rec <+> vs <+> v | vs <- varss | v <- vars] empty) - - gen_unsafeCopy c q rec - = (patn "MV" 1 <+> patn c 2, - mk_do [q rec <+> vs <> char '1' <+> vs <> char '2' | vs <- varss] - empty) - - gen_unsafeMove rec - = (patn "MV" 1 <+> patn "MV" 2, - mk_do [qM rec <+> vs <> char '1' <+> vs <> char '2' | vs <- varss] - empty) - - gen_unsafeGrow rec - = (pat "MV" <+> var 'm', - mk_do [vs <> char '\'' <+> text "<-" - <+> qM rec <+> vs <+> var 'm' | vs <- varss] - $ text "return $" <+> con "MV" - <+> parens (var 'm' <> char '+' <> var 'n') - <+> sep (map (<> char '\'') varss)) - - gen_initialize rec - = (pat "MV", mk_do [qM rec <+> vs | vs <- varss] empty) - - gen_unsafeFreeze rec - = (pat "MV", - mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss] - $ text "return $" <+> con "V" <+> var 'n' - <+> sep [vs <> char '\'' | vs <- varss]) - - gen_unsafeThaw rec - = (pat "V", - mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss] - $ text "return $" <+> con "MV" <+> var 'n' - <+> sep [vs <> char '\'' | vs <- varss]) - - gen_basicUnsafeIndexM rec - = (pat "V" <+> var 'i', - mk_do [v <+> text "<-" <+> qG rec <+> vs <+> var 'i' - | vs <- varss | v <- vars] - $ text "return" <+> tuple vars) - - gen_elemseq rec - = (char '_' <+> tuple vars, - vcat $ r : [char '.' <+> r | r <- rs]) - where - r : rs = [qG rec <+> parens (text "undefined :: Vector" <+> v) - <+> v | v <- vars] - - mk_do cmds ret = hang (text "do") - 2 - $ vcat $ cmds ++ [ret] - - method (s, f) = case f s of - (p,e) -> text "{-# INLINE" <+> text s <+> text " #-}" - $$ hang (text s <+> p) - 4 - (char '=' <+> e) - - - methods_MVector = [("basicLength", gen_length "MV") - ,("basicUnsafeSlice", gen_unsafeSlice "M" "MV") - ,("basicOverlaps", gen_overlaps) - ,("basicUnsafeNew", gen_unsafeNew) - ,("basicUnsafeReplicate", gen_unsafeReplicate) - ,("basicUnsafeRead", gen_unsafeRead) - ,("basicUnsafeWrite", gen_unsafeWrite) - ,("basicClear", gen_clear) - ,("basicSet", gen_set) - ,("basicUnsafeCopy", gen_unsafeCopy "MV" qM) - ,("basicUnsafeMove", gen_unsafeMove) - ,("basicUnsafeGrow", gen_unsafeGrow) - ,("basicInitialize", gen_initialize)] - - methods_Vector = [("basicUnsafeFreeze", gen_unsafeFreeze) - ,("basicUnsafeThaw", gen_unsafeThaw) - ,("basicLength", gen_length "V") - ,("basicUnsafeSlice", gen_unsafeSlice "G" "V") - ,("basicUnsafeIndexM", gen_basicUnsafeIndexM) - ,("basicUnsafeCopy", gen_unsafeCopy "V" qG) - ,("elemseq", gen_elemseq)] diff --git a/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances b/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances deleted file mode 100644 index 6fb88d4a4047..000000000000 --- a/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances +++ /dev/null @@ -1,1134 +0,0 @@ -#ifdef DEFINE_INSTANCES -data instance MVector s (a, b) - = MV_2 {-# UNPACK #-} !Int !(MVector s a) - !(MVector s b) -data instance Vector (a, b) - = V_2 {-# UNPACK #-} !Int !(Vector a) - !(Vector b) -instance (Unbox a, Unbox b) => Unbox (a, b) -instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where - {-# INLINE basicLength #-} - basicLength (MV_2 n_ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (MV_2 _ as bs) - = MV_2 m_ (M.basicUnsafeSlice i_ m_ as) - (M.basicUnsafeSlice i_ m_ bs) - {-# INLINE basicOverlaps #-} - basicOverlaps (MV_2 _ as1 bs1) (MV_2 _ as2 bs2) - = M.basicOverlaps as1 as2 - || M.basicOverlaps bs1 bs2 - {-# INLINE basicUnsafeNew #-} - basicUnsafeNew n_ - = do - as <- M.basicUnsafeNew n_ - bs <- M.basicUnsafeNew n_ - return $ MV_2 n_ as bs - {-# INLINE basicInitialize #-} - basicInitialize (MV_2 _ as bs) - = do - M.basicInitialize as - M.basicInitialize bs - {-# INLINE basicUnsafeReplicate #-} - basicUnsafeReplicate n_ (a, b) - = do - as <- M.basicUnsafeReplicate n_ a - bs <- M.basicUnsafeReplicate n_ b - return $ MV_2 n_ as bs - {-# INLINE basicUnsafeRead #-} - basicUnsafeRead (MV_2 _ as bs) i_ - = do - a <- M.basicUnsafeRead as i_ - b <- M.basicUnsafeRead bs i_ - return (a, b) - {-# INLINE basicUnsafeWrite #-} - basicUnsafeWrite (MV_2 _ as bs) i_ (a, b) - = do - M.basicUnsafeWrite as i_ a - M.basicUnsafeWrite bs i_ b - {-# INLINE basicClear #-} - basicClear (MV_2 _ as bs) - = do - M.basicClear as - M.basicClear bs - {-# INLINE basicSet #-} - basicSet (MV_2 _ as bs) (a, b) - = do - M.basicSet as a - M.basicSet bs b - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_2 _ as1 bs1) (MV_2 _ as2 bs2) - = do - M.basicUnsafeCopy as1 as2 - M.basicUnsafeCopy bs1 bs2 - {-# INLINE basicUnsafeMove #-} - basicUnsafeMove (MV_2 _ as1 bs1) (MV_2 _ as2 bs2) - = do - M.basicUnsafeMove as1 as2 - M.basicUnsafeMove bs1 bs2 - {-# INLINE basicUnsafeGrow #-} - basicUnsafeGrow (MV_2 n_ as bs) m_ - = do - as' <- M.basicUnsafeGrow as m_ - bs' <- M.basicUnsafeGrow bs m_ - return $ MV_2 (m_+n_) as' bs' -instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where - {-# INLINE basicUnsafeFreeze #-} - basicUnsafeFreeze (MV_2 n_ as bs) - = do - as' <- G.basicUnsafeFreeze as - bs' <- G.basicUnsafeFreeze bs - return $ V_2 n_ as' bs' - {-# INLINE basicUnsafeThaw #-} - basicUnsafeThaw (V_2 n_ as bs) - = do - as' <- G.basicUnsafeThaw as - bs' <- G.basicUnsafeThaw bs - return $ MV_2 n_ as' bs' - {-# INLINE basicLength #-} - basicLength (V_2 n_ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (V_2 _ as bs) - = V_2 m_ (G.basicUnsafeSlice i_ m_ as) - (G.basicUnsafeSlice i_ m_ bs) - {-# INLINE basicUnsafeIndexM #-} - basicUnsafeIndexM (V_2 _ as bs) i_ - = do - a <- G.basicUnsafeIndexM as i_ - b <- G.basicUnsafeIndexM bs i_ - return (a, b) - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_2 _ as1 bs1) (V_2 _ as2 bs2) - = do - G.basicUnsafeCopy as1 as2 - G.basicUnsafeCopy bs1 bs2 - {-# INLINE elemseq #-} - elemseq _ (a, b) - = G.elemseq (undefined :: Vector a) a - . G.elemseq (undefined :: Vector b) b -#endif -#ifdef DEFINE_MUTABLE --- | /O(1)/ Zip 2 vectors -zip :: (Unbox a, Unbox b) => MVector s a -> - MVector s b -> MVector s (a, b) -{-# INLINE_FUSED zip #-} -zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) - where len = length as `delayed_min` length bs --- | /O(1)/ Unzip 2 vectors -unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, - MVector s b) -{-# INLINE unzip #-} -unzip (MV_2 _ as bs) = (as, bs) -#endif -#ifdef DEFINE_IMMUTABLE --- | /O(1)/ Zip 2 vectors -zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b) -{-# INLINE_FUSED zip #-} -zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) - where len = length as `delayed_min` length bs -{-# RULES "stream/zip [Vector.Unboxed]" forall as bs . - G.stream (zip as bs) = Bundle.zipWith (,) (G.stream as) - (G.stream bs) #-} - --- | /O(1)/ Unzip 2 vectors -unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, - Vector b) -{-# INLINE unzip #-} -unzip (V_2 _ as bs) = (as, bs) -#endif -#ifdef DEFINE_INSTANCES -data instance MVector s (a, b, c) - = MV_3 {-# UNPACK #-} !Int !(MVector s a) - !(MVector s b) - !(MVector s c) -data instance Vector (a, b, c) - = V_3 {-# UNPACK #-} !Int !(Vector a) - !(Vector b) - !(Vector c) -instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) -instance (Unbox a, - Unbox b, - Unbox c) => M.MVector MVector (a, b, c) where - {-# INLINE basicLength #-} - basicLength (MV_3 n_ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (MV_3 _ as bs cs) - = MV_3 m_ (M.basicUnsafeSlice i_ m_ as) - (M.basicUnsafeSlice i_ m_ bs) - (M.basicUnsafeSlice i_ m_ cs) - {-# INLINE basicOverlaps #-} - basicOverlaps (MV_3 _ as1 bs1 cs1) (MV_3 _ as2 bs2 cs2) - = M.basicOverlaps as1 as2 - || M.basicOverlaps bs1 bs2 - || M.basicOverlaps cs1 cs2 - {-# INLINE basicUnsafeNew #-} - basicUnsafeNew n_ - = do - as <- M.basicUnsafeNew n_ - bs <- M.basicUnsafeNew n_ - cs <- M.basicUnsafeNew n_ - return $ MV_3 n_ as bs cs - {-# INLINE basicInitialize #-} - basicInitialize (MV_3 _ as bs cs) - = do - M.basicInitialize as - M.basicInitialize bs - M.basicInitialize cs - {-# INLINE basicUnsafeReplicate #-} - basicUnsafeReplicate n_ (a, b, c) - = do - as <- M.basicUnsafeReplicate n_ a - bs <- M.basicUnsafeReplicate n_ b - cs <- M.basicUnsafeReplicate n_ c - return $ MV_3 n_ as bs cs - {-# INLINE basicUnsafeRead #-} - basicUnsafeRead (MV_3 _ as bs cs) i_ - = do - a <- M.basicUnsafeRead as i_ - b <- M.basicUnsafeRead bs i_ - c <- M.basicUnsafeRead cs i_ - return (a, b, c) - {-# INLINE basicUnsafeWrite #-} - basicUnsafeWrite (MV_3 _ as bs cs) i_ (a, b, c) - = do - M.basicUnsafeWrite as i_ a - M.basicUnsafeWrite bs i_ b - M.basicUnsafeWrite cs i_ c - {-# INLINE basicClear #-} - basicClear (MV_3 _ as bs cs) - = do - M.basicClear as - M.basicClear bs - M.basicClear cs - {-# INLINE basicSet #-} - basicSet (MV_3 _ as bs cs) (a, b, c) - = do - M.basicSet as a - M.basicSet bs b - M.basicSet cs c - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_3 _ as1 bs1 cs1) (MV_3 _ as2 bs2 cs2) - = do - M.basicUnsafeCopy as1 as2 - M.basicUnsafeCopy bs1 bs2 - M.basicUnsafeCopy cs1 cs2 - {-# INLINE basicUnsafeMove #-} - basicUnsafeMove (MV_3 _ as1 bs1 cs1) (MV_3 _ as2 bs2 cs2) - = do - M.basicUnsafeMove as1 as2 - M.basicUnsafeMove bs1 bs2 - M.basicUnsafeMove cs1 cs2 - {-# INLINE basicUnsafeGrow #-} - basicUnsafeGrow (MV_3 n_ as bs cs) m_ - = do - as' <- M.basicUnsafeGrow as m_ - bs' <- M.basicUnsafeGrow bs m_ - cs' <- M.basicUnsafeGrow cs m_ - return $ MV_3 (m_+n_) as' bs' cs' -instance (Unbox a, - Unbox b, - Unbox c) => G.Vector Vector (a, b, c) where - {-# INLINE basicUnsafeFreeze #-} - basicUnsafeFreeze (MV_3 n_ as bs cs) - = do - as' <- G.basicUnsafeFreeze as - bs' <- G.basicUnsafeFreeze bs - cs' <- G.basicUnsafeFreeze cs - return $ V_3 n_ as' bs' cs' - {-# INLINE basicUnsafeThaw #-} - basicUnsafeThaw (V_3 n_ as bs cs) - = do - as' <- G.basicUnsafeThaw as - bs' <- G.basicUnsafeThaw bs - cs' <- G.basicUnsafeThaw cs - return $ MV_3 n_ as' bs' cs' - {-# INLINE basicLength #-} - basicLength (V_3 n_ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (V_3 _ as bs cs) - = V_3 m_ (G.basicUnsafeSlice i_ m_ as) - (G.basicUnsafeSlice i_ m_ bs) - (G.basicUnsafeSlice i_ m_ cs) - {-# INLINE basicUnsafeIndexM #-} - basicUnsafeIndexM (V_3 _ as bs cs) i_ - = do - a <- G.basicUnsafeIndexM as i_ - b <- G.basicUnsafeIndexM bs i_ - c <- G.basicUnsafeIndexM cs i_ - return (a, b, c) - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_3 _ as1 bs1 cs1) (V_3 _ as2 bs2 cs2) - = do - G.basicUnsafeCopy as1 as2 - G.basicUnsafeCopy bs1 bs2 - G.basicUnsafeCopy cs1 cs2 - {-# INLINE elemseq #-} - elemseq _ (a, b, c) - = G.elemseq (undefined :: Vector a) a - . G.elemseq (undefined :: Vector b) b - . G.elemseq (undefined :: Vector c) c -#endif -#ifdef DEFINE_MUTABLE --- | /O(1)/ Zip 3 vectors -zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> - MVector s b -> - MVector s c -> MVector s (a, b, c) -{-# INLINE_FUSED zip3 #-} -zip3 as bs cs = MV_3 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - where - len = length as `delayed_min` length bs `delayed_min` length cs --- | /O(1)/ Unzip 3 vectors -unzip3 :: (Unbox a, - Unbox b, - Unbox c) => MVector s (a, b, c) -> (MVector s a, - MVector s b, - MVector s c) -{-# INLINE unzip3 #-} -unzip3 (MV_3 _ as bs cs) = (as, bs, cs) -#endif -#ifdef DEFINE_IMMUTABLE --- | /O(1)/ Zip 3 vectors -zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> - Vector b -> - Vector c -> Vector (a, b, c) -{-# INLINE_FUSED zip3 #-} -zip3 as bs cs = V_3 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - where - len = length as `delayed_min` length bs `delayed_min` length cs -{-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs . - G.stream (zip3 as bs cs) = Bundle.zipWith3 (, ,) (G.stream as) - (G.stream bs) - (G.stream cs) #-} - --- | /O(1)/ Unzip 3 vectors -unzip3 :: (Unbox a, - Unbox b, - Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c) -{-# INLINE unzip3 #-} -unzip3 (V_3 _ as bs cs) = (as, bs, cs) -#endif -#ifdef DEFINE_INSTANCES -data instance MVector s (a, b, c, d) - = MV_4 {-# UNPACK #-} !Int !(MVector s a) - !(MVector s b) - !(MVector s c) - !(MVector s d) -data instance Vector (a, b, c, d) - = V_4 {-# UNPACK #-} !Int !(Vector a) - !(Vector b) - !(Vector c) - !(Vector d) -instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d) => M.MVector MVector (a, b, c, d) where - {-# INLINE basicLength #-} - basicLength (MV_4 n_ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (MV_4 _ as bs cs ds) - = MV_4 m_ (M.basicUnsafeSlice i_ m_ as) - (M.basicUnsafeSlice i_ m_ bs) - (M.basicUnsafeSlice i_ m_ cs) - (M.basicUnsafeSlice i_ m_ ds) - {-# INLINE basicOverlaps #-} - basicOverlaps (MV_4 _ as1 bs1 cs1 ds1) (MV_4 _ as2 bs2 cs2 ds2) - = M.basicOverlaps as1 as2 - || M.basicOverlaps bs1 bs2 - || M.basicOverlaps cs1 cs2 - || M.basicOverlaps ds1 ds2 - {-# INLINE basicUnsafeNew #-} - basicUnsafeNew n_ - = do - as <- M.basicUnsafeNew n_ - bs <- M.basicUnsafeNew n_ - cs <- M.basicUnsafeNew n_ - ds <- M.basicUnsafeNew n_ - return $ MV_4 n_ as bs cs ds - {-# INLINE basicInitialize #-} - basicInitialize (MV_4 _ as bs cs ds) - = do - M.basicInitialize as - M.basicInitialize bs - M.basicInitialize cs - M.basicInitialize ds - {-# INLINE basicUnsafeReplicate #-} - basicUnsafeReplicate n_ (a, b, c, d) - = do - as <- M.basicUnsafeReplicate n_ a - bs <- M.basicUnsafeReplicate n_ b - cs <- M.basicUnsafeReplicate n_ c - ds <- M.basicUnsafeReplicate n_ d - return $ MV_4 n_ as bs cs ds - {-# INLINE basicUnsafeRead #-} - basicUnsafeRead (MV_4 _ as bs cs ds) i_ - = do - a <- M.basicUnsafeRead as i_ - b <- M.basicUnsafeRead bs i_ - c <- M.basicUnsafeRead cs i_ - d <- M.basicUnsafeRead ds i_ - return (a, b, c, d) - {-# INLINE basicUnsafeWrite #-} - basicUnsafeWrite (MV_4 _ as bs cs ds) i_ (a, b, c, d) - = do - M.basicUnsafeWrite as i_ a - M.basicUnsafeWrite bs i_ b - M.basicUnsafeWrite cs i_ c - M.basicUnsafeWrite ds i_ d - {-# INLINE basicClear #-} - basicClear (MV_4 _ as bs cs ds) - = do - M.basicClear as - M.basicClear bs - M.basicClear cs - M.basicClear ds - {-# INLINE basicSet #-} - basicSet (MV_4 _ as bs cs ds) (a, b, c, d) - = do - M.basicSet as a - M.basicSet bs b - M.basicSet cs c - M.basicSet ds d - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_4 _ as1 bs1 cs1 ds1) (MV_4 _ as2 - bs2 - cs2 - ds2) - = do - M.basicUnsafeCopy as1 as2 - M.basicUnsafeCopy bs1 bs2 - M.basicUnsafeCopy cs1 cs2 - M.basicUnsafeCopy ds1 ds2 - {-# INLINE basicUnsafeMove #-} - basicUnsafeMove (MV_4 _ as1 bs1 cs1 ds1) (MV_4 _ as2 - bs2 - cs2 - ds2) - = do - M.basicUnsafeMove as1 as2 - M.basicUnsafeMove bs1 bs2 - M.basicUnsafeMove cs1 cs2 - M.basicUnsafeMove ds1 ds2 - {-# INLINE basicUnsafeGrow #-} - basicUnsafeGrow (MV_4 n_ as bs cs ds) m_ - = do - as' <- M.basicUnsafeGrow as m_ - bs' <- M.basicUnsafeGrow bs m_ - cs' <- M.basicUnsafeGrow cs m_ - ds' <- M.basicUnsafeGrow ds m_ - return $ MV_4 (m_+n_) as' bs' cs' ds' -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d) => G.Vector Vector (a, b, c, d) where - {-# INLINE basicUnsafeFreeze #-} - basicUnsafeFreeze (MV_4 n_ as bs cs ds) - = do - as' <- G.basicUnsafeFreeze as - bs' <- G.basicUnsafeFreeze bs - cs' <- G.basicUnsafeFreeze cs - ds' <- G.basicUnsafeFreeze ds - return $ V_4 n_ as' bs' cs' ds' - {-# INLINE basicUnsafeThaw #-} - basicUnsafeThaw (V_4 n_ as bs cs ds) - = do - as' <- G.basicUnsafeThaw as - bs' <- G.basicUnsafeThaw bs - cs' <- G.basicUnsafeThaw cs - ds' <- G.basicUnsafeThaw ds - return $ MV_4 n_ as' bs' cs' ds' - {-# INLINE basicLength #-} - basicLength (V_4 n_ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (V_4 _ as bs cs ds) - = V_4 m_ (G.basicUnsafeSlice i_ m_ as) - (G.basicUnsafeSlice i_ m_ bs) - (G.basicUnsafeSlice i_ m_ cs) - (G.basicUnsafeSlice i_ m_ ds) - {-# INLINE basicUnsafeIndexM #-} - basicUnsafeIndexM (V_4 _ as bs cs ds) i_ - = do - a <- G.basicUnsafeIndexM as i_ - b <- G.basicUnsafeIndexM bs i_ - c <- G.basicUnsafeIndexM cs i_ - d <- G.basicUnsafeIndexM ds i_ - return (a, b, c, d) - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_4 _ as1 bs1 cs1 ds1) (V_4 _ as2 - bs2 - cs2 - ds2) - = do - G.basicUnsafeCopy as1 as2 - G.basicUnsafeCopy bs1 bs2 - G.basicUnsafeCopy cs1 cs2 - G.basicUnsafeCopy ds1 ds2 - {-# INLINE elemseq #-} - elemseq _ (a, b, c, d) - = G.elemseq (undefined :: Vector a) a - . G.elemseq (undefined :: Vector b) b - . G.elemseq (undefined :: Vector c) c - . G.elemseq (undefined :: Vector d) d -#endif -#ifdef DEFINE_MUTABLE --- | /O(1)/ Zip 4 vectors -zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> - MVector s b -> - MVector s c -> - MVector s d -> MVector s (a, b, c, d) -{-# INLINE_FUSED zip4 #-} -zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds --- | /O(1)/ Unzip 4 vectors -unzip4 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d) => MVector s (a, b, c, d) -> (MVector s a, - MVector s b, - MVector s c, - MVector s d) -{-# INLINE unzip4 #-} -unzip4 (MV_4 _ as bs cs ds) = (as, bs, cs, ds) -#endif -#ifdef DEFINE_IMMUTABLE --- | /O(1)/ Zip 4 vectors -zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> - Vector b -> - Vector c -> - Vector d -> Vector (a, b, c, d) -{-# INLINE_FUSED zip4 #-} -zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds -{-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds . - G.stream (zip4 as bs cs ds) = Bundle.zipWith4 (, , ,) (G.stream as) - (G.stream bs) - (G.stream cs) - (G.stream ds) #-} - --- | /O(1)/ Unzip 4 vectors -unzip4 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d) => Vector (a, b, c, d) -> (Vector a, - Vector b, - Vector c, - Vector d) -{-# INLINE unzip4 #-} -unzip4 (V_4 _ as bs cs ds) = (as, bs, cs, ds) -#endif -#ifdef DEFINE_INSTANCES -data instance MVector s (a, b, c, d, e) - = MV_5 {-# UNPACK #-} !Int !(MVector s a) - !(MVector s b) - !(MVector s c) - !(MVector s d) - !(MVector s e) -data instance Vector (a, b, c, d, e) - = V_5 {-# UNPACK #-} !Int !(Vector a) - !(Vector b) - !(Vector c) - !(Vector d) - !(Vector e) -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => Unbox (a, b, c, d, e) -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => M.MVector MVector (a, b, c, d, e) where - {-# INLINE basicLength #-} - basicLength (MV_5 n_ _ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (MV_5 _ as bs cs ds es) - = MV_5 m_ (M.basicUnsafeSlice i_ m_ as) - (M.basicUnsafeSlice i_ m_ bs) - (M.basicUnsafeSlice i_ m_ cs) - (M.basicUnsafeSlice i_ m_ ds) - (M.basicUnsafeSlice i_ m_ es) - {-# INLINE basicOverlaps #-} - basicOverlaps (MV_5 _ as1 bs1 cs1 ds1 es1) (MV_5 _ as2 - bs2 - cs2 - ds2 - es2) - = M.basicOverlaps as1 as2 - || M.basicOverlaps bs1 bs2 - || M.basicOverlaps cs1 cs2 - || M.basicOverlaps ds1 ds2 - || M.basicOverlaps es1 es2 - {-# INLINE basicUnsafeNew #-} - basicUnsafeNew n_ - = do - as <- M.basicUnsafeNew n_ - bs <- M.basicUnsafeNew n_ - cs <- M.basicUnsafeNew n_ - ds <- M.basicUnsafeNew n_ - es <- M.basicUnsafeNew n_ - return $ MV_5 n_ as bs cs ds es - {-# INLINE basicInitialize #-} - basicInitialize (MV_5 _ as bs cs ds es) - = do - M.basicInitialize as - M.basicInitialize bs - M.basicInitialize cs - M.basicInitialize ds - M.basicInitialize es - {-# INLINE basicUnsafeReplicate #-} - basicUnsafeReplicate n_ (a, b, c, d, e) - = do - as <- M.basicUnsafeReplicate n_ a - bs <- M.basicUnsafeReplicate n_ b - cs <- M.basicUnsafeReplicate n_ c - ds <- M.basicUnsafeReplicate n_ d - es <- M.basicUnsafeReplicate n_ e - return $ MV_5 n_ as bs cs ds es - {-# INLINE basicUnsafeRead #-} - basicUnsafeRead (MV_5 _ as bs cs ds es) i_ - = do - a <- M.basicUnsafeRead as i_ - b <- M.basicUnsafeRead bs i_ - c <- M.basicUnsafeRead cs i_ - d <- M.basicUnsafeRead ds i_ - e <- M.basicUnsafeRead es i_ - return (a, b, c, d, e) - {-# INLINE basicUnsafeWrite #-} - basicUnsafeWrite (MV_5 _ as bs cs ds es) i_ (a, b, c, d, e) - = do - M.basicUnsafeWrite as i_ a - M.basicUnsafeWrite bs i_ b - M.basicUnsafeWrite cs i_ c - M.basicUnsafeWrite ds i_ d - M.basicUnsafeWrite es i_ e - {-# INLINE basicClear #-} - basicClear (MV_5 _ as bs cs ds es) - = do - M.basicClear as - M.basicClear bs - M.basicClear cs - M.basicClear ds - M.basicClear es - {-# INLINE basicSet #-} - basicSet (MV_5 _ as bs cs ds es) (a, b, c, d, e) - = do - M.basicSet as a - M.basicSet bs b - M.basicSet cs c - M.basicSet ds d - M.basicSet es e - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_5 _ as1 bs1 cs1 ds1 es1) (MV_5 _ as2 - bs2 - cs2 - ds2 - es2) - = do - M.basicUnsafeCopy as1 as2 - M.basicUnsafeCopy bs1 bs2 - M.basicUnsafeCopy cs1 cs2 - M.basicUnsafeCopy ds1 ds2 - M.basicUnsafeCopy es1 es2 - {-# INLINE basicUnsafeMove #-} - basicUnsafeMove (MV_5 _ as1 bs1 cs1 ds1 es1) (MV_5 _ as2 - bs2 - cs2 - ds2 - es2) - = do - M.basicUnsafeMove as1 as2 - M.basicUnsafeMove bs1 bs2 - M.basicUnsafeMove cs1 cs2 - M.basicUnsafeMove ds1 ds2 - M.basicUnsafeMove es1 es2 - {-# INLINE basicUnsafeGrow #-} - basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_ - = do - as' <- M.basicUnsafeGrow as m_ - bs' <- M.basicUnsafeGrow bs m_ - cs' <- M.basicUnsafeGrow cs m_ - ds' <- M.basicUnsafeGrow ds m_ - es' <- M.basicUnsafeGrow es m_ - return $ MV_5 (m_+n_) as' bs' cs' ds' es' -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => G.Vector Vector (a, b, c, d, e) where - {-# INLINE basicUnsafeFreeze #-} - basicUnsafeFreeze (MV_5 n_ as bs cs ds es) - = do - as' <- G.basicUnsafeFreeze as - bs' <- G.basicUnsafeFreeze bs - cs' <- G.basicUnsafeFreeze cs - ds' <- G.basicUnsafeFreeze ds - es' <- G.basicUnsafeFreeze es - return $ V_5 n_ as' bs' cs' ds' es' - {-# INLINE basicUnsafeThaw #-} - basicUnsafeThaw (V_5 n_ as bs cs ds es) - = do - as' <- G.basicUnsafeThaw as - bs' <- G.basicUnsafeThaw bs - cs' <- G.basicUnsafeThaw cs - ds' <- G.basicUnsafeThaw ds - es' <- G.basicUnsafeThaw es - return $ MV_5 n_ as' bs' cs' ds' es' - {-# INLINE basicLength #-} - basicLength (V_5 n_ _ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (V_5 _ as bs cs ds es) - = V_5 m_ (G.basicUnsafeSlice i_ m_ as) - (G.basicUnsafeSlice i_ m_ bs) - (G.basicUnsafeSlice i_ m_ cs) - (G.basicUnsafeSlice i_ m_ ds) - (G.basicUnsafeSlice i_ m_ es) - {-# INLINE basicUnsafeIndexM #-} - basicUnsafeIndexM (V_5 _ as bs cs ds es) i_ - = do - a <- G.basicUnsafeIndexM as i_ - b <- G.basicUnsafeIndexM bs i_ - c <- G.basicUnsafeIndexM cs i_ - d <- G.basicUnsafeIndexM ds i_ - e <- G.basicUnsafeIndexM es i_ - return (a, b, c, d, e) - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_5 _ as1 bs1 cs1 ds1 es1) (V_5 _ as2 - bs2 - cs2 - ds2 - es2) - = do - G.basicUnsafeCopy as1 as2 - G.basicUnsafeCopy bs1 bs2 - G.basicUnsafeCopy cs1 cs2 - G.basicUnsafeCopy ds1 ds2 - G.basicUnsafeCopy es1 es2 - {-# INLINE elemseq #-} - elemseq _ (a, b, c, d, e) - = G.elemseq (undefined :: Vector a) a - . G.elemseq (undefined :: Vector b) b - . G.elemseq (undefined :: Vector c) c - . G.elemseq (undefined :: Vector d) d - . G.elemseq (undefined :: Vector e) e -#endif -#ifdef DEFINE_MUTABLE --- | /O(1)/ Zip 5 vectors -zip5 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => MVector s a -> - MVector s b -> - MVector s c -> - MVector s d -> - MVector s e -> MVector s (a, b, c, d, e) -{-# INLINE_FUSED zip5 #-} -zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - (unsafeSlice 0 len es) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds `delayed_min` - length es --- | /O(1)/ Unzip 5 vectors -unzip5 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, - MVector s b, - MVector s c, - MVector s d, - MVector s e) -{-# INLINE unzip5 #-} -unzip5 (MV_5 _ as bs cs ds es) = (as, bs, cs, ds, es) -#endif -#ifdef DEFINE_IMMUTABLE --- | /O(1)/ Zip 5 vectors -zip5 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => Vector a -> - Vector b -> - Vector c -> - Vector d -> - Vector e -> Vector (a, b, c, d, e) -{-# INLINE_FUSED zip5 #-} -zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - (unsafeSlice 0 len es) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds `delayed_min` - length es -{-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es . - G.stream (zip5 as - bs - cs - ds - es) = Bundle.zipWith5 (, , , ,) (G.stream as) - (G.stream bs) - (G.stream cs) - (G.stream ds) - (G.stream es) #-} - --- | /O(1)/ Unzip 5 vectors -unzip5 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e) => Vector (a, b, c, d, e) -> (Vector a, - Vector b, - Vector c, - Vector d, - Vector e) -{-# INLINE unzip5 #-} -unzip5 (V_5 _ as bs cs ds es) = (as, bs, cs, ds, es) -#endif -#ifdef DEFINE_INSTANCES -data instance MVector s (a, b, c, d, e, f) - = MV_6 {-# UNPACK #-} !Int !(MVector s a) - !(MVector s b) - !(MVector s c) - !(MVector s d) - !(MVector s e) - !(MVector s f) -data instance Vector (a, b, c, d, e, f) - = V_6 {-# UNPACK #-} !Int !(Vector a) - !(Vector b) - !(Vector c) - !(Vector d) - !(Vector e) - !(Vector f) -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => Unbox (a, b, c, d, e, f) -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => M.MVector MVector (a, b, c, d, e, f) where - {-# INLINE basicLength #-} - basicLength (MV_6 n_ _ _ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (MV_6 _ as bs cs ds es fs) - = MV_6 m_ (M.basicUnsafeSlice i_ m_ as) - (M.basicUnsafeSlice i_ m_ bs) - (M.basicUnsafeSlice i_ m_ cs) - (M.basicUnsafeSlice i_ m_ ds) - (M.basicUnsafeSlice i_ m_ es) - (M.basicUnsafeSlice i_ m_ fs) - {-# INLINE basicOverlaps #-} - basicOverlaps (MV_6 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ as2 - bs2 - cs2 - ds2 - es2 - fs2) - = M.basicOverlaps as1 as2 - || M.basicOverlaps bs1 bs2 - || M.basicOverlaps cs1 cs2 - || M.basicOverlaps ds1 ds2 - || M.basicOverlaps es1 es2 - || M.basicOverlaps fs1 fs2 - {-# INLINE basicUnsafeNew #-} - basicUnsafeNew n_ - = do - as <- M.basicUnsafeNew n_ - bs <- M.basicUnsafeNew n_ - cs <- M.basicUnsafeNew n_ - ds <- M.basicUnsafeNew n_ - es <- M.basicUnsafeNew n_ - fs <- M.basicUnsafeNew n_ - return $ MV_6 n_ as bs cs ds es fs - {-# INLINE basicInitialize #-} - basicInitialize (MV_6 _ as bs cs ds es fs) - = do - M.basicInitialize as - M.basicInitialize bs - M.basicInitialize cs - M.basicInitialize ds - M.basicInitialize es - M.basicInitialize fs - {-# INLINE basicUnsafeReplicate #-} - basicUnsafeReplicate n_ (a, b, c, d, e, f) - = do - as <- M.basicUnsafeReplicate n_ a - bs <- M.basicUnsafeReplicate n_ b - cs <- M.basicUnsafeReplicate n_ c - ds <- M.basicUnsafeReplicate n_ d - es <- M.basicUnsafeReplicate n_ e - fs <- M.basicUnsafeReplicate n_ f - return $ MV_6 n_ as bs cs ds es fs - {-# INLINE basicUnsafeRead #-} - basicUnsafeRead (MV_6 _ as bs cs ds es fs) i_ - = do - a <- M.basicUnsafeRead as i_ - b <- M.basicUnsafeRead bs i_ - c <- M.basicUnsafeRead cs i_ - d <- M.basicUnsafeRead ds i_ - e <- M.basicUnsafeRead es i_ - f <- M.basicUnsafeRead fs i_ - return (a, b, c, d, e, f) - {-# INLINE basicUnsafeWrite #-} - basicUnsafeWrite (MV_6 _ as bs cs ds es fs) i_ (a, b, c, d, e, f) - = do - M.basicUnsafeWrite as i_ a - M.basicUnsafeWrite bs i_ b - M.basicUnsafeWrite cs i_ c - M.basicUnsafeWrite ds i_ d - M.basicUnsafeWrite es i_ e - M.basicUnsafeWrite fs i_ f - {-# INLINE basicClear #-} - basicClear (MV_6 _ as bs cs ds es fs) - = do - M.basicClear as - M.basicClear bs - M.basicClear cs - M.basicClear ds - M.basicClear es - M.basicClear fs - {-# INLINE basicSet #-} - basicSet (MV_6 _ as bs cs ds es fs) (a, b, c, d, e, f) - = do - M.basicSet as a - M.basicSet bs b - M.basicSet cs c - M.basicSet ds d - M.basicSet es e - M.basicSet fs f - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_6 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ as2 - bs2 - cs2 - ds2 - es2 - fs2) - = do - M.basicUnsafeCopy as1 as2 - M.basicUnsafeCopy bs1 bs2 - M.basicUnsafeCopy cs1 cs2 - M.basicUnsafeCopy ds1 ds2 - M.basicUnsafeCopy es1 es2 - M.basicUnsafeCopy fs1 fs2 - {-# INLINE basicUnsafeMove #-} - basicUnsafeMove (MV_6 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ as2 - bs2 - cs2 - ds2 - es2 - fs2) - = do - M.basicUnsafeMove as1 as2 - M.basicUnsafeMove bs1 bs2 - M.basicUnsafeMove cs1 cs2 - M.basicUnsafeMove ds1 ds2 - M.basicUnsafeMove es1 es2 - M.basicUnsafeMove fs1 fs2 - {-# INLINE basicUnsafeGrow #-} - basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_ - = do - as' <- M.basicUnsafeGrow as m_ - bs' <- M.basicUnsafeGrow bs m_ - cs' <- M.basicUnsafeGrow cs m_ - ds' <- M.basicUnsafeGrow ds m_ - es' <- M.basicUnsafeGrow es m_ - fs' <- M.basicUnsafeGrow fs m_ - return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs' -instance (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => G.Vector Vector (a, b, c, d, e, f) where - {-# INLINE basicUnsafeFreeze #-} - basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs) - = do - as' <- G.basicUnsafeFreeze as - bs' <- G.basicUnsafeFreeze bs - cs' <- G.basicUnsafeFreeze cs - ds' <- G.basicUnsafeFreeze ds - es' <- G.basicUnsafeFreeze es - fs' <- G.basicUnsafeFreeze fs - return $ V_6 n_ as' bs' cs' ds' es' fs' - {-# INLINE basicUnsafeThaw #-} - basicUnsafeThaw (V_6 n_ as bs cs ds es fs) - = do - as' <- G.basicUnsafeThaw as - bs' <- G.basicUnsafeThaw bs - cs' <- G.basicUnsafeThaw cs - ds' <- G.basicUnsafeThaw ds - es' <- G.basicUnsafeThaw es - fs' <- G.basicUnsafeThaw fs - return $ MV_6 n_ as' bs' cs' ds' es' fs' - {-# INLINE basicLength #-} - basicLength (V_6 n_ _ _ _ _ _ _) = n_ - {-# INLINE basicUnsafeSlice #-} - basicUnsafeSlice i_ m_ (V_6 _ as bs cs ds es fs) - = V_6 m_ (G.basicUnsafeSlice i_ m_ as) - (G.basicUnsafeSlice i_ m_ bs) - (G.basicUnsafeSlice i_ m_ cs) - (G.basicUnsafeSlice i_ m_ ds) - (G.basicUnsafeSlice i_ m_ es) - (G.basicUnsafeSlice i_ m_ fs) - {-# INLINE basicUnsafeIndexM #-} - basicUnsafeIndexM (V_6 _ as bs cs ds es fs) i_ - = do - a <- G.basicUnsafeIndexM as i_ - b <- G.basicUnsafeIndexM bs i_ - c <- G.basicUnsafeIndexM cs i_ - d <- G.basicUnsafeIndexM ds i_ - e <- G.basicUnsafeIndexM es i_ - f <- G.basicUnsafeIndexM fs i_ - return (a, b, c, d, e, f) - {-# INLINE basicUnsafeCopy #-} - basicUnsafeCopy (MV_6 _ as1 bs1 cs1 ds1 es1 fs1) (V_6 _ as2 - bs2 - cs2 - ds2 - es2 - fs2) - = do - G.basicUnsafeCopy as1 as2 - G.basicUnsafeCopy bs1 bs2 - G.basicUnsafeCopy cs1 cs2 - G.basicUnsafeCopy ds1 ds2 - G.basicUnsafeCopy es1 es2 - G.basicUnsafeCopy fs1 fs2 - {-# INLINE elemseq #-} - elemseq _ (a, b, c, d, e, f) - = G.elemseq (undefined :: Vector a) a - . G.elemseq (undefined :: Vector b) b - . G.elemseq (undefined :: Vector c) c - . G.elemseq (undefined :: Vector d) d - . G.elemseq (undefined :: Vector e) e - . G.elemseq (undefined :: Vector f) f -#endif -#ifdef DEFINE_MUTABLE --- | /O(1)/ Zip 6 vectors -zip6 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => MVector s a -> - MVector s b -> - MVector s c -> - MVector s d -> - MVector s e -> - MVector s f -> MVector s (a, b, c, d, e, f) -{-# INLINE_FUSED zip6 #-} -zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - (unsafeSlice 0 len es) - (unsafeSlice 0 len fs) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds `delayed_min` - length es `delayed_min` - length fs --- | /O(1)/ Unzip 6 vectors -unzip6 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, - MVector s b, - MVector s c, - MVector s d, - MVector s e, - MVector s f) -{-# INLINE unzip6 #-} -unzip6 (MV_6 _ as bs cs ds es fs) = (as, bs, cs, ds, es, fs) -#endif -#ifdef DEFINE_IMMUTABLE --- | /O(1)/ Zip 6 vectors -zip6 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => Vector a -> - Vector b -> - Vector c -> - Vector d -> - Vector e -> - Vector f -> Vector (a, b, c, d, e, f) -{-# INLINE_FUSED zip6 #-} -zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as) - (unsafeSlice 0 len bs) - (unsafeSlice 0 len cs) - (unsafeSlice 0 len ds) - (unsafeSlice 0 len es) - (unsafeSlice 0 len fs) - where - len = length as `delayed_min` - length bs `delayed_min` - length cs `delayed_min` - length ds `delayed_min` - length es `delayed_min` - length fs -{-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs . - G.stream (zip6 as - bs - cs - ds - es - fs) = Bundle.zipWith6 (, , , , ,) (G.stream as) - (G.stream bs) - (G.stream cs) - (G.stream ds) - (G.stream es) - (G.stream fs) #-} - --- | /O(1)/ Unzip 6 vectors -unzip6 :: (Unbox a, - Unbox b, - Unbox c, - Unbox d, - Unbox e, - Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a, - Vector b, - Vector c, - Vector d, - Vector e, - Vector f) -{-# INLINE unzip6 #-} -unzip6 (V_6 _ as bs cs ds es fs) = (as, bs, cs, ds, es, fs) -#endif |