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

IntervalAlgebra

Contents

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 five typeclasses designed to separate concerns of constructing, relating, and combining Intervals:

  1. Intervallic provides an interface to the data structure of an Interval, defining how an Interval a is constructed.
  2. IntervalAlgebraic provides an interface to the IntervalRelations, the workhorse of Allen's temporal logic.
  3. IntervalCombinable provides an interface to methods of combining two Intervals.
  4. IntervalSizeable and the related Moment provides methods for measuring and modifying the size of an interval.
  5. IntervalFilterable provides methods for filtering Filterable collections of intervals.

An advantage of nested typeclass design is that developers can define an Interval of type a with just the amount of structure that they need.

Total Ordering of Intervals

The modules makes the (opinionated) choice of a total ordering for Intervallic Intervals. Namely, the ordering is based on first ordering the begins then the ends.

Development

This module is under development and the API may change in the future.

Synopsis

Classes

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

The Intervallic typeclass specifies how an Interval as is constructed. It also includes functions for getting the begin and end of an Interval a.

Minimal complete definition

Nothing

Methods

parseInterval :: a -> a -> Either String (Interval a) Source #

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

unsafeInterval :: a -> a -> Interval a Source #

Create a new Interval a. This function is not safe as it does not enforce that \(x < y\). Use with caution. It is meant to be helper function in early prototyping of this package. This function may be deprecated in future releases.

begin :: Interval a -> a Source #

Access the ends of an Interval a .

end :: Interval a -> a Source #

Access the ends of an Interval a .

class (Eq a, Intervallic a) => IntervalAlgebraic a where Source #

The IntervalAlgebraic typeclass specifies the functions and relational operators for interval-based temporal logic. The typeclass defines the relational operators for intervals, plus other useful utilities such as disjoint, in', and composeRelations.

Minimal complete definition

Nothing

Methods

relate :: Interval a -> Interval a -> IntervalRelation Source #

Compare two intervals to determine their IntervalRelation.

equals :: ComparativePredicateOf (Interval a) Source #

Does x equal y?

meets :: ComparativePredicateOf (Interval a) Source #

Does x meet y? Is y metBy x?

metBy :: ComparativePredicateOf (Interval a) Source #

Does x meet y? Is y metBy x?

before :: ComparativePredicateOf (Interval a) Source #

Is x before y? Is x after y?

after :: ComparativePredicateOf (Interval a) Source #

Is x before y? Is x after y?

overlaps :: ComparativePredicateOf (Interval a) Source #

Does x overlap y? Is x overlapped by y?

overlappedBy :: ComparativePredicateOf (Interval a) Source #

Does x overlap y? Is x overlapped by y?

starts :: ComparativePredicateOf (Interval a) Source #

Does x start y? Is x started by y?

startedBy :: ComparativePredicateOf (Interval a) Source #

Does x start y? Is x started by y?

finishes :: ComparativePredicateOf (Interval a) Source #

Does x finish y? Is x finished by y?

finishedBy :: ComparativePredicateOf (Interval a) Source #

Does x finish y? Is x finished by y?

during :: ComparativePredicateOf (Interval a) Source #

Is x during y? Does x contain y?

contains :: ComparativePredicateOf (Interval a) Source #

Is x during y? Does x contain y?

composeRelations :: [ComparativePredicateOf (Interval a)] -> ComparativePredicateOf (Interval a) Source #

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

disjoint :: ComparativePredicateOf (Interval a) Source #

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

notDisjoint :: ComparativePredicateOf (Interval a) Source #

Are x and y not disjoint; i.e. do they share any support?

in' :: ComparativePredicateOf (Interval a) Source #

Is x contained in y in any sense (during, starts, finishes or equals?

Instances

Instances details
IntervalAlgebraic Int Source # 
Instance details

Defined in IntervalAlgebra

IntervalAlgebraic Integer Source # 
Instance details

Defined in IntervalAlgebra

IntervalAlgebraic Day Source # 
Instance details

Defined in IntervalAlgebra

class IntervalAlgebraic a => IntervalCombinable a where Source #

The IntervalCombinable typeclass provides methods for (possibly) combining two Intervals.

Minimal complete definition

Nothing

Methods

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

Maybe form a new Interval by the union of two Intervals that meets.

extenterval :: Interval a -> Interval a -> Interval a Source #

Creates a new Interval spanning the extent x and y

(><) :: Interval a -> Interval a -> Maybe (Interval 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 (Interval a)), Applicative f) => Interval a -> Interval a -> f (Interval a) Source #

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 folding over an *ordered* container of Intervals and combining intervals when x is *not* before y.

class (Intervallic a, Num b, Ord b) => Moment a b | a -> b where Source #

The Moment class fixes the smallest duration of an 'Intervallic a'.

Minimal complete definition

Nothing

Methods

moment :: b Source #

Instances

Instances details
Moment Int Int Source # 
Instance details

Defined in IntervalAlgebra

Methods

moment :: Int Source #

Moment Integer Integer Source # 
Instance details

Defined in IntervalAlgebra

Moment Day Integer Source # 
Instance details

Defined in IntervalAlgebra

class (Intervallic a, Moment a b, Num b, Ord b) => IntervalSizeable a b | a -> b where Source #

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

Minimal complete definition

add, diff

Methods

duration :: Interval a -> b Source #

Determine the duration of an 'Interval 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.

expand :: b -> b -> Interval a -> Interval a Source #

Resize an 'Interval 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.

expandl :: b -> Interval a -> Interval a Source #

Expands an 'Interval a' to left by i.

expandr :: b -> Interval a -> Interval a Source #

Expands an 'Interval a' to right by i.

beginerval :: b -> a -> Interval a Source #

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

enderval :: b -> a -> Interval a Source #

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

Instances

Instances details
IntervalSizeable Int Int Source # 
Instance details

Defined in IntervalAlgebra

IntervalSizeable Integer Integer Source # 
Instance details

Defined in IntervalAlgebra

IntervalSizeable Day Integer Source # 
Instance details

Defined in IntervalAlgebra

class (Filterable f, IntervalAlgebraic a) => IntervalFilterable f a where Source #

The IntervalFilterable class provides functions for filtering Filterables of Intervals based on IntervalAlgebraic relations.

Minimal complete definition

Nothing

Methods

filterMaker :: ComparativePredicateOf (Interval a) -> Interval a -> f (Interval a) -> f (Interval a) Source #

Creates a function for filtering a Filterable of Interval as based on a predicate

filterOverlaps :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that overlaps the Interval a in the first argument.

filterOverlappedBy :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those overlappedBy the Interval a in the first argument.

filterBefore :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those before the Interval a in the first argument.

filterAfter :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those after the Interval a in the first argument.

filterMeets :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that meets the Interval a in the first argument.

filterMetBy :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those metBy the Interval a in the first argument.

filterDuring :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those during the Interval a in the first argument.

filterContains :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that contains the Interval a in the first argument.

filterDisjoint :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that are disjoint from the Interval a in the first argument.

filterNotDisjoint :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that are notDisjoint from the Interval a in the first argument.

filterIn' :: Interval a -> f (Interval a) -> f (Interval a) Source #

Filter a Filterable of Interval as to those that are in' the Interval a in the first argument.

Instances

Instances details
IntervalFilterable [] Int Source # 
Instance details

Defined in IntervalAlgebra

IntervalFilterable [] Integer Source # 
Instance details

Defined in IntervalAlgebra

IntervalFilterable [] Day Source # 
Instance details

Defined in IntervalAlgebra

Types

data Interval a Source #

An Interval a is a pair of as \( (x, y) \text{ where } x < y\). The Intervallic class provides a safe parseInterval function that returns a Left error if \(y < x\) and unsafeInterval as constructor for creating an interval that may not be valid.

Instances

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

Defined in IntervalAlgebra

Methods

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

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

Intervallic 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

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 #

(Intervallic a, Show a) => Show (Interval a) Source # 
Instance details

Defined in IntervalAlgebra

Methods

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

show :: Interval a -> String #

showList :: [Interval a] -> ShowS #

Arbitrary (Interval Int) Source # 
Instance details

Defined in IntervalAlgebra.Arbitrary

Arbitrary (Interval Day) Source # 
Instance details

Defined in IntervalAlgebra.Arbitrary

data IntervalRelation Source #

The IntervalRelation type enumerates the thirteen possible ways that two Interval a objects can relate according to the interval algebra.

Meets, Metby

x `meets` y
y `metBy` x
x: |-----|
y:       |-----| 

Before, After

x `before` y
y `after` x
x: |-----|  
y:          |-----|

Overlaps, OverlappedBy

x `overlaps` y
y `overlappedBy` x
x: |-----|
y:     |-----|

Starts, StartedBy

x `starts` y
y `startedBy` x
x: |---| 
y: |-----|

Finishes, FinishedBy

x `finishes` y
y `finishedBy` x
x:   |---| 
y: |-----|

During, Contains

x `during` y
y `contains` x
x:   |-| 
y: |-----|

Equal

x `equal` y
y `equal` x
x: |-----| 
y: |-----|

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

Defines a predicate of two objects of type a.