{-# 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)), CanTestCertainly (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 = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo
instance
(HasOrderAsymmetric t1 t2, IsBool (CSequence (OrderCompareType t1 t2)), CanTestCertainly (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 = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan
greaterThan :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
greaterThan = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan
leq :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
leq = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq
geq :: CSequence t1
-> CSequence t2 -> OrderCompareType (CSequence t1) (CSequence t2)
geq = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 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 = forall t1 t2. (CN t1 -> CN t2) -> CSequence t1 -> CSequence t2
lift1 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 = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min
max :: CSequence t1
-> CSequence t2 -> MinMaxType (CSequence t1) (CSequence t2)
max = forall t1 t2 t3.
(CN t1 -> CN t2 -> CN t3)
-> CSequence t1 -> CSequence t2 -> CSequence t3
lift2 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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
max :: CSequence a -> MPBall -> MinMaxType (CSequence a) MPBall
max CSequence a
s MPBall
a = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min (forall v. v -> CN v
cn MPBall
a) (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
max :: MPBall -> CSequence a -> MinMaxType MPBall (CSequence a)
max MPBall
a CSequence a
s = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max (forall v. v -> CN v
cn MPBall
a) (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
min CN MPBall
a (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall t1 t2.
CanMinMaxAsymmetric t1 t2 =>
t1 -> t2 -> MinMaxType t1 t2
max CN MPBall
a (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
instance
(HasEqAsymmetric a MPBall, CanTestCertainly (EqCompareType 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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
notEqualTo :: CSequence a -> MPBall -> EqCompareType (CSequence a) MPBall
notEqualTo CSequence a
s MPBall
a = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
instance
(HasEqAsymmetric a MPBall, CanTestCertainly (EqCompareType 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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
instance
(HasEqAsymmetric MPBall b, CanTestCertainly (EqCompareType 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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
notEqualTo :: MPBall -> CSequence b -> EqCompareType MPBall (CSequence b)
notEqualTo MPBall
a CSequence b
s = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
instance
(HasEqAsymmetric MPBall b, CanTestCertainly (EqCompareType 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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
equalTo CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b. HasEqAsymmetric a b => a -> b -> EqCompareType a b
notEqualTo CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a))
instance
(HasOrderAsymmetric a MPBall, CanTestCertainly (OrderCompareType 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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
greaterThan :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
greaterThan CSequence a
s MPBall
a = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
leq :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
leq CSequence a
s MPBall
a = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
geq :: CSequence a -> MPBall -> OrderCompareType (CSequence a) MPBall
geq CSequence a
s MPBall
a = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a)) (forall v. v -> CN v
cn MPBall
a)
instance
(HasOrderAsymmetric a MPBall, CanTestCertainly (OrderCompareType 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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (CSequence a
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision CN MPBall
a)) CN MPBall
a
instance
(HasOrderAsymmetric MPBall b, CanTestCertainly (OrderCompareType 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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
greaterThan :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
greaterThan MPBall
a CSequence b
s = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
leq :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
leq MPBall
a CSequence b
s = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
geq :: MPBall -> CSequence b -> OrderCompareType MPBall (CSequence b)
geq MPBall
a CSequence b
s = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq (forall v. v -> CN v
cn MPBall
a) (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (forall t. HasPrecision t => t -> Precision
getPrecision MPBall
a))
instance
(HasOrderAsymmetric MPBall b, CanTestCertainly (OrderCompareType 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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
lessThan CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
greaterThan CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
leq CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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 = forall a b.
HasOrderAsymmetric a b =>
a -> b -> OrderCompareType a b
geq CN MPBall
a (CSequence b
s forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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)), CanTestCertainly (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
| ExtractedApproximation (CSequence a) Precision
aD forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!==! ExtractedApproximation (CSequence a) Precision
bD = Bool
True
| ExtractedApproximation (CSequence a) Precision
aD forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!/=! ExtractedApproximation (CSequence a) Precision
bD = Bool
False
| Bool
otherwise =
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 forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision
bD :: ExtractedApproximation (CSequence a) Precision
bD = CSequence a
b 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
| ExtractedApproximation (CSequence a) Precision
aD forall a b. HasEqCertainlyAsymmetric a b => a -> b -> Bool
!==! ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.EQ
| ExtractedApproximation (CSequence a) Precision
aD forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!<! ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.LT
| ExtractedApproximation (CSequence a) Precision
aD forall a b. HasOrderCertainlyAsymmetric a b => a -> b -> Bool
!>! ExtractedApproximation (CSequence a) Precision
bD = Ordering
P.GT
| Bool
otherwise =
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 forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision
bD :: ExtractedApproximation (CSequence a) Precision
bD = CSequence a
b forall e q.
CanExtractApproximation e q =>
e -> q -> ExtractedApproximation e q
? Precision
defaultPrecision