Bryan O'Sullivan avatar Bryan O'Sullivan committed dbff92e

Add GHC generics support everywhere

Comments (0)

Files changed (20)

Statistics/Distribution/Beta.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Statistics.Distribution.Beta
   , bdBeta
   ) where
 
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.SpecFunctions           (incompleteBeta, invIncompleteBeta, logBeta)
 import Numeric.MathFunctions.Constants (m_NaN)
 import qualified Statistics.Distribution as D
-import Data.Typeable
 
 -- | The beta distribution
 data BetaDistribution = BD
    -- ^ Alpha shape parameter
  , bdBeta  :: {-# UNPACK #-} !Double
    -- ^ Beta shape parameter
- } deriving (Eq,Read,Show,Typeable)
+ } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | Create beta distribution. Both shape parameters must be positive.
 betaDistr :: Double             -- ^ Shape parameter alpha

Statistics/Distribution/Binomial.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Binomial
 -- Copyright : (c) 2009 Bryan O'Sullivan
     , bdProbability
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 import Numeric.SpecFunctions (choose)
 
     -- ^ Number of trials.
     , bdProbability :: {-# UNPACK #-} !Double
     -- ^ Probability.
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution BinomialDistribution where
     cumulative = cumulative
 
 -- This could be slow for big n
 probability :: BinomialDistribution -> Int -> Double
-probability (BD n p) k 
+probability (BD n p) k
   | k < 0 || k > n = 0
   | n == 0         = 1
   | otherwise      = choose n k * p^k * (1-p)^(n-k)
 binomial :: Int                 -- ^ Number of trials.
          -> Double              -- ^ Probability.
          -> BinomialDistribution
-binomial n p 
+binomial n p
   | n < 0          =
     error $ msg ++ "number of trials must be non-negative. Got " ++ show n
-  | p < 0 || p > 1 = 
+  | p < 0 || p > 1 =
     error $ msg++"probability must be in [0,1] range. Got " ++ show p
   | otherwise      = BD n p
     where msg = "Statistics.Distribution.Binomial.binomial: "

Statistics/Distribution/CauchyLorentz.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.CauchyLorentz
 -- Copyright : (c) 2011 Aleksey Khudyakov
   , standardCauchy
   ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 
-
 -- | Cauchy-Lorentz distribution.
 data CauchyDistribution = CD {
     -- | Central value of Cauchy-Lorentz distribution which is its
     --   maximum (HWHM).
   , cauchyDistribScale  :: {-# UNPACK #-} !Double
   }
-  deriving (Eq,Show,Read,Typeable)
+  deriving (Eq, Show, Read, Typeable, Data, Generic)
 
 -- | Cauchy distribution
 cauchyDistribution :: Double    -- ^ Central point

Statistics/Distribution/ChiSquared.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.ChiSquared
 -- Copyright : (c) 2010 Alexey Khudyakov
         , chiSquaredNDF
         ) where
 
-import Data.Typeable         (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.SpecFunctions (incompleteGamma,invIncompleteGamma,logGamma)
 
 import qualified Statistics.Distribution         as D
 
 -- | Chi-squared distribution
 newtype ChiSquared = ChiSquared Int
-                     deriving (Show,Typeable)
+                     deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | Get number of degrees of freedom
 chiSquaredNDF :: ChiSquared -> Int
 --   must be positive.
 chiSquared :: Int -> ChiSquared
 chiSquared n
-  | n <= 0    = error $ 
+  | n <= 0    = error $
      "Statistics.Distribution.ChiSquared.chiSquared: N.D.F. must be positive. Got " ++ show n
   | otherwise = ChiSquared n
 {-# INLINE chiSquared #-}

Statistics/Distribution/Exponential.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Exponential
 -- Copyright : (c) 2009 Bryan O'Sullivan
     , edLambda
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution         as D
 import qualified Statistics.Sample               as S
 import qualified System.Random.MWC.Distributions as MWC
 
 newtype ExponentialDistribution = ED {
       edLambda :: Double
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution ExponentialDistribution where
     cumulative      = cumulative
 exponential :: Double            -- ^ &#955; (scale) parameter.
             -> ExponentialDistribution
 exponential l
-  | l <= 0 = 
+  | l <= 0 =
     error $ "Statistics.Distribution.Exponential.exponential: scale parameter must be positive. Got " ++ show l
   | otherwise = ED l
 {-# INLINE exponential #-}

Statistics/Distribution/FDistribution.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.FDistribution
 -- Copyright : (c) 2011 Aleksey Khudyakov
   , fDistributionNDF2
   ) where
 
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
-import Data.Typeable         (Typeable)
 import Numeric.SpecFunctions (logBeta, incompleteBeta, invIncompleteBeta)
 
 
                        , fDistributionNDF2 :: {-# UNPACK #-} !Double
                        , _pdfFactor        :: {-# UNPACK #-} !Double
                        }
-                   deriving (Eq,Show,Read,Typeable)
+                   deriving (Eq, Show, Read, Typeable, Data, Generic)
 
 
 fDistribution :: Int -> Int -> FDistribution
 fDistribution n m
-  | n > 0 && m > 0 = 
-    let n' = fromIntegral n  
+  | n > 0 && m > 0 =
+    let n' = fromIntegral n
         m' = fromIntegral m
         f' = 0.5 * (log m' * m' + log n' * n') - logBeta (0.5*n') (0.5*m')
     in F n' m' f'
     error "Statistics.Distribution.FDistribution.fDistribution: non-positive number of degrees of freedom"
 
 instance D.Distribution FDistribution where
-  cumulative = cumulative 
+  cumulative = cumulative
 
 instance D.ContDistr FDistribution where
   density  = density
   quantile = quantile
-  
+
 cumulative :: FDistribution -> Double -> Double
 cumulative (F n m _) x
   | x <= 0       = 0
 
 quantile :: FDistribution -> Double -> Double
 quantile (F n m _) p
-  | p >= 0 && p <= 1 = 
+  | p >= 0 && p <= 1 =
     let x = invIncompleteBeta (0.5 * n) (0.5 * m) p
     in m * x / (n * (1 - x))
   | otherwise =
                       | otherwise = Nothing
 
 instance D.MaybeVariance FDistribution where
-  maybeStdDev (F n m _) 
+  maybeStdDev (F n m _)
     | m > 4     = Just $ 2 * sqr m * (m + n - 2) / (n * sqr (m - 2) * (m - 4))
     | otherwise = Nothing
 

Statistics/Distribution/Gamma.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Gamma
 -- Copyright : (c) 2009, 2011 Bryan O'Sullivan
     , gdScale
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.MathFunctions.Constants (m_pos_inf, m_NaN)
 import Numeric.SpecFunctions           (incompleteGamma, invIncompleteGamma)
 import Statistics.Distribution.Poisson.Internal  as Poisson
 data GammaDistribution = GD {
       gdShape :: {-# UNPACK #-} !Double -- ^ Shape parameter, /k/.
     , gdScale :: {-# UNPACK #-} !Double -- ^ Scale parameter, &#977;.
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | Create gamma distribution. Both shape and scale parameters must
 -- be positive.

Statistics/Distribution/Geometric.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Geometric
 -- Copyright : (c) 2009 Bryan O'Sullivan
     , gdSuccess
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 
 newtype GeometricDistribution = GD {
       gdSuccess :: Double
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution GeometricDistribution where
     cumulative = cumulative

Statistics/Distribution/Hypergeometric.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Hypergeometric
 -- Copyright : (c) 2009 Bryan O'Sullivan
     , hdK
     ) where
 
-import Data.Typeable         (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.SpecFunctions (choose)
 import qualified Statistics.Distribution as D
 
       hdM :: {-# UNPACK #-} !Int
     , hdL :: {-# UNPACK #-} !Int
     , hdK :: {-# UNPACK #-} !Int
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution HypergeometricDistribution where
     cumulative = cumulative

Statistics/Distribution/Normal.hs

-{-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Normal
 -- Copyright : (c) 2009 Bryan O'Sullivan
     , standard
     ) where
 
-import Data.Typeable                   (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.MathFunctions.Constants (m_sqrt_2, m_sqrt_2_pi)
 import Numeric.SpecFunctions           (erfc, invErfc)
 import qualified Statistics.Distribution as D
     , stdDev     :: {-# UNPACK #-} !Double
     , ndPdfDenom :: {-# UNPACK #-} !Double
     , ndCdfDenom :: {-# UNPACK #-} !Double
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution NormalDistribution where
     cumulative      = cumulative

Statistics/Distribution/Poisson.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Poisson
 -- Copyright : (c) 2009, 2011 Bryan O'Sullivan
     -- $references
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 import qualified Statistics.Distribution.Poisson.Internal as I
 import Numeric.SpecFunctions (incompleteGamma)
 
 newtype PoissonDistribution = PD {
       poissonLambda :: Double
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance D.Distribution PoissonDistribution where
     cumulative (PD lambda) x

Statistics/Distribution/StudentT.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.StudentT
 -- Copyright : (c) 2011 Aleksey Khudyakov
   ) where
 
 
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 import Statistics.Distribution.Transform (LinearTransform (..))
-import Data.Typeable         (Typeable)
 import Numeric.SpecFunctions (logBeta, incompleteBeta, invIncompleteBeta)
 
 -- | Student-T distribution
 newtype StudentT = StudentT { studentTndf :: Double }
-                   deriving (Eq,Show,Read,Typeable)
+                   deriving (Eq, Show, Read, Typeable, Data, Generic)
 
 -- | Create Student-T distribution. Number of parameters must be positive.
 studentT :: Double -> StudentT
   | otherwise = modErr "studentT" "non-positive number of degrees of freedom"
 
 instance D.Distribution StudentT where
-  cumulative = cumulative 
+  cumulative = cumulative
 
 instance D.ContDistr StudentT where
   density  = density
   quantile = quantile
-  
+
 cumulative :: StudentT -> Double -> Double
 cumulative (StudentT ndf) x
   | x > 0     = 1 - 0.5 * ibeta
 
 quantile :: StudentT -> Double -> Double
 quantile (StudentT ndf) p
-  | p >= 0 && p <= 1 = 
+  | p >= 0 && p <= 1 =
     let x = invIncompleteBeta (0.5 * ndf) 0.5 (2 * min p (1 - p))
     in case sqrt $ ndf * (1 - x) / x of
          r | p < 0.5   -> -r
-           | otherwise -> r 
+           | otherwise -> r
   | otherwise = modErr "quantile" $ "p must be in [0,1] range. Got: "++show p
 
 

Statistics/Distribution/Transform.hs

-{-# LANGUAGE FlexibleInstances, UndecidableInstances, FlexibleContexts, DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, FlexibleContexts,
+    FlexibleInstances, UndecidableInstances #-}
 -- |
 -- Module    : Statistics.Distribution.Transform
 -- Copyright : (c) 2013 John McDonnell;
   , scaleAround
   ) where
 
-import Data.Typeable         (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Data.Functor          ((<$>))
 import qualified Statistics.Distribution as D
 
     -- | Scale parameter.
   , linTransDistr    :: d
     -- | Distribution being transformed.
-  } deriving (Eq,Show,Read,Typeable)
+  } deriving (Eq, Show, Read, Typeable, Data, Generic)
 
 -- | Apply linear transformation to distribution.
 scaleAround :: Double           -- ^ Fixed point
 
 instance D.ContDistr d => D.ContDistr (LinearTransform d) where
   density  (LinearTransform loc sc dist) x = D.density dist ((x-loc) / sc) / sc
-  quantile (LinearTransform loc sc dist) p = loc + sc * D.quantile dist p 
+  quantile (LinearTransform loc sc dist) p = loc + sc * D.quantile dist p
 
 instance D.MaybeMean d => D.MaybeMean (LinearTransform d) where
   maybeMean (LinearTransform loc _ dist) = (+loc) <$> D.maybeMean dist

Statistics/Distribution/Uniform.hs

-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
 -- |
 -- Module    : Statistics.Distribution.Uniform
 -- Copyright : (c) 2011 Aleksey Khudyakov
     , uniformB
     ) where
 
-import Data.Typeable (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import qualified Statistics.Distribution as D
 import qualified System.Random.MWC       as MWC
 
 data UniformDistribution = UniformDistribution {
       uniformA :: {-# UNPACK #-} !Double -- ^ Low boundary of distribution
     , uniformB :: {-# UNPACK #-} !Double -- ^ Upper boundary of distribution
-    } deriving (Eq, Read, Show, Typeable)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | Create uniform distribution.
 uniformDistr :: Double -> Double -> UniformDistribution
   | a < b     = UniformDistribution a b
   | otherwise = error "Statistics.Distribution.Uniform.uniform: wrong parameters"
 -- NOTE: failure is in default branch to guard againist NaNs.
-                
+
 instance D.Distribution UniformDistribution where
   cumulative (UniformDistribution a b) x
     | x < a     = 0

Statistics/Math/RootFinding.hs

-{-# LANGUAGE BangPatterns, DeriveDataTypeable #-}
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, DeriveGeneric #-}
 
 -- |
 -- Module    : Statistics.Math.RootFinding
 
 import Control.Applicative
 import Control.Monad       (MonadPlus(..), ap)
-import Data.Typeable       (Typeable)
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 
 
 -- | The result of searching for a root of a mathematical function.
             -- error tolerance after the given number of iterations.
             | Root a
             -- ^ A root was successfully found.
-              deriving (Eq, Read, Show, Typeable)
+              deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance Functor Root where
     fmap _ NotBracketed = NotBracketed

Statistics/Resampling.hs

-{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, DeriveGeneric #-}
 
 -- |
 -- Module    : Statistics.Resampling
 import Control.Concurrent (forkIO, newChan, readChan, writeChan)
 import Control.Monad (forM_, liftM, replicateM_)
 import Control.Monad.Primitive (PrimMonad, PrimState)
+import Data.Data (Data, Typeable)
 import Data.Vector.Algorithms.Intro (sort)
 import Data.Vector.Generic (unsafeFreeze)
 import Data.Word (Word32)
 import GHC.Conc (numCapabilities)
+import GHC.Generics (Generic)
 import Statistics.Function (indices)
 import Statistics.Types (Estimator, Sample)
 import System.Random.MWC (Gen, initialize, uniform, uniformVector)
 -- humble author's brain to go wrong.
 newtype Resample = Resample {
       fromResample :: U.Vector Double
-    } deriving (Eq, Show)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | /O(e*r*s)/ Resample a data set repeatedly, with replacement,
 -- computing each estimate over the resampled data.

Statistics/Resampling/Bootstrap.hs

-{-# LANGUAGE DeriveDataTypeable, OverloadedStrings, RecordWildCards #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, OverloadedStrings,
+    RecordWildCards #-}
 
 -- |
 -- Module    : Statistics.Resampling.Bootstrap
 import Data.Data (Data)
 import Data.Typeable (Typeable)
 import Data.Vector.Unboxed ((!))
+import GHC.Generics
 import Statistics.Distribution (cumulative, quantile)
 import Statistics.Distribution.Normal
 import Statistics.Resampling (Resample(..), jackknife)
     -- the confidence interval).
     , estConfidenceLevel :: {-# UNPACK #-} !Double
     -- ^ Confidence level of the confidence intervals.
-    } deriving (Eq, Show, Typeable, Data)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 instance NFData Estimate
 
   where
     e est (Resample resample)
       | U.length sample == 1 = estimate pt pt pt confidenceLevel
-      | otherwise = 
+      | otherwise =
           estimate pt (resample ! lo) (resample ! hi) confidenceLevel
       where
         pt    = est sample

Statistics/Sample/KernelDensity/Simple.hs

-{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, FlexibleContexts #-}
 -- |
 -- Module    : Statistics.Sample.KernelDensity.Simple
 -- Copyright : (c) 2009 Bryan O'Sullivan
     -- $references
     ) where
 
+import Data.Data (Data, Typeable)
+import GHC.Generics (Generic)
 import Numeric.MathFunctions.Constants (m_1_sqrt_2, m_2_sqrt_pi)
 import Statistics.Function (minMax)
 import Statistics.Sample   (stdDev)
 -- | Points from the range of a 'Sample'.
 newtype Points = Points {
       fromPoints :: U.Vector Double
-    } deriving (Eq, Show)
+    } deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | Bandwidth estimator for an Epanechnikov kernel.
 epanechnikovBW :: Double -> Bandwidth

Statistics/Sample/Powers.hs

-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE BangPatterns     #-}
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, DeriveGeneric,
+    FlexibleContexts #-}
 -- |
 -- Module    : Statistics.Sample.Powers
 -- Copyright : (c) 2009, 2010 Bryan O'Sullivan
     -- $references
     ) where
 
+import Data.Data (Data, Typeable)
 import Data.Vector.Generic   (unsafeFreeze)
 import Data.Vector.Unboxed   ((!))
+import GHC.Generics (Generic)
 import Prelude hiding (sum)
 import Statistics.Function   (indexed)
 import Statistics.Internal   (inlinePerformIO)
 import qualified Data.Vector.Unboxed.Mutable as MU
 
 newtype Powers = Powers (U.Vector Double)
-    deriving (Eq, Show)
+    deriving (Eq, Read, Show, Typeable, Data, Generic)
 
 -- | O(/n/) Collect the /n/ simple powers of a sample.
 --
 name:           statistics
-version:        0.10.3.0
+version:        0.10.4.0
 synopsis:       A library of statistical types, data, and functions
 description:
   This library provides a number of common functions and types useful
   * Common statistical tests for significant differences between
     samples.
   .
+  Changes in 0.10.4.0
+  .
+  * Support for versions of GHC older than 7.2 is discontinued.
+  .
+  * All datatypes support 'GHC.Generics'.
+  .
   Changes in 0.10.3.0
   .
   * Bug fixes
   * Modules 'Statistics.Math' and 'Statistics.Constants' are moved to
     the @math-functions@ package. They are still available but marked
     as deprecated.
-  .
-  Changed in 0.10.0.1
-  .
-  * @dct@ and @idct@ now have type @Vector Double -> Vector Double@
-  .
-  Changes in 0.10.0.0:
-  .
-  * The type classes @Mean@ and @Variance@ are split in two. This is
-    required for distributions which do not have finite variance or
-    mean.
-  .
-  * The @S.Sample.KernelDensity@ module has been renamed, and
-    completely rewritten to be much more robust.  The older module
-    oversmoothed multi-modal data.  (The older module is still
-    available under the name @S.Sample.KernelDensity.Simple@).
-  .
-  * Histogram computation is added, in @S.Sample.Histogram@.
-  .
-  * Forward and inverse discrete Fourier and cosine transforms are
-    added, in @S.Transform@.
-  .
-  * Root finding is added, in @S.Math.RootFinding@.
-  .
-  * The @complCumulative@ function is added to the @Distribution@
-    class in order to accurately assess probalities P(X>x) which are
-    used in one-tailed tests.
-  .
-  * A @stdDev@ function is added to the @Variance@ class for
-    distributions.
-  .
-  * The constructor @S.Distribution.normalDistr@ now takes standard
-    deviation instead of variance as its parameter.
-  .
-  * A bug in @S.Quantile.weightedAvg@ is fixed. It produced a wrong
-    answer if a sample contained only one element.
-  .
-  * Bugs in quantile estimations for chi-square and gamma distribution
-    are fixed.
-  .
-  * Integer overlow in @mannWhitneyUCriticalValue@ is fixed. It
-    produced incorrect critical values for moderately large
-    samples. Something around 20 for 32-bit machines and 40 for 64-bit
-    ones.
-  .
-  * A bug in @mannWhitneyUSignificant@ is fixed. If either sample was
-    larger than 20, it produced a completely incorrect answer.
-  .
-  * One- and two-tailed tests in @S.Tests.NonParametric@ are selected
-    with sum types instead of @Bool@.
-  .
-  * Test results returned as enumeration instead of @Bool@.
-  .
-  * Performance improvements for Mann-Whitney U and Wilcoxon tests.
-  .
-  * Module @S.Tests.NonParamtric@ is split into @S.Tests.MannWhitneyU@
-    and @S.Tests.WilcoxonT@
-  .
-  * @sortBy@ is added to @S.Function@.
-  .
-  * Mean and variance for gamma distribution are fixed.
-  .
-  * Much faster cumulative probablity functions for Poisson and
-    hypergeometric distributions.
-  .
-  * Better density functions for gamma and Poisson distributions.
-  .
-  * Student-T, Fisher-Snedecor F-distributions and Cauchy-Lorentz
-    distrbution are added.
-  .
-  * The function @S.Function.create@ is removed. Use @generateM@ from
-    the @vector@ package instead.
-  .
-  * Function to perform approximate comparion of doubles is added to
-    @S.Function.Comparison@
-  .
-  * Regularized incomplete beta function and its inverse are added to
-    @S.Function@.
 
 license:        BSD3
 license-file:   LICENSE
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.