{-# OPTIONS_GHC -Wno-orphans #-}
{-|
    Module      :  AERN2.Real.Tests
    Description :  Tests for operations on Cauchy real numbers
    Copyright   :  (c) Michal Konecny
    License     :  BSD3

    Maintainer  :  mikkonecny@gmail.com
    Stability   :  experimental
    Portability :  portable

    Tests for operations on Cauchy real numbers.

    To run the tests using stack, execute:

    @
    stack test aern2-real --test-arguments "-a 1000 -m CReal"
    @
-}
module AERN2.Real.Tests
  (
    specCReal, tCReal
  )
where

import MixedTypesNumPrelude
-- import qualified Prelude as P
-- import Data.Ratio
-- import Text.Printf

import qualified Numeric.CollectErrors as CN

import Test.Hspec
import Test.QuickCheck
-- import qualified Test.Hspec.SmallCheck as SC

-- import AERN2.Norm
import AERN2.MP.Accuracy
--
import AERN2.MP
import AERN2.MP.Dyadic

import AERN2.Limit
import AERN2.Select
import AERN2.Real.Type
-- import AERN2.Real.CKleenean
import AERN2.Real.Field ()
import AERN2.Real.Elementary ()
import AERN2.Real.Limit ()

instance Arbitrary CReal where
  arbitrary :: Gen CReal
arbitrary =
    forall a. [(Int, Gen a)] -> Gen a
frequency
      [(forall t. CanBeInt t => t -> Int
int Integer
1, forall t. CanBeCReal t => t -> CReal
creal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a.
(Arbitrary a, HasOrderCertainly a Integer) =>
Integer -> Gen a
arbitrarySmall Integer
1000000 :: Gen Integer)),
       (forall t. CanBeInt t => t -> Int
int Integer
1, forall t. CanBeCReal t => t -> CReal
creal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a.
(Arbitrary a, HasOrderCertainly a Integer) =>
Integer -> Gen a
arbitrarySmall Integer
1000000 :: Gen Rational)),
       (forall t. CanBeInt t => t -> Int
int Integer
2, forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
(*) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a.
(Arbitrary a, HasOrderCertainly a Integer) =>
Integer -> Gen a
arbitrarySmall Integer
1000000 :: Gen Integer) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen CReal
arbitrarySignedBinary)
      ]
      where
      arbitrarySignedBinary :: Gen CReal
arbitrarySignedBinary =
        forall {a}.
(EqCompareType a Integer ~ Bool, HasEqAsymmetric a Integer) =>
[a] -> CReal
signedBinary2Real forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Gen a -> Gen [a]
infiniteListOf (forall a. [a] -> Gen a
elements [-Integer
1,Integer
0,Integer
1])
      signedBinary2Real :: [a] -> CReal
signedBinary2Real [a]
sbits =
        (Precision -> CN MPBall) -> CReal
crealFromPrecFunction forall a b. (a -> b) -> a -> b
$ \ Precision
p -> forall v. v -> CN v
cn forall a b. (a -> b) -> a -> b
$ [MPBall]
balls forall n a. CanBeInteger n => [a] -> n -> a
!! Precision
p
        where
        balls :: [MPBall]
balls = forall {a} {t}.
(EqCompareType a Integer ~ Bool, MulType (AddType t t) Dyadic ~ t,
 MulType (AddType t (MulType (AddType t t) Dyadic)) Dyadic ~ t,
 MinMaxType (IntervalEndpoint t) (IntervalEndpoint t)
 ~ IntervalEndpoint t,
 HasEqAsymmetric a Integer, CanAddAsymmetric t t,
 CanAddAsymmetric t (MulType (AddType t t) Dyadic),
 CanMulAsymmetric (AddType t t) Dyadic,
 CanMulAsymmetric (AddType t (MulType (AddType t t) Dyadic)) Dyadic,
 CanSetPrecision t, IsInterval t,
 CanMinMaxAsymmetric (IntervalEndpoint t) (IntervalEndpoint t)) =>
t -> [(a, Precision)] -> [t]
nextBit (forall t. CanBeMPBall t => t -> MPBall
mpBall (Integer
0,Integer
1)) forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [(a, b)]
zip [a]
sbits (forall a b. (a -> b) -> [a] -> [b]
map Integer -> Precision
prec [Integer
10..])
        nextBit :: t -> [(a, Precision)] -> [t]
nextBit t
ball ((a
sbit, Precision
p):[(a, Precision)]
rest) =
          t
ball forall a. a -> [a] -> [a]
: t -> [(a, Precision)] -> [t]
nextBit t
newBall [(a, Precision)]
rest
          where
          newBall :: t
newBall =
            case a
sbit of
              (-1) -> forall i.
(IsInterval i, CanMinMaxSameType (IntervalEndpoint i)) =>
i -> i -> i
fromEndpointsAsIntervals t
l MulType (AddType t t) Dyadic
m
              a
0 -> forall i.
(IsInterval i, CanMinMaxSameType (IntervalEndpoint i)) =>
i -> i -> i
fromEndpointsAsIntervals MulType (AddType t (MulType (AddType t t) Dyadic)) Dyadic
l2 MulType (AddType t (MulType (AddType t t) Dyadic)) Dyadic
r2
              a
1 -> forall i.
(IsInterval i, CanMinMaxSameType (IntervalEndpoint i)) =>
i -> i -> i
fromEndpointsAsIntervals MulType (AddType t t) Dyadic
m t
r
              a
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"in Arbitrary CReal"
          (t
l_,t
r_) = forall i. IsInterval i => i -> (i, i)
endpointsAsIntervals t
ball
          l :: t
l = forall t. CanSetPrecision t => Precision -> t -> t
setPrecision Precision
p t
l_
          r :: t
r = forall t. CanSetPrecision t => Precision -> t -> t
setPrecision Precision
p t
r_
          m :: MulType (AddType t t) Dyadic
m = (t
l forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
+ t
r) forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
* (forall t. CanBeDyadic t => t -> Dyadic
dyadic Rational
0.5)
          l2 :: MulType (AddType t (MulType (AddType t t) Dyadic)) Dyadic
l2 = (t
l forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
+ MulType (AddType t t) Dyadic
m) forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
* (forall t. CanBeDyadic t => t -> Dyadic
dyadic Rational
0.5)
          r2 :: MulType (AddType t (MulType (AddType t t) Dyadic)) Dyadic
r2 = (t
r forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
+ MulType (AddType t t) Dyadic
m) forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
* (forall t. CanBeDyadic t => t -> Dyadic
dyadic Rational
0.5)
        nextBit t
_ [(a, Precision)]
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"in Arbitrary CReal"

arbitrarySmall :: (Arbitrary a, HasOrderCertainly a Integer) => Integer -> Gen a
arbitrarySmall :: forall a.
(Arbitrary a, HasOrderCertainly a Integer) =>
Integer -> Gen a
arbitrarySmall Integer
bound = Gen a
aux
  where
  aux :: Gen a
aux =
    do
    a
x <- forall a. Arbitrary a => Gen a
arbitrary
    if -Integer
bound forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<=! a
x forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& a
x forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<=! Integer
bound
      then forall (m :: * -> *) a. Monad m => a -> m a
return a
x
      else Gen a
aux


{-|
  A runtime representative of type @CReal@.
  Used for specialising polymorphic tests to concrete types.
-}
tCReal :: T CReal
tCReal :: T CReal
tCReal = forall t. [Char] -> T t
T [Char]
"CReal"

specCRrespectsAccuracy1 ::
  String ->
  (CReal -> CReal) ->
  (CReal -> Accuracy -> Bool) ->
  Spec
specCRrespectsAccuracy1 :: [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
opName CReal -> CReal
op CReal -> Accuracy -> Bool
precond =
  forall a.
(HasCallStack, Example a) =>
[Char] -> a -> SpecWith (Arg a)
it ([Char]
opName forall a. [a] -> [a] -> [a]
++ [Char]
" respects accuracy requests") forall a b. (a -> b) -> a -> b
$ do
    forall prop. Testable prop => prop -> Property
property forall a b. (a -> b) -> a -> b
$
      \ (CReal
x :: CReal) (Accuracy
ac :: Accuracy) ->
        Accuracy
ac forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
< (forall t. ConvertibleExactly t Accuracy => t -> Accuracy
bits Integer
1000) forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& CReal -> Accuracy -> Bool
precond CReal
x Accuracy
ac forall prop. Testable prop => Bool -> prop -> Property
==>
        case forall es v. CanBeErrors es => CollectErrors es v -> Either es v
CN.toEither ((CReal -> CReal
op CReal
x) forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) of
          Right MPBall
v -> forall a. HasAccuracy a => a -> Accuracy
getAccuracy MPBall
v Accuracy -> Accuracy -> Property
>=$ Accuracy
ac
          Either NumErrors MPBall
_ -> forall prop. Testable prop => prop -> Property
property Bool
True

specCRrespectsAccuracy2 ::
  String ->
  (CReal -> CReal -> CReal) ->
  (CReal -> Accuracy -> Bool) ->
  (CReal -> Accuracy -> Bool) ->
  Spec
specCRrespectsAccuracy2 :: [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
opName CReal -> CReal -> CReal
op CReal -> Accuracy -> Bool
precond1 CReal -> Accuracy -> Bool
precond2 =
  forall a.
(HasCallStack, Example a) =>
[Char] -> a -> SpecWith (Arg a)
it ([Char]
opName forall a. [a] -> [a] -> [a]
++ [Char]
" respects accuracy requests") forall a b. (a -> b) -> a -> b
$ do
    forall prop. Testable prop => prop -> Property
property forall a b. (a -> b) -> a -> b
$
      \ (CReal
x :: CReal) (CReal
y :: CReal) (Accuracy
ac :: Accuracy) ->
        Accuracy
ac forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
< (forall t. ConvertibleExactly t Accuracy => t -> Accuracy
bits Integer
1000) forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& CReal -> Accuracy -> Bool
precond1 CReal
x Accuracy
ac forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& CReal -> Accuracy -> Bool
precond2 CReal
y Accuracy
ac forall prop. Testable prop => Bool -> prop -> Property
==>
        case forall es v. CanBeErrors es => CollectErrors es v -> Either es v
CN.toEither ((CReal -> CReal -> CReal
op CReal
x CReal
y) forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) of
          Right MPBall
v -> forall a. HasAccuracy a => a -> Accuracy
getAccuracy MPBall
v Accuracy -> Accuracy -> Property
>=$ Accuracy
ac
          Either NumErrors MPBall
_ -> forall prop. Testable prop => prop -> Property
property Bool
True

(>=$) :: Accuracy -> Accuracy -> Property
>=$ :: Accuracy -> Accuracy -> Property
(>=$) = forall prop a b.
(Testable prop, Show a, Show b) =>
[Char] -> (a -> b -> prop) -> a -> b -> Property
printArgsIfFails2 [Char]
">=" forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
(>=)

precondAnyReal :: CReal -> Accuracy -> Bool
precondAnyReal :: CReal -> Accuracy -> Bool
precondAnyReal CReal
_x Accuracy
_ac = Bool
True

precondPositiveReal :: CReal -> Accuracy -> Bool
precondPositiveReal :: CReal -> Accuracy -> Bool
precondPositiveReal CReal
x Accuracy
ac = (CReal
x forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!>! Integer
0

precondNonZeroReal :: CReal -> Accuracy -> Bool
precondNonZeroReal :: CReal -> Accuracy -> Bool
precondNonZeroReal CReal
x Accuracy
ac = (CReal
x forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!/=! Integer
0

precondSmallReal :: CReal -> Accuracy -> Bool
precondSmallReal :: CReal -> Accuracy -> Bool
precondSmallReal CReal
x Accuracy
ac = forall t. CanAbs t => t -> AbsType t
abs (CReal
x forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<! Integer
1000

precondPositiveSmallReal :: CReal -> Accuracy -> Bool
precondPositiveSmallReal :: CReal -> Accuracy -> Bool
precondPositiveSmallReal CReal
x Accuracy
ac = Integer
0 forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<! ExtractedApproximation CReal Accuracy
b forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& ExtractedApproximation CReal Accuracy
b forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<! Integer
1000
  where b :: ExtractedApproximation CReal Accuracy
b = CReal
x forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac

-- specCRrespectsAccuracy2 ::
--   String ->
--   (CReal -> CReal -> CReal) ->
--   (CReal -> Accuracy -> Bool) ->
--   (CReal -> Accuracy -> Bool) ->
--   Spec
-- specCRrespectsAccuracy2 opName op =
--   specCRrespectsAccuracy2CN opName (\ a b -> cn (op a b))

specCRrespectsAccuracy2T ::
  (Arbitrary t, Show t) =>
  T t ->
  String ->
  (CReal -> t -> CReal) ->
  (CReal -> Accuracy -> Bool) ->
  (t -> Bool) ->
  Spec
specCRrespectsAccuracy2T :: forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T  (T [Char]
tName :: T t) [Char]
opName CReal -> t -> CReal
op CReal -> Accuracy -> Bool
precond1 t -> Bool
precond2 =
  forall a.
(HasCallStack, Example a) =>
[Char] -> a -> SpecWith (Arg a)
it ([Char]
opName forall a. [a] -> [a] -> [a]
++ [Char]
" with " forall a. [a] -> [a] -> [a]
++ [Char]
tName forall a. [a] -> [a] -> [a]
++ [Char]
" respects accuracy requests") forall a b. (a -> b) -> a -> b
$ do
    forall prop. Testable prop => prop -> Property
property forall a b. (a -> b) -> a -> b
$
      \ (CReal
x :: CReal) (t
t :: t) (Accuracy
ac :: Accuracy) ->
        Accuracy
ac forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
< (forall t. ConvertibleExactly t Accuracy => t -> Accuracy
bits Integer
1000) forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& CReal -> Accuracy -> Bool
precond1 CReal
x Accuracy
ac forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& t -> Bool
precond2 t
t forall prop. Testable prop => Bool -> prop -> Property
==>
        case forall es v. CanBeErrors es => CollectErrors es v -> Either es v
CN.toEither ((CReal -> t -> CReal
op CReal
x t
t) forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Accuracy
ac) of
          Right MPBall
v -> forall a. HasAccuracy a => a -> Accuracy
getAccuracy MPBall
v Accuracy -> Accuracy -> Property
>=$ Accuracy
ac
          Either NumErrors MPBall
_ -> forall prop. Testable prop => prop -> Property
property Bool
True

precondAnyT :: t -> Bool
precondAnyT :: forall t. t -> Bool
precondAnyT t
_t = Bool
True

precondNonZeroT :: (HasEqCertainly t Integer) => t -> Bool
precondNonZeroT :: forall t. HasEqCertainly t Integer => t -> Bool
precondNonZeroT t
t = t
t forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!/=! Integer
0

precondSmallT :: (HasOrderCertainly t Integer) => t -> Bool
precondSmallT :: forall t. HasOrderCertainly t Integer => t -> Bool
precondSmallT t
t = -Integer
1000 forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<=! t
t forall a b. CanAndOrAsymmetric a b => a -> b -> AndOrType a b
&& t
t forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<=! Integer
1000

specCReal :: Spec
specCReal :: Spec
specCReal =
  forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe ([Char]
"CReal") forall a b. (a -> b) -> a -> b
$ do
    -- specConversion tInteger tCReal creal (fst . integerBounds)
    -- describe "order" $ do
    --   specHasEqNotMixed tCReal
    --   specHasEq tInt tCReal tRational
    --   specCanPickNonZero tCReal
    --   specHasOrderNotMixed tCReal
    --   specHasOrder tInt tCReal tRational
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"min/max/abs" forall a b. (a -> b) -> a -> b
$ do
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"abs" forall t. CanAbs t => t -> AbsType t
abs CReal -> Accuracy -> Bool
precondAnyReal
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"max" forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondAnyReal
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"min" forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondAnyReal
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"ring" forall a b. (a -> b) -> a -> b
$ do
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"negate" forall t. CanNeg t => t -> NegType t
negate CReal -> Accuracy -> Bool
precondAnyReal
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"+" forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
add CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondAnyReal
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Integer
tInteger [Char]
"+" forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
add CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Rational
tRational [Char]
"+" forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
add CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Dyadic
tDyadic [Char]
"+" forall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
add CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"a-b" forall t1 t2. CanSub t1 t2 => t1 -> t2 -> SubType t1 t2
sub CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondAnyReal
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Integer
tInteger [Char]
"a-b" forall t1 t2. CanSub t1 t2 => t1 -> t2 -> SubType t1 t2
sub CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Rational
tRational [Char]
"a-b" forall t1 t2. CanSub t1 t2 => t1 -> t2 -> SubType t1 t2
sub CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Dyadic
tDyadic [Char]
"a-b" forall t1 t2. CanSub t1 t2 => t1 -> t2 -> SubType t1 t2
sub CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"*" forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
mul CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondAnyReal
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Integer
tInteger [Char]
"*" forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
mul CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Rational
tRational [Char]
"*" forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
mul CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Dyadic
tDyadic [Char]
"*" forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
mul CReal -> Accuracy -> Bool
precondAnyReal forall t. t -> Bool
precondAnyT
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"field" forall a b. (a -> b) -> a -> b
$ do
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"/" forall t1 t2. CanDiv t1 t2 => t1 -> t2 -> DivType t1 t2
divide CReal -> Accuracy -> Bool
precondAnyReal CReal -> Accuracy -> Bool
precondNonZeroReal
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Integer
tInteger [Char]
"/" forall t1 t2. CanDiv t1 t2 => t1 -> t2 -> DivType t1 t2
divide CReal -> Accuracy -> Bool
precondAnyReal forall t. HasEqCertainly t Integer => t -> Bool
precondNonZeroT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Rational
tRational [Char]
"/" forall t1 t2. CanDiv t1 t2 => t1 -> t2 -> DivType t1 t2
divide CReal -> Accuracy -> Bool
precondAnyReal forall t. HasEqCertainly t Integer => t -> Bool
precondNonZeroT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Dyadic
tDyadic [Char]
"/" forall t1 t2. CanDiv t1 t2 => t1 -> t2 -> DivType t1 t2
divide CReal -> Accuracy -> Bool
precondAnyReal forall t. HasEqCertainly t Integer => t -> Bool
precondNonZeroT
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"elementary" forall a b. (a -> b) -> a -> b
$ do
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"sqrt" forall t. CanSqrt t => t -> SqrtType t
sqrt CReal -> Accuracy -> Bool
precondPositiveReal
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"exp" forall t. CanExp t => t -> ExpType t
exp CReal -> Accuracy -> Bool
precondSmallReal
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"log" forall t. CanLog t => t -> LogType t
log CReal -> Accuracy -> Bool
precondPositiveSmallReal
      [Char]
-> (CReal -> CReal -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (CReal -> Accuracy -> Bool)
-> Spec
specCRrespectsAccuracy2 [Char]
"pow" forall b e. CanPow b e => b -> e -> PowType b e
pow CReal -> Accuracy -> Bool
precondPositiveSmallReal CReal -> Accuracy -> Bool
precondSmallReal
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Integer
tInteger [Char]
"pow" forall b e. CanPow b e => b -> e -> PowType b e
pow CReal -> Accuracy -> Bool
precondNonZeroReal forall t. HasOrderCertainly t Integer => t -> Bool
precondSmallT
      forall t.
(Arbitrary t, Show t) =>
T t
-> [Char]
-> (CReal -> t -> CReal)
-> (CReal -> Accuracy -> Bool)
-> (t -> Bool)
-> Spec
specCRrespectsAccuracy2T T Rational
tRational [Char]
"pow" forall b e. CanPow b e => b -> e -> PowType b e
pow CReal -> Accuracy -> Bool
precondPositiveSmallReal forall t. HasOrderCertainly t Integer => t -> Bool
precondSmallT
      -- specCRrespectsAccuracy2T tDyadic "pow" pow precondPositiveSmallReal precondSmallT
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"cos" forall t. CanSinCos t => t -> SinCosType t
cos CReal -> Accuracy -> Bool
precondAnyReal
      [Char] -> (CReal -> CReal) -> (CReal -> Accuracy -> Bool) -> Spec
specCRrespectsAccuracy1 [Char]
"sine" forall t. CanSinCos t => t -> SinCosType t
sin CReal -> Accuracy -> Bool
precondAnyReal
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"select" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
[Char] -> a -> SpecWith (Arg a)
it [Char]
"soft abs via select" forall a b. (a -> b) -> a -> b
$ do
        forall prop. Testable prop => prop -> Property
property forall a b. (a -> b) -> a -> b
$ \ (CReal
x :: CReal) (Precision
p :: Precision) (Rational
q :: Rational) ->
          (Integer
1 forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
< Rational
q) forall prop. Testable prop => Bool -> prop -> Property
==>
          let eps :: DivType Integer Rational
eps = Integer
1forall t1 t2. CanDiv t1 t2 => t1 -> t2 -> DivType t1 t2
/Rational
q in
          (forall t. CanAbs t => t -> AbsType t
abs (forall t. CanAbs t => t -> AbsType t
abs CReal
x forall t1 t2. CanSub t1 t2 => t1 -> t2 -> SubType t1 t2
- (if forall k. CanSelect k => k -> k -> SelectType k
select (CReal
x forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
> -DivType Integer Rational
eps) (CReal
x forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
< DivType Integer Rational
eps) then CReal
x else -CReal
x)) forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
p) forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
?<? Integer
2forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
*DivType Integer Rational
eps
    forall a. HasCallStack => [Char] -> SpecWith a -> SpecWith a
describe [Char]
"limit" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
[Char] -> a -> SpecWith (Arg a)
it [Char]
"computing e as a limit of Taylor series" forall a b. (a -> b) -> a -> b
$ do
        forall prop. Testable prop => prop -> Property
property forall a b. (a -> b) -> a -> b
$ \ (Precision
p :: Precision) ->
          ((forall t. CanExp t => t -> ExpType t
exp (forall t. CanBeMPBallP t => Precision -> t -> MPBall
mpBallP Precision
p Rational
1.0)) forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
?==?) forall a b. (a -> b) -> a -> b
$
            (forall ix s. HasLimits ix s => (ix -> s) -> LimitType ix s
limit forall a b. (a -> b) -> a -> b
$ \(Integer
n :: Integer) -> forall t.
(CanAddSameType t, ConvertibleExactly Integer t) =>
[t] -> t
sum forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall t. CanRecip t => t -> DivType Integer t
recip forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. CanBeCReal t => t -> CReal
creal) forall a b. (a -> b) -> a -> b
$ forall n a. CanBeInteger n => n -> [a] -> [a]
take (Integer
nforall t1 t2. CanAddAsymmetric t1 t2 => t1 -> t2 -> AddType t1 t2
+Integer
3) forall a b. (a -> b) -> a -> b
$ forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl forall t1 t2. CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2
(*) Integer
1 [Integer
1..(Integer
n)]) forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
p