def test_set_item(self):
t0 = old.Tone(ji.r(1, 1), rhy.Unit(2))
t1 = old.Tone(ji.r(2, 1), rhy.Unit(2))
melody0 = old.Melody([t0, t1])
melody1 = old.Melody([t1, t0])
melody0[0], melody0[1] = melody1[0], melody1[1]
self.assertEqual(melody0, melody1)
def test_rhythmic_interpolation(self):
p0 = old.RhythmicInterpolation(3, rhy.Unit(3))
p1 = old.RhythmicInterpolation(0, rhy.Unit(2))
p2 = old.RhythmicInterpolation(0, rhy.Unit(2))
self.assertNotEqual(hash(p0), hash(p1))
self.assertEqual(hash(p1), hash(p2))
interp0 = (3, 2.5, 2)
self.assertEqual(p0.interpolate(p1, 3), interp0)
def convert2melody(self) -> Melody:
sorted_by_delay = sorted(list(self.copy()), key=lambda t: t.delay)
first = sorted_by_delay[0].delay
if first != 0:
sorted_by_delay.insert(0, Rest(0, first))
for t, t_after in zip(sorted_by_delay, sorted_by_delay[1:]):
diff = t_after.delay - t.delay
t.delay = rhy.Unit(diff)
sorted_by_delay[-1].delay = rhy.Unit(sorted_by_delay[-1].duration)
return Melody(sorted_by_delay)
def test_split(self):
tone0 = old.Tone(ji.r(1, 1, 2), rhy.Unit(2), rhy.Unit(1))
tone0B = old.Tone(ji.r(1, 1, 2), rhy.Unit(1), rhy.Unit(1))
tone1 = old.Tone(ji.r(1, 1, 2), rhy.Unit(3), rhy.Unit(1))
tone1B = old.Tone(ji.r(1, 1, 2), rhy.Unit(1), rhy.Unit(1))
pause0 = old.Rest(rhy.Unit(1))
pause1 = old.Rest(rhy.Unit(2))
melody0 = old.Melody([tone0, tone1])
melody1 = old.Melody([tone0B, pause0, tone1B, pause1])
self.assertEqual(melody0.split(), melody1)
def test_vibrato_line(self):
p0 = old.PitchInterpolation(2, mel.SimplePitch(0, 300))
p1 = old.PitchInterpolation(4, mel.SimplePitch(0, 200))
p2 = old.PitchInterpolation(0, mel.SimplePitch(0, 600))
p3 = old.PitchInterpolation(4, mel.SimplePitch(0, -200))
p4 = old.PitchInterpolation(2, mel.SimplePitch(0, -600))
p5 = old.PitchInterpolation(0, mel.SimplePitch(0, -900))
r0 = old.RhythmicInterpolation(6, rhy.Unit(2))
r1 = old.RhythmicInterpolation(0, rhy.Unit(2))
line0 = interpolations.InterpolationLine((p0, p1, p2))
line1 = interpolations.InterpolationLine((p3, p4, p5))
line2 = interpolations.InterpolationLine((r0, r1))
vib0 = old.VibratoLine(line0, line1, line2, "up")
vib1 = old.VibratoLine(line0, line1, line2, "down")
interpol0 = vib0.interpolate(0.5)
interpol1 = vib1.interpolate(0.5)
self.assertNotEqual(interpol0, interpol1)
self.assertEqual(
tuple(round(n, 2) for n in interpol0),
(
-0.0,
275.0,
-0.0,
-371.43,
-0.0,
257.14,
-0.0,
-600.0,
-0.0,
485.71,
-0.0,
-900.0,
),
)
self.assertEqual(
tuple(round(n, 2) for n in interpol1),
(
0.0,
-257.14,
0.0,
225.0,
0.0,
-485.71,
0.0,
371.43,
0.0,
-750.0,
0.0,
600.0,
),
)
def test_cut_up_by_time(self):
t0 = old.Tone(ji.r(1, 1), rhy.Unit(2))
t1 = old.Tone(ji.r(2, 1), rhy.Unit(2))
t2 = old.Tone(ji.r(1, 1), rhy.Unit(1))
r0 = old.Rest(1)
melody0 = old.Melody([t0, t1, t1, t0, t1])
melody1 = old.Melody([t1, t1, t0])
melody2 = old.Melody([r0, t1, t1, t0])
melody3 = old.Melody([t2, t1, t1, t0])
melody4 = old.Melody([t1, t1, t2])
self.assertEqual(melody0.cut_up_by_time(2, 8), melody1)
self.assertEqual(melody0.cut_up_by_time(1, 8), melody2)
self.assertEqual(melody0.cut_up_by_time(1, 8, add_earlier=True), melody3)
self.assertEqual(melody0.cut_up_by_time(2, 7, hard_cut=True), melody4)
self.assertEqual(melody0.cut_up_by_time(2, 7, hard_cut=False), melody1)
def test_delay(self):
rh0 = rhy.Unit(4)
rhy_comp0 = rhy.Compound([rhy.Unit(2), rhy.Unit(4), rhy.Unit(1)])
rhy_comp1 = rhy.Compound([rhy.Unit(4), rhy.Unit(8), rhy.Unit(2)])
self.assertEqual(rh0.delay, time.Time(4))
self.assertEqual(rhy_comp0.delay, time.Time(7))
self.assertEqual(rhy_comp1.delay, time.Time(14))
def convert2cadence(self) -> Cadence:
sorted_by_delay = sorted(list(self.copy()), key=lambda t: t.delay)
first = sorted_by_delay[0].delay
if first != 0:
sorted_by_delay.insert(0, Rest(0))
cadence = Cadence([])
harmony = mel.Harmony([])
for t, t_after in zip(sorted_by_delay, sorted_by_delay[1:] + [0]):
try:
diff = t_after.delay - t.delay
except AttributeError:
diff = t.duration
harmony.add(t.pitch)
if diff != 0:
cadence.append(Chord(harmony, rhy.Unit(diff), rhy.Unit(t.duration)))
harmony = mel.Harmony([])
cadence[-1].delay = rhy.Unit(sorted_by_delay[-1].duration)
return Cadence(cadence)
def convert_rhythm2essence_and_multiply(rhythm: tuple) -> tuple:
if rhythm:
rhythm_as_fraction = tuple(rhy.Unit(r).fraction for r in rhythm)
lcd = tools.lcm(*tuple(r.denominator for r in rhythm_as_fraction))
int_rhythm = tuple(int(r * lcd) for r in rhythm_as_fraction)
essence = Compound.convert_int_rhythm2essence(int_rhythm)
return essence, fractions.Fraction(1, lcd)
else:
return 0, 1
def from_cadence(cls, cadence: Cadence) -> "ToneSet":
new_set = cls()
d = 0
for chord in cadence:
delay = float(chord.delay)
for p in chord.pitch:
t = Tone(p, rhy.Unit(d), chord.duration, chord.volume)
new_set.add(t)
d += delay
return new_set
def from_polyphon(cls, polyphon: Polyphon) -> "ToneSet":
new_set = cls()
for melody in polyphon:
d = 0
for t in melody.copy():
delay = float(t.delay)
t.delay = rhy.Unit(d)
d += delay
new_set.add(t)
return new_set
def fill(self) -> "PolyLine":
"""Add Rests until each Voice has the same length.
so that: sum(Polyphon[0].rhy) == sum(Polyphon[1].rhy) == ...
"""
poly = self.copy()
total = self.duration
for v in poly:
summed = sum(v.delay)
if summed < total:
v.append(self._make_rest(rhy.Unit(total - summed)))
return poly
def test_chordify(self):
chord0 = old.Chord(ji.JIHarmony([self.t0.pitch, self.t2.pitch]), rhy.Unit(1))
chord1 = old.Chord(ji.JIHarmony([self.t1.pitch, self.t3.pitch]), rhy.Unit(1))
cadence0 = old.Cadence([chord0, chord1])
self.assertEqual(cadence0, self.poly0.chordify())
chord0 = old.Chord(ji.JIHarmony([self.p0, self.p5]), rhy.Unit(0.5))
chord1 = old.Chord(ji.JIHarmony([self.p0, self.p1]), rhy.Unit(1.5))
chord2 = old.Chord(ji.JIHarmony([self.p0, self.p3]), rhy.Unit(1))
chord3 = old.Chord(ji.JIHarmony([self.p0]), rhy.Unit(1))
chord4 = old.Chord(ji.JIHarmony([self.p0, self.p2]), rhy.Unit(0.5))
chord5 = old.Chord(ji.JIHarmony([self.p0]), rhy.Unit(0.5))
expected = old.Cadence([chord0, chord1, chord2, chord3, chord4, chord4, chord5])
result = self.poly2.chordify(
harmony_class=ji.JIHarmony, cadence_class=old.Cadence, add_longer=True
)
for ex, re in zip(expected, result):
print(ex, re)
self.assertEqual(expected, result)
def quantisize_rhythm(
melody: old.Melody,
n_divisions: int = 8,
min_tone_size: fractions.Fraction = 0,
min_rest_size: fractions.Fraction = fractions.Fraction(1, 10),
) -> tuple:
new_melody = []
min_size = fractions.Fraction(1, n_divisions)
left_over = 0
for tone in melody:
r = tone.delay
if tone.pitch.is_empty:
is_addable = r >= min_rest_size
else:
is_addable = r >= min_tone_size
if is_addable:
r += left_over
left_over = 0
quantisized = rhy.Unit(round(r * n_divisions) /
n_divisions).fraction
if quantisized == 0:
quantisized = min_size
new_tone = tone.copy()
new_tone.delay = quantisized
new_tone.duration = quantisized
new_melody.append(new_tone)
else:
left_over += r
new_melody[-1].delay += left_over
new_melody[-1].duration += left_over
return old.Melody(new_melody)
def __init__(self, delay: rhy.Unit, interpolation_type=Linear()):
if isinstance(delay, rhy.Unit) is False:
delay = rhy.Unit(delay)
self.__delay = delay
self.__interpolation_type = interpolation_type
def test_stretch(self):
rh0 = rhy.Unit(2)
rh1 = rhy.Unit(4)
rh2 = rhy.Unit(1)
self.assertEqual(rh0.stretch(2), rh1)
self.assertEqual(rh0.stretch(0.5), rh2)
rhy_comp0 = rhy.Compound([rhy.Unit(2), rhy.Unit(4), rhy.Unit(1)])
rhy_comp1 = rhy.Compound([rhy.Unit(4), rhy.Unit(8), rhy.Unit(2)])
rhy_comp2 = rhy.Compound([rhy.Unit(1), rhy.Unit(2), rhy.Unit(0.5)])
self.assertEqual(rhy_comp0, rhy_comp1.stretch(0.5))
self.assertEqual(rhy_comp0.stretch(2), rhy_comp1)
self.assertEqual(rhy_comp0.stretch(0.5), rhy_comp2)
class PolyTest(unittest.TestCase):
p0 = ji.r(5, 4)
p1 = ji.r(3, 2)
p2 = ji.r(1, 1)
p3 = ji.r(6, 5)
p4 = ji.r(7, 4)
p5 = ji.r(9, 8)
t0 = old.Tone(p0, rhy.Unit(1))
t1 = old.Tone(p1, rhy.Unit(1))
t2 = old.Tone(p2, rhy.Unit(1))
t3 = old.Tone(p3, rhy.Unit(1))
t3 = old.Tone(p3, rhy.Unit(1))
t4 = old.Tone(p4, rhy.Unit(1))
t5 = old.Tone(p5, rhy.Unit(1))
t6 = old.Tone(p0, rhy.Unit(2))
t7 = old.Tone(p0, rhy.Unit(0.5))
t8 = old.Tone(p0, rhy.Unit(1.5))
t9 = old.Tone(p1, rhy.Unit(1.5))
t10 = old.Tone(p5, rhy.Unit(0.5))
t11 = old.Tone(p2, rhy.Unit(1))
melody0 = old.Melody((t0, t1))
melody1 = old.Melody((t2, t3))
melody2 = old.Melody((t6, t6, t0, t7)) # duration 5.5
melody3 = old.Melody((t7, t6, t2, t2)) # duration 4.5
melody4 = old.Melody((t7, t7, t7, t2, t2)) # duration 3.5
melody5 = old.Melody((t10, t9, t3, t8, t0)) # duration 5.5
melody6 = old.Melody((t6, t6, t2, t7)) # duration 5.5
poly0 = old.Polyphon([melody0, melody1])
poly1 = old.Polyphon([melody2, melody3, melody4])
poly2 = old.Polyphon([melody6, melody5])
def test_chordify(self):
chord0 = old.Chord(ji.JIHarmony([self.t0.pitch, self.t2.pitch]), rhy.Unit(1))
chord1 = old.Chord(ji.JIHarmony([self.t1.pitch, self.t3.pitch]), rhy.Unit(1))
cadence0 = old.Cadence([chord0, chord1])
self.assertEqual(cadence0, self.poly0.chordify())
chord0 = old.Chord(ji.JIHarmony([self.p0, self.p5]), rhy.Unit(0.5))
chord1 = old.Chord(ji.JIHarmony([self.p0, self.p1]), rhy.Unit(1.5))
chord2 = old.Chord(ji.JIHarmony([self.p0, self.p3]), rhy.Unit(1))
chord3 = old.Chord(ji.JIHarmony([self.p0]), rhy.Unit(1))
chord4 = old.Chord(ji.JIHarmony([self.p0, self.p2]), rhy.Unit(0.5))
chord5 = old.Chord(ji.JIHarmony([self.p0]), rhy.Unit(0.5))
expected = old.Cadence([chord0, chord1, chord2, chord3, chord4, chord4, chord5])
result = self.poly2.chordify(
harmony_class=ji.JIHarmony, cadence_class=old.Cadence, add_longer=True
)
for ex, re in zip(expected, result):
print(ex, re)
self.assertEqual(expected, result)
def test_find_simultan_events(self):
simultan_events0 = self.poly0.find_simultan_events(0, 0)
self.assertEqual(simultan_events0, (self.poly0[1].convert2absolute()[0],))
simultan_events1 = self.poly0.find_simultan_events(1, 1)
self.assertEqual(simultan_events1, (self.poly0[0].convert2absolute()[1],))
simultan_events2 = self.poly1.find_simultan_events(0, 1)
simultan_events2_comp = (
self.poly1[1].convert2absolute()[1],
self.poly1[1].convert2absolute()[2],
self.poly1[1].convert2absolute()[3],
self.poly1[2].convert2absolute()[-2],
self.poly1[2].convert2absolute()[-1],
)
self.assertEqual(simultan_events2, simultan_events2_comp)
simultan_events3 = self.poly1.find_simultan_events(1, 1)
simultan_events3_comp = (
self.poly1[0].convert2absolute()[0],
self.poly1[0].convert2absolute()[1],
self.poly1[2].convert2absolute()[1],
self.poly1[2].convert2absolute()[2],
self.poly1[2].convert2absolute()[3],
)
self.assertEqual(simultan_events3, simultan_events3_comp)
def test_find_exact_simultan_events(self):
poly2 = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 2), old.Tone(ji.r(1, 1), 3)]),
old.Melody([old.Tone(ji.r(3, 2), 3), old.Tone(ji.r(3, 2), 2)]),
old.Melody([old.Tone(ji.r(4, 3), 1), old.Tone(ji.r(4, 3), 2)]),
)
)
simultan_events4 = poly2.find_exact_simultan_events(0, 1)
simultan_events4_expected = (
old.Tone(ji.r(3, 2), 1, 1),
old.Tone(ji.r(3, 2), 2, 2),
old.Tone(ji.r(4, 3), 1, 1),
)
self.assertEqual(simultan_events4, simultan_events4_expected)
simultan_events0 = self.poly0.find_exact_simultan_events(0, 0)
self.assertEqual(simultan_events0, (self.poly0[1][0],))
simultan_events1 = self.poly0.find_exact_simultan_events(0, 0, False)
self.assertEqual(simultan_events1, (self.poly0[1].convert2absolute()[0],))
simultan_events2 = self.poly1.find_exact_simultan_events(1, 0)
simultan_events2_expected = (self.poly1[2][0], self.poly1[2][0])
self.assertEqual(simultan_events2, simultan_events2_expected)
simultan_events3 = self.poly1.find_exact_simultan_events(1, 1)
simultan_events3_expected = (self.t8, self.t7, self.t7, self.t7, self.t2)
self.assertEqual(simultan_events3, simultan_events3_expected)
def test_cut_up_by_time(self):
poly0 = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 2), old.Tone(ji.r(1, 1), 3)]),
old.Melody([old.Tone(ji.r(3, 2), 3), old.Tone(ji.r(3, 2), 2)]),
old.Melody([old.Tone(ji.r(4, 3), 1), old.Tone(ji.r(4, 3), 2)]),
)
)
poly0_cut = poly0.cut_up_by_time(1, 3)
poly0_cut_expected = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 1), old.Tone(ji.r(1, 1), 1)]),
old.Melody([old.Tone(ji.r(3, 2), 2)]),
old.Melody([old.Tone(ji.r(4, 3), 2)]),
)
)
self.assertEqual(poly0_cut, poly0_cut_expected)
poly1_cut = poly0.cut_up_by_time(1, 3, add_earlier=False)
poly1_cut_expected = old.Polyphon(
(
old.Melody([old.Rest(1), old.Tone(ji.r(1, 1), 1)]),
old.Melody([old.Rest(2)]),
old.Melody([old.Tone(ji.r(4, 3), 2)]),
)
)
self.assertEqual(poly1_cut, poly1_cut_expected)
poly2_cut = poly0.cut_up_by_time(1, 3, hard_cut=False)
poly2_cut_expected = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 2), old.Tone(ji.r(1, 1), 3)]),
old.Melody([old.Tone(ji.r(3, 2), 3)]),
old.Melody([old.Rest(1), old.Tone(ji.r(4, 3), 2)]),
)
)
self.assertEqual(poly2_cut[2], poly2_cut_expected[2])
def test_cut_up_by_idx(self):
poly0 = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 2), old.Tone(ji.r(1, 1), 3)]),
old.Melody([old.Tone(ji.r(3, 2), 3), old.Tone(ji.r(3, 2), 2)]),
old.Melody([old.Tone(ji.r(4, 3), 1), old.Tone(ji.r(4, 3), 2)]),
)
)
poly0_cut = poly0.cut_up_by_idx(2, 1)
poly0_cut_expected = old.Polyphon(
(
old.Melody([old.Tone(ji.r(1, 1), 1), old.Tone(ji.r(1, 1), 1)]),
old.Melody([old.Tone(ji.r(3, 2), 2)]),
old.Melody([old.Tone(ji.r(4, 3), 2)]),
)
)
self.assertEqual(poly0_cut, poly0_cut_expected)
def test_pop_by_correct_dur_and_delay(self):
poped_by = self.set0.pop_by_pitch(self.p0, self.p5)
melody = poped_by.convert2melody()
self.assertEqual(melody[0].delay, rhy.Unit(5))
self.assertEqual(melody[0].duration, rhy.Unit(1))
def test_pop_by(self):
popped = ToneSetTest.set0.copy().pop_by_pitch(ToneSetTest.p0, ToneSetTest.p1)
self.assertEqual(ToneSetTest.mel2, popped.convert2melody())
popped = ToneSetTest.set0.copy().pop_by_start(rhy.Unit(0), rhy.Unit(1))
self.assertEqual(ToneSetTest.mel2, popped.convert2melody())
class ToneSetTest(unittest.TestCase):
p0 = ji.r(5, 4)
p1 = ji.r(3, 2)
p2 = ji.r(1, 1)
p3 = ji.r(6, 5)
p4 = ji.r(7, 4)
p5 = ji.r(9, 8)
t0 = old.Tone(p0, rhy.Unit(1))
t1 = old.Tone(p1, rhy.Unit(1))
t2 = old.Tone(p2, rhy.Unit(1))
t3 = old.Tone(p3, rhy.Unit(1))
t3 = old.Tone(p3, rhy.Unit(1))
t4 = old.Tone(p4, rhy.Unit(1))
t5 = old.Tone(p5, rhy.Unit(1))
t0_set = old.Tone(p0, rhy.Unit(0), rhy.Unit(1))
t1_set = old.Tone(p1, rhy.Unit(1), rhy.Unit(1))
t2_set = old.Tone(p2, rhy.Unit(2), rhy.Unit(1))
t3_set = old.Tone(p3, rhy.Unit(3), rhy.Unit(1))
t4_set = old.Tone(p4, rhy.Unit(4), rhy.Unit(1))
t5_set = old.Tone(p5, rhy.Unit(5), rhy.Unit(1))
t6_set = old.Tone(p5, rhy.Unit(1), rhy.Unit(5))
mel0 = old.Melody([t0, t1, t2, t3, t4, t5])
mel1 = old.Melody([old.Rest(rhy.Unit(1)), t1, t2, t3, t4, t5])
mel2 = old.Melody([t0, t1])
set0 = old.ToneSet([t0_set, t1_set, t2_set, t3_set, t4_set, t5_set])
set1 = old.ToneSet([t1_set, t2_set, t3_set, t4_set, t5_set])
set2 = old.ToneSet([t1_set, t6_set, t2_set])
def test_constructor(self):
self.assertEqual(old.ToneSet.from_melody(ToneSetTest.mel0), ToneSetTest.set0)
def test_converter(self):
self.assertEqual(ToneSetTest.mel0, ToneSetTest.set0.convert2melody())
self.assertEqual(ToneSetTest.mel1, ToneSetTest.set1.convert2melody())
def test_pop_by(self):
popped = ToneSetTest.set0.copy().pop_by_pitch(ToneSetTest.p0, ToneSetTest.p1)
self.assertEqual(ToneSetTest.mel2, popped.convert2melody())
popped = ToneSetTest.set0.copy().pop_by_start(rhy.Unit(0), rhy.Unit(1))
self.assertEqual(ToneSetTest.mel2, popped.convert2melody())
def test_pop_by_time(self):
for t in self.set0.pop_by_time(1):
self.assertEqual(t, self.t1_set)
for t in self.set0.pop_by_time(1.5):
self.assertEqual(t, self.t1_set)
test_set0 = self.set2.pop_by_time(1.5)
test_set_compare0 = old.ToneSet([self.t1_set, self.t6_set])
test_set1 = self.set2.pop_by_time(2.7)
test_set_compare1 = old.ToneSet([self.t2_set, self.t6_set])
self.assertEqual(test_set0, test_set_compare0)
self.assertEqual(test_set1, test_set_compare1)
def test_pop_by_correct_dur_and_delay(self):
poped_by = self.set0.pop_by_pitch(self.p0, self.p5)
melody = poped_by.convert2melody()
self.assertEqual(melody[0].delay, rhy.Unit(5))
self.assertEqual(melody[0].duration, rhy.Unit(1))
def _return_correct_time_type(time_item) -> rhy.Unit:
if isinstance(time_item, rhy.Unit):
return time_item
else:
return rhy.Unit(time_item)
def copy(self):
return type(self)(
rhy.Unit(self.delay), self.rhythm.copy(), self.interpolation_type
)
class MelodyTest(unittest.TestCase):
p0 = ji.r(14, 9)
p1 = ji.r(7, 4)
d0 = rhy.Unit(400)
d1 = rhy.Unit(800)
t0 = old.Tone(p0, d0)
t1 = old.Tone(p1, d1)
mel0 = mel.Mel([p0] * 3)
mel1 = mel.Mel([p1] * 3)
rhy0 = rhy.Compound([d0] * 3)
rhy1 = rhy.Compound([d1] * 3)
melody0 = old.Melody([t0] * 3)
def test_constructor(self):
old.Melody([self.t0, self.t0, self.t0])
def test_alternative_constructor(self):
melody1 = old.Melody.from_parameter(self.mel0, self.rhy0)
self.assertEqual(self.melody0, melody1)
def test_duration(self):
self.assertEqual(self.melody0.duration, sum(self.rhy0))
melody1 = old.Melody([old.Rest(3)])
self.assertEqual(melody1.duration, 3)
def test_get_attributes(self):
self.assertEqual(self.melody0.__get_pitch__(), self.mel0)
self.assertEqual(self.melody0.__get_delay__(), self.rhy0)
self.assertEqual(self.melody0.__get_duration__(), self.rhy0)
def test_set_attributes(self):
melody0 = old.Melody([])
melody0.__set_pitch__(self.mel0)
melody0.__set_delay__(self.rhy0)
self.assertEqual(melody0.__get_pitch__(), self.mel0)
self.assertEqual(melody0.__get_delay__(), self.rhy0)
self.assertEqual(melody0.pitch, self.mel0)
self.assertEqual(melody0.delay, self.rhy0)
melody0.__set_pitch__(self.mel1)
melody0.__set_delay__(self.rhy1)
melody0.__set_duration__(self.rhy0)
self.assertEqual(melody0.__get_pitch__(), self.mel1)
self.assertEqual(melody0.__get_delay__(), self.rhy1)
self.assertEqual(melody0.__get_duration__(), self.rhy0)
self.assertEqual(melody0.pitch, self.mel1)
self.assertEqual(melody0.delay, self.rhy1)
self.assertEqual(melody0.dur, self.rhy0)
def test_set_item(self):
t0 = old.Tone(ji.r(1, 1), rhy.Unit(2))
t1 = old.Tone(ji.r(2, 1), rhy.Unit(2))
melody0 = old.Melody([t0, t1])
melody1 = old.Melody([t1, t0])
melody0[0], melody0[1] = melody1[0], melody1[1]
self.assertEqual(melody0, melody1)
def test_freq(self):
self.assertEqual(self.melody0.freq, self.mel0.freq)
def test_add(self):
compound = old.Melody([self.t0, self.t1, self.t1])
melody0 = old.Melody([self.t0])
melody1 = old.Melody([self.t1] * 2)
self.assertEqual(melody0 + melody1, compound)
def test_tie(self):
melodyTest0 = old.Melody([old.Tone(self.t0.pitch, self.t0.delay * 3)])
self.assertEqual(self.melody0.tie(), melodyTest0)
melodyTest1 = old.Melody([old.Tone(self.t0.pitch, self.t0.delay * 2), self.t1])
melody1 = old.Melody([self.t0, self.t0, self.t1])
self.assertEqual(melody1.tie(), melodyTest1)
melody2 = old.Melody([self.t0, self.t1, self.t0])
self.assertEqual(melody2.tie(), melody2)
def test_split(self):
tone0 = old.Tone(ji.r(1, 1, 2), rhy.Unit(2), rhy.Unit(1))
tone0B = old.Tone(ji.r(1, 1, 2), rhy.Unit(1), rhy.Unit(1))
tone1 = old.Tone(ji.r(1, 1, 2), rhy.Unit(3), rhy.Unit(1))
tone1B = old.Tone(ji.r(1, 1, 2), rhy.Unit(1), rhy.Unit(1))
pause0 = old.Rest(rhy.Unit(1))
pause1 = old.Rest(rhy.Unit(2))
melody0 = old.Melody([tone0, tone1])
melody1 = old.Melody([tone0B, pause0, tone1B, pause1])
self.assertEqual(melody0.split(), melody1)
def test_cut_up_by_time(self):
t0 = old.Tone(ji.r(1, 1), rhy.Unit(2))
t1 = old.Tone(ji.r(2, 1), rhy.Unit(2))
t2 = old.Tone(ji.r(1, 1), rhy.Unit(1))
r0 = old.Rest(1)
melody0 = old.Melody([t0, t1, t1, t0, t1])
melody1 = old.Melody([t1, t1, t0])
melody2 = old.Melody([r0, t1, t1, t0])
melody3 = old.Melody([t2, t1, t1, t0])
melody4 = old.Melody([t1, t1, t2])
self.assertEqual(melody0.cut_up_by_time(2, 8), melody1)
self.assertEqual(melody0.cut_up_by_time(1, 8), melody2)
self.assertEqual(melody0.cut_up_by_time(1, 8, add_earlier=True), melody3)
self.assertEqual(melody0.cut_up_by_time(2, 7, hard_cut=True), melody4)
self.assertEqual(melody0.cut_up_by_time(2, 7, hard_cut=False), melody1)
def test_convert2absolute(self):
melody_converted = old.Melody(
(
old.Tone(self.p0, self.d0 * 0, self.d0 * 1),
old.Tone(self.p0, self.d0 * 1, self.d0 * 2),
old.Tone(self.p0, self.d0 * 2, self.d0 * 3),
)
)
self.assertEqual(self.melody0.convert2absolute(), melody_converted)
melody_converted = old.Melody(
(
old.Tone(self.p0, self.d0 * 0, self.d0 * 1),
old.Tone(self.p0, self.d0 * 1, self.d0 * 2),
old.Tone(self.p0, self.d0 * 2, self.d0 * 3),
),
time_measure="relative",
)
self.assertEqual(self.melody0.convert2absolute(), melody_converted)
def test_convert2relative(self):
melody_converted = old.Melody(
(
old.Tone(self.p0, self.d0 * 0, self.d0 * 1),
old.Tone(self.p0, self.d0 * 1, self.d0 * 2),
old.Tone(self.p0, self.d0 * 2, self.d0 * 3),
),
time_measure="absolute",
)
self.assertEqual(melody_converted.convert2relative(), self.melody0)
def test_copy(self):
melody0 = old.Melody([old.Tone(self.p0, self.d0), old.Tone(self.p0, self.d0)])
self.assertEqual(melody0, melody0.copy())
