def motive1(score, octave, limit, chan):
"""
Motive1 generates three notes in random order but always with a
whole step and minor seventh sounding. The motive can be randomly
transposed within limit half-steps.
Parameters
----------
score : Score
The score.
octave : int
The octave to play the notes in.
limit : int
The maximum transposition in half steps.
chan : int
The midi channel to assign to the notes.
"""
# the basic pitches to transpose and jumble e.g. [F#4 E4 D5].
pitches = jumble([6, 4, 14])
# one of the three pitches will be louder than the others.
amps = jumble([.75, .5, .5])
# randomly chosen transpostion within a limit
offset = random.randrange(limit)
for _ in range(3):
knum = next(pitches) + (octave * 12) + offset
note = Note(time=score.now, duration=.1, pitch=knum, amplitude=next(amps), instrument=chan)
score.add(note)
yield .2
def motive2(score, octave, limit, chan):
"""Motive2 generates a repeated tone with one tone accented."""
amps = jumble([.75, .5, .5])
rhys = jumble([.2, .2, .4])
offset = random.randrange(limit)
for _ in range(3):
knum = 0 + (octave * 12) + offset
note = Note(time=score.now, duration=.1, pitch=knum, amplitude=next(amps), instrument=chan)
score.add(note)
yield next(rhys)
def rmfunky(score, reps, dur, keys):
"""
Main composer chooses input spectra , creates a ring modulated
output spectrum and plays them using two parts.
Parameters
----------
score : Score
The musical score.
reps : int
The number of sections to compose.
dur : int
The surface rhythm
keys : list
List of keynums for ring modulation input.
"""
num = choose([1, 2, 3])
# scramble the cycle of fourths
pat = jumble(keys)
for _ in range(reps):
# input1 is 1, 2 or 3 notes from cycle of 4ths
keys1 = [next(pat) for _ in range(next(num))]
# input2 is same
keys2 = [next(pat) for _ in range(next(num))]
# ring modulate the inputs
spect = rmspectrum([hertz(k) for k in keys1],
[hertz(k) for k in keys2])
# convert to keynums
keys3 = spect.keynums(quant=1, unique=True, minkey=21, maxkey=108)
# sprout composers to play inputs and output
playn = pick(3, 4, 5)
score.compose(accompaniment(score, playn, dur, keys1, keys2))
score.compose(melody(score, playn, dur,
keys3)) # do it again after composers finish
yield (dur * playn * 2)
def playpenta(score, num, dur, amp, keys):
pat = jumble(keys)
for _ in range(num):
k = next(pat)
n = Note(time=score.now, duration=dur * 2, pitch=k, amplitude=amp)
score.add(n)
yield odds(.2, 0, dur)
def register(score, rhy, dur, low, high, amp):
"""
Generates a chromatic scale betwen low and high choosing notes from the
scale in random.
"""
pat = jumble(scale(low, high - low + 1, 1))
while score.elapsed < dur:
keyn = next(pat)
note = Note(time=score.now, duration=rhy, pitch=keyn, amplitude=amp)
score.add(note)
yield rhy
def jazz_piano(score, on, tmpo, ampl):
"""
The jazz piano improvises jazz chords based on a pattern of root
changes and a scale pattern that is transposed to each root. The
piano randomly choose between playing triplet eighths or straight
eights for a given measure.
"""
reps = odds(.65, 8, 12)
scal = jumble(jazz_scale)
rhys = cycle([2 / 3, 1 / 3] if reps == 8 else [1 / 3])
for _ in range(reps):
r = intempo(next(rhys), tmpo)
l = [] if odds(2 / 5) else [next(scal) for _ in range(between(1, 9))]
for k in l:
a = pick(.4, .5, .6, .7, .8)
m = Note(time=score.now,
duration=r,
pitch=on + k,
amplitude=a,
instrument=0)
score.add(m)
yield r