def _least_common_multiple_helper(m, n):
from abjad import mathtools
assert isinstance(m, int), repr(m)
assert isinstance(n, int), repr(n)
factors_m = mathtools.factors(m)
factors_n = mathtools.factors(n)
for x in factors_m:
try:
factors_n.remove(x)
except ValueError:
pass
result = 1
for x in factors_m + factors_n:
result *= x
return result
def _least_common_multiple_helper(m, n):
from abjad import mathtools
assert isinstance(m, int), repr(m)
assert isinstance(n, int), repr(n)
factors_m = mathtools.factors(m)
factors_n = mathtools.factors(n)
for x in factors_m:
try:
factors_n.remove(x)
except ValueError:
pass
result = 1
for x in factors_m + factors_n:
result *= x
return result
def _group_by_implied_prolation(durations):
durations = [
mathtools.NonreducedFraction(duration) for duration in durations
]
assert 0 < len(durations)
group = [durations[0]]
result = [group]
for d in durations[1:]:
d_f = set(mathtools.factors(d.denominator))
d_f.discard(2)
gd_f = set(mathtools.factors(group[0].denominator))
gd_f.discard(2)
if d_f == gd_f:
group.append(d)
else:
group = [d]
result.append(group)
return result
def _group_by_implied_prolation(durations):
durations = [
mathtools.NonreducedFraction(duration) for duration in durations
]
assert 0 < len(durations)
group = [durations[0]]
result = [group]
for d in durations[1:]:
d_f = set(mathtools.factors(d.denominator))
d_f.discard(2)
gd_f = set(mathtools.factors(group[0].denominator))
gd_f.discard(2)
if d_f == gd_f:
group.append(d)
else:
group = [d]
result.append(group)
return result
def __call__(self, pitches, durations) -> Selection:
"""
Calls note-maker on ``pitches`` and ``durations``.
"""
from .Tuplet import Tuplet
if isinstance(pitches, str):
pitches = pitches.split()
if not isinstance(pitches, collections.abc.Iterable):
pitches = [pitches]
if isinstance(durations, (numbers.Number, tuple)):
durations = [durations]
nonreduced_fractions = Sequence(
[NonreducedFraction(_) for _ in durations]
)
size = max(len(nonreduced_fractions), len(pitches))
nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
pitches = Sequence(pitches).repeat_to_length(size)
durations = Duration._group_by_implied_prolation(nonreduced_fractions)
result: typing.List[typing.Union[Note, Tuplet]] = []
for duration in durations:
# get factors in denominator of duration group duration not 1 or 2
factors = set(mathtools.factors(duration[0].denominator))
factors.discard(1)
factors.discard(2)
ps = pitches[0 : len(duration)]
pitches = pitches[len(duration) :]
if len(factors) == 0:
result.extend(
self._make_unprolated_notes(
ps,
duration,
increase_monotonic=self.increase_monotonic,
repeat_ties=self.repeat_ties,
tag=self.tag,
)
)
else:
# compute prolation
denominator = duration[0].denominator
numerator = mathtools.greatest_power_of_two_less_equal(
denominator
)
multiplier = Multiplier(numerator, denominator)
ratio = multiplier.reciprocal
duration = [ratio * Duration(d) for d in duration]
ns = self._make_unprolated_notes(
ps,
duration,
increase_monotonic=self.increase_monotonic,
repeat_ties=self.repeat_ties,
tag=self.tag,
)
tuplet = Tuplet(multiplier, ns)
result.append(tuplet)
return Selection(result)
def __call__(self, pitches, durations) -> Selection:
"""
Calls note-maker on ``pitches`` and ``durations``.
"""
from .Tuplet import Tuplet
if isinstance(pitches, str):
pitches = pitches.split()
if not isinstance(pitches, collections.abc.Iterable):
pitches = [pitches]
if isinstance(durations, (numbers.Number, tuple)):
durations = [durations]
nonreduced_fractions = Sequence(
[NonreducedFraction(_) for _ in durations]
)
size = max(len(nonreduced_fractions), len(pitches))
nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
pitches = Sequence(pitches).repeat_to_length(size)
durations = Duration._group_by_implied_prolation(nonreduced_fractions)
result: typing.List[typing.Union[Note, Tuplet]] = []
for duration in durations:
# get factors in denominator of duration group duration not 1 or 2
factors = set(mathtools.factors(duration[0].denominator))
factors.discard(1)
factors.discard(2)
ps = pitches[0 : len(duration)]
pitches = pitches[len(duration) :]
if len(factors) == 0:
result.extend(
self._make_unprolated_notes(
ps,
duration,
increase_monotonic=self.increase_monotonic,
tag=self.tag,
)
)
else:
# compute prolation
denominator = duration[0].denominator
numerator = mathtools.greatest_power_of_two_less_equal(
denominator
)
multiplier = Multiplier(numerator, denominator)
ratio = multiplier.reciprocal
duration = [ratio * Duration(d) for d in duration]
ns = self._make_unprolated_notes(
ps,
duration,
increase_monotonic=self.increase_monotonic,
tag=self.tag,
)
tuplet = Tuplet(multiplier, ns)
result.append(tuplet)
return Selection(result)
def are_relatively_prime(argument):
"""
Is true when ``argument`` is an iterable collection of relative primes.
.. container:: example
>>> abjad.mathtools.are_relatively_prime([13, 14, 15])
True
>>> abjad.mathtools.are_relatively_prime([13, 14, 15, 16])
False
>>> abjad.mathtools.are_relatively_prime('text')
False
.. container:: example
Returns true when ``argument`` is empty:
>>> abjad.mathtools.are_relatively_prime([])
True
Returns true or false.
"""
from abjad import mathtools
if not isinstance(argument, collections.abc.Iterable):
return False
if not all(isinstance(_, numbers.Number) for _ in argument):
return False
all_factors = set([])
for number in argument:
current_factors = mathtools.factors(number)
current_factors = set(current_factors)
if all_factors & current_factors:
return False
all_factors.update(current_factors)
return True
def are_relatively_prime(argument):
"""
Is true when ``argument`` is an iterable collection of relative primes.
.. container:: example
>>> abjad.mathtools.are_relatively_prime([13, 14, 15])
True
>>> abjad.mathtools.are_relatively_prime([13, 14, 15, 16])
False
>>> abjad.mathtools.are_relatively_prime('text')
False
.. container:: example
Returns true when ``argument`` is empty:
>>> abjad.mathtools.are_relatively_prime([])
True
Returns true or false.
"""
from abjad import mathtools
if not isinstance(argument, collections.Iterable):
return False
if not all(isinstance(_, numbers.Number) for _ in argument):
return False
all_factors = set([])
for number in argument:
current_factors = mathtools.factors(number)
current_factors = set(current_factors)
if all_factors & current_factors:
return False
all_factors.update(current_factors)
return True
def __call__(self, pitches, durations) -> Selection:
"""
Calls leaf-maker on ``pitches`` and ``durations``.
Returns selection.
"""
from .Tuplet import Tuplet
if isinstance(pitches, str):
pitches = pitches.split()
if not isinstance(pitches, collections.abc.Iterable):
pitches = [pitches]
if isinstance(durations, (numbers.Number, tuple)):
durations = [durations]
nonreduced_fractions = Sequence(
[NonreducedFraction(_) for _ in durations]
)
size = max(len(nonreduced_fractions), len(pitches))
nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
pitches = Sequence(pitches).repeat_to_length(size)
duration_groups = Duration._group_by_implied_prolation(
nonreduced_fractions
)
result: typing.List[typing.Union[Tuplet, Leaf]] = []
for duration_group in duration_groups:
# get factors in denominator of duration group other than 1, 2.
factors = mathtools.factors(duration_group[0].denominator)
factors = set(factors)
factors.discard(1)
factors.discard(2)
current_pitches = pitches[0 : len(duration_group)]
pitches = pitches[len(duration_group) :]
if len(factors) == 0:
for pitch, duration in zip(current_pitches, duration_group):
leaves = self._make_leaf_on_pitch(
pitch,
duration,
increase_monotonic=self.increase_monotonic,
forbidden_note_duration=self.forbidden_note_duration,
forbidden_rest_duration=self.forbidden_rest_duration,
repeat_ties=self.repeat_ties,
skips_instead_of_rests=self.skips_instead_of_rests,
tag=self.tag,
use_multimeasure_rests=self.use_multimeasure_rests,
)
result.extend(leaves)
else:
# compute tuplet prolation
denominator = duration_group[0].denominator
numerator = mathtools.greatest_power_of_two_less_equal(
denominator
)
multiplier = (numerator, denominator)
ratio = 1 / Duration(*multiplier)
duration_group = [
ratio * Duration(duration) for duration in duration_group
]
# make tuplet leaves
tuplet_leaves: typing.List[Leaf] = []
for pitch, duration in zip(current_pitches, duration_group):
leaves = self._make_leaf_on_pitch(
pitch,
duration,
increase_monotonic=self.increase_monotonic,
repeat_ties=self.repeat_ties,
skips_instead_of_rests=self.skips_instead_of_rests,
tag=self.tag,
use_multimeasure_rests=self.use_multimeasure_rests,
)
tuplet_leaves.extend(leaves)
tuplet = Tuplet(multiplier, tuplet_leaves)
result.append(tuplet)
return Selection(result)
def __call__(self, pitches, durations) -> Selection:
"""
Calls leaf-maker on ``pitches`` and ``durations``.
Returns selection.
"""
from .Tuplet import Tuplet
if isinstance(pitches, str):
pitches = pitches.split()
if not isinstance(pitches, collections.Iterable):
pitches = [pitches]
if isinstance(durations, (numbers.Number, tuple)):
durations = [durations]
nonreduced_fractions = Sequence(
[NonreducedFraction(_) for _ in durations])
size = max(len(nonreduced_fractions), len(pitches))
nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
pitches = Sequence(pitches).repeat_to_length(size)
duration_groups = Duration._group_by_implied_prolation(
nonreduced_fractions)
result: typing.List[typing.Union[Tuplet, Leaf]] = []
for duration_group in duration_groups:
# get factors in denominator of duration group other than 1, 2.
factors = mathtools.factors(duration_group[0].denominator)
factors = set(factors)
factors.discard(1)
factors.discard(2)
current_pitches = pitches[0:len(duration_group)]
pitches = pitches[len(duration_group):]
if len(factors) == 0:
for pitch, duration in zip(current_pitches, duration_group):
leaves = self._make_leaf_on_pitch(
pitch,
duration,
increase_monotonic=self.increase_monotonic,
forbidden_note_duration=self.forbidden_note_duration,
forbidden_rest_duration=self.forbidden_rest_duration,
repeat_ties=self.repeat_ties,
skips_instead_of_rests=self.skips_instead_of_rests,
tag=self.tag,
use_multimeasure_rests=self.use_multimeasure_rests,
)
result.extend(leaves)
else:
# compute tuplet prolation
denominator = duration_group[0].denominator
numerator = mathtools.greatest_power_of_two_less_equal(
denominator)
multiplier = (numerator, denominator)
ratio = 1 / Duration(*multiplier)
duration_group = [
ratio * Duration(duration) for duration in duration_group
]
# make tuplet leaves
tuplet_leaves: typing.List[Leaf] = []
for pitch, duration in zip(current_pitches, duration_group):
leaves = self._make_leaf_on_pitch(
pitch,
duration,
increase_monotonic=self.increase_monotonic,
repeat_ties=self.repeat_ties,
skips_instead_of_rests=self.skips_instead_of_rests,
tag=self.tag,
use_multimeasure_rests=self.use_multimeasure_rests,
)
tuplet_leaves.extend(leaves)
tuplet = Tuplet(multiplier, tuplet_leaves)
result.append(tuplet)
return Selection(result)
