{-# OPTIONS_GHC -Wno-orphans #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StandaloneDeriving #-}
{-|
    Module      :  AERN2.MP.WithCurrentPrec.PreludeInstances
    Description :  WithCurrentPrec instances of Prelude classes
    Copyright   :  (c) Michal Konecny
    License     :  BSD3

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

    WithCurrentPrec instances of Prelude classes
-}
module AERN2.MP.WithCurrentPrec.PreludeInstances
(
    _example1P , _example2P , _example3P
)
where

import Prelude
-- import Text.Printf

import Numeric.CollectErrors (cn, CN)

import AERN2.MP.Precision
import AERN2.MP.Ball

import AERN2.MP.WithCurrentPrec.Type

{-
********************************
Instances of Prelude classes
********************************
-}

instance Eq t => Eq (WithCurrentPrec t p) where
    == :: WithCurrentPrec t p -> WithCurrentPrec t p -> Bool
(==) = (t -> t -> Bool)
-> WithCurrentPrec t p -> WithCurrentPrec t p -> Bool
forall k (p1 :: k) (p2 :: k) t1 t2 t3.
(p1 ~ p2) =>
(t1 -> t2 -> t3)
-> WithCurrentPrec t1 p1 -> WithCurrentPrec t2 p2 -> t3
lift2P t -> t -> Bool
forall a. Eq a => a -> a -> Bool
(==)
instance Ord t => Ord (WithCurrentPrec t p) where
    compare :: WithCurrentPrec t p -> WithCurrentPrec t p -> Ordering
compare = (t -> t -> Ordering)
-> WithCurrentPrec t p -> WithCurrentPrec t p -> Ordering
forall k (p1 :: k) (p2 :: k) t1 t2 t3.
(p1 ~ p2) =>
(t1 -> t2 -> t3)
-> WithCurrentPrec t1 p1 -> WithCurrentPrec t2 p2 -> t3
lift2P t -> t -> Ordering
forall a. Ord a => a -> a -> Ordering
compare

instance 
    (HasCurrentPrecision p, Num t, ConvertibleWithPrecision Integer t) 
    => 
    Num (WithCurrentPrec t p) 
    where
    fromInteger :: Integer -> WithCurrentPrec t p
fromInteger Integer
n = WithCurrentPrec t p
r
        where   
        r :: WithCurrentPrec t p
r = t -> WithCurrentPrec t p
forall k t (p :: k). t -> WithCurrentPrec t p
WithCurrentPrec (t -> WithCurrentPrec t p) -> t -> WithCurrentPrec t p
forall a b. (a -> b) -> a -> b
$ Precision -> Integer -> t
forall t1 t2.
ConvertibleWithPrecision t1 t2 =>
Precision -> t1 -> t2
convertP (WithCurrentPrec t p -> Precision
forall k (p :: k) (proxy :: k -> *).
HasCurrentPrecision p =>
proxy p -> Precision
getCurrentPrecision WithCurrentPrec t p
r) Integer
n
    negate :: WithCurrentPrec t p -> WithCurrentPrec t p
negate = (t -> t) -> WithCurrentPrec t p -> WithCurrentPrec t p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 t -> t
forall a. Num a => a -> a
negate
    abs :: WithCurrentPrec t p -> WithCurrentPrec t p
abs = (t -> t) -> WithCurrentPrec t p -> WithCurrentPrec t p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 t -> t
forall a. Num a => a -> a
abs
    + :: WithCurrentPrec t p -> WithCurrentPrec t p -> WithCurrentPrec t p
(+) = (t -> t -> t)
-> WithCurrentPrec t p
-> WithCurrentPrec t p
-> WithCurrentPrec t p
forall k (p1 :: k) (p2 :: k) t1 t2 t3.
(p1 ~ p2) =>
(t1 -> t2 -> t3)
-> WithCurrentPrec t1 p1
-> WithCurrentPrec t2 p2
-> WithCurrentPrec t3 p1
lift2 t -> t -> t
forall a. Num a => a -> a -> a
(+)
    * :: WithCurrentPrec t p -> WithCurrentPrec t p -> WithCurrentPrec t p
(*) = (t -> t -> t)
-> WithCurrentPrec t p
-> WithCurrentPrec t p
-> WithCurrentPrec t p
forall k (p1 :: k) (p2 :: k) t1 t2 t3.
(p1 ~ p2) =>
(t1 -> t2 -> t3)
-> WithCurrentPrec t1 p1
-> WithCurrentPrec t2 p2
-> WithCurrentPrec t3 p1
lift2 t -> t -> t
forall a. Num a => a -> a -> a
(*)
    signum :: WithCurrentPrec t p -> WithCurrentPrec t p
signum = (t -> t) -> WithCurrentPrec t p -> WithCurrentPrec t p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 t -> t
forall a. Num a => a -> a
signum

instance 
    (HasCurrentPrecision p, Fractional t
    , ConvertibleWithPrecision Integer t, ConvertibleWithPrecision Rational t) 
    => 
    Fractional (WithCurrentPrec t p) 
    where
    fromRational :: Rational -> WithCurrentPrec t p
fromRational Rational
q = WithCurrentPrec t p
r
        where   
        r :: WithCurrentPrec t p
r = t -> WithCurrentPrec t p
forall k t (p :: k). t -> WithCurrentPrec t p
WithCurrentPrec (t -> WithCurrentPrec t p) -> t -> WithCurrentPrec t p
forall a b. (a -> b) -> a -> b
$ Precision -> Rational -> t
forall t1 t2.
ConvertibleWithPrecision t1 t2 =>
Precision -> t1 -> t2
convertP (WithCurrentPrec t p -> Precision
forall k (p :: k) (proxy :: k -> *).
HasCurrentPrecision p =>
proxy p -> Precision
getCurrentPrecision WithCurrentPrec t p
r) Rational
q
    recip :: WithCurrentPrec t p -> WithCurrentPrec t p
recip = (t -> t) -> WithCurrentPrec t p -> WithCurrentPrec t p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 t -> t
forall a. Fractional a => a -> a
recip
    / :: WithCurrentPrec t p -> WithCurrentPrec t p -> WithCurrentPrec t p
(/) = (t -> t -> t)
-> WithCurrentPrec t p
-> WithCurrentPrec t p
-> WithCurrentPrec t p
forall k (p1 :: k) (p2 :: k) t1 t2 t3.
(p1 ~ p2) =>
(t1 -> t2 -> t3)
-> WithCurrentPrec t1 p1
-> WithCurrentPrec t2 p2
-> WithCurrentPrec t3 p1
lift2 t -> t -> t
forall a. Fractional a => a -> a -> a
(/)

instance (HasCurrentPrecision p) => Floating (WithCurrentPrec (CN MPBall) p) where
    pi :: WithCurrentPrec (CN MPBall) p
pi = WithCurrentPrec (CN MPBall) p
r 
        where
        r :: WithCurrentPrec (CN MPBall) p
r = CN MPBall -> WithCurrentPrec (CN MPBall) p
forall k t (p :: k). t -> WithCurrentPrec t p
WithCurrentPrec (CN MPBall -> WithCurrentPrec (CN MPBall) p)
-> CN MPBall -> WithCurrentPrec (CN MPBall) p
forall a b. (a -> b) -> a -> b
$ MPBall -> CN MPBall
forall v. v -> CN v
cn (MPBall -> CN MPBall) -> MPBall -> CN MPBall
forall a b. (a -> b) -> a -> b
$ Precision -> MPBall
piBallP (WithCurrentPrec (CN MPBall) p -> Precision
forall k (p :: k) (proxy :: k -> *).
HasCurrentPrecision p =>
proxy p -> Precision
getCurrentPrecision WithCurrentPrec (CN MPBall) p
r)
    sqrt :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
sqrt = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
sqrt
    exp :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
exp = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
exp
    log :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
log = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
log
    sin :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
sin = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
sin
    cos :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
cos = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
cos
    asin :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
asin = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
asin
    acos :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
acos = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
acos
    atan :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
atan = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
atan
    sinh :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
sinh = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
sinh
    cosh :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
cosh = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
cosh
    asinh :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
asinh = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
asinh
    acosh :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
acosh = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
acosh
    atanh :: WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
atanh = (CN MPBall -> CN MPBall)
-> WithCurrentPrec (CN MPBall) p -> WithCurrentPrec (CN MPBall) p
forall k t1 t2 (p :: k).
(t1 -> t2) -> WithCurrentPrec t1 p -> WithCurrentPrec t2 p
lift1 CN MPBall -> CN MPBall
forall a. Floating a => a -> a
atanh

_example1P :: CN MPBall
_example1P :: CN MPBall
_example1P = Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
-> CN MPBall
forall t.
Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec t n) -> t
runWithPrec (Integer -> Precision
prec Integer
1000) forall a. Floating a => a
forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n
pi

_example2P :: CN MPBall
_example2P :: CN MPBall
_example2P = Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
-> CN MPBall
forall t.
Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec t n) -> t
runWithPrec (Integer -> Precision
prec Integer
1000) ((forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
 -> CN MPBall)
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
-> CN MPBall
forall a b. (a -> b) -> a -> b
$ WithCurrentPrec (CN MPBall) n
forall a. Floating a => a
pi WithCurrentPrec (CN MPBall) n
-> WithCurrentPrec (CN MPBall) n -> WithCurrentPrec (CN MPBall) n
forall a. Num a => a -> a -> a
- WithCurrentPrec (CN MPBall) n
forall a. Floating a => a
pi

_example3P :: CN MPBall
_example3P :: CN MPBall
_example3P = Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
-> CN MPBall
forall t.
Precision
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec t n) -> t
runWithPrec (Integer -> Precision
prec Integer
1000) ((forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
 -> CN MPBall)
-> (forall (n :: Nat). KnownNat n => WithCurrentPrec (CN MPBall) n)
-> CN MPBall
forall a b. (a -> b) -> a -> b
$ WithCurrentPrec (CN MPBall) n -> WithCurrentPrec (CN MPBall) n
forall a. Floating a => a -> a
sqrt WithCurrentPrec (CN MPBall) n
2