Data.Connection.Conn

Conn

data Side

A data kind distinguishing links in a chain of Galois connections of length 2 or 3.

• L-tagged types are increasing (e.g. ceiling, maximize)
• R-tagged types are decreasing (e.g. floor, minimize)

If a connection is existentialized over this value (i.e. has type forall k. Conn k a b) then it can provide either of two functions f, h :: a -> b.

This is useful because it enables rounding, truncation, medians, etc.

Constructors

L

R

data Conn (k :: Side) a b

A chain of Galois connections of length 2 or 3.

Connections have many nice properties wrt numerical conversion:

>>> inner ratf32 (1 / 8)    -- eighths are exactly representable in a float
1 % 8
>>> outer ratf32 (1 % 8)
(0.125,0.125)
>>> inner ratf32 (1 / 7)    -- sevenths are not
9586981 % 67108864
>>> outer ratf32 (1 % 7)
(0.14285713,0.14285715)

Another example avoiding loss-of-precision:

>>> f x y = (x + y) - x
>>> maxOdd32 = 1.6777215e7
>>> f maxOdd32 2.0 :: Float
1.0
>>> round2 f64f32 f maxOdd32 2.0
2.0

See the README file for a slightly more in-depth introduction.

Instances

Category (Conn k :: Type -> Type -> Type)

Defined in Data.Connection.Conn

Methods

id :: Conn k a a

(.) :: Conn k b c -> Conn k a b -> Conn k a c

(>>>) :: Category cat => cat a b -> cat b c -> cat a c infixr 1

Left-to-right composition

(<<<) :: Category cat => cat b c -> cat a b -> cat a c infixr 1

Right-to-left composition

mapped :: Functor f => Conn k a b -> Conn k (f a) (f b)

Lift a Conn into a functor.

Caution: This function will result in an invalid connection if the functor alters the internal preorder (e.g. Down).

choice :: Conn k a b -> Conn k c d -> Conn k (Either a c) (Either b d)

Lift two connections into a connection on the coproduct order

(choice id) (ab >>> cd) = (choice id) ab >>> (choice id) cd
(flip choice id) (ab >>> cd) = (flip choice id) ab >>> (flip choice id) cd

select :: Conn k c a -> Conn k c b -> Conn k c (Either a b) infixr 3

Lift two connections into a connection on the coproduct order

strong :: Conn k a b -> Conn k c d -> Conn k (a, c) (b, d)

Lift two connections into a connection on the product order

(strong id) (ab >>> cd) = (strong id) ab >>> (strong id) cd
(flip strong id) (ab >>> cd) = (flip strong id) ab >>> (flip strong id) cd

divide :: Total c => Conn k a c -> Conn k b c -> Conn k (a, b) c infixr 4

Lift two connections into a connection on the product order

bounded :: Bounded a => Conn k () a

The defining connections of a bounded preorder.

ordered :: Total a => Conn k (a, a) a

The defining connections of a total order.

>>> outer ordered (True, False)
(False,True)

identity :: Conn k a a

The identity connection.

Conn 'L

type ConnL = Conn L

pattern ConnL :: (a -> b) -> (b -> a) -> Conn L a b

A Galois connection between two monotone functions.

A Galois connection between f and g, written \(f \dashv g \) is an adjunction in the category of preorders.

Each side of the connection may be defined in terms of the other:

\( g(x) = \sup \{y \in E \mid f(y) \leq x \} \)

\( f(x) = \inf \{y \in E \mid g(y) \geq x \} \)

Caution: ConnL f g must obey \(f \dashv g \). This condition is not checked.

For further information see Property.

connL :: Conn R a b -> Conn L b a

Witness to the mirror symmetry between ConnL and ConnR.

connL . connR = id
connR . connL = id

upper :: Conn L a b -> b -> a

Extract the upper adjoint of a ConnL.

upper1 :: Conn L a b -> (b -> b) -> a -> a

Map over a ConnL from the right.

This is the unit of the resulting monad:

x <~ upper1 c id x

>>> compare pi $ upper1 f64f32 id pi
LT

upper2 :: Conn L a b -> (b -> b -> b) -> a -> a -> a

Zip over a ConnL from the right.

ceiling :: Conn L a b -> a -> b

Extract the lower half of a ConnL.

ceiling identity = id
ceiling c (x \/ y) = ceiling c x \/ ceiling c y

The latter law is the adjoint functor theorem for preorders.

>>> Data.Connection.ceiling ratf32 (0 :% 0)
NaN
>>> Data.Connection.ceiling ratf32 (13 :% 10)
1.3000001
>>> Data.Connection.ceiling f64f32 pi
3.1415927

ceiling1 :: Conn L a b -> (a -> a) -> b -> b

Map over a ConnL from the left.

ceiling1 identity = id

This is the counit of the resulting comonad:

x >~ ceiling1 c id x

ceiling2 :: Conn L a b -> (a -> a -> a) -> b -> b -> b

Zip over a ConnL from the left.

maximize :: Conn L (a, b) c -> a -> b -> c

Generalized maximum.

Conn 'R

type ConnR = Conn R

pattern ConnR :: (b -> a) -> (a -> b) -> Conn R a b

A Galois connection between two monotone functions.

ConnR is the mirror image of ConnL:

connR :: ConnL a b -> ConnR b a

If you only require one connection there is no particular reason to use one version over the other. However some use cases (e.g. rounding) require an adjoint triple of connections that can lower into a standard connection in either of two ways.

Caution: ConnR f g must obey \(f \dashv g \). This condition is not checked.

For further information see Property.

connR :: Conn L a b -> Conn R b a

Witness to the mirror symmetry between ConnL and ConnR.

connL . connR = id
connR . connL = id

lower :: Conn R a b -> b -> a

Extract the lower adjoint of a ConnR.

lower1 :: Conn R a b -> (b -> b) -> a -> a

Map over a ConnR from the left.

This is the counit of the resulting comonad:

x >~ lower1 c id x

>>> compare pi $ lower1 f64f32 id pi
GT

lower2 :: Conn R a b -> (b -> b -> b) -> a -> a -> a

Zip over a ConnR from the left.

floor :: Conn R a b -> a -> b

Extract the upper half of a ConnR

floor identity = id
floor c (x /\ y) = floor c x /\ floor c y

The latter law is the adjoint functor theorem for preorders.

>>> Data.Connection.floor ratf32 (0 :% 0)
NaN
>>> Data.Connection.floor ratf32 (13 :% 10)
1.3
>>> Data.Connection.floor f64f32 pi
3.1415925

floor1 :: Conn R a b -> (a -> a) -> b -> b

Map over a ConnR from the right.

floor1 identity = id

This is the unit of the resulting monad:

x <~ floor1 c id x

floor2 :: Conn R a b -> (a -> a -> a) -> b -> b -> b

Zip over a ConnR from the right.

minimize :: Conn R (a, b) c -> a -> b -> c

Generalized minimum.

Connection k

pattern Conn :: (a -> b) -> (b -> a) -> (a -> b) -> Conn k a b

An adjoint triple of Galois connections.

An adjoint triple is a chain of connections of length 3:

\(f \dashv g \dashv h \)

When applied to a ConnL or ConnR, the two functions of type a -> b returned will be identical.

Caution: Conn f g h must obey \(f \dashv g \dashv h\). This condition is not checked.

For detailed properties see Property.

outer :: Conn k a b -> a -> (b, b)

Extract the left and/or right adjoints of a connection.

When the connection is an adjoint triple the outer functions are returned:

outer c = floor c &&& ceiling c

>>> outer ratf32 (1 % 8)    -- eighths are exactly representable in a float
(0.125,0.125)
>>> outer ratf32 (1 % 7)    -- sevenths are not
(0.14285713,0.14285715)

inner :: Conn k a b -> b -> a

Extract the upper adjoint of a ConnL, or lower adjoint of a ConnR.

When the connection is an adjoint triple the inner function is returned:

>>> inner ratf32 (1 / 8)    -- eighths are exactly representable in a float
1 % 8
>>> inner ratf32 (1 / 7)    -- sevenths are not
9586981 % 67108864

half :: (Num a, Preorder a) => (forall k. Conn k a b) -> a -> Maybe Ordering

Determine which half of the interval between 2 representations of a a particular value lies.

 half c x = pcompare (x - lower1 c id x) (upper1 c id x - x)

>>> maybe False (== EQ) $ half f64f32 (midpoint f64f32 pi)
True

midpoint :: Fractional a => (forall k. Conn k a b) -> a -> a

Return the midpoint of the interval containing x.

>>> pi - midpoint f64f32 pi
3.1786509424591713e-8

round :: (Num a, Preorder a) => (forall k. Conn k a b) -> a -> b

Return the nearest value to x.

round identity = id

If x lies halfway between two finite values, then return the value with the smaller absolute value (i.e. round towards from zero).

See https://en.wikipedia.org/wiki/Rounding.

round1 :: (Num a, Preorder a) => (forall k. Conn k a b) -> (a -> a) -> b -> b

Lift a unary function over an adjoint triple.

round1 identity = id

Results are rounded to the nearest value with ties away from 0.

round2 :: (Num a, Preorder a) => (forall k. Conn k a b) -> (a -> a -> a) -> b -> b -> b

Lift a binary function over an adjoint triple.

round2 identity = id

Results are rounded to the nearest value with ties away from 0.

Example avoiding loss-of-precision:

>>> f x y = (x + y) - x
>>> maxOdd32 = 1.6777215e7
>>> f maxOdd32 2.0 :: Float
1.0
>>> round2 ratf32 f maxOdd32 2.0
2.0

truncate :: (Num a, Preorder a) => (forall k. Conn k a b) -> a -> b

Truncate towards zero.

truncate identity = id

truncate1 :: (Num a, Preorder a) => (forall k. Conn k a b) -> (a -> a) -> b -> b

Lift a unary function over an adjoint triple.

truncate1 identity = id

Results are truncated towards zero.

truncate2 :: (Num a, Preorder a) => (forall k. Conn k a b) -> (a -> a -> a) -> b -> b -> b

Lift a binary function over an adjoint triple.

truncate2 identity = id

Results are truncated towards zero.

median :: (forall k. Conn k (a, a) a) -> a -> a -> a -> a

Birkoff's median operator.

median x x y = x
median x y z = median z x y
median x y z = median x z y
median (median x w y) w z = median x w (median y w z)

>>> median f32f32 1.0 9.0 7.0
7.0
>>> median f32f32 1.0 9.0 (0.0 / 0.0)
9.0

Down

upL :: Conn L (Down a) (Down b) -> Conn L b a

Convert an inverted ConnL to a ConnL.

upL . downL = downL . upL = id

upR :: Conn R (Down a) (Down b) -> Conn R b a

Convert an inverted ConnR to a ConnR.

upR . downR = downR . upR = id

downL :: Conn L a b -> Conn L (Down b) (Down a)

Convert a ConnL to an inverted ConnL.

>>> let counit = upper1 (downL $ bounded @Ordering) id
>>> counit (Down LT)
Down LT
>>> counit (Down GT)
Down LT

downR :: Conn R a b -> Conn R (Down b) (Down a)

Convert a ConnR to an inverted ConnR.

>>> let unit = lower1 (downR $ bounded @Ordering) id
>>> unit (Down LT)
Down GT
>>> unit (Down GT)
Down GT

filterL :: Preorder b => Conn L a b -> a -> b -> Bool

Obtain the principal filter in B generated by an element of A.

A subset B of a lattice is an filter if and only if it is an upper set that is closed under finite meets, i.e., it is nonempty and for all x, y in B, the element meet c x y is also in b.

filterL and filterR commute with Down:

filterL c a b <=> filterR c (Down a) (Down b)

filterL c (Down a) (Down b) <=> filterR c a b

filterL c a is upward-closed for all a:

a <= b1 && b1 <= b2 => a <= b2
a1 <= b && a2 <= b => minimize c (ceiling c a1) (ceiling c a2) <= b

See https://en.wikipedia.org/wiki/Filter_(mathematics)

filterR :: Preorder b => Conn R a b -> a -> b -> Bool

Obtain the principal ideal in B generated by an element of A.

A subset B of a lattice is an ideal if and only if it is a lower set that is closed under finite joins, i.e., it is nonempty and for all x, y in B, the element join c x y is also in B.

filterR c a is downward-closed for all a:

a >= b1 && b1 >= b2 => a >= b2

a1 >= b && a2 >= b => maximize c (floor c a1) (floor c a2) >= b

See https://en.wikipedia.org/wiki/Ideal_(order_theory)

newtype Down a

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a). If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x

Since: base-4.6.0.0

Constructors

Down a

Instances

Monad Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(>>=) :: Down a -> (a -> Down b) -> Down b

(>>) :: Down a -> Down b -> Down b

return :: a -> Down a

fail :: String -> Down a

Functor Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b

(<$) :: a -> Down b -> Down a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Foldable Down

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Down m -> m

foldMap :: Monoid m => (a -> m) -> Down a -> m

foldr :: (a -> b -> b) -> b -> Down a -> b

foldr' :: (a -> b -> b) -> b -> Down a -> b

foldl :: (b -> a -> b) -> b -> Down a -> b

foldl' :: (b -> a -> b) -> b -> Down a -> b

foldr1 :: (a -> a -> a) -> Down a -> a

foldl1 :: (a -> a -> a) -> Down a -> a

toList :: Down a -> [a]

null :: Down a -> Bool

length :: Down a -> Int

elem :: Eq a => a -> Down a -> Bool

maximum :: Ord a => Down a -> a

minimum :: Ord a => Down a -> a

sum :: Num a => Down a -> a

product :: Num a => Down a -> a

Traversable Down

Since: base-4.12.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b)

sequenceA :: Applicative f => Down (f a) -> f (Down a)

mapM :: Monad m => (a -> m b) -> Down a -> m (Down b)

sequence :: Monad m => Down (m a) -> m (Down a)

Eq a => Eq (Down a)

Since: base-4.6.0.0

Defined in Data.Ord

Methods

(==) :: Down a -> Down a -> Bool

(/=) :: Down a -> Down a -> Bool

Num a => Num (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(+) :: Down a -> Down a -> Down a

(-) :: Down a -> Down a -> Down a

(*) :: Down a -> Down a -> Down a

negate :: Down a -> Down a

abs :: Down a -> Down a

signum :: Down a -> Down a

fromInteger :: Integer -> Down a

Ord a => Ord (Down a)

Since: base-4.6.0.0

Defined in Data.Ord

Methods

compare :: Down a -> Down a -> Ordering

(<) :: Down a -> Down a -> Bool

(<=) :: Down a -> Down a -> Bool

(>) :: Down a -> Down a -> Bool

(>=) :: Down a -> Down a -> Bool

max :: Down a -> Down a -> Down a

min :: Down a -> Down a -> Down a

Read a => Read (Down a)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

readsPrec :: Int -> ReadS (Down a)

readList :: ReadS [Down a]

readPrec :: ReadPrec (Down a)

readListPrec :: ReadPrec [Down a]

Show a => Show (Down a)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

Generic (Down a)

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Semigroup a => Semigroup (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(<>) :: Down a -> Down a -> Down a

sconcat :: NonEmpty (Down a) -> Down a

stimes :: Integral b => b -> Down a -> Down a

Monoid a => Monoid (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

mempty :: Down a

mappend :: Down a -> Down a -> Down a

mconcat :: [Down a] -> Down a

Preorder a => Preorder (Down a)

Defined in Data.Order

Methods

(<~) :: Down a -> Down a -> Bool

(>~) :: Down a -> Down a -> Bool

(?~) :: Down a -> Down a -> Bool

(~~) :: Down a -> Down a -> Bool

(/~) :: Down a -> Down a -> Bool

plt :: Down a -> Down a -> Bool

pgt :: Down a -> Down a -> Bool

similar :: Down a -> Down a -> Bool

pmax :: Down a -> Down a -> Maybe (Down a)

pmin :: Down a -> Down a -> Maybe (Down a)

pcompare :: Down a -> Down a -> Maybe Ordering

Generic1 Down

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: Down a -> Rep1 Down a

to1 :: Rep1 Down a -> Down a

type Rep (Down a)

Since: base-4.12.0.0

Defined in GHC.Generics

type Rep (Down a) = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Down

Since: base-4.12.0.0

Defined in GHC.Generics

type Rep1 Down = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

Extended

type Lifted = Either ()

type Lowered a = Either a ()

data Extended r

Extended r is an extension of r with positive/negative infinity (±∞).

Constructors

NegInf

negative infinity (-∞)

Finite !r

finite value

PosInf

positive infinity (+∞)

Instances

Functor Extended

Defined in Data.ExtendedReal

Methods

fmap :: (a -> b) -> Extended a -> Extended b

(<$) :: a -> Extended b -> Extended a

Connection k Double (Extended Int32)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Int32)

Connection k Double (Extended Int16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Int16)

Connection k Double (Extended Int8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Int8)

Connection k Double (Extended Word32)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Word32)

Connection k Double (Extended Word16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Word16)

Connection k Double (Extended Word8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Double (Extended Word8)

Connection k Float (Extended Int16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Float (Extended Int16)

Connection k Float (Extended Int8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Float (Extended Int8)

Connection k Float (Extended Word16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Float (Extended Word16)

Connection k Float (Extended Word8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Float (Extended Word8)

HasResolution res => Connection k Rational (Extended (Fixed res))

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended (Fixed res))

Connection k Rational (Extended SystemTime)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended SystemTime)

Connection k Rational (Extended Integer)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Integer)

Connection k Rational (Extended Int)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Int)

Connection k Rational (Extended Int64)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Int64)

Connection k Rational (Extended Int32)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Int32)

Connection k Rational (Extended Int16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Int16)

Connection k Rational (Extended Int8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Int8)

Connection k Rational (Extended Natural)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Natural)

Connection k Rational (Extended Word)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Word)

Connection k Rational (Extended Word64)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Word64)

Connection k Rational (Extended Word32)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Word32)

Connection k Rational (Extended Word16)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Word16)

Connection k Rational (Extended Word8)

Defined in Data.Connection.Class

Methods

conn :: Conn k Rational (Extended Word8)

HasResolution res => Connection L Double (Extended (Fixed res))

Defined in Data.Connection.Class

Methods

conn :: Conn L Double (Extended (Fixed res))

HasResolution res => Connection L Float (Extended (Fixed res))

Defined in Data.Connection.Class

Methods

conn :: Conn L Float (Extended (Fixed res))

Heyting a => Algebra R (Extended a)

Defined in Data.Lattice

Methods

algebra :: Extended a -> Conn R (Extended a) (Extended a)

Join a => Semilattice L (Extended a)

Defined in Data.Lattice

Methods

bound :: Conn L () (Extended a)

semilattice :: Conn L (Extended a, Extended a) (Extended a)

Meet a => Semilattice R (Extended a)

Defined in Data.Lattice

Methods

bound :: Conn R () (Extended a)

semilattice :: Conn R (Extended a, Extended a) (Extended a)

Bounded (Extended r)

Defined in Data.ExtendedReal

Methods

minBound :: Extended r

maxBound :: Extended r

Eq r => Eq (Extended r)

Defined in Data.ExtendedReal

Methods

(==) :: Extended r -> Extended r -> Bool

(/=) :: Extended r -> Extended r -> Bool

(Fractional r, Ord r) => Fractional (Extended r)

Note that Extended r is not a field, nor a ring.

Defined in Data.ExtendedReal

Methods

(/) :: Extended r -> Extended r -> Extended r

recip :: Extended r -> Extended r

fromRational :: Rational -> Extended r

Data r => Data (Extended r)

Defined in Data.ExtendedReal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extended r -> c (Extended r)

gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (Extended r)

toConstr :: Extended r -> Constr

dataTypeOf :: Extended r -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Extended r))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Extended r))

gmapT :: (forall b. Data b => b -> b) -> Extended r -> Extended r

gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> Extended r -> r0

gmapQr :: (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> Extended r -> r0

gmapQ :: (forall d. Data d => d -> u) -> Extended r -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Extended r -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r)

(Num r, Ord r) => Num (Extended r)

Note that Extended r is not a field, nor a ring.

PosInf + NegInf is left undefined as usual, but we define 0 * PosInf = 0 * NegInf = 0 by following the convention of probability or measure theory.

Defined in Data.ExtendedReal

Methods

(+) :: Extended r -> Extended r -> Extended r

(-) :: Extended r -> Extended r -> Extended r

(*) :: Extended r -> Extended r -> Extended r

negate :: Extended r -> Extended r

abs :: Extended r -> Extended r

signum :: Extended r -> Extended r

fromInteger :: Integer -> Extended r

Ord r => Ord (Extended r)

Defined in Data.ExtendedReal

Methods

compare :: Extended r -> Extended r -> Ordering

(<) :: Extended r -> Extended r -> Bool

(<=) :: Extended r -> Extended r -> Bool

(>) :: Extended r -> Extended r -> Bool

(>=) :: Extended r -> Extended r -> Bool

max :: Extended r -> Extended r -> Extended r

min :: Extended r -> Extended r -> Extended r

Read r => Read (Extended r)

Defined in Data.ExtendedReal

Methods

readsPrec :: Int -> ReadS (Extended r)

readList :: ReadS [Extended r]

readPrec :: ReadPrec (Extended r)

readListPrec :: ReadPrec [Extended r]

Show r => Show (Extended r)

Defined in Data.ExtendedReal

Methods

showsPrec :: Int -> Extended r -> ShowS

show :: Extended r -> String

showList :: [Extended r] -> ShowS

NFData r => NFData (Extended r)

Defined in Data.ExtendedReal

Methods

rnf :: Extended r -> ()

Hashable r => Hashable (Extended r)

Defined in Data.ExtendedReal

Methods

hashWithSalt :: Int -> Extended r -> Int

hash :: Extended r -> Int

Preorder a => Preorder (Extended a)

Defined in Data.Order

Methods

(<~) :: Extended a -> Extended a -> Bool

(>~) :: Extended a -> Extended a -> Bool

(?~) :: Extended a -> Extended a -> Bool

(~~) :: Extended a -> Extended a -> Bool

(/~) :: Extended a -> Extended a -> Bool

plt :: Extended a -> Extended a -> Bool

pgt :: Extended a -> Extended a -> Bool

similar :: Extended a -> Extended a -> Bool

pmax :: Extended a -> Extended a -> Maybe (Extended a)

pmin :: Extended a -> Extended a -> Maybe (Extended a)

pcompare :: Extended a -> Extended a -> Maybe Ordering

extended :: b -> b -> (a -> b) -> Extended a -> b

Eliminate an Extended.

extend :: (a -> Bool) -> (a -> Bool) -> (a -> b) -> a -> Extended b