def make_unordered_cells_sequence():

    result = []

    harmonic_walk = sequencetools.flatten_sequence(manifolds.etc.pitch.harmonic_walk)
    pitch_fields = manifolds.etc.pitch.pitch_fields
    timeslot_pitch_to_field_cell = \
        manifolds.etc.pitch._helpers.timeslot_pitch_to_field_cell

    len_walk = len(harmonic_walk)
    len_fields = len(pitch_fields)

    lcm = mathtools.least_common_multiple(len_walk, len_fields)

    assert lcm == 120

    harmonic_walk = sequencetools.repeat_list_to_length(harmonic_walk, lcm)

    for timeslot, pitch in enumerate(harmonic_walk):
        field_cell = timeslot_pitch_to_field_cell(timeslot, Pitch(pitch))
        result.append(field_cell)

    assert len(result) == 120
    assert len(sequencetools.flatten_sequence(result)) == 504

    return result
예제 #2
0
 def get_segment_desired_duration_in_seconds(self, segment_index, total_seconds):
     segment_proportions = self[segment_index]
     segment_total = sum(sequencetools.flatten_sequence(
         segment_proportions))
     ratio = durationtools.Multiplier(segment_total, self.total)
     desired_duration_in_seconds = ratio * total_seconds
     return desired_duration_in_seconds
예제 #3
0
 def _make_score(
     self,
     rhythm_maker,
     division_list,
     score_number_markup,
 ):
     lists = rhythm_maker(division_list)
     music = sequencetools.flatten_sequence(lists)
     measures = scoretools.make_spacer_skip_measures(division_list)
     time_signature_context = scoretools.Context(
         measures,
         context_name='TimeSignatureContext',
         name='TimeSignatureContext',
     )
     measures = scoretools.make_spacer_skip_measures(division_list)
     staff = scoretools.Staff(measures)
     set_(staff).instrument_name = score_number_markup
     staff.context_name = 'RhythmicStaff'
     staff.name = 'Note-entry staff'
     measures = mutate(staff).replace_measure_contents(music)
     score = scoretools.Score()
     score.append(time_signature_context)
     score.append(staff)
     self._add_final_bar_line(score)
     self._check_score(score)
     return score
def test_scoretools_make_repeated_skips_from_time_signatures_01():
    r'''Make repeated rests from list of integer pairs.
    '''

    rests = scoretools.make_repeated_rests_from_time_signatures([(2, 8), (3, 32)])
    assert len(rests) == 2

    rests = sequencetools.flatten_sequence(rests)
    staff = Staff(rests)

    r'''
    \new Staff {
        r8
        r8
        r32
        r32
        r32
    }
    '''

    assert format(staff) == stringtools.normalize(
        r'''
        \new Staff {
            r8
            r8
            r32
            r32
            r32
        }
        '''
        )
    assert inspect_(staff).is_well_formed()
def test_scoretools_make_repeated_rests_from_time_signatures_01():
    r'''Make repeated rests from list of integer pairs.
    '''

    rests = scoretools.make_repeated_rests_from_time_signatures(
        [(2, 8), (3, 32)])
    assert len(rests) == 2

    rests = sequencetools.flatten_sequence(rests)
    staff = Staff(rests)

    r'''
    \new Staff {
        r8
        r8
        r32
        r32
        r32
    }
    '''

    assert systemtools.TestManager.compare(
        staff,
        r'''
        \new Staff {
            r8
            r8
            r32
            r32
            r32
        }
        '''
        )
    assert inspect_(staff).is_well_formed()
예제 #6
0
 def _split_at_measure_boundaries(
     selections, 
     meters,
     use_messiaen_style_ties=False,
     ):
     from abjad.tools import metertools
     from abjad.tools import scoretools
     from abjad.tools import sequencetools
     from abjad.tools.topleveltools import inspect_
     from abjad.tools.topleveltools import mutate
     meters = [metertools.Meter(_) for _ in meters]
     durations = [durationtools.Duration(_) for _ in meters]
     music = sequencetools.flatten_sequence(selections)
     assert isinstance(music, list), repr(music)
     total_duration = sum(durations)
     music_duration = sum(inspect_(_).get_duration() for _ in music)
     assert total_duration == music_duration
     voice = scoretools.Voice(music)
     mutate(voice[:]).split(
         durations=durations,
         tie_split_notes=True,
         use_messiaen_style_ties=use_messiaen_style_ties,
         )
     selections = list(voice[:])
     return selections
예제 #7
0
def _flatten_at_indices_helper(sequence, indices, classes, depth):
    from abjad.tools import sequencetools
    if classes is None:
        classes = (list, tuple)
    if not isinstance(sequence, classes):
        raise TypeError()
    ltype = type(sequence)
    len_l = len(sequence)
    indices = [x if 0 <= x else len_l + x for x in indices]
    result = []
    for i, element in enumerate(sequence):
        if i in indices:
            try:
                flattened = sequencetools.flatten_sequence(
                    element,
                    classes=classes,
                    depth=depth,
                )
                result.extend(flattened)
            except:
                result.append(element)
        else:
            result.append(element)
    result = ltype(result)
    return result
def increase_sequence_elements_at_indices_by_addenda(sequence, addenda, indices):
    '''Increase `sequence` by `addenda` at `indices`:

    ::

        >>> sequence = [1, 1, 2, 3, 5, 5, 1, 2, 5, 5, 6]

    ::

        >>> sequencetools.increase_sequence_elements_at_indices_by_addenda(
        ...     sequence, [0.5, 0.5], [0, 4, 8])
        [1.5, 1.5, 2, 3, 5.5, 5.5, 1, 2, 5.5, 5.5, 6]

    Returns list.
    '''
    from abjad.tools import sequencetools

    # assert no overlaps
    tmp = sequencetools.flatten_sequence([range(i, len(addenda)) for i in indices])
    assert len(tmp) == len(set(tmp))

    result = sequence[:]

    for i in indices:
        for j in range(len(addenda)):
            result[i+j] += addenda[j]

    return result
예제 #9
0
 def __init__(
     self,
     calculation_rate=None,
     decay_scale=1,
     frequency_offset=0,
     frequency_scale=1,
     source=None,
     specifications=None,
     ):
     frequencies, amplitudes, decay_times = specifications
     assert len(frequencies)
     if not amplitudes:
         amplitudes = [1.0] * len(frequencies)
     elif not isinstance(amplitudes, collections.Sequence):
         amplitudes = [amplitudes] * len(frequencies)
     if not decay_times:
         decay_times = [1.0] * len(frequencies)
     elif not isinstance(decay_times, collections.Sequence):
         decay_times = [decay_times] * len(frequencies)
     specifications = sequencetools.zip_sequences(
         [frequencies, amplitudes, decay_times])
     specifications = sequencetools.flatten_sequence(specifications)
     specifications = tuple(specifications)
     UGen.__init__(
         self,
         calculation_rate=calculation_rate,
         decay_scale=decay_scale,
         frequency_offset=frequency_offset,
         frequency_scale=frequency_scale,
         source=source,
         specifications=specifications,
         )
예제 #10
0
 def to_osc_message(self, with_textual_osc_command=False):
     if with_textual_osc_command:
         request_id = self.request_command
     else:
         request_id = int(self.request_id)
     buffer_id = int(self.buffer_id)
     contents = [
         request_id,
         buffer_id,
         self.command_name,
         self.flags,
     ]
     if self.command_name in (
             'cheby',
             'sine1',
     ):
         coefficients = self.amplitudes
     elif self.command_name == 'sine2':
         coefficients = zip(
             self.amplitudes,
             self.frequencies,
         )
         coefficients = tuple(coefficients)
     elif self.command_name == 'sine3':
         coefficients = zip(
             self.amplitudes,
             self.frequencies,
             self.phases,
         )
         coefficients = tuple(coefficients)
     coefficients = sequencetools.flatten_sequence(coefficients)
     contents.extend(coefficients)
     message = osctools.OscMessage(*contents)
     return message
예제 #11
0
 def _make_score(
     self,
     rhythm_maker,
     division_list,
     score_number_markup,
     ):
     lists = rhythm_maker(division_list)
     selections = sequencetools.flatten_sequence(lists)
     measures = scoretools.make_spacer_skip_measures(division_list)
     time_signature_context = scoretools.Context(
         measures,
         context_name='TimeSignatureContext',
         name='TimeSignatureContext',
         )
     measures = scoretools.make_spacer_skip_measures(division_list)
     staff = scoretools.Staff(measures)
     set_(staff).instrument_name = score_number_markup
     staff.context_name = 'RhythmicStaff'
     staff.name = 'Note-entry staff'
     measures = mutate(staff).replace_measure_contents(selections)
     score = scoretools.Score()
     score.append(time_signature_context)
     score.append(staff)
     self._add_final_bar_line(score)
     self._check_score(score)
     return score
예제 #12
0
파일: Klank.py 프로젝트: lisongx/supriya
 def __init__(
     self,
     calculation_rate=None,
     decay_scale=1,
     frequency_offset=0,
     frequency_scale=1,
     source=None,
     specifications=None,
 ):
     frequencies, amplitudes, decay_times = specifications
     assert len(frequencies)
     if not amplitudes:
         amplitudes = [1.0] * len(frequencies)
     elif not isinstance(amplitudes, collections.Sequence):
         amplitudes = [amplitudes] * len(frequencies)
     if not decay_times:
         decay_times = [1.0] * len(frequencies)
     elif not isinstance(decay_times, collections.Sequence):
         decay_times = [decay_times] * len(frequencies)
     specifications = sequencetools.zip_sequences(
         [frequencies, amplitudes, decay_times])
     specifications = sequencetools.flatten_sequence(specifications)
     specifications = tuple(specifications)
     UGen.__init__(
         self,
         calculation_rate=calculation_rate,
         decay_scale=decay_scale,
         frequency_offset=frequency_offset,
         frequency_scale=frequency_scale,
         source=source,
         specifications=specifications,
     )
예제 #13
0
 def to_osc_message(self, with_textual_osc_command=False):
     if with_textual_osc_command:
         request_id = self.request_command
     else:
         request_id = int(self.request_id)
     buffer_id = int(self.buffer_id)
     contents = [
         request_id,
         buffer_id,
         self.command_name,
         self.flags,
         ]
     if self.command_name in (
         'cheby',
         'sine1',
         ):
         coefficients = self.amplitudes
     elif self.command_name == 'sine2':
         coefficients = zip(
             self.amplitudes,
             self.frequencies,
             )
         coefficients = tuple(coefficients)
     elif self.command_name == 'sine3':
         coefficients = zip(
             self.amplitudes,
             self.frequencies,
             self.phases,
             )
         coefficients = tuple(coefficients)
     coefficients = sequencetools.flatten_sequence(coefficients)
     contents.extend(coefficients)
     message = osctools.OscMessage(*contents)
     return message
예제 #14
0
 def _split_at_measure_boundaries(
     selections,
     meters,
     use_messiaen_style_ties=False,
 ):
     from abjad.tools import metertools
     from abjad.tools import scoretools
     from abjad.tools import sequencetools
     from abjad.tools.topleveltools import inspect_
     from abjad.tools.topleveltools import mutate
     meters = [metertools.Meter(_) for _ in meters]
     durations = [durationtools.Duration(_) for _ in meters]
     music = sequencetools.flatten_sequence(selections)
     assert isinstance(music, list), repr(music)
     total_duration = sum(durations)
     music_duration = sum(inspect_(_).get_duration() for _ in music)
     assert total_duration == music_duration
     voice = scoretools.Voice(music)
     mutate(voice[:]).split(
         durations=durations,
         tie_split_notes=True,
         use_messiaen_style_ties=use_messiaen_style_ties,
     )
     selections = list(voice[:])
     return selections
예제 #15
0
파일: RhythmMaker.py 프로젝트: ajyoon/abjad
 def _make_secondary_divisions(
     self,
     divisions,
     split_divisions_by_counts,
     ):
     if not split_divisions_by_counts:
         return divisions[:]
     numerators = [
         division.numerator
         for division in divisions
         ]
     secondary_numerators = sequencetools.split_sequence(
         numerators,
         split_divisions_by_counts,
         cyclic=True,
         overhang=True,
         )
     secondary_numerators = \
         sequencetools.flatten_sequence(secondary_numerators)
     denominator = divisions[0].denominator
     secondary_divisions = [
         (n, denominator)
         for n in secondary_numerators
         ]
     return secondary_divisions
예제 #16
0
def test_scoretools_make_repeated_rests_from_time_signatures_01():
    r'''Make repeated rests from list of integer pairs.
    '''

    rests = scoretools.make_repeated_rests_from_time_signatures(
        [(2, 8), (3, 32)])
    assert len(rests) == 2

    rests = sequencetools.flatten_sequence(rests)
    staff = Staff(rests)

    r'''
    \new Staff {
        r8
        r8
        r32
        r32
        r32
    }
    '''

    assert systemtools.TestManager.compare(
        staff,
        r'''
        \new Staff {
            r8
            r8
            r32
            r32
            r32
        }
        '''
        )
    assert inspect_(staff).is_well_formed()
예제 #17
0
 def __init__(
     self,
     divisions=None,
     instrument=None,
     name=None,
     rhythm_maker=None,
     stages=None,
     time_signatures=None
     ):
     assert(isinstance(instrument, instrumenttools.Instrument))
     assert(time_signatures is not None)
     self.divisions = divisions
     self._instrument = instrument
     self._name = name
     self.rhythm_maker = rhythm_maker
     if isinstance(stages, int):
         self.stages = (stages,)
     else:
         self._stages = stages
     self.time_signatures = sequencetools.flatten_sequence(time_signatures)
     # check that divisions and time signatures are the same duration
     if self.divisions is not None:
         divisions_fractions = [Duration(pair) for pair in divisions]
         divisions_sum = sum(divisions_fractions)
         time_sigs_fractions = [Duration(pair) for pair in self.time_signatures]
         time_sigs_sum = sum(time_sigs_fractions)
         assert divisions_sum == time_sigs_sum
예제 #18
0
def test_scoretools_make_repeated_skips_from_time_signatures_01():
    r'''Make repeated rests from list of integer pairs.
    '''

    rests = scoretools.make_repeated_rests_from_time_signatures([(2, 8),
                                                                 (3, 32)])
    assert len(rests) == 2

    rests = sequencetools.flatten_sequence(rests)
    staff = Staff(rests)
    r'''
    \new Staff {
        r8
        r8
        r32
        r32
        r32
    }
    '''

    assert format(staff) == stringtools.normalize(r'''
        \new Staff {
            r8
            r8
            r32
            r32
            r32
        }
        ''')
    assert inspect_(staff).is_well_formed()
예제 #19
0
def _flatten_at_indices_helper(sequence, indices, classes, depth):
    from abjad.tools import sequencetools
    if classes is None:
        classes = (list, tuple)
    if not isinstance(sequence, classes):
        raise TypeError()
    ltype = type(sequence)
    len_l = len(sequence)
    indices = [x if 0 <= x else len_l + x for x in indices]
    result = []
    for i, element in enumerate(sequence):
        if i in indices:
            try:
                flattened = sequencetools.flatten_sequence(
                    element,
                    classes=classes,
                    depth=depth,
                    )
                result.extend(flattened)
            except:
                result.append(element)
        else:
            result.append(element)
    result = ltype(result)
    return result
예제 #20
0
파일: spackle.py 프로젝트: trevorbaca/sekka
def spackle(m, grid, mask):
    '''Creates subdivision grid under m;
    subdivides sections in mask.
    '''

    grid = baca.tools.helianthate(grid, 1, 1)
    grid = sequencetools.repeat_to_length(grid, len(m.leaves))

    positions = [range(x[0], x[1] + 1) for x in mask]
    sequencetools.flatten_sequence(positions)
    positions = [
        pair[-1] if pair[0] in positions else 0
        for pair in enumerate(grid)
        ]
    #sekka.etc.transforms.subdivide(m, positions)
    baca.tools.abjad_subdivide(m, positions)
def test_notetools_make_repeated_notes_from_time_signatures_01():
    r'''Make repeated notes from list of integer pairs.
    '''

    notes = notetools.make_repeated_notes_from_time_signatures([(2, 8), (3, 32)], pitch = "d''")
    assert len(notes) == 2

    notes = sequencetools.flatten_sequence(notes)
    staff = Staff(notes)

    r'''
    \new Staff {
        d''8
        d''8
        d''32
        d''32
        d''32
    }
    '''

    assert testtools.compare(
        staff,
        r'''
        \new Staff {
            d''8
            d''8
            d''32
            d''32
            d''32
        }
        '''
        )
    assert inspect(staff).is_well_formed()
def test_rhythmmakertools_OutputIncisedRestRhythmMaker_03():

    prefix_talea, prefix_lengths = [], [0]
    suffix_talea, suffix_lengths = [], [0]
    talea_denominator = 4
    maker = rhythmmakertools.OutputIncisedRestRhythmMaker(
        prefix_talea, prefix_lengths, suffix_talea, suffix_lengths, talea_denominator)

    divisions = [(5, 8), (5, 8), (5, 8)]
    leaf_lists = maker(divisions)
    leaves = sequencetools.flatten_sequence(leaf_lists)

    staff = Staff(measuretools.make_measures_with_full_measure_spacer_skips(divisions))
    measuretools.replace_contents_of_measures_in_expr(staff, leaves)
    measuretools.set_always_format_time_signature_of_measures_in_expr(staff)

    r'''
    \new Staff {
        {
            \time 5/8
            r2
            r8
        }
        {
            \time 5/8
            r2
            r8
        }
        {
            \time 5/8
            r2
            r8
        }
    }
    '''

    assert testtools.compare(
        staff,
        r'''
        \new Staff {
            {
                \time 5/8
                r2
                r8
            }
            {
                \time 5/8
                r2
                r8
            }
            {
                \time 5/8
                r2
                r8
            }
        }
        '''
        )
def make_harmonic_walk_sections():

    harmonic_walk = manifolds.etc.pitch.harmonic_walk
    harmonic_walk = sequencetools.flatten_sequence(harmonic_walk)
    lengths = manifolds.etc.pitch.harmonic_walk_lengths
    sections = sequencetools.partition_by_lengths(harmonic_walk, lengths)
    sections = [tuple(x) for x in sections]

    return sections
예제 #24
0
    def __call__(self, expr):
        r'''Calls flatten division callback on `expr`.

        Returns list of divisions or list of division lists.
        '''
        return sequencetools.flatten_sequence(
            expr, 
            depth=self.depth,
            )
예제 #25
0
    def __call__(self, expr):
        r'''Calls flatten division callback on `expr`.

        Returns list of divisions or list of division lists.
        '''
        return sequencetools.flatten_sequence(
            expr,
            depth=self.depth,
        )
예제 #26
0
    def __call__(self, expr):
        r'''Iterates tuple `expr`.

        ..  todo:: Does this always return a tuple of selections?
        '''
        assert isinstance(expr, tuple), repr(tuple)
        return sequencetools.flatten_sequence(
            expr,
            depth=self.depth,
        )
    def __call__(self, expr):
        r'''Iterates tuple `expr`.

        ..  todo:: Does this always return a tuple of selections?
        '''
        assert isinstance(expr, tuple), repr(tuple)
        return sequencetools.flatten_sequence(
            expr, 
            depth=self.depth,
            )
예제 #28
0
def make_harmonic_walk():

    field_4 = manifolds.etc.pitch.pitch_fields[3]
    assert field_4 == (
        -20, -16, -12, -10, -8, -7, -5, -2, -0.5,
        0, 2, 3, 6, 9, 10, 13, 15, 20, 21, 25, 29, 30, 31)

    ## later dubbed 'polar values'
    walk = [
        13, 15, 21, 10,
        -12, -10, -0.5,
        -8, -7, 6,
        -2, 2, 3, 0, 9,
        -16, 29, -5, 30,
        -20, 20, 31, 25
    ]

    assert tuple(sorted(walk)) == field_4

    '''
    for i in range(1, 16):
        divisors = mathtools.divisors(16 * i)
        z_divisors = [x for x in divisors if not 16 in mathtools.divisors(x)]
        print '%s\t%s\t%s' % (i, 16 * i, z_divisors)

    1         16        [1, 2, 4, 8]
    2         32        [1, 2, 4, 8]
    3         48        [1, 2, 3, 4, 6, 8, 12, 24]
    4         64        [1, 2, 4, 8]
    5         80        [1, 2, 4, 5, 8, 10, 20, 40]
    6         96        [1, 2, 3, 4, 6, 8, 12, 24]
    7         112      [1, 2, 4, 7, 8, 14, 28, 56]
    8         128      [1, 2, 4, 8]
    9         144      [1, 2, 3, 4, 6, 8, 9, 12, 18, 24, 36, 72]
    10        160      [1, 2, 4, 5, 8, 10, 20, 40]
    11        176      [1, 2, 4, 8, 11, 22, 44, 88]
    12        192      [1, 2, 3, 4, 6, 8, 12, 24]
    13        208      [1, 2, 4, 8, 13, 26, 52, 104]
    14        224      [1, 2, 4, 7, 8, 14, 28, 56]
    15        240      [1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120]
    '''

    indicators = []
    for i in range(23):
        if i % 5 == 0:
            indicators.append((i, 1, 5))
        elif i % 4 == 0:
            indicators.append((i, 1, 3))

    walk = sequencetools.repeat_subruns_to_count(walk, indicators)

    assert len(walk) == 32
    assert len(sequencetools.flatten_sequence(walk)) == 60

    return walk
def test_rhythmmakertools_OutputBurnishedTaleaRhythmMaker___call___04():

    talea, talea_denominator, prolation_addenda  = [1], 8, []
    lefts, middles, rights = [-1], [0], [-1]
    left_lengths, right_lengths = [1], [2]
    maker = rhythmmakertools.OutputBurnishedTaleaRhythmMaker(
        talea, talea_denominator, prolation_addenda,
        lefts, middles, rights,
        left_lengths, right_lengths)

    divisions = [(8, 8)]
    music = maker(divisions)

    music = sequencetools.flatten_sequence(music)
    staff = Staff(measuretools.make_measures_with_full_measure_spacer_skips(divisions))
    measuretools.replace_contents_of_measures_in_expr(staff, music)

    r'''
    \new Staff {
        {
            \time 8/8
            r8
            c'8
            c'8
            c'8
            c'8
            c'8
            r8
            r8
        }
    }
    '''

    assert testtools.compare(
        staff,
        r'''
        \new Staff {
            {
                \time 8/8
                r8
                c'8
                c'8
                c'8
                c'8
                c'8
                r8
                r8
            }
        }
        '''
        )
예제 #30
0
def make_lilypond_file(music, divisions, implicit_scaling=False):
    r'''Makes LilyPond file.

    ..  container::

        ::

            >>> maker = rhythmmakertools.EvenRunRhythmMaker(1)
            >>> divisions = [(3, 4), (4, 8), (1, 4)]
            >>> music = maker(divisions)
            >>> lilypond_file = rhythmmakertools.make_lilypond_file(
            ...     music,
            ...     divisions,
            ...     )
            >>> show(lilypond_file) # doctest: +SKIP

    Used in rhythm-maker docs.

    Returns LilyPond file.
    '''

    assert isinstance(music, list), repr(music)
    prototype = (selectiontools.Selection, scoretools.Tuplet)
    assert all(isinstance(x, prototype) for x in music), repr(music)
    assert isinstance(divisions, (tuple, list)), repr(divisions)

    score = scoretools.Score()
    lilypond_file = \
        lilypondfiletools.make_floating_time_signature_lilypond_file(score)

    context = scoretools.Context(context_name='TimeSignatureContext')
    measures = scoretools.make_spacer_skip_measures(
        divisions,
        implicit_scaling=implicit_scaling,
        )
    context.extend(measures)
    score.append(context)

    measures = scoretools.make_spacer_skip_measures(
        divisions,
        implicit_scaling=implicit_scaling,
        )
    staff = scoretools.Staff(measures)
    staff.context_name = 'RhythmicStaff'
    music = sequencetools.flatten_sequence(music)

    measures = mutate(staff).replace_measure_contents(music)
    score.append(staff)

    return lilypond_file
예제 #31
0
 def __init__(self):
     self.cur_marimba_descent_pitch_index = 0
     self.cur_pitch_1_index = 0
     self.cur_pitch_2_index = 0
     self.cur_sargasso_pitch_index = 0
     self.cur_serration_pitch_index = 0
     self.cur_white_vocalization_index = 0
     self.known_tropes = {}
     white_vocalizations = baca.tools.helianthate(
         [['s', 's', 'š'], ['f', 'f', 's', 'š']], 1, 1)
     white_vocalizations = sequencetools.flatten_sequence(
         white_vocalizations)
     white_vocalizations = sequencetools.CyclicTuple(white_vocalizations)
     self.white_vocalizations = white_vocalizations
예제 #32
0
 def _make_secondary_duration_pairs(
     self, duration_pairs, secondary_divisions):
     if not secondary_divisions:
         return duration_pairs[:]
     numerators = [duration_pair.numerator 
         for duration_pair in duration_pairs]
     secondary_numerators = sequencetools.split_sequence_by_weights(
         numerators, secondary_divisions, cyclic=True, overhang=True)
     secondary_numerators = \
         sequencetools.flatten_sequence(secondary_numerators)
     denominator = duration_pairs[0].denominator
     secondary_duration_pairs = \
         [(n, denominator) for n in secondary_numerators]
     return secondary_duration_pairs
예제 #33
0
def make_lilypond_file(music, divisions, implicit_scaling=False):
    r'''Makes LilyPond file.

    ..  container::

        ::

            >>> maker = rhythmmakertools.EvenRunRhythmMaker(1)
            >>> divisions = [(3, 4), (4, 8), (1, 4)]
            >>> music = maker(divisions)
            >>> lilypond_file = rhythmmakertools.make_lilypond_file(
            ...     music,
            ...     divisions,
            ...     )
            >>> show(lilypond_file) # doctest: +SKIP

    Used in rhythm-maker docs.

    Returns LilyPond file.
    '''

    assert isinstance(music, list), repr(music)
    prototype = (selectiontools.Selection, scoretools.Tuplet)
    assert all(isinstance(x, prototype) for x in music), repr(music)
    assert isinstance(divisions, (tuple, list)), repr(divisions)

    score = scoretools.Score()
    lilypond_file = \
        lilypondfiletools.make_floating_time_signature_lilypond_file(score)

    context = scoretools.Context(context_name='TimeSignatureContext')
    measures = scoretools.make_spacer_skip_measures(
        divisions,
        implicit_scaling=implicit_scaling,
    )
    context.extend(measures)
    score.append(context)

    measures = scoretools.make_spacer_skip_measures(
        divisions,
        implicit_scaling=implicit_scaling,
    )
    staff = scoretools.Staff(measures)
    staff.context_name = 'RhythmicStaff'
    music = sequencetools.flatten_sequence(music)

    measures = mutate(staff).replace_measure_contents(music)
    score.append(staff)

    return lilypond_file
예제 #34
0
 def _split_at_measure_boundaries(
     selections, 
     meters,
     use_messiaen_style_ties=False,
     ):
     from abjad.tools import metertools
     from abjad.tools import scoretools
     from abjad.tools import sequencetools
     from abjad.tools.topleveltools import inspect_
     from abjad.tools.topleveltools import mutate
     from abjad.tools.topleveltools import select
     meters = [metertools.Meter(_) for _ in meters]
     durations = [durationtools.Duration(_) for _ in meters]
     selections = sequencetools.flatten_sequence(selections)
     assert isinstance(selections, list), repr(selections)
     meter_duration = sum(durations)
     music_duration = sum(inspect_(_).get_duration() for _ in selections)
     if not meter_duration == music_duration:
         message = 'Duration of meters is {!s}'
         message += ' but duration of selections is {!s}:'
         message = message.format(meter_duration, music_duration)
         message += '\nmeters: {}.'.format(meters)
         message += '\nmusic: {}.'.format(selections)
         raise Exception(message)
     voice = scoretools.Voice(selections)
     mutate(voice[:]).split(
         durations=durations,
         tie_split_notes=True,
         use_messiaen_style_ties=use_messiaen_style_ties,
         )
     #raise Exception(voice)
     #selections = list(voice[:])
     #return selections
     components = mutate(voice).eject_contents()
     component_durations = [inspect_(_).get_duration() for _ in components]
     parts = sequencetools.partition_sequence_by_weights(
         component_durations,
         weights=durations,
         allow_part_weights=Exact,
         )
     part_lengths = [len(_) for _ in parts]
     parts = sequencetools.partition_sequence_by_counts(
         components,
         counts=part_lengths,
         overhang=Exact,
         )
     selections = [select(_) for _ in parts]
     return selections
예제 #35
0
def increase_elements(sequence, addenda, indices=None):
    '''Increases `sequence` cyclically by `addenda`.

    ..  container:: example

        Increases elements cyclically by ``10`` and ``-10`` in alternation:

        ::

            >>> sequencetools.increase_elements(range(10), [10, -10])
            [10, -9, 12, -7, 14, -5, 16, -3, 18, -1]

    ..  container:: example

        Increases elements by ``0.5`` at indices 0, 4 and 8 and at one element
        following each:

        ::

            >>> sequence = [1, 1, 2, 3, 5, 5, 1, 2, 5, 5, 6]
            >>> sequencetools.increase_elements(
            ...     sequence, [0.5, 0.5], indices=[0, 4, 8])
            [1.5, 1.5, 2, 3, 5.5, 5.5, 1, 2, 5.5, 5.5, 6]

    Returns list.
    '''
    from abjad.tools import sequencetools

    prototype = (collections.Sequence, types.GeneratorType)
    if not isinstance(sequence, prototype):
        raise TypeError(sequence)

    if indices is None:
        result = []
        for i, element in enumerate(sequence):
            new = element + addenda[i % len(addenda)]
            result.append(new)
    else:
        # assert no overlaps
        tmp = [tuple(range(i, len(addenda))) for i in indices]
        tmp = sequencetools.flatten_sequence(tmp)
        assert len(tmp) == len(set(tmp))
        result = sequence[:]
        for i in indices:
            for j in range(len(addenda)):
                result[i + j] += addenda[j]

    return result
 def _split_at_measure_boundaries(
     selections,
     meters,
     use_messiaen_style_ties=False,
 ):
     from abjad.tools import metertools
     from abjad.tools import scoretools
     from abjad.tools import sequencetools
     from abjad.tools.topleveltools import inspect_
     from abjad.tools.topleveltools import mutate
     from abjad.tools.topleveltools import select
     meters = [metertools.Meter(_) for _ in meters]
     durations = [durationtools.Duration(_) for _ in meters]
     selections = sequencetools.flatten_sequence(selections)
     assert isinstance(selections, list), repr(selections)
     meter_duration = sum(durations)
     music_duration = sum(inspect_(_).get_duration() for _ in selections)
     if not meter_duration == music_duration:
         message = 'Duration of meters is {!s}'
         message += ' but duration of selections is {!s}:'
         message = message.format(meter_duration, music_duration)
         message += '\nmeters: {}.'.format(meters)
         message += '\nmusic: {}.'.format(selections)
         raise Exception(message)
     voice = scoretools.Voice(selections)
     mutate(voice[:]).split(
         durations=durations,
         tie_split_notes=True,
         use_messiaen_style_ties=use_messiaen_style_ties,
     )
     #raise Exception(voice)
     #selections = list(voice[:])
     #return selections
     components = mutate(voice).eject_contents()
     component_durations = [inspect_(_).get_duration() for _ in components]
     parts = sequencetools.partition_sequence_by_weights(
         component_durations,
         weights=durations,
         allow_part_weights=Exact,
     )
     part_lengths = [len(_) for _ in parts]
     parts = sequencetools.partition_sequence_by_counts(
         components,
         counts=part_lengths,
         overhang=Exact,
     )
     selections = [select(_) for _ in parts]
     return selections
예제 #37
0
 def add_division_lists_to_score(self):
     from experimental.tools import musicexpressiontools
     for voice in iterate(self.score).by_class(scoretools.Voice):
         voice_division_list = \
             musicexpressiontools.DivisionList([], voice_name=voice.name)
         voice_proxy = \
             self.score_specification.voice_data_structures_by_voice[
                 voice.name]
         expressions = \
             voice_proxy.payload_expressions_by_attribute['divisions']
         divisions = [x.payload.divisions for x in expressions]
         divisions = sequencetools.flatten_sequence(divisions, depth=1)
         for division in divisions:
             division = copy.deepcopy(division)
             voice_division_list.divisions.append(division)
         voice_proxy._voice_division_list = voice_division_list
예제 #38
0
 def add_division_lists_to_score(self):
     from experimental.tools import musicexpressiontools
     for voice in iterate(self.score).by_class(scoretools.Voice):
         voice_division_list = \
             musicexpressiontools.DivisionList([], voice_name=voice.name)
         voice_proxy = \
             self.score_specification.voice_data_structures_by_voice[
                 voice.name]
         expressions = \
             voice_proxy.payload_expressions_by_attribute['divisions']
         divisions = [x.payload.divisions for x in expressions]
         divisions = sequencetools.flatten_sequence(divisions, depth=1)
         for division in divisions:
             division = copy.deepcopy(division)
             voice_division_list.divisions.append(division)
         voice_proxy._voice_division_list = voice_division_list
예제 #39
0
 def _gallery_input_block_to_score(self, block):
     from abjad.tools import sequencetools
     maker = type(self)(**block.input_)
     lists = maker(block.divisions)
     music = sequencetools.flatten_sequence(lists)
     measures = scoretools.make_spacer_skip_measures(block.divisions)
     time_signature_context = scoretools.Context(
         measures,
         context_name='TimeSignatureContext',
         name='TimeSignatureContext',
         )
     measures = scoretools.make_spacer_skip_measures(block.divisions)
     staff = scoretools.RhythmicStaff(measures)
     measures = mutate(staff).replace_measure_contents(music)
     score = scoretools.Score()
     score.append(time_signature_context)
     score.append(staff)
     return score
예제 #40
0
 def _make_secondary_divisions(
     self,
     divisions,
     split_divisions_by_counts,
 ):
     if not split_divisions_by_counts:
         return divisions[:]
     numerators = [division.numerator for division in divisions]
     secondary_numerators = sequencetools.split_sequence(
         numerators,
         split_divisions_by_counts,
         cyclic=True,
         overhang=True,
     )
     secondary_numerators = \
         sequencetools.flatten_sequence(secondary_numerators)
     denominator = divisions[0].denominator
     secondary_divisions = [(n, denominator) for n in secondary_numerators]
     return secondary_divisions
예제 #41
0
    def register(self, pitch_classes):
        '''Registers `pitch_classes` by pitch set.

        ..  container:: example

            ::

                >>> pitch_set = pitchtools.PitchSet(
                ...     items=[10, 19, 20, 23, 24, 26, 27, 29, 30, 33, 37, 40],
                ...     item_class=pitchtools.NumberedPitch,
                ...     )
                >>> pitch_classes = [10, 0, 2, 6, 8, 7, 5, 3, 1, 9, 4, 11]
                >>> pitches = pitch_set.register(pitch_classes)
                >>> for pitch in pitches:
                ...     pitch
                NumberedPitch(10)
                NumberedPitch(24)
                NumberedPitch(26)
                NumberedPitch(30)
                NumberedPitch(20)
                NumberedPitch(19)
                NumberedPitch(29)
                NumberedPitch(27)
                NumberedPitch(37)
                NumberedPitch(33)
                NumberedPitch(40)
                NumberedPitch(23)

        Returns list of zero or more numbered pitches.
        '''
        if isinstance(pitch_classes, list):
            result = [
                [_ for _ in self if _.pitch_number % 12 == pc]
                for pc in [x % 12 for x in pitch_classes]
                ]
            result = sequencetools.flatten_sequence(result)
        elif isinstance(pitch_classes, int):
            result = [p for p in pitch_classes if p % 12 == pitch_classes][0]
        else:
            message = 'must be pitch-class or list of pitch-classes.'
            raise TypeError(message)
        return result
예제 #42
0
    def register(self, pitch_classes):
        '''Registers `pitch_classes` by pitch set.

        ..  container:: example

            ::

                >>> pitch_set = pitchtools.PitchSet(
                ...     items=[10, 19, 20, 23, 24, 26, 27, 29, 30, 33, 37, 40],
                ...     item_class=pitchtools.NumberedPitch,
                ...     )
                >>> pitch_classes = [10, 0, 2, 6, 8, 7, 5, 3, 1, 9, 4, 11]
                >>> pitches = pitch_set.register(pitch_classes)
                >>> for pitch in pitches:
                ...     pitch
                NumberedPitch(10)
                NumberedPitch(24)
                NumberedPitch(26)
                NumberedPitch(30)
                NumberedPitch(20)
                NumberedPitch(19)
                NumberedPitch(29)
                NumberedPitch(27)
                NumberedPitch(37)
                NumberedPitch(33)
                NumberedPitch(40)
                NumberedPitch(23)

        Returns list of zero or more numbered pitches.
        '''
        if isinstance(pitch_classes, list):
            result = [
                [_ for _ in self if _.pitch_number % 12 == pc]
                for pc in [x % 12 for x in pitch_classes]
                ]
            result = sequencetools.flatten_sequence(result)
        elif isinstance(pitch_classes, int):
            result = [p for p in pitch_classes if p % 12 == pitch_classes][0]
        else:
            message = 'must be pitch-class or list of pitch-classes.'
            raise TypeError(message)
        return result
예제 #43
0
def interlace_sequences(*sequences):
    '''Interlaces `sequences`.

    ::

        >>> k = range(100, 103)
        >>> l = range(200, 201)
        >>> m = range(300, 303)
        >>> n = range(400, 408)
        >>> sequencetools.interlace_sequences(k, l, m, n)
        [100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]

    Returns list.
    '''
    from abjad.tools import sequencetools

    result = sequencetools.zip_sequences(sequences, truncate=False)
    result = sequencetools.flatten_sequence(result, depth=1)

    return result
예제 #44
0
def register_pitch_class_numbers_by_pitch_number_aggregate(
        pitch_class_numbers, aggregate):
    '''Register `pitch_class_numbers` by pitch-number `aggregate`:

    ::

        >>> pitchtools.register_pitch_class_numbers_by_pitch_number_aggregate(
        ...     [10, 0, 2, 6, 8, 7, 5, 3, 1, 9, 4, 11],
        ...     [10, 19, 20, 23, 24, 26, 27, 29, 30, 33, 37, 40])
        [10, 24, 26, 30, 20, 19, 29, 27, 37, 33, 40, 23]

    Returns list of zero or more pitch numbers.
    '''

    if isinstance(pitch_class_numbers, list):
        result = [[p for p in aggregate if p % 12 == pc]
                  for pc in [x % 12 for x in pitch_class_numbers]]
        result = sequencetools.flatten_sequence(result)
    elif isinstance(pitch_class_numbers, int):
        result = [p for p in aggregate if p % 12 == pitch_class_numbers][0]
    else:
        message = 'must be pitch-class number or list of pitch-class numbers.'
        raise TypeError(message)
    return result
예제 #45
0
def interlace_sequences(sequences):
    '''Interlaces `sequences`.

    ..  container:: example

        **Example 1.** Interlaces generators:

        ::

            >>> sequences = []
            >>> sequences.append(range(100, 103))
            >>> sequences.append(range(200, 201))
            >>> sequences.append(range(300, 303))
            >>> sequences.append(range(400, 408))
            >>> sequencetools.interlace_sequences(sequences)
            [100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]

    ..  container:: example

        **Example 2.** Interlaces tuples:

        ::

            >>> sequences = []
            >>> sequences.append(tuple(range(100, 103)))
            >>> sequences.append(tuple(range(200, 201)))
            >>> sequences.append(tuple(range(300, 303)))
            >>> sequences.append(tuple(range(400, 408)))
            >>> sequencetools.interlace_sequences(sequences)
            [100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]

    ..  container:: example

        **Example 3.** Interlaces lists:

        ::

            >>> sequences = []
            >>> sequences.append(list(range(100, 103)))
            >>> sequences.append(list(range(200, 201)))
            >>> sequences.append(list(range(300, 303)))
            >>> sequences.append(list(range(400, 408)))
            >>> sequencetools.interlace_sequences(sequences)
            [100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]

    ..  container:: example

        **Example 4.** Interlaces strings:

        ::

            >>> sequences = []
            >>> sequences.append('first')
            >>> sequences.append('second')
            >>> sequencetools.interlace_sequences(sequences)
            ['f', 's', 'i', 'e', 'r', 'c', 's', 'o', 't', 'n', 'd']

    Returns list.
    '''
    from abjad.tools import sequencetools

    for sequence in sequences:
        if not isinstance(sequence, collections.Iterable):
            message = 'must be iterable: {!r}.'
            message = message.format(sequence)
            raise Exception(message)

    result = sequencetools.zip_sequences(sequences, truncate=False)
    result = sequencetools.flatten_sequence(result, depth=1)

    assert isinstance(result, list), repr(result)
    return result
예제 #46
0
def partition_sequence_by_ratio_of_weights(sequence, weights):
    '''Partitions `sequence` by ratio of `weights`.

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1] * 10, [1, 1, 1])
        [[1, 1, 1], [1, 1, 1, 1], [1, 1, 1]]

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1] * 10, [1, 1, 1, 1])
        [[1, 1, 1], [1, 1], [1, 1, 1], [1, 1]]

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1] * 10, [2, 2, 3])
        [[1, 1, 1], [1, 1, 1], [1, 1, 1, 1]]

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1] * 10, [3, 2, 2])
        [[1, 1, 1, 1], [1, 1, 1], [1, 1, 1]]

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], [1, 1])
        [[1, 1, 1, 1, 1, 1, 2, 2], [2, 2, 2, 2]]

    ::

        >>> sequencetools.partition_sequence_by_ratio_of_weights(
        ...     [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], [1, 1, 1])
        [[1, 1, 1, 1, 1, 1], [2, 2, 2], [2, 2, 2]]


    Weights of parts of returned list equal `weights_ratio` proportions
    with some rounding magic.

    Returns list of lists.
    '''
    from abjad.tools import sequencetools

    if not isinstance(sequence, collections.Sequence):
        message = 'must be sequence: {!r}.'
        message = message.format(sequence)
        raise Exception(message)

    list_weight = mathtools.weight(sequence)
    weights_parts = mathtools.partition_integer_by_ratio(list_weight, weights)
    cumulative_weights = mathtools.cumulative_sums(weights_parts, start=None)

    result = []
    sublist = []
    result.append(sublist)
    current_cumulative_weight = cumulative_weights.pop(0)
    for n in sequence:
        if not isinstance(n, (int, float, fractions.Fraction)):
            message = 'must be number: {!r}.'
            message = message.format(n)
            raise TypeError(message)
        sublist.append(n)
        while current_cumulative_weight <= \
            mathtools.weight(sequencetools.flatten_sequence(result)):
            try:
                current_cumulative_weight = cumulative_weights.pop(0)
                sublist = []
                result.append(sublist)
            except IndexError:
                break

    return result
def partition_sequence_by_weights(
    sequence,
    weights,
    cyclic=False,
    overhang=False,
    allow_part_weights=Exact,
):
    r'''Partitions `sequence` by `weights` exactly.

    ::

        >>> sequence = [3, 3, 3, 3, 4, 4, 4, 4, 5]

    ..  container:: example

        **Example 1.** Partition sequence once by weights exactly without
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [3, 9],
            ...     cyclic=False,
            ...     overhang=False,
            ...     )
            [[3], [3, 3, 3]]

    ..  container:: example

        **Example 2.** Partition sequence once by weights exactly with
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [3, 9],
            ...     cyclic=False,
            ...     overhang=True,
            ...     )
            [[3], [3, 3, 3], [4, 4, 4, 4, 5]]

    ..  container:: example

        **Example 3.** Partition sequence cyclically by weights exactly
        without overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [12],
            ...     cyclic=True,
            ...     overhang=False,
            ...     )
            [[3, 3, 3, 3], [4, 4, 4]]

    ..  container:: example

        **Example 4.** Partition sequence cyclically by weights exactly with
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [12],
            ...     cyclic=True,
            ...     overhang=True,
            ...     )
            [[3, 3, 3, 3], [4, 4, 4], [4, 5]]

    ::

        >>> sequence = [3, 3, 3, 3, 4, 4, 4, 4, 5, 5]

    ..  container:: example

        **Example 1.** Partition sequence once by weights at most without
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=False,
            ...     overhang=False,
            ...     allow_part_weights=Less,
            ...     )
            [[3, 3, 3], [3]]

    ..  container:: example

        **Example 2.** Partition sequence once by weights at most with
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=False,
            ...     overhang=True,
            ...     allow_part_weights=Less,
            ...     )
            [[3, 3, 3], [3], [4, 4, 4, 4, 5, 5]]

    ..  container:: example

        **Example 3.** Partition sequence cyclically by weights at most
        without overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 5],
            ...     cyclic=True,
            ...     overhang=False,
            ...     allow_part_weights=Less,
            ...     )
            [[3, 3, 3], [3], [4, 4], [4], [4, 5], [5]]

    ..  container:: example

        **Example 4.** Partition sequence cyclically by weights at most
        with overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 5],
            ...     cyclic=True,
            ...     overhang=True,
            ...     allow_part_weights=Less,
            ...     )
            [[3, 3, 3], [3], [4, 4], [4], [4, 5], [5]]

    ::

        >>> sequence = [3, 3, 3, 3, 4, 4, 4, 4, 5, 5]

    ..  container:: example

        **Example 1.** Partition sequence once by weights at least without
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=False,
            ...     overhang=False,
            ...     allow_part_weights=More,
            ...     )
            [[3, 3, 3, 3], [4]]

    ..  container:: example

        **Example 2.** Partition sequence once by weights at least with
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=False,
            ...     overhang=True,
            ...     allow_part_weights=More,
            ...     )
            [[3, 3, 3, 3], [4], [4, 4, 4, 5, 5]]

    ..  container:: example

        **Example 3.** Partition sequence cyclically by weights at least
        without overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=True,
            ...     overhang=False,
            ...     allow_part_weights=More,
            ...     )
            [[3, 3, 3, 3], [4], [4, 4, 4], [5]]

    ..  container:: example

        **Example 4.** Partition sequence cyclically by weights at least with
        overhang:

        ::

            >>> sequencetools.partition_sequence_by_weights(
            ...     sequence,
            ...     [10, 4],
            ...     cyclic=True,
            ...     overhang=True,
            ...     allow_part_weights=More,
            ...     )
            [[3, 3, 3, 3], [4], [4, 4, 4], [5], [5]]

    Returns list sequence objects.
    '''
    from abjad.tools import sequencetools

    if allow_part_weights == Exact:
        candidate = sequencetools.split_sequence(
            sequence,
            weights,
            cyclic=cyclic,
            overhang=overhang,
        )
        flattened_candidate = sequencetools.flatten_sequence(candidate)
        if flattened_candidate == sequence[:len(flattened_candidate)]:
            return candidate
        else:
            message = 'can not partition exactly.'
            raise Exception(message)
    elif allow_part_weights == More:
        if not cyclic:
            return _partition_sequence_once_by_weights_at_least(
                sequence, weights, overhang=overhang)
        else:
            return _partition_sequence_cyclically_by_weights_at_least(
                sequence, weights, overhang=overhang)
    elif allow_part_weights == Less:
        if not cyclic:
            return _partition_sequence_once_by_weights_at_most(
                sequence,
                weights,
                overhang=overhang,
            )
        else:
            return _partition_sequence_cyclically_by_weights_at_most(
                sequence,
                weights,
                overhang=overhang,
            )
    else:
        message = 'not an ordinal value constant: {!r}.'
        message = message.format(allow_part_weights)
        raise ValueError(message)
예제 #48
0
 def _split(
     self,
     durations,
     cyclic=False,
     fracture_spanners=False,
     tie_split_notes=True,
     use_messiaen_style_ties=False,
     ):
     from abjad.tools import pitchtools
     from abjad.tools import selectiontools
     from abjad.tools import scoretools
     from abjad.tools import spannertools
     durations = [durationtools.Duration(x) for x in durations]
     if cyclic:
         durations = sequencetools.repeat_sequence_to_weight(
             durations, self._get_duration())
     durations = [durationtools.Duration(x) for x in durations]
     if sum(durations) < self._get_duration():
         last_duration = self._get_duration() - sum(durations)
         durations.append(last_duration)
     sequencetools.truncate_sequence(
         durations,
         weight=self._get_duration(),
         )
     result = []
     leaf_prolation = self._get_parentage(include_self=False).prolation
     timespan = self._get_timespan()
     start_offset = timespan.start_offset
     for duration in durations:
         new_leaf = copy.copy(self)
         preprolated_duration = duration / leaf_prolation
         shard = new_leaf._set_duration(
             preprolated_duration,
             use_messiaen_style_ties=use_messiaen_style_ties,
             )
         for x in shard:
             if isinstance(x, scoretools.Leaf):
                 x_duration = x.written_duration * leaf_prolation
             else:
                 x_duration = x.multiplied_duration * leaf_prolation
             stop_offset = x_duration + start_offset
             x._start_offset = start_offset
             x._stop_offset = stop_offset
             x._timespan = timespantools.Timespan(
                 start_offset=start_offset,
                 stop_offset=stop_offset,
                 )
             start_offset = stop_offset
         shard = [x._get_parentage().root for x in shard]
         result.append(shard)
     flattened_result = sequencetools.flatten_sequence(result)
     flattened_result = selectiontools.SliceSelection(flattened_result)
     prototype = (spannertools.Tie,)
     parentage = self._get_parentage()
     if parentage._get_spanners(prototype=prototype):
         selection = select(flattened_result)
         for component in selection:
             # TODO: make top-level detach() work here
             for spanner in component._get_spanners(prototype):
                 spanner._sever_all_components()
             #detach(prototype, component)
     # replace leaf with flattened result
     selection = selectiontools.SliceSelection(self)
     parent, start, stop = selection._get_parent_and_start_stop_indices()
     if parent:
         parent.__setitem__(slice(start, stop + 1), flattened_result)
     else:
         selection._give_dominant_spanners(flattened_result)
         selection._withdraw_from_crossing_spanners()
     # fracture spanners
     if fracture_spanners:
         first_shard = result[0]
         for spanner in first_shard[-1]._get_spanners():
             index = spanner._index(first_shard[-1])
             spanner._fracture(index, direction=Right)
         last_shard = result[-1]
         for spanner in last_shard[0]._get_spanners():
             index = spanner._index(last_shard[0])
             spanner._fracture(index, direction=Left)
         for middle_shard in result[1:-1]:
             for spanner in middle_shard[0]._get_spanners():
                 index = spanner._index(middle_shard[0])
                 spanner._fracture(index, direction=Left)
             for spanner in middle_shard[-1]._get_spanners():
                 index = spanner._index(middle_shard[-1])
                 spanner._fracture(index, direction=Right)
     # adjust first leaf
     first_leaf = flattened_result[0]
     self._detach_grace_containers(kind='after')
     # adjust any middle leaves
     for middle_leaf in flattened_result[1:-1]:
         middle_leaf._detach_grace_containers(kind='grace')
         self._detach_grace_containers(kind='after')
         detach(object, middle_leaf)
     # adjust last leaf
     last_leaf = flattened_result[-1]
     last_leaf._detach_grace_containers(kind='grace')
     detach(object, last_leaf)
     # tie split notes, rests and chords as specified
     if pitchtools.Pitch.is_pitch_carrier(self) and tie_split_notes:
         flattened_result_leaves = iterate(flattened_result).by_class(
             scoretools.Leaf)
         # TODO: implement SliceSelection._attach_tie_spanner_to_leaves()
         for leaf_pair in sequencetools.iterate_sequence_nwise(
             flattened_result_leaves):
             selection = selectiontools.ContiguousSelection(leaf_pair)
             selection._attach_tie_spanner_to_leaf_pair(
                 use_messiaen_style_ties=use_messiaen_style_ties,
                 )
     # return result
     return result
예제 #49
0
def make_lilypond_file(
    selections,
    divisions,
    implicit_scaling=None,
    pitched_staff=None,
    time_signatures=None,
):
    r'''Makes LilyPond file.

    ..  container::

        **Example 1.**

        ::

            >>> maker = rhythmmakertools.EvenRunRhythmMaker(exponent=1)
            >>> divisions = [(3, 4), (4, 8), (1, 4)]
            >>> selections = maker(divisions)
            >>> lilypond_file = rhythmmakertools.make_lilypond_file(
            ...     selections,
            ...     divisions,
            ...     )
            >>> show(lilypond_file) # doctest: +SKIP

    Used in rhythm-maker docs.

    Returns LilyPond file.
    '''
    assert isinstance(selections, list), repr(selections)
    prototype = selectiontools.Selection
    assert all(isinstance(_, prototype) for _ in selections), repr(selections)
    assert isinstance(divisions, (tuple, list)), repr(divisions)
    time_signatures = time_signatures or divisions
    score = scoretools.Score()
    lilypond_file = \
        lilypondfiletools.make_floating_time_signature_lilypond_file(score)
    context = scoretools.Context(context_name='TimeSignatureContext')
    measures = scoretools.make_spacer_skip_measures(
        time_signatures,
        implicit_scaling=implicit_scaling,
    )
    context.extend(measures)
    score.append(context)
    measures = scoretools.make_spacer_skip_measures(
        time_signatures,
        implicit_scaling=implicit_scaling,
    )
    if pitched_staff:
        staff = scoretools.Staff(measures)
    else:
        staff = scoretools.Staff(measures, context_name='RhythmicStaff')
    selections = sequencetools.flatten_sequence(selections)
    selections_ = copy.deepcopy(selections)
    try:
        measures = mutate(staff).replace_measure_contents(selections)
    except StopIteration:
        if pitched_staff:
            staff = scoretools.Staff(selections_)
        else:
            staff = scoretools.Staff(selections_, context_name='RhythmicStaff')
    score.append(staff)
    return lilypond_file
예제 #50
0
    def pitches(self):
        r'''Pitches in pitch array.

        Returns tuple.
        '''
        return sequencetools.flatten_sequence(self.pitches_by_row)
예제 #51
0
    def __graph__(self, **kwargs):
        r'''Gets Graphviz format of meter.

        ..  container:: example

            **Example 1.** Graphs ``7/4``:

            ::

                >>> meter = metertools.Meter((7, 4))
                >>> meter_graph = meter.__graph__()
                >>> graph(meter_graph) # doctest: +SKIP

            ..  doctest::

                >>> print(str(meter_graph))
                digraph G {
                    graph [bgcolor=transparent,
                        fontname=Arial,
                        penwidth=2,
                        truecolor=true];
                    node [fontname=Arial,
                        fontsize=12,
                        penwidth=2];
                    edge [penwidth=2];
                    node_0 [label="7/4",
                        shape=triangle];
                    node_1 [label="3/4",
                        shape=triangle];
                    node_2 [label="1/4",
                        shape=box];
                    node_3 [label="1/4",
                        shape=box];
                    node_4 [label="1/4",
                        shape=box];
                    node_5 [label="2/4",
                        shape=triangle];
                    node_6 [label="1/4",
                        shape=box];
                    node_7 [label="1/4",
                        shape=box];
                    node_8 [label="2/4",
                        shape=triangle];
                    node_9 [label="1/4",
                        shape=box];
                    node_10 [label="1/4",
                        shape=box];
                    subgraph cluster_cluster_offsets {
                        graph [style=rounded];
                        node_11_0 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 0 | <f_0_1> +++ }",
                            shape=Mrecord,
                            style=filled];
                        node_11_1 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 1/4 | <f_0_1> + }",
                            shape=Mrecord,
                            style=filled];
                        node_11_2 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 1/2 | <f_0_1> + }",
                            shape=Mrecord,
                            style=filled];
                        node_11_3 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 3/4 | <f_0_1> ++ }",
                            shape=Mrecord,
                            style=filled];
                        node_11_4 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 1 | <f_0_1> + }",
                            shape=Mrecord,
                            style=filled];
                        node_11_5 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 5/4 | <f_0_1> ++ }",
                            shape=Mrecord,
                            style=filled];
                        node_11_6 [color=white,
                            fillcolor=black,
                            fontcolor=white,
                            fontname="Arial bold",
                            label="{ <f_0_0> 3/2 | <f_0_1> + }",
                            shape=Mrecord,
                            style=filled];
                        node_11_7 [label="{ <f_0_0> 7/4 | <f_0_1> +++ }",
                            shape=Mrecord];
                    }
                    node_0 -> node_1;
                    node_0 -> node_5;
                    node_0 -> node_8;
                    node_1 -> node_2;
                    node_1 -> node_3;
                    node_1 -> node_4;
                    node_2 -> node_11_0 [style=dotted];
                    node_2 -> node_11_1 [style=dotted];
                    node_3 -> node_11_1 [style=dotted];
                    node_3 -> node_11_2 [style=dotted];
                    node_4 -> node_11_2 [style=dotted];
                    node_4 -> node_11_3 [style=dotted];
                    node_5 -> node_6;
                    node_5 -> node_7;
                    node_6 -> node_11_3 [style=dotted];
                    node_6 -> node_11_4 [style=dotted];
                    node_7 -> node_11_4 [style=dotted];
                    node_7 -> node_11_5 [style=dotted];
                    node_8 -> node_9;
                    node_8 -> node_10;
                    node_9 -> node_11_5 [style=dotted];
                    node_9 -> node_11_6 [style=dotted];
                    node_10 -> node_11_6 [style=dotted];
                    node_10 -> node_11_7 [style=dotted];
                }

        Returns Graphviz graph.
        '''
        def make_offset_node(
            offset,
            leaf_one=None,
            leaf_two=None,
            is_last=False,
        ):
            if not is_last:
                offset_node = documentationtools.GraphvizNode(attributes={
                    'shape':
                    'Mrecord',
                    'style':
                    'filled',
                    'color':
                    'white',
                    'fontname':
                    'Arial bold',
                    'fontcolor':
                    'white',
                    'fillcolor':
                    'black',
                }, )
            else:
                offset_node = documentationtools.GraphvizNode(attributes={
                    'shape':
                    'Mrecord',
                }, )
            offset_field = documentationtools.GraphvizField(
                label=str(offset), )
            weight_field = documentationtools.GraphvizField(label='+' *
                                                            offsets[offset], )
            group = documentationtools.GraphvizGroup()
            group.extend([offset_field, weight_field])
            offset_node.append(group)
            offset_subgraph.append(offset_node)
            leaf_one_node = node_mapping[leaf_one]
            edge = documentationtools.GraphvizEdge(
                attributes={'style': 'dotted'}, )
            edge.attach(leaf_one_node, offset_node)
            if leaf_two:
                leaf_two_node = node_mapping[leaf_two]
                edge = documentationtools.GraphvizEdge(
                    attributes={'style': 'dotted'}, )
                edge.attach(leaf_two_node, offset_node)

        from abjad.tools import metertools
        offsets = metertools.MetricAccentKernel.count_offsets_in_expr(
            sequencetools.flatten_sequence(self.depthwise_offset_inventory))
        graph = documentationtools.GraphvizGraph(
            name='G',
            attributes={
                'bgcolor': 'transparent',
                'fontname': 'Arial',
                'penwidth': 2,
                'truecolor': True,
            },
            edge_attributes={
                'penwidth': 2,
            },
            node_attributes={
                'fontname': 'Arial',
                'fontsize': 12,
                'penwidth': 2,
            },
        )
        node_mapping = {}
        for node in self._root_node.nodes:
            graphviz_node = documentationtools.GraphvizNode()
            graphviz_node.attributes['label'] = str(node.preprolated_duration)
            if isinstance(node, rhythmtreetools.RhythmTreeContainer):
                graphviz_node.attributes['shape'] = 'triangle'
            else:
                graphviz_node.attributes['shape'] = 'box'
            graph.append(graphviz_node)
            node_mapping[node] = graphviz_node
            if node.parent is not None:
                documentationtools.GraphvizEdge().attach(
                    node_mapping[node.parent],
                    node_mapping[node],
                )
        leaves = self._root_node.leaves
        offset = leaves[0].start_offset
        offset_subgraph = documentationtools.GraphvizSubgraph(
            name='cluster_offsets',
            attributes={
                'style': 'rounded',
            },
        )
        graph.append(offset_subgraph)
        make_offset_node(offset, leaves[0])
        for one, two in sequencetools.iterate_sequence_nwise(leaves):
            offset = one.stop_offset
            make_offset_node(offset, one, two)
        offset = leaves[-1].stop_offset
        make_offset_node(offset, leaves[-1], is_last=True)
        return graph
예제 #52
0
    def flatten(self, classes=None, depth=-1, indices=None):
        r'''Flattens sequence.

        ..  container:: example

            **Example 1.** Flattens sequence completely:

            ::

                >>> sequence = Sequence((1, [2, 3, [4]], 5, [6, 7, [8]]))
                >>> sequence.flatten()
                Sequence((1, 2, 3, 4, 5, 6, 7, 8))

        ..  container:: example

            **Example 2.** Flattens `sequence` to depth ``1``:

            ::

                >>> sequence = Sequence((1, [2, 3, [4]], 5, [6, 7, [8]]))
                >>> sequence.flatten(depth=1)
                Sequence((1, 2, 3, [4], 5, 6, 7, [8]))

        ..  container:: example

            **Example 3.** Flattens `sequence` to depth ``2``:

            ::

                >>> sequence = Sequence((1, [2, 3, [4]], 5, [6, 7, [8]]))
                >>> sequence.flatten(depth=2)
                Sequence((1, 2, 3, 4, 5, 6, 7, 8))

        ..  container:: example

            **Example 4.** Flattens `sequence` at `indices`:

            ::

                >>> sequence = Sequence((1, [2, 3, [4]], 5, [6, 7, [8]]))
                >>> sequence.flatten(indices=[3])
                Sequence((1, [2, 3, [4]], 5, 6, 7, 8))

        ..  container:: example

            **Example 5.** Flattens `sequence` at negative `indices`:

            ::

                >>> sequence = Sequence((1, [2, 3, [4]], 5, [6, 7, [8]]))
                >>> sequence.flatten(indices=[-1])
                Sequence((1, [2, 3, [4]], 5, 6, 7, 8))

        ..  container:: example

            **Example 6.** Flattens only tuples in `sequence`:

            ::

                >>> sequence = Sequence(('ab', 'cd', ('ef', 'gh'), ('ij', 'kl')))
                >>> sequence.flatten(classes=(tuple,))
                Sequence(('ab', 'cd', 'ef', 'gh', 'ij', 'kl'))

        Returns new sequence.
        '''
        from abjad.tools import sequencetools
        items = sequencetools.flatten_sequence(
            self._items[:],
            classes=classes,
            depth=depth,
            indices=indices,
        )
        result = type(self)(items)
        return result
예제 #53
0
def increase_elements(sequence, addenda, indices=None):
    '''Increases `sequence` cyclically by `addenda`.

    ..  container:: example

        **Example 1a.** Increases range elements by ``10`` and ``-10`` in
        alternation:

        ::

            >>> sequencetools.increase_elements(range(10), [10, -10])
            [10, -9, 12, -7, 14, -5, 16, -3, 18, -1]


        **Example 1b.** Increases list elements by 10 and -10 in alternation:

        ::

            >>> sequencetools.increase_elements(list(range(10)), [10, -10])
            [10, -9, 12, -7, 14, -5, 16, -3, 18, -1]

        **Example 1c.** Increases tuple elements by 10 and -10 in alternation:

        ::

            >>> sequencetools.increase_elements(tuple(range(10)), [10, -10])
            [10, -9, 12, -7, 14, -5, 16, -3, 18, -1]

    ..  container:: example

        **Example 2.** Increases pairs of elements by ``0.5`` starting at
        indices 0, 4, 8:

        ::

            >>> sequence = [1, 1, 2, 3, 5, 5, 1, 2, 5, 5, 6]
            >>> addenda = [0.5, 0.5]
            >>> indices = [0, 4, 8]
            >>> sequencetools.increase_elements(sequence, addenda, indices)
            [1.5, 1.5, 2, 3, 5.5, 5.5, 1, 2, 5.5, 5.5, 6]

    Returns list.
    '''
    from abjad.tools import sequencetools
    sequence = list(sequence)
    if indices is None:
        result = []
        for i, element in enumerate(sequence):
            new = element + addenda[i % len(addenda)]
            result.append(new)
    else:
        # assert no overlaps
        tmp = [tuple(range(i, len(addenda))) for i in indices]
        tmp = sequencetools.flatten_sequence(tmp)
        assert len(tmp) == len(set(tmp))
        result = sequence[:]
        for i in indices:
            for j in range(len(addenda)):
                result[i + j] += addenda[j]
    assert isinstance(result, list)
    return result