aern2-mp 0.2.6.0 → 0.2.7.0

raw patch · 10 files changed

+170/−143 lines, 10 filesdep ~mixed-types-numPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: mixed-types-num

API changes (from Hackage documentation)

Files

• aern2-mp.cabal +3/−3
• changelog.md +5/−0
• src/AERN2/MP/Ball.hs +2/−6
• src/AERN2/MP/WithCurrentPrec.hs +14/−3
• src/AERN2/MP/WithCurrentPrec/Comparisons.hs +32/−32
• src/AERN2/MP/WithCurrentPrec/Elementary.hs +16/−16
• src/AERN2/MP/WithCurrentPrec/Field.hs +48/−40
• src/AERN2/MP/WithCurrentPrec/Limit.hs +7/−5
• src/AERN2/MP/WithCurrentPrec/PreludeInstances.hs +9/−7
• src/AERN2/MP/WithCurrentPrec/Type.hs +34/−31

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           aern2-mp-version:        0.2.6.0+version:        0.2.7.0 synopsis:       Multi-precision ball (interval) arithmetic description:    Please see the README on GitHub at <https://github.com/michalkonecny/aern2/#readme> category:       Math@@ -89,7 +89,7 @@     , deepseq     , hspec     , integer-logarithms-    , mixed-types-num >=0.5.7+    , mixed-types-num >=0.5.8     , reflection     , regex-tdfa     , template-haskell@@ -129,7 +129,7 @@     , deepseq     , hspec     , integer-logarithms-    , mixed-types-num >=0.5.7+    , mixed-types-num >=0.5.8     , reflection     , regex-tdfa     , template-haskell

@@ -1,5 +1,10 @@ # Change log for aern2-mp +* v 0.2.7 2021-06-02+  * make WithCurrentPrec p (CN MPBall) a Field+  * simplify WithCurrentPrec, swap its parameters+* v 0.2.6 2021-05-29+  * adapt to new ppow operations * v 0.2.5 2021-05-27   * add generic multivalued select + Kleenean instances   * WithCurrentPrec: add MixedTypesNumPrelude class instances

@@ -57,15 +57,11 @@  instance Ring MPBall instance Ring (CN MPBall)-instance Field MPBall-instance Field (CN MPBall)  instance OrderedRing MPBall instance OrderedRing (CN MPBall)-instance OrderedField MPBall-instance OrderedField (CN MPBall)  instance OrderedCertainlyRing MPBall instance OrderedCertainlyRing (CN MPBall)-instance OrderedCertainlyField MPBall-instance OrderedCertainlyField (CN MPBall)++-- Field instances available only with the WithCurrentPrec wrapper so thta Rationals can be cleanly embedded

@@ -4,6 +4,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE StandaloneDeriving #-}+{-# OPTIONS_GHC -Wno-orphans #-} {-|     Module      :  AERN2.MP.WithCurrentPrec     Description :  Type wrapper setting default precision@@ -20,21 +21,31 @@ -} module AERN2.MP.WithCurrentPrec (-    WithCurrentPrec(..), runWithPrec, HasCurrentPrecision(..)+    WithCurrentPrec(..), runWithPrec     , WithAnyPrec(..)-    , mpBallCP+    , cnmpBallCP     , piCP     -- , _example1 , _example2 , _example3     -- , _example1P , _example2P , _example3P ) where --- import MixedTypesNumPrelude+import MixedTypesNumPrelude -- import qualified Prelude as P -- import Text.Printf +import GHC.TypeNats+ import AERN2.MP.WithCurrentPrec.Type import AERN2.MP.WithCurrentPrec.Comparisons () import AERN2.MP.WithCurrentPrec.Field () import AERN2.MP.WithCurrentPrec.Elementary (piCP)+import AERN2.MP.WithCurrentPrec.Limit () import AERN2.MP.WithCurrentPrec.PreludeInstances ()++import AERN2.MP.Ball++instance (KnownNat p) => Ring (WithCurrentPrec p (CN MPBall))+instance (KnownNat p) => Field (WithCurrentPrec p (CN MPBall))+instance (KnownNat p) => OrderedRing (WithCurrentPrec p (CN MPBall))+instance (KnownNat p) => OrderedField (WithCurrentPrec p (CN MPBall))

@@ -34,18 +34,18 @@ instance     (HasEqAsymmetric t1 t2, p1 ~ p2)     =>-    HasEqAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) +    HasEqAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)      where-    type EqCompareType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = EqCompareType t1 t2+    type EqCompareType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = EqCompareType t1 t2     equalTo = lift2P equalTo     notEqualTo = lift2P notEqualTo  instance     (HasOrderAsymmetric t1 t2, p1 ~ p2)     =>-    HasOrderAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) +    HasOrderAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)      where-    type OrderCompareType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = OrderCompareType t1 t2+    type OrderCompareType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = OrderCompareType t1 t2     greaterThan = lift2P greaterThan     lessThan = lift2P lessThan     geq = lift2P geq@@ -54,17 +54,17 @@ instance     (CanAbs t)     =>-    CanAbs (WithCurrentPrec t p)+    CanAbs (WithCurrentPrec p t)     where-    type AbsType (WithCurrentPrec t p) = WithCurrentPrec (AbsType t) p+    type AbsType (WithCurrentPrec p t) = WithCurrentPrec p (AbsType t)     abs = lift1 abs  instance     (CanMinMaxAsymmetric t1 t2, p1 ~ p2)     =>-    CanMinMaxAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) +    CanMinMaxAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)      where-    type MinMaxType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (MinMaxType t1 t2) p1+    type MinMaxType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (MinMaxType t1 t2)     min = lift2 min     max = lift2 max @@ -79,36 +79,36 @@     instance       (CanMinMaxAsymmetric a $t)       => -      CanMinMaxAsymmetric (WithCurrentPrec a p) $t+      CanMinMaxAsymmetric (WithCurrentPrec p a) $t       where-      type MinMaxType (WithCurrentPrec a p) $t = WithCurrentPrec (MinMaxType a $t) p+      type MinMaxType (WithCurrentPrec p a) $t = WithCurrentPrec p (MinMaxType a $t)       min = lift1T min       max = lift1T max      instance       (CanMinMaxAsymmetric a (CN $t))       => -      CanMinMaxAsymmetric (WithCurrentPrec a p) (CN $t)+      CanMinMaxAsymmetric (WithCurrentPrec p a) (CN $t)       where-      type MinMaxType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (MinMaxType a (CN $t)) p+      type MinMaxType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (MinMaxType a (CN $t))       min = lift1T min       max = lift1T max      instance       (CanMinMaxAsymmetric $t a)       => -      CanMinMaxAsymmetric $t (WithCurrentPrec a p)+      CanMinMaxAsymmetric $t (WithCurrentPrec p a)       where-      type MinMaxType $t (WithCurrentPrec a p) = WithCurrentPrec (MinMaxType $t a) p+      type MinMaxType $t (WithCurrentPrec p a) = WithCurrentPrec p (MinMaxType $t a)       min = liftT1 min       max = liftT1 max      instance       (CanMinMaxAsymmetric (CN $t) a)       => -      CanMinMaxAsymmetric (CN $t) (WithCurrentPrec a p)+      CanMinMaxAsymmetric (CN $t) (WithCurrentPrec p a)       where-      type MinMaxType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (MinMaxType (CN $t) a) p+      type MinMaxType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (MinMaxType (CN $t) a)       min = liftT1 min       max = liftT1 max @@ -117,36 +117,36 @@     instance       (HasEqAsymmetric a $t)       => -      HasEqAsymmetric (WithCurrentPrec a p) $t+      HasEqAsymmetric (WithCurrentPrec p a) $t       where-      type EqCompareType (WithCurrentPrec a p) $t = EqCompareType a $t+      type EqCompareType (WithCurrentPrec p a) $t = EqCompareType a $t       equalTo = lift1TP (==)       notEqualTo = lift1TP (/=)      instance       (HasEqAsymmetric a (CN $t))       => -      HasEqAsymmetric (WithCurrentPrec a p) (CN $t)+      HasEqAsymmetric (WithCurrentPrec p a) (CN $t)       where-      type EqCompareType (WithCurrentPrec a p) (CN $t) = EqCompareType a (CN $t)+      type EqCompareType (WithCurrentPrec p a) (CN $t) = EqCompareType a (CN $t)       equalTo = lift1TP (==)       notEqualTo = lift1TP (/=)      instance       (HasEqAsymmetric $t a)       =>-      HasEqAsymmetric $t (WithCurrentPrec a p)+      HasEqAsymmetric $t (WithCurrentPrec p a)       where-      type EqCompareType $t (WithCurrentPrec a p) = EqCompareType $t a+      type EqCompareType $t (WithCurrentPrec p a) = EqCompareType $t a       equalTo = liftT1P (==)       notEqualTo = liftT1P (/=)      instance       (HasEqAsymmetric (CN $t) a)       =>-      HasEqAsymmetric (CN $t) (WithCurrentPrec a p)+      HasEqAsymmetric (CN $t) (WithCurrentPrec p a)       where-      type EqCompareType (CN $t) (WithCurrentPrec a p) = EqCompareType (CN $t) a+      type EqCompareType (CN $t) (WithCurrentPrec p a) = EqCompareType (CN $t) a       equalTo = liftT1P (==)       notEqualTo = liftT1P (/=) @@ -155,9 +155,9 @@     instance       (HasOrderAsymmetric a $t)       => -      HasOrderAsymmetric (WithCurrentPrec a p) $t+      HasOrderAsymmetric (WithCurrentPrec p a) $t       where-      type OrderCompareType (WithCurrentPrec a p) $t = OrderCompareType a $t+      type OrderCompareType (WithCurrentPrec p a) $t = OrderCompareType a $t       lessThan = lift1TP lessThan       greaterThan = lift1TP greaterThan       leq = lift1TP leq@@ -166,9 +166,9 @@     instance       (HasOrderAsymmetric a (CN $t))       => -      HasOrderAsymmetric (WithCurrentPrec a p) (CN $t)+      HasOrderAsymmetric (WithCurrentPrec p a) (CN $t)       where-      type OrderCompareType (WithCurrentPrec a p) (CN $t) = OrderCompareType a (CN $t)+      type OrderCompareType (WithCurrentPrec p a) (CN $t) = OrderCompareType a (CN $t)       lessThan = lift1TP lessThan       greaterThan = lift1TP greaterThan       leq = lift1TP leq@@ -177,9 +177,9 @@     instance       (HasOrderAsymmetric $t a)       =>-      HasOrderAsymmetric $t (WithCurrentPrec a p)+      HasOrderAsymmetric $t (WithCurrentPrec p a)       where-      type OrderCompareType $t (WithCurrentPrec a p) = OrderCompareType $t a+      type OrderCompareType $t (WithCurrentPrec p a) = OrderCompareType $t a       lessThan = liftT1P lessThan       greaterThan = liftT1P greaterThan       leq = liftT1P leq@@ -188,9 +188,9 @@     instance       (HasOrderAsymmetric (CN $t) a)       =>-      HasOrderAsymmetric (CN $t) (WithCurrentPrec a p)+      HasOrderAsymmetric (CN $t) (WithCurrentPrec p a)       where-      type OrderCompareType (CN $t) (WithCurrentPrec a p) = OrderCompareType (CN $t) a+      type OrderCompareType (CN $t) (WithCurrentPrec p a) = OrderCompareType (CN $t) a       lessThan = liftT1P lessThan       greaterThan = liftT1P greaterThan       leq = liftT1P leq

@@ -38,7 +38,7 @@  import AERN2.MP.WithCurrentPrec.Field () -piCP :: (KnownNat p) => WithCurrentPrec (CN MPBall) p+piCP :: (KnownNat p) => WithCurrentPrec p (CN MPBall) piCP = r      where     r = WithCurrentPrec $ cn $ piBallP (getCurrentPrecision r)@@ -46,41 +46,41 @@ instance     (CanSinCos t)     =>-    CanSinCos (WithCurrentPrec t p)+    CanSinCos (WithCurrentPrec p t)     where-    type SinCosType (WithCurrentPrec t p) = WithCurrentPrec (SinCosType t) p+    type SinCosType (WithCurrentPrec p t) = WithCurrentPrec p (SinCosType t)     sin = lift1 sin     cos = lift1 cos  instance     (CanSqrt t)     =>-    CanSqrt (WithCurrentPrec t p)+    CanSqrt (WithCurrentPrec p t)     where-    type SqrtType (WithCurrentPrec t p) = WithCurrentPrec (SqrtType t) p+    type SqrtType (WithCurrentPrec p t) = WithCurrentPrec p (SqrtType t)     sqrt = lift1 sqrt  instance     (CanExp t)     =>-    CanExp (WithCurrentPrec t p)+    CanExp (WithCurrentPrec p t)     where-    type ExpType (WithCurrentPrec t p) = WithCurrentPrec (ExpType t) p+    type ExpType (WithCurrentPrec p t) = WithCurrentPrec p (ExpType t)     exp = lift1 exp  instance     (CanLog t)     =>-    CanLog (WithCurrentPrec t p)+    CanLog (WithCurrentPrec p t)     where-    type LogType (WithCurrentPrec t p) = WithCurrentPrec (LogType t) p+    type LogType (WithCurrentPrec p t) = WithCurrentPrec p (LogType t)     log = lift1 log  instance     (CanPow t1 t2, p1~p2)     =>-    (CanPow (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where-    type PowType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (PowType t1 t2) p1+    (CanPow (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where+    type PowType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (PowType t1 t2)     pow = lift2 pow  $(declForTypes@@ -90,9 +90,9 @@   instance      (CanPow b $e)     =>-    CanPow (WithCurrentPrec b p) $e +    CanPow (WithCurrentPrec p b) $e      where-    type PowType (WithCurrentPrec b p) $e = WithCurrentPrec (PowType b $e) p+    type PowType (WithCurrentPrec p b) $e = WithCurrentPrec p (PowType b $e)     pow = lift1T pow    |]))@@ -104,9 +104,9 @@   instance      (CanPow $b e, HasOrderCertainly e Integer, CanTestInteger e)     =>-    CanPow $b (WithCurrentPrec e p) +    CanPow $b (WithCurrentPrec p e)      where-    type PowType $b (WithCurrentPrec e p) = WithCurrentPrec (PowType $b e) p+    type PowType $b (WithCurrentPrec p e) = WithCurrentPrec p (PowType $b e)     pow = liftT1 pow   |])) @@ -117,4 +117,4 @@ _example2 = runWithPrec (prec 1000) $ piCP - piCP  _example3 :: CN MPBall-_example3 = runWithPrec (prec 1000) $ sqrt (mpBallCP 2)+_example3 = runWithPrec (prec 1000) $ sqrt (cnmpBallCP 2)

@@ -32,31 +32,39 @@ import AERN2.MP.WithCurrentPrec.Type  instance+    (CanNeg t)+    =>+    CanNeg (WithCurrentPrec p t)+    where+    type NegType (WithCurrentPrec p t) = WithCurrentPrec p (NegType t)+    negate = lift1 negate++instance     (CanAddAsymmetric t1 t2, p1~p2)     =>-    (CanAddAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where-    type AddType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (AddType t1 t2) p1+    (CanAddAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where+    type AddType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (AddType t1 t2)     add = lift2 add  instance     (CanSub t1 t2, p1~p2)     =>-    (CanSub (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where-    type SubType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (SubType t1 t2) p1+    (CanSub (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where+    type SubType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (SubType t1 t2)     sub = lift2 sub  instance     (CanMulAsymmetric t1 t2, p1~p2)     =>-    (CanMulAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where-    type MulType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (MulType t1 t2) p1+    (CanMulAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where+    type MulType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (MulType t1 t2)     mul = lift2 mul  instance     (CanDiv t1 t2, p1~p2)     =>-    (CanDiv (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where-    type DivType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (DivType t1 t2) p1+    (CanDiv (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where+    type DivType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (DivType t1 t2)     divide = lift2 divide  @@ -73,129 +81,129 @@     instance       (CanAddAsymmetric a $t)       => -      CanAddAsymmetric (WithCurrentPrec a p) $t+      CanAddAsymmetric (WithCurrentPrec p a) $t       where-      type AddType (WithCurrentPrec a p) $t = WithCurrentPrec (AddType a $t) p+      type AddType (WithCurrentPrec p a) $t = WithCurrentPrec p (AddType a $t)       add = lift1T add      instance       (CanAddAsymmetric a (CN $t))       => -      CanAddAsymmetric (WithCurrentPrec a p) (CN $t)+      CanAddAsymmetric (WithCurrentPrec p a) (CN $t)       where-      type AddType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (AddType a (CN $t)) p+      type AddType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (AddType a (CN $t))       add = lift1T add      instance       (CanAddAsymmetric $t a)       => -      CanAddAsymmetric $t (WithCurrentPrec a p)+      CanAddAsymmetric $t (WithCurrentPrec p a)       where-      type AddType $t (WithCurrentPrec a p) = WithCurrentPrec (AddType $t a) p+      type AddType $t (WithCurrentPrec p a) = WithCurrentPrec p (AddType $t a)       add = liftT1 add      instance       (CanAddAsymmetric (CN $t) a)       => -      CanAddAsymmetric (CN $t) (WithCurrentPrec a p)+      CanAddAsymmetric (CN $t) (WithCurrentPrec p a)       where-      type AddType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (AddType (CN $t) a) p+      type AddType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (AddType (CN $t) a)       add = liftT1 add      instance       (CanSub a $t)       => -      CanSub (WithCurrentPrec a p) $t+      CanSub (WithCurrentPrec p a) $t       where-      type SubType (WithCurrentPrec a p) $t = WithCurrentPrec (SubType a $t) p+      type SubType (WithCurrentPrec p a) $t = WithCurrentPrec p (SubType a $t)       sub = lift1T sub      instance       (CanSub a (CN $t))       => -      CanSub (WithCurrentPrec a p) (CN $t)+      CanSub (WithCurrentPrec p a) (CN $t)       where-      type SubType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (SubType a (CN $t)) p+      type SubType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (SubType a (CN $t))       sub = lift1T sub      instance       (CanSub $t a)       => -      CanSub $t (WithCurrentPrec a p)+      CanSub $t (WithCurrentPrec p a)       where-      type SubType $t (WithCurrentPrec a p) = WithCurrentPrec (SubType $t a) p+      type SubType $t (WithCurrentPrec p a) = WithCurrentPrec p (SubType $t a)       sub = liftT1 sub      instance       (CanSub (CN $t) a)       => -      CanSub (CN $t) (WithCurrentPrec a p)+      CanSub (CN $t) (WithCurrentPrec p a)       where-      type SubType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (SubType (CN $t) a) p+      type SubType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (SubType (CN $t) a)       sub = liftT1 sub      instance       (CanMulAsymmetric a $t)       => -      CanMulAsymmetric (WithCurrentPrec a p) $t+      CanMulAsymmetric (WithCurrentPrec p a) $t       where-      type MulType (WithCurrentPrec a p) $t = WithCurrentPrec (MulType a $t) p+      type MulType (WithCurrentPrec p a) $t = WithCurrentPrec p (MulType a $t)       mul = lift1T mul      instance       (CanMulAsymmetric a (CN $t))       => -      CanMulAsymmetric (WithCurrentPrec a p) (CN $t)+      CanMulAsymmetric (WithCurrentPrec p a) (CN $t)       where-      type MulType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (MulType a (CN $t)) p+      type MulType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (MulType a (CN $t))       mul = lift1T mul      instance       (CanMulAsymmetric $t a)       => -      CanMulAsymmetric $t (WithCurrentPrec a p)+      CanMulAsymmetric $t (WithCurrentPrec p a)       where-      type MulType $t (WithCurrentPrec a p) = WithCurrentPrec (MulType $t a) p+      type MulType $t (WithCurrentPrec p a) = WithCurrentPrec p (MulType $t a)       mul = liftT1 mul      instance       (CanMulAsymmetric (CN $t) a)       => -      CanMulAsymmetric (CN $t) (WithCurrentPrec a p)+      CanMulAsymmetric (CN $t) (WithCurrentPrec p a)       where-      type MulType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (MulType (CN $t) a) p+      type MulType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (MulType (CN $t) a)       mul = liftT1 mul      instance       (CanDiv a $t)       => -      CanDiv (WithCurrentPrec a p) $t+      CanDiv (WithCurrentPrec p a) $t       where-      type DivType (WithCurrentPrec a p) $t = WithCurrentPrec (DivType a $t) p+      type DivType (WithCurrentPrec p a) $t = WithCurrentPrec p (DivType a $t)       divide = lift1T divide      instance       (CanDiv a (CN $t))       => -      CanDiv (WithCurrentPrec a p) (CN $t)+      CanDiv (WithCurrentPrec p a) (CN $t)       where-      type DivType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (DivType a (CN $t)) p+      type DivType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (DivType a (CN $t))       divide = lift1T divide      instance       (CanDiv $t a)       => -      CanDiv $t (WithCurrentPrec a p)+      CanDiv $t (WithCurrentPrec p a)       where-      type DivType $t (WithCurrentPrec a p) = WithCurrentPrec (DivType $t a) p+      type DivType $t (WithCurrentPrec p a) = WithCurrentPrec p (DivType $t a)       divide = liftT1 divide      instance       (CanDiv (CN $t) a)       => -      CanDiv (CN $t) (WithCurrentPrec a p)+      CanDiv (CN $t) (WithCurrentPrec p a)       where-      type DivType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (DivType (CN $t) a) p+      type DivType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (DivType (CN $t) a)       divide = liftT1 divide    |]))

@@ -26,6 +26,8 @@  -- import qualified Numeric.CollectErrors as CN +import GHC.TypeLits+ import AERN2.MP.Ball  import AERN2.Limit@@ -35,17 +37,17 @@ instance      (HasLimits ix (CN MPBall -> CN MPBall)     , LimitType ix (CN MPBall -> CN MPBall) ~ (CN MPBall -> CN MPBall)-    ,HasCurrentPrecision p)+    , KnownNat p)     => -    HasLimits ix (WithCurrentPrec (CN MPBall) p) +    HasLimits ix (WithCurrentPrec p (CN MPBall))      where-    type LimitType ix (WithCurrentPrec (CN MPBall) p) = WithCurrentPrec (CN MPBall) p-    limit (s :: ix -> (WithCurrentPrec (CN MPBall) p)) = +    type LimitType ix (WithCurrentPrec p (CN MPBall)) = WithCurrentPrec p (CN MPBall)+    limit (s :: ix -> (WithCurrentPrec p (CN MPBall))) =          WithCurrentPrec $ limit (snop) $ sample         where         sample :: CN MPBall         sample = setPrecision (getCurrentPrecision sampleP) (cn $ mpBall 0)-        sampleP :: WithCurrentPrec MPBall p+        sampleP :: WithCurrentPrec p MPBall         sampleP = error "sampleP is not defined, it is only a type proxy"         snop :: ix -> (CN MPBall -> CN MPBall)         snop ix _sample = unWithCurrentPrec $ s ix

@@ -27,6 +27,8 @@  import Numeric.CollectErrors (cn, CN) +import GHC.TypeLits+ import AERN2.MP.Precision import AERN2.MP.Ball @@ -38,15 +40,15 @@ ******************************** -} -instance Eq t => Eq (WithCurrentPrec t p) where+instance Eq t => Eq (WithCurrentPrec p t) where     (==) = lift2P (==)-instance Ord t => Ord (WithCurrentPrec t p) where+instance Ord t => Ord (WithCurrentPrec p t) where     compare = lift2P compare  instance -    (HasCurrentPrecision p, Num t, ConvertibleWithPrecision Integer t) +    (KnownNat p, Num t, ConvertibleWithPrecision Integer t)      => -    Num (WithCurrentPrec t p) +    Num (WithCurrentPrec p t)      where     fromInteger n = r         where   @@ -58,10 +60,10 @@     signum = lift1 signum  instance -    (HasCurrentPrecision p, Fractional t+    (KnownNat p, Fractional t     , ConvertibleWithPrecision Integer t, ConvertibleWithPrecision Rational t)      => -    Fractional (WithCurrentPrec t p) +    Fractional (WithCurrentPrec p t)      where     fromRational q = r         where   @@ -69,7 +71,7 @@     recip = lift1 recip     (/) = lift2 (/) -instance (HasCurrentPrecision p) => Floating (WithCurrentPrec (CN MPBall) p) where+instance (KnownNat p) => Floating (WithCurrentPrec p (CN MPBall)) where     pi = r          where         r = WithCurrentPrec $ cn $ piBallP (getCurrentPrecision r)

@@ -32,12 +32,16 @@  import AERN2.MP -class HasCurrentPrecision p where-    getCurrentPrecision :: proxy p -> Precision+newtype WithCurrentPrec p t = WithCurrentPrec { unWithCurrentPrec :: t }+    deriving (Show) -instance KnownNat n => HasCurrentPrecision n where-    getCurrentPrecision p = max (prec 2) . min maximumPrecision $ prec (natVal p)+deriving instance (CanTakeErrors NumErrors t) => (CanTakeErrors NumErrors (WithCurrentPrec p t))+deriving instance (CanTestIsIntegerType t) => (CanTestIsIntegerType (WithCurrentPrec p t)) +getCurrentPrecision :: (KnownNat p) => WithCurrentPrec p t -> Precision+getCurrentPrecision (_ :: (WithCurrentPrec p t)) =+    max (prec 2) . min maximumPrecision $ prec (natVal (undefined :: Proxy p))+ {-|  An existential type wrapper for convenient conversions, eg using aern2-real:@@ -49,49 +53,48 @@ > _r_x = creal $ WithAnyPrec _x  -}-newtype WithAnyPrec t = WithAnyPrec (forall p. (KnownNat p) => WithCurrentPrec t p)---- data PrecAdd10 (p :: *)+newtype WithAnyPrec t = WithAnyPrec (forall p. (KnownNat p) => WithCurrentPrec p t) --- instance (HasCurrentPrecision p) => HasCurrentPrecision (PrecAdd10 p) where---     isPrecision (_ :: proxy _) = 10 + isPrecision (undefined :: proxy p)+{-| +    Run a WithCurrentPrec computation with a specific precision.+-}+runWithPrec :: Precision -> (forall p. (KnownNat p) => WithCurrentPrec p t) -> t+runWithPrec p (wfp :: (forall p. (KnownNat p) => WithCurrentPrec p t)) = +    reifyNat (integer p) withNat+    where+    withNat :: KnownNat p => Proxy p -> t+    withNat (_ :: Proxy p) = +        unWithCurrentPrec (wfp :: WithCurrentPrec p t) -newtype WithCurrentPrec t p = WithCurrentPrec { unWithCurrentPrec :: t }-    deriving (Show)+instance (ConvertibleWithPrecision t1 t2, KnownNat p) => ConvertibleExactly t1 (WithCurrentPrec p t2) where+    safeConvertExactly v = Right r+        where+        r = WithCurrentPrec $ convertP (getCurrentPrecision r) v -deriving instance (CanTakeErrors NumErrors t) => (CanTakeErrors NumErrors (WithCurrentPrec t p))-deriving instance (CanTestIsIntegerType t) => (CanTestIsIntegerType (WithCurrentPrec t p))+-- mpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec p MPBall+-- mpBallCP = convertExactly  -runWithPrec :: Precision -> (forall n. (KnownNat n) => WithCurrentPrec t n) -> t-runWithPrec p (wfp :: (forall n. (KnownNat n) => WithCurrentPrec t n)) = -    reifyNat (integer p) withNat-    where-    withNat :: KnownNat n => Proxy n -> t-    withNat (_ :: Proxy n) = -        unWithCurrentPrec (wfp :: WithCurrentPrec t n)+cnmpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec p (CN MPBall)+cnmpBallCP = lift1 cn . convertExactly  -lift1 :: (t1 -> t2) -> (WithCurrentPrec t1 p) -> (WithCurrentPrec t2 p)+lift1 :: (t1 -> t2) -> (WithCurrentPrec p t1) -> (WithCurrentPrec p t2) lift1 f (WithCurrentPrec v1) = WithCurrentPrec (f v1) -lift2 :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> (WithCurrentPrec t2 p2) -> (WithCurrentPrec t3 p1)+lift2 :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> (WithCurrentPrec p2 t2) -> (WithCurrentPrec p1 t3) lift2 f (WithCurrentPrec v1) (WithCurrentPrec v2) = WithCurrentPrec (f v1 v2) -lift2P :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> (WithCurrentPrec t2 p2) -> t3+lift2P :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> (WithCurrentPrec p2 t2) -> t3 lift2P f (WithCurrentPrec v1) (WithCurrentPrec v2) = f v1 v2 -lift1T :: (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> t2 -> (WithCurrentPrec t3 p1)+lift1T :: (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> t2 -> (WithCurrentPrec p1 t3) lift1T f (WithCurrentPrec v1) v2 = WithCurrentPrec (f v1 v2) -lift1TP :: (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> t2 -> t3+lift1TP :: (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> t2 -> t3 lift1TP f (WithCurrentPrec v1) v2 = f v1 v2 -liftT1 :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec t2 p2) -> (WithCurrentPrec t3 p1)+liftT1 :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec p2 t2) -> (WithCurrentPrec p1 t3) liftT1 f v1 (WithCurrentPrec v2) = WithCurrentPrec (f v1 v2) -liftT1P :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec t2 p2) -> t3+liftT1P :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec p2 t2) -> t3 liftT1P f v1 (WithCurrentPrec v2) = f v1 v2 -mpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec (CN MPBall) p-mpBallCP v = r -    where-    r = WithCurrentPrec $ cn $ mpBallP (getCurrentPrecision r) v