def timespan_2_contains_timespan_1_improperly(
timespan_1=None,
timespan_2=None,
hold=False,
):
r"""
Makes time relation indicating that ``timespan_2`` contains
``timespan_1`` improperly.
.. container:: example
>>> relation = abjad.timespans.timespan_2_contains_timespan_1_improperly()
>>> abjad.f(relation)
abjad.timespans.TimespanTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('timespan_2.start_offset <= timespan_1.start_offset'),
abjad.TimespanInequality('timespan_1.stop_offset <= timespan_2.stop_offset'),
],
logical_operator='and',
),
)
.. container:: example
>>> staff = abjad.Staff(
... r"c'8. \p \< fs'16 a'4 af'8 \f \> g'8 ~ g'16 f' e' ef' \p",
... )
>>> timespan_1 = abjad.Timespan((1, 4), (3, 8))
>>> abjad.show(staff) # doctest: +SKIP
>>> offset_lists = staff[:]._get_offset_lists()
>>> time_relation = abjad.timespans.timespan_2_contains_timespan_1_improperly(timespan_1=timespan_1)
>>> start_index, stop_index = time_relation.get_offset_indices(*offset_lists)
>>> selected_notes = staff[start_index:stop_index]
>>> selected_notes
Selection([Note("a'4")])
>>> abjad.label(selected_notes).color_leaves('red')
>>> abjad.show(staff) # doctest: +SKIP
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'timespan_2.start_offset <= timespan_1.start_offset',
'timespan_1.stop_offset <= timespan_2.stop_offset',
])
time_relation = timespans.TimespanTimespanTimeRelation(
inequality,
timespan_1=timespan_1,
timespan_2=timespan_2,
)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def offset_happens_when_timespan_stops(timespan=None, offset=None, hold=False):
"""
Makes time relation indicating that ``offset`` happens
when ``timespan`` stops.
.. container:: example
>>> relation = abjad.timespans.offset_happens_when_timespan_stops()
>>> abjad.f(relation)
abjad.timespans.OffsetTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('offset == timespan.stop'),
],
logical_operator='and',
),
)
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'offset == timespan.stop',
])
time_relation = timespans.OffsetTimespanTimeRelation(inequality,
timespan=timespan,
offset=offset)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def __init__(self, inequality=None):
from abjad import timespans
if not inequality:
inequality = timespans.CompoundInequality([
'timespan_1.start_offset < timespan_2.start_offset',
])
assert isinstance(
inequality, timespans.CompoundInequality), repr(inequality)
self._inequality = inequality
def timespan_2_happens_during_timespan_1(
timespan_1=None,
timespan_2=None,
hold=False,
):
"""
Makes time relation indicating that ``timespan_2`` happens during
``timespan_1``.
.. container:: example
>>> relation = abjad.timespans.timespan_2_happens_during_timespan_1()
>>> abjad.f(relation)
abjad.timespans.TimespanTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('timespan_1.start_offset <= timespan_2.start_offset'),
abjad.TimespanInequality('timespan_2.stop_offset <= timespan_1.stop_offset'),
],
logical_operator='and',
),
)
.. container:: example
Evaluates whether timespan ``[7/8, 8/8)`` happens during timespan
``[1/2, 3/2)``:
>>> timespan_1 = abjad.Timespan((1, 2), (3, 2))
>>> timespan_2 = abjad.Timespan((7, 8), (8, 8))
>>> abjad.timespans.timespan_2_happens_during_timespan_1(
... timespan_1=timespan_1,
... timespan_2=timespan_2,
... )
True
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'timespan_1.start_offset <= timespan_2.start_offset',
'timespan_2.stop_offset <= timespan_1.stop_offset',
])
time_relation = timespans.TimespanTimespanTimeRelation(
inequality,
timespan_1=timespan_1,
timespan_2=timespan_2,
)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def timespan_2_overlaps_only_stop_of_timespan_1(
timespan_1=None,
timespan_2=None,
hold=False,
):
"""
Makes time relation indicating that ``timespan_2`` overlaps
only stop of ``timespan_1``.
.. container:: example
>>> relation = abjad.timespans.timespan_2_overlaps_only_stop_of_timespan_1()
>>> abjad.f(relation)
abjad.timespans.TimespanTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('timespan_1.start_offset <= timespan_2.start_offset'),
abjad.TimespanInequality('timespan_2.start_offset < timespan_1.stop_offset'),
abjad.TimespanInequality('timespan_1.stop_offset < timespan_2.stop_offset'),
],
logical_operator='and',
),
)
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'timespan_1.start_offset <= timespan_2.start_offset',
'timespan_2.start_offset < timespan_1.stop_offset',
'timespan_1.stop_offset < timespan_2.stop_offset',
])
time_relation = timespans.TimespanTimespanTimeRelation(
inequality,
timespan_1=timespan_1,
timespan_2=timespan_2,
)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def timespan_2_stops_when_timespan_1_stops(
timespan_1=None,
timespan_2=None,
hold=False,
):
"""
Makes time relation indicating that ``timespan_2`` happens
during ``timespan_1``.
.. container:: example
>>> inequality = abjad.timespans.timespan_2_stops_when_timespan_1_stops()
>>> abjad.f(inequality)
abjad.timespans.TimespanTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('timespan_2.stop_offset == timespan_1.stop_offset'),
],
logical_operator='and',
),
)
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'timespan_2.stop_offset == timespan_1.stop_offset',
])
time_relation = timespans.TimespanTimespanTimeRelation(
inequality,
timespan_1=timespan_1,
timespan_2=timespan_2,
)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def timespan_2_starts_during_timespan_1(
timespan_1=None,
timespan_2=None,
hold=False,
):
"""
Makes time relation indicating that ``timespan_2`` starts
during ``timespan_1``.
.. container:: example
>>> relation = abjad.timespans.timespan_2_starts_during_timespan_1()
>>> abjad.f(relation)
abjad.timespans.TimespanTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('timespan_1.start_offset <= timespan_2.start_offset'),
abjad.TimespanInequality('timespan_2.start_offset < timespan_1.stop_offset'),
],
logical_operator='and',
),
)
.. container:: example
>>> staff_1 = abjad.Staff("c'4 d'4 e'4 f'4 g'2 c''2")
>>> staff_2 = abjad.Staff("c'2 b'2 a'2 g'2")
>>> score = abjad.Score([staff_1, staff_2])
>>> abjad.show(score) # doctest: +SKIP
>>> start_offsets = [
... abjad.inspect(note).timespan().start_offset
... for note in staff_1
... ]
>>> stop_offsets = [
... abjad.inspect(note).timespan().stop_offset
... for note in staff_1
... ]
>>> timespan_1 = abjad.Timespan((1, 4), (5, 4))
>>> time_relation = abjad.timespans.timespan_2_starts_during_timespan_1(
... timespan_1=timespan_1)
>>> start_index, stop_index = time_relation.get_offset_indices(
... start_offsets, stop_offsets)
>>> selected_notes = staff_1[start_index:stop_index]
>>> selected_notes
Selection([Note("d'4"), Note("e'4"), Note("f'4"), Note("g'2")])
>>> abjad.label(selected_notes).color_leaves('red')
>>> abjad.show(score) # doctest: +SKIP
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'timespan_1.start_offset <= timespan_2.start_offset',
'timespan_2.start_offset < timespan_1.stop_offset',
])
time_relation = timespans.TimespanTimespanTimeRelation(
inequality,
timespan_1=timespan_1,
timespan_2=timespan_2,
)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
def offset_happens_before_timespan_starts(
timespan=None,
offset=None,
hold=False,
):
"""
Makes time relation indicating that ``offset`` happens before ``timespan``
starts.
.. container:: example
Makes time relation indicating that ``offset`` happens before ``timespan``
starts:
>>> relation = abjad.timespans.offset_happens_before_timespan_starts()
>>> abjad.f(relation)
abjad.timespans.OffsetTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('offset < timespan.start'),
],
logical_operator='and',
),
)
.. container:: example
Makes time relation indicating that offset ``1/2`` happens before
``timespan`` starts:
>>> offset = abjad.Offset(1, 2)
>>> relation = abjad.timespans.offset_happens_before_timespan_starts(
... offset=offset)
>>> abjad.f(relation)
abjad.timespans.OffsetTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('offset < timespan.start'),
],
logical_operator='and',
),
offset=abjad.Offset(1, 2),
)
.. container:: example
Makes time relation indicating that ``offset`` happens before timespan
``[2, 8)`` starts:
>>> timespan = abjad.Timespan(2, 8)
>>> relation = abjad.timespans.offset_happens_before_timespan_starts(
... timespan=timespan)
>>> abjad.f(relation)
abjad.timespans.OffsetTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('offset < timespan.start'),
],
logical_operator='and',
),
timespan=abjad.Timespan(
start_offset=abjad.Offset(2, 1),
stop_offset=abjad.Offset(8, 1),
),
)
.. container:: example
Makes time relation indicating that offset ``1/2`` happens before
timespan ``[2, 8)`` starts:
>>> relation = abjad.timespans.offset_happens_before_timespan_starts(
... timespan=timespan,
... offset=offset,
... hold=True,
... )
>>> abjad.f(relation)
abjad.timespans.OffsetTimespanTimeRelation(
inequality=abjad.timespans.CompoundInequality(
[
abjad.TimespanInequality('offset < timespan.start'),
],
logical_operator='and',
),
timespan=abjad.Timespan(
start_offset=abjad.Offset(2, 1),
stop_offset=abjad.Offset(8, 1),
),
offset=abjad.Offset(1, 2),
)
.. container:: example
Evaluates time relation indicating that offset ``1/2`` happens before
timespan ``[2, 8)`` starts:
>>> abjad.timespans.offset_happens_before_timespan_starts(
... timespan=timespan,
... offset=offset,
... hold=False,
... )
True
Returns time relation or boolean.
"""
from abjad import timespans
inequality = timespans.CompoundInequality([
'offset < timespan.start',
])
time_relation = timespans.OffsetTimespanTimeRelation(inequality,
timespan=timespan,
offset=offset)
if time_relation.is_fully_loaded and not hold:
return time_relation()
else:
return time_relation
