Basically, all operations apply on discrete intervals exactly the way they apply on continuous intervals. The only "issue" is to simplify (i.e. to "union") the resulting atomic intervals into a proper discrete interval.

As you said, using iterate only works if we know in advance what are the bounds (and moreover, it is not very efficient computation-wise). For atomic intervals, it is quite "easy" to convert them to discrete intervals. For non-atomic ones, we need a bit more involved approach.

The "trick" relies on a 2-steps process:

A first pass to "extend" the intervals (i.e. to convert them to open intervals);
A second pass to "reduce" them (i.e. to convert them to closed intervals).

The first one is needed to, e.g., join [0,1] | [2,3] properly (basically, the idea is to convert them to (-1, 2) | (1, 4) = (-1, 4)). The second one is required to convert (-1, 4) back to [0, 3] (and, also implicitly to keep singletons as singletons).

We'll use the .apply function of an interval to do these steps. Let's define one function per step:

>>> first_step = lambda s: (P.OPEN, (s.lower - 1 if s.left is P.CLOSED else s.lower), (s.upper + 1 if s.right is P.CLOSED else s.upper), P.OPEN)
>>> second_step = lambda s: (P.CLOSED, (s.lower + 1 if s.left is P.OPEN else s.lower), (s.upper - 1 if s.right is P.OPEN else s.upper), P.CLOSED)

TL;DR: first_step extends closed intervals, while second_step reduces open ones.

Then, we can feed these functions to .apply. Let's create a function that does the job:

>>> discretize = lambda i: i.apply(first_step).apply(second_step)

We can now check if it works:

>>> discretize(P.closed(0, 1) | P.closed(2, 3))                                                   
[0,3]
>>> discretize(P.closed(0, 1) | P.closed(3, 4))                                                   
[0,1] | [3,4]
>>> discretize(P.singleton(1) | P.singleton(2) | P.singleton(10))                                 
[1,2] | [10]
>>> discretize(P.openclosed(2, 4))                                                                
[3,4]

Infinities are not handled in our implementation:

>>> discretize(P.empty())
TypeError: unsupported operand type(s) for +: '_PInf' and 'int'

To support them, change the second_step implementation (replace if s.left is P.OPEN by if s.left is P.OPEN and s.lower != -P.inf and its equivalent for the other bound).

All in one, with support for infinities:

def discretize(i, incr=1):
    first_step = lambda s: (P.OPEN, (s.lower - incr if s.left is P.CLOSED else s.lower), (s.upper + incr if s.right is P.CLOSED else s.upper), P.OPEN)
    second_step = lambda s: (P.CLOSED, (s.lower + incr if s.left is P.OPEN and s.lower != -P.inf else s.lower), (s.upper - incr if s.right is P.OPEN and s.upper != P.inf else s.upper), P.CLOSED)
    return i.apply(first_step).apply(second_step)

Uh oh!

How to simulate discrete intervals? #24

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions