Interval (Interval v2.0.1)

Interval - A library for working with intervals in Elixir.

It is modelled after Postgres' range types. In cases where behaviour is ambiguous, the "correct" behaviour is whatever Postgres does.

An interval represents the points between two endpoints.

The interval can be empty. The empty interval is never contained in any other interval, and itself contains no points.

It can be left and/or right unbounded, in which case it contains all points in the unbounded direction. A fully unbounded interval contains all other intervals, except the empty interval.

Features

Supports intervals of stdlib types like DateTime. Also comes with support for Decimal out of the box.

Automatically generates an Ecto.Type for use with Postgres' range types (see https://www.postgresql.org/docs/current/rangetypes.html)

You can very easily implement your own types into the interval with the Interval.__using__/1 macro.

Built in intervals:

Interval Notation

Throughout the documentation and comments, you'll see a notation for writing about intervals. As this library is inspired by the functionality in PostgreSQL's range types, we align ourselves with it's notation choice and borrow it (https://www.postgresql.org/docs/current/rangetypes.html)

This notation is also described in ISO 31-11.

[left-inclusive, right-inclusive]
(left-exclusive, right-exclusive)
[left-inclusive, right-exclusive)
(left-exclusive, right-inclusive]
empty

An unbounded interval is written by omitting the bound type and point:

,right-exclusive)
[left-inclusive,

When specifying bound types we sometimes leave the point out and just write the left and right bounds:

[]
()
(]
[)
(
)
[
]

Types of Interval

This library ships with a few different types of intervals. The built-in intervals are:

Interval.DateInterval containing points of type Date
Interval.DateTimeInterval containing points of type DateTime
Interval.NaiveDateTimeInterval containing points of type NaiveDateTime
Interval.FloatIntervalInterval containing points of type Float
Interval.IntegerIntervalInterval containing points of type Integer
Interval.DecimalInterval containing points of type Decimal (See https://hexdocs.pm/decimal/2.0.0)

However, you can quite easily implement an interval by implementing the Interval.Behaviour.

The easiest way to do so, is by using the Interval.__using__ macro:

defmodule MyInterval do
  use Interval, type: MyType, discrete: false
end

You must implement a few functions defined in Interval.Behaviour. Once that's done, all operations available in the Interval module (like interesection, union, overlap etc) will work on your interval struct.

An obvious usecase for this would be to implement an interval that works with the https://hexdocs.pm/decimal library.

Discrete vs Continuous intervals

Depending on the behaviour you want from your interval, it is either said to be discrete or continuous.

A discrete interval represents a set of finite points (like integers). A continuous interval can be said to represent the infinite number of points between two endpoints (like an interval between two floats).

With discrete points, it is possible to define what the next and previous point is, and we normalise these intervals to the bound type [).

The distinction between a discrete and continuous interval is important because the two behave slightly different in some of the library functions.

A discrete interval is adjacent to another discrete interval, if there is no points between the two interval. Contrast this to continuous intervals of real numbers where there is always an infinite number of real numbers between two distinct real numbers, and so continuous intervals are only said to be adjacent to each other if they include the same point, and one point is inclusive where the other is exclusive.

Where relevant, the function documentation will mention the differences between discrete and continuous intervals.

Create an Interval

See new/1

Normalization

When creating an interval through new/1, it will get normalized so that intervals that represents the same points, are also represented in the same way in the struct. This allows you to compare two intervals for equality by using == (and using pattern matching).

It is therefore not recommended to modify an interval struct directly, but instead do so by using one of the functions that modify the interval.

An interval is said to be empty if it spans zero points. The normalized form of an empty interval is the special interval struct where left and right is set to :empty, however a non-normalized empty struct will still correctly report empty via the empty?/1 function.

Summary

Types

bound()

The bound type of an endpoint.

endpoint(t)

An endpoint of an interval.

point()

A point in an interval.

strbounds()

Options are: "[]" | "()" | "(]" | "[)" | "[" | "]" | "(" | ")" | ""

t()

Shorthand for t(any())

t(point)

An interval struct, representing all points between two endpoints.

Functions

__using__(opts)

Define an interval struct of a specific point type.

adjacent?(a, b)

Check if two intervals are adjacent.

adjacent_left_of?(a, b)

Is the interval a adjacent to b, to the left of b.

adjacent_right_of?(a, b)

Is the interval a adjacent to b, to the right of b.

compare_bounds(a_side, a, b_side, b)

Compare the left/right side of a with the left/right side of b

contains?(a, b)

Does a contain b?

contains_point?(a, x)

Does a contain the point x?

difference(a, b)

Computes the difference between a and b by subtracting all points in b from a.

empty?(a)

Is the interval empty?

exclusive_left?(map)

Is the interval left-exclusive?

exclusive_right?(map)

Is the interval right-exclusive?

format(a)

Format the interval as a string

inclusive_left?(map)

Is the interval left-inclusive?

inclusive_right?(map)

Is the interval right-inclusive?

intersection(a, b)

Compute the intersection between a and b.

left(map)

Return the left point.

new(opts)

Create a new interval.

overlaps?(a, b)

Does a overlap with b?

parse(string, module)

Parse a string into an interval.

parse!(string, module)

Parse a string into an interval, raises Interval.IntervalParseError if parsing fails.

partition(a, x)

Partition an interval a into 3 intervals using x

right(map)

Return the right point.

strictly_left_of?(a, b)

Is a strictly left of b.

strictly_right_of?(a, b)

Is a strictly right of b.

unbounded_left?(map)

Check if the interval is left-unbounded.

unbounded_right?(map)

Check if the interval is right-unbounded.

union(a, b)

Computes the union of a and b.

Types

bound()

@type bound() :: :inclusive | :exclusive

The bound type of an endpoint.

endpoint(t)

@type endpoint(t) :: :empty | :unbounded | {bound(), t}

An endpoint of an interval.

Can be either

:empty representing an empty interval (both endpoints will be empty)
:unbounded representing an unbounded endpoint
{bound(), t} representing a bounded endpoint

point()

@type point() :: any()

A point in an interval.

strbounds()

@type strbounds() :: String.t()

Options are: "[]" | "()" | "(]" | "[)" | "[" | "]" | "(" | ")" | ""

t()

@type t() :: t(any())

Shorthand for t(any())

t(point)

@type t(point) :: %{
  __struct__: module(),
  left: endpoint(point),
  right: endpoint(point)
}

An interval struct, representing all points between two endpoints.

The struct has two fields: left and right, representing the left (lower) and right (upper) points in the interval.

If either left or right is set to :empty, the both must be set to :empty.

The specific struct type depends on the interval implementation, but the left and right field is always present, all will be manipulated by the Interval module regardless of the interval implementation.

Functions

using(opts)

(macro)

Define an interval struct of a specific point type.

Support for Ecto.Type and the Postgrex.Range can be automatically generated by specifying ecto_type: <type> when useing.

Options

type - The internal point type in this interval. required
discrete - Is this interval discrete? default: false

Examples

defmodule MyInterval do
  use Interval, type: MyType, discrete: false
end

adjacent?(a, b)

(since 2.0.0)

Check if two intervals are adjacent.

Two intervals are adjacent if they do not overlap, and there are no points between them.

This function is a shorthand for adjacent_left_of(a, b) or adjacent_right_of?(a, b).

adjacent_left_of?(a, b)

@spec adjacent_left_of?(t(), t()) :: boolean()

Is the interval a adjacent to b, to the left of b.

a is adjacent to b left of b, if a and b do not overlap, and there are no points between a.right and b.left.

# a: [---)
# b:     [---)
# r: true

# a: [---]
# b:     [---]
# r: false (overlaps)

# a: (---)
# b:        (---)
# r: false (points exist between a.right and b.left)

Examples

iex> adjacent_left_of?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 2, right: 3))
true

iex> adjacent_left_of?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
false

iex> adjacent_left_of?(new(module: Interval.IntegerInterval, left: 3, right: 4), new(module: Interval.IntegerInterval, left: 1, right: 2))
false

iex> adjacent_left_of?(new(module: Interval.IntegerInterval, right: 2, bounds: "[]"), new(module: Interval.IntegerInterval, left: 3))
true

adjacent_right_of?(a, b)

@spec adjacent_right_of?(t(), t()) :: boolean()

Is the interval a adjacent to b, to the right of b.

a is adjacent to b right of b, if a and b do not overlap, and there are no points between a.left and b.right.

# a:     [---)
# b: [---)
# r: true

# a:     [---)
# b: [---]
# r: false (overlaps)

# a:        (---)
# b: (---)
# r: false (points exist between a.left and b.right)

Examples

iex> adjacent_right_of?(new(module: Interval.IntegerInterval, left: 2, right: 3), new(module: Interval.IntegerInterval, left: 1, right: 2))
true

iex> adjacent_right_of?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
false

iex> adjacent_right_of?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 3, right: 4))
false

iex> adjacent_right_of?(new(module: Interval.IntegerInterval, left: 3), new(module: Interval.IntegerInterval, right: 2, bounds: "]"))
true

compare_bounds(a_side, a, b_side, b)

(since 2.0.0)

@spec compare_bounds(:left | :right, t(), :left | :right, t()) :: :lt | :eq | :gt

Compare the left/right side of a with the left/right side of b

Returns :lt | :gt | :eq depending on as relationship to b.

Other interval operations use this function as primitive.

contains?(a, b)

@spec contains?(t(), t()) :: boolean()

Does a contain b?

a contains b of all points in b is also in a.

For an interval a to contain an interval b, all points in b must be contained in a:

# a: [-------]
# b:   [---]
# r: true

# a: [---]
# b: [---]
# r: true

# a: [---]
# b: (---)
# r: true

# a: (---)
# b: [---]
# r: false

# a:   [---]
# b: [-------]
# r: false

This means that a.left is less than b.left (or unbounded), and a.right is greater than b.right (or unbounded)

If a and b's point match, then b is "in" a if a and b share bound types.

E.g. if a.left and b.left matches, then a contains b if both a and b's left is inclusive or exclusive.

If either of b endpoints are unbounded, then a only contains b if the corresponding endpoint in a is also unbounded.

Examples

iex> contains?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 1, right: 2))
true

iex> contains?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 3))
true

iex> contains?(new(module: Interval.IntegerInterval, left: 2, right: 3), new(module: Interval.IntegerInterval, left: 1, right: 4))
false

iex> contains?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 1, right: 2))
true

iex> contains?(new(module: Interval.IntegerInterval, left: 1, right: 2, bounds: "()"), new(module: Interval.IntegerInterval, left: 1, right: 3))
false

iex> contains?(new(module: Interval.IntegerInterval, right: 1), new(module: Interval.IntegerInterval, left: 0, right: 1))
true

contains_point?(a, x)

(since 0.1.4)

@spec contains_point?(t(), point()) :: boolean()

Does a contain the point x?

Examples

iex> contains_point?(new(module: Interval.IntegerInterval, left: 1, right: 2), 0)
false

iex> contains_point?(new(module: Interval.IntegerInterval, left: 1, right: 2), 1)
true

difference(a, b)

(since 2.0.0)

Computes the difference between a and b by subtracting all points in b from a.

b must not be contained in a in such a way that the difference would not be a single interval.

Examples:

Discrete:

# a: [-----)
# b:     [-----)
# c: [---)
iex> difference(Interval.IntegerInterval.new(1, 4), Interval.IntegerInterval.new(3, 5))
Interval.IntegerInterval.new(1, 3)

# a:     [-----)
# b: [-----)
# c:       [---)
iex> difference(Interval.IntegerInterval.new(3, 5), Interval.IntegerInterval.new(1, 4))
Interval.IntegerInterval.new(4, 5)

Continuous:

# a: [------)
# b:     [-----)
# c: [---)
iex> difference(Interval.FloatInterval.new(1.0, 4.0), Interval.FloatInterval.new(3.0, 5.0))
Interval.FloatInterval.new(1.0, 3.0)

# a: [-----)
# b:     (-----)
# c: [---]
iex> difference(Interval.FloatInterval.new(1.0, 4.0), Interval.FloatInterval.new(3.0, 5.0, "()"))
Interval.FloatInterval.new(1.0, 3.0, "[]")

empty?(a)

@spec empty?(t()) :: boolean()

Is the interval empty?

An empty interval is an interval that represents no points. Any interval containing no points is considered empty.

An unbounded interval is never empty.

For continuous points, the interval is empty when the left and right points are identical, and the point is not included in the interval.

For discrete points, the interval is empty when the left and right point isn't inclusive, and there are no points between the left and right point.

Examples

iex> empty?(new(module: Interval.IntegerInterval, left: 0, right: 0))
true

iex> empty?(new(module: Interval.FloatInterval, left: 1.0))
false

iex> empty?(new(module: Interval.IntegerInterval, left: 1, right: 2))
false

exclusive_left?(map)

@spec exclusive_left?(t()) :: boolean()

Is the interval left-exclusive?

The interval is left-exclusive if the left endpoint value is excluded from the interval.

Note

Discrete intervals (like Interval.IntegerInterval and Interval.DateInterval) are always normalized to be left-inclusive right-exclusive ([)).

iex> exclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[]"))
false

iex> exclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "(]"))
true

iex> exclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "()"))
true

exclusive_right?(map)

@spec exclusive_right?(t()) :: boolean()

Is the interval right-exclusive?

The interval is right-exclusive if the right endpoint value is excluded from the interval.

Note

Discrete intervals (like Interval.IntegerInterval and Interval.DateInterval) are always normalized to be left-inclusive right-exclusive ([)).

iex> exclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[]"))
false

iex> exclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[)"))
true

iex> exclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "()"))
true

format(a)

@spec format(t()) :: String.t()

Format the interval as a string

inclusive_left?(map)

@spec inclusive_left?(t()) :: boolean()

Is the interval left-inclusive?

The interval is left-inclusive if the left endpoint value is included in the interval.

Note

Discrete intervals (like Interval.IntegerInterval and Interval.DateInterval) are always normalized to be left-inclusive right-exclusive ([)).

iex> inclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[]"))
true

iex> inclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[)"))
true

iex> inclusive_left?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "()"))
false

inclusive_right?(map)

@spec inclusive_right?(t()) :: boolean()

Is the interval right-inclusive?

The interval is right-inclusive if the right endpoint value is included in the interval.

Note

Discrete intervals (like Interval.IntegerInterval and Interval.DateInterval) are always normalized to be left-inclusive right-exclusive ([)).

iex> inclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[]"))
true

iex> inclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "[)"))
false

iex> inclusive_right?(new(module: Interval.FloatInterval, left: 1.0, right: 2.0, bounds: "()"))
false

intersection(a, b)

@spec intersection(t(), t()) :: t()

Compute the intersection between a and b.

The intersection contains all of the points that are both in a and b.

If either a or b are empty, the returned interval will be empty.

# a: [----]
# b:    [----]
# r:    [-]

# a: (----)
# b:    (----)
# r:    (-)

# a: [----)
# b:    [----)
# r:    [-)

Examples:

Discrete:

# a: [----)
# b:    [----)
# c:    [-)
iex> intersection(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
new(module: Interval.IntegerInterval, left: 2, right: 3)

Continuous:

# a: [----)
# b:    [----)
# c:    [-)
iex> intersection(new(module: Interval.FloatInterval, left: 1.0, right: 3.0), new(module: Interval.FloatInterval, left: 2.0, right: 4.0))
new(module: Interval.FloatInterval, left: 2.0, right: 3.0)

# a: (----)
# b:    (----)
# c:    (-)
iex> intersection(
...>   new(module: Interval.FloatInterval, left: 1.0, right: 3.0, bounds: "()"),
...>   new(module: Interval.FloatInterval, left: 2.0, right: 4.0, bounds: "()")
...> )
new(module: Interval.FloatInterval, left: 2.0, right: 3.0, bounds: "()")

# a: [-----)
# b:   [-------
# c:   [---)
iex> intersection(new(module: Interval.FloatInterval, left: 1.0, right: 3.0), new(module: Interval.FloatInterval, left: 2.0))
new(module: Interval.FloatInterval, left: 2.0, right: 3.0)

left(map)

@spec left(t()) :: point()

Return the left point.

This function always returns nil when no point exist. Use the functions empty?/1, inclusive_left?/1 and unbounded_left?/1 to check for the meaning of the point.

Example

iex> left(new(module: Interval.IntegerInterval, left: 1, right: 2))
1

new(opts)

@spec new(Keyword.t()) :: t()

Create a new interval.

Options

left The left (or lower) endpoint value of the interval (default: :unbounded)
right The right (or upper) endpoint value of the interval (default: :unbounded)
bounds The bound mode to use (default: "[)")
empty If set to true, the interval will be empty (default: false)
module The interval implementation to use. When calling new/1 from an Interval.Behaviour this is inferred.

Specifying left or right as nil will be interpreted as :unbounded. The endpoint will also be considered unbounded if the bounds explicitly sets it as unbounded.

Specifying left or right as :empty will create an empty interval.

Bounds

The bounds options contains the left and right bound mode to use. The bound can be inclusive, exclusive or unbounded.

The following valid bound values are supported:

"[)" left-inclusive, right-exclusive (default)
"(]" left-exclusive, right-inclusive
"[]" left-inclusive, right-inclusive
"()" left-exclusive, right-exclusive
")" left-unbounded, right-exclusive
"]" left-unbounded, right-inclusive
"(" left-exclusive, right-unbounded
"[" left-inclusive, right-unbounded

Examples

iex> new(module: Interval.IntegerInterval)

iex> new(module: Interval.IntegerInterval, empty: true)

iex> new(module: Interval.IntegerInterval, left: 1)

iex> new(module: Interval.IntegerInterval, left: 1, right: 1, bounds: "[]")

iex> new(module: Interval.IntegerInterval, left: 10, right: 20, bounds: "()")

overlaps?(a, b)

@spec overlaps?(t(), t()) :: boolean()

Does a overlap with b?

a overlaps with b if any point in a is also in b.

# a: [---)
# b:   [---)
# r: true

# a: [---)
# b:     [---)
# r: false

# a: [---]
# b:     [---]
# r: true

# a: (---)
# b:     (---)
# r: false

# a: [---)
# b:        [---)
# r: false

Examples

# [--a--)
#     [--b--)

iex> overlaps?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
true


# [--a--)
#       [--b--)

iex> overlaps?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 3, right: 5))
false


# [--a--]
#       [--b--]

iex> overlaps?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
true


# (--a--)
#       (--b--)

iex> overlaps?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 3, right: 5))
false


# [--a--)
#          [--b--)

iex> overlaps?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 3, right: 4))
false

parse(string, module)

@spec parse(String.t(), module()) :: {:ok, t()} | {:error, reason :: any()}

Parse a string into an interval.

parse!(string, module)

@spec parse!(String.t(), module()) :: t()

Parse a string into an interval, raises Interval.IntervalParseError if parsing fails.

partition(a, x)

(since 0.1.4)

@spec partition(t(), point() | t()) :: [t()] | []

Partition an interval a into 3 intervals using x:

The interval with all points from a where a < x
The interval with x
The interval with all points from a where a > x

If x is not in a this function returns an empty list.

Note: Since 2.0.0, x can be a point or an interval. When x is a point, the middle interval will be an interval such that [x,x].

If there are no points in a to the left of x, an empty interval is returned for the left side. The same of course applies to the right side of x.

Examples

iex> partition(Interval.IntegerInterval.new(1, 5, "[]"), 3)
[
  Interval.IntegerInterval.new(1, 3, "[)"),
  Interval.IntegerInterval.new(3, 3, "[]"),
  Interval.IntegerInterval.new(3, 5, "(]")
]

iex> partition(Interval.IntegerInterval.new(1, 5), -10)
[]

iex> partition(Interval.IntegerInterval.new(1, 6), Interval.IntegerInterval.new(3, 4))
[
  Interval.IntegerInterval.new(1, 3, "[)"),
  Interval.IntegerInterval.new(3, 4, "[)"),
  Interval.IntegerInterval.new(4, 6, "[)")
]

iex> partition(Interval.FloatInterval.new(1.0, 6.0), Interval.FloatInterval.new(1.0, 3.0, "[]"))
[
  Interval.FloatInterval.new(1.0, 1.0, "[)"),
  Interval.FloatInterval.new(1.0, 3.0, "[]"),
  Interval.FloatInterval.new(3.0, 6.0, "()")
]

right(map)

@spec right(t()) :: point()

Return the right point.

This function always returns nil when no point exist. Use the functions empty?/1, inclusive_right?/1 and unbounded_right?/1 to check for the meaning of the point.

Example

iex> right(new(module: Interval.IntegerInterval, left: 1, right: 2))
2

strictly_left_of?(a, b)

@spec strictly_left_of?(t(), t()) :: boolean()

Is a strictly left of b.

a is strictly left of b if no point in a is in b, and all points in a is left (<) of all points in b.

Examples

# a: [---)
# b:     [---)
# r: true

# a: [---)
# b:        [---)
# r: true

# a: [---)
# b:    [---)
# r: false (overlaps)

iex> strictly_left_of?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 3, right: 4))
true

iex> strictly_left_of?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
false

iex> strictly_left_of?(new(module: Interval.IntegerInterval, left: 3, right: 4), new(module: Interval.IntegerInterval, left: 1, right: 2))
false

strictly_right_of?(a, b)

@spec strictly_right_of?(t(), t()) :: boolean()

Is a strictly right of b.

a is strictly right of b if no point in a is in b, and all points in a is right (>) of all points in b.

Examples

# a:     [---)
# b: [---)
# r: true

# a:        [---)
# b: [---)
# r: true

# a:    [---)
# b: [---)
# r: false (overlaps)

iex> strictly_right_of?(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 3, right: 4))
false

iex> strictly_right_of?(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
false

iex> strictly_right_of?(new(module: Interval.IntegerInterval, left: 3, right: 4), new(module: Interval.IntegerInterval, left: 1, right: 2))
true

unbounded_left?(map)

@spec unbounded_left?(t()) :: boolean()

Check if the interval is left-unbounded.

The interval is left-unbounded if all points left of the right bound is included in this interval.

Examples

iex> unbounded_left?(new(module: Interval.IntegerInterval))
true

iex> unbounded_left?(new(module: Interval.IntegerInterval, right: 2))
true

iex> unbounded_left?(new(module: Interval.IntegerInterval, left: 1, right: 2))
false

unbounded_right?(map)

@spec unbounded_right?(t()) :: boolean()

Check if the interval is right-unbounded.

The interval is right-unbounded if all points right of the left bound is included in this interval.

Examples

iex> unbounded_right?(new(module: Interval.IntegerInterval, right: 1))
false

iex> unbounded_right?(new(module: Interval.IntegerInterval))
true

iex> unbounded_right?(new(module: Interval.IntegerInterval, left: 1))
true

union(a, b)

@spec union(t(), t()) :: t()

Computes the union of a and b.

The union contains all of the points that are either in a or b.

If either a or b are empty, the returned interval will be the non-empty interval.

# a: [---)
# b:   [---)
# r: [-----)

Examples

# [--A--)
#     [--B--)
# [----C----)

iex> union(new(module: Interval.IntegerInterval, left: 1, right: 3), new(module: Interval.IntegerInterval, left: 2, right: 4))
new(module: Interval.IntegerInterval, left: 1, right: 4)


# [-A-)
#     [-B-)
# [---C---)

iex> union(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 2, right: 3))
new(module: Interval.IntegerInterval, left: 1, right: 3)

iex> union(new(module: Interval.IntegerInterval, left: 1, right: 2), new(module: Interval.IntegerInterval, left: 3, right: 4))
** (Interval.IntervalOperationError) cannot union non-overlapping non-adjacent intervals as the result would be non-contiguous