interval-algebra-2.1.2: An implementation of Allen's interval algebra for temporal logic
Copyright(c) NoviSci Inc 2020
LicenseBSD3
Maintainerbsaul@novisci.com
Safe HaskellSafe
LanguageHaskell2010

IntervalAlgebra.Core

Description

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.
Synopsis

Intervals

data Interval a Source #

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

Instances

Instances details
Intervallic Interval Source # 
Instance details

Defined in IntervalAlgebra.Core

Ord a => IntervalCombinable Interval a Source # 
Instance details

Defined in IntervalAlgebra.Core

(Ord a, Arbitrary a) => Arbitrary (Interval a) Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

arbitrary :: Gen (Interval a)

shrink :: Interval a -> [Interval a]

Generic (Interval a) Source # 
Instance details

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) Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

showsPrec :: Int -> Interval a -> ShowS #

show :: Interval a -> String #

showList :: [Interval a] -> ShowS #

Binary a => Binary (Interval a) Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

put :: Interval a -> Put #

get :: Get (Interval a) #

putList :: [Interval a] -> Put #

NFData a => NFData (Interval a) Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

rnf :: Interval a -> () #

Eq a => Eq (Interval a) Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

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

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

Ord a => Ord (Interval a) Source #

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

Instance details

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) Source # 
Instance details

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 Source #

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 Source #

Get the interval from an i a.

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

Set the interval in an i a.

newtype ParseErrorInterval Source #

A type identifying interval parsing errors.

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

Access the endpoints of an i a .

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

Access the endpoints of an i a .

Create new intervals

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

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) Source #

A synonym for parseInterval

beginerval Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

A synonym for safeInterval

Modify intervals

expand Source #

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 Source #

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 Source #

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 Source #

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.

Instances

Instances details
Bounded IntervalRelation Source # 
Instance details

Defined in IntervalAlgebra.Core

Enum IntervalRelation Source # 
Instance details

Defined in IntervalAlgebra.Core

Show IntervalRelation Source # 
Instance details

Defined in IntervalAlgebra.Core

Eq IntervalRelation Source # 
Instance details

Defined in IntervalAlgebra.Core

Ord IntervalRelation Source # 
Instance details

Defined in IntervalAlgebra.Core

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

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

Operator for composing the union of two predicates

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

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

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

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 Source #

The set of IntervalRelation meaning two intervals are disjoint.

withinRelations :: Set IntervalRelation Source #

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

strictWithinRelations :: Set IntervalRelation Source #

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

type ComparativePredicateOf1 a = a -> a -> Bool Source #

Defines a predicate of two objects of type a.

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

Defines a predicate of two object of different types.

beginervalFromEnd Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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

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

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 Source #

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

Combine two intervals

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

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) Source #

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

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

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) Source #

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

Instances details
Ord a => IntervalCombinable Interval a Source # 
Instance details

Defined in IntervalAlgebra.Core

(Ord a, Eq b, Monoid b) => IntervalCombinable (PairedInterval b) a Source # 
Instance details

Defined in IntervalAlgebra.PairedInterval

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

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 Source #

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 Source #

The smallest duration for an 'Interval a'.

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

Determine the duration of an 'i a'.

add :: b -> a -> a Source #

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 Source #

Takes the difference between two a to return a b.

Instances

Instances details
IntervalSizeable Day Integer Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. Integer Source #

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

add :: Integer -> Day -> Day Source #

diff :: Day -> Day -> Integer Source #

IntervalSizeable UTCTime NominalDiffTime Source #

Note that the moment of this instance is a Pico

Instance details

Defined in IntervalAlgebra.Core

IntervalSizeable Integer Integer Source # 
Instance details

Defined in IntervalAlgebra.Core

IntervalSizeable Int Int Source # 
Instance details

Defined in IntervalAlgebra.Core

Methods

moment :: forall a. Int Source #

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

add :: Int -> Int -> Int Source #

diff :: Int -> Int -> Int Source #