def __div__(self, *arguments):
"""
Divides duration by ``arguments``.
.. container:: example
>>> abjad.Duration(1) / abjad.NonreducedFraction(3, 3)
NonreducedFraction(3, 3)
>>> abjad.NonreducedFraction(3, 3) / abjad.Duration(1)
NonreducedFraction(3, 3)
Returns multiplier.
"""
import abjad
if len(arguments) == 1 and isinstance(arguments[0], type(self)):
fraction = Fraction.__truediv__(self, *arguments)
result = abjad.Multiplier(fraction)
elif len(arguments) == 1 and isinstance(
arguments[0], abjad.NonreducedFraction
):
result = arguments[0].__rdiv__(self)
else:
result = type(self)(Fraction.__truediv__(self, *arguments))
return result
def test_3(self):
# sf = SimpleFormat(durations=[Fraction(4) + Fraction(1, 2), Fraction(1, 2)])
sf = SimpleFormat(quarter_durations=[
Fraction(4, 1) +
Fraction(5, 7), Fraction(5, 7)
])
# sf = SimpleFormat(durations=[Fraction(4, 1) + Fraction(5, 7), Fraction(2, 7)])
v = sf.to_stream_voice()
v.add_to_score(self.score)
self.score.finish()
# print([chord.quarter_duration for chord in self.score.get_measure(2).get_part(1).chords])
# print([chord.tie_types for chord in self.score.get_measure(2).get_part(1).chords])
result_path = path + '_test_3'
self.score.write(path=result_path)
def test_1(self):
self.score.add_measure(TreeMeasure(time=(5, 4)))
sf = SimpleFormat(quarter_durations=[5])
v = sf.to_stream_voice(1)
v.add_to_score(self.score)
self.score.finish()
output = []
for measure in self.score.get_children_by_type(TreeMeasure):
for part in measure.get_children_by_type(TreePart):
for beat in part.get_beats():
output.append([ch.quarter_duration for ch in beat.chords])
result = [[Fraction(3, 1)], [], [], [Fraction(2, 1)], []]
self.assertEqual(output, result)
def __add__(self, *arguments):
"""
Adds duration to ``arguments``.
.. container:: example
Returns duration when ``arguments`` is a duration:
>>> duration_1 = abjad.Duration(1, 2)
>>> duration_2 = abjad.Duration(3, 2)
>>> duration_1 + duration_2
Duration(2, 1)
.. container:: example
Returns nonreduced fraction when ``arguments`` is a nonreduced
fraction:
>>> duration = abjad.Duration(1, 2)
>>> nonreduced_fraction = abjad.NonreducedFraction(3, 6)
>>> duration + nonreduced_fraction
NonreducedFraction(6, 6)
Returns duration.
"""
if len(arguments) == 1 and isinstance(
arguments[0], mathtools.NonreducedFraction
):
result = arguments[0].__radd__(self)
else:
result = type(self)(Fraction.__add__(self, *arguments))
return result
def __abs__(self, *arguments):
"""
Gets absolute value of duration.
Returns nonnegative duration.
"""
return type(self)(Fraction.__abs__(self, *arguments))
def test_4(self):
cf_1 = ChordField(
quarter_duration=10,
midi_generator=ValueGenerator(cycle([60, 61, 64, 66])),
long_ending_mode='self_extend',
short_ending_mode='self_shrink'
)
cf_2 = ChordField(
quarter_duration=3,
midi_generator=ValueGenerator(cycle([72, 73, 74, 73, 72])),
long_ending_mode='self_extend',
short_ending_mode='self_shrink'
)
breathe_unit = Fraction(1, 5)
breathe_breakpoints = (5 * breathe_unit, breathe_unit, 5 * breathe_unit)
breathe_proportions = [2, 4, 1, 7, 2]
breathe = Breathe(proportions=breathe_proportions,
quarter_duration=13,
breakpoints=breathe_breakpoints)
cfg = ChordField(duration_generator=breathe.duration_generator)
cfg.add_child(cf_1)
cfg.add_child(cf_2)
simple_format = SimpleFormat()
simple_format.extend(cf_1.simple_format)
simple_format.extend(cf_2.simple_format)
self.score.set_time_signatures(ceil(simple_format.quarter_duration))
simple_format.to_stream_voice().add_to_score(self.score)
xml_path = path + 'test_4.xml'
self.score.write(xml_path)
self.assertCompareFiles(xml_path)
def __ge__(self, argument):
r'''Is true when duration is greater than or equal to `argument`.
Otherwise false.
Returns true or false.
'''
return Fraction.__ge__(self, argument)
def __rpow__(self, *arguments):
"""
Raises ``arguments`` to the power of duration.
Returns new duration.
"""
return type(self)(Fraction.__rpow__(self, *arguments))
def __rsub__(self, *arguments):
"""
Subtracts duration from ``arguments``.
Returns new duration.
"""
return type(self)(Fraction.__rsub__(self, *arguments))
def __rtruediv__(self, *arguments):
"""
Documentation required.
Returns new duration.
"""
return type(self)(Fraction.__rtruediv__(self, *arguments))
def __rmul__(self, *arguments):
"""
Multiplies ``arguments`` by duration.
Returns new duration.
"""
return type(self)(Fraction.__rmul__(self, *arguments))
def __radd__(self, *arguments):
"""
Adds ``arguments`` to duration.
Returns new duration.
"""
return type(self)(Fraction.__radd__(self, *arguments))
def __rdiv__(self, *arguments):
"""
Divides ``arguments`` by duration.
Returns new duration.
"""
return type(self)(Fraction.__rdiv__(self, *arguments))
def __pos__(self, *arguments):
"""
Get positive duration.
Returns new duration.
"""
return type(self)(Fraction.__pos__(self, *arguments))
def __eq__(self, argument):
r'''Is true when duration equals `argument`.
Otherwise false.
Returns true or false.
'''
return Fraction.__eq__(self, argument)
def __mul__(self, *arguments):
"""
Duration multiplied by ``arguments``.
.. container:: example
Returns a new duration when ``arguments`` is a duration:
>>> duration_1 = abjad.Duration(1, 2)
>>> duration_2 = abjad.Duration(3, 2)
>>> duration_1 * duration_2
Duration(3, 4)
.. container:: example
Returns nonreduced fraction when ``arguments`` is a nonreduced
fraction:
>>> duration = abjad.Duration(1, 2)
>>> nonreduced_fraction = abjad.NonreducedFraction(3, 6)
>>> duration * nonreduced_fraction
NonreducedFraction(3, 12)
Returns duration or nonreduced fraction.
"""
if len(arguments) == 1 and isinstance(
arguments[0], mathtools.NonreducedFraction
):
result = arguments[0].__rmul__(self)
else:
result = type(self)(Fraction.__mul__(self, *arguments))
return result
def __neg__(self, *arguments):
"""
Negates duration.
Returns new duration.
"""
return type(self)(Fraction.__neg__(self, *arguments))
def __mod__(self, *arguments):
"""
Modulus operator applied to duration.
Returns duration.
"""
return type(self)(Fraction.__mod__(self, *arguments))
def __lt__(self, argument):
"""
Is true when duration is less than ``argument``.
Returns true or false.
"""
return Fraction.__lt__(self, argument)
def __gt__(self, argument):
"""
Is true when duration is greater than ``argument``.
Returns true or false.
"""
return Fraction.__gt__(self, argument)
def __rtruediv__(self, *arguments):
"""
Documentation required.
Returns new duration.
"""
return type(self)(Fraction.__rtruediv__(self, *arguments))
def __pow__(self, *arguments):
"""
Raises duration to ``arguments`` power.
Returns new duration.
"""
return type(self)(Fraction.__pow__(self, *arguments))
def __rsub__(self, *arguments):
"""
Subtracts duration from ``arguments``.
Returns new duration.
"""
return type(self)(Fraction.__rsub__(self, *arguments))
def __rmul__(self, *arguments):
"""
Multiplies ``arguments`` by duration.
Returns new duration.
"""
return type(self)(Fraction.__rmul__(self, *arguments))
def test_half_down(self):
w = HalfWave(quarter_duration=10,
proportions=[7, 5, 3, 1],
duration_units=[
Fraction(1, 7),
Fraction(1, 6),
Fraction(1, 5),
Fraction(1, 4)
],
min_midi=60,
max_midi=76,
direction='down',
show_last_note=True)
w.simple_format.to_stream_voice().add_to_score(self.score)
with self.file_path(path, 'half_down', 'xml') as xml_path:
self.score.write(xml_path)
def __eq__(self, argument):
"""
Is true when duration equals ``argument``.
Returns true or false.
"""
return Fraction.__eq__(self, argument)
def test_1(self):
proportions = (1, 3, 1, 5, 1)
breakpoints = (1, Fraction(1, 7), 1)
quarter_durations = [8, 12]
breathe = Breathe(proportions=proportions, breakpoints=breakpoints, quarter_duration=sum(quarter_durations),
quantize=1)
breathe.midi_generator = ValueGenerator(cycle([71]))
test_chord_field = ChordField(duration_generator=breathe.duration_generator.__deepcopy__())
for i in range(len(quarter_durations)):
quarter_duration = quarter_durations[i]
midi = 60 + i
test_chord_field.add_child(
ChordField(midi_generator=ValueGenerator(cycle([midi])), long_ending_mode='self_extend',
short_ending_mode='self_shrink', quarter_duration=quarter_duration))
test_chord_field_2 = ChordField(duration_generator=breathe.duration_generator.__deepcopy__())
for i in range(len(quarter_durations)):
quarter_duration = quarter_durations[i]
midi = 72 + i
test_chord_field_2.add_child(
ChordField(midi_generator=ValueGenerator(cycle([midi])), long_ending_mode='cut',
short_ending_mode='add_rest', quarter_duration=quarter_duration))
breathe.simple_format.to_stream_voice().add_to_score(score=self.score, part_number=1)
test_chord_field.simple_format.to_stream_voice().add_to_score(score=self.score, part_number=2)
simple_format = SimpleFormat()
for child in test_chord_field_2.children:
simple_format.extend(child.simple_format)
simple_format.to_stream_voice().add_to_score(score=self.score, part_number=3)
xml_path = path + '_test_1.xml'
self.score.write(xml_path)
self.assertCompareFiles(xml_path)
def test_units(self):
w = Wave(quarter_duration=13,
field_proportions=[1, 1],
show_last_note=True)
w.rising_field.proportions = [5, 4, 3, 2, 1]
w.rising_field.duration_units = [
Fraction(1, 7),
Fraction(1, 6),
Fraction(1, 5),
Fraction(1, 4)
]
w.falling_field.proportions = [5, 4, 3, 2, 1]
w.falling_field.duration_units = w.rising_field.duration_units
w.simple_format.to_stream_voice().add_to_score(self.score)
with self.file_path(path, 'units', 'xml') as xml_path:
self.score.write(xml_path)
def __rpow__(self, *arguments):
"""
Raises ``arguments`` to the power of duration.
Returns new duration.
"""
return type(self)(Fraction.__rpow__(self, *arguments))
def __add__(self, *arguments):
"""
Adds duration to ``arguments``.
.. container:: example
Returns duration when ``arguments`` is a duration:
>>> duration_1 = abjad.Duration(1, 2)
>>> duration_2 = abjad.Duration(3, 2)
>>> duration_1 + duration_2
Duration(2, 1)
.. container:: example
Returns nonreduced fraction when ``arguments`` is a nonreduced
fraction:
>>> duration = abjad.Duration(1, 2)
>>> nonreduced_fraction = abjad.NonreducedFraction(3, 6)
>>> duration + nonreduced_fraction
NonreducedFraction(6, 6)
Returns duration.
"""
if (
len(arguments) == 1 and
isinstance(arguments[0], mathtools.NonreducedFraction)
):
result = arguments[0].__radd__(self)
else:
result = type(self)(Fraction.__add__(self, *arguments))
return result
def __radd__(self, *arguments):
"""
Adds ``arguments`` to duration.
Returns new duration.
"""
return type(self)(Fraction.__radd__(self, *arguments))
def __eq__(self, argument):
"""
Is true when duration equals ``argument``.
Returns true or false.
"""
return Fraction.__eq__(self, argument)
def __pos__(self, *arguments):
"""
Get positive duration.
Returns new duration.
"""
return type(self)(Fraction.__pos__(self, *arguments))
def __pow__(self, *arguments):
"""
Raises duration to ``arguments`` power.
Returns new duration.
"""
return type(self)(Fraction.__pow__(self, *arguments))
def __mul__(self, *arguments):
"""
Duration multiplied by ``arguments``.
.. container:: example
Returns a new duration when ``arguments`` is a duration:
>>> duration_1 = abjad.Duration(1, 2)
>>> duration_2 = abjad.Duration(3, 2)
>>> duration_1 * duration_2
Duration(3, 4)
.. container:: example
Returns nonreduced fraction when ``arguments`` is a nonreduced
fraction:
>>> duration = abjad.Duration(1, 2)
>>> nonreduced_fraction = abjad.NonreducedFraction(3, 6)
>>> duration * nonreduced_fraction
NonreducedFraction(3, 12)
Returns duration or nonreduced fraction.
"""
if (
len(arguments) == 1 and
isinstance(arguments[0], mathtools.NonreducedFraction)
):
result = arguments[0].__rmul__(self)
else:
result = type(self)(Fraction.__mul__(self, *arguments))
return result
def __neg__(self, *arguments):
"""
Negates duration.
Returns new duration.
"""
return type(self)(Fraction.__neg__(self, *arguments))
def __lt__(self, argument):
"""
Is true when duration is less than ``argument``.
Returns true or false.
"""
return Fraction.__lt__(self, argument)
def __mod__(self, *arguments):
"""
Modulus operator applied to duration.
Returns duration.
"""
return type(self)(Fraction.__mod__(self, *arguments))
def __lt__(self, argument):
r'''Is true when duration is less than `argument`.
Otherwise false.
Returns true or false.
'''
return Fraction.__lt__(self, argument)
def __gt__(self, argument):
"""
Is true when duration is greater than ``argument``.
Returns true or false.
"""
return Fraction.__gt__(self, argument)
def __rdiv__(self, *arguments):
"""
Divides ``arguments`` by duration.
Returns new duration.
"""
return type(self)(Fraction.__rdiv__(self, *arguments))
def __abs__(self, *arguments):
"""
Gets absolute value of duration.
Returns nonnegative duration.
"""
return type(self)(Fraction.__abs__(self, *arguments))
def _generate_simple_format():
unit = Fraction(1, 2)
quarter_durations = [x * unit for x in range(1, 8)]
intervals = list(range(1, 7))
midis = dToX(intervals, first_element=60)
output = SimpleFormat(quarter_durations=quarter_durations, midis=midis)
return output
def periodic_float_to_fraction(s: str) -> Fraction:
"""
Convert a float with a periodic part to its fraction
Args:
s: the numer as string. Notate the periodic part
(for example 1/3=0.333...)
as 0.(3, without repetitions. For example, 2.83333... as 2.8(3
Returns:
the fraction which results in the same periodic float
Notation::
12.3(17 2.3171717...
123.45(67 123.45676767...
"""
s2 = s.replace("(", "")
x = float(s.replace("(", ""))
numDecimals = len(s2.split(".")[1])
lenPeriod = len(s.split("(")[1])
factorA = 10 ** numDecimals
factorB = 10 ** (numDecimals-lenPeriod)
den = factorA - factorB
num = int(x*factorA) - int(x*factorB)
return Fraction(num, den)
def fraction_range(start: number_t, stop: number_t = None, step: number_t = None
) -> Iterator[Fraction]:
""" Like range, but yielding Fractions """
if stop is None:
stopF = asFraction(start)
startF = Fraction(0)
else:
startF = asFraction(start)
stopF = asFraction(stop)
if step is None:
step = Fraction(1)
else:
step = asFraction(step)
while startF < stopF:
yield startF
startF += step
def test_5(self):
self.score.set_time_signatures(
[Fraction(3, 2)])
sf = SimpleFormat(quarter_durations=[0.666, 0.333, 0.5])
xml_path = path + '_test_5.xml'
sf.to_stream_voice().add_to_score(self.score)
self.score.get_score_parts()[0].max_division = 1
self.score.write(xml_path)
def __new__(class_, *arguments):
"""
Makes new duration.
"""
if len(arguments) == 1:
argument = arguments[0]
if type(argument) is class_:
return argument
if isinstance(argument, mathtools.NonreducedFraction):
return Fraction.__new__(class_, *argument.pair)
try:
return Fraction.__new__(class_, *argument)
except (AttributeError, TypeError):
pass
try:
return Fraction.__new__(class_, argument)
except (AttributeError, TypeError):
pass
if (
isinstance(argument, tuple)
and len(argument) == 2
and mathtools.is_integer_equivalent(argument[0])
and mathtools.is_integer_equivalent(argument[1])
and not argument[1] == 0
):
return Fraction.__new__(
class_, int(argument[0]), int(argument[1])
)
try:
return Fraction.__new__(class_, argument.duration)
except AttributeError:
pass
if isinstance(argument, str) and "/" not in argument:
result = Duration._initialize_from_lilypond_duration_string(
argument
)
return Fraction.__new__(class_, result)
if (
isinstance(argument, tuple)
and len(argument) == 1
and mathtools.is_integer_equivalent(argument[0])
):
return Fraction.__new__(class_, int(argument[0]))
else:
try:
return Fraction.__new__(class_, *arguments)
except TypeError:
pass
if mathtools.all_are_integer_equivalent_numbers(arguments):
return Fraction.__new__(class_, *[int(x) for x in arguments])
raise ValueError(f"can not construct duration: {arguments!r}.")
def _calculate_quarter_durations(self):
if self.proportions:
quarter_durations = [
(Fraction(Fraction(p), Fraction(sum(self.proportions)))) * Fraction(self.quarter_duration) for p in
self.proportions]
if self.duration_units:
quarter_durations = find_best_quantized_values(values=quarter_durations, units=self.duration_units,
check_sum=True)
if self.direction == 'down':
quarter_durations = quarter_durations[::-1]
self._quarter_durations = quarter_durations
if self.quarter_durations:
self._duration_generator = ValueGenerator(iter(self.quarter_durations), duration=self.quarter_duration,
value_mode='duration')
else:
self._duration_generator = None
def __divmod__(self, *arguments):
"""
Equals the pair (duration // ``arguments``, duration % ``arguments``).
Returns pair.
"""
truncated, residue = Fraction.__divmod__(self, *arguments)
truncated = type(self)(truncated)
residue = type(self)(residue)
return truncated, residue
def __sub__(self, *arguments):
"""
Subtracts ``arguments`` from duration.
.. container:: example
>>> abjad.Duration(1, 2) - abjad.NonreducedFraction(2, 8)
NonreducedFraction(2, 8)
>>> abjad.NonreducedFraction(4, 8) - abjad.Duration(1, 4)
NonreducedFraction(2, 8)
Returns new duration.
"""
if len(arguments) == 1 and isinstance(
arguments[0], mathtools.NonreducedFraction
):
return arguments[0].__rsub__(self)
else:
return type(self)(Fraction.__sub__(self, *arguments))
def __rmod__(self, *arguments):
"""
Documentation required.
"""
return type(self)(Fraction.__rmod__(self, *arguments))
