IntervalAlgebra.Core

The IntervalAlgebra module provides data types and related classes for the interval-based temporal logic described in Allen (1983) and axiomatized in Allen and Hayes (1987). A good primer on Allen's algebra can be found here.

Design

The module is built around three typeclasses designed to separate concerns of constructing, relating, and combining types that contain Intervals:

1. Intervallic provides an interface to the data structures which contain an Interval.
2. IntervalCombinable provides an interface to methods of combining two Intervals.
3. IntervalSizeable provides methods for measuring and modifying the size of an interval.

Intervals

data Interval a

An Interval a is a pair \( (x, y) \text{ such that } x < y\). To create intervals use the parseInterval, beginerval, or enderval functions.

Instances

Intervallic Interval

Defined in IntervalAlgebra.Core

Methods

getInterval :: Interval a -> Interval a

setInterval :: Interval a -> Interval b -> Interval b

Ord a => IntervalCombinable Interval a

Defined in IntervalAlgebra.Core

Methods

(.+.) :: Interval a -> Interval a -> Maybe (Interval a)

(><) :: Interval a -> Interval a -> Maybe (Interval a)

(<+>) :: (Semigroup (f (Interval a)), Applicative f) => Interval a -> Interval a -> f (Interval a)

(Ord a, Arbitrary a) => Arbitrary (Interval a)

Defined in IntervalAlgebra.Core

Methods

arbitrary :: Gen (Interval a)

shrink :: Interval a -> [Interval a]

Generic (Interval a)

Defined in IntervalAlgebra.Core

Associated Types

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

Methods

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

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

(Show a, Ord a) => Show (Interval a)

Defined in IntervalAlgebra.Core

Methods

showsPrec :: Int -> Interval a -> ShowS

show :: Interval a -> String

showList :: [Interval a] -> ShowS

Binary a => Binary (Interval a)

Defined in IntervalAlgebra.Core

Methods

put :: Interval a -> Put

get :: Get (Interval a)

putList :: [Interval a] -> Put

NFData a => NFData (Interval a)

Defined in IntervalAlgebra.Core

Methods

rnf :: Interval a -> ()

Eq a => Eq (Interval a)

Defined in IntervalAlgebra.Core

Methods

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

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

Ord a => Ord (Interval a)

Imposes a total ordering on Interval a based on first ordering the begins then the ends.

Defined in IntervalAlgebra.Core

Methods

compare :: Interval a -> Interval a -> Ordering

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

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

(>) :: Interval a -> Interval a -> Bool

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

max :: Interval a -> Interval a -> Interval a

min :: Interval a -> Interval a -> Interval a

type Rep (Interval a)

Defined in IntervalAlgebra.Core

type Rep (Interval a) = D1 ('MetaData "Interval" "IntervalAlgebra.Core" "interval-algebra-2.1.2-inplace" 'True) (C1 ('MetaCons "Interval" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a, a))))

class Intervallic i where

The Intervallic typeclass defines how to get and set the Interval content of a data structure. It also includes functions for getting the endpoints of the Interval via begin and end.

>>> getInterval (Interval (0, 10))
(0, 10)

>>> begin (Interval (0, 10))
0

>>> end (Interval (0, 10))
10

Methods

getInterval :: i a -> Interval a

Get the interval from an i a.

setInterval :: i a -> Interval b -> i b

Set the interval in an i a.

Instances

Intervallic Interval

Defined in IntervalAlgebra.Core

Methods

getInterval :: Interval a -> Interval a

setInterval :: Interval a -> Interval b -> Interval b

Intervallic IntervalText

Defined in IntervalAlgebra.IntervalDiagram

Methods

getInterval :: IntervalText a -> Interval a

setInterval :: IntervalText a -> Interval b -> IntervalText b

Intervallic (PairedInterval b)

Defined in IntervalAlgebra.PairedInterval

Methods

getInterval :: PairedInterval b a -> Interval a

setInterval :: PairedInterval b a -> Interval b0 -> PairedInterval b b0

newtype ParseErrorInterval

A type identifying interval parsing errors.

Constructors

ParseErrorInterval String

Instances

Show ParseErrorInterval

Defined in IntervalAlgebra.Core

Methods

showsPrec :: Int -> ParseErrorInterval -> ShowS

show :: ParseErrorInterval -> String

showList :: [ParseErrorInterval] -> ShowS

Eq ParseErrorInterval

Defined in IntervalAlgebra.Core

Methods

(==) :: ParseErrorInterval -> ParseErrorInterval -> Bool

(/=) :: ParseErrorInterval -> ParseErrorInterval -> Bool

begin :: Intervallic i => i a -> a

Access the endpoints of an i a .

end :: Intervallic i => i a -> a

Access the endpoints of an i a .

Create new intervals

parseInterval :: (Show a, Ord a) => a -> a -> Either ParseErrorInterval (Interval a)

Safely parse a pair of as to create an Interval a.

>>> parseInterval 0 1
Right (0, 1)

>>> parseInterval 1 0
Left (ParseErrorInterval "0<=1")

prsi :: (Show a, Ord a) => a -> a -> Either ParseErrorInterval (Interval a)

A synonym for parseInterval

beginerval

Arguments

:: forall a b. IntervalSizeable a b

=> b

duration to add to the begin

-> a

the begin point of the Interval

-> Interval a

Safely creates an 'Interval a' using x as the begin and adding max moment dur to x as the end.

>>> beginerval (0::Int) (0::Int)
(0, 1)

>>> beginerval (1::Int) (0::Int)
(0, 1)

>>> beginerval (2::Int) (0::Int)
(0, 2)

bi

Arguments

:: IntervalSizeable a b

=> b

duration to add to the begin

-> a

the begin point of the Interval

-> Interval a

A synonym for beginerval

enderval

Arguments

:: forall a b. IntervalSizeable a b

=> b

duration to subtract from the end

-> a

the end point of the Interval

-> Interval a

Safely creates an 'Interval a' using x as the end and adding negate max moment dur to x as the begin.

>>> enderval (0::Int) (0::Int)
(-1, 0)

>>> enderval (1::Int) (0::Int)
(-1, 0)

>>> enderval (2::Int) (0::Int)
(-2, 0)

ei

Arguments

:: IntervalSizeable a b

=> b

duration to subtract from the end

-> a

the end point of the Interval

-> Interval a

A synonym for enderval

safeInterval :: IntervalSizeable a b => (a, a) -> Interval a

Safely creates an Interval from a pair of endpoints. IMPORTANT: This function uses beginerval, thus if the second element of the pair is <= the first element, the duration will be an Interval of moment duration.

>>> safeInterval (4, 5 ::Int)
(4, 5)
>>> safeInterval (4, 3 :: Int)
(4, 5)

si :: IntervalSizeable a b => (a, a) -> Interval a

A synonym for safeInterval

Modify intervals

expand

Arguments

:: forall i a b. (IntervalSizeable a b, Intervallic i)

=> b

duration to subtract from the begin

-> b

duration to add to the end

-> i a

-> i a

Resize an i a to by expanding to "left" by l and to the "right" by r. In the case that l or r are less than a moment the respective endpoints are unchanged.

>>> iv2to4 = safeInterval (2::Int, 4::Int)
>>> iv2to4' = expand 0 0 iv2to4
>>> iv1to5 = expand 1 1 iv2to4

>>> iv2to4
(2, 4)

>>> iv2to4'
(2, 4)

>>> iv1to5
(1, 5)

>>> pretty $ standardExampleDiagram [(iv2to4, "iv2to4"), (iv1to5, "iv1to5")] []
  --  <- [iv2to4]
 ---- <- [iv1to5]
=====

expandl :: (IntervalSizeable a b, Intervallic i) => b -> i a -> i a

Expands an i a to the "left".

>>> iv2to4 = (safeInterval (2::Int, 4::Int))
>>> iv0to4 = expandl 2 iv2to4

>>> iv2to4
(2, 4)

>>> iv0to4
(0, 4)

>>> pretty $ standardExampleDiagram [(iv2to4, "iv2to4"), (iv0to4, "iv0to4")] []
  -- <- [iv2to4]
---- <- [iv0to4]
====

expandr :: (IntervalSizeable a b, Intervallic i) => b -> i a -> i a

Expands an i a to the "right".

>>> iv2to4 = (safeInterval (2::Int, 4::Int))
>>> iv2to6 = expandr 2 iv2to4

>>> iv2to4
(2, 4)

>>> iv2to6
(2, 6)

>>> pretty $ standardExampleDiagram [(iv2to4, "iv2to4"), (iv2to6, "iv2to6")] []
  --   <- [iv2to4]
  ---- <- [iv2to6]
======

Interval Algebra

Interval Relations and Predicates

data IntervalRelation

The IntervalRelation type and the associated predicate functions enumerate the thirteen possible ways that two Interval objects may relate according to Allen's interval algebra. Constructors are shown with their corresponding predicate function.

Constructors

Before

before

Meets

meets

Overlaps

overlaps

FinishedBy

finishedBy

Contains

contains

Starts

starts

Equals

equals

StartedBy

startedBy

During

during

Finishes

finishes

OverlappedBy

overlappedBy

MetBy

metBy

After

after

Instances

Bounded IntervalRelation

Defined in IntervalAlgebra.Core

Methods

minBound :: IntervalRelation

maxBound :: IntervalRelation

Enum IntervalRelation

Defined in IntervalAlgebra.Core

Methods

succ :: IntervalRelation -> IntervalRelation

pred :: IntervalRelation -> IntervalRelation

toEnum :: Int -> IntervalRelation

fromEnum :: IntervalRelation -> Int

enumFrom :: IntervalRelation -> [IntervalRelation]

enumFromThen :: IntervalRelation -> IntervalRelation -> [IntervalRelation]

enumFromTo :: IntervalRelation -> IntervalRelation -> [IntervalRelation]

enumFromThenTo :: IntervalRelation -> IntervalRelation -> IntervalRelation -> [IntervalRelation]

Show IntervalRelation

Defined in IntervalAlgebra.Core

Methods

showsPrec :: Int -> IntervalRelation -> ShowS

show :: IntervalRelation -> String

showList :: [IntervalRelation] -> ShowS

Eq IntervalRelation

Defined in IntervalAlgebra.Core

Methods

(==) :: IntervalRelation -> IntervalRelation -> Bool

(/=) :: IntervalRelation -> IntervalRelation -> Bool

Ord IntervalRelation

Defined in IntervalAlgebra.Core

Methods

compare :: IntervalRelation -> IntervalRelation -> Ordering

(<) :: IntervalRelation -> IntervalRelation -> Bool

(<=) :: IntervalRelation -> IntervalRelation -> Bool

(>) :: IntervalRelation -> IntervalRelation -> Bool

(>=) :: IntervalRelation -> IntervalRelation -> Bool

max :: IntervalRelation -> IntervalRelation -> IntervalRelation

min :: IntervalRelation -> IntervalRelation -> IntervalRelation

meets :: (Eq a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x meets y? Is x metBy y?

Example data with corresponding diagram:

>>> x = bi 5 0
>>> y = bi 5 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
-----      <- [x]
     ----- <- [y]
==========

Examples:

>>> x `meets` y
True

>>> x `metBy` y
False

>>> y `meets` x
False

>>> y `metBy` x
True

metBy :: (Eq a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x meets y? Is x metBy y?

Example data with corresponding diagram:

>>> x = bi 5 0
>>> y = bi 5 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
-----      <- [x]
     ----- <- [y]
==========

Examples:

>>> x `meets` y
True

>>> x `metBy` y
False

>>> y `meets` x
False

>>> y `metBy` x
True

before :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x before y? Does x precedes y? Is x after y? Is x precededBy y?

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 4 6
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---        <- [x]
      ---- <- [y]
==========

Examples:

>>> x `before` y
True
>>> x `precedes` y
True

>>> x `after`y
False
>>> x `precededBy` y
False

>>> y `before` x
False
>>> y `precedes` x
False

>>> y `after` x
True
>>> y `precededBy` x
True

after :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x before y? Does x precedes y? Is x after y? Is x precededBy y?

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 4 6
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---        <- [x]
      ---- <- [y]
==========

Examples:

>>> x `before` y
True
>>> x `precedes` y
True

>>> x `after`y
False
>>> x `precededBy` y
False

>>> y `before` x
False
>>> y `precedes` x
False

>>> y `after` x
True
>>> y `precededBy` x
True

overlaps :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x overlaps y? Is x overlappedBy y?

Example data with corresponding diagram:

>>> x = bi 6 0
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
------     <- [x]
    ------ <- [y]
==========

Examples:

>>> x `overlaps` y
True

>>> x `overlappedBy` y
False

>>> y `overlaps` x
False

>>> y `overlappedBy` x
True

overlappedBy :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x overlaps y? Is x overlappedBy y?

Example data with corresponding diagram:

>>> x = bi 6 0
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
------     <- [x]
    ------ <- [y]
==========

Examples:

>>> x `overlaps` y
True

>>> x `overlappedBy` y
False

>>> y `overlaps` x
False

>>> y `overlappedBy` x
True

finishedBy :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x finishes y? Is x finishedBy y?

Example data with corresponding diagram:

>>> x = bi 3 7
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
       --- <- [x]
    ------ <- [y]
==========

Examples:

>>> x `finishes` y
True

>>> x `finishedBy` y
False

>>> y `finishes` x
False

>>> y `finishedBy` x
True

finishes :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x finishes y? Is x finishedBy y?

Example data with corresponding diagram:

>>> x = bi 3 7
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
       --- <- [x]
    ------ <- [y]
==========

Examples:

>>> x `finishes` y
True

>>> x `finishedBy` y
False

>>> y `finishes` x
False

>>> y `finishedBy` x
True

contains :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x during y? Does x contains y?

Example data with corresponding diagram:

>>> x = bi 3 5
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
     ---   <- [x]
    ------ <- [y]
==========

Examples:

>>> x `during` y
True

>>> x `contains` y
False

>>> y `during` x
False

>>> y `contains` x
True

during :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x during y? Does x contains y?

Example data with corresponding diagram:

>>> x = bi 3 5
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
     ---   <- [x]
    ------ <- [y]
==========

Examples:

>>> x `during` y
True

>>> x `contains` y
False

>>> y `during` x
False

>>> y `contains` x
True

starts :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x starts y? Is x startedBy y?

Example data with corresponding diagram:

>>> x = bi 3 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ---    <- [x]
    ------ <- [y]
==========

Examples:

>>> x `starts` y
True

>>> x `startedBy` y
False

>>> y `starts` x
False

>>> y `startedBy` x
True

startedBy :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x starts y? Is x startedBy y?

Example data with corresponding diagram:

>>> x = bi 3 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ---    <- [x]
    ------ <- [y]
==========

Examples:

>>> x `starts` y
True

>>> x `startedBy` y
False

>>> y `starts` x
False

>>> y `startedBy` x
True

equals :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x equals y?

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    ------ <- [y]
==========

Examples:

>>> x `equals` y
True

>>> y `equals` x
True

Additional predicates and utilities

precedes :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x before y? Does x precedes y? Is x after y? Is x precededBy y?

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 4 6
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---        <- [x]
      ---- <- [y]
==========

Examples:

>>> x `before` y
True
>>> x `precedes` y
True

>>> x `after`y
False
>>> x `precededBy` y
False

>>> y `before` x
False
>>> y `precedes` x
False

>>> y `after` x
True
>>> y `precededBy` x
True

precededBy :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x before y? Does x precedes y? Is x after y? Is x precededBy y?

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 4 6
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---        <- [x]
      ---- <- [y]
==========

Examples:

>>> x `before` y
True
>>> x `precedes` y
True

>>> x `after`y
False
>>> x `precededBy` y
False

>>> y `before` x
False
>>> y `precedes` x
False

>>> y `after` x
True
>>> y `precededBy` x
True

disjoint :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Are x and y disjoint (before, after, meets, or metBy)?

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---      <- [x]
     --- <- [y]
========

Examples:

>>> x `disjoint` y
True

>>> y `disjoint` x
True

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---    <- [x]
   --- <- [y]
======

Examples:

>>> x `disjoint` y
True

>>> y `disjoint` x
True

Example data with corresponding diagram:

>>> x = bi 6 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
------ <- [x]
   --- <- [y]
======

Examples:

>>> x `disjoint` y
False

>>> y `disjoint` x
False

notDisjoint :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x concur with y? Is x notDisjoint with y?); This is the complement of disjoint.

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---     <- [x]
    --- <- [y]
=======

Examples:

>>> x `notDisjoint` y
False
>>> y `concur` x
False

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---    <- [x]
   --- <- [y]
======

Examples:

>>> x `notDisjoint` y
False
>>> y `concur` x
False

Example data with corresponding diagram:

>>> x = bi 6 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
------ <- [x]
   --- <- [y]
======

Examples:

>>> x `notDisjoint` y
True
>>> y `concur` x
True

concur :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x concur with y? Is x notDisjoint with y?); This is the complement of disjoint.

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---     <- [x]
    --- <- [y]
=======

Examples:

>>> x `notDisjoint` y
False
>>> y `concur` x
False

Example data with corresponding diagram:

>>> x = bi 3 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
---    <- [x]
   --- <- [y]
======

Examples:

>>> x `notDisjoint` y
False
>>> y `concur` x
False

Example data with corresponding diagram:

>>> x = bi 6 0
>>> y = bi 3 3
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
------ <- [x]
   --- <- [y]
======

Examples:

>>> x `notDisjoint` y
True
>>> y `concur` x
True

within :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x within (enclosedBy) y? That is, during, starts, finishes, or equals?

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    ------ <- [y]
==========

Examples:

>>> x `within` y
True

>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 5 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    -----  <- [y]
==========

Examples:

>>> x `within` y
False

>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 4 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
     ----  <- [y]
==========

Examples:

>>> x `within` y
False
>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 2 7
>>> y = bi 1 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
       -- <- [x]
     -    <- [y]
=========

Examples:

>>> x `within` y
False

>>> y `enclosedBy` x
False

encloses :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Does x encloses y? That is, is y within x?

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    ------ <- [y]
==========

Examples:

>>> x `encloses` y
True

>>> y `encloses` x
True

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 5 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    -----  <- [y]
==========

Examples:

>>> x `encloses` y
True

>>> y `encloses` x
False

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 4 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
     ----  <- [y]
==========

Examples:

>>> x `encloses` y
True

>>> y `encloses` x
False

Example data with corresponding diagram:

>>> x = bi 2 7
>>> y = bi 1 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
       -- <- [x]
     -    <- [y]
=========

Examples:

>>> x `encloses` y
False

>>> y `encloses` x
False

enclosedBy :: (Ord a, Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a)

Is x within (enclosedBy) y? That is, during, starts, finishes, or equals?

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 6 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    ------ <- [y]
==========

Examples:

>>> x `within` y
True

>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 5 4
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
    -----  <- [y]
==========

Examples:

>>> x `within` y
False

>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 6 4
>>> y = bi 4 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
    ------ <- [x]
     ----  <- [y]
==========

Examples:

>>> x `within` y
False
>>> y `enclosedBy` x
True

Example data with corresponding diagram:

>>> x = bi 2 7
>>> y = bi 1 5
>>> pretty $ standardExampleDiagram [(x, "x"), (y, "y")] []
       -- <- [x]
     -    <- [y]
=========

Examples:

>>> x `within` y
False

>>> y `enclosedBy` x
False

(<|>) :: (Intervallic i0, Intervallic i1) => ComparativePredicateOf2 (i0 a) (i1 a) -> ComparativePredicateOf2 (i0 a) (i1 a) -> ComparativePredicateOf2 (i0 a) (i1 a)

Operator for composing the union of two predicates

predicate :: (Ord a, Intervallic i0, Intervallic i1) => Set IntervalRelation -> ComparativePredicateOf2 (i0 a) (i1 a)

Forms a predicate function from the union of a set of IntervalRelations.

unionPredicates :: [ComparativePredicateOf2 a b] -> ComparativePredicateOf2 a b

Compose a list of interval relations with _or_ to create a new ComparativePredicateOf1 i a. For example, unionPredicates [before, meets] creates a predicate function determining if one interval is either before or meets another interval.

disjointRelations :: Set IntervalRelation

The set of IntervalRelation meaning two intervals are disjoint.

withinRelations :: Set IntervalRelation

The set of IntervalRelation meaning one interval is within the other.

strictWithinRelations :: Set IntervalRelation

The set of IntervalRelation meaning one interval is *strictly* within the other.

type ComparativePredicateOf1 a = a -> a -> Bool

Defines a predicate of two objects of type a.

type ComparativePredicateOf2 a b = a -> b -> Bool

Defines a predicate of two object of different types.

beginervalFromEnd

Arguments

:: (IntervalSizeable a b, Intervallic i)

=> b

duration to add to the end

-> i a

the i a from which to get the end

-> Interval a

Creates a new Interval from the end of an i a.

endervalFromBegin

Arguments

:: (IntervalSizeable a b, Intervallic i)

=> b

duration to subtract from the begin

-> i a

the i a from which to get the begin

-> Interval a

Creates a new Interval from the begin of an i a.

beginervalMoment :: forall a b. IntervalSizeable a b => a -> Interval a

Safely creates a new Interval with moment length with begin at x

>>> beginervalMoment (10 :: Int)
(10, 11)

endervalMoment :: forall a b. IntervalSizeable a b => a -> Interval a

Safely creates a new Interval with moment length with end at x

>>> endervalMoment (10 :: Int)
(9, 10)

shiftFromBegin :: (IntervalSizeable a b, Intervallic i1, Intervallic i0) => i0 a -> i1 a -> i1 b

Modifies the endpoints of second argument's interval by taking the difference from the first's input's begin.

Example data with corresponding diagram:

>>> a = bi 3 2 :: Interval Int
>>> a
(2, 5)
>>> x = bi 3 7 :: Interval Int
>>> x
(7, 10)
>>> y = bi 4 9 :: Interval Int
>>> y
(9, 13)
>>> pretty $ standardExampleDiagram [(a, "a"), (x, "x"), (y, "y")] []
  ---         <- [a]
       ---    <- [x]
         ---- <- [y]
=============

Examples:

>>> x' = shiftFromBegin a x
>>> x'
(5, 8)
>>> y' = shiftFromBegin a y
>>> y'
(7, 11)
>>> pretty $ standardExampleDiagram [(x', "x'"), (y', "y'")] []
     ---    <- [x']
       ---- <- [y']
===========

shiftFromEnd :: (IntervalSizeable a b, Intervallic i1, Intervallic i0) => i0 a -> i1 a -> i1 b

Modifies the endpoints of second argument's interval by taking the difference from the first's input's end.

Example data with corresponding diagram:

>>> a = bi 3 2 :: Interval Int
>>> a
(2, 5)
>>> x = bi 3 7 :: Interval Int
>>> x
(7, 10)
>>> y = bi 4 9 :: Interval Int
>>> y
(9, 13)
>>> pretty $ standardExampleDiagram [(a, "a"), (x, "x"), (y, "y")] []
  ---         <- [a]
       ---    <- [x]
         ---- <- [y]
=============

Examples:

>>> x' = shiftFromEnd a x
>>> x'
(2, 5)
>>> y' = shiftFromEnd a y
>>> y'
(4, 8)
>>> pretty $ standardExampleDiagram [(x', "x'"), (y', "y'")] []
  ---    <- [x']
    ---- <- [y']
========

momentize :: forall i a b. (IntervalSizeable a b, Intervallic i) => i a -> i a

Changes the duration of an Intervallic value to a moment starting at the begin of the interval.

>>> momentize (Interval (6, 10))
(6, 7)

toEnumInterval :: (Enum a, Intervallic i) => i Int -> i a

Converts an i Int to an i a via toEnum. This assumes the provided toEnum method is strictly monotone increasing: For a types that are Ord, then for Int values x, y it holds that x < y implies toEnum x < toEnum y.

fromEnumInterval :: (Enum a, Intervallic i) => i a -> i Int

Converts an i a to an i Int via fromEnum. This assumes the provided fromEnum method is strictly monotone increasing: For a types that are Ord with values x, y, then x < y implies fromEnum x < fromEnum y, so long as the latter is well-defined.

Algebraic operations

intervalRelations :: Set IntervalRelation

The Set of all IntervalRelations.

relate :: (Ord a, Intervallic i0, Intervallic i1) => i0 a -> i1 a -> IntervalRelation

Compare two i a to determine their IntervalRelation.

>>> relate (Interval (0::Int, 1)) (Interval (1, 2))
Meets

>>> relate (Interval (1::Int, 2)) (Interval (0, 1))
MetBy

compose :: IntervalRelation -> IntervalRelation -> Set IntervalRelation

Compose two interval relations according to the rules of the algebra. The rules are enumerated according to this table.

complement :: Set IntervalRelation -> Set IntervalRelation

Finds the complement of a Set IntervalRelation.

union :: Set IntervalRelation -> Set IntervalRelation -> Set IntervalRelation

Find the union of two Sets of IntervalRelations.

intersection :: Set IntervalRelation -> Set IntervalRelation -> Set IntervalRelation

Find the intersection of two Sets of IntervalRelations.

converse :: Set IntervalRelation -> Set IntervalRelation

Find the converse of a Set IntervalRelation.

Combine two intervals

class (Ord a, Intervallic i) => IntervalCombinable i a where

The IntervalCombinable typeclass provides methods for (possibly) combining two i as to form a Maybe i a, or in case of ><, a possibly different Intervallic type.

Minimal complete definition

(><), (<+>)

Methods

(.+.) :: i a -> i a -> Maybe (i a)

Maybe form a new i a by the union of two i as that meets.

(><) :: i a -> i a -> Maybe (i a)

If x is before y, then form a new Just Interval a from the interval in the "gap" between x and y from the end of x to the begin of y. Otherwise, Nothing.

(<+>) :: (Semigroup (f (i a)), Applicative f) => i a -> i a -> f (i a)

Deprecated: A specialized function without clear use-cases.

If x is before y, return f x appended to f y. Otherwise, return extenterval of x and y (wrapped in f). This is useful for (left) folding over an *ordered* container of Intervals and combining intervals when x is *not* before y.

Instances

Ord a => IntervalCombinable Interval a

Defined in IntervalAlgebra.Core

Methods

(.+.) :: Interval a -> Interval a -> Maybe (Interval a)

(><) :: Interval a -> Interval a -> Maybe (Interval a)

(<+>) :: (Semigroup (f (Interval a)), Applicative f) => Interval a -> Interval a -> f (Interval a)

(Ord a, Eq b, Monoid b) => IntervalCombinable (PairedInterval b) a

Defined in IntervalAlgebra.PairedInterval

Methods

(.+.) :: PairedInterval b a -> PairedInterval b a -> Maybe (PairedInterval b a)

(><) :: PairedInterval b a -> PairedInterval b a -> Maybe (PairedInterval b a)

(<+>) :: (Semigroup (f (PairedInterval b a)), Applicative f) => PairedInterval b a -> PairedInterval b a -> f (PairedInterval b a)

extenterval :: (Ord a, Intervallic i) => i a -> i a -> Interval a

Creates a new Interval spanning the extent x and y.

>>> extenterval (Interval (0, 1)) (Interval (9, 10))
(0, 10)

Measure an interval

class (Ord a, Num b, Ord b) => IntervalSizeable a b | a -> b where

The IntervalSizeable typeclass provides functions to determine the size of an Intervallic type and to resize an 'Interval a'.

Minimal complete definition

add, diff

Methods

moment :: forall a. b

The smallest duration for an 'Interval a'.

duration :: Intervallic i => i a -> b

Determine the duration of an 'i a'.

add :: b -> a -> a

Shifts an a. Most often, the b will be the same type as a. But for example, if a is Day then b could be Int.

diff :: a -> a -> b

Takes the difference between two a to return a b.

Instances

IntervalSizeable Day Integer

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. Integer

duration :: Intervallic i => i Day -> Integer

add :: Integer -> Day -> Day

diff :: Day -> Day -> Integer

IntervalSizeable UTCTime NominalDiffTime

Note that the moment of this instance is a Pico

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. NominalDiffTime

duration :: Intervallic i => i UTCTime -> NominalDiffTime

add :: NominalDiffTime -> UTCTime -> UTCTime

diff :: UTCTime -> UTCTime -> NominalDiffTime

IntervalSizeable Integer Integer

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. Integer

duration :: Intervallic i => i Integer -> Integer

add :: Integer -> Integer -> Integer

diff :: Integer -> Integer -> Integer

IntervalSizeable Int Int

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. Int

duration :: Intervallic i => i Int -> Int

add :: Int -> Int -> Int

diff :: Int -> Int -> Int