def glissando_rhythm(rotate=0):
return baca.rhythm(
rmakers.talea(abjad.sequence.rotate([5, 1, 2, 1], n=rotate), 8),
rmakers.beam(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
tag=abjad.Tag("animales.glissando_rhythm()"),
)
def clb_rhythm(
section: str,
member: int,
counts: typing.Sequence[abjad.IntegerSequence],
wrap: int,
):
if section in ("First.Violin", "Second.Violin", "Viola"):
assert member in range(1, 18 + 1), repr(member)
elif section == "Cello":
assert member in range(1, 14 + 1), repr(member)
elif section == "Contrabass":
assert member in range(1, 6 + 1), repr(member)
else:
assert ValueError(section)
section_to_offset = {
"First.Violin": 0,
"Second.Violin": 18,
"Viola": 36,
"Cello": 54,
"Contrabass": 68,
}
total_players = 74
index = section_to_offset[section] + member - 1
counts_ = baca.sequence.helianthate(counts, -1, -1)
counts_ = abjad.sequence.flatten(counts_)
counts_ = abjad.sequence.repeat_to_weight(counts_, total_players * wrap)
shards = abjad.sequence.split(counts_, [wrap],
cyclic=True,
overhang=abjad.Exact)
assert len(shards) == total_players
assert abjad.sequence.weight(shards) == abjad.sequence.weight(counts_)
counts_ = shards[index]
extra_counts = None
if index % 9 in [2, 3, 6, 7]:
extra_counts = [-1]
def preprocessor(divisions):
result = baca.sequence.fuse(divisions)
result = baca.sequence.quarters(result)
return result
return baca.rhythm(
rmakers.talea(counts_, 16, extra_counts=extra_counts),
rmakers.beam(),
rmakers.rewrite_rest_filled(),
rmakers.trivialize(),
rmakers.force_diminution(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
preprocessor=preprocessor,
tag=abjad.Tag("animales.clb_rhythm()"),
)
def downbeat_attack(count=1, denominator=8):
return baca.rhythm(
rmakers.talea([count], denominator),
rmakers.force_rest(baca.selectors.lts((1, None)), ),
rmakers.beam(),
rmakers.rewrite_rest_filled(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
tag=abjad.Tag("animales.downbeat_attack()"),
)
def make_tied_notes(*, measures: typings.SliceTyping = None) -> RhythmCommand:
"""
Makes tied notes; rewrites meter.
"""
return RhythmCommand(
rmakers.stack(
rmakers.note(),
rmakers.beam(classes.select().plts()),
rmakers.tie(classes.select().ptails()[:-1]),
rmakers.rewrite_meter(),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def brass_manifest_rhythm(part):
assert part in range(1, 12 + 1), repr(part)
counts, delay, extra_counts = {
1: ([8, 8, -2], 9, [0, 0, 0, 1]),
2: ([8, 8, -2], 13, [0, 1, 0, 0]),
3: ([8, 8, -2], None, [0, 0, 1, 0]),
4: ([8, 8, -2], 4, [1, 0, 0, 0]),
5: ([7, 7, -2], 6, [0, 0, 0, 1]),
6: ([7, 7, -2], 10, [0, 1, 0, 0]),
7: ([7, 7, -2], None, [0, 0, 1, 0]),
8: ([7, 7, -2], 4, [1, 0, 0, 0]),
9: ([6, 6, 6, -2], 9, [0, 0, 0, 1]),
10: ([6, 6, 6, -2], 13, [0, 1, 0, 0]),
11: ([6, 6, 6, -2], None, [0, 0, 1, 0]),
12: ([6, 6, 6, -2], 4, [1, 0, 0, 0]),
}[part]
if delay is None:
preamble = ()
else:
preamble = [-delay]
def preprocessor(divisions):
result = baca.sequence.fuse(divisions)
result = baca.sequence.quarters(divisions)
return result
return baca.rhythm(
rmakers.talea(counts, 8, extra_counts=extra_counts, preamble=preamble),
rmakers.beam(),
rmakers.rewrite_rest_filled(),
rmakers.trivialize(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
preprocessor=preprocessor,
persist="brass_manifest_rhythm",
tag=abjad.Tag("animales.brass_manifest_rhythm()"),
)
def pennant_rhythm(extra_counts=None, silences=None):
commands = []
if silences is not None:
specifier = rmakers.force_rest(baca.selectors.tuplets(silences), )
commands.append(specifier)
def preprocessor(divisions):
result = baca.sequence.fuse(divisions)
result = baca.sequence.quarters(divisions)
return result
return baca.rhythm(
rmakers.talea([1], 16, extra_counts=extra_counts),
*commands,
rmakers.beam(),
rmakers.rewrite_rest_filled(),
rmakers.force_diminution(),
rmakers.trivialize(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
preprocessor=preprocessor,
tag=abjad.Tag("animales.pennant_rhythm()"),
)
def make_repeated_duration_notes(
durations: typing.Sequence[abjad.DurationTyping],
*specifiers: rmakers.Command,
do_not_rewrite_meter: bool = None,
measures: typings.SliceTyping = None,
) -> RhythmCommand:
"""
Makes repeated-duration notes; rewrites meter.
"""
if isinstance(durations, abjad.Duration):
durations = [durations]
elif isinstance(durations, tuple):
assert len(durations) == 2
durations = [abjad.Duration(durations)]
def preprocessor(divisions):
divisions = classes.Sequence(divisions)
divisions = divisions.fuse()
divisions = divisions.split_divisions(durations, cyclic=True)
return divisions
rewrite_specifiers: typing.List[rmakers.Command] = []
if not do_not_rewrite_meter:
rewrite_specifiers.append(rmakers.rewrite_meter())
return RhythmCommand(
rmakers.stack(
rmakers.note(),
*specifiers,
*rewrite_specifiers,
rmakers.force_repeat_tie(),
preprocessor=preprocessor,
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def make_notes(
*specifiers,
measures: typings.SliceTyping = None,
repeat_ties: bool = False,
) -> RhythmCommand:
"""
Makes notes; rewrites meter.
"""
if repeat_ties:
repeat_tie_specifier = [rmakers.force_repeat_tie()]
else:
repeat_tie_specifier = []
return RhythmCommand(
rmakers.stack(
rmakers.note(),
*specifiers,
rmakers.rewrite_meter(),
*repeat_tie_specifier,
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def harp_exchange_rhythm(this_part, *commands, silence_first=False):
part_to_pattern = dict([
(0, abjad.index([0, 30], period=36)),
(1, abjad.index([0, 12, 16, 28, 32], period=48)),
(2, abjad.index([0, 30], period=36)),
(3, abjad.index([0, 12, 16, 28, 32], period=48)),
])
part_to_indices = {}
for part in part_to_pattern:
part_to_indices[part] = []
harp_indices = []
part = 0
pattern = part_to_pattern[part]
index = 0
while True:
if index % pattern.period in pattern.indices:
part_to_indices[part].append(index)
harp_indices.append((index, part))
degrees = []
for indices in part_to_indices.values():
talea = abjad.math.difference_series(indices)
degree = baca.sequence.degree_of_rotational_symmetry(talea)
degrees.append(degree)
if all(1 < _ for _ in degrees):
break
part = (part + 1) % len(part_to_pattern)
pattern = part_to_pattern[part]
index += 1
if 999 < index:
break
part_to_preamble = {}
part_to_counts = {}
for part, indices in part_to_indices.items():
offset = indices[0]
preamble = []
if offset != 0:
preamble.append(offset)
part_to_preamble[part] = preamble
counts = abjad.math.difference_series(indices)
period = baca.sequence.period_of_rotation(counts)
counts = counts[:period]
part_to_counts[part] = counts
preamble = part_to_preamble[this_part]
counts = []
for count in part_to_counts[this_part]:
counts.append(2)
rest = -(count - 2)
counts.append(rest)
silence_first_specifier = []
if silence_first is True:
specifier = rmakers.force_rest(baca.selectors.lt(0))
silence_first_specifier.append(specifier)
def preprocessor(divisions):
result = baca.sequence.fuse(divisions)
result = baca.sequence.quarters(result)
return result
return baca.rhythm(
rmakers.talea(counts, 16, extra_counts=[2], preamble=preamble),
*commands,
rmakers.cache_state(),
*silence_first_specifier,
rmakers.beam(),
rmakers.trivialize(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
rmakers.force_repeat_tie(),
preprocessor=preprocessor,
persist="harp_exchange_rhythm",
tag=abjad.Tag("animales.harp_exchange_rhythm()"),
)
def sforzando_exchange_rhythm(this_part):
part_to_pattern = dict([
(0, abjad.index([0, 15], period=18)),
(1, abjad.index([0, 6, 8, 14, 16], period=24)),
(2, abjad.index([0, 15], period=18)),
(3, abjad.index([0, 6, 8, 14, 16], period=24)),
(4, abjad.index([0, 15], period=18)),
(5, abjad.index([0, 6, 8, 14, 16], period=24)),
(6, abjad.index([0, 15], period=18)),
])
part_to_indices = {}
for part in part_to_pattern:
part_to_indices[part] = []
sforzando_indices = []
part = 0
pattern = part_to_pattern[part]
index = 0
while True:
if index % pattern.period in pattern.indices:
part_to_indices[part].append(index)
sforzando_indices.append((index, part))
degrees = []
for indices in part_to_indices.values():
talea = abjad.math.difference_series(indices)
degree = baca.sequence.degree_of_rotational_symmetry(talea)
degrees.append(degree)
if all(1 < _ for _ in degrees):
break
part = (part + 1) % len(part_to_pattern)
pattern = part_to_pattern[part]
index += 1
part_to_preamble = {}
part_to_counts = {}
for part, indices in part_to_indices.items():
offset = indices[0]
preamble = []
if offset != 0:
preamble.append(offset)
part_to_preamble[part] = preamble
counts = abjad.math.difference_series(indices)
period = baca.sequence.period_of_rotation(counts)
counts = counts[:period]
part_to_counts[part] = counts
preamble = part_to_preamble[this_part]
counts = part_to_counts[this_part]
def preprocessor(divisions):
result = baca.sequence.fuse(divisions)
result = baca.sequence.quarters(divisions)
return result
return baca.rhythm(
rmakers.talea(counts, 16, extra_counts=[2], preamble=preamble),
rmakers.beam(),
rmakers.trivialize(),
rmakers.extract_trivial(),
rmakers.rewrite_meter(),
rmakers.force_repeat_tie(),
preprocessor=preprocessor,
persist="sforzando_exchange_rhythm",
tag=abjad.Tag("animales.sforzando_exchange_rhythm()"),
)
def make_repeat_tied_notes(
*specifiers: rmakers.Command,
do_not_rewrite_meter: bool = None,
measures: typings.SliceTyping = None,
) -> RhythmCommand:
r"""
Makes repeat-tied notes; rewrites meter.
.. container:: example
REGRESSION. All notes below are tagged NOT_YET_PITCHED_COLORING (and
colored gold), even tied notes resulting from meter rewriting:
>>> maker = baca.SegmentMaker(
... score_template=baca.SingleStaffScoreTemplate(),
... spacing=baca.minimum_duration((1, 12)),
... time_signatures=[(10, 8)],
... )
>>> maker(
... 'Music_Voice',
... baca.make_repeat_tied_notes(),
... )
>>> lilypond_file = maker.run(environment='docs')
>>> abjad.show(lilypond_file) # doctest: +SKIP
.. docs::
>>> string = abjad.lilypond(lilypond_file[abjad.Score])
>>> print(string)
<BLANKLINE>
\context Score = "Score"
<<
<BLANKLINE>
\context GlobalContext = "Global_Context"
<<
<BLANKLINE>
\context GlobalSkips = "Global_Skips"
{
<BLANKLINE>
% [Global_Skips measure 1]
\baca-new-spacing-section #1 #12
\time 10/8
\baca-time-signature-color #'blue
s1 * 5/4
<BLANKLINE>
% [Global_Skips measure 2]
\baca-new-spacing-section #1 #4
\time 1/4
\baca-time-signature-transparent
s1 * 1/4
\once \override Score.BarLine.transparent = ##t
\once \override Score.SpanBar.transparent = ##t
<BLANKLINE>
}
<BLANKLINE>
>>
<BLANKLINE>
\context MusicContext = "Music_Context"
<<
<BLANKLINE>
\context Staff = "Music_Staff"
{
<BLANKLINE>
\context Voice = "Music_Voice"
{
<BLANKLINE>
% [Music_Voice measure 1]
\baca-not-yet-pitched-coloring
b'4.
- \abjad-dashed-line-with-hook
- \baca-text-spanner-left-text "make_repeat_tied_notes()"
- \tweak bound-details.right.padding 2.75
- \tweak color #darkcyan
- \tweak staff-padding 8
\bacaStartTextSpanRhythmAnnotation
- \tweak stencil ##f
~
<BLANKLINE>
\baca-not-yet-pitched-coloring
b'4
\repeatTie
- \tweak stencil ##f
~
<BLANKLINE>
\baca-not-yet-pitched-coloring
b'4.
\repeatTie
- \tweak stencil ##f
~
<BLANKLINE>
\baca-not-yet-pitched-coloring
b'4
\repeatTie
<> \bacaStopTextSpanRhythmAnnotation
<BLANKLINE>
<<
<BLANKLINE>
\context Voice = "Music_Voice"
{
<BLANKLINE>
% [Music_Voice measure 2]
\abjad-invisible-music-coloring
%@% \abjad-invisible-music
\baca-not-yet-pitched-coloring
b'1 * 1/4
%@% ^ \baca-duration-multiplier-markup #"1" #"4"
<BLANKLINE>
}
<BLANKLINE>
\context Voice = "Rest_Voice"
{
<BLANKLINE>
% [Rest_Voice measure 2]
\once \override Score.TimeSignature.X-extent = ##f
\once \override MultiMeasureRest.transparent = ##t
\stopStaff
\once \override Staff.StaffSymbol.transparent = ##t
\startStaff
R1 * 1/4
%@% ^ \baca-duration-multiplier-markup #"1" #"4"
<BLANKLINE>
}
<BLANKLINE>
>>
<BLANKLINE>
}
<BLANKLINE>
}
<BLANKLINE>
>>
<BLANKLINE>
>>
"""
specifier: rmakers.Command
specifiers_ = list(specifiers)
specifier = rmakers.beam(classes.select().plts())
specifiers_.append(specifier)
specifier = rmakers.repeat_tie(classes.select().pheads()[1:])
specifiers_.append(specifier)
if not do_not_rewrite_meter:
command = rmakers.rewrite_meter()
specifiers_.append(command)
specifier = rmakers.force_repeat_tie()
specifiers_.append(specifier)
return RhythmCommand(
rmakers.stack(rmakers.note(),
*specifiers_,
tag=_site(inspect.currentframe())),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
)