Numeric.MixedTypes.Eq

Equality checks

type HasEq t1 t2 = (HasEqAsymmetric t1 t2, HasEqAsymmetric t2 t1, EqCompareType t1 t2 ~ EqCompareType t2 t1)

class IsBool (EqCompareType a b) => HasEqAsymmetric a b where

Minimal complete definition

Nothing

Associated Types

type EqCompareType a b

Methods

equalTo :: a -> b -> EqCompareType a b

equalTo :: (EqCompareType a b ~ Bool, a ~ b, Eq a) => a -> b -> EqCompareType a b

notEqualTo :: a -> b -> EqCompareType a b

notEqualTo :: CanNegSameType (EqCompareType a b) => a -> b -> EqCompareType a b

Instances

HasEqAsymmetric Bool Bool

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Bool Bool :: Type

Methods

equalTo :: Bool -> Bool -> EqCompareType Bool Bool

notEqualTo :: Bool -> Bool -> EqCompareType Bool Bool

HasEqAsymmetric Char Char

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Char Char :: Type

Methods

equalTo :: Char -> Char -> EqCompareType Char Char

notEqualTo :: Char -> Char -> EqCompareType Char Char

HasEqAsymmetric Double Double

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Double Double :: Type

Methods

equalTo :: Double -> Double -> EqCompareType Double Double

notEqualTo :: Double -> Double -> EqCompareType Double Double

HasEqAsymmetric Double Int

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Double Int :: Type

Methods

equalTo :: Double -> Int -> EqCompareType Double Int

notEqualTo :: Double -> Int -> EqCompareType Double Int

HasEqAsymmetric Double Integer

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Double Integer :: Type

Methods

equalTo :: Double -> Integer -> EqCompareType Double Integer

notEqualTo :: Double -> Integer -> EqCompareType Double Integer

HasEqAsymmetric Int Double

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Int Double :: Type

Methods

equalTo :: Int -> Double -> EqCompareType Int Double

notEqualTo :: Int -> Double -> EqCompareType Int Double

HasEqAsymmetric Int Int

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Int Int :: Type

Methods

equalTo :: Int -> Int -> EqCompareType Int Int

notEqualTo :: Int -> Int -> EqCompareType Int Int

HasEqAsymmetric Int Integer

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Int Integer :: Type

Methods

equalTo :: Int -> Integer -> EqCompareType Int Integer

notEqualTo :: Int -> Integer -> EqCompareType Int Integer

HasEqAsymmetric Int Rational

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Int Rational :: Type

Methods

equalTo :: Int -> Rational -> EqCompareType Int Rational

notEqualTo :: Int -> Rational -> EqCompareType Int Rational

HasEqAsymmetric Integer Double

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Integer Double :: Type

Methods

equalTo :: Integer -> Double -> EqCompareType Integer Double

notEqualTo :: Integer -> Double -> EqCompareType Integer Double

HasEqAsymmetric Integer Int

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Integer Int :: Type

Methods

equalTo :: Integer -> Int -> EqCompareType Integer Int

notEqualTo :: Integer -> Int -> EqCompareType Integer Int

HasEqAsymmetric Integer Integer

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Integer Integer :: Type

Methods

equalTo :: Integer -> Integer -> EqCompareType Integer Integer

notEqualTo :: Integer -> Integer -> EqCompareType Integer Integer

HasEqAsymmetric Integer Rational

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Integer Rational :: Type

Methods

equalTo :: Integer -> Rational -> EqCompareType Integer Rational

notEqualTo :: Integer -> Rational -> EqCompareType Integer Rational

HasEqAsymmetric Rational Int

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Rational Int :: Type

Methods

equalTo :: Rational -> Int -> EqCompareType Rational Int

notEqualTo :: Rational -> Int -> EqCompareType Rational Int

HasEqAsymmetric Rational Integer

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Rational Integer :: Type

Methods

equalTo :: Rational -> Integer -> EqCompareType Rational Integer

notEqualTo :: Rational -> Integer -> EqCompareType Rational Integer

HasEqAsymmetric Rational Rational

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Rational Rational :: Type

Methods

equalTo :: Rational -> Rational -> EqCompareType Rational Rational

notEqualTo :: Rational -> Rational -> EqCompareType Rational Rational

HasEqAsymmetric () ()

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType () () :: Type

Methods

equalTo :: () -> () -> EqCompareType () ()

notEqualTo :: () -> () -> EqCompareType () ()

HasEqAsymmetric Double b => HasEqAsymmetric Double (Complex b)

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType Double (Complex b) :: Type

Methods

equalTo :: Double -> Complex b -> EqCompareType Double (Complex b)

notEqualTo :: Double -> Complex b -> EqCompareType Double (Complex b)

HasEqAsymmetric Int b => HasEqAsymmetric Int (Complex b)

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType Int (Complex b) :: Type

Methods

equalTo :: Int -> Complex b -> EqCompareType Int (Complex b)

notEqualTo :: Int -> Complex b -> EqCompareType Int (Complex b)

HasEqAsymmetric Integer b => HasEqAsymmetric Integer (Complex b)

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType Integer (Complex b) :: Type

Methods

equalTo :: Integer -> Complex b -> EqCompareType Integer (Complex b)

notEqualTo :: Integer -> Complex b -> EqCompareType Integer (Complex b)

HasEqAsymmetric Rational b => HasEqAsymmetric Rational (Complex b)

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType Rational (Complex b) :: Type

Methods

equalTo :: Rational -> Complex b -> EqCompareType Rational (Complex b)

notEqualTo :: Rational -> Complex b -> EqCompareType Rational (Complex b)

(HasEqAsymmetric Bool b, CanEnsureCE es b, CanEnsureCE es (EqCompareType Bool b), IsBool (EnsureCE es (EqCompareType Bool b)), SuitableForCE es) => HasEqAsymmetric Bool (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Bool (CollectErrors es b) :: Type

Methods

equalTo :: Bool -> CollectErrors es b -> EqCompareType Bool (CollectErrors es b)

notEqualTo :: Bool -> CollectErrors es b -> EqCompareType Bool (CollectErrors es b)

(HasEqAsymmetric Double b, CanEnsureCE es b, CanEnsureCE es (EqCompareType Double b), IsBool (EnsureCE es (EqCompareType Double b)), SuitableForCE es) => HasEqAsymmetric Double (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Double (CollectErrors es b) :: Type

Methods

equalTo :: Double -> CollectErrors es b -> EqCompareType Double (CollectErrors es b)

notEqualTo :: Double -> CollectErrors es b -> EqCompareType Double (CollectErrors es b)

(HasEqAsymmetric Int b, CanEnsureCE es b, CanEnsureCE es (EqCompareType Int b), IsBool (EnsureCE es (EqCompareType Int b)), SuitableForCE es) => HasEqAsymmetric Int (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Int (CollectErrors es b) :: Type

Methods

equalTo :: Int -> CollectErrors es b -> EqCompareType Int (CollectErrors es b)

notEqualTo :: Int -> CollectErrors es b -> EqCompareType Int (CollectErrors es b)

(HasEqAsymmetric Integer b, CanEnsureCE es b, CanEnsureCE es (EqCompareType Integer b), IsBool (EnsureCE es (EqCompareType Integer b)), SuitableForCE es) => HasEqAsymmetric Integer (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Integer (CollectErrors es b) :: Type

Methods

equalTo :: Integer -> CollectErrors es b -> EqCompareType Integer (CollectErrors es b)

notEqualTo :: Integer -> CollectErrors es b -> EqCompareType Integer (CollectErrors es b)

(HasEqAsymmetric Rational b, CanEnsureCE es b, CanEnsureCE es (EqCompareType Rational b), IsBool (EnsureCE es (EqCompareType Rational b)), SuitableForCE es) => HasEqAsymmetric Rational (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType Rational (CollectErrors es b) :: Type

Methods

equalTo :: Rational -> CollectErrors es b -> EqCompareType Rational (CollectErrors es b)

notEqualTo :: Rational -> CollectErrors es b -> EqCompareType Rational (CollectErrors es b)

HasEqAsymmetric a Integer => HasEqAsymmetric (Complex a) Integer

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType (Complex a) Integer :: Type

Methods

equalTo :: Complex a -> Integer -> EqCompareType (Complex a) Integer

notEqualTo :: Complex a -> Integer -> EqCompareType (Complex a) Integer

HasEqAsymmetric a Int => HasEqAsymmetric (Complex a) Int

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType (Complex a) Int :: Type

Methods

equalTo :: Complex a -> Int -> EqCompareType (Complex a) Int

notEqualTo :: Complex a -> Int -> EqCompareType (Complex a) Int

HasEqAsymmetric a Rational => HasEqAsymmetric (Complex a) Rational

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType (Complex a) Rational :: Type

Methods

equalTo :: Complex a -> Rational -> EqCompareType (Complex a) Rational

notEqualTo :: Complex a -> Rational -> EqCompareType (Complex a) Rational

HasEqAsymmetric a Double => HasEqAsymmetric (Complex a) Double

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType (Complex a) Double :: Type

Methods

equalTo :: Complex a -> Double -> EqCompareType (Complex a) Double

notEqualTo :: Complex a -> Double -> EqCompareType (Complex a) Double

HasEqAsymmetric a b => HasEqAsymmetric [a] [b]

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType [a] [b] :: Type

Methods

equalTo :: [a] -> [b] -> EqCompareType [a] [b]

notEqualTo :: [a] -> [b] -> EqCompareType [a] [b]

HasEqAsymmetric a b => HasEqAsymmetric (Maybe a) (Maybe b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (Maybe a) (Maybe b) :: Type

Methods

equalTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b)

notEqualTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b)

HasEqAsymmetric a b => HasEqAsymmetric (Complex a) (Complex b)

Defined in Numeric.MixedTypes.Complex

Associated Types

type EqCompareType (Complex a) (Complex b) :: Type

Methods

equalTo :: Complex a -> Complex b -> EqCompareType (Complex a) (Complex b)

notEqualTo :: Complex a -> Complex b -> EqCompareType (Complex a) (Complex b)

(HasEqAsymmetric (Maybe Bool) b, CanEnsureCE es b, CanEnsureCE es (EqCompareType (Maybe Bool) b), IsBool (EnsureCE es (EqCompareType (Maybe Bool) b)), SuitableForCE es) => HasEqAsymmetric (Maybe Bool) (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (Maybe Bool) (CollectErrors es b) :: Type

Methods

equalTo :: Maybe Bool -> CollectErrors es b -> EqCompareType (Maybe Bool) (CollectErrors es b)

notEqualTo :: Maybe Bool -> CollectErrors es b -> EqCompareType (Maybe Bool) (CollectErrors es b)

(HasEqAsymmetric a Bool, CanEnsureCE es a, CanEnsureCE es (EqCompareType a Bool), IsBool (EnsureCE es (EqCompareType a Bool)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) Bool

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) Bool :: Type

Methods

equalTo :: CollectErrors es a -> Bool -> EqCompareType (CollectErrors es a) Bool

notEqualTo :: CollectErrors es a -> Bool -> EqCompareType (CollectErrors es a) Bool

(HasEqAsymmetric a Integer, CanEnsureCE es a, CanEnsureCE es (EqCompareType a Integer), IsBool (EnsureCE es (EqCompareType a Integer)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) Integer

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) Integer :: Type

Methods

equalTo :: CollectErrors es a -> Integer -> EqCompareType (CollectErrors es a) Integer

notEqualTo :: CollectErrors es a -> Integer -> EqCompareType (CollectErrors es a) Integer

(HasEqAsymmetric a Int, CanEnsureCE es a, CanEnsureCE es (EqCompareType a Int), IsBool (EnsureCE es (EqCompareType a Int)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) Int

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) Int :: Type

Methods

equalTo :: CollectErrors es a -> Int -> EqCompareType (CollectErrors es a) Int

notEqualTo :: CollectErrors es a -> Int -> EqCompareType (CollectErrors es a) Int

(HasEqAsymmetric a Rational, CanEnsureCE es a, CanEnsureCE es (EqCompareType a Rational), IsBool (EnsureCE es (EqCompareType a Rational)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) Rational

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) Rational :: Type

Methods

equalTo :: CollectErrors es a -> Rational -> EqCompareType (CollectErrors es a) Rational

notEqualTo :: CollectErrors es a -> Rational -> EqCompareType (CollectErrors es a) Rational

(HasEqAsymmetric a Double, CanEnsureCE es a, CanEnsureCE es (EqCompareType a Double), IsBool (EnsureCE es (EqCompareType a Double)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) Double

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) Double :: Type

Methods

equalTo :: CollectErrors es a -> Double -> EqCompareType (CollectErrors es a) Double

notEqualTo :: CollectErrors es a -> Double -> EqCompareType (CollectErrors es a) Double

(HasEqAsymmetric a (Maybe Bool), CanEnsureCE es a, CanEnsureCE es (EqCompareType a (Maybe Bool)), IsBool (EnsureCE es (EqCompareType a (Maybe Bool))), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) (Maybe Bool)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) (Maybe Bool) :: Type

Methods

equalTo :: CollectErrors es a -> Maybe Bool -> EqCompareType (CollectErrors es a) (Maybe Bool)

notEqualTo :: CollectErrors es a -> Maybe Bool -> EqCompareType (CollectErrors es a) (Maybe Bool)

(HasEqAsymmetric a1 b1, HasEqAsymmetric a2 b2, CanAndOrAsymmetric (EqCompareType a1 b1) (EqCompareType a2 b2), IsBool (AndOrType (EqCompareType a1 b1) (EqCompareType a2 b2))) => HasEqAsymmetric (a1, a2) (b1, b2)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (a1, a2) (b1, b2) :: Type

Methods

equalTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2)

notEqualTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2)

(HasEqAsymmetric a b, CanEnsureCE es (EqCompareType a b), CanEnsureCE es a, CanEnsureCE es b, IsBool (EnsureCE es (EqCompareType a b)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) (CollectErrors es b)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (CollectErrors es a) (CollectErrors es b) :: Type

Methods

equalTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b)

notEqualTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b)

HasEqAsymmetric ((a1, a2), a3) ((b1, b2), b3) => HasEqAsymmetric (a1, a2, a3) (b1, b2, b3)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (a1, a2, a3) (b1, b2, b3) :: Type

Methods

equalTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3)

notEqualTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3)

HasEqAsymmetric ((a1, a2, a3), a4) ((b1, b2, b3), b4) => HasEqAsymmetric (a1, a2, a3, a4) (b1, b2, b3, b4)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4) :: Type

Methods

equalTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4)

notEqualTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4)

HasEqAsymmetric ((a1, a2, a3, a4), a5) ((b1, b2, b3, b4), b5) => HasEqAsymmetric (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

Defined in Numeric.MixedTypes.Eq

Associated Types

type EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) :: Type

Methods

equalTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

notEqualTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

(==) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b infix 4

(/=) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b infix 4

type HasEqCertainly t1 t2 = (HasEq t1 t2, CanTestCertainly (EqCompareType t1 t2))

type HasEqCertainlyAsymmetric t1 t2 = (HasEqAsymmetric t1 t2, CanTestCertainly (EqCompareType t1 t2))

type HasEqCertainlyCE es t1 t2 = (HasEqCertainly t1 t2, HasEqCertainly (EnsureCE es t1) (EnsureCE es t2))

type HasEqCertainlyCN t1 t2 = HasEqCertainlyCE NumErrors t1 t2

notCertainlyDifferentFrom :: HasEqCertainlyAsymmetric a b => a -> b -> Bool

certainlyEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool

certainlyNotEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool

(?==?) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4

(!==!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4

(!/=!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4

Tests

specHasEq :: (Show t1, Show t2, Show t3, Arbitrary t1, Arbitrary t2, Arbitrary t3, CanTestCertainly (EqCompareType t1 t1), CanTestCertainly (EqCompareType t1 t2), CanTestCertainly (EqCompareType t2 t1), CanTestCertainly (EqCompareType t2 t3), CanTestCertainly (AndOrType (EqCompareType t1 t2) (EqCompareType t2 t3)), CanAndOrAsymmetric (EqCompareType t1 t2) (EqCompareType t2 t3), HasEqAsymmetric t1 t1, HasEqAsymmetric t1 t2, HasEqAsymmetric t2 t1, HasEqAsymmetric t2 t3) => T t1 -> T t2 -> T t3 -> Spec

HSpec properties that each implementation of HasEq should satisfy.

specHasEqNotMixed :: (Show t, Arbitrary t, CanTestCertainly (EqCompareType t t), CanTestCertainly (AndOrType (EqCompareType t t) (EqCompareType t t)), HasEqAsymmetric t t) => T t -> Spec

HSpec properties that each implementation of HasEq should satisfy.

specConversion :: (Arbitrary t1, Show t1, HasEqCertainly t1 t1) => T t1 -> T t2 -> (t1 -> t2) -> (t2 -> t1) -> Spec

HSpec property of there-and-back conversion.

Specific comparisons

class CanTestNaN t where

Minimal complete definition

Nothing

Methods

isNaN :: t -> Bool

isNaN :: RealFloat t => t -> Bool

Instances

CanTestNaN Double

Defined in Numeric.MixedTypes.Eq

Methods

isNaN :: Double -> Bool

CanTestNaN Integer

Defined in Numeric.MixedTypes.Eq

Methods

isNaN :: Integer -> Bool

CanTestNaN Rational

Defined in Numeric.MixedTypes.Eq

Methods

isNaN :: Rational -> Bool

(CanTestNaN t, SuitableForCE es) => CanTestNaN (CollectErrors es t)

Defined in Numeric.MixedTypes.Eq

Methods

isNaN :: CollectErrors es t -> Bool

class CanTestFinite t where

Minimal complete definition

Nothing

Methods

isInfinite :: t -> Bool

isInfinite :: RealFloat t => t -> Bool

isFinite :: t -> Bool

isFinite :: RealFloat t => t -> Bool

Instances

CanTestFinite Double

Defined in Numeric.MixedTypes.Eq

Methods

isInfinite :: Double -> Bool

isFinite :: Double -> Bool

CanTestFinite Int

Defined in Numeric.MixedTypes.Eq

Methods

isInfinite :: Int -> Bool

isFinite :: Int -> Bool

CanTestFinite Integer

Defined in Numeric.MixedTypes.Eq

Methods

isInfinite :: Integer -> Bool

isFinite :: Integer -> Bool

CanTestFinite Rational

Defined in Numeric.MixedTypes.Eq

Methods

isInfinite :: Rational -> Bool

isFinite :: Rational -> Bool

(CanTestFinite t, SuitableForCE es) => CanTestFinite (CollectErrors es t)

Defined in Numeric.MixedTypes.Eq

Methods

isInfinite :: CollectErrors es t -> Bool

isFinite :: CollectErrors es t -> Bool

class CanTestInteger t where

Minimal complete definition

certainlyNotInteger, certainlyIntegerGetIt

Methods

certainlyNotInteger :: t -> Bool

certainlyInteger :: t -> Bool

certainlyIntegerGetIt :: t -> Maybe Integer

Instances

CanTestInteger Double

Defined in Numeric.MixedTypes.Eq

Methods

certainlyNotInteger :: Double -> Bool

certainlyInteger :: Double -> Bool

certainlyIntegerGetIt :: Double -> Maybe Integer

CanTestInteger Int

Defined in Numeric.MixedTypes.Eq

Methods

certainlyNotInteger :: Int -> Bool

certainlyInteger :: Int -> Bool

certainlyIntegerGetIt :: Int -> Maybe Integer

CanTestInteger Integer

Defined in Numeric.MixedTypes.Eq

Methods

certainlyNotInteger :: Integer -> Bool

certainlyInteger :: Integer -> Bool

certainlyIntegerGetIt :: Integer -> Maybe Integer

CanTestInteger Rational

Defined in Numeric.MixedTypes.Eq

Methods

certainlyNotInteger :: Rational -> Bool

certainlyInteger :: Rational -> Bool

certainlyIntegerGetIt :: Rational -> Maybe Integer

(CanTestInteger t, CanTestZero t) => CanTestInteger (Complex t)

Defined in Numeric.MixedTypes.Complex

Methods

certainlyNotInteger :: Complex t -> Bool

certainlyInteger :: Complex t -> Bool

certainlyIntegerGetIt :: Complex t -> Maybe Integer

(CanTestInteger t, SuitableForCE es) => CanTestInteger (CollectErrors es t)

Defined in Numeric.MixedTypes.Eq

Methods

certainlyNotInteger :: CollectErrors es t -> Bool

certainlyInteger :: CollectErrors es t -> Bool

certainlyIntegerGetIt :: CollectErrors es t -> Maybe Integer

class CanTestZero t where

Minimal complete definition

Nothing

Methods

isCertainlyZero :: t -> Bool

isCertainlyNonZero :: t -> Bool

isCertainlyZero :: HasEqCertainly t Integer => t -> Bool

isCertainlyNonZero :: HasEqCertainly t Integer => t -> Bool

Instances

CanTestZero Double

Defined in Numeric.MixedTypes.Eq

Methods

isCertainlyZero :: Double -> Bool

isCertainlyNonZero :: Double -> Bool

CanTestZero Int

Defined in Numeric.MixedTypes.Eq

Methods

isCertainlyZero :: Int -> Bool

isCertainlyNonZero :: Int -> Bool

CanTestZero Integer

Defined in Numeric.MixedTypes.Eq

Methods

isCertainlyZero :: Integer -> Bool

isCertainlyNonZero :: Integer -> Bool

CanTestZero Rational

Defined in Numeric.MixedTypes.Eq

Methods

isCertainlyZero :: Rational -> Bool

isCertainlyNonZero :: Rational -> Bool

(CanTestZero t, SuitableForCE es) => CanTestZero (CollectErrors es t)

Defined in Numeric.MixedTypes.Eq

Methods

isCertainlyZero :: CollectErrors es t -> Bool

isCertainlyNonZero :: CollectErrors es t -> Bool

specCanTestZero :: (CanTestZero t, ConvertibleExactly Integer t) => T t -> Spec

HSpec properties that each implementation of CanTestZero should satisfy.

class CanPickNonZero t where

Minimal complete definition

Nothing

Methods

pickNonZero :: [(t, s)] -> Maybe (t, s)

Given a list [(a1,b1),(a2,b2),...] and assuming that at least one of a1,a2,... is non-zero, pick one of them and return the corresponding pair (ai,bi).

If none of a1,a2,... is zero, either throws an exception or loops forever.

The default implementation is based on a CanTestZero instance and is not parallel.

pickNonZero :: (CanTestZero t, Show t) => [(t, s)] -> Maybe (t, s)

Given a list [(a1,b1),(a2,b2),...] and assuming that at least one of a1,a2,... is non-zero, pick one of them and return the corresponding pair (ai,bi).

If none of a1,a2,... is zero, either throws an exception or loops forever.

The default implementation is based on a CanTestZero instance and is not parallel.

Instances

CanPickNonZero Int

Defined in Numeric.MixedTypes.Eq

Methods

pickNonZero :: [(Int, s)] -> Maybe (Int, s)

CanPickNonZero Integer

Defined in Numeric.MixedTypes.Eq

Methods

pickNonZero :: [(Integer, s)] -> Maybe (Integer, s)

CanPickNonZero Rational

Defined in Numeric.MixedTypes.Eq

Methods

pickNonZero :: [(Rational, s)] -> Maybe (Rational, s)

(CanPickNonZero a, SuitableForCE es) => CanPickNonZero (CollectErrors es a)

Defined in Numeric.MixedTypes.Eq

Methods

pickNonZero :: [(CollectErrors es a, s)] -> Maybe (CollectErrors es a, s)

specCanPickNonZero :: (CanPickNonZero t, CanTestZero t, ConvertibleExactly Integer t, Show t, Arbitrary t) => T t -> Spec

HSpec properties that each implementation of CanPickNonZero should satisfy.