Hello community, here is the log from the commit of package ghc-math-functions for openSUSE:Factory checked in at 2020-06-19 17:15:07 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-math-functions (Old) and /work/SRC/openSUSE:Factory/.ghc-math-functions.new.3606 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-math-functions" Fri Jun 19 17:15:07 2020 rev:6 rq:815128 version:0.3.4.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-math-functions/ghc-math-functions.changes 2019-12-27 13:55:00.668705927 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-math-functions.new.3606/ghc-math-functions.changes 2020-06-19 17:15:10.306484439 +0200 @@ -1,0 +2,9 @@ +Tue Jun 9 09:10:52 UTC 2020 - [email protected] + +- Update math-functions to version 0.3.4.0. + ## Changes in 0.3.4.0 + + * Dependency on `vector-th-unbox` is dropped. All instances are written by + hand now. + +------------------------------------------------------------------- Old: ---- math-functions-0.3.3.0.tar.gz New: ---- math-functions-0.3.4.0.tar.gz math-functions.cabal ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-math-functions.spec ++++++ --- /var/tmp/diff_new_pack.oWGoT1/_old 2020-06-19 17:15:15.622501007 +0200 +++ /var/tmp/diff_new_pack.oWGoT1/_new 2020-06-19 17:15:15.626501020 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-math-functions # -# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2020 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,25 +19,26 @@ %global pkg_name math-functions %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.3.3.0 +Version: 0.3.4.0 Release: 0 Summary: Collection of tools for numeric computations License: BSD-2-Clause URL: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz +Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal#/%{pkg_name}.cabal BuildRequires: ghc-Cabal-devel BuildRequires: ghc-data-default-class-devel BuildRequires: ghc-deepseq-devel BuildRequires: ghc-primitive-devel BuildRequires: ghc-rpm-macros BuildRequires: ghc-vector-devel -BuildRequires: ghc-vector-th-unbox-devel %if %{with tests} BuildRequires: ghc-QuickCheck-devel BuildRequires: ghc-erf-devel BuildRequires: ghc-tasty-devel BuildRequires: ghc-tasty-hunit-devel BuildRequires: ghc-tasty-quickcheck-devel +BuildRequires: ghc-vector-th-unbox-devel %endif %description @@ -58,6 +59,7 @@ %prep %setup -q -n %{pkg_name}-%{version} +cp -p %{SOURCE1} %{pkg_name}.cabal %build %ghc_lib_build ++++++ math-functions-0.3.3.0.tar.gz -> math-functions-0.3.4.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/math-functions-0.3.3.0/Numeric/SpecFunctions/Internal.hs new/math-functions-0.3.4.0/Numeric/SpecFunctions/Internal.hs --- old/math-functions-0.3.3.0/Numeric/SpecFunctions/Internal.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/math-functions-0.3.4.0/Numeric/SpecFunctions/Internal.hs 2001-09-09 03:46:40.000000000 +0200 @@ -582,7 +582,7 @@ -- | Regularized incomplete beta function. -- -- \[ --- I(x;a,b) = \frac{1}{B(a,b)} \int_0^x t^{a-1}(1-t)^{1-b}\,dt +-- I(x;a,b) = \frac{1}{B(a,b)} \int_0^x t^{a-1}(1-t)^{b-1}\,dt -- \] -- -- Uses algorithm AS63 by Majumder and Bhattachrjee and quadrature diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/math-functions-0.3.3.0/Numeric/Sum.hs new/math-functions-0.3.4.0/Numeric/Sum.hs --- old/math-functions-0.3.3.0/Numeric/Sum.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/math-functions-0.3.4.0/Numeric/Sum.hs 2001-09-09 03:46:40.000000000 +0200 @@ -1,5 +1,5 @@ {-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleContexts, - MultiParamTypeClasses, TemplateHaskell, TypeFamilies, CPP #-} + MultiParamTypeClasses, TypeFamilies, CPP #-} {-# OPTIONS_GHC -fno-warn-name-shadowing #-} -- | -- Module : Numeric.Sum @@ -58,13 +58,14 @@ import Data.Semigroup (Semigroup(..)) #endif import Data.Vector.Generic (Vector(..), foldl') -import Data.Vector.Unboxed.Deriving (derivingUnbox) -- Needed for GHC 7.2 & 7.4 to derive Unbox instances +import Control.Monad (liftM) import Data.Vector.Generic.Mutable (MVector(..)) import qualified Data.Foldable as F import qualified Data.Vector as V import qualified Data.Vector.Generic as G +import qualified Data.Vector.Generic.Mutable as GM import qualified Data.Vector.Unboxed as U -- | A class for summation of floating point numbers. @@ -98,10 +99,53 @@ data KahanSum = KahanSum {-# UNPACK #-} !Double {-# UNPACK #-} !Double deriving (Eq, Show, Typeable, Data) -derivingUnbox "KahanSum" - [t| KahanSum -> (Double, Double) |] - [| \ (KahanSum a b) -> (a, b) |] - [| \ (a, b) -> KahanSum a b |] +instance U.Unbox KahanSum +newtype instance U.MVector s KahanSum = MV_KahanSum (U.MVector s (Double, Double)) +instance MVector U.MVector KahanSum where + {-# INLINE GM.basicLength #-} + {-# INLINE GM.basicUnsafeSlice #-} + {-# INLINE basicOverlaps #-} + {-# INLINE basicUnsafeNew #-} + {-# INLINE basicInitialize #-} + {-# INLINE basicUnsafeReplicate #-} + {-# INLINE basicUnsafeRead #-} + {-# INLINE basicUnsafeWrite #-} + {-# INLINE basicClear #-} + {-# INLINE basicSet #-} + {-# INLINE GM.basicUnsafeCopy #-} + {-# INLINE basicUnsafeMove #-} + {-# INLINE basicUnsafeGrow #-} + basicLength (MV_KahanSum mvec) = GM.basicLength mvec + basicUnsafeSlice idx len (MV_KahanSum mvec) = MV_KahanSum (GM.basicUnsafeSlice idx len mvec) + basicOverlaps (MV_KahanSum mvec) (MV_KahanSum mvec') = basicOverlaps mvec mvec' + basicUnsafeNew len = MV_KahanSum `liftM` basicUnsafeNew len + basicInitialize (MV_KahanSum mvec) = basicInitialize mvec + basicUnsafeReplicate len val = MV_KahanSum `liftM` basicUnsafeReplicate len ((\ (KahanSum a b) -> (a, b)) val) + basicUnsafeRead (MV_KahanSum mvec) idx = (\ (a, b) -> KahanSum a b) `liftM` basicUnsafeRead mvec idx + basicUnsafeWrite (MV_KahanSum mvec) idx val = basicUnsafeWrite mvec idx ((\ (KahanSum a b) -> (a, b)) val) + basicClear (MV_KahanSum mvec) = basicClear mvec + basicSet (MV_KahanSum mvec) val = basicSet mvec ((\ (KahanSum a b) -> (a, b)) val) + basicUnsafeCopy (MV_KahanSum mvec) (MV_KahanSum mvec') = GM.basicUnsafeCopy mvec mvec' + basicUnsafeMove (MV_KahanSum mvec) (MV_KahanSum mvec') = basicUnsafeMove mvec mvec' + basicUnsafeGrow (MV_KahanSum mvec) len = MV_KahanSum `liftM` basicUnsafeGrow mvec len + +newtype instance U.Vector KahanSum = V_KahanSum (U.Vector (Double, Double)) +instance Vector U.Vector KahanSum where + {-# INLINE basicUnsafeFreeze #-} + {-# INLINE basicUnsafeThaw #-} + {-# INLINE G.basicLength #-} + {-# INLINE G.basicUnsafeSlice #-} + {-# INLINE basicUnsafeIndexM #-} + {-# INLINE G.basicUnsafeCopy #-} + {-# INLINE elemseq #-} + basicUnsafeFreeze (MV_KahanSum mvec) = V_KahanSum `liftM` basicUnsafeFreeze mvec + basicUnsafeThaw (V_KahanSum vec) = MV_KahanSum `liftM` basicUnsafeThaw vec + basicLength (V_KahanSum vec) = G.basicLength vec + basicUnsafeSlice idx len (V_KahanSum vec) = V_KahanSum (G.basicUnsafeSlice idx len vec) + basicUnsafeIndexM (V_KahanSum vec) idx = (\ (a, b) -> KahanSum a b) `liftM` basicUnsafeIndexM vec idx + basicUnsafeCopy (MV_KahanSum mvec) (V_KahanSum vec) = G.basicUnsafeCopy mvec vec + elemseq (V_KahanSum vec) val = elemseq vec ((\ (KahanSum a b) -> (a, b)) val) + instance Summation KahanSum where zero = KahanSum 0 0 @@ -137,10 +181,53 @@ data KBNSum = KBNSum {-# UNPACK #-} !Double {-# UNPACK #-} !Double deriving (Eq, Show, Typeable, Data) -derivingUnbox "KBNSum" - [t| KBNSum -> (Double, Double) |] - [| \ (KBNSum a b) -> (a, b) |] - [| \ (a, b) -> KBNSum a b |] +instance U.Unbox KBNSum +newtype instance U.MVector s KBNSum = MV_KBNSum (U.MVector s (Double, Double)) +instance MVector U.MVector KBNSum where + {-# INLINE GM.basicLength #-} + {-# INLINE GM.basicUnsafeSlice #-} + {-# INLINE basicOverlaps #-} + {-# INLINE basicUnsafeNew #-} + {-# INLINE basicInitialize #-} + {-# INLINE basicUnsafeReplicate #-} + {-# INLINE basicUnsafeRead #-} + {-# INLINE basicUnsafeWrite #-} + {-# INLINE basicClear #-} + {-# INLINE basicSet #-} + {-# INLINE GM.basicUnsafeCopy #-} + {-# INLINE basicUnsafeMove #-} + {-# INLINE basicUnsafeGrow #-} + basicLength (MV_KBNSum mvec) = GM.basicLength mvec + basicUnsafeSlice idx len (MV_KBNSum mvec) = MV_KBNSum (GM.basicUnsafeSlice idx len mvec) + basicOverlaps (MV_KBNSum mvec) (MV_KBNSum mvec') = basicOverlaps mvec mvec' + basicUnsafeNew len = MV_KBNSum `liftM` basicUnsafeNew len + basicInitialize (MV_KBNSum mvec) = basicInitialize mvec + basicUnsafeReplicate len val = MV_KBNSum `liftM` basicUnsafeReplicate len ((\ (KBNSum a b) -> (a, b)) val) + basicUnsafeRead (MV_KBNSum mvec) idx = (\ (a, b) -> KBNSum a b) `liftM` basicUnsafeRead mvec idx + basicUnsafeWrite (MV_KBNSum mvec) idx val = basicUnsafeWrite mvec idx ((\ (KBNSum a b) -> (a, b)) val) + basicClear (MV_KBNSum mvec) = basicClear mvec + basicSet (MV_KBNSum mvec) val = basicSet mvec ((\ (KBNSum a b) -> (a, b)) val) + basicUnsafeCopy (MV_KBNSum mvec) (MV_KBNSum mvec') = GM.basicUnsafeCopy mvec mvec' + basicUnsafeMove (MV_KBNSum mvec) (MV_KBNSum mvec') = basicUnsafeMove mvec mvec' + basicUnsafeGrow (MV_KBNSum mvec) len = MV_KBNSum `liftM` basicUnsafeGrow mvec len + +newtype instance U.Vector KBNSum = V_KBNSum (U.Vector (Double, Double)) +instance Vector U.Vector KBNSum where + {-# INLINE basicUnsafeFreeze #-} + {-# INLINE basicUnsafeThaw #-} + {-# INLINE G.basicLength #-} + {-# INLINE G.basicUnsafeSlice #-} + {-# INLINE basicUnsafeIndexM #-} + {-# INLINE G.basicUnsafeCopy #-} + {-# INLINE elemseq #-} + basicUnsafeFreeze (MV_KBNSum mvec) = V_KBNSum `liftM` basicUnsafeFreeze mvec + basicUnsafeThaw (V_KBNSum vec) = MV_KBNSum `liftM` basicUnsafeThaw vec + basicLength (V_KBNSum vec) = G.basicLength vec + basicUnsafeSlice idx len (V_KBNSum vec) = V_KBNSum (G.basicUnsafeSlice idx len vec) + basicUnsafeIndexM (V_KBNSum vec) idx = (\ (a, b) -> KBNSum a b) `liftM` basicUnsafeIndexM vec idx + basicUnsafeCopy (MV_KBNSum mvec) (V_KBNSum vec) = G.basicUnsafeCopy mvec vec + elemseq (V_KBNSum vec) val = elemseq vec ((\ (KBNSum a b) -> (a, b)) val) + instance Summation KBNSum where zero = KBNSum 0 0 @@ -183,10 +270,52 @@ {-# UNPACK #-} !Double deriving (Eq, Show, Typeable, Data) -derivingUnbox "KB2Sum" - [t| KB2Sum -> (Double, Double, Double) |] - [| \ (KB2Sum a b c) -> (a, b, c) |] - [| \ (a, b, c) -> KB2Sum a b c |] +instance U.Unbox KB2Sum +newtype instance U.MVector s KB2Sum = MV_KB2Sum (U.MVector s (Double, Double, Double)) +instance MVector U.MVector KB2Sum where + {-# INLINE GM.basicLength #-} + {-# INLINE GM.basicUnsafeSlice #-} + {-# INLINE basicOverlaps #-} + {-# INLINE basicUnsafeNew #-} + {-# INLINE basicInitialize #-} + {-# INLINE basicUnsafeReplicate #-} + {-# INLINE basicUnsafeRead #-} + {-# INLINE basicUnsafeWrite #-} + {-# INLINE basicClear #-} + {-# INLINE basicSet #-} + {-# INLINE GM.basicUnsafeCopy #-} + {-# INLINE basicUnsafeMove #-} + {-# INLINE basicUnsafeGrow #-} + basicLength (MV_KB2Sum mvec) = GM.basicLength mvec + basicUnsafeSlice idx len (MV_KB2Sum mvec) = MV_KB2Sum (GM.basicUnsafeSlice idx len mvec) + basicOverlaps (MV_KB2Sum mvec) (MV_KB2Sum mvec') = basicOverlaps mvec mvec' + basicUnsafeNew len = MV_KB2Sum `liftM` basicUnsafeNew len + basicInitialize (MV_KB2Sum mvec) = basicInitialize mvec + basicUnsafeReplicate len val = MV_KB2Sum `liftM` basicUnsafeReplicate len ((\ (KB2Sum a b c) -> (a, b, c)) val) + basicUnsafeRead (MV_KB2Sum mvec) idx = (\ (a, b, c) -> KB2Sum a b c) `liftM` basicUnsafeRead mvec idx + basicUnsafeWrite (MV_KB2Sum mvec) idx val = basicUnsafeWrite mvec idx ((\ (KB2Sum a b c) -> (a, b, c)) val) + basicClear (MV_KB2Sum mvec) = basicClear mvec + basicSet (MV_KB2Sum mvec) val = basicSet mvec ((\ (KB2Sum a b c) -> (a, b, c)) val) + basicUnsafeCopy (MV_KB2Sum mvec) (MV_KB2Sum mvec') = GM.basicUnsafeCopy mvec mvec' + basicUnsafeMove (MV_KB2Sum mvec) (MV_KB2Sum mvec') = basicUnsafeMove mvec mvec' + basicUnsafeGrow (MV_KB2Sum mvec) len = MV_KB2Sum `liftM` basicUnsafeGrow mvec len + +newtype instance U.Vector KB2Sum = V_KB2Sum (U.Vector (Double, Double, Double)) +instance Vector U.Vector KB2Sum where + {-# INLINE basicUnsafeFreeze #-} + {-# INLINE basicUnsafeThaw #-} + {-# INLINE G.basicLength #-} + {-# INLINE G.basicUnsafeSlice #-} + {-# INLINE basicUnsafeIndexM #-} + {-# INLINE G.basicUnsafeCopy #-} + {-# INLINE elemseq #-} + basicUnsafeFreeze (MV_KB2Sum mvec) = V_KB2Sum `liftM` basicUnsafeFreeze mvec + basicUnsafeThaw (V_KB2Sum vec) = MV_KB2Sum `liftM` basicUnsafeThaw vec + basicLength (V_KB2Sum vec) = G.basicLength vec + basicUnsafeSlice idx len (V_KB2Sum vec) = V_KB2Sum (G.basicUnsafeSlice idx len vec) + basicUnsafeIndexM (V_KB2Sum vec) idx = (\ (a, b, c) -> KB2Sum a b c) `liftM` basicUnsafeIndexM vec idx + basicUnsafeCopy (MV_KB2Sum mvec) (V_KB2Sum vec) = G.basicUnsafeCopy mvec vec + elemseq (V_KB2Sum vec) val = elemseq vec ((\ (KB2Sum a b c) -> (a, b, c)) val) instance Summation KB2Sum where zero = KB2Sum 0 0 0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/math-functions-0.3.3.0/changelog.md new/math-functions-0.3.4.0/changelog.md --- old/math-functions-0.3.3.0/changelog.md 2001-09-09 03:46:40.000000000 +0200 +++ new/math-functions-0.3.4.0/changelog.md 2001-09-09 03:46:40.000000000 +0200 @@ -1,3 +1,8 @@ +## Changes in 0.3.4.0 + + * Dependency on `vector-th-unbox` is dropped. All instances are written by + hand now. + ## Changes in 0.3.3.0 * New implementation for `logGamma`. Now it's precise within 2 ulps at full diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/math-functions-0.3.3.0/math-functions.cabal new/math-functions-0.3.4.0/math-functions.cabal --- old/math-functions-0.3.3.0/math-functions.cabal 2001-09-09 03:46:40.000000000 +0200 +++ new/math-functions-0.3.4.0/math-functions.cabal 2001-09-09 03:46:40.000000000 +0200 @@ -1,5 +1,5 @@ name: math-functions -version: 0.3.3.0 +version: 0.3.4.0 cabal-version: >= 1.10 license: BSD2 license-file: LICENSE @@ -28,6 +28,8 @@ || ==8.2.2 || ==8.4.4 || ==8.6.5 + || ==8.8.3 + || ==8.10.1 , GHCJS ==8.4 extra-source-files: @@ -65,7 +67,6 @@ FlexibleContexts MultiParamTypeClasses ScopedTypeVariables - TemplateHaskell TypeFamilies DeriveGeneric @@ -75,7 +76,6 @@ , data-default-class >= 0.1.2.0 , vector >= 0.7 , primitive - , vector-th-unbox >= 0.2.1.6 if flag(system-expm1) && !os(windows) cpp-options: -DUSE_SYSTEM_EXPM1 if flag(system-erf) && !impl(ghcjs) ++++++ math-functions.cabal ++++++ name: math-functions version: 0.3.4.0 x-revision: 1 cabal-version: >= 1.10 license: BSD2 license-file: LICENSE author: Bryan O'Sullivan <[email protected]>, Alexey Khudyakov <[email protected]> maintainer: Alexey Khudyakov <[email protected]> homepage: https://github.com/bos/math-functions bug-reports: https://github.com/bos/math-functions/issues category: Math, Numeric build-type: Simple synopsis: Collection of tools for numeric computations description: This library contain collection of various utilities for numerical computing. So far there're special mathematical functions, compensated summation algorithm, summation of series, root finding for real functions, polynomial summation and Chebyshev polynomials. tested-with: GHC ==7.4.2 || ==7.6.3 || ==7.8.4 || ==7.10.3 || ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.3 || ==8.10.1 , GHCJS ==8.4 extra-source-files: changelog.md README.markdown tests/Tests/SpecFunctions/gen.py tests/tables/generate.py tests/tables/shell.nix tests/tables/*.dat tests/tables/inputs/*.dat doc/sinc.hs flag system-expm1 description: Use expm1 provided by system. For GHC newer that 8.0, GHCJS, and on Windows has no effect. GHC>=8.0 provides expm1 so it's used. On GHCJS and on Windows we don't have C implementation so bundled one is used instead. default: True manual: True flag system-erf description: Use erf and erfc provided by system. On GHCJS version provided by library is used regardless of flag for that lack of libc. default: True manual: True library default-language: Haskell2010 other-extensions: BangPatterns CPP DeriveDataTypeable FlexibleContexts MultiParamTypeClasses ScopedTypeVariables TypeFamilies DeriveGeneric ghc-options: -Wall -O2 build-depends: base >= 4.5 && < 5 , deepseq , data-default-class >= 0.1.2.0 , vector >= 0.11 , primitive if flag(system-expm1) && !os(windows) cpp-options: -DUSE_SYSTEM_EXPM1 if flag(system-erf) && !impl(ghcjs) cpp-options: -DUSE_SYSTEM_ERF exposed-modules: Numeric.MathFunctions.Constants Numeric.MathFunctions.Comparison Numeric.Polynomial Numeric.Polynomial.Chebyshev Numeric.RootFinding Numeric.SpecFunctions Numeric.SpecFunctions.Extra Numeric.SpecFunctions.Internal Numeric.Series Numeric.Sum other-modules: Numeric.SpecFunctions.Compat test-suite tests default-language: Haskell2010 other-extensions: ViewPatterns type: exitcode-stdio-1.0 ghc-options: -Wall -threaded if arch(i386) -- The Sum tests require SSE2 on i686 to pass (because of excess precision) ghc-options: -msse2 hs-source-dirs: tests main-is: tests.hs other-modules: Tests.Helpers Tests.Chebyshev Tests.Comparison Tests.RootFinding Tests.SpecFunctions Tests.SpecFunctions.Tables Tests.Sum if flag(system-erf) && !impl(ghcjs) cpp-options: -DUSE_SYSTEM_ERF build-depends: base >=4.5 && <5 , math-functions , data-default-class >= 0.1.2.0 , deepseq , primitive , vector >= 0.7 , vector-th-unbox , erf , QuickCheck >= 2.7 , tasty >= 1.2 , tasty-hunit >= 0.10 , tasty-quickcheck >= 0.10 source-repository head type: git location: https://github.com/bos/math-functions
