Hello community, here is the log from the commit of package ghc-scientific for openSUSE:Factory checked in at 2017-03-20 17:06:33 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-scientific (Old) and /work/SRC/openSUSE:Factory/.ghc-scientific.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-scientific" Mon Mar 20 17:06:33 2017 rev:12 rq:461680 version:0.3.4.10 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-scientific/ghc-scientific.changes 2016-08-24 10:08:02.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-scientific.new/ghc-scientific.changes 2017-03-20 17:06:34.231220739 +0100 @@ -1,0 +2,10 @@ +Sun Feb 12 14:14:50 UTC 2017 - [email protected] + +- Update to version 0.3.4.10 with cabal2obs. + +------------------------------------------------------------------- +Wed Jan 4 21:22:15 UTC 2017 - [email protected] + +- Update to version 0.3.4.9 revision 1 with cabal2obs. + +------------------------------------------------------------------- Old: ---- scientific-0.3.4.9.tar.gz New: ---- scientific-0.3.4.10.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-scientific.spec ++++++ --- /var/tmp/diff_new_pack.z5WRqL/_old 2017-03-20 17:06:34.883128690 +0100 +++ /var/tmp/diff_new_pack.z5WRqL/_new 2017-03-20 17:06:34.883128690 +0100 @@ -1,7 +1,7 @@ # # spec file for package ghc-scientific # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,11 +19,11 @@ %global pkg_name scientific %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.3.4.9 +Version: 0.3.4.10 Release: 0 Summary: Numbers represented using scientific notation License: BSD-3-Clause -Group: System/Libraries +Group: Development/Languages/Other Url: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz BuildRequires: ghc-Cabal-devel @@ -32,6 +32,7 @@ BuildRequires: ghc-containers-devel BuildRequires: ghc-deepseq-devel BuildRequires: ghc-hashable-devel +BuildRequires: ghc-integer-logarithms-devel BuildRequires: ghc-rpm-macros BuildRequires: ghc-text-devel BuildRequires: ghc-vector-devel @@ -90,19 +91,15 @@ %prep %setup -q -n %{pkg_name}-%{version} - %build %ghc_lib_build - %install %ghc_lib_install - %check %cabal_test - %post devel %ghc_pkg_recache ++++++ scientific-0.3.4.9.tar.gz -> scientific-0.3.4.10.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scientific-0.3.4.9/changelog new/scientific-0.3.4.10/changelog --- old/scientific-0.3.4.9/changelog 2016-07-11 23:25:34.000000000 +0200 +++ new/scientific-0.3.4.10/changelog 2017-01-02 23:32:26.000000000 +0100 @@ -1,3 +1,11 @@ +0.3.4.10 + * Tighten lower bound on vector from 0.5 to 0.7 because building with + vector < 0.7 results in a build error. + + * Move the internal modules Math.NumberTheory.Logarithms and + GHC.Integer.Logarithms.Compat to their own package integer-logarithms so + other people can share that code. + 0.3.4.9 * Support QuickCheck-2.9. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scientific-0.3.4.9/scientific.cabal new/scientific-0.3.4.10/scientific.cabal --- old/scientific-0.3.4.9/scientific.cabal 2016-07-11 23:25:34.000000000 +0200 +++ new/scientific-0.3.4.10/scientific.cabal 2017-01-02 23:32:26.000000000 +0100 @@ -1,5 +1,5 @@ name: scientific -version: 0.3.4.9 +version: 0.3.4.10 synopsis: Numbers represented using scientific notation description: @Data.Scientific@ provides the number type 'Scientific'. Scientific numbers are @@ -62,18 +62,17 @@ exposed-modules: Data.ByteString.Builder.Scientific Data.Scientific Data.Text.Lazy.Builder.Scientific - other-modules: Math.NumberTheory.Logarithms - GHC.Integer.Logarithms.Compat - GHC.Integer.Compat + other-modules: GHC.Integer.Compat Utils other-extensions: DeriveDataTypeable, BangPatterns ghc-options: -Wall build-depends: base >= 4.3 && < 4.10 , ghc-prim + , integer-logarithms >= 1 && <1.1 , deepseq >= 1.3 && < 1.5 , text >= 0.8 && < 1.3 , hashable >= 1.1.2 && < 1.3 - , vector >= 0.5 && < 0.12 + , vector >= 0.7 && < 0.13 , containers >= 0.1 && < 0.6 , binary >= 0.4.1 && < 0.9 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scientific-0.3.4.9/src/GHC/Integer/Logarithms/Compat.hs new/scientific-0.3.4.10/src/GHC/Integer/Logarithms/Compat.hs --- old/scientific-0.3.4.9/src/GHC/Integer/Logarithms/Compat.hs 2016-07-11 23:25:34.000000000 +0200 +++ new/scientific-0.3.4.10/src/GHC/Integer/Logarithms/Compat.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,120 +0,0 @@ -{-# LANGUAGE CPP, MagicHash, UnboxedTuples #-} - -module GHC.Integer.Logarithms.Compat - ( integerLog2# - , wordLog2# - ) where - -#if __GLASGOW_HASKELL__ >= 702 -import GHC.Integer.Logarithms (integerLog2#, wordLog2#) -#else -#include "MachDeps.h" - -import GHC.Integer.GMP.Internals (Integer(S#, J#)) - -import GHC.Base ( indexWordArray#, uncheckedIShiftL#, indexInt8Array# - , word2Int#, ByteArray#, newByteArray#, writeInt8Array# - , (==#), (<#), (+#), (*#) - , unsafeFreezeByteArray#, realWorld# - , neWord#, (-#), uncheckedShiftRL# - , Int#, Word#, int2Word# - ) - -#if (WORD_SIZE_IN_BITS != 32) && (WORD_SIZE_IN_BITS != 64) -#error Only word sizes 32 and 64 are supported. -#endif - - -#if WORD_SIZE_IN_BITS == 32 - -#define WSHIFT 5 -#define MMASK 31 - -#else - -#define WSHIFT 6 -#define MMASK 63 - -#endif - --- | Calculate the integer base 2 logarithm of an 'Integer'. --- The calculation is much more efficient than for the general case. --- --- The argument must be strictly positive, that condition is /not/ checked. -integerLog2# :: Integer -> Int# -integerLog2# (S# i) = wordLog2# (int2Word# i) -integerLog2# (J# s ba) = check (s -# 1#) - where - check i = case indexWordArray# ba i of - 0## -> check (i -# 1#) - w -> wordLog2# w +# (uncheckedIShiftL# i WSHIFT#) - --- | This function calculates the integer base 2 logarithm of a 'Word#'. --- @'wordLog2#' 0## = -1#@. -{-# INLINE wordLog2# #-} -wordLog2# :: Word# -> Int# -wordLog2# w = - case leadingZeros of - BA lz -> - let zeros u = indexInt8Array# lz (word2Int# u) in -#if WORD_SIZE_IN_BITS == 64 - case uncheckedShiftRL# w 56# of - a -> - if a `neWord#` 0## - then 64# -# zeros a - else - case uncheckedShiftRL# w 48# of - b -> - if b `neWord#` 0## - then 56# -# zeros b - else - case uncheckedShiftRL# w 40# of - c -> - if c `neWord#` 0## - then 48# -# zeros c - else - case uncheckedShiftRL# w 32# of - d -> - if d `neWord#` 0## - then 40# -# zeros d - else -#endif - case uncheckedShiftRL# w 24# of - e -> - if e `neWord#` 0## - then 32# -# zeros e - else - case uncheckedShiftRL# w 16# of - f -> - if f `neWord#` 0## - then 24# -# zeros f - else - case uncheckedShiftRL# w 8# of - g -> - if g `neWord#` 0## - then 16# -# zeros g - else 8# -# zeros w - --- Lookup table -data BA = BA ByteArray# - -leadingZeros :: BA -leadingZeros = - let mkArr s = - case newByteArray# 256# s of - (# s1, mba #) -> - case writeInt8Array# mba 0# 9# s1 of - s2 -> - let fillA lim val idx st = - if idx ==# 256# - then st - else if idx <# lim - then case writeInt8Array# mba idx val st of - nx -> fillA lim val (idx +# 1#) nx - else fillA (2# *# lim) (val -# 1#) idx st - in case fillA 2# 8# 1# s2 of - s3 -> case unsafeFreezeByteArray# mba s3 of - (# _, ba #) -> ba - in case mkArr realWorld# of - b -> BA b -#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scientific-0.3.4.9/src/Math/NumberTheory/Logarithms.hs new/scientific-0.3.4.10/src/Math/NumberTheory/Logarithms.hs --- old/scientific-0.3.4.9/src/Math/NumberTheory/Logarithms.hs 2016-07-11 23:25:34.000000000 +0200 +++ new/scientific-0.3.4.10/src/Math/NumberTheory/Logarithms.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,74 +0,0 @@ -{-# LANGUAGE CPP, MagicHash, UnboxedTuples #-} - --- | Integer logarithm, copied from Daniel Fischer's @arithmoi@ -module Math.NumberTheory.Logarithms ( integerLog10' ) where - -#if defined(INTEGER_SIMPLE) && __GLASGOW_HASKELL__ < 702 -import GHC.Integer.Logarithms (integerLogBase#) -import GHC.Base (Int(I#)) - --- | Only defined for positive inputs! -integerLog10' :: Integer -> Int -integerLog10' m = I# (integerLogBase# 10 m) - -#else -import GHC.Base ( Int(I#), Word#, Int# - , int2Word#, eqWord#, neWord#, (-#), and#, uncheckedShiftRL# - -#if __GLASGOW_HASKELL__ >= 707 - , isTrue# -#endif - ) - -import GHC.Integer.Logarithms.Compat (integerLog2#, wordLog2#) - --- | Only defined for positive inputs! -integerLog10' :: Integer -> Int -integerLog10' n - | n < 10 = 0 - | n < 100 = 1 - | otherwise = ex + integerLog10' (n `quot` integerPower 10 ex) - where - ln = I# (integerLog2# n) - -- u/v is a good approximation of log 2/log 10 - u = 1936274 - v = 6432163 - -- so ex is a good approximation to integerLogBase 10 n - ex = fromInteger ((u * fromIntegral ln) `quot` v) - --- | Power of an 'Integer' by the left-to-right repeated squaring algorithm. --- This needs two multiplications in each step while the right-to-left --- algorithm needs only one multiplication for 0-bits, but here the --- two factors always have approximately the same size, which on average --- gains a bit when the result is large. --- --- For small results, it is unlikely to be any faster than '(^)', quite --- possibly slower (though the difference shouldn't be large), and for --- exponents with few bits set, the same holds. But for exponents with --- many bits set, the speedup can be significant. --- --- /Warning:/ No check for the negativity of the exponent is performed, --- a negative exponent is interpreted as a large positive exponent. -integerPower :: Integer -> Int -> Integer -integerPower b (I# e#) = power b (int2Word# e#) - -power :: Integer -> Word# -> Integer -power b w# - | isTrue# (w# `eqWord#` 0##) = 1 - | isTrue# (w# `eqWord#` 1##) = b - | otherwise = go (wordLog2# w# -# 1#) b (b*b) - where - go 0# l h = if isTrue# ((w# `and#` 1##) `eqWord#` 0##) then l*l else (l*h) - go i# l h - | w# `hasBit#` i# = go (i# -# 1#) (l*h) (h*h) - | otherwise = go (i# -# 1#) (l*l) (l*h) - --- | A raw version of testBit for 'Word#'. -hasBit# :: Word# -> Int# -> Bool -hasBit# w# i# = isTrue# (((w# `uncheckedShiftRL#` i#) `and#` 1##) `neWord#` 0##) - -#if __GLASGOW_HASKELL__ < 707 -isTrue# :: Bool -> Bool -isTrue# = id -#endif -#endif
