timespan

Timespan classes and functions.

digraph InheritanceGraph { graph [bgcolor=transparent, color=lightsteelblue2, fontname=Arial, fontsize=10, outputorder=edgesfirst, overlap=prism, penwidth=2, rankdir=LR, splines=spline, style="dashed, rounded", truecolor=true ]; node [colorscheme=pastel19, fontname=Arial, fontsize=10, height=0, penwidth=2, shape=box, style="filled, rounded", width=0 ]; edge [color=lightslategrey, penwidth=1 ]; subgraph "cluster_abjad.timespan" { graph [label="abjad.timespan"]; node [color=1]; "abjad.timespan.Timespan" [color=1, label=Timespan]; } subgraph cluster_builtins { graph [label=builtins]; node [color=2]; "builtins.object" [URL="https://docs.python.org/3.7/library/functions.html#object", color=2, label=object, target=_top]; } subgraph "cluster_evans.timespan" { graph [label="evans.timespan"]; node [color=3]; "evans.timespan.SilentTimespan" [URL="../api/evans/timespan.html#evans.timespan.SilentTimespan", color=black, fontcolor=white, label="Silent\nTimespan", target=_top]; "evans.timespan.TimespanMaker" [URL="../api/evans/timespan.html#evans.timespan.TimespanMaker", color=black, fontcolor=white, label="Timespan\nMaker", target=_top]; "evans.timespan.TimespanSpecifier" [URL="../api/evans/timespan.html#evans.timespan.TimespanSpecifier", color=black, fontcolor=white, label="Timespan\nSpecifier", target=_top]; } "abjad.timespan.Timespan" -> "evans.timespan.SilentTimespan" [minlen=1]; "builtins.object" -> "abjad.timespan.Timespan" [minlen=1]; "builtins.object" -> "evans.timespan.TimespanMaker" [minlen=2]; "builtins.object" -> "evans.timespan.TimespanSpecifier" [minlen=1]; }

Classes

TimespanMaker

TimespanSpecifier

class evans.timespan.TimespanMaker(denominator, total_duration)[source]
>>> timespan_maker = evans.TimespanMaker(
...     denominator=8,
...     total_duration=abjad.Duration(15, 2),
... )
>>> counts = [3, 5, -3, 4, 7, -1]
>>> timespan_list = timespan_maker(counts, max_duration=6, voice_name="A")
>>> abjad.show(timespan_list, scale=0.5)  

>>> timespan_maker = evans.TimespanMaker(
...     denominator=8,
...     total_duration=abjad.Duration(15, 2),
... )
>>> counts = [3, 1, -2, 2, 3, -1, 2, -2]
>>> timespan_list_1 = timespan_maker(counts, max_duration=6, voice_name="A")
>>> timespan_list_2 = timespan_maker(
...     counts, max_duration=6, voice_name="B", rotation=2, translation=1
... )
>>> timespan_list_3 = timespan_maker(
...     counts, max_duration=6, voice_name="C", rotation=5, translation=3
... )
>>> timespan_list_4 = timespan_maker(
...     counts, max_duration=6, voice_name="D", rotation=3, translation=2
... )
>>> timespanlist = abjad.TimespanList()
>>> for span in timespan_list_1:
...     timespanlist.append(span)
... 
>>> for span in timespan_list_2:
...     timespanlist.append(span)
... 
>>> for span in timespan_list_3:
...     timespanlist.append(span)
... 
>>> for span in timespan_list_4:
...     timespanlist.append(span)
... 
>>> abjad.show(timespanlist, scale=0.5, key="annotation")

Attributes Summary

__call__

Call self as a function.

__repr__

Return repr(self).

__str__

Return str(self).

denominator

total_duration

Special methods

overridden __call__(counts, max_duration=None, translation=0, rotation=None, voice_name=None)[source]

Call self as a function.

overridden __repr__()[source]

Return repr(self).

overridden __str__()[source]

Return str(self).

Read-only properties

denominator
total_duration
class evans.timespan.TimespanSpecifier(voice_name=None, handler=None)[source]

Attributes Summary

__repr__

Return repr(self).

__str__

Return str(self).

Special methods

overridden __repr__()[source]

Return repr(self).

overridden __str__()[source]

Return str(self).

Functions

add_silences_to_timespan_dict

add_silences_to_timespan_lists

add_silent_timespans

collect_offsets

human_sorted_keys

intercalate_silences

make_showable_list

make_split_list

sorted_keys

talea_timespans

to_digit

evans.timespan.add_silences_to_timespan_dict(timespan_dict, specifier=None)[source]
evans.timespan.add_silences_to_timespan_lists(timespan_lists)[source]
evans.timespan.add_silent_timespans(timespan_list, specifier=None)[source]
evans.timespan.collect_offsets(timespan_list)[source]
evans.timespan.human_sorted_keys(pair)[source]
evans.timespan.intercalate_silences(rhythm_command_list, voice_names=None)[source]
evans.timespan.make_showable_list(timespan_lists)[source]
evans.timespan.make_split_list(timespan_list, offsets)[source]
evans.timespan.sorted_keys(text)[source]
>>> evans.sorted_keys("Voice 1")
['Voice ', 1, '']
evans.timespan.talea_timespans(talea, advancement=0)[source]
evans.timespan.to_digit(string)[source]
>>> evans.to_digit("2")
2

Timespans

SilentTimespan

Silent Timespan
class evans.timespan.SilentTimespan(start_offset, stop_offset, annotation=None)[source]

Silent Timespan

>>> span = evans.SilentTimespan(0, 1)
>>> abjad.show(span)

Attributes Summary

__repr__

Gets interpreter representation.

__str__

Return str(self).

Special methods

(Timespan).__and__(argument)

Logical AND of two timespans.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)
>>> timespan_4 = abjad.Timespan(10, 20)

>>> timespan_1 & timespan_2
TimespanList([Timespan(Offset((5, 1)), Offset((10, 1)))])

>>> timespan_1 & timespan_3
TimespanList([Timespan(Offset((0, 1)), Offset((2, 1)))])

>>> timespan_1 & timespan_4
TimespanList([])

>>> timespan_2 & timespan_3
TimespanList([])

>>> timespan_2 & timespan_4
TimespanList([Timespan(Offset((10, 1)), Offset((12, 1)))])

>>> timespan_3 & timespan_4
TimespanList([])
Return type

TimespanList

(Timespan).__contains__(argument)

Is true when timespan contains argument.

Works with offsets:

>>> timespan = abjad.Timespan(0, (1, 4))

>>> -1 in timespan
False

>>> 0 in timespan
True

>>> abjad.Offset(1, 8) in timespan
True

>>> abjad.Offset(1, 4) in timespan
True

>>> abjad.Offset(1, 2) in timespan
False

Works with other timespans:

>>> timespan = abjad.Timespan(0, (1, 4))

>>> abjad.Timespan(0, (1, 4)) in timespan
True

>>> abjad.Timespan((1, 16), (2, 16)) in timespan
True

>>> abjad.Timespan(0, (1, 2)) in timespan
False
Return type

bool

(Timespan).__eq__(argument)

Is true when argument is a timespan with equal offsets.

>>> abjad.Timespan(1, 3) == abjad.Timespan(1, 3)
True

>>> abjad.Timespan(1, 3) == abjad.Timespan(2, 3)
False
Return type

bool

(Timespan).__ge__(argument)

Is true when argument start offset is greater or equal to timespan start offset.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)

>>> timespan_2 >= timespan_3
True

>>> timespan_1 >= timespan_2
False
Return type

bool

(Timespan).__gt__(argument)

Is true when argument start offset is greater than timespan start offset.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)

>>> timespan_2 > timespan_3
True

>>> timespan_1 > timespan_2
False
Return type

bool

(Timespan).__hash__()

Hashes timespan.

Required to be explicitly redefined on Python 3 if __eq__ changes.

Return type

int

(Timespan).__le__(argument)

Is true when argument start offset is less than or equal to timespan start offset.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)

>>> timespan_2 <= timespan_3
False

>>> timespan_1 <= timespan_2
True
Return type

bool

(Timespan).__len__()

Defined equal to 1 for all timespans.

>>> timespan = abjad.Timespan(0, 10)

>>> len(timespan)
1
Return type

int

(Timespan).__lt__(argument)

Is true when argument start offset is less than timespan start offset.

Return type

bool

(Timespan).__or__(argument)

Logical OR of two timespans.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)
>>> timespan_4 = abjad.Timespan(10, 20)

>>> new_timespan = timespan_1 | timespan_2
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((12, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_1 | timespan_3
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_1 | timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_2 | timespan_3
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((2, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((5, 1)),
            stop_offset=abjad.Offset((12, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_2 | timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((5, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_3 | timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((2, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((10, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )
Return type

TimespanList

overridden __repr__()[source]

Gets interpreter representation.

overridden __str__()[source]

Return str(self).

(Timespan).__sub__(argument)

Subtract argument from timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)
>>> timespan_4 = abjad.Timespan(10, 20)

>>> timespan_1 - timespan_1
TimespanList([])

>>> timespan_1 - timespan_2
TimespanList([Timespan(Offset((0, 1)), Offset((5, 1)))])

>>> timespan_1 - timespan_3
TimespanList([Timespan(Offset((2, 1)), Offset((10, 1)))])

>>> timespan_1 - timespan_4
TimespanList([Timespan(Offset((0, 1)), Offset((10, 1)))])

>>> timespan_2 - timespan_1
TimespanList([Timespan(Offset((10, 1)), Offset((12, 1)))])

>>> timespan_2 - timespan_2
TimespanList([])

>>> timespan_2 - timespan_3
TimespanList([Timespan(Offset((5, 1)), Offset((12, 1)))])

>>> timespan_2 - timespan_4
TimespanList([Timespan(Offset((5, 1)), Offset((10, 1)))])

>>> timespan_3 - timespan_3
TimespanList([])

>>> timespan_3 - timespan_1
TimespanList([Timespan(Offset((-2, 1)), Offset((0, 1)))])

>>> timespan_3 - timespan_2
TimespanList([Timespan(Offset((-2, 1)), Offset((2, 1)))])

>>> timespan_3 - timespan_4
TimespanList([Timespan(Offset((-2, 1)), Offset((2, 1)))])

>>> timespan_4 - timespan_4
TimespanList([])

>>> timespan_4 - timespan_1
TimespanList([Timespan(Offset((10, 1)), Offset((20, 1)))])

>>> timespan_4 - timespan_2
TimespanList([Timespan(Offset((12, 1)), Offset((20, 1)))])

>>> timespan_4 - timespan_3
TimespanList([Timespan(Offset((10, 1)), Offset((20, 1)))])

Returns timespan list.

Return type

TimespanList

(Timespan).__xor__(argument)

Logical XOR of two timespans.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 12)
>>> timespan_3 = abjad.Timespan(-2, 2)
>>> timespan_4 = abjad.Timespan(10, 20)

>>> new_timespan = timespan_1 ^ timespan_2
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((5, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((10, 1)),
            stop_offset=abjad.Offset((12, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_1 ^ timespan_3
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((0, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((2, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_1 ^ timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((10, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_2 ^ timespan_3
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((2, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((5, 1)),
            stop_offset=abjad.Offset((12, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_2 ^ timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((5, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((12, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )

>>> new_timespan = timespan_3 ^ timespan_4
>>> string = abjad.storage(new_timespan)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((-2, 1)),
            stop_offset=abjad.Offset((2, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((10, 1)),
            stop_offset=abjad.Offset((20, 1)),
            ),
        ]
    )
Return type

TimespanList

Methods

(Timespan).contains_timespan_improperly(timespan)

Is true when timespan contains timespan improperly.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 10)

>>> timespan_1.contains_timespan_improperly(timespan_1)
True

>>> timespan_1.contains_timespan_improperly(timespan_2)
True

>>> timespan_2.contains_timespan_improperly(timespan_1)
False

>>> timespan_2.contains_timespan_improperly(timespan_2)
True
Return type

bool

(Timespan).curtails_timespan(timespan)

Is true when timespan curtails timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 10)

>>> timespan_1.curtails_timespan(timespan_1)
False

>>> timespan_1.curtails_timespan(timespan_2)
False

>>> timespan_2.curtails_timespan(timespan_1)
True

>>> timespan_2.curtails_timespan(timespan_2)
False
Return type

bool

(Timespan).delays_timespan(timespan)

Is true when timespan delays timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)
>>> timespan_3 = abjad.Timespan(10, 20)

>>> timespan_1.delays_timespan(timespan_2)
True

>>> timespan_2.delays_timespan(timespan_3)
True
Return type

bool

(Timespan).divide_by_ratio(ratio)

Divides timespan by ratio.

>>> timespan = abjad.Timespan((1, 2), (3, 2))

>>> for x in timespan.divide_by_ratio((1, 2, 1)):
...     x
... 
Timespan(Offset((1, 2)), Offset((3, 4)))
Timespan(Offset((3, 4)), Offset((5, 4)))
Timespan(Offset((5, 4)), Offset((3, 2)))
Return type

Tuple[Timespan, …]

(Timespan).get_overlap_with_timespan(timespan)

Gets duration of overlap with timespan.

>>> timespan_1 = abjad.Timespan(0, 15)
>>> timespan_2 = abjad.Timespan(5, 10)
>>> timespan_3 = abjad.Timespan(6, 6)
>>> timespan_4 = abjad.Timespan(12, 22)

>>> timespan_1.get_overlap_with_timespan(timespan_1)
Duration(15, 1)

>>> timespan_1.get_overlap_with_timespan(timespan_2)
Duration(5, 1)

>>> timespan_1.get_overlap_with_timespan(timespan_3)
Duration(0, 1)

>>> timespan_1.get_overlap_with_timespan(timespan_4)
Duration(3, 1)

>>> timespan_2.get_overlap_with_timespan(timespan_2)
Duration(5, 1)

>>> timespan_2.get_overlap_with_timespan(timespan_3)
Duration(0, 1)

>>> timespan_2.get_overlap_with_timespan(timespan_4)
Duration(0, 1)

>>> timespan_3.get_overlap_with_timespan(timespan_3)
Duration(0, 1)

>>> timespan_3.get_overlap_with_timespan(timespan_4)
Duration(0, 1)

>>> timespan_4.get_overlap_with_timespan(timespan_4)
Duration(10, 1)
Return type

Optional[Duration]

(Timespan).happens_during_timespan(timespan)

Is true when timespan happens during timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 10)

>>> timespan_1.happens_during_timespan(timespan_1)
True

>>> timespan_1.happens_during_timespan(timespan_2)
False

>>> timespan_2.happens_during_timespan(timespan_1)
True

>>> timespan_2.happens_during_timespan(timespan_2)
True
Return type

bool

(Timespan).intersects_timespan(timespan)

Is true when timespan intersects timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)
>>> timespan_3 = abjad.Timespan(10, 15)

>>> timespan_1.intersects_timespan(timespan_1)
True

>>> timespan_1.intersects_timespan(timespan_2)
True

>>> timespan_1.intersects_timespan(timespan_3)
False
Return type

bool

(Timespan).is_congruent_to_timespan(timespan)

Is true when timespan is congruent to timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.is_congruent_to_timespan(timespan_1)
True

>>> timespan_1.is_congruent_to_timespan(timespan_2)
False

>>> timespan_2.is_congruent_to_timespan(timespan_1)
False

>>> timespan_2.is_congruent_to_timespan(timespan_2)
True
Return type

bool

(Timespan).is_tangent_to_timespan(timespan)

Is true when timespan is tangent to timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.is_tangent_to_timespan(timespan_1)
False

>>> timespan_1.is_tangent_to_timespan(timespan_2)
True

>>> timespan_2.is_tangent_to_timespan(timespan_1)
True

>>> timespan_2.is_tangent_to_timespan(timespan_2)
False
Return type

bool

(Timespan).overlaps_all_of_timespan(timespan)

Is true when timespan overlaps all of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 6)
>>> timespan_3 = abjad.Timespan(5, 10)

>>> timespan_1.overlaps_all_of_timespan(timespan_1)
False

>>> timespan_1.overlaps_all_of_timespan(timespan_2)
True

>>> timespan_1.overlaps_all_of_timespan(timespan_3)
False
Return type

bool

(Timespan).overlaps_only_start_of_timespan(timespan)

Is true when timespan overlaps only start of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(-5, 5)
>>> timespan_3 = abjad.Timespan(4, 6)
>>> timespan_4 = abjad.Timespan(5, 15)

>>> timespan_1.overlaps_only_start_of_timespan(timespan_1)
False

>>> timespan_1.overlaps_only_start_of_timespan(timespan_2)
False

>>> timespan_1.overlaps_only_start_of_timespan(timespan_3)
False

>>> timespan_1.overlaps_only_start_of_timespan(timespan_4)
True
Return type

bool

(Timespan).overlaps_only_stop_of_timespan(timespan)

Is true when timespan overlaps only stop of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(-5, 5)
>>> timespan_3 = abjad.Timespan(4, 6)
>>> timespan_4 = abjad.Timespan(5, 15)

>>> timespan_1.overlaps_only_stop_of_timespan(timespan_1)
False

>>> timespan_1.overlaps_only_stop_of_timespan(timespan_2)
True

>>> timespan_1.overlaps_only_stop_of_timespan(timespan_3)
False

>>> timespan_1.overlaps_only_stop_of_timespan(timespan_4)
False
Return type

bool

(Timespan).overlaps_start_of_timespan(timespan)

Is true when timespan overlaps start of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(-5, 5)
>>> timespan_3 = abjad.Timespan(4, 6)
>>> timespan_4 = abjad.Timespan(5, 15)

>>> timespan_1.overlaps_start_of_timespan(timespan_1)
False

>>> timespan_1.overlaps_start_of_timespan(timespan_2)
False

>>> timespan_1.overlaps_start_of_timespan(timespan_3)
True

>>> timespan_1.overlaps_start_of_timespan(timespan_4)
True
Return type

bool

(Timespan).overlaps_stop_of_timespan(timespan)

Is true when timespan overlaps start of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(-5, 5)
>>> timespan_3 = abjad.Timespan(4, 6)
>>> timespan_4 = abjad.Timespan(5, 15)

>>> timespan_1.overlaps_stop_of_timespan(timespan_1)
False

>>> timespan_1.overlaps_stop_of_timespan(timespan_2)
True

>>> timespan_1.overlaps_stop_of_timespan(timespan_3)
True

>>> timespan_1.overlaps_stop_of_timespan(timespan_4)
False
Return type

bool

(Timespan).reflect(axis=None)

Reflects timespan about axis.

Reverse timespan about timespan axis:

>>> abjad.Timespan(3, 6).reflect()
Timespan(Offset((3, 1)), Offset((6, 1)))

Reverse timespan about arbitrary axis:

>>> abjad.Timespan(3, 6).reflect(axis=abjad.Offset(10))
Timespan(Offset((14, 1)), Offset((17, 1)))
Return type

Timespan

(Timespan).round_offsets(multiplier, anchor=Left, must_be_wellformed=True)

Rounds timespan offsets to multiple of multiplier.

>>> timespan = abjad.Timespan((1, 5), (4, 5))

>>> timespan.round_offsets(1)
Timespan(Offset((0, 1)), Offset((1, 1)))

>>> timespan.round_offsets(2)
Timespan(Offset((0, 1)), Offset((2, 1)))

>>> timespan.round_offsets(2, anchor=abjad.Right)
Timespan(Offset((-2, 1)), Offset((0, 1)))

>>> timespan.round_offsets(2, anchor=abjad.Right, must_be_wellformed=False)
Timespan(Offset((0, 1)), Offset((0, 1)))
Return type

Timespan

(Timespan).scale(multiplier, anchor=Left)

Scales timespan by multiplier.

>>> timespan = abjad.Timespan(3, 6)

Scale timespan relative to timespan start offset:

>>> timespan.scale(abjad.Multiplier(2))
Timespan(Offset((3, 1)), Offset((9, 1)))

Scale timespan relative to timespan stop offset:

>>> timespan.scale(abjad.Multiplier(2), anchor=abjad.Right)
Timespan(Offset((0, 1)), Offset((6, 1)))
Return type

Timespan

(Timespan).set_duration(duration)

Sets timespan duration to duration.

>>> timespan = abjad.Timespan((1, 2), (3, 2))

>>> timespan.set_duration((3, 5))
Timespan(Offset((1, 2)), Offset((11, 10)))
Return type

Timespan

(Timespan).set_offsets(start_offset=None, stop_offset=None)

Sets timespan start offset to start_offset and stop offset to stop_offset.

>>> timespan = abjad.Timespan((1, 2), (3, 2))

>>> timespan.set_offsets(stop_offset=(7, 8))
Timespan(Offset((1, 2)), Offset((7, 8)))

Subtracts negative start_offset from existing stop offset:

>>> timespan.set_offsets(start_offset=(-1, 2))
Timespan(Offset((1, 1)), Offset((3, 2)))

Subtracts negative stop_offset from existing stop offset:

>>> timespan.set_offsets(stop_offset=(-1, 2))
Timespan(Offset((1, 2)), Offset((1, 1)))
Return type

Timespan

(Timespan).split_at_offset(offset)

Split into two parts when offset happens during timespan:

>>> timespan = abjad.Timespan(0, 5)

>>> left, right = timespan.split_at_offset((2, 1))

>>> left
Timespan(Offset((0, 1)), Offset((2, 1)))

>>> right
Timespan(Offset((2, 1)), Offset((5, 1)))

Otherwise return a copy of timespan:

>>> timespan.split_at_offset((12, 1))[0]
Timespan(Offset((0, 1)), Offset((5, 1)))
Return type

TimespanList

(Timespan).split_at_offsets(offsets)

Split into one or more parts when offsets happens during timespan:

>>> timespan = abjad.Timespan(0, 10)

>>> result = timespan.split_at_offsets((1, 3, 7))
>>> string = abjad.storage(result)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((1, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((1, 1)),
            stop_offset=abjad.Offset((3, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((3, 1)),
            stop_offset=abjad.Offset((7, 1)),
            ),
        abjad.Timespan(
            start_offset=abjad.Offset((7, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        ]
    )

Otherwise return a timespan list containing a copy of timespan:

>>> result = timespan.split_at_offsets((-100,))
>>> string = abjad.storage(result)
>>> print(string)
abjad.TimespanList(
    [
        abjad.Timespan(
            start_offset=abjad.Offset((0, 1)),
            stop_offset=abjad.Offset((10, 1)),
            ),
        ]
    )
Return type

TimespanList

(Timespan).starts_after_offset(offset)

Is true when timespan overlaps start of timespan.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_after_offset((-5, 1))
True

>>> timespan_1.starts_after_offset((0, 1))
False

>>> timespan_1.starts_after_offset((5, 1))
False
Return type

bool

(Timespan).starts_after_timespan_starts(timespan)

Is true when timespan starts after timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.starts_after_timespan_starts(timespan_1)
False

>>> timespan_1.starts_after_timespan_starts(timespan_2)
False

>>> timespan_2.starts_after_timespan_starts(timespan_1)
True

>>> timespan_2.starts_after_timespan_starts(timespan_2)
False
Return type

bool

(Timespan).starts_after_timespan_stops(timespan)

Is true when timespan starts after timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)
>>> timespan_3 = abjad.Timespan(10, 20)
>>> timespan_4 = abjad.Timespan(15, 25)

>>> timespan_1.starts_after_timespan_stops(timespan_1)
False

>>> timespan_2.starts_after_timespan_stops(timespan_1)
False

>>> timespan_3.starts_after_timespan_stops(timespan_1)
True

>>> timespan_4.starts_after_timespan_stops(timespan_1)
True
Return type

bool

(Timespan).starts_at_offset(offset)

Is true when timespan starts at offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_at_offset((-5, 1))
False

>>> timespan_1.starts_at_offset((0, 1))
True

>>> timespan_1.starts_at_offset((5, 1))
False
Return type

bool

(Timespan).starts_at_or_after_offset(offset)

Is true when timespan starts at or after offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_at_or_after_offset((-5, 1))
True

>>> timespan_1.starts_at_or_after_offset((0, 1))
True

>>> timespan_1.starts_at_or_after_offset((5, 1))
False
Return type

bool

(Timespan).starts_before_offset(offset)

Is true when timespan starts before offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_before_offset((-5, 1))
False

>>> timespan_1.starts_before_offset((0, 1))
False

>>> timespan_1.starts_before_offset((5, 1))
True
Return type

bool

(Timespan).starts_before_or_at_offset(offset)

Is true when timespan starts before or at offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_before_or_at_offset((-5, 1))
False

>>> timespan_1.starts_before_or_at_offset((0, 1))
True

>>> timespan_1.starts_before_or_at_offset((5, 1))
True
Return type

bool

(Timespan).starts_before_timespan_starts(timespan)

Is true when timespan starts before timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.starts_before_timespan_starts(timespan_1)
False

>>> timespan_1.starts_before_timespan_starts(timespan_2)
True

>>> timespan_2.starts_before_timespan_starts(timespan_1)
False

>>> timespan_2.starts_before_timespan_starts(timespan_2)
False
Return type

bool

(Timespan).starts_before_timespan_stops(timespan)

Is true when timespan starts before timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.starts_before_timespan_stops(timespan_1)
True

>>> timespan_1.starts_before_timespan_stops(timespan_2)
True

>>> timespan_2.starts_before_timespan_stops(timespan_1)
True

>>> timespan_2.starts_before_timespan_stops(timespan_2)
True
Return type

bool

(Timespan).starts_during_timespan(timespan)

Is true when timespan starts during timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.starts_during_timespan(timespan_1)
True

>>> timespan_1.starts_during_timespan(timespan_2)
False

>>> timespan_2.starts_during_timespan(timespan_1)
True

>>> timespan_2.starts_during_timespan(timespan_2)
True
Return type

bool

(Timespan).starts_when_timespan_starts(timespan)

Is true when timespan starts when timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 15)

>>> timespan_1.starts_when_timespan_starts(timespan_1)
True

>>> timespan_1.starts_when_timespan_starts(timespan_2)
False

>>> timespan_2.starts_when_timespan_starts(timespan_1)
False

>>> timespan_2.starts_when_timespan_starts(timespan_2)
True
Return type

bool

(Timespan).starts_when_timespan_stops(timespan)

Is true when timespan starts when timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.starts_when_timespan_stops(timespan_1)
False

>>> timespan_1.starts_when_timespan_stops(timespan_2)
False

>>> timespan_2.starts_when_timespan_stops(timespan_1)
True

>>> timespan_2.starts_when_timespan_stops(timespan_2)
False
Return type

bool

(Timespan).stops_after_offset(offset)

Is true when timespan stops after offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.starts_after_offset((-5, 1))
True

>>> timespan_1.starts_after_offset((0, 1))
False

>>> timespan_1.starts_after_offset((5, 1))
False
Return type

bool

(Timespan).stops_after_timespan_starts(timespan)

Is true when timespan stops when timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_after_timespan_starts(timespan_1)
True

>>> timespan_1.stops_after_timespan_starts(timespan_2)
False

>>> timespan_2.stops_after_timespan_starts(timespan_1)
True

>>> timespan_2.stops_after_timespan_starts(timespan_2)
True
Return type

bool

(Timespan).stops_after_timespan_stops(timespan)

Is true when timespan stops when timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_after_timespan_stops(timespan_1)
False

>>> timespan_1.stops_after_timespan_stops(timespan_2)
False

>>> timespan_2.stops_after_timespan_stops(timespan_1)
True

>>> timespan_2.stops_after_timespan_stops(timespan_2)
False
Return type

bool

(Timespan).stops_at_offset(offset)

Is true when timespan stops at offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.stops_at_offset((-5, 1))
False

>>> timespan_1.stops_at_offset((0, 1))
False

>>> timespan_1.stops_at_offset((5, 1))
False
Return type

bool

(Timespan).stops_at_or_after_offset(offset)

Is true when timespan stops at or after offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.stops_at_or_after_offset((-5, 1))
True

>>> timespan_1.stops_at_or_after_offset((0, 1))
True

>>> timespan_1.stops_at_or_after_offset((5, 1))
True
Return type

bool

(Timespan).stops_before_offset(offset)

Is true when timespan stops before offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.stops_before_offset((-5, 1))
False

>>> timespan_1.stops_before_offset((0, 1))
False

>>> timespan_1.stops_before_offset((5, 1))
False
Return type

bool

(Timespan).stops_before_or_at_offset(offset)

Is true when timespan stops before or at offset.

>>> timespan_1 = abjad.Timespan(0, 10)

>>> timespan_1.stops_before_or_at_offset((-5, 1))
False

>>> timespan_1.stops_before_or_at_offset((0, 1))
False

>>> timespan_1.stops_before_or_at_offset((5, 1))
False
Return type

bool

(Timespan).stops_before_timespan_starts(timespan)

Is true when timespan stops before timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_before_timespan_starts(timespan_1)
False

>>> timespan_1.stops_before_timespan_starts(timespan_2)
False

>>> timespan_2.stops_before_timespan_starts(timespan_1)
False

>>> timespan_2.stops_before_timespan_starts(timespan_2)
False
Return type

bool

(Timespan).stops_before_timespan_stops(timespan)

Is true when timespan stops before timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_before_timespan_stops(timespan_1)
False

>>> timespan_1.stops_before_timespan_stops(timespan_2)
True

>>> timespan_2.stops_before_timespan_stops(timespan_1)
False

>>> timespan_2.stops_before_timespan_stops(timespan_2)
False
Return type

bool

(Timespan).stops_during_timespan(timespan)

Is true when timespan stops during timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_during_timespan(timespan_1)
True

>>> timespan_1.stops_during_timespan(timespan_2)
False

>>> timespan_2.stops_during_timespan(timespan_1)
False

>>> timespan_2.stops_during_timespan(timespan_2)
True
Return type

bool

(Timespan).stops_when_timespan_starts(timespan)

Is true when timespan stops when timespan starts.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_when_timespan_starts(timespan_1)
False

>>> timespan_1.stops_when_timespan_starts(timespan_2)
True

>>> timespan_2.stops_when_timespan_starts(timespan_1)
False

>>> timespan_2.stops_when_timespan_starts(timespan_2)
False
Return type

bool

(Timespan).stops_when_timespan_stops(timespan)

Is true when timespan stops when timespan stops.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(10, 20)

>>> timespan_1.stops_when_timespan_stops(timespan_1)
True

>>> timespan_1.stops_when_timespan_stops(timespan_2)
False

>>> timespan_2.stops_when_timespan_stops(timespan_1)
False

>>> timespan_2.stops_when_timespan_stops(timespan_2)
True
Return type

bool

(Timespan).stretch(multiplier, anchor=None)

Stretches timespan by multiplier relative to anchor.

Stretch relative to timespan start offset:

>>> abjad.Timespan(3, 10).stretch(abjad.Multiplier(2))
Timespan(Offset((3, 1)), Offset((17, 1)))

Stretch relative to timespan stop offset:

>>> abjad.Timespan(3, 10).stretch(abjad.Multiplier(2), abjad.Offset(10))
Timespan(Offset((-4, 1)), Offset((10, 1)))

Stretch relative to offset prior to timespan:

>>> abjad.Timespan(3, 10).stretch(abjad.Multiplier(2), abjad.Offset(0, 1))
Timespan(Offset((6, 1)), Offset((20, 1)))

Stretch relative to offset after timespan:

>>> abjad.Timespan(3, 10).stretch(abjad.Multiplier(3), abjad.Offset(12))
Timespan(Offset((-15, 1)), Offset((6, 1)))

Stretch relative to offset that happens during timespan:

>>> abjad.Timespan(3, 10).stretch(abjad.Multiplier(2), abjad.Offset(4))
Timespan(Offset((2, 1)), Offset((16, 1)))
Return type

Timespan

(Timespan).translate(translation=None)

Translates timespan by translation.

>>> timespan = abjad.Timespan(5, 10)

>>> timespan.translate(2)
Timespan(Offset((7, 1)), Offset((12, 1)))
Return type

Timespan

(Timespan).translate_offsets(start_offset_translation=None, stop_offset_translation=None)

Translates timespan start offset by start_offset_translation and stop offset by stop_offset_translation.

>>> timespan = abjad.Timespan((1, 2), (3, 2))

>>> timespan.translate_offsets(start_offset_translation=(-1, 8))
Timespan(Offset((3, 8)), Offset((3, 2)))
Return type

Timespan

(Timespan).trisects_timespan(timespan)

Is true when timespan trisects timespan.

>>> timespan_1 = abjad.Timespan(0, 10)
>>> timespan_2 = abjad.Timespan(5, 6)

>>> timespan_1.trisects_timespan(timespan_1)
False

>>> timespan_1.trisects_timespan(timespan_2)
False

>>> timespan_2.trisects_timespan(timespan_1)
True

>>> timespan_2.trisects_timespan(timespan_2)
False
Return type

bool

Read-only properties

(Timespan).axis

Gets arithmetic mean of timespan start- and stop-offsets.

>>> abjad.Timespan(0, 10).axis
Offset((5, 1))
Return type

Offset

(Timespan).duration

Gets duration of timespan.

>>> abjad.Timespan(0, 10).duration
Duration(10, 1)
Return type

Duration

(Timespan).offsets

Gets offsets.

>>> abjad.Timespan(0, 10).offsets
(Offset((0, 1)), Offset((10, 1)))
Return type

Tuple[Offset, Offset]

(Timespan).start_offset

Gets start offset.

>>> abjad.Timespan(0, 10).start_offset
Offset((0, 1))
Return type

Offset

(Timespan).stop_offset

Gets stop offset.

>>> abjad.Timespan(0, 10).stop_offset
Offset((10, 1))
Return type

Offset

(Timespan).wellformed

Is true when timespan start offset preceeds timespan stop offset.

>>> abjad.Timespan(0, 10).wellformed
True
Return type

bool