protocol

# intervalp

> Basic temporal interval relations protocol (based on James F. Allen Interval Algebra work).

author:
  `Paulo Moura`
version:
  `1.1`
date:
  `2014/4/26`

compilation flags:
  `static`

(no dependencies on other files)

## Public interface

### new/3

> Constructs a new interval given start and end points. The start point must strictly precede the end point.

compilation flags:
  `static`
template:
  `new(Start,End,Interval)`
mode – number of proofs:
  `new(@ground,@ground,-interval) – zero_or_one`

### valid/1

> True if Interval is a valid interval.

compilation flags:
  `static`
template:
  `valid(Interval)`
mode – number of proofs:
  `valid(@interval) – zero_or_one`

### before/2

> True if Interval1 takes place before Interval2.

compilation flags:
  `static`
template:
  `before(Interval1,Interval2)`
mode – number of proofs:
  `before(@interval,@interval) – zero_or_one`

### after/2

> True if Interval1 takes place after Interval2.

compilation flags:
  `static`
template:
  `after(Interval1,Interval2)`
mode – number of proofs:
  `after(@interval,@interval) – zero_or_one`

### meets/2

> True if Interval1 meets Interval2.

compilation flags:
  `static`
template:
  `meets(Interval1,Interval2)`
mode – number of proofs:
  `meets(@interval,@interval) – zero_or_one`

### met_by/2

> True if Interval1 is met by Interval2.

compilation flags:
  `static`
template:
  `met_by(Interval1,Interval2)`
mode – number of proofs:
  `met_by(@interval,@interval) – zero_or_one`

### overlaps/2

> True if Interval1 overlaps with Interval2.

compilation flags:
  `static`
template:
  `overlaps(Interval1,Interval2)`
mode – number of proofs:
  `overlaps(@interval,@interval) – zero_or_one`

### overlapped_by/2

> True if Interval1 is overlapped by Interval2.

compilation flags:
  `static`
template:
  `overlapped_by(Interval1,Interval2)`
mode – number of proofs:
  `overlapped_by(@interval,@interval) – zero_or_one`

### starts/2

> True if Interval1 starts Interval2.

compilation flags:
  `static`
template:
  `starts(Interval1,Interval2)`
mode – number of proofs:
  `starts(@interval,@interval) – zero_or_one`

### started_by/2

> True if Interval1 is started by Interval2.

compilation flags:
  `static`
template:
  `started_by(Interval1,Interval2)`
mode – number of proofs:
  `started_by(@interval,@interval) – zero_or_one`

### during/2

> True if Interval1 occurs during Interval2.

compilation flags:
  `static`
template:
  `during(Interval1,Interval2)`
mode – number of proofs:
  `during(@interval,@interval) – zero_or_one`

### contains/2

> True if Interval1 contains Interval2.

compilation flags:
  `static`
template:
  `contains(Interval1,Interval2)`
mode – number of proofs:
  `contains(@interval,@interval) – zero_or_one`

### finishes/2

> True if Interval1 finishes Interval2.

compilation flags:
  `static`
template:
  `finishes(Interval1,Interval2)`
mode – number of proofs:
  `finishes(@interval,@interval) – zero_or_one`

### finished_by/2

> True if Interval1 is finished by Interval2.

compilation flags:
  `static`
template:
  `finished_by(Interval1,Interval2)`
mode – number of proofs:
  `finished_by(@interval,@interval) – zero_or_one`

### equal/2

> True if Interval1 is equal to Interval2.

compilation flags:
  `static`
template:
  `equal(Interval1,Interval2)`
mode – number of proofs:
  `equal(@interval,@interval) – zero_or_one`

## Protected interface

(none)

## Private predicates

(none)

## Operators

### (none)

## Remarks

### (none)

## See also

### (none)