IntervalAlgebra.IntervalUtilities

Documentation

combineIntervals :: (IntervalCombinable a, Applicative f, Monoid (f (Interval a)), Foldable f) => f (Interval a) -> f (Interval a)

Returns a container of intervals where any intervals that meet or share support are combined into one interval. *To work properly, the input should be sorted*. See combineIntervals' for a version that works only on lists.

>>> combineIntervals [intInt 0 10, intInt 2 7, intInt 10 12, intInt 13 15]
[(0, 12),(13, 15)]

combineIntervals' :: IntervalCombinable a => [Interval a] -> [Interval a]

Returns a list of intervals where any intervals that meet or share support are combined into one interval. *To work properly, the input list should be sorted*.

>>> combineIntervals' [intInt 0 10, intInt 2 7, intInt 10 12, intInt 13 15]
[(0, 12),(13, 15)]

gaps :: (IntervalCombinable a, Applicative f, Monoid (f (Interval a)), Foldable f) => f (Interval a) -> f (Interval a)

Returns a (possibly empty) container of intervals consisting of the gaps between intervals in the input. *To work properly, the input should be sorted*. See gaps' for a version that returns a list.

>>> gaps [intInt 1 5, intInt 8 12, intInt 11 14]
[(5, 8)]

gaps' :: (IntervalCombinable a, Applicative f, Monoid (f (Interval a)), Foldable f) => f (Interval a) -> [Interval a]

Returns a (possibly empty) list of intervals consisting of the gaps between intervals in the input container. *To work properly, the input should be sorted*. This version outputs a list. See gaps for a version that lifts the result to same input structure f.

durations :: (Functor f, Intervallic i a, IntervalSizeable a b) => f (i a) -> f b

Returns the duration of each 'Intervallic i a' in the Functor f.

>>> durations [intInt 1 10, intInt 2 12, intInt 5 6]
[9,10,1]

clip :: (IntervalAlgebraic Interval a, IntervalSizeable a b) => Interval a -> Interval a -> Maybe (Interval a)

In the case that x y are not disjoint, clips y to the extent of x.

>>> clip (intInt 0 5) (intInt 3 6)
Just (3, 5)

>>> clip (intInt 0 3) (intInt 4 6)
Nothing

relations :: (IntervalAlgebraic i a, Foldable f) => f (i a) -> [IntervalRelation (i a)]

Returns a list of the IntervalRelation between each consecutive pair of intervals. This the specialized form of relations' which can return any Applicative, Monoid structure.

>>> relations [intInt 0 1, intInt 1 2]
[Meets]

relations' :: (IntervalAlgebraic i a, Foldable f, Applicative m, Monoid (m (IntervalRelation (i a)))) => f (i a) -> m (IntervalRelation (i a))

A generic form of relations which can output any Applicative and Monoid structure. >>> (relations' [intInt 0 1, intInt 1 2]) :: [IntervalRelation Int] [Meets]

gapsWithin

Arguments

:: (Applicative f, Foldable f, Monoid (f (Interval a)), IntervalSizeable a b, IntervalCombinable a, Filterable f, IntervalAlgebraic Interval a)

=> Interval a

i

-> f (Interval a)

x

-> Maybe (f (Interval a))

Applies gaps to all the non-disjoint intervals in x that are *not* disjoint from i. Intervals that overlaps or are overlappedBy i are clipped to i, so that all the intervals are within i. If there are no gaps, then Nothing is returned.

>>> gapsWithin (intInt 1 10) [intInt 0 5, intInt 7 9, intInt 12 15]
Just [(5, 7),(9, 10)]

nothingIf

Arguments

:: (Monoid (f (i a)), Filterable f, IntervalAlgebraic i a)

=> ((i a -> Bool) -> f (i a) -> Bool)

e.g. any or all

-> (i a -> Bool)

predicate to apply to each element of input list

-> f (i a)

-> Maybe (f (i a))

Given a predicate combinator, a predicate, and list of intervals, returns the input unchanged if the predicate combinator is True. Otherwise, returns an empty list. See nothingIfAny and nothingIfNone for examples.

nothingIfNone

Arguments

:: (Monoid (f (i a)), Foldable f, Filterable f, IntervalAlgebraic i a)

=> (i a -> Bool)

predicate to apply to each element of input list

-> f (i a)

-> Maybe (f (i a))

Returns the Nothing if *none* of the element of input satisfy the predicate condition.

For example, the following returns Nothing because none of the intervals in the input list starts (3, 5).

>>> nothingIfNone (starts (intInt 3 5)) [intInt 3 4, intInt 5 6]
Nothing

In the following, (3, 5) starts (3, 6), so Just the input is returned.

>>> nothingIfNone (starts (intInt 3 5)) [intInt 3 6, intInt 5 6]
Just [(3, 6),(5, 6)]

nothingIfAny

Arguments

:: (Monoid (f (i a)), Foldable f, Filterable f, IntervalAlgebraic i a)

=> (i a -> Bool)

predicate to apply to each element of input list

-> f (i a)

-> Maybe (f (i a))

Returns Nothing if *any* of the element of input satisfy the predicate condition.

nothingIfAll

Arguments

:: (Monoid (f (i a)), Foldable f, Filterable f, IntervalAlgebraic i a)

=> (i a -> Bool)

predicate to apply to each element of input list

-> f (i a)

-> Maybe (f (i a))

Returns Nothing if *all* of the element of input satisfy the predicate condition

Filtering functions

compareIntervals :: (IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => ComparativePredicateOf (Interval a) -> i0 a -> i1 a -> Bool

Filter functions provides means for filtering Filterable containers of 'Intervallic i a's based on IntervalAlgebraic relations.

Lifts a predicate to be able to compare two different IntervalAlgebraic structure by comparing the intervals contain within each.

filterBefore :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by before.

filterMeets :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by meets.

filterOverlaps :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by overlaps.

filterFinishedBy :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter byfinishedBy.

filterContains :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by contains.

filterStarts :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by starts.

filterEquals :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by equals.

filterStartedBy :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by startedBy.

filterDuring :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by during.

filterFinishes :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by finishes.

filterOverlappedBy :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by overlappedBy.

filterMetBy :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by metBy.

filterAfter :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by after.

filterDisjoint :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by disjoint.

filterNotDisjoint :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by notDisjoint.

filterConcur :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by concur.

filterWithin :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by within.

filterEnclose :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by enclose.

filterEnclosedBy :: (Filterable f, IntervalAlgebraic Interval a, IntervalAlgebraic i0 a, IntervalAlgebraic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

Filter by enclosedBy.