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 make_music(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=(0, 0, 0),
),
rmakers.beam()
)
selection = stack(divisions)
# attach time signature to first leaf in each tuplet
assert len(divisions) == len(selection)
for division, tuplet in zip(divisions, selection):
time_signature = abjad.TimeSignature(division)
leaf = abjad.select(tuplet).leaf(0)
abjad.attach(time_signature, leaf)
# apply pitch material
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True) # make iterator out of selection using logical ties as virtual measures
iterator = enumerate(iterator) # makes enum out of iterator
for index, logical_tie in iterator:
print("entered the loop make_music")
pitch = cyclic_tuple[index]
print(pitch)
for old_leaf in logical_tie:
print("here is the old leaf: ", old_leaf)
if isinstance(pitch, int):
print("in if pitch is still", pitch)
old_leaf.written_pitch = pitch
print(old_leaf)
elif isinstance(pitch, list):
print("entered elif")
print("pitch is still", pitch)
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
print("this is the new leaf: ", new_leaf)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
elif isinstance(pitch, abjad.Chord):
print("entered elif")
print("pitch is still", pitch)
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
print("this is the new leaf: ", new_leaf)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
# remove trivial 1:1 tuplets
self.staff.extend(selection)
command = rmakers.extract_trivial()
command(selection)
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_phrase(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=(0, 0, 0),
),
rmakers.beam()
)
selection = stack(divisions)
# attach time signature to first leaf in each tuplet
assert len(divisions) == len(selection)
previous_time_signature = None
for division, tuplet in zip(divisions, selection):
time_signature = abjad.TimeSignature(division)
leaf = abjad.select(tuplet).leaf(0)
if time_signature != previous_time_signature:
abjad.attach(time_signature, leaf)
previous_time_signature = time_signature
# apply pitch material
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True) # make iterator out of selection using logical ties as virtual measures
iterator = enumerate(iterator) # makes enum out of iterator
for index, logical_tie in iterator:
pitch = cyclic_tuple[index]
for old_leaf in logical_tie:
if isinstance(pitch, int):
old_leaf.written_pitch = pitch
elif isinstance(pitch, str):
# warning: was formerly checking for list import rill.tools.FuzzyHarmony as FuzzyHarmony
#import rill.tools.PhraseMaker as PhraseMaker
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
elif isinstance(pitch, abjad.Chord):
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
# remove trivial 1:1 tuplets
self.container.extend(selection)
command = rmakers.extract_trivial()
command(selection)
def material_test():
print(
"Running material test using ``muda.Material()`` class and its methods."
)
timespans = muda.alternating_timespans([[1, 1], [1, 1], [1, 1]], 2,
["matA", "matB"])
durations = timespans.annotated_durations(subdivision=(2, 4))
makers = {
"matA":
rmakers.stack(rmakers.talea([-1, 2, -1], 16),
rmakers.extract_trivial()),
"matB":
rmakers.stack(rmakers.talea([1, 1, 1, 1], 16),
rmakers.extract_trivial()),
}
mat = muda.Material("A")
mat.alternating_materials(durations, makers)
pitches = {
"matA": abjad.PitchSegment("fs'"),
"matB": abjad.PitchSegment("ds'"),
}
mat.write_pitches_by_name(pitches)
mat.material_name_markups(["matA", "matB"])
def make_music(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=None,
),
rmakers.beam(),
)
selection = stack(divisions)
# # attach time signature to first leaf in each tuplet
# assert len(divisions) == len(selection)
# for division, tuplet in zip(divisions, selection):
# time_signature = abjad.TimeSignature(division)
# leaf = abjad.select(tuplet).leaf(0)
# abjad.attach(time_signature, leaf)
#
# apply pitches
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True)
iterator = enumerate(iterator)
for index, logical_tie in iterator:
pitch = cyclic_tuple[index]
for old_leaf in logical_tie:
if isinstance(pitch, int):
old_leaf.written_pitch = pitch
elif isinstance(pitch, list):
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
# remove trivial 1:1 tuplets
self.staff.extend(selection)
command = rmakers.extract_trivial()
command(selection)
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()"),
)
stack = rmakers.stack(
rmakers.tuplet([(1, 2, 4, 1, 1, 1)]),
rmakers.force_rest(selector),
rmakers.before_grace_container(
[1, 2, 1],
abjad.select().tuplets().map(
abjad.select().logical_ties(pitched=True).exclude([0, 3, 4, 5])),
),
rmakers.rewrite_dots(abjad.select().tuplets().get([1])),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
stack2 = rmakers.stack(
rmakers.talea([3, 1, 4, -1, 5, 9], 8, extra_counts=[1, 3, 5]),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
selection1 = stack([time_signatures[0]])
state1 = stack.state
selection2 = stack2([time_signatures[1]])
state2 = stack2.state
selection3 = stack([time_signatures[2]], previous_state=state1)
selection4 = stack2(time_signatures[3:], previous_state=state2)
selection = selection1 + selection2 + selection3 + selection4
staff = abjad.Staff(selection, name="staffname")
import abjad
import abjadext.rmakers as rmakers
selector = abjad.select().tuplets()[:-1]
selector = selector.map(abjad.select().note(-1))
rhythm_maker_voice_one = rmakers.stack(
rmakers.talea(
[3, 2, 1], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
rhythm_maker_voice_two = rmakers.stack(
rmakers.talea(
[3, 1, 2], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
rhythm_maker_voice_three = rmakers.stack(
rmakers.talea(
[1, 2, 3], # counts
8, # denominator
),
forget=False,
name="guerrero_handler",
)
##
##
heterophony_maker = rmakers.stack(
rmakers.talea(
[
4,
1,
3,
5,
4,
6,
7,
3,
2,
],
8,
extra_counts=[0, 0, 1, 0, 1],
),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
heterophony_handler = evans.RhythmHandler(
rmaker=heterophony_maker,
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()"),
)
import abjad
import evans
from abjadext import rmakers
rmaker_one = evans.RTMMaker(rtm=[
"(1 ((3 (1 1 1)) 1 2 2))",
"(1 (1 2 2 3))",
"(1 ((2 (1 1)) 2 3 1))",
"(1 ((2 (1 1)) 3 1 2))",
])
rmaker_two = rmakers.stack(
rmakers.talea(
[3, -1, 2, -2, 3, 1, 2, 2, -3, 1, -2, 2],
4,
extra_counts=[0, 3, -1, 2, -2, 0, 3, 1, 2, 2, 0, -3, 1, -2, 2],
),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
rmaker_three = evans.RTMMaker(rtm=[
"(1 (2 2 1 3))",
"(1 (2 2 1 4))",
"(1 (3 3 3 5))",
"(1 (4 4 4 5))",
"(1 (4 4 3 4))",
# "(1 (5 4 4 5))",
"(1 (2 1 1 2))",
# NOTE LIST VOICE FOUR SEGMENT IV END
# 4 _ _ _ 1 4 _ _ _ 1 4 _ _ _ 1 4 _ _ _ 1
# 3 _ _ 2 _ 3 _ _ 2 _
# 2 _ 2 _ 2 _ 2 _ 2
# 4 _ _ _ 4 _ \ _ _ 1 3 _ _ \ 1 3 _ _ 1 2 _ 1 2 _ 1 1
# 1 2 _ 1 2 _ \ 1 3 _ _ 1 3 \ _ _ 1 2 _ 1 2 _ 1 1
# 2 _ 3 _ _ 4 \ _ _ _ 1 3 _ \ _ 1 2 _ 1 2 _ 1 1
# TALEA RHYTHM MAKER
selector = abjad.select().tuplets()[:-1]
selector = selector.map(abjad.select().note(-1))
rhythm_maker_voice_two = rmakers.stack(
rmakers.talea(
[4, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 1], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
rmakers.tie(selector),
)
rhythm_maker_voice_three = rmakers.stack(
rmakers.talea(
[1, 2, 1, 2, 1, 3, 1, 3, 1, 2, 1, 2, 1, 1], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
rmakers.tie(selector),
)
import abjad
import abjadext.rmakers as rmakers
import evans
import random
# THOSE CHORDS IN VOICE FIVE (once was one)
rhythm_maker_voice_five = rmakers.stack(
rmakers.talea(
[2, 1, 3], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
# MATERIAL FROM SEGMENT 2 AND 3
# REST LIST
rest_list = evans.e_dovan_cycle(n=2, iters=16, first=1, second=1, modulus=5)
rest_list.sort(reverse=True)
# NOTE LIST VOICE TWO
note_list_voice_two = [4, 1]
non_cyc_generator = evans.CyclicList(lst=note_list_voice_two,
continuous=False,
count=1)
new_note_list_voice_two = non_cyc_generator(r=40)
# NOTE + REST = TALEA VOICE TWO
note_and_rest_voice_two = []
note_sublist_voice_two = []
# rmakers.beam(),
# rmakers.extract_trivial(),
)
# rmakers.tuplet(
# [(1, 2, 2, 1), (1, 2, 2, 2, 1)],),
# rmakers.force_rest(abjad.select().leaves().get([0])),
# rmakers.tie(abjad.select().leaves().get([3], 4)),
# rmakers.beam(),
# rmakers.rewrite_sustained(),
# rmakers.extract_trivial(),
rhythm_maker_voice_one_old = rmakers.stack(
rmakers.talea(
[1], # counts
4,
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
rhythm_maker_voice_two = rmakers.stack(
rmakers.talea(
[2, 3], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
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()"),
)
time_signatures = []
for item in durations:
if isinstance(item, list):
for i in item:
time_signatures.append(abjad.TimeSignature(i))
else:
time_signatures.append(abjad.TimeSignature(item))
# time_signatures = timespans.time_signatures()
# It is a list of durations where each one is annotated with
# the material name.
# Rhythms of each material
makers = {
"matL": rmakers.stack(rmakers.talea([2, 1, -1], 16), rmakers.extract_trivial()),
"matK": rmakers.stack(
rmakers.talea([1, 1, 1, 1, 1], 32, extra_counts=[1]),
rmakers.extract_trivial(),
),
"matJ": rmakers.stack(
rmakers.talea([-1, 1, -1], 8, extra_counts=[1]), rmakers.extract_trivial()
),
"matI": rmakers.stack(
rmakers.talea([1, 1, 1], 4, extra_counts=[1]), rmakers.extract_trivial()
),
"matH": rmakers.stack(
rmakers.talea([-3, -2, 1, -3, -3], 16, extra_counts=[4]),
rmakers.extract_trivial(),
),
"matG": rmakers.stack(
import abjad
import evans
from abjadext import rmakers
rmaker = rmakers.talea([1, 3, 2, 4, 5], 8, extra_counts=[1, 0, 1, 1, 2, 3, 4])
def quarters(divisions):
divisions = evans.BacaSequence(divisions)
divisions = evans.BacaSequence(
evans.BacaSequence(_).quarters() for _ in divisions)
divisions = evans.BacaSequence(divisions).flatten(depth=-1)
return divisions
commands = [
rmakers.trivialize(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_rest_filled(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_sustained(lambda _: abjad.Selection(_).tuplets()),
rmakers.extract_trivial(),
rmakers.RewriteMeterCommand(
boundary_depth=-1,
reference_meters=[
abjad.Meter((6, 8)),
abjad.Meter((9, 8)),
],
),
]
stack = rmakers.stack(
rmaker,
import abjad
import abjadext.rmakers as rmakers
import evans
import random
# THOSE CHORDS IN VOICE ONE
rhythm_maker_voice_one = rmakers.stack(
rmakers.talea(
[2, 1, 3], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
# NEW MATERIAL
# REST LIST
rest_list = evans.e_dovan_cycle(
n=2, iters=16, first=1, second=1, modulus=5)
rest_list.sort(reverse=True)
# NOTE LIST
note_list = [4, 1]
non_cyc_generator = evans.CyclicList(lst=note_list, continuous=False, count=1)
new_note_list = non_cyc_generator(r=40)
new_note_list
# NOTE + REST = TALEA
note_and_rest = []
note_sublist = []
import abjad
import abjadext.rmakers as rmakers
import muda
durations_general = [(4, 4)] * 32
rmaker_afluteA = rmakers.stack(
rmakers.talea([4, -2, 1], 8),
rmakers.extract_trivial(), # counts # denominator
tag=abjad.Tag("Mat_A"),
)
rmaker_afluteB = rmakers.stack(
rmakers.talea([1], 8, extra_counts=[1]),
rmakers.beam(),
rmakers.extract_trivial(), # counts # denominator
# rmakers.rewrite_meter(),
tag=abjad.Tag("Mat_B"),
)
rest_maker = rmakers.stack(rmakers.note(),
rmakers.force_rest(abjad.select()),
tag=abjad.Tag("Rests"))
rmaker_bclarinetA = rmakers.stack(
rmakers.talea([-4, 2], 8), # counts # denominator
rmakers.beam(),
rmakers.extract_trivial(),
tag=abjad.Tag("Mat_A"),
)
rmaker_bclarinetB = rmakers.stack(
import abjad
import abjadext.rmakers as rmakers
import random
import organi
voz = abjad.Voice()
selector = abjad.select().tuplets()[:-1]
selector = selector.map(abjad.select().note(-1))
rhythm = rmakers.stack(
rmakers.talea(
[7, 7, 7, 7], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.denominator((1, 8)),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
divisions = [(4, 8)] * 7
measures = rhythm(divisions)
voz = abjad.Voice(
measures) # NEED TO PUT IN A CONTAINER TO SEPARATE WELL THE LOGICAL TIES
logical_ties = abjad.select(voz).leaves().logical_ties(pitched=True)
logical_ties
voz_time = abjad.Voice("s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s4 s1")
abjad.Staff(voz, voz_time)
time_signatures = []
for item in divisions:
time_signatures.append(abjad.TimeSignature(item))