{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module AERN2.Real.Comparisons
()
where
import MixedTypesNumPrelude
import qualified Prelude as P
import AERN2.MP.Ball
import AERN2.MP.Dyadic
import AERN2.Real.Type
import AERN2.Real.CKleenean ()
instance
(HasEqAsymmetric t1 t2, IsBool (CSequence (EqCompareType t1 t2)))
=>
HasEqAsymmetric (CSequence t1) (CSequence t2)
where
type EqCompareType (CSequence t1) (CSequence t2) = CSequence (EqCompareType t1 t2)
equalTo :: CSequence t1
-> CSequence t2 -> EqCompareType (CSequence t1) (CSequence t2)
equalTo = (CN t1 -> CN t2 -> CN (EqCompareType t1 t2))
-> CSequence t1 -> CSequence t2 -> CSequence (EqCompareType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (EqCompareType t1 t2)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo
instance
(HasOrderAsymmetric t1 t2, IsBool (CSequence (OrderCompareType t1 t2)))
=>
HasOrderAsymmetric (CSequence t1) (CSequence t2)
where
type OrderCompareType (CSequence t1) (CSequence t2) = CSequence (OrderCompareType t1 t2)
lessThan :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
lessThan = (CN t1 -> CN t2 -> CN (OrderCompareType t1 t2))
-> CSequence t1
-> CSequence t2
-> CSequence (OrderCompareType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (OrderCompareType t1 t2)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan
greaterThan :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
greaterThan = (CN t1 -> CN t2 -> CN (OrderCompareType t1 t2))
-> CSequence t1
-> CSequence t2
-> CSequence (OrderCompareType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (OrderCompareType t1 t2)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan
leq :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
leq = (CN t1 -> CN t2 -> CN (OrderCompareType t1 t2))
-> CSequence t1
-> CSequence t2
-> CSequence (OrderCompareType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (OrderCompareType t1 t2)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq
geq :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
geq = (CN t1 -> CN t2 -> CN (OrderCompareType t1 t2))
-> CSequence t1
-> CSequence t2
-> CSequence (OrderCompareType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (OrderCompareType t1 t2)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq
instance
(CanAbs t1)
=>
CanAbs (CSequence t1)
where
type AbsType (CSequence t1) = CSequence (AbsType t1)
abs :: CSequence t1 -> AbsType (CSequence t1)
abs = (CN t1 -> CN (AbsType t1))
-> CSequence t1 -> CSequence (AbsType t1)
forall t1 t2. (CN t1 -> CN t2) -> CSequence t1 -> CSequence t2
lift1 CN t1 -> CN (AbsType t1)
forall t. CanAbs t => t -> AbsType t
abs
instance
(CanMinMaxAsymmetric t1 t2)
=>
CanMinMaxAsymmetric (CSequence t1) (CSequence t2)
where
type MinMaxType (CSequence t1) (CSequence t2) = CSequence (MinMaxType t1 t2)
min :: CSequence t1
-> CSequence t2 -> MinMaxType (CSequence t1) (CSequence t2)
min = (CN t1 -> CN t2 -> CN (MinMaxType t1 t2))
-> CSequence t1 -> CSequence t2 -> CSequence (MinMaxType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (MinMaxType t1 t2)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min
max :: CSequence t1
-> CSequence t2 -> MinMaxType (CSequence t1) (CSequence t2)
max = (CN t1 -> CN t2 -> CN (MinMaxType t1 t2))
-> CSequence t1 -> CSequence t2 -> CSequence (MinMaxType t1 t2)
forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 CN t1 -> CN t2 -> CN (MinMaxType t1 t2)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max
instance
(CanMinMaxAsymmetric a MPBall)
=>
CanMinMaxAsymmetric (CSequence a) MPBall
where
type MinMaxType (CSequence a) MPBall = MinMaxType (CN a) (CN MPBall)
min :: CSequence a -> MPBall -> MinMaxType (CSequence a) MPBall
min CSequence a
s MPBall
a = CN a -> CN MPBall -> MinMaxType (CN a) (CN MPBall)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
max :: CSequence a -> MPBall -> MinMaxType (CSequence a) MPBall
max CSequence a
s MPBall
a = CN a -> CN MPBall -> MinMaxType (CN a) (CN MPBall)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
instance
(CanMinMaxAsymmetric a MPBall)
=>
CanMinMaxAsymmetric (CSequence a) (CN MPBall)
where
type MinMaxType (CSequence a) (CN MPBall) = MinMaxType (CN a) (CN MPBall)
min :: CSequence a -> CN MPBall -> MinMaxType (CSequence a) (CN MPBall)
min CSequence a
s CN MPBall
a = CN a -> CN MPBall -> MinMaxType (CN a) (CN MPBall)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
max :: CSequence a -> CN MPBall -> MinMaxType (CSequence a) (CN MPBall)
max CSequence a
s CN MPBall
a = CN a -> CN MPBall -> MinMaxType (CN a) (CN MPBall)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
instance
(CanMinMaxAsymmetric MPBall a)
=>
CanMinMaxAsymmetric MPBall (CSequence a)
where
type MinMaxType MPBall (CSequence a) = MinMaxType (CN MPBall) (CN a)
min :: MPBall -> CSequence a -> MinMaxType MPBall (CSequence a)
min MPBall
a CSequence a
s = CN MPBall -> CN a -> MinMaxType (CN MPBall) (CN a)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
max :: MPBall -> CSequence a -> MinMaxType MPBall (CSequence a)
max MPBall
a CSequence a
s = CN MPBall -> CN a -> MinMaxType (CN MPBall) (CN a)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
instance
(CanMinMaxAsymmetric MPBall a)
=>
CanMinMaxAsymmetric (CN MPBall) (CSequence a)
where
type MinMaxType (CN MPBall) (CSequence a) = MinMaxType (CN MPBall) (CN a)
min :: CN MPBall -> CSequence a -> MinMaxType (CN MPBall) (CSequence a)
min CN MPBall
a CSequence a
s = CN MPBall -> CN a -> MinMaxType (CN MPBall) (CN a)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min CN MPBall
a (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
max :: CN MPBall -> CSequence a -> MinMaxType (CN MPBall) (CSequence a)
max CN MPBall
a CSequence a
s = CN MPBall -> CN a -> MinMaxType (CN MPBall) (CN a)
forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max CN MPBall
a (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
instance
(HasEqAsymmetric a MPBall)
=>
HasEqAsymmetric (CSequence a) MPBall
where
type EqCompareType (CSequence a) MPBall = EqCompareType (CN a) (CN MPBall)
equalTo :: CSequence a -> MPBall -> EqCompareType (CSequence a) MPBall
equalTo CSequence a
s MPBall
a = CN a -> CN MPBall -> EqCompareType (CN a) (CN MPBall)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
notEqualTo :: CSequence a -> MPBall -> EqCompareType (CSequence a) MPBall
notEqualTo CSequence a
s MPBall
a = CN a -> CN MPBall -> EqCompareType (CN a) (CN MPBall)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
instance
(HasEqAsymmetric a MPBall)
=>
HasEqAsymmetric (CSequence a) (CN MPBall)
where
type EqCompareType (CSequence a) (CN MPBall) = EqCompareType (CN a) (CN MPBall)
equalTo :: CSequence a -> CN MPBall -> EqCompareType (CSequence a) (CN MPBall)
equalTo CSequence a
s CN MPBall
a = CN a -> CN MPBall -> EqCompareType (CN a) (CN MPBall)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
notEqualTo :: CSequence a -> CN MPBall -> EqCompareType (CSequence a) (CN MPBall)
notEqualTo CSequence a
s CN MPBall
a = CN a -> CN MPBall -> EqCompareType (CN a) (CN MPBall)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
instance
(HasEqAsymmetric MPBall b)
=>
HasEqAsymmetric MPBall (CSequence b)
where
type EqCompareType MPBall (CSequence b) = EqCompareType (CN MPBall) (CN b)
equalTo :: MPBall -> CSequence b -> EqCompareType MPBall (CSequence b)
equalTo MPBall
a CSequence b
s = CN MPBall -> CN b -> EqCompareType (CN MPBall) (CN b)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
notEqualTo :: MPBall -> CSequence b -> EqCompareType MPBall (CSequence b)
notEqualTo MPBall
a CSequence b
s = CN MPBall -> CN b -> EqCompareType (CN MPBall) (CN b)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
instance
(HasEqAsymmetric MPBall b)
=>
HasEqAsymmetric (CN MPBall) (CSequence b)
where
type EqCompareType (CN MPBall) (CSequence b) = EqCompareType (CN MPBall) (CN b)
equalTo :: CN MPBall -> CSequence b -> EqCompareType (CN MPBall) (CSequence b)
equalTo CN MPBall
a CSequence b
s = CN MPBall -> CN b -> EqCompareType (CN MPBall) (CN b)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
notEqualTo :: CN MPBall -> CSequence b -> EqCompareType (CN MPBall) (CSequence b)
notEqualTo CN MPBall
a CSequence b
s = CN MPBall -> CN b -> EqCompareType (CN MPBall) (CN b)
forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
instance
(HasOrderAsymmetric a MPBall)
=>
HasOrderAsymmetric (CSequence a) MPBall
where
type OrderCompareType (CSequence a) MPBall = OrderCompareType (CN a) (CN MPBall)
lessThan :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
lessThan CSequence a
s MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
greaterThan :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
greaterThan CSequence a
s MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
leq :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
leq CSequence a
s MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
geq :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
geq CSequence a
s MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a)
instance
(HasOrderAsymmetric a MPBall)
=>
HasOrderAsymmetric (CSequence a) (CN MPBall)
where
type OrderCompareType (CSequence a) (CN MPBall) = OrderCompareType (CN a) (CN MPBall)
lessThan :: CSequence a
-> CN MPBall -> OrderCompareType (CSequence a) (CN MPBall)
lessThan CSequence a
s CN MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
greaterThan :: CSequence a
-> CN MPBall -> OrderCompareType (CSequence a) (CN MPBall)
greaterThan CSequence a
s CN MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
leq :: CSequence a
-> CN MPBall -> OrderCompareType (CSequence a) (CN MPBall)
leq CSequence a
s CN MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
geq :: CSequence a
-> CN MPBall -> OrderCompareType (CSequence a) (CN MPBall)
geq CSequence a
s CN MPBall
a = CN a -> CN MPBall -> OrderCompareType (CN a) (CN MPBall)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (CSequence a
s CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
instance
(HasOrderAsymmetric MPBall b)
=>
HasOrderAsymmetric MPBall (CSequence b)
where
type OrderCompareType MPBall (CSequence b) = OrderCompareType (CN MPBall) (CN b)
lessThan :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
lessThan MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
greaterThan :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
greaterThan MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
leq :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
leq MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
geq :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
geq MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (MPBall -> CN MPBall
forall v. v -> CN v
cn MPBall
a) (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
instance
(HasOrderAsymmetric MPBall b)
=>
HasOrderAsymmetric (CN MPBall) (CSequence b)
where
type OrderCompareType (CN MPBall) (CSequence b) = OrderCompareType (CN MPBall) (CN b)
lessThan :: CN MPBall
-> CSequence b -> OrderCompareType (CN MPBall) (CSequence b)
lessThan CN MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
greaterThan :: CN MPBall
-> CSequence b -> OrderCompareType (CN MPBall) (CSequence b)
greaterThan CN MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
leq :: CN MPBall
-> CSequence b -> OrderCompareType (CN MPBall) (CSequence b)
leq CN MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
geq :: CN MPBall
-> CSequence b -> OrderCompareType (CN MPBall) (CSequence b)
geq CN MPBall
a CSequence b
s = CN MPBall -> CN b -> OrderCompareType (CN MPBall) (CN b)
forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq CN MPBall
a (CSequence b
s CSequence b
-> Precision -> ExtractedApproximation (CSequence b) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (CN MPBall -> Precision
forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
$(declForTypes
[[t| Integer |], [t| Int |], [t| Rational |], [t| Dyadic |]]
(\ t -> [d|
instance
(CanMinMaxAsymmetric a $t)
=>
CanMinMaxAsymmetric (CSequence a) $t
where
type MinMaxType (CSequence a) $t = CSequence (MinMaxType a $t)
min = lift1T min
max = lift1T max
instance
(CanMinMaxAsymmetric a $t)
=>
CanMinMaxAsymmetric (CSequence a) (CN $t)
where
type MinMaxType (CSequence a) (CN $t) = CSequence (MinMaxType a $t)
min = lift1T min
max = lift1T max
instance
(CanMinMaxAsymmetric $t a)
=>
CanMinMaxAsymmetric $t (CSequence a)
where
type MinMaxType $t (CSequence a) = CSequence (MinMaxType $t a)
min = liftT1 min
max = liftT1 max
instance
(CanMinMaxAsymmetric $t a)
=>
CanMinMaxAsymmetric (CN $t) (CSequence a)
where
type MinMaxType (CN $t) (CSequence a) = CSequence (MinMaxType $t a)
min = liftT1 min
max = liftT1 max
instance
(HasEqAsymmetric a $t, IsBool (CSequence (EqCompareType a $t)))
=>
HasEqAsymmetric (CSequence a) $t
where
type EqCompareType (CSequence a) $t = CSequence (EqCompareType a $t)
equalTo = lift1T (==)
notEqualTo = lift1T (/=)
instance
(HasEqAsymmetric a $t, IsBool (CSequence (EqCompareType a $t)))
=>
HasEqAsymmetric (CSequence a) (CN $t)
where
type EqCompareType (CSequence a) (CN $t) = CSequence (EqCompareType a $t)
equalTo = lift1T (==)
notEqualTo = lift1T (/=)
instance
(HasEqAsymmetric $t a, IsBool (CSequence (EqCompareType $t a)))
=>
HasEqAsymmetric $t (CSequence a)
where
type EqCompareType $t (CSequence a) = CSequence (EqCompareType $t a)
equalTo = liftT1 (==)
notEqualTo = liftT1 (/=)
instance
(HasEqAsymmetric $t a, IsBool (CSequence (EqCompareType $t a)))
=>
HasEqAsymmetric (CN $t) (CSequence a)
where
type EqCompareType (CN $t) (CSequence a) = CSequence (EqCompareType $t a)
equalTo = liftT1 (==)
notEqualTo = liftT1 (/=)
instance
(HasOrderAsymmetric a $t, IsBool (CSequence (OrderCompareType a $t)))
=>
HasOrderAsymmetric (CSequence a) $t
where
type OrderCompareType (CSequence a) $t = CSequence (OrderCompareType a $t)
lessThan = lift1T lessThan
greaterThan = lift1T greaterThan
leq = lift1T leq
geq = lift1T geq
instance
(HasOrderAsymmetric a $t, IsBool (CSequence (OrderCompareType a $t)))
=>
HasOrderAsymmetric (CSequence a) (CN $t)
where
type OrderCompareType (CSequence a) (CN $t) = CSequence (OrderCompareType a $t)
lessThan = lift1T lessThan
greaterThan = lift1T greaterThan
leq = lift1T leq
geq = lift1T geq
instance
(HasOrderAsymmetric $t a, IsBool (CSequence (OrderCompareType $t a)))
=>
HasOrderAsymmetric $t (CSequence a)
where
type OrderCompareType $t (CSequence a) = CSequence (OrderCompareType $t a)
lessThan = liftT1 lessThan
greaterThan = liftT1 greaterThan
leq = liftT1 leq
geq = liftT1 geq
instance
(HasOrderAsymmetric $t a, IsBool (CSequence (OrderCompareType $t a)))
=>
HasOrderAsymmetric (CN $t) (CSequence a)
where
type OrderCompareType (CN $t) (CSequence a) = CSequence (OrderCompareType $t a)
lessThan = liftT1 lessThan
greaterThan = liftT1 greaterThan
leq = liftT1 leq
geq = liftT1 geq
|]))
instance
(HasEqCertainly a a)
=>
P.Eq (CSequence a)
where
CSequence a
a == :: CSequence a -> CSequence a -> Bool
== CSequence a
b
| CN a
ExtractedApproximation (CSequence a) Precision
aD CN a -> CN a -> Bool
forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!==! CN a
ExtractedApproximation (CSequence a) Precision
bD = Bool
True
| CN a
ExtractedApproximation (CSequence a) Precision
aD CN a -> CN a -> Bool
forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!/=! CN a
ExtractedApproximation (CSequence a) Precision
bD = Bool
False
| Bool
otherwise =
[Char] -> Bool
forall a. HasCallStack => [Char] -> a
error [Char]
"Failed to decide equality of Sequences. If you switch to MixedTypesNumPrelude instead of Prelude, comparison of Sequences returns CSequence Kleenean or similar instead of Bool."
where
aD :: ExtractedApproximation (CSequence a) Precision
aD = CSequence a
a CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision
bD :: ExtractedApproximation (CSequence a) Precision
bD = CSequence a
b CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision
instance
(HasEqCertainly a a, HasOrderCertainly a a)
=>
P.Ord (CSequence a)
where
compare :: CSequence a -> CSequence a -> Ordering
compare CSequence a
a CSequence a
b
| CN a
ExtractedApproximation (CSequence a) Precision
aD CN a -> CN a -> Bool
forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!==! CN a
ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.EQ
| CN a
ExtractedApproximation (CSequence a) Precision
aD CN a -> CN a -> Bool
forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<! CN a
ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.LT
| CN a
ExtractedApproximation (CSequence a) Precision
aD CN a -> CN a -> Bool
forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!>! CN a
ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.GT
| Bool
otherwise =
[Char] -> Ordering
forall a. HasCallStack => [Char] -> a
error [Char]
"Failed to decide order of Sequences. If you switch to MixedTypesNumPrelude instead of Prelude, comparison of Sequences returns CSequence Kleenean or similar instead of Bool."
where
aD :: ExtractedApproximation (CSequence a) Precision
aD = CSequence a
a CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision
bD :: ExtractedApproximation (CSequence a) Precision
bD = CSequence a
b CSequence a
-> Precision -> ExtractedApproximation (CSequence a) Precision
forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision