Note: This type does not define interval arithmetic.

The `ClosedIntervals`

module defines a data type `ClosedInterval`

that
represents a set of the form `[a,b] = {x: a <= x <= b}`

. Typically, a
`ClosedInterval`

is created by specifying its end points:

```
julia> using ClosedIntervals
julia> ClosedInterval(3,7)
[3,7]
julia> ClosedInterval(8,2)
[2,8]
julia> a = (6,0)
(6,0)
julia> 5 .. 2 # dot-dot notation works to create a ClosedInterval
[2,5]
julia> 5 ± 2 # a ± b creates the interval from a-b to a+b
[3,7]
julia> ClosedInterval(a)
[0,6]
julia> ClosedInterval(1, 2.3) # type promotion of end point
[1.0,2.3]
```

This example illustrates a few points.

- First, interval is printed in standard mathematical notation using square brackets.
- Second, the end points can be specified in either order.
- Third, the interval can be constructed from a tuple.
- Finally, the type of the two end points need not be the same. Julia's promotion mechanism selects an appropriate common type for the two end points.

The two end points of the interval may be the same, in which case it is enough to name only one of the end points:

```
julia> ClosedInterval(5)
[5,5]
```

If no arguments are provided to `ClosedInterval`

the result is the
unit interval [0,1] with `Float64`

end points. Or, if we supply a
type `T`

, then the result is again [0,1], but with type `T`

end
points.

```
julia> ClosedInterval()
[0.0,1.0]
julia> ClosedInterval(Int)
[0,1]
julia> typeof(ans)
ClosedInterval{Int64} (constructor with 1 method)
```

We also provide an empty interval constructed with `EmptyInterval`

,
like this:

```
julia> X = EmptyInterval()
[]
julia> typeof(X)
ClosedInterval{Float64} (constructor with 1 method)
julia> Y = EmptyInterval(Int)
[]
julia> typeof(Y)
ClosedInterval{Int64} (constructor with 1 method)
```

Notice that empty intervals are printed as a pair of square brackets with nothing between.

The functions `left`

and `right`

are used to retrieve the left and
right end points of an interval. Use `length`

to get the length of the
interval (difference of the end points).

```
julia> A = ClosedInterval(6,2)
[2,6]
julia> left(A)
2
julia> right(A)
6
julia> length(A)
4
```

Empty intervals have `length`

equal to zero.
The `left`

and `right`

functions applied to empty
intervals throw an error.
Use `isempty`

to test if an interval is empty.

```
julia> isempty(A)
false
julia> isempty(X)
true
```

To test if a given value lies inside an interval, use `in`

:

```
julia> A = ClosedInterval(3,10)
[3,10]
julia> in(5,A)
true
julia> in(1,A)
false
julia> X = EmptyInterval(Int)
[]
julia> in(0,A)
false
```

Notice that testing for membership in an empty interval
always return `false`

.

Two operations are defined for intervals.

- The intersection
`*`

is the largest interval contained in both. If the intervals are disjoint, this returns an empty interval. Also available as`∧`

. - The sum
`+`

is the smallest interval containing both (i.e., the join of the intervals). If the intervals overlap, then this is the same as their union. Note that the empty interval serves as an identity element for this operation. Also available as`∨`

.

```
julia> A = ClosedInterval(1,5)
[1,5]
julia> B = ClosedInterval(3,7)
[3,7]
julia> A*B
[3,5]
julia> A+B
[1,7]
julia> C = ClosedInterval(1,3)
[1,3]
julia> D = ClosedInterval(5,6)
[5,6]
julia> C*D
[]
julia> C+D
[1,6]
```

When intervals have end points that are floating points numbers, it is possible to work with infinite intervals. Everything works as one might expect.

```
julia> A = ClosedInterval(0., Inf)
[0.0,Inf]
julia> B = ClosedInterval(1., -Inf)
[-Inf,1.0]
julia> A*B
[0.0,1.0]
julia> A+B
[-Inf,Inf]
julia> length(A)
Inf
julia> in(2.,A)
true
julia> in(2.,B)
false
```

The usual comparison operators may be applied to pairs of
intervals. As usual, equality may be checked with `==`

(or
`isequal`

).

Use `issubset(J,K)`

to test if `J`

is contained in `K`

. The following
comparison operations work as expected:

`J ⊆ K`

-- subset, same as`issubset(J,K)`

`J ⊊ K`

-- proper subset`J ⊇ K`

-- superset`J ⊋ K`

-- proper superset

We also define `isless`

for intervals as follows. An empty interval is
defined to be less than all nonempty intervals. Otherwise, we sort
intervals lexicographically. That is, interval `[a,b]`

is less than
`[c,d]`

provided either (a) `a<c`

or (b) `(a==c) && (b<d)`

.

Intervals of mixed type may be compared. For example:

```
julia> A = ClosedInterval(1,2)
[1,2]
julia> B = ClosedInterval(1.,2.)
[1.0,2.0]
julia> A==B
true
julia> A = ClosedInterval(-Inf,3.)
[-Inf,3.0]
julia> B = ClosedInterval(3,5)
[3,5]
julia> A < B
true
```

We use `<<`

to test if one interval is completely to the left of another.
That is `[a,b]<<[c,d]`

exactly when `b<c`

. In this case, comparing an
empty interval to any other yields `false`

. Likewise, we use `>>`

to test if one interval is to the right of another.

```
julia> A = ClosedInterval(1,5);
julia> B = ClosedInterval(3,8);
julia> C = ClosedInterval(7,9);
julia> A<<B
false
julia> A<<C
true
julia> B<<C
false
julia> C>>A
true
```

Normally, the end points of a `ClosedInterval`

are real numbers
(subtypes of `Real`

).
However, we do permit the end point types to be any Julia objects
that can be compared with `<`

. For example:

```
julia> J = ClosedInterval("charlie", "bravo")
[bravo,charlie]
julia> K = ClosedInterval("oscar", "yankee")
[oscar,yankee]
julia> J+K
[bravo,yankee]
julia> in("romeo", K)
true
```

However, some operations will fail if they rely on numeric operations. For example:

```
julia> length(J)
ERROR: MethodError: `-` has no method matching -(::String, ::String)
julia> J*K
ERROR: MethodError: no method matching zero(::Type{String})
```

The IntervalSets module also defines a `ClosedInterval`

type that
has some notable differences in how intervals are handled.

In `ClosedIntervals`

, the end points may be specified in either order,
while in `IntervalSets`

if the left end point is
greater than the right, an empty interval results.

```
julia> using ClosedIntervals
julia> ClosedInterval(1,2) == ClosedInterval(2,1)
true
```

```
julia> using IntervalSets
julia> ClosedInterval(1,2) == ClosedInterval(2,1)
false
```

In the `ClosedIntervals`

module, the join `J ∨ K`

or `J + K`

of two intervals is
the smallest interval containing both. In particular, we permit the join of
disjoint intervals. The intervals may be disjoint.

```
julia> ClosedInterval(1,2) ∨ ClosedInterval(3,4)
[1,4]
```

The `IntervalSets`

module provides for the union of intervals.
If the two intervals are disjoint, their set-theoretic union is not an
interval and results in an error.

```
julia> ClosedInterval(1,2) ∪ ClosedInterval(3,4)
ERROR: ArgumentError: Cannot construct union of disjoint sets.
```

Note that the intersection (`IntervalSets`

) and meet (`ClosedIntervals`

) of
two intervals are the same.

The two modules have different implementations of the `length`

function.

- In the
`ClosedIntervals`

module,`length`

is simply the difference between the right and left end point values. - In
`IntervalSets`

, one can only apply`length`

to intervals with integer end points, in which case the`length`

is the number of integers in the set. Instead, use`width`

to determine the distance between the end points.

```
julia> using ClosedIntervals
julia> length(ClosedInterval(1,4))
3
julia> length(ClosedInterval(1.0,4.0))
3.0
```

```
julia> using IntervalSets
julia> length(ClosedInterval(1,4))
4
julia> length(ClosedInterval(1.0,4.0))
ERROR: MethodError: no method matching length(::ClosedInterval{Float64})
julia> width(ClosedInterval(1.0,4.0))
3.0
```