Add freeze
[darcs-mirrors/vector.git] / Data / Vector / Storable.hs
1 {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies, Rank2Types #-}
2
3 -- |
4 -- Module : Data.Vector.Storable
5 -- Copyright : (c) Roman Leshchinskiy 2009-2010
6 -- License : BSD-style
7 --
8 -- Maintainer : Roman Leshchinskiy <rl@cse.unsw.edu.au>
9 -- Stability : experimental
10 -- Portability : non-portable
11 --
12 -- 'Storable'-based vectors.
13 --
14
15 module Data.Vector.Storable (
16 -- * Storable vectors
17 Vector, MVector(..), Storable,
18
19 -- * Accessors
20
21 -- ** Length information
22 length, null,
23
24 -- ** Indexing
25 (!), head, last,
26 unsafeIndex, unsafeHead, unsafeLast,
27
28 -- ** Monadic indexing
29 indexM, headM, lastM,
30 unsafeIndexM, unsafeHeadM, unsafeLastM,
31
32 -- ** Extracting subvectors (slicing)
33 slice, init, tail, take, drop,
34 unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
35
36 -- * Construction
37
38 -- ** Initialisation
39 empty, singleton, replicate, generate,
40
41 -- ** Monadic initialisation
42 replicateM, create,
43
44 -- ** Unfolding
45 unfoldr, unfoldrN,
46
47 -- ** Enumeration
48 enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
49
50 -- ** Concatenation
51 cons, snoc, (++), concat,
52
53 -- ** Restricting memory usage
54 force,
55
56 -- * Modifying vectors
57
58 -- ** Bulk updates
59 (//), update_,
60 unsafeUpd, unsafeUpdate_,
61
62 -- ** Accumulations
63 accum, accumulate_,
64 unsafeAccum, unsafeAccumulate_,
65
66 -- ** Permutations
67 reverse, backpermute, unsafeBackpermute,
68
69 -- ** Safe destructive updates
70 modify,
71
72 -- * Elementwise operations
73
74 -- ** Mapping
75 map, imap, concatMap,
76
77 -- ** Monadic mapping
78 mapM, mapM_, forM, forM_,
79
80 -- ** Zipping
81 zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
82 izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
83
84 -- ** Monadic zipping
85 zipWithM, zipWithM_,
86
87 -- * Working with predicates
88
89 -- ** Filtering
90 filter, ifilter, filterM,
91 takeWhile, dropWhile,
92
93 -- ** Partitioning
94 partition, unstablePartition, span, break,
95
96 -- ** Searching
97 elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
98
99 -- * Folding
100 foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
101 ifoldl, ifoldl', ifoldr, ifoldr',
102
103 -- ** Specialised folds
104 all, any, and, or,
105 sum, product,
106 maximum, maximumBy, minimum, minimumBy,
107 minIndex, minIndexBy, maxIndex, maxIndexBy,
108
109 -- ** Monadic folds
110 foldM, foldM', fold1M, fold1M',
111
112 -- * Prefix sums (scans)
113 prescanl, prescanl',
114 postscanl, postscanl',
115 scanl, scanl', scanl1, scanl1',
116 prescanr, prescanr',
117 postscanr, postscanr',
118 scanr, scanr', scanr1, scanr1',
119
120 -- * Conversions
121
122 -- ** Lists
123 toList, fromList, fromListN,
124
125 -- ** Other vector types
126 G.convert,
127
128 -- ** Mutable vectors
129 freeze, thaw, copy, unsafeFreeze, unsafeThaw, unsafeCopy,
130
131 -- * Raw pointers
132 unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith
133 ) where
134
135 import qualified Data.Vector.Generic as G
136 import Data.Vector.Storable.Mutable ( MVector(..) )
137 import Data.Vector.Storable.Internal
138 import qualified Data.Vector.Fusion.Stream as Stream
139
140 import Foreign.Storable
141 import Foreign.ForeignPtr
142 import Foreign.Ptr
143 import Foreign.Marshal.Array ( advancePtr, copyArray )
144
145 import Control.Monad.ST ( ST )
146 import Control.Monad.Primitive
147
148 import Prelude hiding ( length, null,
149 replicate, (++), concat,
150 head, last,
151 init, tail, take, drop, reverse,
152 map, concatMap,
153 zipWith, zipWith3, zip, zip3, unzip, unzip3,
154 filter, takeWhile, dropWhile, span, break,
155 elem, notElem,
156 foldl, foldl1, foldr, foldr1,
157 all, any, and, or, sum, product, minimum, maximum,
158 scanl, scanl1, scanr, scanr1,
159 enumFromTo, enumFromThenTo,
160 mapM, mapM_ )
161
162 import qualified Prelude
163
164 import Data.Typeable ( Typeable )
165 import Data.Data ( Data(..) )
166
167 import Data.Monoid ( Monoid(..) )
168
169 #include "vector.h"
170
171 -- | 'Storable'-based vectors
172 data Vector a = Vector {-# UNPACK #-} !(Ptr a)
173 {-# UNPACK #-} !Int
174 {-# UNPACK #-} !(ForeignPtr a)
175 deriving ( Typeable )
176
177 instance (Show a, Storable a) => Show (Vector a) where
178 show = (Prelude.++ " :: Data.Vector.Storable.Vector")
179 . ("fromList " Prelude.++)
180 . show
181 . toList
182
183 instance (Data a, Storable a) => Data (Vector a) where
184 gfoldl = G.gfoldl
185 toConstr _ = error "toConstr"
186 gunfold _ _ = error "gunfold"
187 dataTypeOf _ = G.mkType "Data.Vector.Storable.Vector"
188 dataCast1 = G.dataCast
189
190 type instance G.Mutable Vector = MVector
191
192 instance Storable a => G.Vector Vector a where
193 {-# INLINE basicUnsafeFreeze #-}
194 basicUnsafeFreeze (MVector p n fp) = return $ Vector p n fp
195
196 {-# INLINE basicUnsafeThaw #-}
197 basicUnsafeThaw (Vector p n fp) = return $ MVector p n fp
198
199 {-# INLINE basicLength #-}
200 basicLength (Vector _ n _) = n
201
202 {-# INLINE basicUnsafeSlice #-}
203 basicUnsafeSlice i n (Vector p _ fp) = Vector (p `advancePtr` i) n fp
204
205 {-# INLINE basicUnsafeIndexM #-}
206 basicUnsafeIndexM (Vector p _ fp) i = return
207 . unsafeInlineIO
208 $ withForeignPtr fp $ \_ ->
209 peekElemOff p i
210
211 {-# INLINE basicUnsafeCopy #-}
212 basicUnsafeCopy (MVector p n fp) (Vector q _ fq)
213 = unsafePrimToPrim
214 $ withForeignPtr fp $ \_ ->
215 withForeignPtr fq $ \_ ->
216 copyArray p q n
217
218 {-# INLINE elemseq #-}
219 elemseq _ = seq
220
221 -- See http://trac.haskell.org/vector/ticket/12
222 instance (Storable a, Eq a) => Eq (Vector a) where
223 {-# INLINE (==) #-}
224 xs == ys = Stream.eq (G.stream xs) (G.stream ys)
225
226 {-# INLINE (/=) #-}
227 xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
228
229 -- See http://trac.haskell.org/vector/ticket/12
230 instance (Storable a, Ord a) => Ord (Vector a) where
231 {-# INLINE compare #-}
232 compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
233
234 {-# INLINE (<) #-}
235 xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
236
237 {-# INLINE (<=) #-}
238 xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
239
240 {-# INLINE (>) #-}
241 xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
242
243 {-# INLINE (>=) #-}
244 xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
245
246 instance Storable a => Monoid (Vector a) where
247 {-# INLINE mempty #-}
248 mempty = empty
249
250 {-# INLINE mappend #-}
251 mappend = (++)
252
253 {-# INLINE mconcat #-}
254 mconcat = concat
255
256 -- Length
257 -- ------
258
259 -- | /O(1)/ Yield the length of the vector.
260 length :: Storable a => Vector a -> Int
261 {-# INLINE length #-}
262 length = G.length
263
264 -- | /O(1)/ Test whether a vector if empty
265 null :: Storable a => Vector a -> Bool
266 {-# INLINE null #-}
267 null = G.null
268
269 -- Indexing
270 -- --------
271
272 -- | O(1) Indexing
273 (!) :: Storable a => Vector a -> Int -> a
274 {-# INLINE (!) #-}
275 (!) = (G.!)
276
277 -- | /O(1)/ First element
278 head :: Storable a => Vector a -> a
279 {-# INLINE head #-}
280 head = G.head
281
282 -- | /O(1)/ Last element
283 last :: Storable a => Vector a -> a
284 {-# INLINE last #-}
285 last = G.last
286
287 -- | /O(1)/ Unsafe indexing without bounds checking
288 unsafeIndex :: Storable a => Vector a -> Int -> a
289 {-# INLINE unsafeIndex #-}
290 unsafeIndex = G.unsafeIndex
291
292 -- | /O(1)/ First element without checking if the vector is empty
293 unsafeHead :: Storable a => Vector a -> a
294 {-# INLINE unsafeHead #-}
295 unsafeHead = G.unsafeHead
296
297 -- | /O(1)/ Last element without checking if the vector is empty
298 unsafeLast :: Storable a => Vector a -> a
299 {-# INLINE unsafeLast #-}
300 unsafeLast = G.unsafeLast
301
302 -- Monadic indexing
303 -- ----------------
304
305 -- | /O(1)/ Indexing in a monad.
306 --
307 -- The monad allows operations to be strict in the vector when necessary.
308 -- Suppose vector copying is implemented like this:
309 --
310 -- > copy mv v = ... write mv i (v ! i) ...
311 --
312 -- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
313 -- would unnecessarily retain a reference to @v@ in each element written.
314 --
315 -- With 'indexM', copying can be implemented like this instead:
316 --
317 -- > copy mv v = ... do
318 -- > x <- indexM v i
319 -- > write mv i x
320 --
321 -- Here, no references to @v@ are retained because indexing (but /not/ the
322 -- elements) is evaluated eagerly.
323 --
324 indexM :: (Storable a, Monad m) => Vector a -> Int -> m a
325 {-# INLINE indexM #-}
326 indexM = G.indexM
327
328 -- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
329 -- explanation of why this is useful.
330 headM :: (Storable a, Monad m) => Vector a -> m a
331 {-# INLINE headM #-}
332 headM = G.headM
333
334 -- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
335 -- explanation of why this is useful.
336 lastM :: (Storable a, Monad m) => Vector a -> m a
337 {-# INLINE lastM #-}
338 lastM = G.lastM
339
340 -- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
341 -- explanation of why this is useful.
342 unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a
343 {-# INLINE unsafeIndexM #-}
344 unsafeIndexM = G.unsafeIndexM
345
346 -- | /O(1)/ First element in a monad without checking for empty vectors.
347 -- See 'indexM' for an explanation of why this is useful.
348 unsafeHeadM :: (Storable a, Monad m) => Vector a -> m a
349 {-# INLINE unsafeHeadM #-}
350 unsafeHeadM = G.unsafeHeadM
351
352 -- | /O(1)/ Last element in a monad without checking for empty vectors.
353 -- See 'indexM' for an explanation of why this is useful.
354 unsafeLastM :: (Storable a, Monad m) => Vector a -> m a
355 {-# INLINE unsafeLastM #-}
356 unsafeLastM = G.unsafeLastM
357
358 -- Extracting subvectors (slicing)
359 -- -------------------------------
360
361 -- | /O(1)/ Yield a slice of the vector without copying it. The vector must
362 -- contain at least @i+n@ elements.
363 slice :: Storable a
364 => Int -- ^ @i@ starting index
365 -> Int -- ^ @n@ length
366 -> Vector a
367 -> Vector a
368 {-# INLINE slice #-}
369 slice = G.slice
370
371 -- | /O(1)/ Yield all but the last element without copying. The vector may not
372 -- be empty.
373 init :: Storable a => Vector a -> Vector a
374 {-# INLINE init #-}
375 init = G.init
376
377 -- | /O(1)/ Yield all but the first element without copying. The vector may not
378 -- be empty.
379 tail :: Storable a => Vector a -> Vector a
380 {-# INLINE tail #-}
381 tail = G.tail
382
383 -- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
384 -- contain less than @n@ elements in which case it is returned unchanged.
385 take :: Storable a => Int -> Vector a -> Vector a
386 {-# INLINE take #-}
387 take = G.take
388
389 -- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
390 -- contain less than @n@ elements in which case an empty vector is returned.
391 drop :: Storable a => Int -> Vector a -> Vector a
392 {-# INLINE drop #-}
393 drop = G.drop
394
395 -- | /O(1)/ Yield a slice of the vector without copying. The vector must
396 -- contain at least @i+n@ elements but this is not checked.
397 unsafeSlice :: Storable a => Int -- ^ @i@ starting index
398 -> Int -- ^ @n@ length
399 -> Vector a
400 -> Vector a
401 {-# INLINE unsafeSlice #-}
402 unsafeSlice = G.unsafeSlice
403
404 -- | /O(1)/ Yield all but the last element without copying. The vector may not
405 -- be empty but this is not checked.
406 unsafeInit :: Storable a => Vector a -> Vector a
407 {-# INLINE unsafeInit #-}
408 unsafeInit = G.unsafeInit
409
410 -- | /O(1)/ Yield all but the first element without copying. The vector may not
411 -- be empty but this is not checked.
412 unsafeTail :: Storable a => Vector a -> Vector a
413 {-# INLINE unsafeTail #-}
414 unsafeTail = G.unsafeTail
415
416 -- | /O(1)/ Yield the first @n@ elements without copying. The vector must
417 -- contain at least @n@ elements but this is not checked.
418 unsafeTake :: Storable a => Int -> Vector a -> Vector a
419 {-# INLINE unsafeTake #-}
420 unsafeTake = G.unsafeTake
421
422 -- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
423 -- must contain at least @n@ elements but this is not checked.
424 unsafeDrop :: Storable a => Int -> Vector a -> Vector a
425 {-# INLINE unsafeDrop #-}
426 unsafeDrop = G.unsafeDrop
427
428 -- Initialisation
429 -- --------------
430
431 -- | /O(1)/ Empty vector
432 empty :: Storable a => Vector a
433 {-# INLINE empty #-}
434 empty = G.empty
435
436 -- | /O(1)/ Vector with exactly one element
437 singleton :: Storable a => a -> Vector a
438 {-# INLINE singleton #-}
439 singleton = G.singleton
440
441 -- | /O(n)/ Vector of the given length with the same value in each position
442 replicate :: Storable a => Int -> a -> Vector a
443 {-# INLINE replicate #-}
444 replicate = G.replicate
445
446 -- | /O(n)/ Construct a vector of the given length by applying the function to
447 -- each index
448 generate :: Storable a => Int -> (Int -> a) -> Vector a
449 {-# INLINE generate #-}
450 generate = G.generate
451
452 -- Unfolding
453 -- ---------
454
455 -- | /O(n)/ Construct a vector by repeatedly applying the generator function
456 -- to a seed. The generator function yields 'Just' the next element and the
457 -- new seed or 'Nothing' if there are no more elements.
458 --
459 -- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
460 -- > = <10,9,8,7,6,5,4,3,2,1>
461 unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
462 {-# INLINE unfoldr #-}
463 unfoldr = G.unfoldr
464
465 -- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
466 -- generator function to the a seed. The generator function yields 'Just' the
467 -- next element and the new seed or 'Nothing' if there are no more elements.
468 --
469 -- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
470 unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
471 {-# INLINE unfoldrN #-}
472 unfoldrN = G.unfoldrN
473
474 -- Enumeration
475 -- -----------
476
477 -- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
478 -- etc. This operation is usually more efficient than 'enumFromTo'.
479 --
480 -- > enumFromN 5 3 = <5,6,7>
481 enumFromN :: (Storable a, Num a) => a -> Int -> Vector a
482 {-# INLINE enumFromN #-}
483 enumFromN = G.enumFromN
484
485 -- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
486 -- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
487 --
488 -- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
489 enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a
490 {-# INLINE enumFromStepN #-}
491 enumFromStepN = G.enumFromStepN
492
493 -- | /O(n)/ Enumerate values from @x@ to @y@.
494 --
495 -- /WARNING:/ This operation can be very inefficient. If at all possible, use
496 -- 'enumFromN' instead.
497 enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
498 {-# INLINE enumFromTo #-}
499 enumFromTo = G.enumFromTo
500
501 -- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
502 --
503 -- /WARNING:/ This operation can be very inefficient. If at all possible, use
504 -- 'enumFromStepN' instead.
505 enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
506 {-# INLINE enumFromThenTo #-}
507 enumFromThenTo = G.enumFromThenTo
508
509 -- Concatenation
510 -- -------------
511
512 -- | /O(n)/ Prepend an element
513 cons :: Storable a => a -> Vector a -> Vector a
514 {-# INLINE cons #-}
515 cons = G.cons
516
517 -- | /O(n)/ Append an element
518 snoc :: Storable a => Vector a -> a -> Vector a
519 {-# INLINE snoc #-}
520 snoc = G.snoc
521
522 infixr 5 ++
523 -- | /O(m+n)/ Concatenate two vectors
524 (++) :: Storable a => Vector a -> Vector a -> Vector a
525 {-# INLINE (++) #-}
526 (++) = (G.++)
527
528 -- | /O(n)/ Concatenate all vectors in the list
529 concat :: Storable a => [Vector a] -> Vector a
530 {-# INLINE concat #-}
531 concat = G.concat
532
533 -- Monadic initialisation
534 -- ----------------------
535
536 -- | /O(n)/ Execute the monadic action the given number of times and store the
537 -- results in a vector.
538 replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a)
539 {-# INLINE replicateM #-}
540 replicateM = G.replicateM
541
542 -- | Execute the monadic action and freeze the resulting vector.
543 --
544 -- @
545 -- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
546 -- @
547 create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
548 {-# INLINE create #-}
549 create = G.create
550
551 -- Restricting memory usage
552 -- ------------------------
553
554 -- | /O(n)/ Yield the argument but force it not to retain any extra memory,
555 -- possibly by copying it.
556 --
557 -- This is especially useful when dealing with slices. For example:
558 --
559 -- > force (slice 0 2 <huge vector>)
560 --
561 -- Here, the slice retains a reference to the huge vector. Forcing it creates
562 -- a copy of just the elements that belong to the slice and allows the huge
563 -- vector to be garbage collected.
564 force :: Storable a => Vector a -> Vector a
565 {-# INLINE force #-}
566 force = G.force
567
568 -- Bulk updates
569 -- ------------
570
571 -- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
572 -- element at position @i@ by @a@.
573 --
574 -- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
575 --
576 (//) :: Storable a => Vector a -- ^ initial vector (of length @m@)
577 -> [(Int, a)] -- ^ list of index/value pairs (of length @n@)
578 -> Vector a
579 {-# INLINE (//) #-}
580 (//) = (G.//)
581
582 -- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
583 -- corresponding value @a@ from the value vector, replace the element of the
584 -- initial vector at position @i@ by @a@.
585 --
586 -- > update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>
587 --
588 update_ :: Storable a
589 => Vector a -- ^ initial vector (of length @m@)
590 -> Vector Int -- ^ index vector (of length @n1@)
591 -> Vector a -- ^ value vector (of length @n2@)
592 -> Vector a
593 {-# INLINE update_ #-}
594 update_ = G.update_
595
596 -- | Same as ('//') but without bounds checking.
597 unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a
598 {-# INLINE unsafeUpd #-}
599 unsafeUpd = G.unsafeUpd
600
601 -- | Same as 'update_' but without bounds checking.
602 unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
603 {-# INLINE unsafeUpdate_ #-}
604 unsafeUpdate_ = G.unsafeUpdate_
605
606 -- Accumulations
607 -- -------------
608
609 -- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
610 -- @a@ at position @i@ by @f a b@.
611 --
612 -- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
613 accum :: Storable a
614 => (a -> b -> a) -- ^ accumulating function @f@
615 -> Vector a -- ^ initial vector (of length @m@)
616 -> [(Int,b)] -- ^ list of index/value pairs (of length @n@)
617 -> Vector a
618 {-# INLINE accum #-}
619 accum = G.accum
620
621 -- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
622 -- corresponding value @b@ from the the value vector,
623 -- replace the element of the initial vector at
624 -- position @i@ by @f a b@.
625 --
626 -- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
627 --
628 accumulate_ :: (Storable a, Storable b)
629 => (a -> b -> a) -- ^ accumulating function @f@
630 -> Vector a -- ^ initial vector (of length @m@)
631 -> Vector Int -- ^ index vector (of length @n1@)
632 -> Vector b -- ^ value vector (of length @n2@)
633 -> Vector a
634 {-# INLINE accumulate_ #-}
635 accumulate_ = G.accumulate_
636
637 -- | Same as 'accum' but without bounds checking.
638 unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
639 {-# INLINE unsafeAccum #-}
640 unsafeAccum = G.unsafeAccum
641
642 -- | Same as 'accumulate_' but without bounds checking.
643 unsafeAccumulate_ :: (Storable a, Storable b) =>
644 (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
645 {-# INLINE unsafeAccumulate_ #-}
646 unsafeAccumulate_ = G.unsafeAccumulate_
647
648 -- Permutations
649 -- ------------
650
651 -- | /O(n)/ Reverse a vector
652 reverse :: Storable a => Vector a -> Vector a
653 {-# INLINE reverse #-}
654 reverse = G.reverse
655
656 -- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
657 -- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
658 -- often much more efficient.
659 --
660 -- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
661 backpermute :: Storable a => Vector a -> Vector Int -> Vector a
662 {-# INLINE backpermute #-}
663 backpermute = G.backpermute
664
665 -- | Same as 'backpermute' but without bounds checking.
666 unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a
667 {-# INLINE unsafeBackpermute #-}
668 unsafeBackpermute = G.unsafeBackpermute
669
670 -- Safe destructive updates
671 -- ------------------------
672
673 -- | Apply a destructive operation to a vector. The operation will be
674 -- performed in place if it is safe to do so and will modify a copy of the
675 -- vector otherwise.
676 --
677 -- @
678 -- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
679 -- @
680 modify :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
681 {-# INLINE modify #-}
682 modify = G.modify
683
684 -- Mapping
685 -- -------
686
687 -- | /O(n)/ Map a function over a vector
688 map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
689 {-# INLINE map #-}
690 map = G.map
691
692 -- | /O(n)/ Apply a function to every element of a vector and its index
693 imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b
694 {-# INLINE imap #-}
695 imap = G.imap
696
697 -- | Map a function over a vector and concatenate the results.
698 concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b
699 {-# INLINE concatMap #-}
700 concatMap = G.concatMap
701
702 -- Monadic mapping
703 -- ---------------
704
705 -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
706 -- vector of results
707 mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b)
708 {-# INLINE mapM #-}
709 mapM = G.mapM
710
711 -- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
712 -- results
713 mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m ()
714 {-# INLINE mapM_ #-}
715 mapM_ = G.mapM_
716
717 -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
718 -- vector of results. Equvalent to @flip 'mapM'@.
719 forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b)
720 {-# INLINE forM #-}
721 forM = G.forM
722
723 -- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
724 -- results. Equivalent to @flip 'mapM_'@.
725 forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m ()
726 {-# INLINE forM_ #-}
727 forM_ = G.forM_
728
729 -- Zipping
730 -- -------
731
732 -- | /O(min(m,n))/ Zip two vectors with the given function.
733 zipWith :: (Storable a, Storable b, Storable c)
734 => (a -> b -> c) -> Vector a -> Vector b -> Vector c
735 {-# INLINE zipWith #-}
736 zipWith = G.zipWith
737
738 -- | Zip three vectors with the given function.
739 zipWith3 :: (Storable a, Storable b, Storable c, Storable d)
740 => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
741 {-# INLINE zipWith3 #-}
742 zipWith3 = G.zipWith3
743
744 zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e)
745 => (a -> b -> c -> d -> e)
746 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
747 {-# INLINE zipWith4 #-}
748 zipWith4 = G.zipWith4
749
750 zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e,
751 Storable f)
752 => (a -> b -> c -> d -> e -> f)
753 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
754 -> Vector f
755 {-# INLINE zipWith5 #-}
756 zipWith5 = G.zipWith5
757
758 zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e,
759 Storable f, Storable g)
760 => (a -> b -> c -> d -> e -> f -> g)
761 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
762 -> Vector f -> Vector g
763 {-# INLINE zipWith6 #-}
764 zipWith6 = G.zipWith6
765
766 -- | /O(min(m,n))/ Zip two vectors with a function that also takes the
767 -- elements' indices.
768 izipWith :: (Storable a, Storable b, Storable c)
769 => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
770 {-# INLINE izipWith #-}
771 izipWith = G.izipWith
772
773 -- | Zip three vectors and their indices with the given function.
774 izipWith3 :: (Storable a, Storable b, Storable c, Storable d)
775 => (Int -> a -> b -> c -> d)
776 -> Vector a -> Vector b -> Vector c -> Vector d
777 {-# INLINE izipWith3 #-}
778 izipWith3 = G.izipWith3
779
780 izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e)
781 => (Int -> a -> b -> c -> d -> e)
782 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
783 {-# INLINE izipWith4 #-}
784 izipWith4 = G.izipWith4
785
786 izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e,
787 Storable f)
788 => (Int -> a -> b -> c -> d -> e -> f)
789 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
790 -> Vector f
791 {-# INLINE izipWith5 #-}
792 izipWith5 = G.izipWith5
793
794 izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e,
795 Storable f, Storable g)
796 => (Int -> a -> b -> c -> d -> e -> f -> g)
797 -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
798 -> Vector f -> Vector g
799 {-# INLINE izipWith6 #-}
800 izipWith6 = G.izipWith6
801
802 -- Monadic zipping
803 -- ---------------
804
805 -- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
806 -- vector of results
807 zipWithM :: (Monad m, Storable a, Storable b, Storable c)
808 => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
809 {-# INLINE zipWithM #-}
810 zipWithM = G.zipWithM
811
812 -- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
813 -- results
814 zipWithM_ :: (Monad m, Storable a, Storable b)
815 => (a -> b -> m c) -> Vector a -> Vector b -> m ()
816 {-# INLINE zipWithM_ #-}
817 zipWithM_ = G.zipWithM_
818
819 -- Filtering
820 -- ---------
821
822 -- | /O(n)/ Drop elements that do not satisfy the predicate
823 filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
824 {-# INLINE filter #-}
825 filter = G.filter
826
827 -- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
828 -- values and their indices
829 ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a
830 {-# INLINE ifilter #-}
831 ifilter = G.ifilter
832
833 -- | /O(n)/ Drop elements that do not satisfy the monadic predicate
834 filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a)
835 {-# INLINE filterM #-}
836 filterM = G.filterM
837
838 -- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
839 -- without copying.
840 takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
841 {-# INLINE takeWhile #-}
842 takeWhile = G.takeWhile
843
844 -- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
845 -- without copying.
846 dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
847 {-# INLINE dropWhile #-}
848 dropWhile = G.dropWhile
849
850 -- Parititioning
851 -- -------------
852
853 -- | /O(n)/ Split the vector in two parts, the first one containing those
854 -- elements that satisfy the predicate and the second one those that don't. The
855 -- relative order of the elements is preserved at the cost of a sometimes
856 -- reduced performance compared to 'unstablePartition'.
857 partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
858 {-# INLINE partition #-}
859 partition = G.partition
860
861 -- | /O(n)/ Split the vector in two parts, the first one containing those
862 -- elements that satisfy the predicate and the second one those that don't.
863 -- The order of the elements is not preserved but the operation is often
864 -- faster than 'partition'.
865 unstablePartition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
866 {-# INLINE unstablePartition #-}
867 unstablePartition = G.unstablePartition
868
869 -- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
870 -- the predicate and the rest without copying.
871 span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
872 {-# INLINE span #-}
873 span = G.span
874
875 -- | /O(n)/ Split the vector into the longest prefix of elements that do not
876 -- satisfy the predicate and the rest without copying.
877 break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
878 {-# INLINE break #-}
879 break = G.break
880
881 -- Searching
882 -- ---------
883
884 infix 4 `elem`
885 -- | /O(n)/ Check if the vector contains an element
886 elem :: (Storable a, Eq a) => a -> Vector a -> Bool
887 {-# INLINE elem #-}
888 elem = G.elem
889
890 infix 4 `notElem`
891 -- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
892 notElem :: (Storable a, Eq a) => a -> Vector a -> Bool
893 {-# INLINE notElem #-}
894 notElem = G.notElem
895
896 -- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing'
897 -- if no such element exists.
898 find :: Storable a => (a -> Bool) -> Vector a -> Maybe a
899 {-# INLINE find #-}
900 find = G.find
901
902 -- | /O(n)/ Yield 'Just' the index of the first element matching the predicate
903 -- or 'Nothing' if no such element exists.
904 findIndex :: Storable a => (a -> Bool) -> Vector a -> Maybe Int
905 {-# INLINE findIndex #-}
906 findIndex = G.findIndex
907
908 -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
909 -- order.
910 findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int
911 {-# INLINE findIndices #-}
912 findIndices = G.findIndices
913
914 -- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
915 -- 'Nothing' if the vector does not contain the element. This is a specialised
916 -- version of 'findIndex'.
917 elemIndex :: (Storable a, Eq a) => a -> Vector a -> Maybe Int
918 {-# INLINE elemIndex #-}
919 elemIndex = G.elemIndex
920
921 -- | /O(n)/ Yield the indices of all occurences of the given element in
922 -- ascending order. This is a specialised version of 'findIndices'.
923 elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int
924 {-# INLINE elemIndices #-}
925 elemIndices = G.elemIndices
926
927 -- Folding
928 -- -------
929
930 -- | /O(n)/ Left fold
931 foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a
932 {-# INLINE foldl #-}
933 foldl = G.foldl
934
935 -- | /O(n)/ Left fold on non-empty vectors
936 foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a
937 {-# INLINE foldl1 #-}
938 foldl1 = G.foldl1
939
940 -- | /O(n)/ Left fold with strict accumulator
941 foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a
942 {-# INLINE foldl' #-}
943 foldl' = G.foldl'
944
945 -- | /O(n)/ Left fold on non-empty vectors with strict accumulator
946 foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a
947 {-# INLINE foldl1' #-}
948 foldl1' = G.foldl1'
949
950 -- | /O(n)/ Right fold
951 foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b
952 {-# INLINE foldr #-}
953 foldr = G.foldr
954
955 -- | /O(n)/ Right fold on non-empty vectors
956 foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a
957 {-# INLINE foldr1 #-}
958 foldr1 = G.foldr1
959
960 -- | /O(n)/ Right fold with a strict accumulator
961 foldr' :: Storable a => (a -> b -> b) -> b -> Vector a -> b
962 {-# INLINE foldr' #-}
963 foldr' = G.foldr'
964
965 -- | /O(n)/ Right fold on non-empty vectors with strict accumulator
966 foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a
967 {-# INLINE foldr1' #-}
968 foldr1' = G.foldr1'
969
970 -- | /O(n)/ Left fold (function applied to each element and its index)
971 ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
972 {-# INLINE ifoldl #-}
973 ifoldl = G.ifoldl
974
975 -- | /O(n)/ Left fold with strict accumulator (function applied to each element
976 -- and its index)
977 ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
978 {-# INLINE ifoldl' #-}
979 ifoldl' = G.ifoldl'
980
981 -- | /O(n)/ Right fold (function applied to each element and its index)
982 ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
983 {-# INLINE ifoldr #-}
984 ifoldr = G.ifoldr
985
986 -- | /O(n)/ Right fold with strict accumulator (function applied to each
987 -- element and its index)
988 ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
989 {-# INLINE ifoldr' #-}
990 ifoldr' = G.ifoldr'
991
992 -- Specialised folds
993 -- -----------------
994
995 -- | /O(n)/ Check if all elements satisfy the predicate.
996 all :: Storable a => (a -> Bool) -> Vector a -> Bool
997 {-# INLINE all #-}
998 all = G.all
999
1000 -- | /O(n)/ Check if any element satisfies the predicate.
1001 any :: Storable a => (a -> Bool) -> Vector a -> Bool
1002 {-# INLINE any #-}
1003 any = G.any
1004
1005 -- | /O(n)/ Check if all elements are 'True'
1006 and :: Vector Bool -> Bool
1007 {-# INLINE and #-}
1008 and = G.and
1009
1010 -- | /O(n)/ Check if any element is 'True'
1011 or :: Vector Bool -> Bool
1012 {-# INLINE or #-}
1013 or = G.or
1014
1015 -- | /O(n)/ Compute the sum of the elements
1016 sum :: (Storable a, Num a) => Vector a -> a
1017 {-# INLINE sum #-}
1018 sum = G.sum
1019
1020 -- | /O(n)/ Compute the produce of the elements
1021 product :: (Storable a, Num a) => Vector a -> a
1022 {-# INLINE product #-}
1023 product = G.product
1024
1025 -- | /O(n)/ Yield the maximum element of the vector. The vector may not be
1026 -- empty.
1027 maximum :: (Storable a, Ord a) => Vector a -> a
1028 {-# INLINE maximum #-}
1029 maximum = G.maximum
1030
1031 -- | /O(n)/ Yield the maximum element of the vector according to the given
1032 -- comparison function. The vector may not be empty.
1033 maximumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
1034 {-# INLINE maximumBy #-}
1035 maximumBy = G.maximumBy
1036
1037 -- | /O(n)/ Yield the minimum element of the vector. The vector may not be
1038 -- empty.
1039 minimum :: (Storable a, Ord a) => Vector a -> a
1040 {-# INLINE minimum #-}
1041 minimum = G.minimum
1042
1043 -- | /O(n)/ Yield the minimum element of the vector according to the given
1044 -- comparison function. The vector may not be empty.
1045 minimumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
1046 {-# INLINE minimumBy #-}
1047 minimumBy = G.minimumBy
1048
1049 -- | /O(n)/ Yield the index of the maximum element of the vector. The vector
1050 -- may not be empty.
1051 maxIndex :: (Storable a, Ord a) => Vector a -> Int
1052 {-# INLINE maxIndex #-}
1053 maxIndex = G.maxIndex
1054
1055 -- | /O(n)/ Yield the index of the maximum element of the vector according to
1056 -- the given comparison function. The vector may not be empty.
1057 maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
1058 {-# INLINE maxIndexBy #-}
1059 maxIndexBy = G.maxIndexBy
1060
1061 -- | /O(n)/ Yield the index of the minimum element of the vector. The vector
1062 -- may not be empty.
1063 minIndex :: (Storable a, Ord a) => Vector a -> Int
1064 {-# INLINE minIndex #-}
1065 minIndex = G.minIndex
1066
1067 -- | /O(n)/ Yield the index of the minimum element of the vector according to
1068 -- the given comparison function. The vector may not be empty.
1069 minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
1070 {-# INLINE minIndexBy #-}
1071 minIndexBy = G.minIndexBy
1072
1073 -- Monadic folds
1074 -- -------------
1075
1076 -- | /O(n)/ Monadic fold
1077 foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
1078 {-# INLINE foldM #-}
1079 foldM = G.foldM
1080
1081 -- | /O(n)/ Monadic fold over non-empty vectors
1082 fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
1083 {-# INLINE fold1M #-}
1084 fold1M = G.fold1M
1085
1086 -- | /O(n)/ Monadic fold with strict accumulator
1087 foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
1088 {-# INLINE foldM' #-}
1089 foldM' = G.foldM'
1090
1091 -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
1092 fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
1093 {-# INLINE fold1M' #-}
1094 fold1M' = G.fold1M'
1095
1096 -- Prefix sums (scans)
1097 -- -------------------
1098
1099 -- | /O(n)/ Prescan
1100 --
1101 -- @
1102 -- prescanl f z = 'init' . 'scanl' f z
1103 -- @
1104 --
1105 -- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
1106 --
1107 prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1108 {-# INLINE prescanl #-}
1109 prescanl = G.prescanl
1110
1111 -- | /O(n)/ Prescan with strict accumulator
1112 prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1113 {-# INLINE prescanl' #-}
1114 prescanl' = G.prescanl'
1115
1116 -- | /O(n)/ Scan
1117 --
1118 -- @
1119 -- postscanl f z = 'tail' . 'scanl' f z
1120 -- @
1121 --
1122 -- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
1123 --
1124 postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1125 {-# INLINE postscanl #-}
1126 postscanl = G.postscanl
1127
1128 -- | /O(n)/ Scan with strict accumulator
1129 postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1130 {-# INLINE postscanl' #-}
1131 postscanl' = G.postscanl'
1132
1133 -- | /O(n)/ Haskell-style scan
1134 --
1135 -- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
1136 -- > where y1 = z
1137 -- > yi = f y(i-1) x(i-1)
1138 --
1139 -- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
1140 --
1141 scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1142 {-# INLINE scanl #-}
1143 scanl = G.scanl
1144
1145 -- | /O(n)/ Haskell-style scan with strict accumulator
1146 scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
1147 {-# INLINE scanl' #-}
1148 scanl' = G.scanl'
1149
1150 -- | /O(n)/ Scan over a non-empty vector
1151 --
1152 -- > scanl f <x1,...,xn> = <y1,...,yn>
1153 -- > where y1 = x1
1154 -- > yi = f y(i-1) xi
1155 --
1156 scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
1157 {-# INLINE scanl1 #-}
1158 scanl1 = G.scanl1
1159
1160 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator
1161 scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
1162 {-# INLINE scanl1' #-}
1163 scanl1' = G.scanl1'
1164
1165 -- | /O(n)/ Right-to-left prescan
1166 --
1167 -- @
1168 -- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
1169 -- @
1170 --
1171 prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1172 {-# INLINE prescanr #-}
1173 prescanr = G.prescanr
1174
1175 -- | /O(n)/ Right-to-left prescan with strict accumulator
1176 prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1177 {-# INLINE prescanr' #-}
1178 prescanr' = G.prescanr'
1179
1180 -- | /O(n)/ Right-to-left scan
1181 postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1182 {-# INLINE postscanr #-}
1183 postscanr = G.postscanr
1184
1185 -- | /O(n)/ Right-to-left scan with strict accumulator
1186 postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1187 {-# INLINE postscanr' #-}
1188 postscanr' = G.postscanr'
1189
1190 -- | /O(n)/ Right-to-left Haskell-style scan
1191 scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1192 {-# INLINE scanr #-}
1193 scanr = G.scanr
1194
1195 -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
1196 scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
1197 {-# INLINE scanr' #-}
1198 scanr' = G.scanr'
1199
1200 -- | /O(n)/ Right-to-left scan over a non-empty vector
1201 scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
1202 {-# INLINE scanr1 #-}
1203 scanr1 = G.scanr1
1204
1205 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
1206 -- accumulator
1207 scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
1208 {-# INLINE scanr1' #-}
1209 scanr1' = G.scanr1'
1210
1211 -- Conversions - Lists
1212 -- ------------------------
1213
1214 -- | /O(n)/ Convert a vector to a list
1215 toList :: Storable a => Vector a -> [a]
1216 {-# INLINE toList #-}
1217 toList = G.toList
1218
1219 -- | /O(n)/ Convert a list to a vector
1220 fromList :: Storable a => [a] -> Vector a
1221 {-# INLINE fromList #-}
1222 fromList = G.fromList
1223
1224 -- | /O(n)/ Convert the first @n@ elements of a list to a vector
1225 --
1226 -- @
1227 -- fromListN n xs = 'fromList' ('take' n xs)
1228 -- @
1229 fromListN :: Storable a => Int -> [a] -> Vector a
1230 {-# INLINE fromListN #-}
1231 fromListN = G.fromListN
1232
1233 -- Conversions - Mutable vectors
1234 -- -----------------------------
1235
1236 -- | /O(1)/ Unsafe convert a mutable vector to an immutable one without
1237 -- copying. The mutable vector may not be used after this operation.
1238 unsafeFreeze
1239 :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
1240 {-# INLINE unsafeFreeze #-}
1241 unsafeFreeze = G.unsafeFreeze
1242
1243 -- | /O(1)/ Unsafely convert an immutable vector to a mutable one without
1244 -- copying. The immutable vector may not be used after this operation.
1245 unsafeThaw
1246 :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
1247 {-# INLINE unsafeThaw #-}
1248 unsafeThaw = G.unsafeThaw
1249
1250 -- | /O(n)/ Yield a mutable copy of the immutable vector.
1251 thaw :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
1252 {-# INLINE thaw #-}
1253 thaw = G.thaw
1254
1255 -- | /O(n)/ Yield an immutable copy of the mutable vector.
1256 freeze :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
1257 {-# INLINE freeze #-}
1258 freeze = G.freeze
1259
1260 -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
1261 -- have the same length. This is not checked.
1262 unsafeCopy
1263 :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
1264 {-# INLINE unsafeCopy #-}
1265 unsafeCopy = G.unsafeCopy
1266
1267 -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
1268 -- have the same length.
1269 copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
1270 {-# INLINE copy #-}
1271 copy = G.copy
1272
1273 -- Conversions - Raw pointers
1274 -- --------------------------
1275
1276 -- | /O(1)/ Create a vector from a 'ForeignPtr' with an offset and a length.
1277 -- The data may not be modified through the 'ForeignPtr' afterwards.
1278 unsafeFromForeignPtr :: Storable a
1279 => ForeignPtr a -- ^ pointer
1280 -> Int -- ^ offset
1281 -> Int -- ^ length
1282 -> Vector a
1283 {-# INLINE unsafeFromForeignPtr #-}
1284 unsafeFromForeignPtr fp i n = Vector (offsetToPtr fp i) n fp
1285
1286 -- | /O(1)/ Yield the underlying 'ForeignPtr' together with the offset to the
1287 -- data and its length. The data may not be modified through the 'ForeignPtr'.
1288 unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)
1289 {-# INLINE unsafeToForeignPtr #-}
1290 unsafeToForeignPtr (Vector p n fp) = (fp, ptrToOffset fp p, n)
1291
1292 -- | Pass a pointer to the vector's data to the IO action. The data may not be
1293 -- modified through the 'Ptr.
1294 unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b
1295 {-# INLINE unsafeWith #-}
1296 unsafeWith (Vector p n fp) m = withForeignPtr fp $ \_ -> m p
1297
1298