dph-prim-par/seq: comments and formatting only
authorBen Lippmeier <benl@ouroborus.net>
Mon, 29 Aug 2011 06:01:19 +0000 (16:01 +1000)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 29 Aug 2011 06:01:19 +0000 (16:01 +1000)
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Types.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Basics.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Enum.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Segmented.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Subarrays.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Sums.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Basics.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Combinators.hs

index 25bb619..16738c0 100644 (file)
@@ -506,46 +506,57 @@ instance DT USegd where
   data Dist  USegd   = DUSegd  !(Dist (Vector Int))
                                !(Dist (Vector Int))
                                !(Dist Int)
+
   data MDist USegd s = MDUSegd !(MDist (Vector Int) s)
                                !(MDist (Vector Int) s)
                                !(MDist Int        s)
 
   indexD (DUSegd lens idxs eles) i
-          = mkUSegd (indexD lens i) (indexD idxs i) (indexD eles i)
-  newMD g = liftM3 MDUSegd (newMD g) (newMD g) (newMD g)
+   = mkUSegd (indexD lens i) (indexD idxs i) (indexD eles i)
+
+  newMD g
+   = liftM3 MDUSegd (newMD g) (newMD g) (newMD g)
+
   readMD (MDUSegd lens idxs eles) i
-          = liftM3 mkUSegd (readMD lens i) (readMD idxs i) (readMD eles i)
+   = liftM3 mkUSegd (readMD lens i) (readMD idxs i) (readMD eles i)
+
   writeMD (MDUSegd lens idxs eles) i segd
-          = do
-              writeMD lens i (lengthsUSegd  segd)
-              writeMD idxs i (indicesUSegd  segd)
-              writeMD eles i (elementsUSegd segd)
+   = do writeMD lens i (lengthsUSegd  segd)
+        writeMD idxs i (indicesUSegd  segd)
+        writeMD eles i (elementsUSegd segd)
+
   unsafeFreezeMD (MDUSegd lens idxs eles)
-          = liftM3 DUSegd (unsafeFreezeMD lens)
-                          (unsafeFreezeMD idxs)
-                          (unsafeFreezeMD eles)
+   = liftM3 DUSegd (unsafeFreezeMD lens)
+                   (unsafeFreezeMD idxs)
+                   (unsafeFreezeMD eles)
 
-  deepSeqD segd z = deepSeqD (lengthsUSegd  segd)
-                  $ deepSeqD (indicesUSegd  segd)
-                  $ deepSeqD (elementsUSegd segd) z
+  deepSeqD segd z
+   = deepSeqD (lengthsUSegd  segd)
+   $ deepSeqD (indicesUSegd  segd)
+   $ deepSeqD (elementsUSegd segd) z
 
   sizeD  (DUSegd  _ _ eles) = sizeD eles
   sizeMD (MDUSegd _ _ eles) = sizeMD eles
 
-  measureD segd = "Segd " ++ show (lengthUSegd segd) ++ " " ++ show (elementsUSegd segd)
+  measureD segd 
+   = "Segd " ++ show (lengthUSegd segd) ++ " " ++ show (elementsUSegd segd)
+
 
 lengthUSegdD :: Dist USegd -> Dist Int
 {-# INLINE_DIST lengthUSegdD #-}
 lengthUSegdD (DUSegd lens _ _) = lengthD lens
 
+
 lengthsUSegdD :: Dist USegd -> Dist (Vector Int)
 {-# INLINE_DIST lengthsUSegdD #-}
 lengthsUSegdD (DUSegd lens _ _ ) = lens
 
+
 indicesUSegdD :: Dist USegd -> Dist (Vector Int)
 {-# INLINE_DIST indicesUSegdD #-}
 indicesUSegdD (DUSegd _ idxs _) = idxs
 
+
 elementsUSegdD :: Dist USegd -> Dist Int
 {-# INLINE_DIST elementsUSegdD #-}
 elementsUSegdD (DUSegd _ _ dns) = dns
index 1b9ff0c..3275d65 100644 (file)
@@ -21,6 +21,7 @@ import GHC.Base ( remInt )
 nullUP :: Unbox e => Vector e -> Bool
 nullUP  = (== 0) . Seq.length
 
+
 -- | Yield an empty array
 emptyUP :: Unbox e => Vector e
 emptyUP = Seq.new 0 (const $ return ())
@@ -32,36 +33,42 @@ lengthUP = Seq.length
 -- | Yield an array where all elements contain the same value
 replicateUP :: Unbox e => Int -> e -> Vector e
 {-# INLINE_UP replicateUP #-}
-replicateUP n !e = joinD theGang balanced
-                 . mapD theGang (\n ->Seq.replicate n e)
-                 $ splitLenD theGang n
+replicateUP n !e 
+        = joinD theGang balanced
+        . mapD theGang (\n ->Seq.replicate n e)
+        $ splitLenD theGang n
 
 
 -- | Repeat an array the given number of times.
 repeatUP :: Unbox e => Int -> Vector e -> Vector e
 {-# INLINE_UP repeatUP #-}
-repeatUP n es = seq m
-              . bpermuteUP es
-              . mapUP (\i -> i `remInt` m)
-              $ enumFromToUP 0 (m*n-1)
+repeatUP n es 
+        = seq m
+        . bpermuteUP es
+        . mapUP (\i -> i `remInt` m)
+        $ enumFromToUP 0 (m*n-1)
   where
     m = Seq.length es
 
+
 -- | Interleave elements of two arrays
 interleaveUP :: Unbox e => Vector e -> Vector e -> Vector e
 {-# INLINE_UP interleaveUP #-}
-interleaveUP xs ys = joinD theGang unbalanced
-                     (zipWithD theGang Seq.interleave
-                       (splitD theGang balanced xs)
-                       (splitD theGang balanced ys))
-   
+interleaveUP xs ys
+        = joinD theGang unbalanced
+        $ zipWithD theGang Seq.interleave
+                (splitD theGang balanced xs)
+                (splitD theGang balanced ys)
+
+
 -- | Associate each element of the array with its index
 indexedUP :: (DT e, Unbox e) => Vector e -> Vector (Int,e)
 {-# INLINE_U indexedUP #-}
-indexedUP = splitJoinD theGang indexedFn 
-  where
+indexedUP 
+ = splitJoinD theGang indexedFn 
+ where
     sizes  arr   = fst $ scanD theGang (+) 0 $ lengthD arr
-    indexedFn = \arr -> (zipWithD theGang (\o -> Seq.map (\(x,y) -> (x + o, y))) (sizes arr) $ 
-                        mapD theGang Seq.indexed arr)
+    indexedFn    = \arr -> zipWithD theGang (\o -> Seq.map (\(x,y) -> (x + o, y))) (sizes arr) 
+                        $  mapD theGang Seq.indexed arr
 
 
index 79d7595..9c4bc98 100644 (file)
@@ -21,25 +21,25 @@ delay_inline x = x
 
 enumFromToUP :: (Unbox a, Enum a) => a -> a -> Vector a
 {-# INLINE enumFromToUP #-}
-enumFromToUP start end = mapUP toEnum (enumFromStepLenUP start' 1 len)
-  where
   start' = fromEnum start
-    end'   = fromEnum end
-    len    = delay_inline max (end' - start' + 1) 0
+enumFromToUP start end 
+ = mapUP toEnum (enumFromStepLenUP start' 1 len)
where  start' = fromEnum start
+        end'   = fromEnum end
+        len    = delay_inline max (end' - start' + 1) 0
 
 
 enumFromThenToUP :: (Unbox a, Enum a) => a -> a -> a -> Vector a
 {-# INLINE enumFromThenToUP #-}
-enumFromThenToUP start next end =
-  mapUP toEnum (enumFromStepLenUP start' delta len)
-  where
-    start' = fromEnum start
-    next'  = fromEnum next
-    end'   = fromEnum end
-    delta  = next' - start'
-    -- distance between start' and end' expressed in deltas
-    dist   = (end' - start' + delta) `divInt` delta
-    len    = max dist 0
+enumFromThenToUP start next end 
= mapUP toEnum (enumFromStepLenUP start' delta len)
+ where  start' = fromEnum start
+        next'  = fromEnum next
+        end'   = fromEnum end
+        delta  = next' - start'
+
+        -- distance between start' and end' expressed in deltas
+        dist   = (end' - start' + delta) `divInt` delta
+        len    = max dist 0
 
 
 enumFromStepLenUP :: Int -> Int -> Int -> Vector Int
index abb902d..8747ab3 100644 (file)
@@ -56,11 +56,9 @@ replicateRSUP n xs
 -- | Segmented append.
 appendSUP
         :: Unbox a
-        => UPSegd       -- ^ segment descriptor of result array
-        -> UPSegd       -- ^ segment descriptor of first array
-        -> Vector a     -- ^ data of first array
-        -> UPSegd       -- ^ segment descriptor of second array
-        -> Vector a     -- ^ data of first array
+        => UPSegd               -- ^ segment descriptor of result array
+        -> UPSegd -> Vector a   -- ^ segd/data of first array
+        -> UPSegd -> Vector a   -- ^ segd/data of second array
         -> Vector a
 
 {-# INLINE_UP appendSUP #-}
index 9f5d74a..6dcd599 100644 (file)
@@ -10,6 +10,9 @@ import Data.Array.Parallel.Unlifted.Sequential.Vector as Seq
 import Data.Array.Parallel.Unlifted.Distributed
 
 
+-- | Drop a the element at the provided index from a vector.
 dropUP :: Unbox e => Int -> Vector e -> Vector e
-dropUP n xs = Seq.slice xs (min (max 0 n) (Seq.length xs)) (min (Seq.length xs) (Seq.length xs - n)) 
 {-# INLINE_U dropUP #-}
+dropUP n xs 
+        = Seq.slice xs  (min (max 0 n)       (Seq.length xs))
+                        (min (Seq.length xs) (Seq.length xs - n)) 
index 06b13d6..ea9dd20 100644 (file)
@@ -21,11 +21,13 @@ orUP :: Vector Bool -> Bool
 {-# INLINE orUP #-}
 orUP = foldUP (||) False
 
+
 -- | Check whether all the elements in a array meet the given predicate.
 allUP :: Unbox e => (e -> Bool) -> Vector e -> Bool
 {-# INLINE allUP #-}
 allUP p = andUP . mapUP p
 
+
 -- | Check whether any of the elements in a array meet the given predicate.
 anyUP :: Unbox e => (e -> Bool) -> Vector e -> Bool
 {-# INLINE anyUP #-}
@@ -50,7 +52,7 @@ maximumUP :: (DT e, Ord e, Unbox e) => Vector e -> e
 maximumUP = fold1UP max
 
 
---  |Determine the maximum element in an array under the given ordering
+-- Determine the maximum element in an array under the given ordering
 maximumByUP :: (DT e, Unbox e) => (e -> e -> Ordering) -> Vector e -> e
 {-# INLINE maximumByUP #-}
 maximumByUP = fold1UP . maxBy
@@ -59,8 +61,7 @@ maximumByUP = fold1UP . maxBy
                           LT -> y
                           _  -> x
 
--- | Determine the index of the maximum element in an array under the given
---   ordering
+-- | Determine the index of the maximum element in an array under the given ordering
 maximumIndexByUP :: (DT e, Unbox e) => (e -> e -> Ordering) -> Vector e -> Int
 {-# INLINE maximumIndexByUP #-}
 maximumIndexByUP cmp = fst . maximumByUP cmp' . indexedUP
index e7388d3..bfb0e2b 100644 (file)
@@ -11,38 +11,46 @@ import Data.Array.Parallel.Unlifted.Sequential.Segmented.USegd
 import qualified Data.Vector.Fusion.Stream as S
 
 
+-- | Segmented replicate of a vector based on the lengths of the segments
+--   of the provided `USegd`.
 replicateSU :: Unbox a => USegd -> Vector a -> Vector a
 {-# INLINE_U replicateSU #-}
-replicateSU segd xs = unstream
-                     (replicateEachS (elementsUSegd segd)
-                     (S.zip (stream (lengthsUSegd segd)) (stream xs)))
+replicateSU segd xs 
+        = unstream
+             (replicateEachS (elementsUSegd segd)
+             (S.zip (stream (lengthsUSegd segd)) (stream xs)))
 
 
 replicateRSU :: Unbox a => Int -> Vector a -> Vector a
 {-# INLINE_U replicateRSU #-}
-replicateRSU n xs = unstream
-                  . replicateEachRS n
-                  $ stream xs
+replicateRSU n xs
+        = unstream
+        . replicateEachRS n
+        $ stream xs
                   
 
-appendSU :: Unbox a => USegd -> Vector a -> USegd -> Vector a -> Vector a
+-- | Segmented append.
+appendSU :: Unbox a 
+         => USegd -> Vector a   -- segd/data of first array
+         -> USegd -> Vector a   -- segd/data of second array
+         -> Vector a
 {-# INLINE_U appendSU #-}
-appendSU xd xs yd ys = unstream
-                     $ appendSS (stream (lengthsUSegd xd))
-                                (stream xs)
-                                (stream (lengthsUSegd yd))
-                                (stream ys)
-
-
-indicesSU' :: Int -> USegd -> Vector Int
-{-# INLINE_U indicesSU' #-}
-indicesSU' i segd = unstream
-                  . indicesSS (elementsUSegd segd) i
-                  . stream
-                  $ lengthsUSegd segd
+appendSU xd xs yd ys
+        = unstream
+        $ appendSS (stream (lengthsUSegd xd)) (stream xs)
+                   (stream (lengthsUSegd yd)) (stream ys)
 
 
+-- | Segmented indices.
 indicesSU :: USegd -> Vector Int
 {-# INLINE_U indicesSU #-}
 indicesSU = indicesSU' 0
 
+indicesSU' :: Int -> USegd -> Vector Int
+{-# INLINE_U indicesSU' #-}
+indicesSU' i segd
+        = unstream
+        . indicesSS (elementsUSegd segd) i
+        . stream
+        $ lengthsUSegd segd
+
index 49ae7f8..489070b 100644 (file)
@@ -17,8 +17,9 @@ import Debug.Trace
 -- | Segmented array reduction proceeding from the left
 foldlSU :: (Unbox a, Unbox b) => (b -> a -> b) -> b -> USegd -> Vector a -> Vector b
 {-# INLINE_U foldlSU #-}
-foldlSU f z segd xs = unstream
-                    $ foldSS f z (stream (lengthsUSegd segd)) (stream xs)
+foldlSU f z segd xs 
+        = unstream
+         $ foldSS f z (stream (lengthsUSegd segd)) (stream xs)
 
 
 -- | Segmented array reduction that requires an associative combination
@@ -30,8 +31,9 @@ foldSU = foldlSU
 -- | Segmented array reduction from left to right with non-empty subarrays only
 foldl1SU :: Unbox a => (a -> a -> a) -> USegd -> Vector a -> Vector a
 {-# INLINE_U foldl1SU #-}
-foldl1SU f segd xs = unstream
-                   $ fold1SS f (stream (lengthsUSegd segd)) (stream xs)
+foldl1SU f segd xs 
+        = unstream
+        $ fold1SS f (stream (lengthsUSegd segd)) (stream xs)
 
 
 -- | Segmented array reduction with non-empty subarrays and an associative
@@ -43,14 +45,16 @@ fold1SU = foldl1SU
 -- | Merge two segmented arrays according to flag array
 combineSU :: Unbox a => Vector Bool -> USegd -> Vector a -> USegd -> Vector a -> Vector a
 {-# INLINE_U combineSU #-}
-combineSU bs xd xs yd ys = unstream
-                         $ combineSS (stream bs)
-                                     (stream (lengthsUSegd xd)) (stream xs)
-                                     (stream (lengthsUSegd yd)) (stream ys)
+combineSU bs xd xs yd ys
+        = unstream
+        $ combineSS (stream bs)
+                    (stream (lengthsUSegd xd)) (stream xs)
+                    (stream (lengthsUSegd yd)) (stream ys)
 
 
 -- | Regular arrar reduction 
 foldlRU :: (Unbox a, Unbox b) => (b -> a -> b) -> b -> Int -> Vector a -> Vector b
 {-# INLINE_U foldlRU #-}
-foldlRU f z segSize = unstream . foldValuesR f z segSize . stream
+foldlRU f z segSize
+        = unstream . foldValuesR f z segSize . stream