def test_mathtools_is_positive_integer_equivalent_number_02():
assert not mathtools.is_positive_integer_equivalent_number(0)
assert not mathtools.is_positive_integer_equivalent_number(-2)
assert not mathtools.is_positive_integer_equivalent_number(Duration(5, 2))
assert not mathtools.is_positive_integer_equivalent_number(2.5)
assert not mathtools.is_positive_integer_equivalent_number('foo')
def partition_integer_into_parts_less_than_double(n, m):
r'''Partitions integer `n` into parts less than double integer `m`.
.. container:: example
**Example:**
::
>>> for n in range(1, 24+1):
... print n, mathtools.partition_integer_into_parts_less_than_double(n, 4)
1 (1,)
2 (2,)
3 (3,)
4 (4,)
5 (5,)
6 (6,)
7 (7,)
8 (4, 4)
9 (4, 5)
10 (4, 6)
11 (4, 7)
12 (4, 4, 4)
13 (4, 4, 5)
14 (4, 4, 6)
15 (4, 4, 7)
16 (4, 4, 4, 4)
17 (4, 4, 4, 5)
18 (4, 4, 4, 6)
19 (4, 4, 4, 7)
20 (4, 4, 4, 4, 4)
21 (4, 4, 4, 4, 5)
22 (4, 4, 4, 4, 6)
23 (4, 4, 4, 4, 7)
24 (4, 4, 4, 4, 4, 4)
Returns tuple of one or more integers.
'''
from abjad.tools import mathtools
# check input
assert mathtools.is_positive_integer_equivalent_number(n)
assert mathtools.is_positive_integer_equivalent_number(m)
n, m = int(n), int(m)
# initialize values
result = []
current_value = n
double_m = 2 * m
# partition n
while double_m <= current_value:
result.append(m)
current_value -= m
result.append(current_value)
# return result
return tuple(result)
def partition_integer_into_parts_less_than_double(n, m):
r'''Partitions integer `n` into parts less than double integer `m`.
.. container:: example
::
>>> for n in range(1, 24+1):
... print(n, mathtools.partition_integer_into_parts_less_than_double(n, 4))
1 (1,)
2 (2,)
3 (3,)
4 (4,)
5 (5,)
6 (6,)
7 (7,)
8 (4, 4)
9 (4, 5)
10 (4, 6)
11 (4, 7)
12 (4, 4, 4)
13 (4, 4, 5)
14 (4, 4, 6)
15 (4, 4, 7)
16 (4, 4, 4, 4)
17 (4, 4, 4, 5)
18 (4, 4, 4, 6)
19 (4, 4, 4, 7)
20 (4, 4, 4, 4, 4)
21 (4, 4, 4, 4, 5)
22 (4, 4, 4, 4, 6)
23 (4, 4, 4, 4, 7)
24 (4, 4, 4, 4, 4, 4)
Returns tuple of one or more integers.
'''
from abjad.tools import mathtools
# check input
assert mathtools.is_positive_integer_equivalent_number(n)
assert mathtools.is_positive_integer_equivalent_number(m)
n, m = int(n), int(m)
# initialize values
result = []
current_value = n
double_m = 2 * m
# partition n
while double_m <= current_value:
result.append(m)
current_value -= m
result.append(current_value)
# return result
return tuple(result)
def all_are_positive_integer_equivalent_numbers(expr):
'''True when `expr` is a sequence and all elements in `expr` are positive
integer-equivalent numbers. Otherwise false:
::
>>> sequencetools.all_are_positive_integer_equivalent_numbers([Fraction(4, 2), 2.0, 2])
True
Returns boolean.
'''
try:
return all(mathtools.is_positive_integer_equivalent_number(x) for x in expr)
except TypeError:
return False
def all_are_positive_integer_equivalent_numbers(expr):
'''Is true when `expr` is a sequence and all elements in `expr` are
positive integer-equivalent numbers. Otherwise false:
::
>>> mathtools.all_are_positive_integer_equivalent_numbers([Fraction(4, 2), 2.0, 2])
True
Returns boolean.
'''
from abjad.tools import mathtools
try:
return all(mathtools.is_positive_integer_equivalent_number(x) for x in expr)
except TypeError:
return False
def test_mathtools_is_positive_integer_equivalent_number_01():
assert mathtools.is_positive_integer_equivalent_number(Duration(4, 2))
assert mathtools.is_positive_integer_equivalent_number(2.0)
assert mathtools.is_positive_integer_equivalent_number(2)
def divide_by_ratio(self, ratio):
r"""Divide timespan expression by `ratio`:
::
>>> timespans = red_segment.timespan.divide_by_ratio((2, 3))
::
>>> print timespans[0].storage_format
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory([
'self._divide_by_ratio(original_start_offset, original_stop_offset, (2, 3), 0)'
])
)
::
>>> print timespans[1].storage_format
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory([
'self._divide_by_ratio(original_start_offset, original_stop_offset, (2, 3), 1)'
])
)
Coerce integer `ratio` to ``Ratio(ratio*[1])``:
::
>>> timespans = red_segment.timespan.divide_by_ratio(3)
::
>>> print timespans[0].storage_format
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory([
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 0)'
])
)
::
>>> print timespans[1].storage_format
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory([
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 1)'
])
)
::
>>> print timespans[2].storage_format
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory([
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 2)'
])
)
Returns tuple of newly constructed timespans with callback.
"""
result = []
if mathtools.is_positive_integer_equivalent_number(ratio):
ratio = int(ratio) * [1]
for part in range(len(ratio)):
callback = "self._divide_by_ratio(original_start_offset, original_stop_offset, {!r}, {!r})"
callback = callback.format(ratio, part)
result.append(self._copy_and_append_callback(callback))
return tuple(result)
def __init__(
self,
talea=(-1, 4, -2, 3),
talea_denominator=16,
prolation_addenda=None,
burnish_specifier=None,
secondary_divisions=None,
helper_functions=None,
beam_each_cell=False,
beam_cells_together=False,
decrease_durations_monotonically=True,
tie_split_notes=False,
burnish_divisions=False,
burnish_output=False,
):
from abjad.tools import rhythmmakertools
RhythmMaker.__init__(
self,
beam_each_cell=beam_each_cell,
beam_cells_together=beam_cells_together,
decrease_durations_monotonically=decrease_durations_monotonically,
)
prototype = (tuple, type(None))
talea = self._to_tuple(talea)
assert isinstance(talea, prototype)
assert sequencetools.all_are_integer_equivalent_numbers(talea)
self._talea = talea
helper_functions = helper_functions or {}
talea_helper = helper_functions.get('talea')
prolation_addenda_helper = helper_functions.get('prolation_addenda')
lefts_helper = helper_functions.get('lefts')
middles_helper = helper_functions.get('middles')
rights_helper = helper_functions.get('rights')
left_lengths_helper = helper_functions.get('left_lengths')
right_lengths_helper = helper_functions.get('right_lengths')
secondary_divisions_helper = helper_functions.get('secondary_divisions')
assert isinstance(burnish_divisions, bool)
assert isinstance(burnish_output, bool)
self._burnish_divisions = burnish_divisions
self._burnish_output = burnish_output
prolation_addenda = self._to_tuple(prolation_addenda)
burnish_specifier = burnish_specifier or \
rhythmmakertools.BurnishSpecifier()
assert isinstance(burnish_specifier, rhythmmakertools.BurnishSpecifier)
self._burnish_specifier = burnish_specifier
secondary_divisions = self._to_tuple(secondary_divisions)
talea_helper = self._none_to_trivial_helper(talea_helper)
prolation_addenda_helper = self._none_to_trivial_helper(
prolation_addenda_helper)
lefts_helper = self._none_to_trivial_helper(lefts_helper)
middles_helper = self._none_to_trivial_helper(middles_helper)
rights_helper = self._none_to_trivial_helper(rights_helper)
left_lengths_helper = self._none_to_trivial_helper(
left_lengths_helper)
right_lengths_helper = self._none_to_trivial_helper(
right_lengths_helper)
secondary_divisions_helper = self._none_to_trivial_helper(
secondary_divisions_helper)
assert mathtools.is_positive_integer_equivalent_number(
talea_denominator)
assert prolation_addenda is None or \
sequencetools.all_are_nonnegative_integer_equivalent_numbers(
prolation_addenda)
assert secondary_divisions is None or \
sequencetools.all_are_nonnegative_integer_equivalent_numbers(
secondary_divisions)
assert callable(talea_helper)
assert callable(prolation_addenda_helper)
assert callable(lefts_helper)
assert callable(middles_helper)
assert callable(rights_helper)
assert callable(left_lengths_helper)
assert callable(right_lengths_helper)
assert isinstance(decrease_durations_monotonically, bool)
assert isinstance(tie_split_notes, bool)
self._talea_denominator = talea_denominator
self._prolation_addenda = prolation_addenda
self._secondary_divisions = secondary_divisions
if helper_functions == {}:
helper_functions = None
self._helper_functions = helper_functions
self._tie_split_notes = tie_split_notes
def __init__(self,
talea=None,
talea_denominator=None,
prolation_addenda=None,
lefts=None,
middles=None,
rights=None,
left_lengths=None,
right_lengths=None,
secondary_divisions=None,
talea_helper=None,
prolation_addenda_helper=None,
lefts_helper=None,
middles_helper=None,
rights_helper=None,
left_lengths_helper=None,
right_lengths_helper=None,
secondary_divisions_helper=None,
beam_each_cell=False,
beam_cells_together=False,
decrease_durations_monotonically=True,
tie_split_notes=False,
tie_rests=False,
):
RhythmMaker.__init__(self,
beam_each_cell=beam_each_cell,
beam_cells_together=beam_cells_together,
)
prolation_addenda = self._none_to_new_list(prolation_addenda)
lefts = self._none_to_new_list(lefts)
middles = self._none_to_new_list(middles)
rights = self._none_to_new_list(rights)
left_lengths = self._none_to_new_list(left_lengths)
right_lengths = self._none_to_new_list(right_lengths)
secondary_divisions = self._none_to_new_list(secondary_divisions)
talea_helper = self._none_to_trivial_helper(talea_helper)
prolation_addenda_helper = self._none_to_trivial_helper(
prolation_addenda_helper)
lefts_helper = self._none_to_trivial_helper(lefts_helper)
middles_helper = self._none_to_trivial_helper(middles_helper)
rights_helper = self._none_to_trivial_helper(rights_helper)
left_lengths_helper = self._none_to_trivial_helper(
left_lengths_helper)
right_lengths_helper = self._none_to_trivial_helper(
right_lengths_helper)
secondary_divisions_helper = self._none_to_trivial_helper(
secondary_divisions_helper)
assert sequencetools.all_are_integer_equivalent_numbers(talea)
assert mathtools.is_positive_integer_equivalent_number(
talea_denominator)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
prolation_addenda)
assert all(x in (-1, 0, 1) for x in lefts)
assert all(x in (-1, 0, 1) for x in middles)
assert all(x in (-1, 0, 1) for x in rights)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
left_lengths)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
right_lengths)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
secondary_divisions)
assert isinstance(talea_helper,
(types.FunctionType, types.MethodType))
assert isinstance(prolation_addenda_helper,
(types.FunctionType, types.MethodType))
assert isinstance(lefts_helper,
(types.FunctionType, types.MethodType))
assert isinstance(middles_helper,
(types.FunctionType, types.MethodType))
assert isinstance(rights_helper,
(types.FunctionType, types.MethodType))
assert isinstance(left_lengths_helper,
(types.FunctionType, types.MethodType))
assert isinstance(right_lengths_helper,
(types.FunctionType, types.MethodType))
assert isinstance(decrease_durations_monotonically, bool)
assert isinstance(tie_split_notes, bool)
assert isinstance(tie_rests, bool)
self.talea = talea
self.talea_denominator = talea_denominator
self.prolation_addenda = prolation_addenda
self.lefts = lefts
self.middles = middles
self.rights = rights
self.left_lengths = left_lengths
self.right_lengths = right_lengths
self.secondary_divisions = secondary_divisions
self.talea_helper = talea_helper
self.prolation_addenda_helper = prolation_addenda_helper
self.lefts_helper = lefts_helper
self.middles_helper = middles_helper
self.rights_helper = rights_helper
self.left_lengths_helper = left_lengths_helper
self.right_lengths_helper = right_lengths_helper
self.secondary_divisions_helper = secondary_divisions_helper
#self.beam_each_cell = beam_each_cell
self.decrease_durations_monotonically = \
decrease_durations_monotonically
self.tie_split_notes = tie_split_notes
self.tie_rests = tie_rests
def __init__(
self,
prefix_talea=None,
prefix_lengths=None,
suffix_talea=None,
suffix_lengths=None,
talea_denominator=None,
body_ratio=None,
prolation_addenda=None,
secondary_divisions=None,
prefix_talea_helper=None,
prefix_lengths_helper=None,
suffix_talea_helper=None,
suffix_lengths_helper=None,
prolation_addenda_helper=None,
secondary_divisions_helper=None,
decrease_durations_monotonically=True,
tie_rests=False,
forbidden_written_duration=None,
beam_each_cell=False,
beam_cells_together=False,
):
RhythmMaker.__init__(
self,
forbidden_written_duration=forbidden_written_duration,
beam_each_cell=beam_each_cell,
beam_cells_together=beam_cells_together,
)
prolation_addenda = \
self._none_to_new_list(prolation_addenda)
secondary_divisions = \
self._none_to_new_list(secondary_divisions)
prefix_talea_helper = \
self._none_to_trivial_helper(prefix_talea_helper)
prefix_lengths_helper = \
self._none_to_trivial_helper(prefix_lengths_helper)
suffix_talea_helper = \
self._none_to_trivial_helper(suffix_talea_helper)
suffix_lengths_helper = \
self._none_to_trivial_helper(suffix_lengths_helper)
prolation_addenda_helper = \
self._none_to_trivial_helper(prolation_addenda_helper)
secondary_divisions_helper = \
self._none_to_trivial_helper(secondary_divisions_helper)
assert sequencetools.all_are_integer_equivalent_numbers(
prefix_talea)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
prefix_lengths)
assert sequencetools.all_are_integer_equivalent_numbers(
suffix_talea)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
suffix_lengths)
assert mathtools.is_positive_integer_equivalent_number(
talea_denominator)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
prolation_addenda)
assert sequencetools.all_are_nonnegative_integer_equivalent_numbers(
secondary_divisions)
assert isinstance(
prefix_talea_helper, (types.FunctionType, types.MethodType))
assert isinstance(
prefix_lengths_helper, (types.FunctionType, types.MethodType))
assert isinstance(
suffix_talea_helper, (types.FunctionType, types.MethodType))
assert isinstance(
suffix_lengths_helper, (types.FunctionType, types.MethodType))
assert isinstance(
prolation_addenda_helper, (types.FunctionType, types.MethodType))
assert isinstance(
secondary_divisions_helper, (types.FunctionType, types.MethodType))
assert isinstance(
decrease_durations_monotonically, bool)
assert isinstance(
tie_rests, bool)
self.prefix_talea = prefix_talea
self.prefix_lengths = prefix_lengths
self.suffix_talea = suffix_talea
self.suffix_lengths = suffix_lengths
self.prolation_addenda = prolation_addenda
self.talea_denominator = talea_denominator
if body_ratio is not None:
body_ratio = mathtools.Ratio(body_ratio)
self.body_ratio = body_ratio
self.secondary_divisions = secondary_divisions
self.prefix_talea_helper = \
self._none_to_trivial_helper(prefix_talea_helper)
self.prefix_lengths_helper = \
self._none_to_trivial_helper(prefix_lengths_helper)
self.suffix_talea_helper = \
self._none_to_trivial_helper(suffix_talea_helper)
self.suffix_lengths_helper = \
self._none_to_trivial_helper(suffix_lengths_helper)
self.prolation_addenda_helper = \
self._none_to_trivial_helper(prolation_addenda_helper)
self.secondary_divisions_helper = \
self._none_to_trivial_helper(secondary_divisions_helper)
self.decrease_durations_monotonically = \
decrease_durations_monotonically
self.tie_rests = tie_rests
def divide_by_ratio(self, ratio):
r'''Divide timespan expression by `ratio`:
::
>>> timespans = red_segment.timespan.divide_by_ratio((2, 3))
::
>>> print(format(timespans[0]))
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory(
[
'self._divide_by_ratio(original_start_offset, original_stop_offset, (2, 3), 0)',
]
),
)
::
>>> print(format(timespans[1]))
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory(
[
'self._divide_by_ratio(original_start_offset, original_stop_offset, (2, 3), 1)',
]
),
)
Coerce integer `ratio` to ``Ratio(ratio*[1])``:
::
>>> timespans = red_segment.timespan.divide_by_ratio(3)
::
>>> print(format(timespans[0]))
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory(
[
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 0)',
]
),
)
::
>>> print(format(timespans[1]))
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory(
[
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 1)',
]
),
)
::
>>> print(format(timespans[2]))
musicexpressiontools.TimespanExpression(
anchor='red',
callbacks=musicexpressiontools.CallbackInventory(
[
'self._divide_by_ratio(original_start_offset, original_stop_offset, [1, 1, 1], 2)',
]
),
)
Returns tuple of newly constructed timespans with callback.
'''
result = []
if mathtools.is_positive_integer_equivalent_number(ratio):
ratio = int(ratio) * [1]
for part in range(len(ratio)):
callback = \
'self._divide_by_ratio(original_start_offset, original_stop_offset, {!r}, {!r})'
callback = callback.format(ratio, part)
result.append(self._copy_and_append_callback(callback))
return tuple(result)