Use consistent module name qualifiers
authorBen Lippmeier <benl@ouroborus.net>
Fri, 25 Nov 2011 04:48:38 +0000 (15:48 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 29 Nov 2011 05:32:39 +0000 (16:32 +1100)
18 files changed:
dph-lifted-vseg/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Double.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Int.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Nested.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Sum2.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Word8.hs
dph-prim-interface/Data/Array/Parallel/Unlifted.hs
dph-prim-interface/interface/DPH_Header.h
dph-prim-interface/interface/DPH_Interface.h
dph-prim-par/Data/Array/Parallel/Unlifted.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSel.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPVSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USel.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Vector.hs

index 27df6db..0c686bd 100644 (file)
@@ -78,6 +78,7 @@ import qualified Data.Vector                    as V
 import qualified "dph-lifted-base" Data.Array.Parallel.PArray           as R
 import qualified "dph-lifted-base" Data.Array.Parallel.PArray.Reference as R
 
+
 import qualified Prelude                        as P
 import Prelude hiding 
         ( length, replicate, concat
@@ -172,7 +173,7 @@ singleton x
 singletonl :: PA a => PArray a -> PArray (PArray a)
 singletonl arr
  = withRef2 "singletonl" (R.singletonl (toRef1 arr))
- $ replicatel (replicate (length arr) 1) arr
+ $ replicatel_ (replicate_ (length arr) 1) arr
 {-# INLINE_PA singletonl #-}
 
 
@@ -180,20 +181,29 @@ singletonl arr
 --   We require the replication count to be > 0 so that it's easier to maintain
 --   the validPR invariants for nested arrays.
 replicate :: PA a => Int -> a -> PArray a
-replicate n@(I# n#) x
+replicate n x
  = withRef1 "replicate" (R.replicate n x)
- $ PArray n# (replicatePA (I# n#) x)
+ $ replicate_ n x
 {-# INLINE_PA replicate #-}
+replicate_ :: PA a => Int -> a -> PArray a
+replicate_ (I# n#) x
+ = PArray n# (replicatePA (I# n#) x)
+{-# INLINE_PA replicate_ #-}
 
 
 -- | O(sum lengths). Lifted replicate.
 replicatel :: PA a => PArray Int -> PArray a -> PArray (PArray a)
-replicatel reps@(PArray n# (PInt lens)) arr@(PArray _ pdata)
+replicatel reps arr
  = withRef2 "replicatel" (R.replicatel (toRef1 reps) (toRef1 arr))
- $ if n# ==# 0# then empty else 
-    let segd    = U.lengthsToSegd lens
-        pdata'  = replicatesPA segd pdata
-        c       = I# n#
+ $ replicatel_ reps arr
+
+replicatel_ :: PA a => PArray Int -> PArray a -> PArray (PArray a)
+replicatel_ (PArray n# (PInt lens)) (PArray _ pdata)
+ = if n# ==# 0# then empty else 
+    let !segd    = U.lengthsToSegd lens
+        !pdata'  = replicatesPA segd pdata
+        !c       = I# n#
         
      in PArray n# 
          $ mkPNested
@@ -202,8 +212,7 @@ replicatel reps@(PArray n# (PInt lens)) arr@(PArray _ pdata)
                 (U.indicesSegd segd)
                 (U.replicate c 0)
                 (singletondPA pdata')
-
-{-# INLINE_PA replicatel #-}
+{-# INLINE_PA replicatel_ #-}
 
 
 -- | O(sum lengths). Segmented replicate.
@@ -261,7 +270,7 @@ concatl arr@(PArray n# pdata1)
 -- | Impose a nesting structure on a flat array
 unconcat :: (PA a, PA b) => PArray (PArray a) -> PArray b -> PArray (PArray b)
 unconcat (PArray n# pdata1) (PArray _ pdata2)
       = PArray n# $ unconcatPA pdata1 pdata2
+ = PArray n# $ unconcatPA pdata1 pdata2
 {-# INLINE_PA unconcat #-}
 
 
@@ -296,21 +305,21 @@ lengthl arr@(PArray n# (PNested vsegd _))
 -- | O(1). Lookup a single element from the source array.
 index    :: PA a => PArray a -> Int -> a
 index (PArray _ arr) ix
- = indexPA arr ix
       = indexPA arr ix
 {-# INLINE_PA index #-}
 
 
 -- | O(len indices). Lookup a several elements from several source arrays
 indexl    :: PA a => PArray (PArray a) -> PArray Int -> PArray a
 indexl (PArray n# darr) (PArray _ ixs)
- = PArray n# (indexlPA darr ixs)
       = PArray n# (indexlPA darr ixs)
 {-# INLINE_PA indexl #-}
 
 
 -- | Extract a range of elements from an array.
 extract  :: PA a => PArray a -> Int -> Int -> PArray a
 extract (PArray _ arr) start len@(I# len#)
- = PArray len# (extractPA arr start len)
       = PArray len# (extractPA arr start len)
 {-# INLINE_PA extract #-}
 
 
@@ -338,9 +347,9 @@ extracts'
         -> PArray Int           -- ^ length of each segment.
         -> PArray a
 extracts' arrs (PArray _ (PInt sources)) (PArray _ (PInt starts)) (PArray _ (PInt lengths))
- = let  segd    = U.lengthsToSegd lengths
-        ssegd   = U.mkSSegd starts sources segd
-   in   extracts arrs ssegd
+ = let segd    = U.lengthsToSegd lengths
+       ssegd   = U.mkSSegd starts sources segd
+   in  extracts arrs ssegd
 {-# INLINE_PA extracts' #-}
         
 
@@ -445,7 +454,7 @@ zip (PArray n# pdata1) (PArray _ pdata2)
 zipl    :: (PA a, PA b)
         => PArray (PArray a) -> PArray (PArray b) -> PArray (PArray (a, b))
 zipl (PArray n# xs) (PArray _ ys)
       = PArray n# $ ziplPA xs ys
+ = PArray n# $ ziplPA xs ys
 {-# INLINE_PA zipl #-}
 
 
index cfeb180..6285f78 100644 (file)
@@ -11,7 +11,6 @@ import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.PData.Nested
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
-import qualified Data.Vector.Unboxed            as VU
 
 -------------------------------------------------------------------------------
 data instance PData Double
@@ -79,13 +78,13 @@ instance PR Double where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PDouble arr) ix
-        = arr VU.! ix
+        = arr U.!: ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PDoubles pvecs) (PInt srcs) (PInt ixs)
    = PDouble $ U.zipWith get srcs ixs
-   where get !src !ix
-                = (pvecs V.! src) VU.! ix
+   where get !ix !src    = (pvecs V.! src) U.!: ix     -- SAFE INDEXING SIMPLIFIER BUG WORKAROUND
+
 
   {-# NOINLINE extractPR #-}
   extractPR (PDouble arr) start len 
index 9d008a5..2387040 100644 (file)
@@ -6,7 +6,6 @@ module Data.Array.Parallel.PArray.PData.Int () where
 import Data.Array.Parallel.PArray.PData.Base
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
-import qualified Data.Vector.Unboxed            as VU
 import Text.PrettyPrint
 import Prelude                                  as P
 import Data.Array.Parallel.Pretty
@@ -74,7 +73,7 @@ instance PR Int where
   indexsPR (PInts pvecs) (PInt srcs) (PInt ixs)
    = PInt $ U.zipWith get srcs ixs
    where get !src !ix
-                = (pvecs V.! src) VU.! ix
+                = (pvecs V.! src) U.!: ix         -- SAFE INDEXING SIMPLIFIER BUG WORKAROUND
 
   {-# NOINLINE extractPR #-}
   extractPR (PInt arr) start len 
index 5cbbb1a..f035ac7 100644 (file)
@@ -21,8 +21,8 @@ import Data.Array.Parallel.PArray.PData.Base    as PA
 import qualified Data.IntSet                    as IS
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
-import qualified Data.Vector.Unboxed            as VU
 import GHC.Exts
+import Debug.Trace
 
 -- TODO: Using plain V.Vector for the psegdata field means that operations on
 --       this field aren't parallelised. In particular, when we append two
@@ -377,9 +377,9 @@ instance PR a => PR (PArray a) where
          -- Function to get one element of the result.
          {-# INLINE get #-}
          get srcid vsegid
-          = let !pseglen        = (arrs_pseglens   V.! srcid) VU.! vsegid
-                !psegstart      = (arrs_psegstarts V.! srcid) VU.! vsegid
-                !psegsrcid      = (arrs_psegsrcids V.! srcid) VU.! vsegid  
+          = let !pseglen        = (arrs_pseglens   V.! srcid) U.!: vsegid
+                !psegstart      = (arrs_psegstarts V.! srcid) U.!: vsegid
+                !psegsrcid      = (arrs_psegsrcids V.! srcid) U.!: vsegid  
                                 + psrcoffset V.! srcid
             in  (pseglen, psegstart, psegsrcid)
             
index fedb0b6..b10391e 100644 (file)
@@ -14,7 +14,6 @@ import Data.Array.Parallel.PArray.Types
 import Data.Array.Parallel.Base                 (intToTag)
 import Data.Array.Parallel.Unlifted             as U
 import qualified Data.Vector                    as V
-import qualified Data.Vector.Unboxed            as VU
 import Text.PrettyPrint
 import Prelude                                  as P
 import Data.Array.Parallel.Pretty
@@ -127,11 +126,6 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
           bs    = appendPR bs1 bs2
       in  PSum2 sel as bs
         
-        
-  -- {-# INLINE_PDATA appendsPR #-}
-  -- appendsPR
-  --       = nope "appends"
-
 
   -- Projections --------------------------------
   {-# INLINE_PDATA lengthPR #-}
@@ -151,8 +145,8 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
    = let 
          getFlagIndex !src !ix
           = let !sel        = sels                V.!  src
-                !elemFlag   = (U.tagsSel2    sel) VU.! ix
-                !elemIndex  = (U.indicesSel2 sel) VU.! ix
+                !elemFlag   = (U.tagsSel2    sel) U.!: ix
+                !elemIndex  = (U.indicesSel2 sel) U.!: ix
             in  (elemFlag, elemIndex)
             
          (flags', indices')
index d2dec3d..c1adfde 100644 (file)
@@ -6,7 +6,6 @@ module Data.Array.Parallel.PArray.PData.Word8 where
 import Data.Array.Parallel.PArray.PData.Base
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
-import qualified Data.Vector.Unboxed            as VU
 import Text.PrettyPrint
 import Prelude                                  as P
 import Data.Word
@@ -83,7 +82,7 @@ instance PR Word8 where
   indexsPR (PWord8s pvecs) (PInt srcs) (PInt ixs)
    = PWord8 $ U.zipWith get srcs ixs
    where get !src !ix
-                = (pvecs V.! src) VU.! ix
+                = (pvecs V.! src) U.!: ix
 
   {-# NOINLINE extractPR #-}
   extractPR (PWord8 arr) start len 
index f689cd2..ec5f8f9 100644 (file)
@@ -87,6 +87,7 @@ enumFromStepLenEach size starts steps lens
 -- Projections ----------------------------------------------------------------
 length          = P.length
 (!:)            = (P.!!)
+unsafeIndex     = (P.!!)
 
 extract xs i n  = P.take n (P.drop i xs)
 extract_ss      = notImplemented "extract_ss"
index 7bbaf04..f810d43 100644 (file)
@@ -20,7 +20,7 @@ module Data.Array.Parallel.Unlifted (
 
   -- * Projections
   length,
-  (!:),
+  (!:),     unsafeIndex,
   extract,  extract_ss,
   drop,
   
index 3dc975b..30a858a 100644 (file)
@@ -195,6 +195,11 @@ length :: Elt a => Array a -> Int
 {-# INLINE_BACKEND (!:) #-}
 
 
+-- | O(1). Retrieve a numbered element from an array, without bounds checks.
+unsafeIndex :: Elt a => Array a -> Int -> a
+{-# INLINE_BACKEND unsafeIndex #-}
+
+
 -- | O(n). Extract a subrange of elements from an array.
 --  
 --   @extract [23, 42, 93, 50, 27] 1 3  = [42, 93, 50]@
index de40c70..f3b5c53 100644 (file)
@@ -104,8 +104,9 @@ enumFromStepLenEach n starts steps lens
 
 
 -- Projections ----------------------------------------------------------------
-length  = Seq.length
-(!:)    = (Seq.!)
+length          = Seq.length
+(!:)            = (Seq.!)
+unsafeIndex     = Seq.unsafeIndex
 
 extract arr i n
         =  tracePrim (TraceExtract (Seq.length arr) i n)
index 5080536..1ce2592 100644 (file)
@@ -66,9 +66,9 @@ import Data.Array.Parallel.Unlifted.Parallel.Segmented
 import Data.Array.Parallel.Unlifted.Parallel.Text       ()
 import Data.Array.Parallel.Unlifted.Parallel.Subarrays
 import Data.Array.Parallel.Unlifted.Parallel.Sums
+import Data.Array.Parallel.Unlifted.Sequential.Vector           as US
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSegd   as UPSegd
-import qualified Data.Vector                                    as V
-import Data.Array.Parallel.Unlifted.Sequential.Vector           as Seq
+import qualified Data.Vector                                    as VS
 
 
 -- | O(n). Segmented extract.
@@ -84,7 +84,7 @@ import Data.Array.Parallel.Unlifted.Sequential.Vector           as Seq
 {-# INLINE_UP extractsUP #-}
 extractsUP
         :: Unbox a 
-        => V.Vector (Vector a)  -- ^ Source Vectors.
+        => VS.Vector (Vector a) -- ^ Source Vectors.
         -> Vector Int           -- ^ Source array indices for each segment.
         -> Vector Int           -- ^ Starting element for each segment in its source array.
         -> Vector Int           -- ^ Length of each segment.
@@ -109,14 +109,14 @@ extractsUP arrs srcids ixBase lens
 
         {-# INLINE get #-}
         get (ixDst, ixSegDst) (ixSegSrcBase, srcid)
-         = let  !arr    = arrs V.! srcid                        -- TODO: use unsafeIndex
+         = let  !arr    = arrs VS.! srcid                        -- TODO: use unsafeIndex
                 !ix     = ixDst - ixSegDst + ixSegSrcBase
-           in   arr Seq.! ix                                    -- TODO unsafe unsafeIndex
+           in   arr US.! ix                                    -- TODO unsafe unsafeIndex
          
         result    = zipWithUP get
-                        (Seq.zip (enumFromToUP 0 (dstLen - 1))
+                        (US.zip (enumFromToUP 0 (dstLen - 1))
                                  startixs')
-                        (Seq.zip baseixs
+                        (US.zip baseixs
                                  srcids')
 
    in result
index 4a7ca74..d674dab 100644 (file)
@@ -42,10 +42,9 @@ import Data.Array.Parallel.Unlifted.Sequential.Vector                   (Vector,
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSegd           as UPSegd
 import qualified Data.Array.Parallel.Unlifted.Distributed.USSegd        as DUSSegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd         as USSegd
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector         as Seq
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector         as US
 import qualified Data.Array.Parallel.Unlifted.Sequential                as Seq
-
-import qualified Data.Vector                                            as V
+import qualified Data.Vector                                            as VS
 import Control.Monad.ST
 import Prelude hiding (length)
 
@@ -254,21 +253,21 @@ appendWith upssegd1 pdatas1
 -- Fold -----------------------------------------------------------------------
 -- | Fold segments specified by a `UPSSegd`.
 foldWithP :: Unbox a
-         => (a -> a -> a) -> a -> UPSSegd -> V.Vector (Vector a) -> Vector a
+         => (a -> a -> a) -> a -> UPSSegd -> VS.Vector (Vector a) -> Vector a
 foldWithP f !z  = foldSegsWithP f (Seq.foldlSSU f z)
 {-# INLINE_UP foldWithP #-}
 
 
 -- | Fold segments specified by a `UPSSegd`, with a non-empty vector.
 fold1WithP :: Unbox a
-         => (a -> a -> a) -> UPSSegd -> V.Vector (Vector a) -> Vector a
+         => (a -> a -> a) -> UPSSegd -> VS.Vector (Vector a) -> Vector a
 fold1WithP f    = foldSegsWithP f (Seq.fold1SSU f)
 {-# INLINE_UP fold1WithP #-}
 
 
 -- | Sum up segments specified by a `UPSSegd`.
 sumWithP :: (Num a, Unbox a)
-        => UPSSegd -> V.Vector (Vector a) -> Vector a
+        => UPSSegd -> VS.Vector (Vector a) -> Vector a
 sumWithP = foldWithP (+) 0
 {-# INLINE_UP sumWithP #-}
 
@@ -283,8 +282,8 @@ sumWithP = foldWithP (+) 0
 foldSegsWithP
         :: Unbox a
         => (a -> a -> a)
-        -> (USSegd -> V.Vector (Vector a) -> Vector a)
-        -> UPSSegd -> V.Vector (Vector a) -> Vector a
+        -> (USSegd -> VS.Vector (Vector a) -> Vector a)
+        -> UPSSegd -> VS.Vector (Vector a) -> Vector a
 
 {-# INLINE_UP foldSegsWithP #-}
 foldSegsWithP fElem fSeg segd xss 
@@ -292,7 +291,7 @@ foldSegsWithP fElem fSeg segd xss
    runST (do
         mrs <- joinDM theGang drs
         fixupFold fElem mrs dcarry
-        Seq.unsafeFreeze mrs)
+        US.unsafeFreeze mrs)
 
  where  (dcarry,drs)
           = unzipD
@@ -304,8 +303,7 @@ foldSegsWithP fElem fSeg segd xss
                n | off == 0  = 0
                  | otherwise = 1
 
-           in  ((k, Seq.take n rs), Seq.drop n rs)
-
+           in  ((k, US.take n rs), US.drop n rs)
 
 
 fixupFold
@@ -321,10 +319,10 @@ fixupFold f !mrs !dcarry = go 1
     !p = gangSize theGang
 
     go i | i >= p = return ()
-         | Seq.null c = go (i+1)
+         | US.null c = go (i+1)
          | otherwise   = do
-                           x <- Seq.read mrs k
-                           Seq.write mrs k (f x (c Seq.! 0))
+                           x <- US.read mrs k
+                           US.write mrs k (f x (c US.! 0))
                            go (i + 1)
       where
         (k,c) = indexD dcarry i
index 9fefc69..57766d6 100644 (file)
@@ -34,7 +34,7 @@ import Data.Array.Parallel.Unlifted.Distributed
 import Data.Array.Parallel.Unlifted.Sequential.USegd                    (USegd)
 import qualified Data.Array.Parallel.Unlifted.Distributed.USegd         as USegd
 import qualified Data.Array.Parallel.Unlifted.Sequential                as Seq
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector         as Seq
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector         as US
 import qualified Data.Array.Parallel.Unlifted.Sequential.USegd          as USegd
 import Data.Array.Parallel.Pretty                                       hiding (empty)
 import Data.Array.Parallel.Unlifted.Sequential.Vector                   (Vector, MVector, Unbox)
@@ -198,7 +198,7 @@ replicateWithP segd !xs
   $ takeDistributed segd
   where
     rep ((dsegd,di),_)
-      = Seq.replicateSU dsegd (Seq.slice xs di (USegd.length dsegd))
+      = Seq.replicateSU dsegd (US.slice xs di (USegd.length dsegd))
 {-# INLINE_UP replicateWithP #-}
 
 
@@ -242,7 +242,7 @@ foldSegsWithP fElem fSeg segd xs
    runST (do
         mrs <- joinDM theGang drs
         fixupFold fElem mrs dcarry
-        Seq.unsafeFreeze mrs)
+        US.unsafeFreeze mrs)
 
  where  (dcarry,drs)
           = unzipD
@@ -256,7 +256,7 @@ foldSegsWithP fElem fSeg segd xs
                n | off == 0  = 0
                  | otherwise = 1
 
-           in  ((k, Seq.take n rs), Seq.drop n rs)
+           in  ((k, US.take n rs), US.drop n rs)
 
 
 fixupFold
@@ -271,10 +271,10 @@ fixupFold f !mrs !dcarry = go 1
     !p = gangSize theGang
 
     go i | i >= p = return ()
-         | Seq.null c = go (i+1)
+         | US.null c = go (i+1)
          | otherwise   = do
-                           x <- Seq.read mrs k
-                           Seq.write mrs k (f x (c Seq.! 0))
+                           x <- US.read mrs k
+                           US.write mrs k (f x (c US.! 0))
                            go (i + 1)
       where
         (k,c) = indexD dcarry i
index ec8b0f8..a113199 100644 (file)
@@ -20,7 +20,7 @@ module Data.Array.Parallel.Unlifted.Parallel.UPSel (
   elementsUPSelRep2_0,
   elementsUPSelRep2_1,
 ) where
-import Data.Array.Parallel.Unlifted.Sequential.Vector as Seq
+import Data.Array.Parallel.Unlifted.Sequential.Vector   as US
 import Data.Array.Parallel.Unlifted.Sequential.USel
 import Data.Array.Parallel.Unlifted.Distributed
 import Data.Array.Parallel.Base (Tag, tagToInt)
@@ -142,8 +142,8 @@ mkUPSelRep2 tags = zipD idxs lens
     idxs = fst
          $ scanD theGang add (0,0) lens
 
-    count bs = let ones = Seq.sum (Seq.map tagToInt bs)
-               in (Seq.length bs - ones,ones)
+    count bs = let ones = US.sum (US.map tagToInt bs)
+               in (US.length bs - ones,ones)
 
     add (x1,y1) (x2,y2) = (x1+x2, y1+y2)
 {-# INLINE_UP mkUPSelRep2 #-}
@@ -157,8 +157,8 @@ indicesUPSelRep2 tags rep
               rep
   where
     indices tags ((i,j), (m,n))
-      = Seq.combine2ByTag tags (Seq.enumFromStepLen i 1 m)
-                               (Seq.enumFromStepLen j 1 n)
+      = US.combine2ByTag tags (US.enumFromStepLen i 1 m)
+                              (US.enumFromStepLen j 1 n)
 {-# INLINE_UP indicesUPSelRep2 #-}
 
 
index 392ad74..3a37d5c 100644 (file)
@@ -48,8 +48,8 @@ import Data.Array.Parallel.Unlifted.Sequential.Vector           (Vector)
 import Data.Array.Parallel.Pretty                               hiding (empty)
 import Prelude                                                  hiding (length)
 
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as US
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd as USSegd
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSel    as UPSel
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSegd   as UPSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSSegd  as UPSSegd
@@ -108,7 +108,7 @@ data UPVSegd
 instance PprPhysical UPVSegd where
  pprp (UPVSegd _ _ vsegids _ upssegd)
   = vcat
-  [ text "UPVSegd" $$ (nest 7 $ text "vsegids: " <+> (text $ show $ V.toList vsegids))
+  [ text "UPVSegd" $$ (nest 7 $ text "vsegids: " <+> (text $ show $ US.toList vsegids))
   , pprp upssegd ]
 
 
@@ -145,7 +145,7 @@ mkUPVSegd vsegids ussegd
 --
 fromUPSSegd :: UPSSegd -> UPVSegd
 fromUPSSegd upssegd
- = let  vsegids = V.enumFromTo 0 (UPSSegd.length upssegd - 1)
+ = let  vsegids = US.enumFromTo 0 (UPSSegd.length upssegd - 1)
    in   UPVSegd True vsegids vsegids upssegd upssegd
 {-# INLINE_UP fromUPSSegd #-}
 
@@ -163,7 +163,7 @@ fromUPSegd      = fromUPSSegd . UPSSegd.fromUPSegd
 -- | O(1). Construct an empty segment descriptor, with no elements or segments.
 empty :: UPVSegd
 empty
- = let  vsegids = V.empty
+ = let  vsegids = US.empty
         upssegd = UPSSegd.empty
    in   UPVSegd True vsegids vsegids upssegd upssegd
 {-# INLINE_UP empty #-}
@@ -174,7 +174,7 @@ empty
 --   with sourceid 0.
 singleton :: Int -> UPVSegd
 singleton n
- = let  vsegids = V.singleton 0
+ = let  vsegids = US.singleton 0
         upssegd = UPSSegd.singleton n
    in   UPVSegd True vsegids vsegids upssegd upssegd
 {-# INLINE_UP singleton #-}
@@ -210,7 +210,7 @@ isContiguous    = UPSSegd.isContiguous . upvsegd_upssegd_culled
 
 -- | O(1). Yield the overall number of segments.
 length :: UPVSegd -> Int
-length          = V.length . upvsegd_vsegids_redundant
+length          = US.length . upvsegd_vsegids_redundant
 {-# INLINE length #-}
 
 
@@ -258,7 +258,7 @@ takeUPSSegdRedundant    = upvsegd_upssegd_redundant
 takeLengths :: UPVSegd -> Vector Int
 takeLengths (UPVSegd manifest _ vsegids _ upssegd)
  | manifest     = UPSSegd.takeLengths upssegd
- | otherwise    = V.map (UPSSegd.takeLengths upssegd V.!) vsegids
+ | otherwise    = US.map (UPSSegd.takeLengths upssegd US.!) vsegids
 {-# NOINLINE takeLengths #-}
 --  NOINLINE because we don't want a case expression due to the test on the 
 --  manifest flag to appear in the core program.
@@ -276,7 +276,7 @@ getSeg upvsegd ix
  = let  vsegids = upvsegd_vsegids_redundant upvsegd
         upssegd = upvsegd_upssegd_redundant upvsegd
         (len, _index, start, source)
-                = UPSSegd.getSeg upssegd (vsegids V.! ix)
+                = UPSSegd.getSeg upssegd (vsegids US.! ix)
    in   (len, start, source)
 {-# INLINE_UP getSeg #-}
 
@@ -398,10 +398,10 @@ appendWith
 
  = let  -- vsegids releative to appended psegs
         vsegids1' = vsegids1
-        vsegids2' = V.map (+ UPSSegd.length upssegd1) vsegids2
+        vsegids2' = US.map (+ UPSSegd.length upssegd1) vsegids2
         
         -- append the vsegids
-        vsegids'  = vsegids1' V.++ vsegids2'
+        vsegids'  = vsegids1' US.++ vsegids2'
 
         -- All data from the source arrays goes into the result
         upssegd'  = UPSSegd.appendWith
@@ -435,10 +435,10 @@ combine2
 
  = let  -- vsegids relative to combined psegs
         vsegids1' = vsegids1
-        vsegids2' = V.map (+ (V.length vsegids1)) vsegids2
+        vsegids2' = US.map (+ (US.length vsegids1)) vsegids2
 
         -- combine the vsegids
-        vsegids'  = V.combine2ByTag (UPSel.tagsUPSel2 upsel2)
+        vsegids'  = US.combine2ByTag (UPSel.tagsUPSel2 upsel2)
                                     vsegids1' vsegids2'
 
          -- All data from the source arrays goes into the result
index 6c2a1f9..bddd5dc 100644 (file)
@@ -16,7 +16,7 @@ import Data.Array.Parallel.Unlifted.Sequential
 import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd as USSegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.UVSegd as UVSegd
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as U
 
 #include "DPH_Interface.h"
 
@@ -26,82 +26,83 @@ import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
 
 
 -- Basics ---------------------------------------------------------------------
-class V.Unbox a => Elt a
-type Array              = V.Vector
+class U.Unbox a => Elt a
+type Array              = U.Vector
 
 
 -- Constructors ---------------------------------------------------------------
-empty                   = V.empty
-(+:+)                   = (V.++)
+empty                   = U.empty
+(+:+)                   = (U.++)
 append_s _              = appendSU
-replicate               = V.replicate
+replicate               = U.replicate
 replicate_s             = replicateSU
 replicate_rs            = replicateRSU
-repeat n _              = V.repeat n
-indexed                 = V.indexed
+repeat n _              = U.repeat n
+indexed                 = U.indexed
 indices_s               = indicesSU
-enumFromTo              = V.enumFromTo
-enumFromThenTo          = V.enumFromThenTo
-enumFromStepLen         = V.enumFromStepLen
-enumFromStepLenEach     = V.enumFromStepLenEach
+enumFromTo              = U.enumFromTo
+enumFromThenTo          = U.enumFromThenTo
+enumFromStepLen         = U.enumFromStepLen
+enumFromStepLenEach     = U.enumFromStepLenEach
 
 
 -- Projections ----------------------------------------------------------------
-length                  = V.length
-(!:)                    = (V.!)
-extract                 = V.extract
+length                  = U.length
+(!:)                    = (U.!)
+unsafeIndex             = U.unsafeIndex
+extract                 = U.extract
 extract_ss              = extractsSU
-drop                    = V.drop
+drop                    = U.drop
 
 
 -- Update ---------------------------------------------------------------------
-update                  = V.update
+update                  = U.update
 
 
 -- Permutation ----------------------------------------------------------------
-permute                 = V.permute
-bpermute                = V.bpermute
-mbpermute               = V.mbpermute
-bpermuteDft             = V.bpermuteDft
+permute                 = U.permute
+bpermute                = U.bpermute
+mbpermute               = U.mbpermute
+bpermuteDft             = U.bpermuteDft
 
 
 -- Zipping and Unzipping ------------------------------------------------------
-zip                     = V.zip
-zip3                    = V.zip3
-unzip                   = V.unzip
-unzip3                  = V.unzip3
-fsts                    = V.fsts
-snds                    = V.snds
+zip                     = U.zip
+zip3                    = U.zip3
+unzip                   = U.unzip
+unzip3                  = U.unzip3
+fsts                    = U.fsts
+snds                    = U.snds
 
 
 -- Map and ZipWith ------------------------------------------------------------
-map                     = V.map
-zipWith                 = V.zipWith
+map                     = U.map
+zipWith                 = U.zipWith
 
 
 -- Scans and Folds ------------------------------------------------------------
-scan                    = V.scan
-fold                    = V.fold
+scan                    = U.scan
+fold                    = U.fold
 fold_s                  = foldSU
 fold_ss                 = foldSSU
 fold_r                  = foldlRU
-fold1                   = V.fold1
+fold1                   = U.fold1
 fold1_s                 = fold1SU
 fold1_ss                = fold1SSU
-sum                     = V.sum
+sum                     = U.sum
 sum_r                   = sumRU
-and                     = V.and
+and                     = U.and
 
 
 -- Packing and Filter ---------------------------------------------------------
-pack                    = V.pack
-filter                  = V.filter
+pack                    = U.pack
+filter                  = U.filter
 
 
 -- Combine and Interleave -----------------------------------------------------
-combine                 = V.combine
-combine2 tags _         = V.combine2ByTag tags
-interleave              = V.interleave
+combine                 = U.combine
+combine2 tags _         = U.combine2ByTag tags
+interleave              = U.interleave
 
 
 -- Selectors ------------------------------------------------------------------
@@ -175,15 +176,15 @@ combine2VSegd                   = UVSegd.combine2
 
 
 -- Random Arrays --------------------------------------------------------------
-randoms                 = V.random
-randomRs                = V.randomR
+randoms                 = U.random
+randomRs                = U.randomR
 
 
 -- Array IO -------------------------------------------------------------------
-class V.UIO a => IOElt a
-hPut                    = V.hPut
-hGet                    = V.hGet
+class U.UIO a => IOElt a
+hPut                    = U.hPut
+hGet                    = U.hGet
 
-toList                  = V.toList
-fromList                = V.fromList
+toList                  = U.toList
+fromList                = U.fromList
 
index 8967c3d..0241fde 100644 (file)
@@ -39,10 +39,10 @@ module Data.Array.Parallel.Unlifted.Sequential.USel (
   tagsUSel2, indicesUSel2, elementsUSel2_0, elementsUSel2_1,
   tagsToIndices2
 ) where
-import Data.Array.Parallel.Unlifted.Sequential.Vector as V
-import qualified Data.Vector.Fusion.Stream as S
-import Data.Vector.Fusion.Stream.Monadic ( Stream(..) )
-import Data.Array.Parallel.Base (Tag)
+import Data.Array.Parallel.Unlifted.Sequential.Vector   as V
+import qualified Data.Vector.Fusion.Stream              as S
+import Data.Vector.Fusion.Stream.Monadic                ( Stream(..) )
+import Data.Array.Parallel.Base                         (Tag)
 
 
 -- | Abstract selector. 
index d584c7d..26fc943 100644 (file)
@@ -25,7 +25,8 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
   length, null, empty, singleton, cons, units,
   replicate,
   -- replicateEachU,
-  (!), (++),
+  (!), unsafeIndex,
+  (++),
   interleave, indexed, repeat, repeatS,
 
   -- * Subarrays