def _make_score_number_markup(configuration_number, score_number): assert mathtools.is_nonnegative_integer(configuration_number) assert mathtools.is_nonnegative_integer(score_number) number_string = "{}-{}".format(configuration_number, score_number) command = markuptools.MarkupCommand("fontsize", 2, number_string) command = markuptools.MarkupCommand("italic", command) command = markuptools.MarkupCommand("box", command) pair = schemetools.SchemePair("box-padding", 0.75) command = markuptools.MarkupCommand("override", pair, command) width = 9 command = markuptools.MarkupCommand("hcenter-in", width, command) markup = markuptools.Markup(command) return markup
def repeat_sequence_to_length(sequence, length, start=0): '''Repeats `sequence` to nonnegative integer `length`. :: >>> sequencetools.repeat_sequence_to_length(list(range(5)), 11) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0] Repeats `sequence` to nonnegative integer `length` from `start`: :: >>> sequencetools.repeat_sequence_to_length( ... list(range(5)), 11, start=2) [2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2] Returns newly constructed `sequence` object. ''' if not mathtools.is_nonnegative_integer(length): raise TypeError if len(sequence) <= 0: raise ValueError result = [] start %= len(sequence) stop_index = start + length repetitions = int(math.ceil(float(stop_index) / len(sequence))) for x in range(repetitions): for element in sequence: result.append(copy.copy(element)) return type(sequence)(result[start:stop_index])
def repeat_sequence_to_length(sequence, length, start=0): '''Repeat `sequence` to nonnegative integer `length`: :: >>> sequencetools.repeat_sequence_to_length(range(5), 11) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0] Repeat `sequence` to nonnegative integer `length` from `start`: :: >>> sequencetools.repeat_sequence_to_length(range(5), 11, start=2) [2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2] Returns newly constructed `sequence` object. ''' if not mathtools.is_nonnegative_integer(length): raise TypeError if len(sequence) <= 0: raise ValueError result = [] start %= len(sequence) stop_index = start + length repetitions = int(math.ceil(stop_index / len(sequence))) for x in range(repetitions): for element in sequence: result.append(copy.copy(element)) return type(sequence)(result[start:stop_index])
def repeat_sequence(sequence, n): '''Repeats `sequence` `n` times. :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 3) (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5) Repeats `sequence` ``0`` times: :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 0) () Returns newly constructed `sequence` object of copied `sequence` elements. ''' if not mathtools.is_nonnegative_integer(n): message = 'must be nonnegative integer: {!r}.' message = message.format(n) raise ValueError(message) result = [] for x in range(n): for element in sequence: result.append(copy.copy(element)) return type(sequence)(result)
def repeat_to_length(self, length): r'''Repeat payload to `length`. Returns copy of expression with callback. ''' assert mathtools.is_nonnegative_integer(length) callback = 'result = self._repeat_to_length(payload_expression, {!r})' callback = callback.format(length) return self._copy_and_append_callback(callback)
def repeat_to_length(self, length): r'''Repeat payload to `length`. Returns copy of expression with callback. ''' assert mathtools.is_nonnegative_integer(length) callback = 'result = self._repeat_to_length(payload_expression, {!r})' callback = callback.format(length) return self._copy_and_append_callback(callback)
def repeat_sequence_to_length(sequence, length, start=0): '''Repeats `sequence` to nonnegative integer `length`. .. container:: example **Example 1.** Repeats list to length 11: :: >>> sequencetools.repeat_sequence_to_length(list(range(5)), 11) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0] .. container:: example **Example 2.** Repeats `sequence` to nonnegative integer `length` from `start`: :: >>> sequencetools.repeat_sequence_to_length( ... list(range(5)), 11, start=2) [2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2] **Example 3.** Repeats tuple to length 11: :: >>> sequencetools.repeat_sequence_to_length(tuple(range(5)), 11) (0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0) Copies `sequence` element references; does not copy `sequence` elements. Returns new object of `sequence` type. ''' if not isinstance(sequence, collections.Sequence): message = 'must by sequence {!r}.' message = message.format(sequence) raise Exception(message) sequence_type = type(sequence) if not mathtools.is_nonnegative_integer(length): raise TypeError if len(sequence) <= 0: raise ValueError result = [] start %= len(sequence) stop_index = start + length repetitions = int(math.ceil(float(stop_index) / len(sequence))) for x in range(repetitions): for element in sequence: result.append(element) return sequence_type(result[start:stop_index])
def repeat_sequence_to_length(sequence, length, start=0): '''Repeats `sequence` to nonnegative integer `length`. .. container:: example **Example 1.** Repeats list to length 11: :: >>> sequencetools.repeat_sequence_to_length(list(range(5)), 11) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0] .. container:: example **Example 2.** Repeats `sequence` to nonnegative integer `length` from `start`: :: >>> sequencetools.repeat_sequence_to_length( ... list(range(5)), 11, start=2) [2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2] **Example 3.** Repeats tuple to length 11: :: >>> sequencetools.repeat_sequence_to_length(tuple(range(5)), 11) (0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0) Copies `sequence` element references; does not copy `sequence` elements. Returns new object of `sequence` type. ''' if not isinstance(sequence, collections.Sequence): message = 'must by sequence {!r}.' message = message.format(sequence) raise Exception(message) sequence_type = type(sequence) if not mathtools.is_nonnegative_integer(length): raise TypeError if len(sequence) <= 0: raise ValueError result = [] start %= len(sequence) stop_index = start + length repetitions = int(math.ceil(float(stop_index) / len(sequence))) for x in range(repetitions): for element in sequence: result.append(element) return sequence_type(result[start:stop_index])
def _make_score_number_markup( configuration_number, score_number, ): assert mathtools.is_nonnegative_integer(configuration_number) assert mathtools.is_nonnegative_integer(score_number) number_string = '{}-{}'.format( configuration_number, score_number, ) command = markuptools.MarkupCommand('fontsize', 2, number_string) command = markuptools.MarkupCommand('italic', command) command = markuptools.MarkupCommand('box', command) pair = schemetools.SchemePair('box-padding', 0.75) command = markuptools.MarkupCommand('override', pair, command) width = 9 command = markuptools.MarkupCommand('hcenter-in', width, command) markup = markuptools.Markup(command) return markup
def _make_score_number_markup( configuration_number, score_number, ): assert mathtools.is_nonnegative_integer(configuration_number) assert mathtools.is_nonnegative_integer(score_number) number_string = '{}-{}'.format( configuration_number, score_number, ) command = markuptools.MarkupCommand('fontsize', 2, number_string) command = markuptools.MarkupCommand('italic', command) command = markuptools.MarkupCommand('box', command) pair = schemetools.SchemePair('box-padding', 0.75) command = markuptools.MarkupCommand('override', pair, command) width = 9 command = markuptools.MarkupCommand('hcenter-in', width, command) markup = markuptools.Markup(command) return markup
def repeat_sequence(sequence, n): '''Repeats `sequence` `n` times. .. container:: example **Example 1.** Repeats tuple three times: :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 3) (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5) .. container:: example **Example 2.** Repeats tuple zero times: :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 0) () .. container:: example **Example 3.** Repeats list three times: :: >>> sequencetools.repeat_sequence([1, 2, 3, 4, 5], 3) [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5] Repeats references to `sequence` elements; does not copy `sequence` elements. Returns new object of `sequence` type. ''' if not isinstance(sequence, collections.Sequence): message = 'must by sequence {!r}.' message = message.format(sequence) raise Exception(message) sequence_type = type(sequence) if not mathtools.is_nonnegative_integer(n): message = 'must be nonnegative integer: {!r}.' message = message.format(n) raise ValueError(message) result = [] for x in range(n): for element in sequence: result.append(element) result = sequence_type(result) return result
def repeat_sequence(sequence, n): '''Repeats `sequence` `n` times. .. container:: example **Example 1.** Repeats tuple three times: :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 3) (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5) .. container:: example **Example 2.** Repeats tuple zero times: :: >>> sequencetools.repeat_sequence((1, 2, 3, 4, 5), 0) () .. container:: example **Example 3.** Repeats list three times: :: >>> sequencetools.repeat_sequence([1, 2, 3, 4, 5], 3) [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5] Repeats references to `sequence` elements; does not copy `sequence` elements. Returns new object of `sequence` type. ''' if not isinstance(sequence, collections.Sequence): message = 'must by sequence {!r}.' message = message.format(sequence) raise Exception(message) sequence_type = type(sequence) if not mathtools.is_nonnegative_integer(n): message = 'must be nonnegative integer: {!r}.' message = message.format(n) raise ValueError(message) result = [] for x in range(n): for element in sequence: result.append(element) result = sequence_type(result) return result
def test_mathtools_is_nonnegative_integer_01(): assert mathtools.is_nonnegative_integer(1) assert mathtools.is_nonnegative_integer(int(1)) assert mathtools.is_nonnegative_integer(Duration(1, 1)) assert mathtools.is_nonnegative_integer(1.0) assert mathtools.is_nonnegative_integer(True) assert mathtools.is_nonnegative_integer(0) assert mathtools.is_nonnegative_integer(False)
def __init__( self, denominator_multiplier_exponent=0, beam_each_cell=True, beam_cells_together=False, ): assert mathtools.is_nonnegative_integer( denominator_multiplier_exponent) RhythmMaker.__init__(self, beam_each_cell=beam_each_cell, beam_cells_together=beam_cells_together ) self._denominator_multiplier_exponent = \ denominator_multiplier_exponent
def __init__( self, exponent=None, beam_specifier=None, duration_spelling_specifier=None, tie_specifier=None, ): if exponent is not None: assert mathtools.is_nonnegative_integer(exponent) RhythmMaker.__init__( self, beam_specifier=beam_specifier, duration_spelling_specifier=duration_spelling_specifier, tie_specifier=tie_specifier, ) self._exponent = exponent
def __init__( self, exponent=None, beam_specifier=None, duration_spelling_specifier=None, tie_specifier=None, tuplet_spelling_specifier=None, ): if exponent is not None: assert mathtools.is_nonnegative_integer(exponent) RhythmMaker.__init__( self, beam_specifier=beam_specifier, duration_spelling_specifier=duration_spelling_specifier, tie_specifier=tie_specifier, tuplet_spelling_specifier=tuplet_spelling_specifier, ) self._exponent = exponent
def __init__( self, denominator_multiplier_exponent=0, beam_cells_together=False, beam_each_cell=True, decrease_durations_monotonically=True, forbidden_written_duration=None, ): assert mathtools.is_nonnegative_integer( denominator_multiplier_exponent) RhythmMaker.__init__( self, beam_cells_together=beam_cells_together, beam_each_cell=beam_each_cell, decrease_durations_monotonically=decrease_durations_monotonically, forbidden_written_duration=forbidden_written_duration, ) self._denominator_multiplier_exponent = \ denominator_multiplier_exponent
def repeat_sequence_elements_n_times_each(sequence, n): '''Repeat `sequence` elements `n` times each: :: >>> sequencetools.repeat_sequence_elements_n_times_each((1, -1, 2, -3, 5, -5, 6), 2) (1, 1, -1, -1, 2, 2, -3, -3, 5, 5, -5, -5, 6, 6) Returns newly constructed `sequence` object with copied `sequence` elements. ''' if not mathtools.is_nonnegative_integer(n): raise ValueError result = [] for element in sequence: for x in range(n): result.append(copy.copy(element)) return type(sequence)(result)
def all_are_nonnegative_integers(argument): '''Is true when `argument` is an iterable collection of nonnegative integers. Otherwise false. .. container:: example >>> abjad.mathtools.all_are_nonnegative_integers([0, 1, 2, 99]) True >>> abjad.mathtools.all_are_nonnegative_integers([0, 1, 2, -99]) False Returns true or false. ''' from abjad.tools import mathtools try: return all(mathtools.is_nonnegative_integer(_) for _ in argument) except TypeError: return False
def all_are_nonnegative_integers(expr): '''True when `expr` is a sequence and all elements in `expr` are nonnegative integers: :: >>> sequencetools.all_are_nonnegative_integers([0, 1, 2, 99]) True Otherwise false: :: >>> sequencetools.all_are_nonnegative_integers([0, 1, 2, -99]) False Returns boolean. ''' try: return all(mathtools.is_nonnegative_integer(x) for x in expr) except TypeError: return False
def all_are_nonnegative_integers(expr): '''Is true when `expr` is a sequence and all elements in `expr` are nonnegative integers. :: >>> mathtools.all_are_nonnegative_integers([0, 1, 2, 99]) True Otherwise false: :: >>> mathtools.all_are_nonnegative_integers([0, 1, 2, -99]) False Returns true or false. ''' from abjad.tools import mathtools try: return all(mathtools.is_nonnegative_integer(x) for x in expr) except TypeError: return False
def test_mathtools_is_nonnegative_integer_02(): assert not mathtools.is_nonnegative_integer(-99)
def test_mathtools_is_nonnegative_integer_03(): assert not mathtools.is_nonnegative_integer('foo')