{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -Wno-orphans #-}
{-|
    Module      :  AERN2.Real.Comparisons
    Description :  comparison  on CReal
    Copyright   :  (c) Michal Konecny
    License     :  BSD3

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

    Comparison relations over Cauchy Real numbers.
-}
module AERN2.Real.Comparisons
()
where

import MixedTypesNumPrelude
import qualified Prelude as P

-- import Data.Complex

import AERN2.MP.Ball
import AERN2.MP.Dyadic

import AERN2.Real.Type
import AERN2.Real.CKleenean ()

-- equality:

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

-- order:

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

-- abs:

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

-- min / max:

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

-- mixed type instances:

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

  |]))


{- Prelude Eq, Ord instances -}

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