packages feed

variable-precision 0.2.1 → 0.3.1

raw patch · 10 files changed

+250/−161 lines, 10 filesdep +complex-generic

Dependencies added: complex-generic

Files

Numeric/VariablePrecision.hs view
@@ -3,7 +3,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  portable
Numeric/VariablePrecision/Algorithms.hs view
@@ -4,7 +4,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  BangPatterns
Numeric/VariablePrecision/Aliases.hs view
@@ -3,7 +3,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  portable @@ -15,10 +15,15 @@ module Numeric.VariablePrecision.Aliases   ( toFloat, fromFloat, toDouble, fromDouble   , toComplexFloat, fromComplexFloat, toComplexDouble, fromComplexDouble+  , F, X, C, CF, CX   , F8, F16, F24, F32, F40, F48, F53   , f8, f16, f24, f32, f40, f48, f53-  , C8, C16, C24, C32, C40, C48, C53-  , c8, c16, c24, c32, c40, c48, c53+  , X8, X16, X24, X32, X40, X48, X53+  , x8, x16, x24, x32, x40, x48, x53+  , CF8, CF16, CF24, CF32, CF40, CF48, CF53+  , cf8, cf16, cf24, cf32, cf40, cf48, cf53+  , CX8, CX16, CX24, CX32, CX40, CX48, CX53+  , cx8, cx16, cx24, cx32, cx40, cx48, cx53   , module TypeLevel.NaturalNumber   , module TypeLevel.NaturalNumber.ExtraNumbers   ) where@@ -28,10 +33,11 @@   (N16, n16, N24, n24, N32, n32, N40, n40, N48, n48, N53, n53)  import Numeric.VariablePrecision.Float (VFloat)+import Numeric.VariablePrecision.Fixed (VFixed) import Numeric.VariablePrecision.Complex (VComplex, recodeComplex, toComplex, fromComplex) import Numeric.VariablePrecision.Algorithms (recodeFloat) -import Data.Complex (Complex)+import Data.Complex.Generic (Complex)  -- | Convert to a Float from the same precision. toFloat :: F24 -> Float@@ -50,33 +56,55 @@ fromDouble = recodeFloat  -- | Convert to a Float from the same precision.-toComplexFloat :: C24 -> Complex Float+toComplexFloat :: CF24 -> Complex Float toComplexFloat = recodeComplex . toComplex  -- | Convert from a Float to the same precision.-fromComplexFloat :: Complex Float -> C24+fromComplexFloat :: Complex Float -> CF24 fromComplexFloat = fromComplex . recodeComplex  -- | Convert to a Double from the same precision.-toComplexDouble :: C53 -> Complex Double+toComplexDouble :: CF53 -> Complex Double toComplexDouble = recodeComplex . toComplex  -- | Convert from a Double to the same precision.-fromComplexDouble :: Complex Double -> C53+fromComplexDouble :: Complex Double -> CF53 fromComplexDouble = fromComplex . recodeComplex -type F8  = VFloat N8  ; f8  :: F8  ; f8  = 0-type F16 = VFloat N16 ; f16 :: F16 ; f16 = 0-type F24 = VFloat N24 ; f24 :: F24 ; f24 = 0-type F32 = VFloat N32 ; f32 :: F32 ; f32 = 0-type F40 = VFloat N40 ; f40 :: F40 ; f40 = 0-type F48 = VFloat N48 ; f48 :: F48 ; f48 = 0-type F53 = VFloat N53 ; f53 :: F53 ; f53 = 0+type F = VFloat+type X = VFixed+type C = VComplex+type CF = C F+type CX = C X -type C8  = VComplex N8  ; c8  :: C8  ; c8  = 0-type C16 = VComplex N16 ; c16 :: C16 ; c16 = 0-type C24 = VComplex N24 ; c24 :: C24 ; c24 = 0-type C32 = VComplex N32 ; c32 :: C32 ; c32 = 0-type C40 = VComplex N40 ; c40 :: C40 ; c40 = 0-type C48 = VComplex N48 ; c48 :: C48 ; c48 = 0-type C53 = VComplex N53 ; c53 :: C53 ; c53 = 0+type F8  = F N8  ; f8  :: F8  ; f8  = 0+type F16 = F N16 ; f16 :: F16 ; f16 = 0+type F24 = F N24 ; f24 :: F24 ; f24 = 0+type F32 = F N32 ; f32 :: F32 ; f32 = 0+type F40 = F N40 ; f40 :: F40 ; f40 = 0+type F48 = F N48 ; f48 :: F48 ; f48 = 0+type F53 = F N53 ; f53 :: F53 ; f53 = 0++type X8  = X N8  ; x8  :: X8  ; x8  = 0+type X16 = X N16 ; x16 :: X16 ; x16 = 0+type X24 = X N24 ; x24 :: X24 ; x24 = 0+type X32 = X N32 ; x32 :: X32 ; x32 = 0+type X40 = X N40 ; x40 :: X40 ; x40 = 0+type X48 = X N48 ; x48 :: X48 ; x48 = 0+type X53 = X N53 ; x53 :: X53 ; x53 = 0++type CF8  = CF N8  ; cf8  :: CF8  ; cf8  = 0+type CF16 = CF N16 ; cf16 :: CF16 ; cf16 = 0+type CF24 = CF N24 ; cf24 :: CF24 ; cf24 = 0+type CF32 = CF N32 ; cf32 :: CF32 ; cf32 = 0+type CF40 = CF N40 ; cf40 :: CF40 ; cf40 = 0+type CF48 = CF N48 ; cf48 :: CF48 ; cf48 = 0+type CF53 = CF N53 ; cf53 :: CF53 ; cf53 = 0++type CX8  = CX N8  ; cx8  :: CX8  ; cx8  = 0+type CX16 = CX N16 ; cx16 :: CX16 ; cx16 = 0+type CX24 = CX N24 ; cx24 :: CX24 ; cx24 = 0+type CX32 = CX N32 ; cx32 :: CX32 ; cx32 = 0+type CX40 = CX N40 ; cx40 :: CX40 ; cx40 = 0+type CX48 = CX N48 ; cx48 :: CX48 ; cx48 = 0+type CX53 = CX N53 ; cx53 :: CX53 ; cx53 = 0
Numeric/VariablePrecision/Complex.hs view
@@ -1,188 +1,245 @@-{-# LANGUAGE DeriveDataTypeable, GeneralizedNewtypeDeriving, Rank2Types #-}+{-# LANGUAGE DeriveDataTypeable, GeneralizedNewtypeDeriving, StandaloneDeriving, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, Rank2Types, UndecidableInstances #-} {- | Module      :  Numeric.VariablePrecision.Complex Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable-Portability :  DeriveDataTypeable, GeneralizedNewtypeDeriving, Rank2Types+Portability :  DeriveDataTypeable, GeneralizedNewtypeDeriving, StandaloneDeriving, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, Rank2Types, UndecidableInstances -Newtype wrapper around 'Data.Complex'.  When both of 'Data.Complex' and-this module need to be imported, use qualified imports.+Complex numbers with variable precision.  -} module Numeric.VariablePrecision.Complex-  ( VComplex()-  , (.+)-  , (.*)-  , (*.)+  ( module Data.Complex.Generic+  , VComplex()   , toComplex   , fromComplex   , withComplex-  , mapComplex   , recodeComplex   , scaleComplex-  , realPart-  , imagPart-  , conjugate-  , magnitude-  , magnitude2-  , sqr-  , phase-  , polar-  , cis-  , mkPolar-  , scaleComplex'-  , magnitude2'-  , sqr'-  , DComplex(..)-  , toDComplex-  , fromDComplex-  , withDComplex+  , scaleVComplex+  , toComplexDFloat+  , toComplexDFixed+  , fromComplexDFloat+  , fromComplexDFixed+  , withComplexDFloat+  , withComplexDFixed   ) where -import Data.Data (Data())-import Data.Typeable (Typeable())-import qualified Data.Complex as X+import Data.Complex.Generic+import Data.Complex.Generic.Default +import Numeric.VariablePrecision.Fixed import Numeric.VariablePrecision.Float import Numeric.VariablePrecision.Precision import Numeric.VariablePrecision.Algorithms (recodeFloat) --- | Newtype wrapper around 'X.Complex' so that instances can be written+-- | Newtype wrapper around 'Complex' so that instances can be written --   for 'HasPrecision' and 'VariablePrecision'.-newtype VComplex p = FromComplex-  { -- | Convert 'VComplex' to 'X.Complex'.-    toComplex :: X.Complex (VFloat p)+newtype VComplex t p = FromComplex+  { -- | Convert 'VComplex' to 'Complex'.+    toComplex :: Complex (t p)   }-  deriving (Eq, Num, Fractional, Floating, Data, Typeable)+  deriving (Eq) --- | Convert 'X.Complex' to 'VComplex'.-fromComplex :: X.Complex (VFloat p) -> VComplex p+deriving instance Num (Complex (t p)) => Num (VComplex t p)+deriving instance Fractional (Complex (t p)) => Fractional (VComplex t p)+deriving instance Floating (Complex (t p)) => Floating (VComplex t p)++-- | Convert 'Complex' to 'VComplex'.+fromComplex :: Complex (t p) -> VComplex t p fromComplex = FromComplex --- | Alike to 'X.:+', constructs a complex number from a real part and---   an imaginary part.-(.+) :: NaturalNumber p => VFloat p -> VFloat p -> VComplex p-x .+ y = fromComplex (x X.:+ y)-infix 6 .++instance NaturalNumber p => Num (Complex (VFloat p)) where+  (+) = addDefault+  (-) = subDefault+  (*) = mulDefault+  negate = negateDefault+  fromInteger = fromIntegerDefault+  abs = absDefault+  signum = signumDefault -instance HasPrecision VComplex+instance NaturalNumber p => Num (Complex (VFixed p)) where+  (+) = addDefault+  (-) = subDefault+  (*) = mulDefault+  negate = negateDefault+  fromInteger = fromIntegerDefault+  abs = error "Num.abs: unimplemented for Complex VFixed"+  signum = error "Num.signum: unimplemented for Complex VFixed" -instance VariablePrecision VComplex where-  adjustPrecision = withComplex (mapComplex adjustPrecision)+instance NaturalNumber p => Fractional (Complex (VFloat p)) where+  (/) = divDefaultRF+  fromRational = fromRationalDefault -instance Normed VComplex where-  norm1 z = abs (realPart z) + abs (imagPart z)-  norm2 = magnitude-  norm2Squared = magnitude2-  normInfinity z = abs (realPart z) `max` abs (imagPart z)+instance NaturalNumber p => Fractional (Complex (VFixed p)) where+  (/) = divDefault+  fromRational = fromRationalDefault --- | Lift an operation on 'X.Complex' to one on 'VComplex'.-withComplex :: (X.Complex (VFloat p) -> X.Complex (VFloat q)) -> (VComplex p -> VComplex q)-withComplex f = fromComplex . f . toComplex+instance NaturalNumber p => Floating (Complex (VFloat p)) where+  pi = piDefault+  exp = expDefault+  log = logDefault+  sqrt = sqrtDefault+  sin = sinDefault+  cos = cosDefault+  tan = tanDefault+  sinh = sinhDefault+  cosh = coshDefault+  tanh = tanhDefault+  asin = asinDefault+  acos = acosDefault+  atan = atanDefault+  asinh = asinhDefault+  acosh = acoshDefault+  atanh = atanhDefault -instance NaturalNumber p => Show (VComplex p) where-  showsPrec p = showsPrec p . toComplex+instance NaturalNumber p => ComplexRect (Complex (VFloat p)) (VFloat p) where+  mkRect x y = (x :+ y)+  rect (x :+ y) = (x, y)+  real = realDefault+  imag = imagDefault+  realPart = realPartDefault+  imagPart = imagPartDefault+  conjugate = conjugateDefault+  magnitudeSquared = magnitudeSquaredDefault+  sqr = sqrDefaultRF+  (.*) = rmulDefault+  (*.) = mulrDefault -instance NaturalNumber p => Read (VComplex p) where-  readsPrec p = map (first fromComplex) . readsPrec p-    where first f (a, b) = (f a, b)+instance NaturalNumber p => ComplexRect (Complex (VFixed p)) (VFixed p) where+  mkRect x y = (x :+ y)+  rect (x :+ y) = (x, y)+  real = realDefault+  imag = imagDefault+  realPart = realPartDefault+  imagPart = imagPartDefault+  conjugate = conjugateDefault+  magnitudeSquared = magnitudeSquaredDefault+  sqr = sqrDefault -- FIXME+  (.*) = rmulDefault+  (*.) = mulrDefault --- | Unit at phase.-cis :: NaturalNumber p => VFloat p -> VComplex p-cis = fromComplex . X.cis+instance NaturalNumber p => ComplexPolar (Complex (VFloat p)) (VFloat p) where+  mkPolar = mkPolarDefault+  cis = cisDefault+  polar = polarDefault+  magnitude = magnitudeDefaultRF+  phase = phaseDefaultRF --- | From polar form.-mkPolar :: NaturalNumber p => VFloat p -> VFloat p -> VComplex p-mkPolar r t = fromComplex (X.mkPolar r t)+instance NaturalNumber p => ComplexRect (VComplex VFloat p) (VFloat p) where+  mkRect x y = FromComplex (x :+ y)+  rect = rect . toComplex+  real = realDefault+  imag = imagDefault+  realPart = realPartDefault+  imagPart = imagPartDefault+  conjugate = conjugateDefault+  magnitudeSquared = magnitudeSquaredDefault+  sqr = sqrDefaultRF+  (.*) = rmulDefault+  (*.) = mulrDefault --- | Conjugate.-conjugate :: NaturalNumber p => VComplex p -> VComplex p-conjugate = withComplex X.conjugate+instance NaturalNumber p => ComplexRect (VComplex VFixed p) (VFixed p) where+  mkRect x y = FromComplex (x :+ y)+  rect = rect . toComplex+  real = realDefault+  imag = imagDefault+  realPart = realPartDefault+  imagPart = imagPartDefault+  conjugate = conjugateDefault+  magnitudeSquared = magnitudeSquaredDefault+  sqr = sqrDefault -- FIXME+  (.*) = rmulDefault+  (*.) = mulrDefault --- | Imaginary part.-imagPart :: NaturalNumber p => VComplex p -> VFloat p-imagPart = X.imagPart . toComplex+instance NaturalNumber p => ComplexPolar (VComplex VFloat p) (VFloat p) where+  mkPolar = mkPolarDefault+  cis = cisDefault+  polar = polarDefault+  magnitude = magnitudeDefaultRF+  phase = phaseDefaultRF --- | Real part.-realPart :: NaturalNumber p => VComplex p -> VFloat p-realPart = X.realPart . toComplex+instance HasPrecision (VComplex VFloat) --- | Phase.-phase :: NaturalNumber p => VComplex p -> VFloat p-phase = X.phase . toComplex+instance HasPrecision (VComplex VFixed) --- | Polar form.-polar :: NaturalNumber p => VComplex p -> (VFloat p, VFloat p)-polar = X.polar . toComplex+instance VariablePrecision (VComplex VFloat) where+  adjustPrecision = withComplex (fmap adjustPrecision) --- | Magnitude.-magnitude :: NaturalNumber p => VComplex p -> VFloat p-magnitude = X.magnitude . toComplex+instance VariablePrecision (VComplex VFixed) where+  adjustPrecision = withComplex (fmap adjustPrecision) --- | Magnitude squared.-magnitude2 :: NaturalNumber p => VComplex p -> VFloat p-magnitude2 = magnitude2' . toComplex+instance Normed (VComplex VFloat) where+  norm1 z = abs (realPart z) + abs (imagPart z)+  norm2 = magnitude+  norm2Squared = magnitudeSquared+  normInfinity z = abs (realPart z) `max` abs (imagPart z) --- | Apply a function to both components of a complex number.-mapComplex :: (RealFloat a, RealFloat b) => (a -> b) -> X.Complex a -> X.Complex b-mapComplex f (x X.:+ y) = f x X.:+ f y+instance NaturalNumber p => Show (VComplex VFloat p) where+  showsPrec p = showsPrec p . toComplex --- | Much like 'mapComplex' 'recodeFloat'.-recodeComplex :: (RealFloat a, RealFloat b) => X.Complex a -> X.Complex b-recodeComplex = mapComplex recodeFloat+instance NaturalNumber p => Show (VComplex VFixed p) where+  showsPrec p = showsPrec p . toComplex --- | Magnitude squared.-magnitude2' :: RealFloat r => X.Complex r -> r-magnitude2' (x X.:+ y) = x * x + y * y+instance NaturalNumber p => Read (VComplex VFloat p) where+  readsPrec p = map (first fromComplex) . readsPrec p+    where first f (a, b) = (f a, b) --- | Complex square.-sqr :: NaturalNumber p => VComplex p -> VComplex p-sqr = withComplex sqr'+instance NaturalNumber p => Read (VComplex VFixed p) where+  readsPrec p = map (first fromComplex) . readsPrec p+    where first f (a, b) = (f a, b) --- | Complex square.-sqr' :: RealFloat r => X.Complex r -> X.Complex r-sqr' (x X.:+ y) = (x + y) * (x - y) X.:+ scaleFloat 1 (x * y)+-- | Lift an operation on 'X.Complex' to one on 'VComplex'.+withComplex :: (Complex (t p) -> Complex (t q)) -> (VComplex t p -> VComplex t q)+withComplex f = fromComplex . f . toComplex +-- | Much like 'mapComplex' 'recodeFloat'.+recodeComplex :: (RealFloat a, RealFloat b) => Complex a -> Complex b+recodeComplex = fmap recodeFloat+ -- | Much like 'withComplex' 'scaleComplex''.-scaleComplex :: NaturalNumber p => Int -> VComplex p -> VComplex p-scaleComplex = withComplex . scaleComplex'+scaleVComplex :: NaturalNumber p => Int -> VComplex VFloat p -> VComplex VFloat p+scaleVComplex = withComplex . scaleComplex  -- | Much like 'mapComplex' 'scaleFloat'.-scaleComplex' :: RealFloat r => Int -> X.Complex r -> X.Complex r-scaleComplex' = mapComplex . scaleFloat---- | Real-complex multiplication.-(.*) :: NaturalNumber p => VFloat p -> VComplex p -> VComplex p-x .* y = withComplex (mapComplex (x *)) y-infixl 7 .*+scaleComplex :: RealFloat r => Int -> Complex r -> Complex r+scaleComplex = fmap . scaleFloat --- | Complex-real multiplication.-(*.) :: NaturalNumber p => VComplex p -> VFloat p -> VComplex p-x *. y = withComplex (mapComplex (* y)) x-infixl 7 *.+-- | Freeze a 'VComplex VFloat'.+toComplexDFloat :: NaturalNumber p => VComplex VFloat p -> Complex DFloat+toComplexDFloat = fmap toDFloat . toComplex +-- | Freeze a 'VComplex VFixed'.+toComplexDFixed :: NaturalNumber p => VComplex VFixed p -> Complex DFixed+toComplexDFixed = fmap toDFixed . toComplex --- | A concrete format suitable for storage or wire transmission.-data DComplex = DComplex{ dRealPart :: !DFloat, dImagPart :: !DFloat }-  deriving (Eq, Ord, Read, Show, Data, Typeable)+-- | Thaw a 'Complex DFloat'.  Results in 'Nothing' on precision mismatch.+fromComplexDFloat :: NaturalNumber p => Complex DFloat -> Maybe (VComplex VFloat p)+fromComplexDFloat (x :+ y) = do+  r <- fromDFloat x+  i <- fromDFloat y+  return (r .+ i) --- | Freeze a 'VComplex'.-toDComplex :: NaturalNumber p => VComplex p -> DComplex-toDComplex v = DComplex (toDFloat (realPart v)) (toDFloat (imagPart v))+-- | Thaw a 'Complex DFixed'.  Results in 'Nothing' on precision mismatch.+fromComplexDFixed :: NaturalNumber p => Complex DFixed -> Maybe (VComplex VFixed p)+fromComplexDFixed (x :+ y) = do+  r <- fromDFixed x+  i <- fromDFixed y+  return (r .+ i) --- | Thaw a 'DComplex'.  Results in 'Nothing' on precision mismatch.-fromDComplex :: NaturalNumber p => DComplex -> Maybe (VComplex p)-fromDComplex d = do-  r <- fromDFloat (dRealPart d)-  i <- fromDFloat (dImagPart d)+-- | Thaw a 'Complex DFloat' to its natural precision.  'Nothing' is passed on+--   precision mismatch between real and imaginary parts.+withComplexDFloat :: Complex DFloat -> (forall p . NaturalNumber p => Maybe (VComplex VFloat p) -> r) -> r+withComplexDFloat (x :+ y) f = withDFloat x $ \r -> f $ do+  i <- fromDFloat y   return (r .+ i) --- | Thaw a 'DComplex' to its natural precision.  'Nothing' is passed on+-- | Thaw a 'Complex DFixed' to its natural precision.  'Nothing' is passed on --   precision mismatch between real and imaginary parts.-withDComplex :: DComplex -> (forall p . NaturalNumber p => Maybe (VComplex p) -> r) -> r-withDComplex d f = withDFloat (dRealPart d) $ \r -> f $ do-  i <- fromDFloat (dImagPart d)+withComplexDFixed :: Complex DFixed -> (forall p . NaturalNumber p => Maybe (VComplex VFixed p) -> r) -> r+withComplexDFixed (x :+ y) f = withDFixed x $ \r -> f $ do+  i <- fromDFixed y   return (r .+ i)
Numeric/VariablePrecision/Fixed.hs view
@@ -4,7 +4,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  BangPatterns, DeriveDataTypeable, Rank2Types, MonoLocalBinds @@ -90,7 +90,10 @@   l@(F x) * F y = F $ (x * y) `shiftR` fromIntegral (precision l)   negate (F x) = F (negate x)   abs (F x) = F (abs x)-  signum (F x) = F (signum x)+  signum (F x)+    | x > 0 = 1+    | x < 0 = -1+    | otherwise = 0   fromInteger x = let r = F (x `shiftL` fromIntegral (precision r)) in r
Numeric/VariablePrecision/Float.hs view
@@ -4,7 +4,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  BangPatterns, DeriveDataTypeable, Rank2Types
Numeric/VariablePrecision/Precision.hs view
@@ -3,7 +3,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  portable
Numeric/VariablePrecision/Precision/Reify.hs view
@@ -4,7 +4,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  unstable Portability :  Rank2Types
TypeLevel/NaturalNumber/ExtraNumbers.hs view
@@ -3,7 +3,7 @@ Copyright   :  (c) Claude Heiland-Allen 2012 License     :  BSD3 -Maintainer  :  claudiusmaximus@goto10.org+Maintainer  :  claude@mathr.co.uk Stability   :  stable Portability :  portable
variable-precision.cabal view
@@ -1,5 +1,5 @@ Name:                variable-precision-Version:             0.2.1+Version:             0.3.1 Synopsis:            variable-precision floating point Description:   Software floating point with type-tagged variable mantissa precision,@@ -20,7 +20,7 @@ License:             BSD3 License-file:        LICENSE Author:              Claude Heiland-Allen-Maintainer:          claudiusmaximus@goto10.org+Maintainer:          claude@mathr.co.uk Copyright:           (c) 2012 Claude Heiland-Allen Category:            Math Build-type:          Simple@@ -54,6 +54,7 @@     Numeric.VariablePrecision.Integer.Logarithm   Build-depends:     base >= 3 && < 6,+    complex-generic >= 0.1.1 && < 0.2,     floatshow >= 0.2 && < 0.3,     type-level-natural-number >= 1 && < 2   if (!flag(fast))@@ -71,4 +72,4 @@ source-repository this   type:     git   location: git://gitorious.org/variable-precision/variable-precision.git-  tag:      v0.2.1+  tag:      v0.3.1