Package glue :: Module __segments :: Class segment

Class segment

object --+    
         |    
     tuple --+
             |
            segment

The segment class defines objects that represent a range of values. A segment has a start and an end, and is taken to represent the range of values in the semi-open interval [start, end). Some limited arithmetic operations are possible with segments, but because the set of (single) segments is not closed under the sensible definitions of the standard arithmetic operations, the behaviour of the arithmetic operators on segments may not be as you would expect. For general arithmetic on segments, use segmentlist objects. The methods for this class exist mostly for purpose of simplifying the implementation of the segmentlist class.

The segment class is a subclass of the tuple built-in class provided by Python. This means segments are immutable --- you cannot modify a segment object after creating it, to change the boundaries of a segment you must create a new segment object with the desired boundaries. Like tuples, segments can be used as dictionary keys, and like tuples the comparison used to find a segment in the dictionary is done by value not by ID. And, like tuples, a segment can be created from any sequence-like object by passing it to the constructor (the sequence must have exactly two elements in it).

Example:

>>> segment(0, 10) & segment(5, 15)
segment(5, 10)
>>> segment(0, 10) | segment(5, 15)
segment(0, 15)
>>> segment(0, 10) - segment(5, 15)
segment(0, 5)
>>> segment(0, 10) < segment(5, 15)
True
>>> segment(1, 2) in segment(0, 10)
True
>>> segment(1, 11) in segment(0, 10)
False
>>> segment(0, 1)
segment(0, 1)
>>> segment(1, 0)
segment(0, 1)
>>> bool(segment(0, 1))
True
>>> bool(segment(0, 0))
False
>>> segment("AAA Towing", "York University") & segment("Pool", "Zoo")
segment('Pool', 'York University')
>>> x = [0, 1]  # a list
>>> segment(x)
segment(0, 1)
>>> y = segment(0, 1)
>>> y == x
True
>>> y is x
False
>>> z = {x: ["/path/to/file1", "/path/to/file2"]}
>>> y in z
True
>>> z[y]
['/path/to/file1', '/path/to/file2']

Instance Methods

[hide private]

__abs__(x)
abs(x)

__add__(x, y)
x+y

__and__(x, y)
x&y

__contains__(x, y)
y in x

__eq__(x, y)
x==y

__ge__(x, y)
x>=y

__gt__(x, y)
x>y

__hash__(x)
hash(x)

__le__(x, y)
x<=y

__lt__(x, y)
x<y

__ne__(x, y)
x!=y

a new object with type S, a subtype of T

__new__(T, S, ...)

__nonzero__(x)
x != 0

__or__(x, y)
x|y

__radd__(x, y)
y+x

__rand__(x, y)
y&x

__repr__(x)
repr(x)

__ror__(x, y)
y|x

__rsub__(x, y)
y-x

__str__(x)
str(x)

__sub__(x, y)
x-y

contract(...)
Return a new segment whose bounds are given by adding x to the segment's lower bound and subtracting x from the segment's upper bound.

disjoint(...)
Returns >0 if self covers an interval above other's interval, <0 if self covers an interval below other's, or 0 if the two intervals are not disjoint (intersect or touch).

intersects(...)
Return True if the intersection of self and other is not a null segment.

protract(...)
Return a new segment whose bounds are given by subtracting x from the segment's lower bound and adding x to the segment's upper bound.

shift(...)
Return a new segment whose bounds are given by adding x to the segment's upper and lower bounds.

Inherited from tuple: __getattribute__, __getitem__, __getnewargs__, __getslice__, __iter__, __len__, __mul__, __rmul__, __sizeof__, count, index

Inherited from object: __delattr__, __format__, __init__, __reduce__, __reduce_ex__, __setattr__, __subclasshook__

Properties

[hide private]

Inherited from object: __class__

Method Details

[hide private]

add(x, y)
(Addition operator)

x+y

Overrides: tuple.__add__

contains(x, y)
(In operator)

y in x

Overrides: tuple.__contains__

eq(x, y)
(Equality operator)

x==y

Overrides: tuple.__eq__

ge(x, y)
(Greater-than-or-equals operator)

x>=y

Overrides: tuple.__ge__

gt(x, y)
(Greater-than operator)

x>y

Overrides: tuple.__gt__

hash(x)
(Hashing function)

hash(x)

Overrides: object.__hash__

le(x, y)
(Less-than-or-equals operator)

x<=y

Overrides: tuple.__le__

lt(x, y)
(Less-than operator)

x<y

Overrides: tuple.__lt__

ne(x, y)

x!=y

Overrides: tuple.__ne__

new(T, S, ...)

Returns: a new object with type S, a subtype of T
Overrides: object.__new__

repr(x)
(Representation operator)

repr(x)

Overrides: object.__repr__

str(x)
(Informal representation operator)

str(x)

Overrides: object.__str__

disjoint(...)

Returns >0 if self covers an interval above other's interval, <0 if self covers an interval below other's, or 0 if the two intervals are not disjoint (intersect or touch). A return value of 0 indicates the two segments would coalesce.

Class segment

__add__(x, y) (Addition operator)

__contains__(x, y) (In operator)

__eq__(x, y) (Equality operator)

__ge__(x, y) (Greater-than-or-equals operator)

__gt__(x, y) (Greater-than operator)

__hash__(x) (Hashing function)

__le__(x, y) (Less-than-or-equals operator)

__lt__(x, y) (Less-than operator)

__ne__(x, y)

__new__(T, S, ...)

__repr__(x) (Representation operator)

__str__(x) (Informal representation operator)

disjoint(...)

add(x, y)
(Addition operator)

contains(x, y)
(In operator)

eq(x, y)
(Equality operator)

ge(x, y)
(Greater-than-or-equals operator)

gt(x, y)
(Greater-than operator)

hash(x)
(Hashing function)

le(x, y)
(Less-than-or-equals operator)

lt(x, y)
(Less-than operator)

ne(x, y)

new(T, S, ...)

repr(x)
(Representation operator)

str(x)
(Informal representation operator)