Hello community, here is the log from the commit of package ghc-vector-algorithms for openSUSE:Factory checked in at 2018-10-25 08:19:16 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-vector-algorithms (Old) and /work/SRC/openSUSE:Factory/.ghc-vector-algorithms.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-vector-algorithms" Thu Oct 25 08:19:16 2018 rev:9 rq:642903 version:0.8.0.1 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-vector-algorithms/ghc-vector-algorithms.changes 2018-09-03 10:35:09.752678695 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-vector-algorithms.new/ghc-vector-algorithms.changes 2018-10-25 08:19:20.203991902 +0200 @@ -1,0 +2,6 @@ +Wed Oct 10 19:23:57 UTC 2018 - psimons@suse.com + +- Update vector-algorithms to version 0.8.0.1. + Upstream does not provide a change log file. + +------------------------------------------------------------------- Old: ---- vector-algorithms-0.7.0.4.tar.gz New: ---- vector-algorithms-0.8.0.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-vector-algorithms.spec ++++++ --- /var/tmp/diff_new_pack.FyE2YU/_old 2018-10-25 08:19:20.695991685 +0200 +++ /var/tmp/diff_new_pack.FyE2YU/_new 2018-10-25 08:19:20.699991683 +0200 @@ -12,14 +12,14 @@ # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# Please submit bugfixes or comments via https://bugs.opensuse.org/ # %global pkg_name vector-algorithms %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.7.0.4 +Version: 0.8.0.1 Release: 0 Summary: Efficient algorithms for vector arrays License: BSD-3-Clause ++++++ vector-algorithms-0.7.0.4.tar.gz -> vector-algorithms-0.8.0.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/bench/simple/Blocks.hs new/vector-algorithms-0.8.0.1/bench/simple/Blocks.hs --- old/vector-algorithms-0.7.0.4/bench/simple/Blocks.hs 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/bench/simple/Blocks.hs 2018-10-09 03:32:06.000000000 +0200 @@ -46,12 +46,12 @@ where initial n = fill n >>= unsafeWrite arr n >> when (n > 0) (initial $ n - 1) {-# INLINE initialize #-} -speedTest :: (Unbox e) => Int +speedTest :: (Unbox e) => MVector RealWorld e + -> Int -> (Int -> IO e) -> (MVector RealWorld e -> IO ()) -> IO Integer -speedTest n fill algo = do - arr <- new n +speedTest arr n fill algo = do initialize arr n fill t0 <- clock algo arr diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/bench/simple/Main.hs new/vector-algorithms-0.8.0.1/bench/simple/Main.hs --- old/vector-algorithms-0.7.0.4/bench/simple/Main.hs 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/bench/simple/Main.hs 2018-10-09 03:32:06.000000000 +0200 @@ -5,8 +5,8 @@ import Prelude hiding (read, length) import qualified Prelude as P +import Control.Monad import Control.Monad.ST -import Control.Monad.Error import Data.Char import Data.Ord (comparing) @@ -40,20 +40,21 @@ displayTime :: String -> Integer -> IO () displayTime s elapsed = putStrLn $ - s ++ " : " ++ show (fromIntegral elapsed / 1e12) ++ " seconds" + s ++ " : " ++ show (fromIntegral elapsed / (1e12 :: Double)) ++ " seconds" run :: String -> IO Integer -> IO () run s t = t >>= displayTime s sortSuite :: String -> GenIO -> Int -> (MVector RealWorld Int -> IO ()) -> IO () sortSuite str g n sort = do + arr <- new n putStrLn $ "Testing: " ++ str - run "Random " $ speedTest n (rand g >=> modulo n) sort - run "Sorted " $ speedTest n ascend sort - run "Reverse-sorted " $ speedTest n (descend n) sort - run "Random duplicates " $ speedTest n (rand g >=> modulo 1000) sort + run "Random " $ speedTest arr n (rand g >=> modulo n) sort + run "Sorted " $ speedTest arr n ascend sort + run "Reverse-sorted " $ speedTest arr n (descend n) sort + run "Random duplicates " $ speedTest arr n (rand g >=> modulo 1000) sort let m = 4 * (n `div` 4) - run "Median killer " $ speedTest m (medianKiller m) sort + run "Median killer " $ speedTest arr m (medianKiller m) sort partialSortSuite :: String -> GenIO -> Int -> Int -> (MVector RealWorld Int -> Int -> IO ()) -> IO () @@ -142,7 +143,6 @@ RadixSort -> sortSuite "radix sort" g n radixSort AmericanFlagSort -> sortSuite "flag sort" g n flagSort TimSort -> sortSuite "tim sort" g n timSort - _ -> putStrLn $ "Currently unsupported algorithm: " ++ show alg mergeSort :: MVector RealWorld Int -> IO () mergeSort v = M.sort v diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/src/Data/Vector/Algorithms/Merge.hs new/vector-algorithms-0.8.0.1/src/Data/Vector/Algorithms/Merge.hs --- old/vector-algorithms-0.7.0.4/src/Data/Vector/Algorithms/Merge.hs 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/src/Data/Vector/Algorithms/Merge.hs 2018-10-09 03:32:06.000000000 +0200 @@ -39,15 +39,22 @@ -- | Sorts an array using a custom comparison. sortBy :: (PrimMonad m, MVector v e) => Comparison e -> v (PrimState m) e -> m () -sortBy cmp vec - | len <= 1 = return () - | len == 2 = O.sort2ByOffset cmp vec 0 - | len == 3 = O.sort3ByOffset cmp vec 0 - | len == 4 = O.sort4ByOffset cmp vec 0 - | otherwise = do buf <- new len - mergeSortWithBuf cmp vec buf +sortBy cmp vec = if len <= 4 + then if len <= 2 + then if len /= 2 + then return () + else O.sort2ByOffset cmp vec 0 + else if len == 3 + then O.sort3ByOffset cmp vec 0 + else O.sort4ByOffset cmp vec 0 + else if len < threshold + then I.sortByBounds cmp vec 0 len + else do buf <- new halfLen + mergeSortWithBuf cmp vec buf where - len = length vec + len = length vec + -- odd lengths have a larger half that needs to fit, so use ceiling, not floor + halfLen = (len + 1) `div` 2 {-# INLINE sortBy #-} mergeSortWithBuf :: (PrimMonad m, MVector v e) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/tests/properties/Properties.hs new/vector-algorithms-0.8.0.1/tests/properties/Properties.hs --- old/vector-algorithms-0.7.0.4/tests/properties/Properties.hs 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/tests/properties/Properties.hs 2018-10-09 03:32:06.000000000 +0200 @@ -27,7 +27,7 @@ import qualified Data.Map as M -import Test.QuickCheck +import Test.QuickCheck hiding (Sorted) import Util @@ -104,7 +104,7 @@ in V.all ((e', i') -> e < e' || i < i') (V.tail arr) .&. stable (V.tail arr) -prop_stable_radix :: (forall e s mv. G.MVector mv e => Int -> Int -> (Int -> e -> Int) +prop_stable_radix :: (forall e s mv. G.MVector mv e => Int -> Int -> (Int -> e -> Int) -> mv s e -> ST s ()) -> Vector Int -> Property prop_stable_radix algo arr = @@ -113,7 +113,7 @@ where ix = V.fromList [1 .. V.length arr] e = V.head arr - + prop_optimal :: Int -> (forall e s mv. G.MVector mv e => Comparison e -> mv s e -> Int -> ST s ()) -> Property @@ -137,7 +137,7 @@ prop_permutation :: (Ord e) => (forall s mv. G.MVector mv e => mv s e -> ST s ()) -> Vector e -> Property -prop_permutation algo arr = property $ +prop_permutation algo arr = property $ toBag arr == toBag (modify algo arr) newtype SortedVec e = Sorted (Vector e) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/tests/properties/Tests.hs new/vector-algorithms-0.8.0.1/tests/properties/Tests.hs --- old/vector-algorithms-0.7.0.4/tests/properties/Tests.hs 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/tests/properties/Tests.hs 2018-10-09 03:32:06.000000000 +0200 @@ -1,4 +1,4 @@ -{-# LANGUAGE ImpredicativeTypes, RankNTypes, TypeOperators, FlexibleContexts #-} +{-# LANGUAGE RankNTypes, TypeOperators, FlexibleContexts #-} module Main (main) where @@ -37,36 +37,40 @@ type SizeAlgo e r = forall s mv. MVector mv e => mv s e -> Int -> ST s r type BoundAlgo e r = forall s mv. MVector mv e => mv s e -> Int -> Int -> ST s r +newtype WrappedAlgo e r = WrapAlgo { unWrapAlgo :: Algo e r } +newtype WrappedSizeAlgo e r = WrapSizeAlgo { unWrapSizeAlgo :: SizeAlgo e r } +newtype WrappedBoundAlgo e r = WrapBoundAlgo { unWrapBoundAlgo :: BoundAlgo e r } + args = stdArgs { maxSuccess = 1000 , maxDiscardRatio = 2 } check_Int_sort = forM_ algos $ (name,algo) -> - quickCheckWith args (label name . prop_fullsort algo) + quickCheckWith args (label name . prop_fullsort (unWrapAlgo algo)) where - algos :: [(String, Algo Int ())] - algos = [ ("introsort", INT.sort) - , ("insertion sort", INS.sort) - , ("merge sort", M.sort) - , ("heapsort", H.sort) - , ("timsort", T.sort) + algos :: [(String, WrappedAlgo Int ())] + algos = [ ("introsort", WrapAlgo INT.sort) + , ("insertion sort", WrapAlgo INS.sort) + , ("merge sort", WrapAlgo M.sort) + , ("heapsort", WrapAlgo H.sort) + , ("timsort", WrapAlgo T.sort) ] check_Int_partialsort = forM_ algos $ (name,algo) -> - quickCheckWith args (label name . prop_partialsort algo) + quickCheckWith args (label name . prop_partialsort (unWrapSizeAlgo algo)) where - algos :: [(String, SizeAlgo Int ())] - algos = [ ("intro-partialsort", INT.partialSort) - , ("heap partialsort", H.partialSort) + algos :: [(String, WrappedSizeAlgo Int ())] + algos = [ ("intro-partialsort", WrapSizeAlgo INT.partialSort) + , ("heap partialsort", WrapSizeAlgo H.partialSort) ] check_Int_select = forM_ algos $ (name,algo) -> - quickCheckWith args (label name . prop_select algo) + quickCheckWith args (label name . prop_select (unWrapSizeAlgo algo)) where - algos :: [(String, SizeAlgo Int ())] - algos = [ ("intro-select", INT.select) - , ("heap select", H.select) + algos :: [(String, WrappedSizeAlgo Int ())] + algos = [ ("intro-select", WrapSizeAlgo INT.select) + , ("heap select", WrapSizeAlgo H.select) ] check_radix_sorts = do @@ -142,16 +146,14 @@ qc $ label "flag W64" . prop_permutation (AF.sort :: Algo Word64 ()) qc $ label "flag Word" . prop_permutation (AF.sort :: Algo Word ()) qc $ label "flag ByteString" . prop_permutation (AF.sort :: Algo B.ByteString ()) -{- - qc $ label "intropartial" . prop_sized (const . prop_permutation) + qc $ label "intropartial" . prop_sized (\x -> const (prop_permutation x)) (INT.partialSort :: SizeAlgo Int ()) - qc $ label "introselect" . prop_sized (const . prop_permutation) + qc $ label "introselect" . prop_sized (\x -> const (prop_permutation x)) (INT.select :: SizeAlgo Int ()) - qc $ label "heappartial" . prop_sized (const . prop_permutation) + qc $ label "heappartial" . prop_sized (\x -> const (prop_permutation x)) (H.partialSort :: SizeAlgo Int ()) - qc $ label "heapselect" . prop_sized (const . prop_permutation) - (H.select :: Algo Int ()) --} + qc $ label "heapselect" . prop_sized (\x -> const (prop_permutation x)) + (H.select :: SizeAlgo Int ()) where qc prop = quickCheckWith args prop diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-algorithms-0.7.0.4/vector-algorithms.cabal new/vector-algorithms-0.8.0.1/vector-algorithms.cabal --- old/vector-algorithms-0.7.0.4/vector-algorithms.cabal 2018-08-24 13:13:24.000000000 +0200 +++ new/vector-algorithms-0.8.0.1/vector-algorithms.cabal 2018-10-09 03:32:06.000000000 +0200 @@ -1,5 +1,5 @@ name: vector-algorithms -version: 0.7.0.4 +version: 0.8.0.1 license: BSD3 license-file: LICENSE author: Dan Doel @@ -32,7 +32,7 @@ flag bench description: Build a benchmarking program to test vector-algorithms performance - default: False + default: True flag properties description: Enable the quickcheck tests @@ -100,8 +100,9 @@ if flag(InternalChecks) cpp-options: -DVECTOR_INTERNAL_CHECKS -executable simple-bench +benchmark simple-bench hs-source-dirs: bench/simple + type: exitcode-stdio-1.0 if !flag(bench) buildable: False @@ -111,7 +112,7 @@ other-modules: Blocks - build-depends: base, mwc-random, vector, vector-algorithms, mtl + build-depends: base, mwc-random, vector, vector-algorithms ghc-options: -Wall -- Cabal/Hackage complains about these @@ -138,7 +139,7 @@ base, bytestring, containers, - QuickCheck >= 2, + QuickCheck > 2.9 && < 2.13, vector, vector-algorithms