def test_mathtools_NonreducedFraction___add___02():
result = abjad.NonreducedFraction(3, 3) + 1
assert result.pair == (6, 3)
result = 1 + abjad.NonreducedFraction(3, 3)
assert result.pair == (6, 3)
def test_Duration__group_by_implied_prolation_05():
fractions = [(1, 4), (1, 2), (1, 3)]
duration = abjad.Duration._group_by_implied_prolation(fractions)
assert duration == [
[abjad.NonreducedFraction(1, 4), abjad.NonreducedFraction(1, 2)],
[abjad.NonreducedFraction(1, 3)],
]
def test_mathtools_NonreducedFraction___add___01():
one = abjad.NonreducedFraction(1, 4)
two = abjad.NonreducedFraction(2, 8)
result = one + two
assert result.pair == (4, 8)
one = abjad.NonreducedFraction(2, 8)
two = abjad.NonreducedFraction(1, 4)
result = one + two
assert result.pair == (4, 8)
def test_mathtools_NonreducedFraction___add___03():
a = abjad.NonreducedFraction(3, 6)
b = abjad.NonreducedFraction(3, 12)
result_one = abjad.IOManager.count_function_calls(
'a + b', locals())
result_two = abjad.IOManager.count_function_calls(
'a + 10', locals())
assert result_one <= 110
assert result_two <= 110
def test_NonreducedFraction___add___03():
a = abjad.NonreducedFraction(3, 6)
b = abjad.NonreducedFraction(3, 12)
result_one = abjad.IOManager.count_function_calls("a + b",
global_context=locals())
result_two = abjad.IOManager.count_function_calls("a + 10",
global_context=locals())
assert result_one <= 110
assert result_two <= 110
def _duration_to_time_signature(
duration,
denominators=None,
factor=None,
):
import abjad
duration = abjad.Duration(duration)
if denominators is not None:
if factor is not None:
denominators = [
d for d in denominators
if factor in abjad.mathtools.factors(d)
]
for desired_denominator in sorted(denominators):
nonreduced_fraction = abjad.NonreducedFraction(duration)
candidate_pair = \
nonreduced_fraction.with_denominator(desired_denominator)
if candidate_pair.denominator == desired_denominator:
return abjad.TimeSignature(candidate_pair)
if factor is not None:
if factor in abjad.mathtools.factors(duration.denominator):
return abjad.TimeSignature(duration)
else:
time_signature_numerator = factor * duration.numerator
time_signature_denominator = factor * duration.denominator
return abjad.TimeSignature(
(time_signature_numerator, time_signature_denominator))
else:
return abjad.TimeSignature(duration)
def with_power_of_two_denominator(self, contents_multiplier=1):
r'''Makes new time signature equivalent to current
time signature with power-of-two denominator.
.. container:: example
Non-power-of-two denominator with power-of-two denominator:
>>> time_signature = abjad.TimeSignature((3, 12))
>>> time_signature.with_power_of_two_denominator()
TimeSignature((2, 8))
Returns new time signature.
'''
import abjad
contents_multiplier = abjad.Multiplier(contents_multiplier)
contents_multiplier = abjad.Multiplier(contents_multiplier)
non_power_of_two_denominator = self.denominator
if contents_multiplier == abjad.Multiplier(1):
power_of_two_denominator = \
abjad.mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator)
else:
power_of_two_denominator = \
abjad.mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator, 1)
non_power_of_two_pair = abjad.NonreducedFraction(self.pair)
power_of_two_fraction = non_power_of_two_pair.with_denominator(
power_of_two_denominator)
power_of_two_pair = power_of_two_fraction.pair
return type(self)(power_of_two_pair)
def test_scoretools_Tuplet_from_ratio_and_pair_22():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((99, )),
abjad.NonreducedFraction(6, 16),
)
assert str(tuplet) == 'Container("c\'4.")'
def test_scoretools_Tuplet_from_ratio_and_pair_24():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((-99, )),
abjad.NonreducedFraction(6, 16),
)
assert str(tuplet) == "Container('r4.')"
def __init__(
self,
degrees=None,
):
if degrees is not None:
self._degrees = abjad.NonreducedFraction(degrees, 90)
else:
self._degrees = degrees
def _conditionally_adjust_time_signature(self, old_denominator):
import abjad
if self.automatically_adjust_time_signature:
naive_time_signature = self._get_preprolated_duration()
better_time_signature = \
abjad.NonreducedFraction(naive_time_signature)
better_time_signature = \
better_time_signature.with_denominator(old_denominator)
better_time_signature = abjad.TimeSignature(better_time_signature)
abjad.detach(abjad.TimeSignature, self)
abjad.attach(better_time_signature, self)
def __call__(self, pitches, durations):
"""
Calls note-maker on ``pitches`` and ``durations``.
Returns selection.
"""
import abjad
if isinstance(pitches, str):
pitches = pitches.split()
if not isinstance(pitches, collections.Iterable):
pitches = [pitches]
if isinstance(durations, (numbers.Number, tuple)):
durations = [durations]
nonreduced_fractions = [abjad.NonreducedFraction(_) for _ in durations]
size = max(len(nonreduced_fractions), len(pitches))
nonreduced_fractions = abjad.sequence(nonreduced_fractions)
nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
pitches = abjad.sequence(pitches).repeat_to_length(size)
Duration = abjad.Duration
durations = Duration._group_by_implied_prolation(nonreduced_fractions)
result = []
for duration in durations:
# get factors in denominator of duration group duration not 1 or 2
factors = set(abjad.mathtools.factors(duration[0].denominator))
factors.discard(1)
factors.discard(2)
ps = pitches[0:len(duration)]
pitches = pitches[len(duration):]
if len(factors) == 0:
result.extend(
self._make_unprolated_notes(
ps,
duration,
decrease_monotonic=self.decrease_monotonic,
repeat_ties=self.repeat_ties,
))
else:
# compute prolation
denominator = duration[0].denominator
numerator = abjad.mathtools.greatest_power_of_two_less_equal(
denominator)
multiplier = (numerator, denominator)
ratio = 1 / abjad.Fraction(*multiplier)
duration = [ratio * abjad.Duration(d) for d in duration]
ns = self._make_unprolated_notes(
ps,
duration,
decrease_monotonic=self.decrease_monotonic,
repeat_ties=self.repeat_ties,
)
tuplet = abjad.Tuplet(multiplier, ns)
result.append(tuplet)
result = abjad.select(result)
return result
def duration(self):
r'''Gets duration of Scheme moment.
.. container:: example
>>> abjad.SchemeMoment((2, 68)).duration
NonreducedFraction(2, 68)
Returns nonreduced fraction.
'''
import abjad
return abjad.NonreducedFraction(self.value)
def __add__(self, argument):
r'''Adds time signature to `argument`.
.. container:: example
Adds two time signatures with the same denominator:
>>> abjad.TimeSignature((3, 4)) + abjad.TimeSignature((3, 4))
TimeSignature((6, 4))
.. container:: example
Adds two time signatures with different denominators:
>>> abjad.TimeSignature((3, 4)) + abjad.TimeSignature((6, 8))
TimeSignature((12, 8))
Returns new time signature in terms of greatest denominator.
Returns new time signature.
'''
import abjad
if not isinstance(argument, type(self)):
message = 'must be time signature: {!r}.'
message = message.format(argument)
raise Exception(message)
nonreduced_1 = abjad.NonreducedFraction(
self.numerator,
self.denominator,
)
nonreduced_2 = abjad.NonreducedFraction(
argument.numerator,
argument.denominator,
)
result = nonreduced_1 + nonreduced_2
result = type(self)((
result.numerator,
result.denominator,
))
return result
def make_desordre_measure(pitches) -> abjad.Container:
"""
Makes a measure composed of Désordre cells.
``pitches`` is a nested list of integers, like [[1, 2, 3], [2, 3, 4]].
"""
for sequence in pitches:
container = make_desordre_cell(sequence)
time_signature = abjad.inspect(container).duration()
time_signature = abjad.NonreducedFraction(time_signature)
leaf = abjad.inspect(container).leaf(0)
abjad.attach(time_signature, leaf)
return container
def from_string(string):
"""
Makes spacing section from fraction ``string``.
.. container:: example
>>> baca.SpacingSection.from_string('2/24')
SpacingSection(duration=NonreducedFraction(2, 24))
Returns new spacing section.
"""
duration = abjad.NonreducedFraction(string)
return SpacingSection(duration=duration)
def _coerce_divisions(divisions):
import abjad
divisions_ = []
for division in divisions:
if isinstance(division, abjad.NonreducedFraction):
divisions_.append(division)
else:
division = abjad.NonreducedFraction(division)
divisions_.append(division)
divisions = divisions_
prototype = abjad.NonreducedFraction
assert all(isinstance(_, prototype) for _ in divisions)
return divisions
def test_Tuplet_from_ratio_and_pair_17():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((1, -1, -1)), abjad.NonreducedFraction(3, 16))
assert format(tuplet) == abjad.String.normalize(r"""
\tweak text #tuplet-number::calc-fraction-text
\times 1/1 {
c'16
r16
r16
}
""")
def test_Tuplet_from_ratio_and_pair_03():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((-2, 3, 7)), abjad.NonreducedFraction(7, 16))
assert format(tuplet) == abjad.String.normalize(r"""
\tweak text #tuplet-number::calc-fraction-text
\times 7/12 {
r8
c'8.
c'4..
}
""")
def test_Tuplet_from_ratio_and_pair_01():
tuplet = abjad.Tuplet.from_ratio_and_pair(abjad.NonreducedRatio((1, 2, 4)),
abjad.NonreducedFraction(6, 16))
assert format(tuplet) == abjad.String.normalize(r"""
\tweak text #tuplet-number::calc-fraction-text
\times 6/7 {
c'16
c'8
c'4
}
""")
def make_desordre_measure(pitches) -> abjad.Container:
"""
Makes a measure composed of *Désordre cells*.
``pitches`` is a list of lists of number (e.g., [[1, 2, 3], [2, 3, 4]])
"""
for sequence in pitches:
container = make_desordre_cell(sequence)
time_signature = abjad.inspect(container).duration()
time_signature = abjad.NonreducedFraction(time_signature)
leaf = abjad.inspect(container).leaf(0)
abjad.attach(time_signature, leaf)
return container
def test_Tuplet_from_ratio_and_pair_04():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((7, 7, -4, -1)), abjad.NonreducedFraction(1, 4))
assert format(tuplet) == abjad.String.normalize(r"""
\times 16/19 {
c'16..
c'16..
r16
r64
}
""")
def _get_tuplet_multiplier(container):
parentage = abjad.get.parentage(container)
tuplets = [
component for component in parentage
if isinstance(component, abjad.Tuplet)
]
if tuplets == []:
return abjad.NonreducedFraction((1, 1))
multiplier = tuplets[0].multiplier
for tuplet in tuplets[1:]:
multiplier = multiplier.multiply_with_cross_cancelation(
tuplet.multiplier)
return multiplier
def test_Tuplet_from_ratio_and_pair_07():
tuplet = abjad.Tuplet.from_ratio_and_pair(abjad.NonreducedRatio((4, 8, 8)),
abjad.NonreducedFraction(12, 16))
assert format(tuplet) == abjad.String.normalize(r"""
\tweak text #tuplet-number::calc-fraction-text
\times 3/5 {
c'4
c'2
c'2
}
""")
def make_desordre_measure(pitches):
'''Makes a measure composed of *Désordre cells*.
`pitches` is a list of lists of number (e.g., [[1, 2, 3], [2, 3, 4]])
Returns a measure.
'''
for sequence in pitches:
container = abjad.demos.ligeti.make_desordre_cell(sequence)
time_signature = abjad.inspect(container).get_duration()
time_signature = abjad.NonreducedFraction(time_signature)
time_signature = time_signature.with_denominator(8)
measure = abjad.Measure(time_signature, [container])
return measure
def test_scoretools_Tuplet_from_ratio_and_pair_06():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((2, 4, 4)),
abjad.NonreducedFraction(12, 16),
)
assert format(tuplet) == abjad.String.normalize(r'''
\tweak text #tuplet-number::calc-fraction-text
\times 6/5 {
c'8
c'4
c'4
}
''')
def test_scoretools_Tuplet_from_ratio_and_pair_13():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((1, 2, 2)),
abjad.NonreducedFraction(6, 2),
)
assert format(tuplet) == abjad.String.normalize(r'''
\tweak text #tuplet-number::calc-fraction-text
\times 6/5 {
c'2
c'1
c'1
}
''')
def test_Tuplet_from_ratio_and_pair_14():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((1, 2, 2)),
abjad.NonreducedFraction(6, 4),
)
assert format(tuplet) == abjad.String.normalize(r"""
\tweak text #tuplet-number::calc-fraction-text
\times 6/5 {
c'4
c'2
c'2
}
""")
def t_DURATION(self, t):
r'-?[1-9]\d*(/[1-9]\d*)?'
import abjad
parts = t.value.partition('/')
if not parts[2]:
t.value = abjad.Duration(int(parts[0]))
else:
numerator, denominator = int(parts[0]), int(parts[2])
fraction = abjad.NonreducedFraction(numerator, denominator)
preprolated_duration = abjad.Duration(fraction)
if fraction.numerator == preprolated_duration.numerator:
t.value = preprolated_duration
else:
t.value = fraction
return t
def test_scoretools_Tuplet_from_ratio_and_pair_18():
tuplet = abjad.Tuplet.from_ratio_and_pair(
abjad.NonreducedRatio((1, 1, -1, -1)),
abjad.NonreducedFraction(4, 16),
)
assert format(tuplet) == abjad.String.normalize(r'''
\tweak text #tuplet-number::calc-fraction-text
\times 1/1 {
c'16
c'16
r16
r16
}
''')
