abjad.timespan

`abjad.timespan.OffsetCounter`(items, item_class)	Offset counter.
`abjad.timespan.Timespan`([start_offset, ...])	Timespan.
`abjad.timespan.TimespanList`([argument])	Timespan list.

class abjad.timespan.OffsetCounter(items: ~typing.Any = (), item_class: ~typing.Any = <class 'abjad.duration.Offset'>)[source]

Offset counter.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...     ]
... )
>>> timespan_operand = abjad.Timespan(6, 10)
>>> timespans = timespans - timespan_operand
>>> offset_counter = abjad.OffsetCounter(timespans)
>>> for item in offset_counter.items.items():
...     item
... 
(Offset((-2, 1)), 1)
(Offset((0, 1)), 1)
(Offset((5, 1)), 1)
(Offset((6, 1)), 3)
(Offset((10, 1)), 2)
(Offset((12, 1)), 1)
(Offset((16, 1)), 1)

>>> abjad.show(offset_counter, scale=0.5)  

class abjad.timespan.Timespan(start_offset: Any = None, stop_offset: Any = None, annotation: Any = None)[source]

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)

Annotations work like this:

>>> annotated_timespan = abjad.Timespan(
...     annotation=["a", "b", "c", "foo"],
...     start_offset=(1, 4),
...     stop_offset=(7, 8),
... )
>>> annotated_timespan.annotation
['a', 'b', 'c', 'foo']

Annotated timespans maintain their annotations duration mutation:

>>> left, right = annotated_timespan.split_at_offset((1, 2))
>>> left.annotation.append("foo")
>>> right
Timespan(Offset((1, 2)), Offset((7, 8)), annotation=['a', 'b', 'c', 'foo', 'foo'])

Timespans are closed-open intervals.

`axis`()	Gets arithmetic mean of timespan start- and stop-offsets.
`divide_by_proportion`(proportion)	Divides timespan by `proportion`.
`duration`()	Gets duration of timespan.
`is_wellformed`()	Is true when timespan start offset preceeds timespan stop offset.
`offsets`()	Gets offsets.
`overlap_with_timespan`(timespan)	Gets duration of overlap with `timespan`.
`reflect`([axis])	Reflects timespan about `axis`.
`round_offsets`(multiplier[, anchor, ...])	Rounds timespan offsets to multiple of `multiplier`.
`scale`(multiplier[, anchor])	Scales timespan by `multiplier`.
`set_duration`(duration)	Sets timespan duration to `duration`.
`set_offsets`([start_offset, stop_offset])	Sets timespan start offset to `start_offset` and stop offset to `stop_offset`.
`split_at_offset`(offset)	Split into two parts when `offset` happens during timespan.
`split_at_offsets`(offsets)	Split into one or more parts when `offsets` happens during timespan.
`stretch`(multiplier[, anchor])	Stretches timespan by `multiplier` relative to `anchor`.
`translate`([translation])	Translates timespan by `translation`.
`translate_offsets`([...])	Translates timespan start offset by `start_offset_translation` and stop offset by `stop_offset_translation`.

axis() → Offset[source]

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

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

divide_by_proportion(proportion: tuple[int, ...]) → tuple[Timespan, ...][source]

Divides timespan by proportion.

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

>>> for x in timespan.divide_by_proportion((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)))

duration() → Duration[source]

Gets duration of timespan.

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

is_wellformed() → bool[source]

Is true when timespan start offset preceeds timespan stop offset.

>>> abjad.Timespan(0, 10).is_wellformed()
True

offsets() → tuple[Offset, Offset][source]

Gets offsets.

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

overlap_with_timespan(timespan) → Duration | None[source]

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.overlap_with_timespan(timespan_1)
Duration(15, 1)

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

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

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

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

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

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

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

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

>>> timespan_4.overlap_with_timespan(timespan_4)
Duration(10, 1)

reflect(axis=None) → Timespan[source]

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)))

round_offsets(multiplier, anchor=Horizontal.LEFT, must_be_wellformed=True) → Timespan[source]

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)))

scale(multiplier, anchor=Horizontal.LEFT) → Timespan[source]

Scales timespan by multiplier.

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

Scale timespan relative to timespan start offset:

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

Scale timespan relative to timespan stop offset:

>>> timespan.scale(abjad.Fraction(2), anchor=abjad.RIGHT)
Timespan(Offset((0, 1)), Offset((6, 1)))

set_duration(duration) → Timespan[source]

Sets timespan duration to duration.

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

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

set_offsets(start_offset=None, stop_offset=None) → Timespan[source]

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)))

split_at_offset(offset) → TimespanList[source]

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)))

split_at_offsets(offsets) → TimespanList[source]

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

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

>>> timespans = timespan.split_at_offsets((1, 3, 7))
>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((1, 1)))
Timespan(Offset((1, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((7, 1)))
Timespan(Offset((7, 1)), Offset((10, 1)))

Otherwise return a timespan list containing a copy of timespan:

>>> timespans = timespan.split_at_offsets((-100,))
>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((10, 1)))

stretch(multiplier, anchor=None) → Timespan[source]

Stretches timespan by multiplier relative to anchor.

Stretch relative to timespan start offset:

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

Stretch relative to timespan stop offset:

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

Stretch relative to offset prior to timespan:

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

Stretch relative to offset after timespan:

>>> abjad.Timespan(3, 10).stretch(abjad.Fraction(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.Fraction(2), abjad.Offset(4))
Timespan(Offset((2, 1)), Offset((16, 1)))

translate(translation=None) → Timespan[source]

Translates timespan by translation.

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

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

translate_offsets(start_offset_translation=None, stop_offset_translation=None) → Timespan[source]

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)))

class abjad.timespan.TimespanList(argument=())[source]

Timespan list.

Contiguous timespan list:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

Overlapping timespan list:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((16, 1)))
Timespan(Offset((5, 1)), Offset((12, 1)))
Timespan(Offset((-2, 1)), Offset((8, 1)))
Timespan(Offset((15, 1)), Offset((20, 1)))
Timespan(Offset((24, 1)), Offset((30, 1)))

Empty timespan list:

>>> abjad.TimespanList()
TimespanList([])

Coerces input:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, (1, 2)),
...         ((1, 2), (3, 4)),
...         abjad.Timespan((3, 4), 1),
...     ]
... )

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((1, 2)))
Timespan(Offset((1, 2)), Offset((3, 4)))
Timespan(Offset((3, 4)), Offset((1, 1)))

Operations on timespan currently work in place.

`all_are_contiguous`()	Is true when all timespans are contiguous.
`all_are_nonoverlapping`()	Is true when all timespans are nonoverlapping.
`all_are_wellformed`()	Is true when all timespans are wellformed.
`append`(item)	Coerces `item` and appends.
`axis`()	Gets axis defined equal to arithmetic mean of start- and stop-offsets.
`clip_timespan_durations`([minimum, maximum, ...])	Clips timespan durations.
`compute_logical_and`()	Computes logical AND of timespans.
`compute_logical_or`()	Computes logical OR of timespans.
`compute_logical_xor`()	Computes logical XOR of timespans.
`compute_overlap_factor`([timespan])	Computes overlap factor of timespans.
`compute_overlap_factor_mapping`()	Computes overlap factor for each consecutive offset pair in timespans.
`count_offsets`()	Counts offsets.
`duration`()	Gets duration of timespan list.
`explode`([inventory_count])	Explodes timespans into timespan lists, avoiding overlap, and distributing density as evenly as possible.
`extend`(items)	Coerces `items` and extends.
`has_timespan_that_satisfies_time_relation`(...)	Is true when list has matching timespan.
`is_sorted`()	Is true when timespans are in time order.
`partition`([include_tangent_timespans])	Partitions timespans into timespan lists.
`reflect`([axis])	Reflects timespans.
`remove`(item)	Coerces `item` and removes.
`remove_degenerate_timespans`()	Removes degenerate timespans.
`repeat_to_stop_offset`(stop_offset)	Repeats timespans to `stop_offset`.
`rotate`(count)	Rotates by `count` contiguous timespans.
`round_offsets`(multiplier[, anchor, ...])	Rounds offsets of timespans in list to multiples of `multiplier`.
`scale`(multiplier[, anchor])	Scales timespan by `multiplier` relative to `anchor`.
`split_at_offset`(offset)	Splits timespans at `offset`.
`split_at_offsets`(offsets)	Splits timespans at `offsets`.
`start_offset`()	Gets start offset.
`stop_offset`()	Gets stop offset.
`stretch`(multiplier[, anchor])	Stretches timespans by `multiplier` relative to `anchor`.
`timespan`()	Gets timespan of timespan list.
`timespan_that_satisfies_time_relation`(...)	Gets timespan that satisifies `time_relation`.
`timespans_that_satisfy_time_relation`(...)	Gets timespans that satisfy `time_relation`.
`translate`([translation])	Translates timespans by `translation`.
`translate_offsets`([...])	Translates timespans by `start_offset_translation` and `stop_offset_translation`.

all_are_contiguous() → bool[source]

Is true when all timespans are contiguous.

Is true when all timespans are contiguous:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_contiguous()
True

Is false when timespans not contiguous:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_contiguous()
False

Is true when timespan list is empty:

>>> abjad.TimespanList().all_are_contiguous()
True

all_are_nonoverlapping() → bool[source]

Is true when all timespans are nonoverlapping.

Is true when all timespans are nonoverlapping:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_nonoverlapping()
True

Is false when timespans are overlapping:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_nonoverlapping()
False

Is true when timespan list is empty:

>>> abjad.TimespanList().all_are_nonoverlapping()
True

all_are_wellformed() → bool[source]

Is true when all timespans are wellformed.

Is false when timespans are not all wellformed.

Is true when all timespans are wellformed:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_wellformed()
True

Is true when all timespans are wellformed:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.all_are_wellformed()
True

Is true when timespan list is empty:

>>> abjad.TimespanList().all_are_wellformed()
True

overridden append(item)[source]: Coerces item and appends.

axis() → Offset | None[source]

Gets axis defined equal to arithmetic mean of start- and stop-offsets.

Gets axis:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.axis()
Offset((5, 1))

Gets axis:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.axis()
Offset((14, 1))

Gets none when timespan list is empty:

>>> abjad.TimespanList().axis() is None
True

clip_timespan_durations(minimum=None, maximum=None, anchor=Horizontal.LEFT) → TimespanList[source]

Clips timespan durations.

Clips timespan durations:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 1),
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.clip_timespan_durations(minimum=5)
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((5, 1)))
Timespan(Offset((0, 1)), Offset((10, 1)))

Clips timespan durations:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 1),
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.clip_timespan_durations(maximum=5)
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((1, 1)))
Timespan(Offset((0, 1)), Offset((5, 1)))

Clips timespan durations:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 1),
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.clip_timespan_durations(
...     minimum=3,
...     maximum=7,
... )
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((0, 1)), Offset((7, 1)))

Clips timespan durations:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 1),
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(-2, 10), scale=0.5)  

>>> timespans = timespans.clip_timespan_durations(
...     minimum=3,
...     maximum=7,
...     anchor=abjad.RIGHT,
... )
>>> abjad.show(timespans, range_=(-2, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-2, 1)), Offset((1, 1)))
Timespan(Offset((3, 1)), Offset((10, 1)))

compute_logical_and() → TimespanList[source]

Computes logical AND of timespans.

Same as setwise intersection.

Operates in place and returns timespan list.

Computes logical AND:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_and()
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((10, 1)))

Computes logical AND:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_and()
>>> abjad.show(timespans, range_=(0, 12), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((5, 1)), Offset((10, 1)))

Computes logical AND:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...     ]
... )
>>> abjad.show(timespans, range_=(-2, 12), scale=0.5)  

>>> timespans = timespans.compute_logical_and()
>>> abjad.show(timespans, range_=(-2, 12), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((5, 1)), Offset((8, 1)))

compute_logical_or() → TimespanList[source]

Computes logical OR of timespans.

Operates in place and returns timespan list.

>>> timespans = abjad.TimespanList()
>>> timespans = timespans.compute_logical_or()

>>> timespans
TimespanList([])

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_or()
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((10, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_or()
>>> abjad.show(timespans, range_=(0, 12), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((12, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 2),
...     ]
... )
>>> abjad.show(timespans, range_=(-2, 12), scale=0.5)  

>>> timespans = timespans.compute_logical_or()
>>> abjad.show(timespans, range_=(-2, 12), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-2, 1)), Offset((12, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(-2, 2),
...         abjad.Timespan(10, 20),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_or()
>>> abjad.show(timespans, range_=(-2, 20), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-2, 1)), Offset((2, 1)))
Timespan(Offset((10, 1)), Offset((20, 1)))

compute_logical_xor() → TimespanList[source]

Computes logical XOR of timespans.

Operates in place and returns timespan list.

>>> timespans = abjad.TimespanList()
>>> timespans = timespans.compute_logical_xor()

>>> timespans
TimespanList([])

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_xor()
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((10, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 12), scale=0.5)  

>>> timespans = timespans.compute_logical_xor()
>>> abjad.show(timespans, range_=(0, 12), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((5, 1)))
Timespan(Offset((10, 1)), Offset((12, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 2),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 12), scale=0.5)  

>>> timespans = timespans.compute_logical_xor()
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-2, 1)), Offset((0, 1)))
Timespan(Offset((2, 1)), Offset((5, 1)))
Timespan(Offset((10, 1)), Offset((12, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(-2, 2),
...         abjad.Timespan(10, 20),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_xor()
>>> abjad.show(timespans, range_=(-2, 20), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-2, 1)), Offset((2, 1)))
Timespan(Offset((10, 1)), Offset((20, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(4, 8),
...         abjad.Timespan(2, 6),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_xor()
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((2, 1)))
Timespan(Offset((8, 1)), Offset((10, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(0, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.compute_logical_xor()

>>> timespans
TimespanList([])

compute_overlap_factor(timespan=None) → Fraction[source]

Computes overlap factor of timespans.

Example timespan list:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 15),
...         abjad.Timespan(20, 25),
...         abjad.Timespan(20, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

Computes overlap factor across the entire list:

>>> timespans.compute_overlap_factor()
Fraction(7, 6)

Computes overlap factor within a specific timespan:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(-15, 0))
Fraction(0, 1)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(-10, 5))
Fraction(1, 3)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(-5, 10))
Fraction(1, 1)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(0, 15))
Fraction(4, 3)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(5, 20))
Fraction(1, 1)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(10, 25))
Fraction(1, 1)

Computes overlap factor:

>>> timespans.compute_overlap_factor(timespan=abjad.Timespan(15, 30))
Fraction(1, 1)

compute_overlap_factor_mapping() → dict[source]

Computes overlap factor for each consecutive offset pair in timespans.

Returns mapping.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 10),
...         abjad.Timespan(5, 15),
...         abjad.Timespan(20, 25),
...         abjad.Timespan(20, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> mapping = timespans.compute_overlap_factor_mapping()
>>> for timespan, overlap_factor in mapping.items():
...     timespan.start_offset, timespan.stop_offset, overlap_factor
... 
(Offset((0, 1)), Offset((5, 1)), Fraction(1, 1))
(Offset((5, 1)), Offset((10, 1)), Fraction(2, 1))
(Offset((10, 1)), Offset((15, 1)), Fraction(1, 1))
(Offset((15, 1)), Offset((20, 1)), Fraction(0, 1))
(Offset((20, 1)), Offset((25, 1)), Fraction(2, 1))
(Offset((25, 1)), Offset((30, 1)), Fraction(1, 1))

count_offsets() → OffsetCounter[source]

Counts offsets.

Counts offsets:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

>>> offset_counter = timespans.count_offsets()
>>> abjad.show(offset_counter, range_=(0, 10), scale=0.5)  

>>> for offset, count in sorted(timespans.count_offsets().items.items()):
...     offset, count
... 
(Offset((0, 1)), 1)
(Offset((3, 1)), 2)
(Offset((6, 1)), 2)
(Offset((10, 1)), 1)

Counts offsets:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((16, 1)))
Timespan(Offset((5, 1)), Offset((12, 1)))
Timespan(Offset((-2, 1)), Offset((8, 1)))
Timespan(Offset((15, 1)), Offset((20, 1)))
Timespan(Offset((24, 1)), Offset((30, 1)))

>>> offset_counter = timespans.count_offsets()
>>> abjad.show(offset_counter, range_=(0, 30), scale=0.5)  

>>> for offset, count in sorted(timespans.count_offsets().items.items()):
...     offset, count
... 
(Offset((-2, 1)), 1)
(Offset((0, 1)), 1)
(Offset((5, 1)), 1)
(Offset((8, 1)), 1)
(Offset((12, 1)), 1)
(Offset((15, 1)), 1)
(Offset((16, 1)), 1)
(Offset((20, 1)), 1)
(Offset((24, 1)), 1)
(Offset((30, 1)), 1)

Counts offsets:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(0, 6),
...         abjad.Timespan(0, 9),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> offset_counter = timespans.count_offsets()
>>> abjad.show(offset_counter, range_=(0, 9), scale=0.5)  

>>> for offset, count in sorted(timespans.count_offsets().items.items()):
...     offset, count
... 
(Offset((0, 1)), 3)
(Offset((3, 1)), 1)
(Offset((6, 1)), 1)
(Offset((9, 1)), 1)

duration() → Duration[source]

Gets duration of timespan list.

Gets duration:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.duration()
Duration(10, 1)

Gets duration:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.duration()
Duration(32, 1)

Gets zero when timespan list is empty:

>>> abjad.TimespanList().duration()
Duration(0, 1)

explode(inventory_count=None) → tuple[TimespanList, ...][source]

Explodes timespans into timespan lists, avoiding overlap, and distributing density as evenly as possible.

Example timespan list:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(5, 13),
...         abjad.Timespan(6, 10),
...         abjad.Timespan(8, 9),
...         abjad.Timespan(15, 23),
...         abjad.Timespan(16, 21),
...         abjad.Timespan(17, 19),
...         abjad.Timespan(19, 20),
...         abjad.Timespan(25, 30),
...         abjad.Timespan(26, 29),
...         abjad.Timespan(32, 34),
...         abjad.Timespan(34, 37),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

Explodes timespans into the optimal number of non-overlapping timespan_lists:

>>> for exploded_timespan_list in timespans.explode():
...     for _ in exploded_timespan_list:
...         _
...     "---"
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((5, 1)), Offset((13, 1)))
Timespan(Offset((17, 1)), Offset((19, 1)))
Timespan(Offset((19, 1)), Offset((20, 1)))
Timespan(Offset((34, 1)), Offset((37, 1)))
'---'
Timespan(Offset((6, 1)), Offset((10, 1)))
Timespan(Offset((16, 1)), Offset((21, 1)))
Timespan(Offset((25, 1)), Offset((30, 1)))
'---'
Timespan(Offset((8, 1)), Offset((9, 1)))
Timespan(Offset((15, 1)), Offset((23, 1)))
Timespan(Offset((26, 1)), Offset((29, 1)))
Timespan(Offset((32, 1)), Offset((34, 1)))
'---'

Explodes timespans into a less-than-optimal number of overlapping timespan_lists:

>>> for exploded_timespan_list in timespans.explode(inventory_count=6):
...     for _ in exploded_timespan_list:
...         _
...     "---"
... 
Timespan(Offset((16, 1)), Offset((21, 1)))
Timespan(Offset((34, 1)), Offset((37, 1)))
'---'
Timespan(Offset((15, 1)), Offset((23, 1)))
'---'
Timespan(Offset((8, 1)), Offset((9, 1)))
Timespan(Offset((17, 1)), Offset((19, 1)))
Timespan(Offset((19, 1)), Offset((20, 1)))
Timespan(Offset((26, 1)), Offset((29, 1)))
'---'
Timespan(Offset((6, 1)), Offset((10, 1)))
Timespan(Offset((32, 1)), Offset((34, 1)))
'---'
Timespan(Offset((5, 1)), Offset((13, 1)))
'---'
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((25, 1)), Offset((30, 1)))
'---'

overridden extend(items)[source]: Coerces items and extends.

has_timespan_that_satisfies_time_relation(time_relation) → bool[source]

Is true when list has matching timespan.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespan = abjad.Timespan(2, 8)
>>> time_relation = (
...     lambda _: timespan.start_offset < _.start_offset < timespan.stop_offset
... )
>>> timespans.has_timespan_that_satisfies_time_relation(time_relation)
True

Is false when list does not have matching timespan:

>>> timespan = abjad.Timespan(10, 20)
>>> timespans.has_timespan_that_satisfies_time_relation(time_relation)
False

is_sorted() → bool[source]

Is true when timespans are in time order.

Is true when timespans are sorted:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.is_sorted()
True

Is false when timespans are not sorted:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(6, 10),
...         abjad.Timespan(3, 6),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.is_sorted()
False

partition(include_tangent_timespans=False) → tuple[TimespanList, ...][source]

Partitions timespans into timespan lists.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

>>> for timespan_list in timespans.partition():
...     for _ in timespan_list:
...         _
...     "---"
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
'---'
Timespan(Offset((3, 1)), Offset((6, 1)))
'---'
Timespan(Offset((6, 1)), Offset((10, 1)))
'---'

Partitions timespans:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((16, 1)))
Timespan(Offset((5, 1)), Offset((12, 1)))
Timespan(Offset((-2, 1)), Offset((8, 1)))
Timespan(Offset((15, 1)), Offset((20, 1)))
Timespan(Offset((24, 1)), Offset((30, 1)))

>>> for timespan_list in timespans.partition():
...     for _ in timespan_list:
...         _
...     "---"
... 
Timespan(Offset((-2, 1)), Offset((8, 1)))
Timespan(Offset((0, 1)), Offset((16, 1)))
Timespan(Offset((5, 1)), Offset((12, 1)))
Timespan(Offset((15, 1)), Offset((20, 1)))
'---'
Timespan(Offset((24, 1)), Offset((30, 1)))
'---'

Treats tangent timespans as part of the same group when include_tangent_timespans is true:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> for timespan_list in timespans.partition(
...     include_tangent_timespans=True,
... ):
...     for _ in timespan_list:
...         _
...     "---"
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))
'---'

reflect(axis=None) → TimespanList[source]

Reflects timespans.

Operates in place.

Reflects timespans about timespan list axis:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.reflect()
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((4, 1)))
Timespan(Offset((4, 1)), Offset((7, 1)))
Timespan(Offset((7, 1)), Offset((10, 1)))

Reflects timespans about arbitrary axis:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 30), scale=0.5)  

>>> timespans = timespans.reflect(axis=abjad.Offset(15))
>>> abjad.show(timespans, range_=(0, 30), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((20, 1)), Offset((24, 1)))
Timespan(Offset((24, 1)), Offset((27, 1)))
Timespan(Offset((27, 1)), Offset((30, 1)))

overridden remove(item)[source]: Coerces item and removes.

remove_degenerate_timespans() → TimespanList[source]

Removes degenerate timespans.

Operates in place.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(5, 5),
...         abjad.Timespan(5, 10),
...         abjad.Timespan(5, 25),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.remove_degenerate_timespans()
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((5, 1)), Offset((10, 1)))
Timespan(Offset((5, 1)), Offset((25, 1)))

repeat_to_stop_offset(stop_offset) → TimespanList[source]

Repeats timespans to stop_offset.

Operates in place.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 15), scale=0.5)  

>>> timespans = timespans.repeat_to_stop_offset(15)
>>> abjad.show(timespans, range_=(0, 15), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))
Timespan(Offset((10, 1)), Offset((13, 1)))
Timespan(Offset((13, 1)), Offset((15, 1)))

rotate(count) → TimespanList[source]

Rotates by count contiguous timespans.

Operates in place.

Rotates by one timespan to the left:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 4),
...         abjad.Timespan(4, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.rotate(-1)
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((1, 1)))
Timespan(Offset((1, 1)), Offset((7, 1)))
Timespan(Offset((7, 1)), Offset((10, 1)))

Rotates by one timespan to the right:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 4),
...         abjad.Timespan(4, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans = timespans.rotate(1)
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((9, 1)))
Timespan(Offset((9, 1)), Offset((10, 1)))

round_offsets(multiplier, anchor=Horizontal.LEFT, must_be_wellformed=True) → TimespanList[source]

Rounds offsets of timespans in list to multiples of multiplier.

Operates in place.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 2),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> rounded_timespans = timespans.round_offsets(3)
>>> abjad.show(rounded_timespans, range_=(0, 10), scale=0.5)  

>>> for _ in rounded_timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((9, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 2),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> rounded_timespans = timespans.round_offsets(5)
>>> abjad.show(rounded_timespans, scale=0.5)  

>>> for _ in rounded_timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((5, 1)))
Timespan(Offset((5, 1)), Offset((10, 1)))
Timespan(Offset((5, 1)), Offset((10, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 2),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(-5, 10), scale=0.5)  

>>> rounded_timespans = timespans.round_offsets(
...     5,
...     anchor=abjad.RIGHT,
... )
>>> abjad.show(rounded_timespans, range_=(-5, 10), scale=0.5)  

>>> for _ in rounded_timespans:
...     _
... 
Timespan(Offset((-5, 1)), Offset((0, 1)))
Timespan(Offset((0, 1)), Offset((5, 1)))
Timespan(Offset((5, 1)), Offset((10, 1)))

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 2),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> rounded_timespans = timespans.round_offsets(
...     5,
...     anchor=abjad.RIGHT,
...     must_be_wellformed=False,
... )

>>> for _ in rounded_timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((0, 1)))
Timespan(Offset((5, 1)), Offset((5, 1)))
Timespan(Offset((5, 1)), Offset((10, 1)))

scale(multiplier, anchor=Horizontal.LEFT) → TimespanList[source]

Scales timespan by multiplier relative to anchor.

Operates in place.

Scales timespans relative to timespan list start offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 14), scale=0.5)  

>>> timespans = timespans.scale(2)
>>> abjad.show(timespans, range_=(0, 14), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((6, 1)))
Timespan(Offset((3, 1)), Offset((9, 1)))
Timespan(Offset((6, 1)), Offset((14, 1)))

Scales timespans relative to timespan list stop offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(-3, 10), scale=0.5)  

>>> timespans = timespans.scale(2, anchor=abjad.RIGHT)
>>> abjad.show(timespans, range_=(-3, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-3, 1)), Offset((3, 1)))
Timespan(Offset((0, 1)), Offset((6, 1)))
Timespan(Offset((2, 1)), Offset((10, 1)))

split_at_offset(offset) → tuple[TimespanList, TimespanList][source]

Splits timespans at offset.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> left, right = timespans.split_at_offset(4)

>>> abjad.show(left, range_=(0, 10), scale=0.5)  

>>> for _ in left:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((4, 1)))

>>> abjad.show(right, range_=(0, 10), scale=0.5)  

>>> for _ in right:
...     _
... 
Timespan(Offset((4, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

Splits at offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> left, right = timespans.split_at_offset(6)

>>> abjad.show(left, range_=(0, 10), scale=0.5)  

>>> for _ in left:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))

>>> abjad.show(right, range_=(0, 10), scale=0.5)  

>>> for _ in right:
...     _
... 
Timespan(Offset((6, 1)), Offset((10, 1)))

Splits at offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> left, right = timespans.split_at_offset(-1)

>>> left
TimespanList([])

>>> abjad.show(right, range_=(0, 10), scale=0.5)  

>>> for _ in right:
...     _
... 
Timespan(Offset((0, 1)), Offset((3, 1)))
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

split_at_offsets(offsets) → list[TimespanList][source]

Splits timespans at offsets.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(4, 10),
...         abjad.Timespan(15, 20),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 20), scale=0.5)  

>>> offsets = [-1, 3, 6, 12, 13]
>>> for timespan_list in timespans.split_at_offsets(offsets):
...     abjad.show(timespan_list, range_=(0, 20), scale=0.5)  
...     for _ in timespan_list:
...         _
...     "---"
... 

Timespan(Offset((0, 1)), Offset((3, 1)))
'---'

Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((4, 1)), Offset((6, 1)))
'---'

Timespan(Offset((6, 1)), Offset((10, 1)))
'---'

Timespan(Offset((15, 1)), Offset((20, 1)))
'---'

Splits empty list:

>>> timespans = abjad.TimespanList([])
>>> timespans.split_at_offsets(offsets)
[TimespanList([])]

start_offset() → Offset | NegativeInfinity[source]

Gets start offset.

Defined equal to earliest start offset of any timespan in list.

Gets start offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.start_offset()
Offset((0, 1))

Gets start offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.start_offset()
Offset((-2, 1))

Gets negative infinity when timespan list is empty:

>>> abjad.TimespanList().start_offset()
NegativeInfinity()

stop_offset() → Offset | Infinity[source]

Gets stop offset.

Defined equal to latest stop offset of any timespan.

Gets stop offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.stop_offset()
Offset((10, 1))

Gets stop offset:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespans.stop_offset()
Offset((30, 1))

Gets infinity when timespan list is empty:

>>> abjad.TimespanList().stop_offset()
Infinity()

stretch(multiplier, anchor=None) → TimespanList[source]

Stretches timespans by multiplier relative to anchor.

Operates in place.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 20), scale=0.5)  

>>> timespans = timespans.stretch(2)
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((12, 1)))
Timespan(Offset((12, 1)), Offset((20, 1)))

Stretches timespans relative to arbitrary anchor:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(-8, 12), scale=0.5)  

>>> timespans = timespans.stretch(2, anchor=abjad.Offset(8))
>>> abjad.show(timespans, scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((-8, 1)), Offset((-2, 1)))
Timespan(Offset((-2, 1)), Offset((4, 1)))
Timespan(Offset((4, 1)), Offset((12, 1)))

timespan()[source]

Gets timespan of timespan list.

Gets timespan:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> abjad.show(timespans.timespan(), range_=(0, 10), scale=0.5)  

>>> timespans.timespan()
Timespan(Offset((0, 1)), Offset((10, 1)))

Gets timespan:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 16),
...         abjad.Timespan(5, 12),
...         abjad.Timespan(-2, 8),
...         abjad.Timespan(15, 20),
...         abjad.Timespan(24, 30),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> abjad.show(timespans.timespan(), range_=(0, 30), scale=0.5)  

>>> timespans.timespan()
Timespan(Offset((-2, 1)), Offset((30, 1)))

Gets infinite timespan when list is empty:

>>> abjad.TimespanList().timespan()
Timespan(NegativeInfinity(), Infinity())

Returns timespan.

timespan_that_satisfies_time_relation(time_relation)[source]

Gets timespan that satisifies time_relation.

Returns timespan when timespan list contains exactly one timespan that satisfies time_relation.

Raises exception when timespan list contains no timespan that satisfies time_relation.

Raises exception when timespan list contains more than one timespan that satisfies time_relation.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespan = abjad.Timespan(2, 5)
>>> time_relation = (
...     lambda _: timespan.start_offset < _.start_offset < timespan.stop_offset
... )
>>> timespan = timespans.timespan_that_satisfies_time_relation(time_relation)
>>> abjad.show(timespan, range_=(0, 10), scale=0.5)  

>>> timespan
Timespan(Offset((3, 1)), Offset((6, 1)))

timespans_that_satisfy_time_relation(time_relation) → TimespanList[source]

Gets timespans that satisfy time_relation.

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, scale=0.5)  

>>> timespan = abjad.Timespan(2, 8)
>>> time_relation = (
...     lambda _: timespan.start_offset < _.start_offset < timespan.stop_offset
... )
>>> timespans = timespans.timespans_that_satisfy_time_relation(time_relation)
>>> abjad.show(timespans, range_=(0, 10), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((3, 1)), Offset((6, 1)))
Timespan(Offset((6, 1)), Offset((10, 1)))

translate(translation=None) → TimespanList[source]

Translates timespans by translation.

Operates in place.

Translates timespan by offset 50:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 60), scale=0.5)  

>>> timespans = timespans.translate(50)
>>> abjad.show(timespans, range_=(0, 60), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((50, 1)), Offset((53, 1)))
Timespan(Offset((53, 1)), Offset((56, 1)))
Timespan(Offset((56, 1)), Offset((60, 1)))

translate_offsets(start_offset_translation=None, stop_offset_translation=None) → TimespanList[source]

Translates timespans by start_offset_translation and stop_offset_translation.

Operates in place.

Translates timespan start- and stop-offsets equally:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 60), scale=0.5)  

>>> timespans = timespans.translate_offsets(50, 50)
>>> abjad.show(timespans, range_=(0, 60), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((50, 1)), Offset((53, 1)))
Timespan(Offset((53, 1)), Offset((56, 1)))
Timespan(Offset((56, 1)), Offset((60, 1)))

Translates timespan stop-offsets only:

>>> timespans = abjad.TimespanList(
...     [
...         abjad.Timespan(0, 3),
...         abjad.Timespan(3, 6),
...         abjad.Timespan(6, 10),
...     ]
... )
>>> abjad.show(timespans, range_=(0, 30), scale=0.5)  

>>> timespans = timespans.translate_offsets(stop_offset_translation=20)
>>> abjad.show(timespans, range_=(0, 30), scale=0.5)  

>>> for _ in timespans:
...     _
... 
Timespan(Offset((0, 1)), Offset((23, 1)))
Timespan(Offset((3, 1)), Offset((26, 1)))
Timespan(Offset((6, 1)), Offset((30, 1)))