diff --git a/Numeric/VariablePrecision.hs b/Numeric/VariablePrecision.hs --- a/Numeric/VariablePrecision.hs +++ b/Numeric/VariablePrecision.hs @@ -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 diff --git a/Numeric/VariablePrecision/Algorithms.hs b/Numeric/VariablePrecision/Algorithms.hs --- a/Numeric/VariablePrecision/Algorithms.hs +++ b/Numeric/VariablePrecision/Algorithms.hs @@ -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 diff --git a/Numeric/VariablePrecision/Aliases.hs b/Numeric/VariablePrecision/Aliases.hs --- a/Numeric/VariablePrecision/Aliases.hs +++ b/Numeric/VariablePrecision/Aliases.hs @@ -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 diff --git a/Numeric/VariablePrecision/Complex.hs b/Numeric/VariablePrecision/Complex.hs --- a/Numeric/VariablePrecision/Complex.hs +++ b/Numeric/VariablePrecision/Complex.hs @@ -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) diff --git a/Numeric/VariablePrecision/Fixed.hs b/Numeric/VariablePrecision/Fixed.hs --- a/Numeric/VariablePrecision/Fixed.hs +++ b/Numeric/VariablePrecision/Fixed.hs @@ -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 diff --git a/Numeric/VariablePrecision/Float.hs b/Numeric/VariablePrecision/Float.hs --- a/Numeric/VariablePrecision/Float.hs +++ b/Numeric/VariablePrecision/Float.hs @@ -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 diff --git a/Numeric/VariablePrecision/Precision.hs b/Numeric/VariablePrecision/Precision.hs --- a/Numeric/VariablePrecision/Precision.hs +++ b/Numeric/VariablePrecision/Precision.hs @@ -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 diff --git a/Numeric/VariablePrecision/Precision/Reify.hs b/Numeric/VariablePrecision/Precision/Reify.hs --- a/Numeric/VariablePrecision/Precision/Reify.hs +++ b/Numeric/VariablePrecision/Precision/Reify.hs @@ -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 diff --git a/TypeLevel/NaturalNumber/ExtraNumbers.hs b/TypeLevel/NaturalNumber/ExtraNumbers.hs --- a/TypeLevel/NaturalNumber/ExtraNumbers.hs +++ b/TypeLevel/NaturalNumber/ExtraNumbers.hs @@ -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 diff --git a/variable-precision.cabal b/variable-precision.cabal --- a/variable-precision.cabal +++ b/variable-precision.cabal @@ -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