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`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

- Public predicates

  - `new/3`

  - `valid/1`

  - `before/2`

  - `after/2`

  - `meets/2`

  - `met_by/2`

  - `overlaps/2`

  - `overlapped_by/2`

  - `starts/2`

  - `started_by/2`

  - `during/2`

  - `contains/2`

  - `finishes/2`

  - `finished_by/2`

  - `equal/2`

- Protected predicates

- Private predicates

- Operators

## Public predicates

### `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 and 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 and 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 and 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 and number of proofs:
`after(@interval,@interval)` - `zero_or_one`

### `meets/2`

True if `Interval1` meets `Interval2`.

Compilation flags:
`static`
Template:
`meets(Interval1,Interval2)`
Mode and 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 and 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 and 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 and 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 and 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 and 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 and number of proofs:
`during(@interval,@interval)` - `zero_or_one`

### `contains/2`

True if `Interval1` contains `Interval2`.

Compilation flags:
`static`
Template:
`contains(Interval1,Interval2)`
Mode and number of proofs:
`contains(@interval,@interval)` - `zero_or_one`

### `finishes/2`

True if `Interval1` finishes `Interval2`.

Compilation flags:
`static`
Template:
`finishes(Interval1,Interval2)`
Mode and 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 and 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 and number of proofs:
`equal(@interval,@interval)` - `zero_or_one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

interval