module Data.Vector.Generic (
Vector(..), Mutable,
length, null,
empty, singleton, cons, snoc, replicate, generate, (++), copy,
(!), head, last, indexM, headM, lastM,
unsafeIndex, unsafeHead, unsafeLast,
unsafeIndexM, unsafeHeadM, unsafeLastM,
slice, init, tail, take, drop,
unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
accum, accumulate, accumulate_,
(//), update, update_,
backpermute, reverse,
unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
unsafeUpd, unsafeUpdate, unsafeUpdate_,
unsafeBackpermute,
map, imap, concatMap,
zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
zip, zip3, zip4, zip5, zip6,
unzip, unzip3, unzip4, unzip5, unzip6,
eq, cmp,
filter, ifilter, takeWhile, dropWhile,
partition, unstablePartition, span, break,
elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
ifoldl, ifoldl', ifoldr, ifoldr',
all, any, and, or,
sum, product,
maximum, maximumBy, minimum, minimumBy,
minIndex, minIndexBy, maxIndex, maxIndexBy,
unfoldr,
prescanl, prescanl',
postscanl, postscanl',
scanl, scanl', scanl1, scanl1',
prescanr, prescanr',
postscanr, postscanr',
scanr, scanr', scanr1, scanr1',
enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
toList, fromList,
stream, unstream, streamR, unstreamR,
new
) where
import Data.Vector.Generic.Mutable ( MVector )
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Generic.New as New
import Data.Vector.Generic.New ( New )
import qualified Data.Vector.Fusion.Stream as Stream
import Data.Vector.Fusion.Stream ( Stream, MStream, inplace )
import qualified Data.Vector.Fusion.Stream.Monadic as MStream
import Data.Vector.Fusion.Stream.Size
import Data.Vector.Fusion.Util
import Control.Monad.ST ( runST )
import Control.Monad.Primitive
import Prelude hiding ( length, null,
replicate, (++),
head, last,
init, tail, take, drop, reverse,
map, concatMap,
zipWith, zipWith3, zip, zip3, unzip, unzip3,
filter, takeWhile, dropWhile, span, break,
elem, notElem,
foldl, foldl1, foldr, foldr1,
all, any, and, or, sum, product, maximum, minimum,
scanl, scanl1, scanr, scanr1,
enumFromTo, enumFromThenTo )
#include "vector.h"
type family Mutable (v :: * -> *) :: * -> * -> *
class MVector (Mutable v) a => Vector v a where
unsafeFreeze :: PrimMonad m => Mutable v (PrimState m) a -> m (v a)
basicLength :: v a -> Int
basicUnsafeSlice :: Int -> Int -> v a -> v a
basicUnsafeIndexM :: Monad m => v a -> Int -> m a
elemseq :: v a -> a -> b -> b
elemseq _ = \_ x -> x
new :: Vector v a => New a -> v a
new m = new' undefined m
new' :: Vector v a => v a -> New a -> v a
new' _ m = m `seq` runST (do
mv <- New.run m
unsafeFreeze mv)
stream :: Vector v a => v a -> Stream a
stream v = v `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n)
where
n = length v
get i | i >= n = Nothing
| otherwise = case basicUnsafeIndexM v i of Box x -> Just (x, i+1)
unstream :: Vector v a => Stream a -> v a
unstream s = new (New.unstream s)
streamR :: Vector v a => v a -> Stream a
streamR v = v `seq` (Stream.unfoldr get n `Stream.sized` Exact n)
where
n = length v
get 0 = Nothing
get i = let i' = i1
in
case basicUnsafeIndexM v i' of Box x -> Just (x, i')
unstreamR :: Vector v a => Stream a -> v a
unstreamR s = new (New.unstreamR s)
length :: Vector v a => v a -> Int
length v = basicLength v
null :: Vector v a => v a -> Bool
null v = length v == 0
empty :: Vector v a => v a
empty = unstream Stream.empty
singleton :: forall v a. Vector v a => a -> v a
singleton x = elemseq (undefined :: v a) x
$ unstream (Stream.singleton x)
replicate :: forall v a. Vector v a => Int -> a -> v a
replicate n x = elemseq (undefined :: v a) x
$ unstream
$ Stream.replicate n x
generate :: Vector v a => Int -> (Int -> a) -> v a
generate n f = unstream (Stream.generate n f)
cons :: forall v a. Vector v a => a -> v a -> v a
cons x v = elemseq (undefined :: v a) x
$ unstream
$ Stream.cons x
$ stream v
snoc :: forall v a. Vector v a => v a -> a -> v a
snoc v x = elemseq (undefined :: v a) x
$ unstream
$ Stream.snoc (stream v) x
infixr 5 ++
(++) :: Vector v a => v a -> v a -> v a
v ++ w = unstream (stream v Stream.++ stream w)
copy :: Vector v a => v a -> v a
copy = unstream . stream
(!) :: Vector v a => v a -> Int -> a
v ! i = BOUNDS_CHECK(checkIndex) "(!)" i (length v)
$ unId (basicUnsafeIndexM v i)
head :: Vector v a => v a -> a
head v = v ! 0
last :: Vector v a => v a -> a
last v = v ! (length v 1)
unsafeIndex :: Vector v a => v a -> Int -> a
unsafeIndex v i = UNSAFE_CHECK(checkIndex) "unsafeIndex" i (length v)
$ unId (basicUnsafeIndexM v i)
unsafeHead :: Vector v a => v a -> a
unsafeHead v = unsafeIndex v 0
unsafeLast :: Vector v a => v a -> a
unsafeLast v = unsafeIndex v (length v 1)
indexM :: (Vector v a, Monad m) => v a -> Int -> m a
indexM v i = BOUNDS_CHECK(checkIndex) "indexM" i (length v)
$ basicUnsafeIndexM v i
headM :: (Vector v a, Monad m) => v a -> m a
headM v = indexM v 0
lastM :: (Vector v a, Monad m) => v a -> m a
lastM v = indexM v (length v 1)
unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
unsafeIndexM v i = UNSAFE_CHECK(checkIndex) "unsafeIndexM" i (length v)
$ basicUnsafeIndexM v i
unsafeHeadM :: (Vector v a, Monad m) => v a -> m a
unsafeHeadM v = unsafeIndexM v 0
unsafeLastM :: (Vector v a, Monad m) => v a -> m a
unsafeLastM v = unsafeIndexM v (length v 1)
slice :: Vector v a => Int
-> Int
-> v a
-> v a
slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
$ basicUnsafeSlice i n v
init :: Vector v a => v a -> v a
init v = slice 0 (length v 1) v
tail :: Vector v a => v a -> v a
tail v = slice 1 (length v 1) v
take :: Vector v a => Int -> v a -> v a
take n v = unsafeSlice 0 (delay_inline min n' (length v)) v
where n' = max n 0
drop :: Vector v a => Int -> v a -> v a
drop n v = unsafeSlice (delay_inline min n' len)
(delay_inline max 0 (len n')) v
where n' = max n 0
len = length v
unsafeSlice :: Vector v a => Int
-> Int
-> v a
-> v a
unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
$ basicUnsafeSlice i n v
unsafeInit :: Vector v a => v a -> v a
unsafeInit v = unsafeSlice 0 (length v 1) v
unsafeTail :: Vector v a => v a -> v a
unsafeTail v = unsafeSlice 1 (length v 1) v
unsafeTake :: Vector v a => Int -> v a -> v a
unsafeTake n v = unsafeSlice 0 n v
unsafeDrop :: Vector v a => Int -> v a -> v a
unsafeDrop n v = unsafeSlice n (length v n) v
unsafeAccum_stream
:: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
unsafeAccum_stream f v s = new (New.accum f (New.unstream (stream v)) s)
unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
unsafeAccum f v us = unsafeAccum_stream f v (Stream.fromList us)
unsafeAccumulate :: (Vector v a, Vector v (Int, b))
=> (a -> b -> a) -> v a -> v (Int,b) -> v a
unsafeAccumulate f v us = unsafeAccum_stream f v (stream us)
unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b)
=> (a -> b -> a) -> v a -> v Int -> v b -> v a
unsafeAccumulate_ f v is xs
= unsafeAccum_stream f v (Stream.zipWith (,) (stream is) (stream xs))
accum_stream :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
accum_stream f v s = new (New.accum f (New.unstream (stream v)) s)
accum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
accum f v us = accum_stream f v (Stream.fromList us)
accumulate :: (Vector v a, Vector v (Int, b))
=> (a -> b -> a) -> v a -> v (Int,b) -> v a
accumulate f v us = accum_stream f v (stream us)
accumulate_ :: (Vector v a, Vector v Int, Vector v b)
=> (a -> b -> a) -> v a -> v Int -> v b -> v a
accumulate_ f v is xs = accum_stream f v (Stream.zipWith (,) (stream is)
(stream xs))
unsafeUpdate_stream :: Vector v a => v a -> Stream (Int,a) -> v a
unsafeUpdate_stream v s = new (New.unsafeUpdate (New.unstream (stream v)) s)
unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a
unsafeUpd v us = unsafeUpdate_stream v (Stream.fromList us)
unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
unsafeUpdate v w = unsafeUpdate_stream v (stream w)
unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
unsafeUpdate_ v is w
= unsafeUpdate_stream v (Stream.zipWith (,) (stream is) (stream w))
update_stream :: Vector v a => v a -> Stream (Int,a) -> v a
update_stream v s = new (New.update (New.unstream (stream v)) s)
(//) :: Vector v a => v a -> [(Int, a)] -> v a
v // us = update_stream v (Stream.fromList us)
update :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
update v w = update_stream v (stream w)
update_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
update_ v is w = update_stream v (Stream.zipWith (,) (stream is) (stream w))
backpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
backpermute v is = seq v
$ unstream
$ Stream.unbox
$ Stream.map (indexM v)
$ stream is
unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
unsafeBackpermute v is = seq v
$ unstream
$ Stream.unbox
$ Stream.map (unsafeIndexM v)
$ stream is
reverse :: (Vector v a) => v a -> v a
reverse = new . New.reverse . New.unstream . stream
map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b
map f = unstream . inplace (MStream.map f) . stream
imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b
imap f = unstream . inplace (MStream.map (uncurry f) . MStream.indexed)
. stream
concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b
concatMap f = unstream . Stream.concatMap (stream . f) . stream
zipWith :: (Vector v a, Vector v b, Vector v c)
=> (a -> b -> c) -> v a -> v b -> v c
zipWith f xs ys = unstream (Stream.zipWith f (stream xs) (stream ys))
zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d)
=> (a -> b -> c -> d) -> v a -> v b -> v c -> v d
zipWith3 f as bs cs = unstream (Stream.zipWith3 f (stream as)
(stream bs)
(stream cs))
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
=> (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
zipWith4 f as bs cs ds
= unstream (Stream.zipWith4 f (stream as)
(stream bs)
(stream cs)
(stream ds))
zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f)
=> (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e
-> v f
zipWith5 f as bs cs ds es
= unstream (Stream.zipWith5 f (stream as)
(stream bs)
(stream cs)
(stream ds)
(stream es))
zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v g)
=> (a -> b -> c -> d -> e -> f -> g)
-> v a -> v b -> v c -> v d -> v e -> v f -> v g
zipWith6 f as bs cs ds es fs
= unstream (Stream.zipWith6 f (stream as)
(stream bs)
(stream cs)
(stream ds)
(stream es)
(stream fs))
izipWith :: (Vector v a, Vector v b, Vector v c)
=> (Int -> a -> b -> c) -> v a -> v b -> v c
izipWith f xs ys = unstream
(Stream.zipWith (uncurry f) (Stream.indexed (stream xs))
(stream ys))
izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d)
=> (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
izipWith3 f as bs cs
= unstream (Stream.zipWith3 (uncurry f) (Stream.indexed (stream as))
(stream bs)
(stream cs))
izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
=> (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
izipWith4 f as bs cs ds
= unstream (Stream.zipWith4 (uncurry f) (Stream.indexed (stream as))
(stream bs)
(stream cs)
(stream ds))
izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f)
=> (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d
-> v e -> v f
izipWith5 f as bs cs ds es
= unstream (Stream.zipWith5 (uncurry f) (Stream.indexed (stream as))
(stream bs)
(stream cs)
(stream ds)
(stream es))
izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v g)
=> (Int -> a -> b -> c -> d -> e -> f -> g)
-> v a -> v b -> v c -> v d -> v e -> v f -> v g
izipWith6 f as bs cs ds es fs
= unstream (Stream.zipWith6 (uncurry f) (Stream.indexed (stream as))
(stream bs)
(stream cs)
(stream ds)
(stream es)
(stream fs))
zip :: (Vector v a, Vector v b, Vector v (a,b)) => v a -> v b -> v (a, b)
zip = zipWith (,)
zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
=> v a -> v b -> v c -> v (a, b, c)
zip3 = zipWith3 (,,)
zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d))
=> v a -> v b -> v c -> v d -> v (a, b, c, d)
zip4 = zipWith4 (,,,)
zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v (a, b, c, d, e))
=> v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
zip5 = zipWith5 (,,,,)
zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v (a, b, c, d, e, f))
=> v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
zip6 = zipWith6 (,,,,,)
unzip :: (Vector v a, Vector v b, Vector v (a,b)) => v (a, b) -> (v a, v b)
unzip xs = (map fst xs, map snd xs)
unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
=> v (a, b, c) -> (v a, v b, v c)
unzip3 xs = (map (\(a, b, c) -> a) xs,
map (\(a, b, c) -> b) xs,
map (\(a, b, c) -> c) xs)
unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d,
Vector v (a, b, c, d))
=> v (a, b, c, d) -> (v a, v b, v c, v d)
unzip4 xs = (map (\(a, b, c, d) -> a) xs,
map (\(a, b, c, d) -> b) xs,
map (\(a, b, c, d) -> c) xs,
map (\(a, b, c, d) -> d) xs)
unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v (a, b, c, d, e))
=> v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
unzip5 xs = (map (\(a, b, c, d, e) -> a) xs,
map (\(a, b, c, d, e) -> b) xs,
map (\(a, b, c, d, e) -> c) xs,
map (\(a, b, c, d, e) -> d) xs,
map (\(a, b, c, d, e) -> e) xs)
unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v (a, b, c, d, e, f))
=> v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
unzip6 xs = (map (\(a, b, c, d, e, f) -> a) xs,
map (\(a, b, c, d, e, f) -> b) xs,
map (\(a, b, c, d, e, f) -> c) xs,
map (\(a, b, c, d, e, f) -> d) xs,
map (\(a, b, c, d, e, f) -> e) xs,
map (\(a, b, c, d, e, f) -> f) xs)
eq :: (Vector v a, Eq a) => v a -> v a -> Bool
xs `eq` ys = stream xs == stream ys
cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering
cmp xs ys = compare (stream xs) (stream ys)
filter :: Vector v a => (a -> Bool) -> v a -> v a
filter f = unstream . inplace (MStream.filter f) . stream
ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
ifilter f = unstream
. inplace (MStream.map snd . MStream.filter (uncurry f)
. MStream.indexed)
. stream
takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
takeWhile f = unstream . Stream.takeWhile f . stream
dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
dropWhile f = unstream . Stream.dropWhile f . stream
partition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
partition f = partition_stream f . stream
partition_stream :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
partition_stream f s = s `seq` runST (
do
(mv1,mv2) <- M.partitionStream f s
v1 <- unsafeFreeze mv1
v2 <- unsafeFreeze mv2
return (v1,v2))
unstablePartition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
unstablePartition f = unstablePartition_stream f . stream
unstablePartition_stream
:: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
unstablePartition_stream f s = s `seq` runST (
do
(mv1,mv2) <- M.unstablePartitionStream f s
v1 <- unsafeFreeze mv1
v2 <- unsafeFreeze mv2
return (v1,v2))
unstablePartition_new :: Vector v a => (a -> Bool) -> New a -> (v a, v a)
unstablePartition_new f (New.New p) = runST (
do
mv <- p
i <- M.unstablePartition f mv
v <- unsafeFreeze mv
return (unsafeTake i v, unsafeDrop i v))
span :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
span f = break (not . f)
break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
break f xs = case findIndex f xs of
Just i -> (unsafeSlice 0 i xs, unsafeSlice i (length xs i) xs)
Nothing -> (xs, empty)
infix 4 `elem`
elem :: (Vector v a, Eq a) => a -> v a -> Bool
elem x = Stream.elem x . stream
infix 4 `notElem`
notElem :: (Vector v a, Eq a) => a -> v a -> Bool
notElem x = Stream.notElem x . stream
find :: Vector v a => (a -> Bool) -> v a -> Maybe a
find f = Stream.find f . stream
findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int
findIndex f = Stream.findIndex f . stream
findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
findIndices f = unstream
. inplace (MStream.map fst . MStream.filter (f . snd)
. MStream.indexed)
. stream
elemIndex :: (Vector v a, Eq a) => a -> v a -> Maybe Int
elemIndex x = findIndex (x==)
elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int
elemIndices x = findIndices (x==)
foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a
foldl f z = Stream.foldl f z . stream
foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
foldl1 f = Stream.foldl1 f . stream
foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a
foldl' f z = Stream.foldl' f z . stream
foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
foldl1' f = Stream.foldl1' f . stream
foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
foldr f z = Stream.foldr f z . stream
foldr1 :: Vector v a => (a -> a -> a) -> v a -> a
foldr1 f = Stream.foldr1 f . stream
foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b
foldr' f z = Stream.foldl' (flip f) z . streamR
foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
foldr1' f = Stream.foldl1' (flip f) . streamR
ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
ifoldl f z = Stream.foldl (uncurry . f) z . Stream.indexed . stream
ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
ifoldl' f z = Stream.foldl' (uncurry . f) z . Stream.indexed . stream
ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
ifoldr f z = Stream.foldr (uncurry f) z . Stream.indexed . stream
ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
ifoldr' f z xs = Stream.foldl' (flip (uncurry f)) z
$ Stream.indexedR (length xs) $ streamR xs
all :: Vector v a => (a -> Bool) -> v a -> Bool
all f = Stream.and . Stream.map f . stream
any :: Vector v a => (a -> Bool) -> v a -> Bool
any f = Stream.or . Stream.map f . stream
and :: Vector v Bool => v Bool -> Bool
and = Stream.and . stream
or :: Vector v Bool => v Bool -> Bool
or = Stream.or . stream
sum :: (Vector v a, Num a) => v a -> a
sum = Stream.foldl' (+) 0 . stream
product :: (Vector v a, Num a) => v a -> a
product = Stream.foldl' (*) 1 . stream
maximum :: (Vector v a, Ord a) => v a -> a
maximum = Stream.foldl1' max . stream
maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
maximumBy cmp = Stream.foldl1' maxBy . stream
where
maxBy x y = case cmp x y of
LT -> y
_ -> x
minimum :: (Vector v a, Ord a) => v a -> a
minimum = Stream.foldl1' min . stream
minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
minimumBy cmp = Stream.foldl1' minBy . stream
where
minBy x y = case cmp x y of
GT -> y
_ -> x
maxIndex :: (Vector v a, Ord a) => v a -> Int
maxIndex = maxIndexBy compare
maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
maxIndexBy cmp = fst . Stream.foldl1' imax . Stream.indexed . stream
where
imax (i,x) (j,y) = case cmp x y of
LT -> (j,y)
_ -> (i,x)
minIndex :: (Vector v a, Ord a) => v a -> Int
minIndex = minIndexBy compare
minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
minIndexBy cmp = fst . Stream.foldl1' imin . Stream.indexed . stream
where
imin (i,x) (j,y) = case cmp x y of
GT -> (j,y)
_ -> (i,x)
unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
unfoldr f = unstream . Stream.unfoldr f
prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
prescanl f z = unstream . inplace (MStream.prescanl f z) . stream
prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
prescanl' f z = unstream . inplace (MStream.prescanl' f z) . stream
postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
postscanl f z = unstream . inplace (MStream.postscanl f z) . stream
postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
postscanl' f z = unstream . inplace (MStream.postscanl' f z) . stream
scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
scanl f z = unstream . Stream.scanl f z . stream
scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
scanl' f z = unstream . Stream.scanl' f z . stream
scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
scanl1 f = unstream . inplace (MStream.scanl1 f) . stream
scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
scanl1' f = unstream . inplace (MStream.scanl1' f) . stream
prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
prescanr f z = unstreamR . inplace (MStream.prescanl (flip f) z) . streamR
prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
prescanr' f z = unstreamR . inplace (MStream.prescanl' (flip f) z) . streamR
postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
postscanr f z = unstreamR . inplace (MStream.postscanl (flip f) z) . streamR
postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
postscanr' f z = unstreamR . inplace (MStream.postscanl' (flip f) z) . streamR
scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
scanr f z = unstreamR . Stream.scanl (flip f) z . streamR
scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
scanr' f z = unstreamR . Stream.scanl' (flip f) z . streamR
scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
scanr1 f = unstreamR . inplace (MStream.scanl1 (flip f)) . streamR
scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
scanr1' f = unstreamR . inplace (MStream.scanl1' (flip f)) . streamR
enumFromN :: (Vector v a, Num a) => a -> Int -> v a
enumFromN x n = enumFromStepN x 1 n
enumFromStepN :: forall v a. (Vector v a, Num a) => a -> a -> Int -> v a
enumFromStepN x y n = elemseq (undefined :: v a) x
$ elemseq (undefined :: v a) y
$ unstream
$ Stream.enumFromStepN x y n
enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
enumFromTo x y = unstream (Stream.enumFromTo x y)
enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
enumFromThenTo x y z = unstream (Stream.enumFromThenTo x y z)
toList :: Vector v a => v a -> [a]
toList = Stream.toList . stream
fromList :: Vector v a => [a] -> v a
fromList = unstream . Stream.fromList