Add unsafeIndex and unsafeSlice
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 2 Dec 2009 12:16:23 +0000 (12:16 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 2 Dec 2009 12:16:23 +0000 (12:16 +0000)
Data/Vector.hs
Data/Vector/Generic.hs
Data/Vector/Generic/New.hs
Data/Vector/Primitive.hs
Data/Vector/Storable.hs

index 54ce3ab..d1c5ffa 100644 (file)
@@ -23,9 +23,11 @@ module Data.Vector (
 
   -- * Accessing individual elements
   (!), head, last, indexM, headM, lastM,
+  unsafeIndex, unsafeIndexM,
 
   -- * Subvectors
   slice, init, tail, take, drop,
+  unsafeSlice,
 
   -- * Permutations
   accum, (//), update, backpermute, reverse,
@@ -173,6 +175,11 @@ copy = G.copy
 {-# INLINE (!) #-}
 (!) = (G.!)
 
+-- | Unsafe indexing without bounds checks
+unsafeIndex :: Vector a -> Int -> a
+{-# INLINE unsafeIndex #-}
+unsafeIndex = G.unsafeIndex
+
 -- | First element
 head :: Vector a -> a
 {-# INLINE head #-}
@@ -189,6 +196,11 @@ indexM :: Monad m => Vector a -> Int -> m a
 {-# INLINE indexM #-}
 indexM = G.indexM
 
+-- | Unsafe monadic indexing without bounds checks
+unsafeIndexM :: Monad m => Vector a -> Int -> m a
+{-# INLINE unsafeIndexM #-}
+unsafeIndexM = G.unsafeIndexM
+
 headM :: Monad m => Vector a -> m a
 {-# INLINE headM #-}
 headM = G.headM
@@ -208,6 +220,14 @@ slice :: Vector a -> Int   -- ^ starting index
 {-# INLINE slice #-}
 slice = G.slice
 
+-- | Unsafely yield a part of the vector without copying it and without
+-- performing bounds checks.
+unsafeSlice :: Vector a -> Int   -- ^ starting index
+                        -> Int   -- ^ length
+                        -> Vector a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
 -- | Yield all but the last element without copying.
 init :: Vector a -> Vector a
 {-# INLINE init #-}
index 2c77bac..d9883e3 100644 (file)
@@ -26,9 +26,11 @@ module Data.Vector.Generic (
 
   -- * Accessing individual elements
   (!), head, last, indexM, headM, lastM,
+  unsafeIndex, unsafeIndexM,
 
   -- * Subvectors
   slice, init, tail, take, drop,
+  unsafeSlice,
 
   -- * Permutations
   accum, (//), update, backpermute, reverse,
@@ -265,6 +267,11 @@ copy = unstream . stream
 v ! i = assert (i >= 0 && i < length v)
       $ unId (basicUnsafeIndexM v i)
 
+-- | Unsafe indexing without bounds checking
+unsafeIndex :: Vector v a => v a -> Int -> a
+{-# INLINE_STREAM unsafeIndex #-}
+unsafeIndex v i = unId (basicUnsafeIndexM v i)
+
 -- | First element
 head :: Vector v a => v a -> a
 {-# INLINE_STREAM head #-}
@@ -280,6 +287,9 @@ last v = v ! (length v - 1)
 "(!)/unstream [Vector]" forall v i s.
   new' v (New.unstream s) ! i = s Stream.!! i
 
+"unsafeIndex/unstream [Vector]" forall v i s.
+  unsafeIndex (new' v (New.unstream s)) i = s Stream.!! i
+
 "head/unstream [Vector]" forall v s.
   head (new' v (New.unstream s)) = Stream.head s
 
@@ -295,6 +305,11 @@ indexM :: (Vector v a, Monad m) => v a -> Int -> m a
 indexM v i = assert (i >= 0 && i < length v)
            $ basicUnsafeIndexM v i
 
+-- | Unsafe monadic indexing without bounds checks
+unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
+{-# INLINE_STREAM unsafeIndexM #-}
+unsafeIndexM v i = basicUnsafeIndexM v i
+
 headM :: (Vector v a, Monad m) => v a -> m a
 {-# INLINE_STREAM headM #-}
 headM v = indexM v 0
@@ -322,15 +337,22 @@ lastM v = indexM v (length v - 1)
 
 -- FIXME: slicing doesn't work with the inplace stuff at the moment
 
--- | Yield a part of the vector without copying it. Safer version of
--- 'basicUnsafeSlice'.
+-- | Yield a part of the vector without copying it.
 slice :: Vector v a => v a -> Int   -- ^ starting index
-                            -> Int   -- ^ length
-                            -> v a
+                           -> Int   -- ^ length
+                           -> v a
 {-# INLINE_STREAM slice #-}
 slice v i n = assert (i >= 0 && n >= 0  && i+n <= length v)
             $ basicUnsafeSlice v i n
 
+-- | Unsafely yield a part of the vector without copying it and without
+-- performing bounds checks.
+unsafeSlice :: Vector v a => v a -> Int   -- ^ starting index
+                                 -> Int   -- ^ length
+                                 -> v a
+{-# INLINE_STREAM unsafeSlice #-}
+unsafeSlice v i n = basicUnsafeSlice v i n
+
 -- | Yield all but the last element without copying.
 init :: Vector v a => v a -> v a
 {-# INLINE_STREAM init #-}
@@ -359,6 +381,9 @@ drop n v = slice v (min n' len) (max 0 (len - n'))
 "slice/new [Vector]" forall v p i n.
   slice (new' v p) i n = new' v (New.slice p i n)
 
+"unsafeSlice/new [Vector]" forall v p i n.
+  unsafeSlice (new' v p) i n = new' v (New.unsafeSlice p i n)
+
 "init/new [Vector]" forall v p.
   init (new' v p) = new' v (New.init p)
 
index 31449bc..a48390a 100644 (file)
@@ -16,7 +16,8 @@
 
 module Data.Vector.Generic.New (
   New(..), run, unstream, transform, accum, update, reverse,
-  slice, init, tail, take, drop
+  slice, init, tail, take, drop,
+  unsafeSlice
 ) where
 
 import qualified Data.Vector.Generic.Mutable as MVector
@@ -69,6 +70,10 @@ slice :: New a -> Int -> Int -> New a
 {-# INLINE_STREAM slice #-}
 slice m i n = apply (\v -> MVector.slice v i n) m
 
+unsafeSlice :: New a -> Int -> Int -> New a
+{-# INLINE_STREAM unsafeSlice #-}
+unsafeSlice m i n = apply (\v -> MVector.unsafeSlice v i n) m
+
 init :: New a -> New a
 {-# INLINE_STREAM init #-}
 init m = apply (\v -> MVector.slice v 0 (MVector.length v - 1)) m
@@ -90,6 +95,9 @@ drop n m = apply (\v -> MVector.slice v n (max 0 (MVector.length v - n))) m
 "slice/unstream [New]" forall s i n.
   slice (unstream s) i n = unstream (Stream.extract s i n)
 
+"unsafeSlice/unstream [New]" forall s i n.
+  unsafeSlice (unstream s) i n = unstream (Stream.extract s i n)
+
 "init/unstream [New]" forall s.
   init (unstream s) = unstream (Stream.init s)
 
index f80a727..7ffa67f 100644 (file)
@@ -23,9 +23,11 @@ module Data.Vector.Primitive (
 
   -- * Accessing individual elements
   (!), head, last,
+  unsafeIndex,
 
   -- * Subvectors
   slice, init, tail, take, drop,
+  unsafeSlice,
 
   -- * Permutations
   accum, (//), backpermute, reverse,
@@ -175,6 +177,11 @@ copy = G.copy
 {-# INLINE (!) #-}
 (!) = (G.!)
 
+-- | Unsafe indexing without bounds checks
+unsafeIndex :: Prim a => Vector a -> Int -> a
+{-# INLINE unsafeIndex #-}
+unsafeIndex = G.unsafeIndex
+
 -- | First element
 head :: Prim a => Vector a -> a
 {-# INLINE head #-}
@@ -191,11 +198,19 @@ last = G.last
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'basicUnsafeSlice'.
 slice :: Prim a => Vector a -> Int   -- ^ starting index
-                             -> Int   -- ^ length
-                             -> Vector a
+                            -> Int   -- ^ length
+                            -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
+-- | Unsafely yield a part of the vector without copying it and without
+-- performing bounds checks.
+unsafeSlice :: Prim a => Vector a -> Int   -- ^ starting index
+                                  -> Int   -- ^ length
+                                  -> Vector a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
 -- | Yield all but the last element without copying.
 init :: Prim a => Vector a -> Vector a
 {-# INLINE init #-}
index 732ed0a..a8341ba 100644 (file)
@@ -23,9 +23,11 @@ module Data.Vector.Storable (
 
   -- * Accessing individual elements
   (!), head, last,
+  unsafeIndex,
 
   -- * Subvectors
   slice, init, tail, take, drop,
+  unsafeSlice,
 
   -- * Permutations
   accum, (//), backpermute, reverse,
@@ -181,6 +183,11 @@ copy = G.copy
 {-# INLINE (!) #-}
 (!) = (G.!)
 
+-- | Unsafe indexing without bounds checks
+unsafeIndex :: Storable a => Vector a -> Int -> a
+{-# INLINE unsafeIndex #-}
+unsafeIndex = G.unsafeIndex
+
 -- | First element
 head :: Storable a => Vector a -> a
 {-# INLINE head #-}
@@ -202,6 +209,14 @@ slice :: Storable a => Vector a -> Int   -- ^ starting index
 {-# INLINE slice #-}
 slice = G.slice
 
+-- | Unsafely yield a part of the vector without copying it and without
+-- performing bounds checks.
+unsafeSlice :: Storable a => Vector a -> Int   -- ^ starting index
+                                      -> Int   -- ^ length
+                                      -> Vector a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
 -- | Yield all but the last element without copying.
 init :: Storable a => Vector a -> Vector a
 {-# INLINE init #-}