def test_rhythmmakertools_TaleaRhythmMaker_tie_split_notes_02():

    talea = rhythmmakertools.Talea(
        counts=[5],
        denominator=16,
        )
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        )

    divisions = [(3, 16), (5, 8), (4, 8), (7, 16)]
    result = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    measures = abjad.mutate(staff).replace_measure_contents(result)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 3/16
                c'8.
                ~
            }   % measure
            {   % measure
                \time 5/8
                c'8
                c'4
                ~
                c'16
                [
                c'8.
                ~
                ]
            }   % measure
            {   % measure
                \time 4/8
                c'8
                c'4
                ~
                c'16
                [
                c'16
                ~
                ]
            }   % measure
            {   % measure
                \time 7/16
                c'4
                c'8.
            }   % measure
        }
        '''
        )

    assert abjad.inspect(staff).is_well_formed()
コード例 #2
0
def test_rhythmmakertools_TieSpecifier_01():

    divisions = [(3, 8), (5, 16), (1, 4), (5, 16)]
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        burnish_specifier=rhythmmakertools.BurnishSpecifier(
            left_classes=[abjad.Rest, abjad.Note],
            left_counts=[1],
        ),
        extra_counts_per_division=[0, 1, 1],
        talea=rhythmmakertools.Talea(
            counts=[1, 2, 3],
            denominator=16,
        ),
        tie_specifier=rhythmmakertools.TieSpecifier(
            tie_across_divisions=True, ),
    )
    selections = rhythm_maker(divisions)
    staff = abjad.Staff(selections)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            \tweak text #tuplet-number::calc-fraction-text
            \times 1/1 {
                r16
                c'8
                [
                c'8.
                ~
                ]
            }
            \tweak text #tuplet-number::calc-fraction-text
            \times 5/6 {
                c'16
                [
                c'8
                c'8.
                ]
            }
            \times 4/5 {
                r16
                c'8
                [
                c'8
                ~
                ]
            }
            \tweak text #tuplet-number::calc-fraction-text
            \times 1/1 {
                c'16
                [
                c'16
                c'8
                c'16
                ]
            }
        }
        ''')
コード例 #3
0
def test_rhythmmakertools_DurationSpecifier_01():
    r'''DurationSpecifier does not leave parent references.
    '''

    beam_specifier = rhythmmakertools.BeamSpecifier(
        beam_each_division=True,
        beam_divisions_together=False,
        use_feather_beams=False,
        )

    duration_specifier = rhythmmakertools.DurationSpecifier(
        decrease_monotonic=True,
        forbid_meter_rewriting=False,
        rewrite_meter=True,
        spell_metrically='unassignable',
        )

    logical_tie_masks = [abjad.silence([0], 2)]

    talea = rhythmmakertools.Talea(counts=[1, 2, 3, 4], denominator=16)

    maker = rhythmmakertools.TaleaRhythmMaker(
        beam_specifier=beam_specifier,
        duration_specifier=duration_specifier,
        logical_tie_masks=logical_tie_masks,
        talea=talea,
        )

    divisions = [abjad.TimeSignature((3, 8)), abjad.TimeSignature((2, 4)), abjad.TimeSignature((5, 16))]

    result = maker(divisions)

    staff = abjad.Staff(result)

    assert format(staff) == abjad.String.normalize(
        r"""
        \new Staff
        {
            r16
            c'16
            ~
            [
            c'16
            ]
            r8.
            c'4
            r16
            c'16
            ~
            [
            c'16
            ]
            r16
            r8
            c'8.
        }
        """)
def test_rhythmmakertools_BurnishSpecifier_outer_divisions_only_02():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[-1],
        right_classes=[-1],
        left_counts=[1],
        right_counts=[1],
        outer_divisions_only=True,
        )

    talea = rhythmmakertools.Talea(
        counts=[1],
        denominator=4,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        burnish_specifier=burnish_specifier,
        extra_counts_per_division=[2],
        )

    divisions = [(3, 16), (3, 8)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 3/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 3/5 {
                    r4
                    c'16
                    ~
                }
            }   % measure
            {   % measure
                \time 3/8
                \tweak text #tuplet-number::calc-fraction-text
                \times 3/4 {
                    c'8.
                    c'4
                    r16
                }
            }   % measure
        }
        '''
        ), format(staff)
コード例 #5
0
def test_rhythmmakertools_TaleaRhythmMaker___call___02():

    talea = rhythmmakertools.Talea(
        counts=[-1, 4, -2, 3],
        denominator=16,
    )
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[3, 4],
        split_divisions_by_counts=[6],
    )

    divisions = [(2, 8), (5, 8)]
    result = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(result)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            {   % measure
                \time 2/8
                \times 4/7 {
                    r16
                    c'4
                    r8
                }
            }   % measure
            {   % measure
                \time 5/8
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'8
                    ~
                }
                \times 2/3 {
                    c'16
                    r16
                    c'4
                    r8
                    c'16
                    ~
                }
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'8
                }
            }   % measure
        }
        ''')
コード例 #6
0
def test_rhythmmakertools_TaleaRhythmMaker_read_talea_once_only_01():

    maker = rhythmmakertools.TaleaRhythmMaker(
        read_talea_once_only=True,
        talea=rhythmmakertools.Talea(
            counts=[1, 2, 3, 4],
            denominator=16,
        ),
    )

    divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
    string = 'maker(divisions)'
    assert pytest.raises(Exception, string)
def test_rhythmmakertools_BurnishSpecifier_outer_divisions_only_04():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[-1],
        right_classes=[-1],
        left_counts=[1],
        right_counts=[2],
        outer_divisions_only=True,
        )

    talea = rhythmmakertools.Talea(
        counts=[1],
        denominator=8,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        burnish_specifier=burnish_specifier,
        extra_counts_per_division=[],
        )

    divisions = [(8, 8)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 8/8
                r8
                c'8
                [
                c'8
                c'8
                c'8
                c'8
                ]
                r8
                r8
            }   % measure
        }
        '''
        ), format(staff)
コード例 #8
0
     forbid_repetitions=True,
     pitch_specifier=abbreviations.agitato_pitch_specifier,
     register_specifier=consort.RegisterSpecifier(
         base_pitch='G3',
         phrase_inflections=consort.RegisterInflection
             .zigzag(3)
             .reverse()
             .align(),
         segment_inflections=consort.RegisterInflection
             .descending(width=3)
             .align()
         ),
     ),
 rhythm_maker=consort.CompositeRhythmMaker(
     default=rhythmmakertools.TaleaRhythmMaker(
         extra_counts_per_division=[0, 0, 1],
         talea=rhythmmakertools.Talea(
             counts=[1, -1, 1, -2, 1, -3],
             denominator=16,
             ),
         ),
     last=rhythmmakertools.IncisedRhythmMaker(
         incise_specifier=rhythmmakertools.InciseSpecifier(
             fill_with_notes=False,
             prefix_counts=[1],
             prefix_talea=[1],
             talea_denominator=16,
             ),
         ),
     ),
 )
コード例 #9
0
            base_pitch='G3',
            phrase_inflections=consort.RegisterInflection.zigzag(6)
                .reverse().align(),
            segment_inflections=consort.RegisterInflection.descending(
                width=12).align()
            ),
        register_spread=6,
        ),
    rhythm_maker=rhythmmakertools.TaleaRhythmMaker(
        burnish_specifier=rhythmmakertools.BurnishSpecifier(
            left_classes=[scoretools.Rest],
            left_counts=[1, 1, 0],
            right_classes=[scoretools.Rest],
            right_counts=[1],
            ),
        extra_counts_per_division=[0, 0, 1],
        division_masks=[
            rhythmmakertools.SustainMask(
                pattern=patterntools.Pattern(
                    indices=[0],
                    period=3,
                    ),
                ),
            ],
        talea=rhythmmakertools.Talea(
            counts=[1, 1, 1, 1, 2],
            denominator=16,
            ),
        ),
    )
コード例 #10
0
            ),
        pitches_are_nonsemantic=True,
        ),
    rhythm_maker=rhythmmakertools.TaleaRhythmMaker(
        extra_counts_per_division=[0, 1, 2],
        talea=rhythmmakertools.Talea(
            counts=[
                1, 1, -1,
                1, 1, -1,
                1, 1, -2,
                1, 1, 1, 1, 1, 1, -1,
                1, 1, -2,
                1, 1, 1, -2,
                1, 1, -1,
                1, 1, 1, 1, 1, 1, 1, -1,
                1, 1, 1, -1,
                1, 1, 1, 1, -2,
                ],
            denominator=16,
            ),
        division_masks=[
            rhythmmakertools.SustainMask(
                pattern=patterntools.Pattern(
                    indices=[1],
                    period=2,
                    ),
                ),
            ],
        )
    )
def test_rhythmmakertools_BeamSpecifier_beam_each_division_01():
    r'''Beam each cell with a multipart beam spanner.
    '''

    talea = rhythmmakertools.Talea(
        counts=[1, 1, 1, -1, 2, 2],
        denominator=32,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[3, 4],
        )

    divisions = [(2, 16), (5, 16)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)
    score = abjad.Score([staff])
    abjad.setting(score).autoBeaming = False

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 2/16
                \times 4/7 {
                    c'32
                    [
                    c'32
                    c'32
                    ]
                    r32
                    c'16
                    [
                    c'32
                    ~
                    ]
                }
            }   % measure
            {   % measure
                \time 5/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 5/7 {
                    c'32
                    [
                    c'32
                    c'32
                    c'32
                    ]
                    r32
                    c'16
                    [
                    c'16
                    c'32
                    c'32
                    c'32
                    ]
                    r32
                    c'32
                }
            }   % measure
        }
        '''
        )
コード例 #12
0
def test_rhythmmakertools_BurnishSpecifier_02():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[0],
        middle_classes=[abjad.Rest],
        right_classes=[0],
        left_counts=[2],
        right_counts=[1],
    )

    talea = rhythmmakertools.Talea(
        counts=[1, 1, 2, 4],
        denominator=32,
    )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[0],
        burnish_specifier=burnish_specifier,
    )

    divisions = [(5, 16), (6, 16)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            {   % measure
                \time 5/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'32
                    [
                    c'32
                    ]
                    r16
                    r8
                    r32
                    c'32
                }
            }   % measure
            {   % measure
                \time 6/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'16
                    [
                    c'8
                    ]
                    r32
                    r32
                    r16
                    c'16
                }
            }   % measure
        }
        ''')
コード例 #13
0
     slur=consort.AttachmentExpression(
         attachments=spannertools.Slur(),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_contiguity()
             .by_length('>', 1)
             .by_leaf()
         ),
     ),
 color='darkyellow',
 pitch_handler=consort.PitchClassPitchHandler(
     deviations=[0, 0, 0, 0.5, 0, -0.5],
     forbid_repetitions=True,
     leap_constraint=6,
     pitch_specifier='d f d f d f c f bf d f df',
     register_specifier=consort.RegisterSpecifier(
         base_pitch='C4',
         segment_inflections=consort.RegisterInflection
             .zigzag(6)
             .reverse(),
         ),
     register_spread=3,
     ),
 rhythm_maker=rhythmmakertools.TaleaRhythmMaker(
     extra_counts_per_division=[0, 0, 1, 2, 0, 1],
     talea=rhythmmakertools.Talea(
         counts=[1, 1, -3, 2, 1, -2, 3, 1, -3],
         denominator=16,
         )
     ),
 )