diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright Andrey Mulik (c) 2019 + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Andrey Mulik nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/sdp4vector.cabal b/sdp4vector.cabal new file mode 100644 --- /dev/null +++ b/sdp4vector.cabal @@ -0,0 +1,100 @@ +name: sdp4vector +version: 0.2 +category: Data Structures + +synopsis: SDP wrapper for Vector +description: Implementation of SDP classes for Vector package + +author: Andrey Mulik +maintainer: +bug-reports: https://github.com/andreymulik/sdp4vector/issues + +copyright: 2019 Andrey Mulik +license-file: LICENSE +license: BSD3 + +build-type: Simple +cabal-version: >=1.10 + +source-repository head + type: git + location: https://github.com/andreymulik/sdp4vector + +--- _ _____ ______ ______ ___ ______ __ __ --- +--- | | |_ _|| ___ \| ___ \ / _ \ | ___ \\ \ / / --- +--- | | | | | |_/ /| |_/ // /_\ \| |_/ / \ V / --- +--- | | | | | ___ \| / | _ || / \ / --- +--- | |____ _| |_ | |_/ /| |\ \ | | | || |\ \ | | --- +--- \_____/ \___/ \____/ \_| \_|\_| |_/\_| \_| \_/ --- + +Library + hs-source-dirs: src + + default-language: Haskell2010 + + build-depends: + base >= 4.12 && < 5, + sdp >= 0.2 && < 0.3, + vector >= 0.12 && < 0.13 + + ghc-options: -Wall -Wcompat -Wno-orphans + + exposed-modules: + SDP.Vector + SDP.Vector.Unboxed + +--- _____ _____ _____ _____ _____ _ _ _____ --- +--- |_ _|| ___|/ ___||_ _||_ _|| \ | || __ \ --- +--- | | | |__ \ `--. | | | | | \| || | \/ --- +--- | | | __| `--. \ | | | | | . ` || | __ --- +--- | | | |___ /\__/ / | | _| |_ | |\ || |_\ \ --- +--- \_/ \____/ \____/ \_/ \___/ \_| \_/ \____/ --- + +test-suite test-vector-boxed + default-language: Haskell2010 + hs-source-dirs: test, src + + type: exitcode-stdio-1.0 + main-is: test-vector-boxed.hs + + other-modules: + SDP.Vector + + build-depends: + base >= 4.12 && < 5, + sdp >= 0.2 && < 0.3, + vector >= 0.12 && < 0.13, + + QuickCheck >= 2.12 && < 3, + sdp-quickcheck >= 0.2 && < 0.3, + quickcheck-instances >= 0.3 && < 0.4, + + test-framework >= 0.8 && < 0.9, + test-framework-quickcheck2 >= 0.3 && < 0.4 + + ghc-options: -Wall -Wcompat -Wno-orphans + +test-suite test-vector-unboxed + default-language: Haskell2010 + hs-source-dirs: test, src + + type: exitcode-stdio-1.0 + main-is: test-vector-unboxed.hs + + other-modules: + SDP.Vector.Unboxed + + build-depends: + base >= 4.12 && < 5, + sdp >= 0.2 && < 0.3, + vector >= 0.12 && < 0.13, + + QuickCheck >= 2.12 && < 3, + sdp-quickcheck >= 0.2 && < 0.3, + quickcheck-instances >= 0.3 && < 0.4, + + test-framework >= 0.8 && < 0.9, + test-framework-quickcheck2 >= 0.3 && < 0.4 + + ghc-options: -Wall -Wcompat -Wno-orphans + diff --git a/src/SDP/Vector.hs b/src/SDP/Vector.hs new file mode 100644 --- /dev/null +++ b/src/SDP/Vector.hs @@ -0,0 +1,230 @@ +{-# LANGUAGE Trustworthy, MagicHash, MultiParamTypeClasses, FlexibleInstances #-} + +{- | + Module : SDP.Vector + Copyright : (c) Andrey Mulik 2019 + License : BSD-style + Maintainer : work.a.mulik@gmail.com + Portability : portable + + @SDP.Vector@ provides 'Vector' - immutable lazy boxed vector. +-} +module SDP.Vector +( + -- * Exports + module SDP.Indexed, + module SDP.Sort, + module SDP.Scan, + + -- * Vector + Vector +) +where + +import Prelude () +import SDP.SafePrelude +import SDP.IndexedM +import SDP.Indexed +import SDP.Sort +import SDP.Scan + +import qualified Data.Vector.Fusion.Bundle as B +import qualified Data.Vector as V + +import Data.Vector.Generic ( stream ) +import Data.Vector ( Vector ) + +import SDP.Unrolled.STUnlist +import SDP.Unrolled.IOUnlist +import SDP.Prim.SArray +import SDP.SortM.Tim + +default () + +-------------------------------------------------------------------------------- + +{- Nullable, Zip, Scan and Estimate instances. -} + +instance Nullable (Vector e) + where + isNull = V.null + lzero = V.empty + +instance Zip Vector + where + all6 f as bs cs ds es fs = B.and $ B.zipWith6 f + (stream as) (stream bs) (stream cs) (stream ds) (stream es) (stream fs) + + all5 f as bs cs ds es = B.and $ B.zipWith5 f + (stream as) (stream bs) (stream cs) (stream ds) (stream es) + + all4 f as bs cs ds = B.and $ B.zipWith4 f + (stream as) (stream bs) (stream cs) (stream ds) + + all3 f as bs cs = B.and $ B.zipWith3 f + (stream as) (stream bs) (stream cs) + + all2 f as bs = B.and $ B.zipWith f + (stream as) (stream bs) + + any6 f as bs cs ds es fs = B.or $ B.zipWith6 f + (stream as) (stream bs) (stream cs) (stream ds) (stream es) (stream fs) + + any5 f as bs cs ds es = B.or $ B.zipWith5 f + (stream as) (stream bs) (stream cs) (stream ds) (stream es) + + any4 f as bs cs ds = B.or $ B.zipWith4 f + (stream as) (stream bs) (stream cs) (stream ds) + + any3 f as bs cs = B.or $ B.zipWith3 f + (stream as) (stream bs) (stream cs) + + any2 f as bs = B.or $ B.zipWith f (stream as) (stream bs) + + zipWith = V.zipWith + zipWith3 = V.zipWith3 + zipWith4 = V.zipWith4 + zipWith5 = V.zipWith5 + zipWith6 = V.zipWith6 + +instance Scan (Vector e) e + +instance Estimate (Vector e) + where + (<==>) = on (<=>) sizeOf + (.>.) = on (>) sizeOf + (.<.) = on (<) sizeOf + (.<=.) = on (<=) sizeOf + (.>=.) = on (>=) sizeOf + + (<.=>) = (<=>) . sizeOf + (.>) = (>) . sizeOf + (.<) = (<) . sizeOf + (.>=) = (>=) . sizeOf + (.<=) = (<=) . sizeOf + +-------------------------------------------------------------------------------- + +{- Linear, Split and Bordered instances. -} + +instance Linear (Vector e) e + where + single = V.singleton + toHead = V.cons + toLast = V.snoc + + listL = V.toList + force = V.force + head = V.head + tail = V.tail + init = V.init + last = V.last + nub = V.uniq + + (!^) = V.unsafeIndex + (++) = (V.++) + + write es = (es //) . single ... (,) + + partitions ps = fmap fromList . partitions ps . toList + concatMap f = V.concatMap f . fromFoldable + + fromListN = V.fromListN + replicate = V.replicate + partition = V.partition + fromList = V.fromList + reverse = V.reverse + + concat = V.concat . toList + filter = V.filter + + ofoldl = V.ifoldl . flip + ofoldr = V.ifoldr + + o_foldl = foldl + o_foldr = foldr + +instance Split (Vector e) e + where + take = V.take + drop = V.drop + split = V.splitAt + + takeWhile = V.takeWhile + dropWhile = V.dropWhile + + spanl = V.span + breakl = V.break + +instance Bordered (Vector e) Int + where + lower _ = 0 + upper es = sizeOf es - 1 + bounds es = (0, sizeOf es - 1) + + sizeOf = V.length + +-------------------------------------------------------------------------------- + +{- Map, Indexed and Sort instances. -} + +instance Map (Vector e) Int e + where + toMap ascs = isNull ascs ? Z $ assoc (l, u) ascs + where + l = fst $ minimumBy cmpfst ascs + u = fst $ maximumBy cmpfst ascs + + toMap' defvalue ascs = isNull ascs ? Z $ assoc' (l, u) defvalue ascs + where + l = fst $ minimumBy cmpfst ascs + u = fst $ maximumBy cmpfst ascs + + Z // ascs = toMap ascs + vs // ascs = vs V.// ascs + + (*$) = toList ... V.findIndices + (.!) = V.unsafeIndex + (.$) = V.findIndex + (!?) = (V.!?) + + kfoldl = ofoldl + kfoldr = ofoldr + +instance Indexed (Vector e) Int e + where + assoc' bnds defvalue ascs = runST $ fromAssocs' bnds defvalue ascs >>= done + + fromIndexed es' = accum (flip const) es ies + where + ies = [ (offset bnds i, e) | (i, e) <- assocs es', inRange bnds i ] + es = replicate (size bnds) undefined + bnds = bounds es' + +instance Sort (Vector e) e + where + sortBy cmp es = runST $ do es' <- thaw es; timSortBy cmp es'; done es' + + sortedBy f = sortedBy f . listL + +-------------------------------------------------------------------------------- + +{- Thaw and Freeze instances. -} + +instance Thaw (ST s) (Vector e) (STArray# s e) where thaw = fromFoldableM +instance Thaw (ST s) (Vector e) (STUnlist s e) where thaw = fromFoldableM + +instance (MonadIO io) => Thaw io (Vector e) (MIOArray# io e) where thaw = fromFoldableM +instance (MonadIO io) => Thaw io (Vector e) (MIOUnlist io e) where thaw = fromFoldableM + +instance Freeze (ST s) (STArray# s e) (Vector e) where freeze = fmap fromList . getLeft +instance Freeze (ST s) (STUnlist s e) (Vector e) where freeze = fmap fromList . getLeft + +instance (MonadIO io) => Freeze io (MIOArray# io e) (Vector e) where freeze = fmap fromList . getLeft +instance (MonadIO io) => Freeze io (MIOUnlist io e) (Vector e) where freeze = fmap fromList . getLeft + +-------------------------------------------------------------------------------- + +done :: STArray# s e -> ST s (Vector e) +done = freeze + diff --git a/src/SDP/Vector/Unboxed.hs b/src/SDP/Vector/Unboxed.hs new file mode 100644 --- /dev/null +++ b/src/SDP/Vector/Unboxed.hs @@ -0,0 +1,200 @@ +{-# LANGUAGE Trustworthy, MagicHash, MultiParamTypeClasses, FlexibleInstances #-} + +{- | + Module : SDP.Vector.Unboxed + Copyright : (c) Andrey Mulik 2019 + License : BSD-style + Maintainer : work.a.mulik@gmail.com + Portability : portable + + @SDP.Vector.Unboxed@ provides 'Vector' - immutable strict unboxed vector. + + This module uses the Unbox and Unboxed classes. Looking at similar names + and, in general, general purpose, they are fundamentally different: + + Despite similar names, classes are very different: + * 'Unboxed' is a low-level interface that generalizes access to data. + * 'Unbox' is a service class that combines Vector and MVector. +-} +module SDP.Vector.Unboxed +( + -- * Exports + module SDP.Indexed, + module SDP.Unboxed, + module SDP.Sort, + module SDP.Scan, + + -- * Vector + Unbox, Vector +) +where + +import Prelude () +import SDP.SafePrelude +import SDP.IndexedM +import SDP.Indexed +import SDP.Unboxed +import SDP.Sort +import SDP.Scan + +import SDP.ByteList.STUblist +import SDP.ByteList.IOUblist + +import SDP.Prim.SBytes +import SDP.SortM.Tim + +import Data.Vector.Unboxed ( Vector, Unbox ) +import qualified Data.Vector.Unboxed as V + +default () + +-------------------------------------------------------------------------------- + +{- Nullable, Scan and Estimate instances. -} + +instance (Unbox e) => Nullable (Vector e) + where + isNull = V.null + lzero = V.empty + +instance (Unbox e) => Scan (Vector e) e + +instance (Unbox e) => Estimate (Vector e) + where + (<==>) = on (<=>) sizeOf + (.>=.) = on (>=) sizeOf + (.<=.) = on (<=) sizeOf + (.>.) = on (>) sizeOf + (.<.) = on (<) sizeOf + + (<.=>) = (<=>) . sizeOf + (.>=) = (>=) . sizeOf + (.<=) = (<=) . sizeOf + (.>) = (>) . sizeOf + (.<) = (<) . sizeOf + +-------------------------------------------------------------------------------- + +{- Linear, Split and Bordered instances. -} + +instance (Unbox e) => Linear (Vector e) e + where + single = V.singleton + toHead = V.cons + toLast = V.snoc + + listL = V.toList + force = V.force + head = V.head + tail = V.tail + init = V.init + last = V.last + nub = V.uniq + + (!^) = V.unsafeIndex + (++) = (V.++) + + write es = (es V.//) . single ... (,) + + partitions ps = fmap fromList . partitions ps . listL + concatMap f = concat . foldr ((:) . f) [] + + fromListN = V.fromListN + replicate = V.replicate + partition = V.partition + fromList = V.fromList + reverse = V.reverse + + concat = V.concat . toList + filter = V.filter + + ofoldl = V.ifoldl . flip + ofoldr = V.ifoldr + o_foldl = V.foldl + o_foldr = V.foldr + +instance (Unbox e) => Split (Vector e) e + where + take = V.take + drop = V.drop + + split = V.splitAt + + takeWhile = V.takeWhile + dropWhile = V.dropWhile + + spanl = V.span + breakl = V.break + + prefix p = V.foldr (\ e c -> p e ? c + 1 $ 0) 0 + suffix p = V.foldl (\ c e -> p e ? c + 1 $ 0) 0 + +instance (Unbox e) => Bordered (Vector e) Int + where + lower _ = 0 + upper es = sizeOf es - 1 + bounds es = (0, sizeOf es - 1) + + sizeOf = V.length + +-------------------------------------------------------------------------------- + +{- Map, Indexed, IFold and Sort instances. -} + +instance (Unboxed e, Unbox e) => Map (Vector e) Int e + where + toMap ascs = isNull ascs ? Z $ ascsBounds ascs `assoc` ascs + + toMap' e ascs = isNull ascs ? Z $ assoc' (ascsBounds ascs) e ascs + + (.!) = V.unsafeIndex + (!?) = (V.!?) + + Z // ascs = toMap ascs + vs // ascs = vs V.// ascs + + (.$) = V.findIndex + (*$) = listL ... V.findIndices + + kfoldl = ofoldl + kfoldr = ofoldr + +instance (Unboxed e, Unbox e) => Indexed (Vector e) Int e + where + assoc bnds ascs = runST $ fromAssocs bnds ascs >>= done + + assoc' bnds e ascs = runST $ fromAssocs' bnds e ascs >>= done + + fromIndexed es = defaultBounds (sizeOf es) `assoc` + [ (offsetOf es i, e) | (i, e) <- assocs es, indexIn es i ] + +instance (Unboxed e, Unbox e) => Sort (Vector e) e + where + sortBy cmp es = runST $ do es' <- thaw es; timSortBy cmp es'; done es' + + sortedBy f = sortedBy f . listL + +-------------------------------------------------------------------------------- + +{- Thaw and Freeze instances. -} + +instance (Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STBytes# s e) where thaw = fromIndexed' +instance (Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STUblist s e) where thaw = fromIndexed' + +instance (MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOBytes# io e) where thaw = fromIndexed' +instance (MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOUblist io e) where thaw = fromIndexed' + +instance (Unboxed e, Unbox e) => Freeze (ST s) (STBytes# s e) (Vector e) where freeze = fmap fromList . getLeft +instance (Unboxed e, Unbox e) => Freeze (ST s) (STUblist s e) (Vector e) where freeze = fmap fromList . getLeft + +instance (MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOBytes# io e) (Vector e) where freeze = fmap fromList . getLeft +instance (MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOUblist io e) (Vector e) where freeze = fmap fromList . getLeft + +-------------------------------------------------------------------------------- + +ascsBounds :: (Ord a) => [(a, b)] -> (a, a) +ascsBounds = \ ((x, _) : xs) -> foldr (\ (e, _) (mn, mx) -> (min mn e, max mx e)) (x, x) xs + +done :: (Unboxed e, Unbox e) => STBytes# s e -> ST s (Vector e) +done = freeze + diff --git a/test/test-vector-boxed.hs b/test/test-vector-boxed.hs new file mode 100644 --- /dev/null +++ b/test/test-vector-boxed.hs @@ -0,0 +1,120 @@ +module Main where + +import Test.Framework +import Test.Framework.Providers.QuickCheck2 + +import SDP.Vector + +import Test.QuickCheck.Instances.Vector () +import Test.SDP + +default () + +-------------------------------------------------------------------------------- + +main :: IO () +main = defaultMain + [ + -- common tests + testProperty "vector-boxed-eq " eqProp, + testProperty "vector-boxed-ord " ordProp, + testProperty "vector-boxed-lexicographic " lgoProp, + + -- linear tests + testProperty "vector-boxed-linear-basic " basicLinearProp, + testProperty "vector-boxed-linear-decons " deconstructionLinearProp, + testProperty "vector-boxed-linear-cons " constructionLinearProp, + testProperty "vector-boxed-linear-reverse " reverseProp, + testProperty "vector-boxed-linear-concat " concatProp, + + -- split test + testProperty "vector-boxed-split " splitProp, + + -- indexed tests + testProperty "vector-boxed-indexed-basic " basicIndexedProp, + testProperty "vector-boxed-indexed-assoc " assocIndexedProp, + testProperty "vector-boxed-indexed-read " readIndexedProp, + + -- sort test + testProperty "vector-boxed-sort " sortProp, + + -- estimate test + testProperty "vector-boxed-estimate " estimateProp + ] + +-------------------------------------------------------------------------------- + +{- Eq property. -} + +eqProp :: TestEq (Vector Int) +eqProp = eqTest + +-------------------------------------------------------------------------------- + +{- Ord property. -} + +ordProp :: TestOrd (Vector Int) +ordProp = ordTest + +lgoProp :: Long (Vector Int) -> Long (Vector Int) -> Bool +lgoProp (Long xs) (Long ys) = lexicographicOrdTest xs ys + +-------------------------------------------------------------------------------- + +{- Linear properties. -} + +basicLinearProp :: Int -> Vector Int -> Bool +basicLinearProp = basicLinearTest + +deconstructionLinearProp :: Vector Int -> Bool +deconstructionLinearProp = deconstructionLinearTest + +constructionLinearProp :: Int -> Vector Int -> Bool +constructionLinearProp = constructionLinearTest + +reverseProp :: Vector Int -> Bool +reverseProp = reverseTest + +replicateProp :: TestLinear (Vector Int) Int +replicateProp = replicateTest + +concatProp :: (Vector Int) -> Bool +concatProp = concatTest + +-------------------------------------------------------------------------------- + +{- Split property. -} + +splitProp :: Int -> TestSplit (Vector Int) +splitProp = splitTest . (>) + +-------------------------------------------------------------------------------- + +{- Indexed property. -} + +basicIndexedProp :: TestIndexed1 Vector Int Int +basicIndexedProp = basicIndexedTest + +assocIndexedProp :: TestIndexed1 Vector Int Int +assocIndexedProp = assocIndexedTest + +readIndexedProp :: TestIndexed1 Vector Int Int +readIndexedProp = readIndexedTest + +-------------------------------------------------------------------------------- + +{- Sort property. -} + +sortProp :: Medium (Vector Int) -> Bool +sortProp = sortTest + +-------------------------------------------------------------------------------- + +{- Estimate property. -} + +estimateProp :: TestEstimate (Vector Int) +estimateProp = estimateTest + + + + diff --git a/test/test-vector-unboxed.hs b/test/test-vector-unboxed.hs new file mode 100644 --- /dev/null +++ b/test/test-vector-unboxed.hs @@ -0,0 +1,120 @@ +module Main where + +import Test.Framework +import Test.Framework.Providers.QuickCheck2 + +import SDP.Vector.Unboxed + +import Test.QuickCheck.Instances.Vector () +import Test.SDP + +default () + +-------------------------------------------------------------------------------- + +main :: IO () +main = defaultMain + [ + -- common tests + testProperty "vector-unboxed-eq " eqProp, + testProperty "vector-unboxed-ord " ordProp, + testProperty "vector-unboxed-lexicographic " lgoProp, + + -- linear tests + testProperty "vector-unboxed-linear-basic " basicLinearProp, + testProperty "vector-unboxed-linear-decons " deconstructionLinearProp, + testProperty "vector-unboxed-linear-cons " constructionLinearProp, + testProperty "vector-unboxed-linear-reverse " reverseProp, + testProperty "vector-unboxed-linear-concat " concatProp, + + -- split test + testProperty "vector-unboxed-split " splitProp, + + -- indexed tests + testProperty "vector-unboxed-indexed-basic " basicIndexedProp, + testProperty "vector-unboxed-indexed-assoc " assocIndexedProp, + testProperty "vector-unboxed-indexed-read " readIndexedProp, + + -- sort test + testProperty "vector-unboxed-sort " sortProp, + + -- estimate test + testProperty "vector-unboxed-estimate " estimateProp + ] + +-------------------------------------------------------------------------------- + +{- Eq property. -} + +eqProp :: TestEq (Vector Int) +eqProp = eqTest + +-------------------------------------------------------------------------------- + +{- Ord property. -} + +ordProp :: TestOrd (Vector Int) +ordProp = ordTest + +lgoProp :: Long (Vector Int) -> Long (Vector Int) -> Bool +lgoProp (Long xs) (Long ys) = lexicographicOrdTest xs ys + +-------------------------------------------------------------------------------- + +{- Linear properties. -} + +basicLinearProp :: Int -> Vector Int -> Bool +basicLinearProp = basicLinearTest + +deconstructionLinearProp :: Vector Int -> Bool +deconstructionLinearProp = deconstructionLinearTest + +constructionLinearProp :: Int -> Vector Int -> Bool +constructionLinearProp = constructionLinearTest + +reverseProp :: Vector Int -> Bool +reverseProp = reverseTest + +replicateProp :: TestLinear (Vector Int) Int +replicateProp = replicateTest + +concatProp :: (Vector Int) -> Bool +concatProp = concatTest + +-------------------------------------------------------------------------------- + +{- Split property. -} + +splitProp :: Int -> TestSplit (Vector Int) +splitProp = splitTest . (>) + +-------------------------------------------------------------------------------- + +{- Indexed property. -} + +basicIndexedProp :: TestIndexed1 Vector Int Int +basicIndexedProp = basicIndexedTest + +assocIndexedProp :: TestIndexed1 Vector Int Int +assocIndexedProp = assocIndexedTest + +readIndexedProp :: TestIndexed1 Vector Int Int +readIndexedProp = readIndexedTest + +-------------------------------------------------------------------------------- + +{- Sort property. -} + +sortProp :: Medium (Vector Int) -> Bool +sortProp = sortTest + +-------------------------------------------------------------------------------- + +{- Estimate property. -} + +estimateProp :: TestEstimate (Vector Int) +estimateProp = estimateTest + + + +