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