def test_get_leaf_18(): """ Does connect through asymmetrically nested tuplets. """ inner_tuplet = abjad.Tuplet((2, 3), "c'8 c'8 c'8") contents = [abjad.Note("c'4"), inner_tuplet, abjad.Note("c'4")] tuplet = abjad.Tuplet((2, 3), contents) assert abjad.lilypond(tuplet) == abjad.String.normalize( r""" \times 2/3 { c'4 \times 2/3 { c'8 c'8 c'8 } c'4 } """ ) assert abjad.get.leaf(tuplet[0], 1) is inner_tuplet[0] assert abjad.get.leaf(inner_tuplet[-1], 1) is tuplet[-1] assert abjad.get.leaf(tuplet[-1], -1) is inner_tuplet[-1] assert abjad.get.leaf(inner_tuplet[0], -1) is tuplet[0]
def test_scoretools_Mutation_splice_03(): r'''Splices tuplet after tuplet. ''' tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8") voice = abjad.Voice([tuplet]) beam = abjad.Beam() abjad.attach(beam, tuplet[:]) tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8") result = abjad.mutate(voice[-1]).splice( [tuplet], grow_spanners=True, ) assert format(voice) == abjad.String.normalize(r''' \new Voice { \times 2/3 { c'8 [ d'8 e'8 } \times 2/3 { c'8 d'8 e'8 ] } } ''') assert abjad.inspect(voice).is_well_formed() assert result == voice[:]
def test_scoretools_Mutation_fuse_08(): r'''Fuses fixed-multiplier tuplets with same multiplier in score. ''' tuplet_1 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8") beam = abjad.Beam() abjad.attach(beam, tuplet_1[:]) tuplet_2 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8 f'8 g'8") slur = abjad.Slur() abjad.attach(slur, tuplet_2[:]) voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r''' \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] } \tweak edge-height #'(0.7 . 0) \times 2/3 { c'8 ( d'8 e'8 f'8 g'8 ) } } ''') tuplets = voice[:] abjad.mutate(tuplets).fuse() assert format(voice) == abjad.String.normalize(r''' \new Voice { \tweak edge-height #'(0.7 . 0) \times 2/3 { c'8 [ d'8 e'8 ] c'8 ( d'8 e'8 f'8 g'8 ) } } ''') assert abjad.inspect(voice).is_well_formed()
def test_get_leaf_07(): """ Tuplets inside a voice. """ tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8") tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8") voice = abjad.Voice([tuplet_1, tuplet_2]) assert abjad.lilypond(voice) == abjad.String.normalize( r""" \new Voice { \times 2/3 { c'8 cs'8 d'8 } \times 2/3 { ef'8 e'8 f'8 } } """ ) assert abjad.get.leaf(tuplet_1[0], 1) is tuplet_1[1] assert abjad.get.leaf(tuplet_1[1], 1) is tuplet_1[2] assert abjad.get.leaf(tuplet_1[2], 1) is tuplet_2[0] assert abjad.get.leaf(tuplet_1[1], -1) is tuplet_1[0] assert abjad.get.leaf(tuplet_1[2], -1) is tuplet_1[1] assert abjad.get.leaf(tuplet_2[0], -1) is tuplet_1[2]
def test_Inspection_leaf_07(): """ Tuplets inside a voice. """ tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8") tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8") voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r""" \new Voice { \times 2/3 { c'8 cs'8 d'8 } \times 2/3 { ef'8 e'8 f'8 } } """) assert abjad.inspect(tuplet_1[0]).leaf(1) is tuplet_1[1] assert abjad.inspect(tuplet_1[1]).leaf(1) is tuplet_1[2] assert abjad.inspect(tuplet_1[2]).leaf(1) is tuplet_2[0] assert abjad.inspect(tuplet_1[1]).leaf(-1) is tuplet_1[0] assert abjad.inspect(tuplet_1[2]).leaf(-1) is tuplet_1[1] assert abjad.inspect(tuplet_2[0]).leaf(-1) is tuplet_1[2]
def test_Inspection_leaf_17(): """ Does connect in sequence of alternating tuplets and notes. """ notes = [abjad.Note(i, abjad.Duration(1, 8)) for i in range(3)] tuplet_1 = abjad.Tuplet((2, 3), notes) notes = [abjad.Note(i, abjad.Duration(1, 8)) for i in range(4, 7)] tuplet_2 = abjad.Tuplet((2, 3), notes) voice = abjad.Voice([tuplet_1, abjad.Note(3, (1, 8)), tuplet_2]) assert format(voice) == abjad.String.normalize(r""" \new Voice { \times 2/3 { c'8 cs'8 d'8 } ef'8 \times 2/3 { e'8 f'8 fs'8 } } """) assert abjad.inspect(tuplet_1[-1]).leaf(1) is voice[1] assert abjad.inspect(voice[1]).leaf(1) is tuplet_2[0] assert abjad.inspect(voice[1]).leaf(-1) is tuplet_1[-1] assert abjad.inspect(tuplet_2[0]).leaf(-1) is voice[1]
def test_Inspection_leaf_18(): """ Does connect through asymmetrically nested tuplets. """ inner_tuplet = abjad.Tuplet((2, 3), "c'8 c'8 c'8") contents = [abjad.Note("c'4"), inner_tuplet, abjad.Note("c'4")] tuplet = abjad.Tuplet((2, 3), contents) assert format(tuplet) == abjad.String.normalize(r""" \times 2/3 { c'4 \times 2/3 { c'8 c'8 c'8 } c'4 } """) assert abjad.inspect(tuplet[0]).leaf(1) is inner_tuplet[0] assert abjad.inspect(inner_tuplet[-1]).leaf(1) is tuplet[-1] assert abjad.inspect(tuplet[-1]).leaf(-1) is inner_tuplet[-1] assert abjad.inspect(inner_tuplet[0]).leaf(-1) is tuplet[0]
def test_scoretools_Inspection_get_leaf_07(): r'''Tuplets inside a voice. ''' tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8") tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8") voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r''' \new Voice { \times 2/3 { c'8 cs'8 d'8 } \times 2/3 { ef'8 e'8 f'8 } } ''') assert abjad.inspect(tuplet_1[0]).get_leaf(1) is tuplet_1[1] assert abjad.inspect(tuplet_1[1]).get_leaf(1) is tuplet_1[2] assert abjad.inspect(tuplet_1[2]).get_leaf(1) is tuplet_2[0] assert abjad.inspect(tuplet_1[1]).get_leaf(-1) is tuplet_1[0] assert abjad.inspect(tuplet_1[2]).get_leaf(-1) is tuplet_1[1] assert abjad.inspect(tuplet_2[0]).get_leaf(-1) is tuplet_1[2]
def test_Mutation_fuse_08(): """ Fuses fixed-multiplier tuplets with same multiplier in score. """ tuplet_1 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8") abjad.beam(tuplet_1[:]) tuplet_2 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8 f'8 g'8") abjad.slur(tuplet_2[:]) voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r""" \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] } \tweak edge-height #'(0.7 . 0) \times 2/3 { c'8 ( d'8 e'8 f'8 g'8 ) } } """), print(format(voice)) tuplets = voice[:] abjad.mutate(tuplets).fuse() assert format(voice) == abjad.String.normalize(r""" \new Voice { \tweak edge-height #'(0.7 . 0) \times 2/3 { c'8 [ d'8 e'8 ] c'8 ( d'8 e'8 f'8 g'8 ) } } """), print(format(voice)) assert abjad.inspect(voice).wellformed()
def test_scoretools_Mutation_fuse_09(): r'''Tuplets must carry same multiplier. ''' tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") tuplet_2 = abjad.Tuplet((4, 5), "c'8 d'8 e'8 f'8 g'8") tuplets = abjad.select([tuplet_1, tuplet_2]) assert pytest.raises(Exception, 'abjad.mutate(tuplets).fuse()')
def test_Staff___setitem___01(): staff = abjad.Staff([ abjad.Note("c'4"), abjad.Rest((1, 4)), abjad.Chord([2, 3, 4], (1, 4)), abjad.Skip((1, 4)), abjad.Tuplet((4, 5), "c'16 c'16 c'16 c'16"), ]) assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Note) assert isinstance(staff[1], abjad.Rest) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[1] = abjad.Chord([12, 13, 15], (1, 4)) assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Note) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[0] = abjad.Rest((1, 4)) assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[-2] = abjad.Tuplet((2, 3), "c'8 c'8 c'8") assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Tuplet) staff[-1] = abjad.Note(13, (1, 4)) assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Note) staff[-3] = abjad.Skip((1, 4)) assert len(staff) == 5 assert abjad.wf.wellformed(staff) assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Skip) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Note)
def test_scoretools_Staff___setitem___01(): staff = abjad.Staff([ abjad.Note("c'4"), abjad.Rest((1, 4)), abjad.Chord([2, 3, 4], (1, 4)), abjad.Skip((1, 4)), abjad.Tuplet((4, 5), 4 * abjad.Note(0, (1, 16))), ]) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Note) assert isinstance(staff[1], abjad.Rest) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[1] = abjad.Chord([12, 13, 15], (1, 4)) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Note) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[0] = abjad.Rest((1, 4)) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Skip) assert isinstance(staff[4], abjad.Tuplet) staff[-2] = abjad.Tuplet((2, 3), 3 * abjad.Note(0, (1, 8))) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Tuplet) staff[-1] = abjad.Note(13, (1, 4)) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Chord) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Note) staff[-3] = abjad.Skip((1, 4)) assert len(staff) == 5 assert abjad.inspect(staff).is_well_formed() assert isinstance(staff[0], abjad.Rest) assert isinstance(staff[1], abjad.Chord) assert isinstance(staff[2], abjad.Skip) assert isinstance(staff[3], abjad.Tuplet) assert isinstance(staff[4], abjad.Note)
def test_scoretools_Mutation_fuse_07(): r'''Fuses tuplets with same multiplier in score. ''' tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") beam = abjad.Beam() abjad.attach(beam, tuplet_1[:]) tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16") slur = abjad.Slur() abjad.attach(slur, tuplet_2[:]) voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r''' \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] } \times 2/3 { c'16 ( d'16 e'16 ) } } ''') tuplets = voice[:] abjad.mutate(tuplets).fuse() assert format(voice) == abjad.String.normalize(r''' \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] c'16 ( d'16 e'16 ) } } ''') assert abjad.inspect(voice).is_well_formed()
def test_get_timespan_21(): """ Offsets work on nested tuplets. """ tuplet_1 = abjad.Tuplet((1, 2), "c'8 d'8 e'8 f'8") contents = [abjad.Note("c'4"), tuplet_1, abjad.Note("c'4")] tuplet = abjad.Tuplet((2, 3), contents) assert abjad.get.timespan(tuplet[0]).start_offset == 0 * abjad.Offset(1, 6) assert abjad.get.timespan(tuplet[1]).start_offset == 1 * abjad.Offset(1, 6) assert abjad.get.timespan(tuplet[2]).start_offset == 2 * abjad.Offset(1, 6)
def test_Mutation_fuse_09(): """ Tuplets must carry same multiplier. """ tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") tuplet_2 = abjad.Tuplet((4, 5), "c'8 d'8 e'8 f'8 g'8") tuplets = abjad.select([tuplet_1, tuplet_2]) with pytest.raises(Exception): abjad.mutate(tuplets).fuse()
def test_Mutation_fuse_07(): """ Fuses tuplets with same multiplier in score. """ tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") abjad.beam(tuplet_1[:]) tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16") abjad.slur(tuplet_2[:]) voice = abjad.Voice([tuplet_1, tuplet_2]) assert format(voice) == abjad.String.normalize(r""" \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] } \times 2/3 { c'16 ( d'16 e'16 ) } } """), print(format(voice)) tuplets = voice[:] abjad.mutate(tuplets).fuse() assert format(voice) == abjad.String.normalize(r""" \new Voice { \times 2/3 { c'8 [ d'8 e'8 ] c'16 ( d'16 e'16 ) } } """), print(format(voice)) assert abjad.inspect(voice).wellformed()
def test_scoretools_Mutation_fuse_06(): r'''Fuses two unincorporated tuplets with same multiplier. ''' tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") beam = abjad.Beam() abjad.attach(beam, tuplet_1[:]) tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16") slur = abjad.Slur() abjad.attach(slur, tuplet_2[:]) assert format(tuplet_1) == abjad.String.normalize(r''' \times 2/3 { c'8 [ d'8 e'8 ] } ''') assert format(tuplet_2) == abjad.String.normalize(r''' \times 2/3 { c'16 ( d'16 e'16 ) } ''') tuplets = abjad.select([tuplet_1, tuplet_2]) new = abjad.mutate(tuplets).fuse() assert format(new) == abjad.String.normalize(r''' \times 2/3 { c'8 [ d'8 e'8 ] c'16 ( d'16 e'16 ) } ''') assert len(tuplet_1) == 0 assert len(tuplet_2) == 0 assert new is not tuplet_1 and new is not tuplet_2 assert abjad.inspect(new).is_well_formed()
def test_Mutation_fuse_06(): """ Fuses two unincorporated tuplets with same multiplier. """ tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") abjad.beam(tuplet_1[:]) tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16") abjad.slur(tuplet_2[:]) assert format(tuplet_1) == abjad.String.normalize(r""" \times 2/3 { c'8 [ d'8 e'8 ] } """), print(format(tuplet_1)) assert format(tuplet_2) == abjad.String.normalize(r""" \times 2/3 { c'16 ( d'16 e'16 ) } """), print(format(tuplet_2)) tuplets = abjad.select([tuplet_1, tuplet_2]) new = abjad.mutate(tuplets).fuse() assert format(new) == abjad.String.normalize(r""" \times 2/3 { c'8 [ d'8 e'8 ] c'16 ( d'16 e'16 ) } """), print(format(new)) assert len(tuplet_1) == 0 assert len(tuplet_2) == 0 assert new is not tuplet_1 and new is not tuplet_2 assert abjad.inspect(new).wellformed()
def test_scoretools_Inspection_get_timespan_21(): r'''Offsets work on nested tuplets. ''' tuplet_1 = abjad.Tuplet((1, 2), "c'8 d'8 e'8 f'8") contents = [abjad.Note("c'4"), tuplet_1, abjad.Note("c'4")] tuplet = abjad.Tuplet((2, 3), contents) assert abjad.inspect( tuplet[0]).get_timespan().start_offset == 0 * abjad.Offset(1, 6) assert abjad.inspect( tuplet[1]).get_timespan().start_offset == 1 * abjad.Offset(1, 6) assert abjad.inspect( tuplet[2]).get_timespan().start_offset == 2 * abjad.Offset(1, 6)
def test_get_timespan_19(): """ Offsets works on sequential tuplets. """ voice = abjad.Voice([ abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"), abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"), abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"), ]) assert abjad.get.timespan(voice[0]).start_offset == 0 * abjad.Offset(1, 4) assert abjad.get.timespan(voice[1]).start_offset == 1 * abjad.Offset(1, 4) assert abjad.get.timespan(voice[2]).start_offset == 2 * abjad.Offset(1, 4)
def test_scoretools_Inspection_get_timespan_09(): r'''Offset works on nested tuplets. ''' tuplet_1 = abjad.Tuplet((2, 3), "c'8 c'8 c'8") tuplet = abjad.Tuplet((2, 3), [abjad.Note("c'4"), tuplet_1, abjad.Note("c'4")]) offset = 0 durations = [(1, 6), (1, 18), (1, 18), (1, 18), (1, 6)] leaves = abjad.select(tuplet).leaves() for leaf, duration in zip(leaves, durations): assert abjad.inspect(leaf).get_timespan().start_offset == offset offset += abjad.Offset(*duration)
def test_scoretools_Tuplet___setattr___01(): r'''Slots constrain tuplet attributes. ''' tuplet = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8") assert pytest.raises(AttributeError, "tuplet.foo = 'bar'")
def test_Tuplet___copy___01(): tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8") abjad.override(tuplet_1).note_head.color = "red" assert format(tuplet_1) == abjad.String.normalize(r""" \override NoteHead.color = #red \times 2/3 { c'8 d'8 e'8 } \revert NoteHead.color """) tuplet_2 = copy.copy(tuplet_1) assert format(tuplet_2) == abjad.String.normalize(r""" \override NoteHead.color = #red \times 2/3 { } \revert NoteHead.color """) assert not len(tuplet_2)
def test_scoretools_Mutation_swap_06(): r'''Trying to move parentage, children and spanners from components that are not parent-contiguous raises exception. ''' voice = abjad.Voice("{ c'8 d'8 } { e'8 f'8 } { g'8 a'8 }") leaves = abjad.select(voice).leaves() beam = abjad.Beam() abjad.attach(beam, leaves) assert format(voice) == abjad.String.normalize(r''' \new Voice { { c'8 [ d'8 } { e'8 f'8 } { g'8 a'8 ] } } ''') tuplet = abjad.Tuplet((2, 3), []) statement = 'abjad.mutate([voice[0], voice[2]]).swap(tuplet)' assert pytest.raises(Exception, statement)
def retrograde(self, material_name): """Retrograde components in container.""" selection = abjad.Selection(self.container[:]).components( abjad.Container) for container in selection: if container.name is not None and material_name in container.name: items = abjad.Selection(container).items # print(container.components) new_container = abjad.Container(name=container.name) for item in reversed(items): for comp in reversed(item.components): if isinstance(comp, abjad.Tuplet): new_tuplet = abjad.Tuplet( multiplier=comp.multiplier, denominator=comp.denominator) for it in reversed(comp.components): new_tuplet.append(it) new_container.append(new_tuplet) elif isinstance(comp, abjad.Container): new_sub_container = abjad.Container() for it in reversed(comp.components): new_sub_container.append(it) new_container.append(new_sub_container) else: new_container.append(comp) for i, item in enumerate(container): container.remove(container[i]) container.append(new_container)
def multiply_by(n, note): new_n = deepcopy(note) new_n.written_duration /= 4 tup = abj.Tuplet(abj.Multiplier(2, n), []) for varied_note in vary(new_n, n): tup.append(varied_note) return tup
def test_Mutation_swap_06(): """ Trying to move parentage, children from components that are not parent-contiguous raises exception. """ voice = abjad.Voice("{ c'8 d'8 } { e'8 f'8 } { g'8 a'8 }") leaves = abjad.select(voice).leaves() abjad.beam(leaves) assert format(voice) == abjad.String.normalize(r""" \new Voice { { c'8 [ d'8 } { e'8 f'8 } { g'8 a'8 ] } } """) tuplet = abjad.Tuplet((2, 3), []) with pytest.raises(Exception): abjad.mutate([voice[0], voice[2]]).swap(tuplet)
def card_4(): # beaming still needs to be fixed div = (1, 8) trip = [abjad.Note(n, div) for n in ("G4", "Ab4", "G4")] notes = [abjad.Tuplet((2, 3), trip)] notes += [abjad.Note('F#4', (1, 8)), abjad.Rest('r8')] return notes
def recurse(node, tuplet_duration): basic_prolated_duration = \ tuplet_duration / node._get_contents_duration() basic_written_duration = \ basic_prolated_duration.equal_or_greater_power_of_two tuplet = abjad.Tuplet(1, []) for child in node.children: if isinstance(child, type(self)): tuplet.extend( recurse( child, child.preprolated_duration * basic_written_duration)) else: leaves = child(basic_written_duration) tuplet.extend(leaves) if 1 < len(leaves): abjad.tie(leaves) assert tuplet.multiplier == 1, repr(tuplet.multiplier) contents_duration = abjad.inspect(tuplet).duration() target_duration = tuplet_duration multiplier = target_duration / contents_duration tuplet.multiplier = multiplier if tuplet.multiplier == 1: return tuplet[:] return [tuplet]
def _make_container(self, division): import abjad duration_specifier = self._get_duration_specifier() forbidden_duration = \ duration_specifier.forbidden_duration time_signature = abjad.TimeSignature(division) implied_prolation = time_signature.implied_prolation numerator, denominator = division.pair denominator = abjad.mathtools.greatest_power_of_two_less_equal( denominator) assert abjad.mathtools.is_positive_integer_power_of_two(denominator) exponent = self.exponent or 0 denominator_multiplier = 2 ** exponent denominator *= denominator_multiplier unit_duration = abjad.Duration(1, denominator) if forbidden_duration is not None: multiplier = 1 while forbidden_duration <= unit_duration: unit_duration /= 2 multiplier *= 2 numerator *= multiplier numerator *= denominator_multiplier maker = abjad.NoteMaker() notes = maker(numerator * [0], [unit_duration]) if implied_prolation == 1: result = abjad.Container(notes) else: multiplier = implied_prolation result = abjad.Tuplet(multiplier, notes) return result