AERN2.MP.Enclosure

Enclosure classes and operations.

Documentation

class IsBall t where

Minimal complete definition

centre, centreAsBallAndRadius, updateRadius

Associated Types

type CentreType t

Methods

centre :: t -> CentreType t

centreAsBallAndRadius :: t -> (t, ErrorBound)

centreAsBall :: t -> t

radius :: t -> ErrorBound

updateRadius :: (ErrorBound -> ErrorBound) -> t -> t

makeExactCentre :: IsBall t => t -> t

When the radius of the ball is implicitly contributed to by imprecision in the centre (eg if the centre is a polynomial with inexact coefficients), move all that imprecision to the explicit radius, making the centre exact. This may lose some information, but as a ball is equivalent to the original. For MPBall this function is pointless because it is equivalent to the identity.

Instances

IsBall MPBall

Associated Types

type CentreType MPBall :: *

Methods

centre :: MPBall -> CentreType MPBall

centreAsBallAndRadius :: MPBall -> (MPBall, ErrorBound)

centreAsBall :: MPBall -> MPBall

radius :: MPBall -> ErrorBound

updateRadius :: (ErrorBound -> ErrorBound) -> MPBall -> MPBall

makeExactCentre :: MPBall -> MPBall

class IsInterval i e where

Minimal complete definition

fromEndpoints, endpoints

Methods

fromEndpoints :: e -> e -> i

endpoints :: i -> (e, e)

Instances

IsInterval MPBall MPFloat

Methods

fromEndpoints :: MPFloat -> MPFloat -> MPBall

endpoints :: MPBall -> (MPFloat, MPFloat)

IsInterval MPBall MPBall

Methods

fromEndpoints :: MPBall -> MPBall -> MPBall

endpoints :: MPBall -> (MPBall, MPBall)

intervalFunctionByEndpoints

Arguments

:: (IsInterval t t, HasEqCertainly t t)

=> (t -> t)

fThin: a version of f that works well on thin intervals

-> t -> t

f on *large* intervals

Computes a *monotone* ball function f on intervals using the interval endpoints.

intervalFunctionByEndpointsUpDown

Arguments

:: IsInterval t e

=> (e -> e)

fDown: a version of f working on endpoints, rounded down

-> (e -> e)

fUp: a version of f working on endpoints, rounded up

-> t -> t

f on intervals rounding *outwards*

Computes a *monotone* ball function f on intervals using the interval endpoints.

class CanTestContains dom e where

Minimal complete definition

contains

Methods

contains :: dom -> e -> Bool

Test if e is inside dom.

Instances

CanTestContains MPBall Int

Methods

contains :: MPBall -> Int -> Bool

CanTestContains MPBall Integer

Methods

contains :: MPBall -> Integer -> Bool

CanTestContains MPBall Rational

Methods

contains :: MPBall -> Rational -> Bool

CanTestContains MPBall Dyadic

Methods

contains :: MPBall -> Dyadic -> Bool

CanTestContains MPBall MPBall

Methods

contains :: MPBall -> MPBall -> Bool

class CanMapInside dom e where

Minimal complete definition

mapInside

Methods

mapInside :: dom -> e -> e

Return some value contained in dom. The returned value does not have to equal the given e even if e is already inside dom. All elements of dom should be covered with roughly the same probability when calling this function for evenly distributed e's.

This function is intended mainly for generating values inside dom for randomised tests.

specCanMapInside :: (CanMapInside d e, CanTestContains d e, Arbitrary d, Arbitrary e, Show d, Show e) => T d -> T e -> Spec

class CanIntersectAsymmetric e1 e2 where

Minimal complete definition

intersect

Associated Types

type IntersectionType e1 e2

Methods

intersect :: e1 -> e2 -> IntersectionType e1 e2

Instances

CanIntersectAsymmetric Bool Bool

Associated Types

type IntersectionType Bool Bool :: *

Methods

intersect :: Bool -> Bool -> IntersectionType Bool Bool

(CanIntersectAsymmetric Bool b, CanEnsureCE es b, CanEnsureCE es (IntersectionType Bool b), SuitableForCE es) => CanIntersectAsymmetric Bool (CollectErrors es b)

Associated Types

type IntersectionType Bool (CollectErrors es b) :: *

Methods

intersect :: Bool -> CollectErrors es b -> IntersectionType Bool (CollectErrors es b)

(CanIntersectAsymmetric a b, CanEnsureCN a, (~) * (IntersectionType a b) (EnsureCN a), CanEnsureCN (EnsureCN a), CanEnsureCN b, (~) * (EnsureCN b) (EnsureCN a)) => CanIntersectAsymmetric (Maybe a) (Maybe b)

Associated Types

type IntersectionType (Maybe a) (Maybe b) :: *

Methods

intersect :: Maybe a -> Maybe b -> IntersectionType (Maybe a) (Maybe b)

(CanIntersectAsymmetric (Maybe a) b, CanEnsureCE es b, CanEnsureCE es (IntersectionType (Maybe a) b), SuitableForCE es) => CanIntersectAsymmetric (Maybe a) (CollectErrors es b)

Associated Types

type IntersectionType (Maybe a) (CollectErrors es b) :: *

Methods

intersect :: Maybe a -> CollectErrors es b -> IntersectionType (Maybe a) (CollectErrors es b)

(CanIntersectAsymmetric a Bool, CanEnsureCE es a, CanEnsureCE es (IntersectionType a Bool), SuitableForCE es) => CanIntersectAsymmetric (CollectErrors es a) Bool

Associated Types

type IntersectionType (CollectErrors es a) Bool :: *

Methods

intersect :: CollectErrors es a -> Bool -> IntersectionType (CollectErrors es a) Bool

(CanIntersectAsymmetric a (Maybe b), CanEnsureCE es a, CanEnsureCE es (IntersectionType a (Maybe b)), SuitableForCE es) => CanIntersectAsymmetric (CollectErrors es a) (Maybe b)

Associated Types

type IntersectionType (CollectErrors es a) (Maybe b) :: *

Methods

intersect :: CollectErrors es a -> Maybe b -> IntersectionType (CollectErrors es a) (Maybe b)

(CanIntersectAsymmetric e1 e2, SuitableForCE es, CanEnsureCE es e1, CanEnsureCE es e2, CanEnsureCE es (IntersectionType e1 e2)) => CanIntersectAsymmetric (CollectErrors es e1) (CollectErrors es e2)

Associated Types

type IntersectionType (CollectErrors es e1) (CollectErrors es e2) :: *

Methods

intersect :: CollectErrors es e1 -> CollectErrors es e2 -> IntersectionType (CollectErrors es e1) (CollectErrors es e2)

type CanIntersect e1 e2 = (CanIntersectAsymmetric e1 e2, CanIntersectAsymmetric e1 e2, IntersectionType e1 e2 ~ IntersectionType e2 e1)

type CanIntersectCNBy e1 e2 = (CanIntersect e1 e2, IntersectionType e1 e2 ~ EnsureCN e1, CanIntersect (EnsureCN e1) e2, IntersectionType (EnsureCN e1) e2 ~ EnsureCN e1)

type CanIntersectCNSameType e1 = (CanIntersectCNBy e1 e1, CanIntersect (EnsureCN e1) (EnsureCN e1), IntersectionType (EnsureCN e1) (EnsureCN e1) ~ EnsureCN e1)

class CanUnionAsymmetric e1 e2 where

Minimal complete definition

union

Associated Types

type UnionType e1 e2

Methods

union :: e1 -> e2 -> UnionType e1 e2

Instances

(CanUnionAsymmetric e1 e2, CanEnsureCN e1, CanEnsureCN e2, CanEnsureCN (UnionType e1 e2)) => CanUnionAsymmetric (CN e1) (CN e2)

Associated Types

type UnionType (CN e1) (CN e2) :: *

Methods

union :: CN e1 -> CN e2 -> UnionType (CN e1) (CN e2)

(Arrow to, CanUnionAsymmetric e1 e2) => CanUnionAsymmetric (to Accuracy e1) (to Accuracy e2)

Associated Types

type UnionType (to Accuracy e1) (to Accuracy e2) :: *

Methods

union :: to Accuracy e1 -> to Accuracy e2 -> UnionType (to Accuracy e1) (to Accuracy e2)

type CanUnion e1 e2 = (CanUnionAsymmetric e1 e2, CanUnionAsymmetric e1 e2, UnionType e1 e2 ~ UnionType e2 e1)

type CanUnionCNBy e1 e2 = (CanUnion e1 e2, UnionType e1 e2 ~ EnsureCN e1, CanUnion (EnsureCN e1) e2, UnionType (EnsureCN e1) e2 ~ EnsureCN e1)

type CanUnionCNSameType e1 = (CanUnionCNBy e1 e1, CanUnion (EnsureCN e1) (EnsureCN e1), UnionType (EnsureCN e1) (EnsureCN e1) ~ EnsureCN e1)

Orphan instances

(CanUnionCNSameType t, CanEnsureCN t) => HasIfThenElse (Maybe Bool) t

Associated Types

type IfThenElseType (Maybe Bool) t :: *

Methods

ifThenElse :: Maybe Bool -> t -> t -> IfThenElseType (Maybe Bool) t