def with_power_of_two_denominator(
self,
contents_multiplier=1,
) -> 'TimeSignature':
"""
Makes new time signature equivalent to current time signature with
power-of-two denominator.
.. container:: example
Non-power-of-two denominator with power-of-two denominator:
>>> time_signature = abjad.TimeSignature((3, 12))
>>> time_signature.with_power_of_two_denominator()
TimeSignature((2, 8))
"""
contents_multiplier = Multiplier(contents_multiplier)
contents_multiplier = Multiplier(contents_multiplier)
non_power_of_two_denominator = self.denominator
if contents_multiplier == Multiplier(1):
power_of_two_denominator = \
mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator)
else:
power_of_two_denominator = \
mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator, 1)
non_power_of_two_pair = NonreducedFraction(self.pair)
power_of_two_fraction = non_power_of_two_pair.with_denominator(
power_of_two_denominator)
power_of_two_pair = power_of_two_fraction.pair
return type(self)(power_of_two_pair)
def with_power_of_two_denominator(
self, contents_multiplier=1
) -> "TimeSignature":
"""
Makes new time signature equivalent to current time signature with
power-of-two denominator.
.. container:: example
Non-power-of-two denominator with power-of-two denominator:
>>> time_signature = abjad.TimeSignature((3, 12))
>>> time_signature.with_power_of_two_denominator()
TimeSignature((2, 8))
"""
contents_multiplier = Multiplier(contents_multiplier)
contents_multiplier = Multiplier(contents_multiplier)
non_power_of_two_denominator = self.denominator
if contents_multiplier == Multiplier(1):
power_of_two_denominator = mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator
)
else:
power_of_two_denominator = mathtools.greatest_power_of_two_less_equal(
non_power_of_two_denominator, 1
)
non_power_of_two_pair = NonreducedFraction(self.pair)
power_of_two_fraction = non_power_of_two_pair.with_denominator(
power_of_two_denominator
)
power_of_two_pair = power_of_two_fraction.pair
return type(self)(power_of_two_pair)
def duration(self) -> NonreducedFraction:
"""
Gets duration of Scheme moment.
.. container:: example
>>> abjad.SchemeMoment((2, 68)).duration
NonreducedFraction(2, 68)
"""
return NonreducedFraction(self.value)
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.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 __add__(self, argument) -> 'TimeSignature':
"""
Adds time signature to ``argument``.
.. container:: example
Adds two time signatures with the same denominator:
>>> abjad.TimeSignature((3, 4)) + abjad.TimeSignature((3, 4))
TimeSignature((6, 4))
.. container:: example
Adds two time signatures with different denominators:
>>> abjad.TimeSignature((3, 4)) + abjad.TimeSignature((6, 8))
TimeSignature((12, 8))
Returns new time signature in terms of greatest denominator.
"""
if not isinstance(argument, type(self)):
raise Exception('must be time signature: {argument!r}.')
nonreduced_1 = NonreducedFraction(
self.numerator,
self.denominator,
)
nonreduced_2 = NonreducedFraction(
argument.numerator,
argument.denominator,
)
result = nonreduced_1 + nonreduced_2
result = type(self)((
result.numerator,
result.denominator,
))
return result
def __init__(
self,
duration: typings.IntegerPair = (0, 1),
) -> None:
pair = NonreducedFraction(duration).pair
Scheme.__init__(self, pair)
def _make_tied_leaf(
class_,
duration,
increase_monotonic=None,
forbidden_duration=None,
multiplier=None,
pitches=None,
tag=None,
tie_parts=True,
repeat_ties=False,
):
from abjad.spanners import tie as abjad_tie
duration = Duration(duration)
if forbidden_duration is not None:
assert forbidden_duration.is_assignable
assert forbidden_duration.numerator == 1
# find preferred numerator of written durations if necessary
if forbidden_duration is not None and forbidden_duration <= duration:
denominators = [
2 * forbidden_duration.denominator,
duration.denominator,
]
denominator = mathtools.least_common_multiple(*denominators)
forbidden_duration = NonreducedFraction(forbidden_duration)
forbidden_duration = forbidden_duration.with_denominator(
denominator
)
duration = NonreducedFraction(duration)
duration = duration.with_denominator(denominator)
forbidden_numerator = forbidden_duration.numerator
assert forbidden_numerator % 2 == 0
preferred_numerator = forbidden_numerator / 2
# make written duration numerators
numerators = []
parts = mathtools.partition_integer_into_canonic_parts(
duration.numerator
)
if forbidden_duration is not None and forbidden_duration <= duration:
for part in parts:
if forbidden_numerator <= part:
better_parts = LeafMaker._partition_less_than_double(
part, preferred_numerator
)
numerators.extend(better_parts)
else:
numerators.append(part)
else:
numerators = parts
# reverse numerators if necessary
if increase_monotonic:
numerators = list(reversed(numerators))
# make one leaf per written duration
result = []
for numerator in numerators:
written_duration = Duration(numerator, duration.denominator)
if pitches is not None:
arguments = (pitches, written_duration)
else:
arguments = (written_duration,)
result.append(class_(*arguments, multiplier=multiplier, tag=tag))
result = Selection(result)
# tie if required
if tie_parts and 1 < len(result):
if not issubclass(class_, (Rest, Skip)):
abjad_tie(result, repeat=repeat_ties)
return result
def __init__(
self,
duration: typing.Union[typing.Tuple[int, int]] = (0, 1),
) -> None:
pair = NonreducedFraction(duration).pair
Scheme.__init__(self, pair)
def _make_tied_leaf(
class_,
duration,
increase_monotonic=None,
forbidden_duration=None,
multiplier=None,
pitches=None,
tag=None,
tie_parts=True,
repeat_ties=False,
):
from abjad.spanners import tie as abjad_tie
duration = Duration(duration)
if forbidden_duration is not None:
assert forbidden_duration.is_assignable
assert forbidden_duration.numerator == 1
# find preferred numerator of written durations if necessary
if (forbidden_duration is not None and forbidden_duration <= duration):
denominators = [
2 * forbidden_duration.denominator,
duration.denominator,
]
denominator = mathtools.least_common_multiple(*denominators)
forbidden_duration = NonreducedFraction(forbidden_duration)
forbidden_duration = forbidden_duration.with_denominator(
denominator)
duration = NonreducedFraction(duration)
duration = duration.with_denominator(denominator)
forbidden_numerator = forbidden_duration.numerator
assert forbidden_numerator % 2 == 0
preferred_numerator = forbidden_numerator / 2
# make written duration numerators
numerators = []
parts = mathtools.partition_integer_into_canonic_parts(
duration.numerator)
if (forbidden_duration is not None and forbidden_duration <= duration):
for part in parts:
if forbidden_numerator <= part:
better_parts = LeafMaker._partition_less_than_double(
part,
preferred_numerator,
)
numerators.extend(better_parts)
else:
numerators.append(part)
else:
numerators = parts
# reverse numerators if necessary
if increase_monotonic:
numerators = list(reversed(numerators))
# make one leaf per written duration
result = []
for numerator in numerators:
written_duration = Duration(
numerator,
duration.denominator,
)
if pitches is not None:
arguments = (pitches, written_duration)
else:
arguments = (written_duration, )
result.append(class_(*arguments, multiplier=multiplier, tag=tag))
result = Selection(result)
# tie if required
if tie_parts and 1 < len(result):
if not issubclass(class_, (Rest, Skip)):
abjad_tie(result, repeat=repeat_ties)
return 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)