Numeric.MixedTypes.Elementary

Square root

class CanSqrt t where

A replacement for Prelude's sqrt. If Floating t, then one can use the default implementation to mirror Prelude's sqrt.

Associated Types

type SqrtType t

Methods

sqrt :: t -> SqrtType t

sqrt :: (SqrtType t ~ t, Floating t) => t -> SqrtType t

Instances

CanSqrt Double

Associated Types

type SqrtType Double :: *

Methods

sqrt :: Double -> SqrtType Double

(CanSqrt a, CanEnsureCE es a, CanEnsureCE es (SqrtType a), SuitableForCE es) => CanSqrt (CollectErrors es a)

Associated Types

type SqrtType (CollectErrors es a) :: *

Methods

sqrt :: CollectErrors es a -> SqrtType (CollectErrors es a)

type CanSqrtSameType t = (CanSqrt t, SqrtType t ~ t)

type CanSqrtCNSameType t = (CanSqrt t, SqrtType t ~ EnsureCN t)

specCanSqrtReal :: (Show t, Show (SqrtType t), Show (PowType (SqrtType t) Integer), Arbitrary t, CanTestCertainly (OrderCompareType (SqrtType t) Integer), CanTestCertainly (EqCompareType (PowType (SqrtType t) Integer) t), HasEqAsymmetric (PowType (SqrtType t) Integer) t, HasOrderAsymmetric (SqrtType t) Integer, CanTestPosNeg t, CanPow (SqrtType t) Integer, CanSqrt t) => T t -> Spec

HSpec properties that each implementation of CanSqrt should satisfy.

Exp

class CanExp t where

A replacement for Prelude's exp. If Floating t, then one can use the default implementation to mirror Prelude's exp.

Associated Types

type ExpType t

Methods

exp :: t -> ExpType t

exp :: (ExpType t ~ t, Floating t) => t -> ExpType t

Instances

CanExp Double

Associated Types

type ExpType Double :: *

Methods

exp :: Double -> ExpType Double

(CanExp a, CanEnsureCE es a, CanEnsureCE es (ExpType a), SuitableForCE es) => CanExp (CollectErrors es a)

Associated Types

type ExpType (CollectErrors es a) :: *

Methods

exp :: CollectErrors es a -> ExpType (CollectErrors es a)

type CanExpSameType t = (CanExp t, ExpType t ~ t)

specCanExpReal :: (Show t, Show (ExpType t), Show (DivType Integer (ExpType t)), Show (ExpType (AddType t t)), Show (MulType (ExpType t) (ExpType t)), Show (EnsureCN (ExpType t)), Arbitrary t, CanEnsureCN (ExpType t), CanTestCertainly (OrderCompareType Integer t), CanTestCertainly (OrderCompareType t Integer), CanTestCertainly (OrderCompareType (ExpType t) Integer), CanTestCertainly (EqCompareType (EnsureCN (ExpType t)) (DivType Integer (ExpType t))), CanTestCertainly (EqCompareType (ExpType (AddType t t)) (MulType (ExpType t) (ExpType t))), CanNeg t, HasEqAsymmetric (ExpType (AddType t t)) (MulType (ExpType t) (ExpType t)), HasEqAsymmetric (EnsureCN (ExpType t)) (DivType Integer (ExpType t)), HasOrderAsymmetric t Integer, HasOrderAsymmetric (ExpType t) Integer, HasOrderAsymmetric Integer t, CanAddAsymmetric t t, CanMulAsymmetric (ExpType t) (ExpType t), CanDiv Integer (ExpType t), CanExp t, CanExp (AddType t t), NegType t ~ t) => T t -> Spec

HSpec properties that each implementation of CanExp should satisfy.

Log

class CanLog t where

A replacement for Prelude's log. If Floating t, then one can use the default implementation to mirror Prelude's log.

Associated Types

type LogType t

Methods

log :: t -> LogType t

log :: (LogType t ~ t, Floating t) => t -> LogType t

Instances

CanLog Double

Associated Types

type LogType Double :: *

Methods

log :: Double -> LogType Double

(CanLog a, CanEnsureCE es a, CanEnsureCE es (LogType a), SuitableForCE es) => CanLog (CollectErrors es a)

Associated Types

type LogType (CollectErrors es a) :: *

Methods

log :: CollectErrors es a -> LogType (CollectErrors es a)

type CanLogSameType t = (CanLog t, LogType t ~ t)

type CanLogCNSameType t = (CanLog t, LogType t ~ EnsureCN t)

specCanLogReal :: (Show t, Show (LogType t), Show (LogType (DivType Integer t)), Show (LogType (MulType t t)), Show (AddType (LogType t) (LogType t)), Show (LogType (ExpType t)), Arbitrary t, CanTestCertainly (OrderCompareType t Integer), CanTestCertainly (OrderCompareType (DivType Integer t) Integer), CanTestCertainly (EqCompareType (LogType (DivType Integer t)) (LogType t)), CanTestCertainly (OrderCompareType (MulType t t) Integer), CanTestCertainly (EqCompareType (LogType (MulType t t)) (AddType (LogType t) (LogType t))), CanTestCertainly (OrderCompareType Integer t), CanTestCertainly (EqCompareType (LogType (ExpType t)) t), CanNeg (LogType t), HasEqAsymmetric (LogType (DivType Integer t)) (LogType t), HasEqAsymmetric (LogType (MulType t t)) (AddType (LogType t) (LogType t)), HasEqAsymmetric (LogType (ExpType t)) t, HasOrderAsymmetric t Integer, HasOrderAsymmetric (DivType Integer t) Integer, HasOrderAsymmetric (MulType t t) Integer, HasOrderAsymmetric Integer t, CanAddAsymmetric (LogType t) (LogType t), CanMulAsymmetric t t, CanDiv Integer t, CanExp t, CanLog t, CanLog (DivType Integer t), CanLog (MulType t t), CanLog (ExpType t), LogType t ~ NegType (LogType t)) => T t -> Spec

HSpec properties that each implementation of CanLog should satisfy.

powUsingExpLog :: (CanTestPosNeg t, CanEnsureCN t, CanEnsureCN (EnsureCN t), EnsureCN t ~ EnsureCN (EnsureCN t), CanLogCNSameType t, CanMulSameType t, CanMulSameType (EnsureCN t), CanExpSameType (EnsureCN t), CanTestInteger t, CanTestZero t, CanRecipCNSameType t) => t -> t -> t -> t -> EnsureCN t

Sine and cosine

class CanSinCos t where

A replacement for Prelude's cos and sin. If Floating t, then one can use the default implementation to mirror Prelude's sin, cos.

Associated Types

type SinCosType t

Methods

cos :: t -> SinCosType t

cos :: (SinCosType t ~ t, Floating t) => t -> SinCosType t

sin :: t -> SinCosType t

sin :: (SinCosType t ~ t, Floating t) => t -> SinCosType t

Instances

CanSinCos Double

Associated Types

type SinCosType Double :: *

Methods

cos :: Double -> SinCosType Double

sin :: Double -> SinCosType Double

(CanSinCos a, CanEnsureCE es a, CanEnsureCE es (SinCosType a), SuitableForCE es) => CanSinCos (CollectErrors es a)

Associated Types

type SinCosType (CollectErrors es a) :: *

Methods

cos :: CollectErrors es a -> SinCosType (CollectErrors es a)

sin :: CollectErrors es a -> SinCosType (CollectErrors es a)

type CanSinCosSameType t = (CanSinCos t, SinCosType t ~ t)

specCanSinCosReal :: (Show t, Show (SinCosType t), Show (AddType (PowType (SinCosType t) Integer) (PowType (SinCosType t) Integer)), Show (SinCosType (SubType t t)), Show (SubType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t))), Show (AddType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t))), Show (DivType (SinCosType t) (SinCosType t)), Show (EnsureCN t), Arbitrary t, CanEnsureCN t, CanTestCertainly (OrderCompareType Integer (SinCosType t)), CanTestCertainly (OrderCompareType (SinCosType t) Integer), CanTestCertainly (EqCompareType (AddType (PowType (SinCosType t) Integer) (PowType (SinCosType t) Integer)) Integer), CanTestCertainly (EqCompareType (SinCosType (SubType t t)) (SubType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t)))), CanTestCertainly (EqCompareType (SinCosType (SubType t t)) (AddType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t)))), CanTestCertainly (OrderCompareType t Integer), CanTestCertainly (OrderCompareType t Rational), CanTestCertainly (OrderCompareType (SinCosType t) t), CanTestCertainly (OrderCompareType (EnsureCN t) (DivType (SinCosType t) (SinCosType t))), HasEqAsymmetric (AddType (PowType (SinCosType t) Integer) (PowType (SinCosType t) Integer)) Integer, HasEqAsymmetric (SinCosType (SubType t t)) (SubType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t))), HasEqAsymmetric (SinCosType (SubType t t)) (AddType (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t))), HasOrderAsymmetric t Integer, HasOrderAsymmetric t Rational, HasOrderAsymmetric (SinCosType t) t, HasOrderAsymmetric (SinCosType t) Integer, HasOrderAsymmetric (EnsureCN t) (DivType (SinCosType t) (SinCosType t)), HasOrderAsymmetric Integer (SinCosType t), CanSub t t, CanSub (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t)), CanAddAsymmetric (PowType (SinCosType t) Integer) (PowType (SinCosType t) Integer), CanAddAsymmetric (MulType (SinCosType t) (SinCosType t)) (MulType (SinCosType t) (SinCosType t)), CanPow (SinCosType t) Integer, CanMulAsymmetric (SinCosType t) (SinCosType t), CanDiv (SinCosType t) (SinCosType t), CanSinCos t, CanSinCos (SubType t t)) => T t -> Spec

HSpec properties that each implementation of CanSinCos should satisfy.

Derived partially from http://math.stackexchange.com/questions/1303044/axiomatic-definition-of-sin-and-cos

approxPi :: Floating t => t

Approximate pi, synonym for Prelude's pi.

We do not define (exect) pi in this package as we have no type that can represent it exactly.

Orphan instances

CanPow Double Double

Associated Types

type PowTypeNoCN Double Double :: *

type PowType Double Double :: *

Methods

powNoCN :: Double -> Double -> PowTypeNoCN Double Double

pow :: Double -> Double -> PowType Double Double

CanPow Double Rational

Associated Types

type PowTypeNoCN Double Rational :: *

type PowType Double Rational :: *

Methods

powNoCN :: Double -> Rational -> PowTypeNoCN Double Rational

pow :: Double -> Rational -> PowType Double Rational

CanPow Int Double

Associated Types

type PowTypeNoCN Int Double :: *

type PowType Int Double :: *

Methods

powNoCN :: Int -> Double -> PowTypeNoCN Int Double

pow :: Int -> Double -> PowType Int Double

CanPow Integer Double

Associated Types

type PowTypeNoCN Integer Double :: *

type PowType Integer Double :: *

Methods

powNoCN :: Integer -> Double -> PowTypeNoCN Integer Double

pow :: Integer -> Double -> PowType Integer Double

CanPow Rational Double

Associated Types

type PowTypeNoCN Rational Double :: *

type PowType Rational Double :: *

Methods

powNoCN :: Rational -> Double -> PowTypeNoCN Rational Double

pow :: Rational -> Double -> PowType Rational Double