def test_inversion_pattern(self):
ctxt = 'CMaj+9@(9)'
template = TertianChordTemplate.parse(ctxt)
if template:
print('succeeded')
chord = template.create_chord()
print(chord)
else:
print("failed")
# Another way to do the same
from tonalmodel.interval import Interval, IntervalType
from tonalmodel.diatonic_tone_cache import DiatonicToneCache
template = TertianChordTemplate(DiatonicToneCache.get_cache().get_tone('C'),
None,
TertianChordType.to_type('Maj'),
[Interval(9, IntervalType.Major)],
None,
Interval(9, IntervalType.Major))
chord = template.create_chord()
print(chord)
# reuse
template = TertianChordTemplate.parse('IVMin')
diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicToneCache.get_cache().get_tone("Db"))
chord = template.create_chord(diatonic_tonality)
print(chord)
diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicToneCache.get_cache().get_tone("F"))
chord = template.create_chord(diatonic_tonality)
print(chord)
diatonic_tonality = Tonality.create(ModalityType.HarmonicMinor, DiatonicToneCache.get_cache().get_tone("C"))
chord = template.create_chord(diatonic_tonality)
print(chord)
def test_pentatonic_tonal_function(self):
t_domain = Tonality.create(ModalityType.MajorPentatonic,
DiatonicTone('C'))
interval = Interval(3, IntervalType.Major)
f = CrossTonalityShiftTonalFunction.create_shift(t_domain, interval)
# C, D, E, G. A ==> E, F#, G#, B, C#
assert 'E' == f['C'].diatonic_symbol
assert 'F#' == f['D'].diatonic_symbol
assert 'G#' == f['E'].diatonic_symbol
assert 'B' == f['G'].diatonic_symbol
assert 'C#' == f['A'].diatonic_symbol
assert 'A' == f['F'].diatonic_symbol
assert 'D#' == f['B'].diatonic_symbol
assert 'A#' == f['F#'].diatonic_symbol
assert 'D##' == f['B#'].diatonic_symbol
assert 'Ab' == f['Fb'].diatonic_symbol
assert 'D' == f['Bb'].diatonic_symbol
t_range = Tonality.create(ModalityType.MajorPentatonic,
interval.get_end_tone(DiatonicTone('C')))
f = CrossTonalityShiftTonalFunction(t_domain, t_range.annotation[2], 2)
# C, D, E, G. A ==> G#, B, C#, E, F#
assert 'G#' == f['C'].diatonic_symbol
assert 'B' == f['D'].diatonic_symbol
assert 'C#' == f['E'].diatonic_symbol
assert 'E' == f['G'].diatonic_symbol
assert 'F#' == f['A'].diatonic_symbol
TestCrossTonalityShiftTonalFunction.print_function(f)
def test_setting_values(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('C'))
t_range = Tonality.create(ModalityType.MajorPentatonic,
DiatonicTone('A'))
# A, B, C#, E, F#
# default map between 2 tonalities of unequal cardinality - empty
p = {
'C': 'A',
'D': 'A',
'E': 'B',
'F': 'C#',
'G': 'C#',
'A': 'E',
'B': 'F#'
}
f = TonalFunction(t_domain, t_range, p)
assert DiatonicToneCache.get_tone('A') == f['C']
assert DiatonicToneCache.get_tone('A') == f['D']
assert DiatonicToneCache.get_tone('B') == f['E']
assert DiatonicToneCache.get_tone('C#') == f['F']
assert DiatonicToneCache.get_tone('C#') == f['G']
assert DiatonicToneCache.get_tone('E') == f['A']
assert DiatonicToneCache.get_tone('F#') == f['B']
assert [0, 0, 1, 2, 2, 3, 4] == f.extract_template().tonal_order
f['C'] = 'B'
f['D'] = 'A'
f['E'] = 'C#'
f['F'] = 'C#'
f['G'] = 'F#'
f['A'] = 'A'
f['B'] = 'E'
# del f['D']
# assert f['D'] is None
assert [1, 0, 2, 2, 4, 0, 3] == f.extract_template().tonal_order
f['C#'] = 'B#'
f['Db'] = 'Ab'
f['A#'] = 'Eb'
assert DiatonicToneCache.get_tone('B#') == f['C#']
assert DiatonicToneCache.get_tone('Ab') == f['Db']
assert DiatonicToneCache.get_tone('Eb') == f['A#']
del f['Db']
def test_additional_octaves(self):
t_domain = Tonality.create(ModalityType.MinorPentatonic,
DiatonicTone('C'))
i = Interval(12, IntervalType.Perfect)
r = PitchRange.create('E:3', 'E:7')
f = CrossTonalityShiftPitchFunction(t_domain, r, i)
print('f={0}'.format(f))
assert 'P:12' == str(f.root_shift_interval)
assert 'G:5' == str(f['C:4'])
assert 'A:5' == str(f['D:4'])
assert 'B:5' == str(f['E:4'])
assert 'C:6' == str(f['F:4'])
i = Interval(11, IntervalType.Perfect).negation()
f = CrossTonalityShiftPitchFunction(t_domain, r, i)
print('f={0}'.format(f))
assert '-P:11' == str(f.root_shift_interval)
assert 'G:2' == str(f['C:4'])
assert 'A:2' == str(f['D:4'])
assert 'B:2' == str(f['E:4'])
assert 'C:3' == str(f['F:4'])
def test_diatonic_modal_indexed_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('C'))
i = Interval(2, IntervalType.Major)
r = PitchRange.create('E:3', 'E:7')
f = CrossTonalityShiftPitchFunction(t_domain, r, i, modal_index=4)
print('f={0}'.format(f))
TestCrossTonalityShiftPitchFunction.print_map('test_diatonic_function',
f)
t = f.tonal_function
print(t)
# test diatonic maps
assert 'D:4' == str(f['C:4'])
assert 'E:4' == str(f['D:4'])
assert 'F#:4' == str(f['E:4'])
assert 'G:4' == str(f['F:4'])
assert 'A:4' == str(f['G:4'])
assert 'B:4' == str(f['A:4'])
assert 'C:5' == str(f['B:4'])
assert 'D:5' == str(f['C:5'])
assert 'M:2' == str(f.root_shift_interval)
def test_value_for(self):
print("------- test_value_for")
tonality = Tonality.create(ModalityType.Major, 'E', 0)
# 11 scalar notes to E:2 to E:3 increment scalar note per value increment of 1/10, with E:2 being 1
interpreter = ScalarRangeInterpreter(tonality,
DiatonicPitch.parse('E:2'), 1,
Fraction(1, 10))
for i in range(0, 8):
p = interpreter.eval_as_nearest_pitch(1 + Fraction(i, 10))
print('[{0}] {1} --> {2}'.format(i, p, interpreter.value_for(p)))
assert interpreter.value_for(DiatonicPitch.parse('E:2')) == 1
assert interpreter.value_for(DiatonicPitch.parse('F#:2')) == Fraction(
11, 10)
assert interpreter.value_for(DiatonicPitch.parse('G#:2')) == Fraction(
12, 10)
assert interpreter.value_for(DiatonicPitch.parse('A:2')) == Fraction(
13, 10)
assert interpreter.value_for(DiatonicPitch.parse('B:2')) == Fraction(
14, 10)
assert interpreter.value_for(DiatonicPitch.parse('F:2')) is None
def test_non_centered_odd_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('E'))
r = PitchRange.create('E:3', 'E:7')
f = DiatonicPitchReflectionFunction(
t_domain, DiatonicPitch(4, DiatonicToneCache.get_tone('F#')), r,
FlipType.LowerNeighborOfPair)
TestFlipOnTonality.print_map('test_non_centered_odd_function', f)
t = f.tonal_function
assert 'E' == t['A'].diatonic_symbol
assert 'F#' == t['G#'].diatonic_symbol
assert 'G#' == t['F#'].diatonic_symbol
assert 'A' == t['E'].diatonic_symbol
assert 'B' == t['D#'].diatonic_symbol
assert 'C#' == t['C#'].diatonic_symbol
assert 'D#' == t['B'].diatonic_symbol
assert 'C#:4' == str(f['C#:5'])
assert 'D#:4' == str(f['B:4'])
assert 'E:4' == str(f['A:4'])
assert 'F#:4' == str(f['G#:4'])
assert 'G#:4' == str(f['F#:4'])
assert 'A:4' == str(f['E:4'])
assert 'B:4' == str(f['D#:4'])
assert 'C#:5' == str(f['C#:4'])
assert 'D#:5' == str(f['B:3'])
def test_centered_even_function(self):
t_domain = Tonality.create(ModalityType.HWOctatonic, DiatonicTone('C'))
r = PitchRange.create('E:3', 'E:7')
f = DiatonicPitchReflectionFunction(
t_domain, DiatonicPitch(4, DiatonicToneCache.get_tone('A')), r,
FlipType.CenterTone)
TestFlipOnTonality.print_map('test_centered_even_function', f)
t = f.tonal_function
assert 'C' == t['Gb'].diatonic_symbol
assert 'Db' == t['Fb'].diatonic_symbol
assert 'Eb' == t['Eb'].diatonic_symbol
assert 'Fb' == t['Db'].diatonic_symbol
assert 'Gb' == t['C'].diatonic_symbol
assert 'G' == t['Bb'].diatonic_symbol
assert 'A' == t['A'].diatonic_symbol
assert 'Bb' == t['G'].diatonic_symbol
assert 'C:4' == str(f['Gb:5'])
assert 'Db:4' == str(f['Fb:5'])
assert 'Eb:4' == str(
f['Eb:5']) # The other stable tone outside of the centered!
assert 'Fb:4' == str(f['Db:5'])
assert 'Gb:4' == str(f['C:5'])
assert 'G:4' == str(f['Bb:4'])
assert 'A:4' == str(f['A:4'])
assert 'Bb:4' == str(f['G:4'])
assert 'C:5' == str(f['Gb:4'])
assert 'Db:5' == str(f['Fb:4'])
def test_C_Natural_variable_cue_center(self):
print('test_C_Natural_variable_cue_center: C-Natural, variable cue')
domain_tonality = Tonality.create(ModalityType.NaturalMinor,
DiatonicToneCache.get_tone('C'))
answers = [['C', 'Bb', 'A', 'G', 'F', 'E', 'D'],
['E', 'D', 'C#', 'B', 'A', 'G#', 'F#'],
['Gb', 'Fb', 'Eb', 'Db', 'Cb', 'Bb', 'Ab'],
['Bb', 'Ab', 'G', 'F', 'Eb', 'D', 'C'],
['D', 'C', 'B', 'A', 'G', 'F#', 'E'],
['Fb', 'Ebb', 'Db', 'Cb', 'Bbb', 'Ab', 'Gb'],
['Ab', 'Gb', 'F', 'Eb', 'Db', 'C', 'Bb']]
index = 0
for cue_tone in domain_tonality.annotation[:-1]:
f = ChromaticTonalReflectionFunction(domain_tonality, cue_tone,
FlipType.CenterTone)
TestChromaticTonalReflectionFunction.print_map(
domain_tonality, f, cue_tone.diatonic_symbol)
for tone, i in zip(domain_tonality.annotation[:-1], range(0, 6)):
assert f[tone] == DiatonicToneCache.get_tone(answers[index][i]), \
'f[{0}]={1} != {2}'.format(tone.diatonic_symbol, f[tone].diatonic_symbol,
DiatonicToneCache.get_tone(answers[index][i]).diatonic_symbol)
index += 1
def test_non_centered_even_function(self):
t_domain = Tonality.create(ModalityType.WholeTone, DiatonicTone('C'))
r = PitchRange.create('E:3', 'E:7')
f = DiatonicPitchReflectionFunction(
t_domain, DiatonicPitch(4, DiatonicToneCache.get_tone('G#')), r,
FlipType.UpperNeighborOfPair)
TestFlipOnTonality.print_map('test_non_centered_even_function', f)
t = f.tonal_function
assert 'C' == t['D'].diatonic_symbol
assert 'D' == t['C'].diatonic_symbol
assert 'E' == t['A#'].diatonic_symbol
assert 'F#' == t['G#'].diatonic_symbol
assert 'G#' == t['F#'].diatonic_symbol
assert 'A#' == t['E'].diatonic_symbol
assert 'C:4' == str(f['D:5'])
assert 'D:4' == str(f['C:5'])
assert 'E:4' == str(f['A#:4'])
assert 'F#:4' == str(f['G#:4'])
assert 'G#:4' == str(f['F#:4'])
assert 'A#:4' == str(f['E:4'])
assert 'C:5' == str(f['D:4'])
def __init__(self, domain_tonality, new_root_tone, modal_index=None, inherent_modality_type=None):
"""
Constructor.
:param domain_tonality: Given domain tonality.
:param new_root_tone: The root for the new tonality.
:param modal_index: The modal index for the new root tone. If none, match to domain_tonality.
:param inherent_modality_type: new modality type for behind the new tonality, e.g. major. if None, match
to domain tonality.
Note: tonality cardinality must match!
Note: new_root_tone should be the domain_tonality's modal_index tone.
"""
modality = inherent_modality_type if inherent_modality_type is not None else domain_tonality.modality_type
if isinstance(new_root_tone, str):
root_tone_parameter = DiatonicToneCache.get_tone(new_root_tone)
else:
root_tone_parameter = new_root_tone
range_tonality = Tonality.create(modality, root_tone_parameter,
modal_index if modal_index is not None else domain_tonality.modal_index)
if domain_tonality.cardinality != range_tonality.cardinality:
raise Exception('domain and range tonalities must have same cardinality')
self._domain_tonality = domain_tonality
self._range_tonality = range_tonality
self._modal_index = range_tonality.modal_index
self.constr_primary_map = self._build_primary_map()
TonalFunction.__init__(self, self.domain_tonality, self.range_tonality, self.constr_primary_map,
self._build_extension_map())
def test_C_Major_variable_cue_lower_neighbor_function(self):
print(
'test_C_Major_variable_cue_lower_neighbor_function: C-major, variable cue'
)
domain_tonality = Tonality.create(ModalityType.Major,
DiatonicToneCache.get_tone('C'))
answers = [['D', 'C', 'Bb', 'A', 'G', 'F', 'Eb'],
['F#', 'E', 'D', 'C#', 'B', 'A', 'G'],
['A', 'G', 'F', 'E', 'D', 'C', 'Bb'],
['C', 'Bb', 'Ab', 'G', 'F', 'Eb', 'Db'],
['E', 'D', 'C', 'B', 'A', 'G', 'G'],
['G#', 'F#', 'E', 'D#', 'C#', 'B', 'A'],
['B', 'A', 'G', 'F#', 'E', 'D', 'C']]
index = 0
for letter in list('CDEFGAB'):
f = ChromaticTonalReflectionFunction(
domain_tonality, DiatonicToneCache.get_tone(letter),
FlipType.LowerNeighborOfPair)
TestChromaticTonalReflectionFunction.print_map(
domain_tonality, f, letter)
for tone, i in zip(domain_tonality.annotation[:-1], range(0, 6)):
assert f[tone] == DiatonicToneCache.get_tone(answers[index][i]), \
'f[{0}]={1} != {2}'.format(tone.diatonic_symbol, f[tone].diatonic_symbol,
DiatonicToneCache.get_tone(answers[index][i]).diatonic_symbol)
index += 1
def test_book_examples(self):
template = QuartalChordTemplate.parse('GPerAug')
if template:
print('succeeded')
chord = template.create_chord()
print(chord)
else:
print("failed")
diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("Bb"))
template = QuartalChordTemplate.parse('IIPerPer@2')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = QuartalChordTemplate.parse('GPPAAPP')
chord = template.create_chord()
print(chord)
template = QuartalChordTemplate.parse('IIIPAPAA@3')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = QuartalChordTemplate.parse('C')
chord = template.create_chord()
print(chord)
template = QuartalChordTemplate.parse('IV')
chord = template.create_chord(diatonic_tonality)
print(chord)
def __create_chord_on_diatonic_without_type(self, diatonic_tone):
from tonalmodel.tonality import Tonality
from tonalmodel.modality import ModalityType
from harmonicmodel.tertian_chord_template import TertianChordTemplate
diatonic_tonality = Tonality.create(ModalityType.Major, diatonic_tone)
tone_scale = diatonic_tonality.annotation
self.chord_basis = []
base_tone = None
for i in range(0, 3):
tone = tone_scale[(2 * i) % (len(tone_scale) - 1)]
if i == 0:
base_tone = tone
pitch_a = DiatonicPitch(1, diatonic_tone)
b_octave = 2 if base_tone.diatonic_index > tone.diatonic_index else 1
pitch_b = DiatonicPitch(b_octave, tone.diatonic_symbol)
interval = Interval.create_interval(pitch_a, pitch_b)
self.chord_basis.append(interval)
self.__tones.append((tone, interval))
self.__set_inversion()
self.__chord_type = TertianChordTemplate.get_chord_type(
self.chord_basis)
def test_centered_odd_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('E'))
r = PitchRange.create('E:3', 'E:7')
f = DiatonicPitchReflectionFunction(
t_domain, DiatonicPitch(4, DiatonicToneCache.get_tone('A')), r,
FlipType.CenterTone)
print('f={0}'.format(f))
TestFlipOnTonality.print_map('test_simple_pitch_function', f)
t = f.tonal_function
assert 'E' == t['D#'].diatonic_symbol
assert 'F#' == t['C#'].diatonic_symbol
assert 'G#' == t['B'].diatonic_symbol
assert 'A' == t['A'].diatonic_symbol
assert 'B' == t['G#'].diatonic_symbol
assert 'C#' == t['F#'].diatonic_symbol
assert 'D#' == t['E'].diatonic_symbol
assert 'D#:5' == str(f['E:4'])
assert 'C#:5' == str(f['F#:4'])
assert 'A:4' == str(f['A:4'])
assert 'G#:4' == str(f['B:4'])
assert 'F#:4' == str(f['C#:5'])
assert 'E:4' == str(f['D#:5'])
def test_C_major_modal_scales_center_cue(self):
print(
'test_C_major_modal_scales_center_cue: CenterTone, cue == root tone, modal on C-Major'
)
answers = [['C', 'Bb', 'Ab', 'G', 'F', 'Eb', 'Db'],
['D', 'C', 'B', 'A', 'G', 'F', 'E'],
['E', 'D#', 'C#', 'B', 'A', 'G#', 'F#'],
['F', 'Eb', 'Db', 'Cb', 'Bb', 'Ab', 'Gb'],
['G', 'F', 'Eb', 'D', 'C', 'Bb', 'A'],
['A', 'G', 'F#', 'E', 'D', 'C#', 'B'],
['B', 'A#', 'G#', 'F#', 'E#', 'D#', 'C#']]
index = 0
for letter in list('CDEFGAB'):
modal_tonality = Tonality.create(
ModalityType.Major, DiatonicToneCache.get_tone(letter), index)
f = ChromaticTonalReflectionFunction(
modal_tonality, DiatonicToneCache.get_tone(letter),
FlipType.CenterTone)
TestChromaticTonalReflectionFunction.print_map(
modal_tonality, f, letter)
for tone, i in zip(modal_tonality.annotation[:-1], range(0, 6)):
assert f[tone] == DiatonicToneCache.get_tone(answers[index][i]), \
'f[{0}]={1} != {2}'.format(tone.diatonic_symbol, f[tone].diatonic_symbol,
DiatonicToneCache.get_tone(answers[index][i]).diatonic_symbol)
index = index + 1
def test_book_examples(self):
diatonic_tonality = Tonality.create(ModalityType.Major,
DiatonicTone("A"))
template = SecondaryChordTemplate.parse('V/V')
if template:
print('succeeded')
chord = template.create_chord(diatonic_tonality)
print(chord)
else:
print("failed")
template = SecondaryChordTemplate.parse('III/II')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = SecondaryChordTemplate.parse('CMaj7/II')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = SecondaryChordTemplate.parse('V/V[NaturalMinor]')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = SecondaryChordTemplate.parse('V/V[Phrygian]')
chord = template.create_chord(diatonic_tonality)
print(chord)
template = SecondaryChordTemplate.parse('QVIPPAP@2/V')
chord = template.create_chord(diatonic_tonality)
print(chord)
def test_eval_as_nearest_pitch(self):
print("------- test_eval_as_nearest_pitch")
# Test for scalar range map
tonality = Tonality.create(ModalityType.Major, 'C', 0)
# 11 scalar notes to C:4 to G:5
interpreter = ScalarRangeInterpreter(tonality,
DiatonicPitch.parse('C:4'), 0,
Fraction(1, 11))
for i in range(0, 12):
p = interpreter.eval_as_nearest_pitch(Fraction(i, 11))
print('[{0}] {1}'.format(i, p))
assert str(interpreter.eval_as_nearest_pitch(Fraction(0, 11))) == 'C:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(1, 11))) == 'D:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(2, 11))) == 'E:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(3, 11))) == 'F:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(4, 11))) == 'G:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(5, 11))) == 'A:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(6, 11))) == 'B:4'
assert str(interpreter.eval_as_nearest_pitch(Fraction(7, 11))) == 'C:5'
assert str(interpreter.eval_as_nearest_pitch(Fraction(8, 11))) == 'D:5'
assert str(interpreter.eval_as_nearest_pitch(Fraction(9, 11))) == 'E:5'
assert str(interpreter.eval_as_nearest_pitch(Fraction(10,
11))) == 'F:5'
assert str(interpreter.eval_as_nearest_pitch(Fraction(11,
11))) == 'G:5'
p = interpreter.eval_as_nearest_pitch(Fraction(3, 11) + 0.01)
assert str(p) == 'F:4'
p = interpreter.eval_as_nearest_pitch(Fraction(3, 11) + 0.08)
assert str(p) == 'G:4'
def test_simple_tonality_permutation_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('A'))
cycles = [['C#', 'D'], ['E', 'G#']]
p = TonalityPermutationFunction.create(t_domain, cycles)
assert DiatonicToneCache.get_tone('C#') in p.domain
assert DiatonicToneCache.get_tone('D') in p.domain
assert DiatonicToneCache.get_tone('E') in p.domain
assert DiatonicToneCache.get_tone('G#') in p.domain
assert DiatonicToneCache.get_tone('D') == p['C#']
assert DiatonicToneCache.get_tone('C#') == p['D']
assert DiatonicToneCache.get_tone('E') == p['G#']
assert DiatonicToneCache.get_tone('G#') == p['E']
f = TonalityPermutationFunction(TonalityPermutation(t_domain, cycles))
assert DiatonicToneCache.get_tone('C#') in f.domain
assert DiatonicToneCache.get_tone('D') in f.domain
assert DiatonicToneCache.get_tone('E') in f.domain
assert DiatonicToneCache.get_tone('G#') in f.domain
assert DiatonicToneCache.get_tone('D') == f['C#']
assert DiatonicToneCache.get_tone('C#') == f['D']
assert DiatonicToneCache.get_tone('E') == f['G#']
assert DiatonicToneCache.get_tone('G#') == f['E']
def test_simple_reverse_pitch_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('E'))
cycles = [['E', 'G#', 'A', 'C#'], ('F#', 'D#')]
permutation_function = TonalityPermutationFunction.create(
t_domain, cycles)
r = PitchRange.create('E:3', 'E:7')
f = TonalityPitchFunction(permutation_function, ('E:4', 'E:5'), r,
True)
TestTonalityPitchFunction.print_map(
'test_simple_reverse_pitch_fnction', f)
assert 'G#:5' == str(f['E:4'])
assert 'D#:6' == str(f['F#:4'])
assert 'A:5' == str(f['G#:4'])
assert 'C#:6' == str(f['A:4'])
assert 'B:5' == str(f['B:4'])
assert 'E:5' == str(f['C#:5'])
assert 'F#:5' == str(f['D#:5'])
assert 'G#:4' == str(f['E:5'])
assert 'D#:5' == str(f['F#:5'])
assert 'A:4' == str(f['G#:5'])
assert 'C#:5' == str(f['A:5'])
assert 'B:4' == str(f['B:5'])
assert 'E:4' == str(f['C#:6'])
assert 'F#:4' == str(f['D#:6'])
def test_major_modality(self):
print('Testing Major Modality: D-Major, cue=G:4')
domain_tonality = Tonality.create(ModalityType.Major, DiatonicFoundation.get_tone('D'))
cue_pitch = DiatonicPitch.parse('G:4')
domain_pitch_range = PitchRange.create('D:3', 'C#:6')
f = ChromaticPitchReflectionFunction(domain_tonality, cue_pitch, domain_pitch_range, FlipType.CenterTone)
TestChromaticPitchReflectionFunction.print_function(f)
# Ensure all domain keys are in the domain_pitch_range
for pitch in f.domain:
assert domain_pitch_range.is_pitch_inbounds(pitch), \
'Pitch {0} is not in range {1}.'.format(pitch, domain_pitch_range)
assert DiatonicPitch.parse('D:3') in f.domain
assert DiatonicPitch.parse('C#:6') in f.domain
# Test for octave coverage
assert 6 == f['D:3'].octave
assert 5 == f['C#:4'].octave
assert 5 == f['D:4'].octave
assert 4 == f['C#:5'].octave
assert 4 == f['D:5'].octave
assert 3 == f['C#:6'].octave
def test_forward_with_extension(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('E'))
cycles = [['E', 'G#', 'A', 'C#'], ('F#', 'D#')]
extension = dict()
extension['D'] = 'F'
extension['F'] = 'G'
permutation_function = TonalityPermutationFunction.create(
t_domain, cycles, extension)
r = PitchRange.create('E:3', 'E:7')
f = TonalityPitchFunction(permutation_function, ('E:4', 'E:5'), r,
False)
TestTonalityPitchFunction.print_map('test_forward_with_extension', f)
assert 'G#:5' == str(f['E:4'])
assert 'G:5' == str(f['F:4'])
assert 'D#:6' == str(f['F#:4'])
assert 'A:5' == str(f['G#:4'])
assert 'C#:6' == str(f['A:4'])
assert 'B:5' == str(f['B:4'])
assert 'E:5' == str(f['C#:5'])
assert 'E:5' == str(f['B##:4'])
assert 'F:5' == str(f['D:5'])
assert 'F:5' == str(f['C##:5'])
assert 'F#:5' == str(f['D#:5'])
def test_pentatonic_tonal_function(self):
t_domain = Tonality.create(ModalityType.MinorPentatonic,
DiatonicTone('C'))
i = Interval(5, IntervalType.Perfect)
r = PitchRange.create('E:3', 'E:7')
f = CrossTonalityShiftPitchFunction(t_domain, r, i)
print('f={0}'.format(f))
TestCrossTonalityShiftPitchFunction.print_map(
'test_pentatonic_tonal_function', f)
t = f.tonal_function
print(t)
assert 'G' == t['C'].diatonic_symbol
assert 'Bb' == t['Eb'].diatonic_symbol
assert 'C' == t['F'].diatonic_symbol
assert 'D' == t['G'].diatonic_symbol
assert 'F' == t['Bb'].diatonic_symbol
assert 'G:5' == str(f['C:5'])
assert 'F:5' == str(f['Bb:4'])
assert 'D:5' == str(f['G:4'])
assert 'C:5' == str(f['F:4'])
assert 'Bb:4' == str(f['Eb:4'])
assert 'G:4' == str(f['C:4'])
# test range
d = f.domain_pitch_range
print(d)
assert d.start_index == DiatonicPitch.parse('E:3').chromatic_distance
assert d.end_index == DiatonicPitch.parse('E:7').chromatic_distance
r = f.range_pitch_range
print(r)
assert r.start_index == DiatonicPitch.parse('B:3').chromatic_distance
assert r.end_index == DiatonicPitch.parse('B:7').chromatic_distance
# test chromatics
assert 'G#:5' == str(f['C#:5'])
assert 'F#:5' == str(f['B:4'])
assert 'E#:5' == str(f['A#:4'])
assert 'E:5' == str(f['A:4'])
assert 'D#:5' == str(f['G#:4'])
assert 'C#:5' == str(f['F#:4'])
assert 'B:4' == str(f['E:4'])
assert 'A:4' == str(f['D:4'])
assert 'A#:4' == str(f['D#:4'])
assert 'G#:4' == str(f['C#:4'])
assert 'Gb:5' == str(f['Cb:5'])
assert 'Fb:5' == str(f['Bbb:4'])
assert 'Eb:5' == str(f['Ab:4'])
assert 'Db:5' == str(f['Gb:4'])
assert 'Cb:5' == str(f['Fb:4'])
assert 'Bbb:4' == str(f['Ebb:4'])
assert 'Ab:4' == str(f['Db:4'])
assert 'Gb:4' == str(f['Cb:4'])
def policy_creator(modality_type, modality_tone, tertian_chord_txt, low_pitch_txt, hi_pitch_txt):
diatonic_tonality = Tonality.create(modality_type, modality_tone)
chord = TertianChordTemplate.parse(tertian_chord_txt).create_chord(diatonic_tonality)
hc = HarmonicContext(diatonic_tonality, chord, Duration(1, 2))
pitch_range = PitchRange(DiatonicPitch.parse(low_pitch_txt).chromatic_distance,
DiatonicPitch.parse(hi_pitch_txt).chromatic_distance)
return PolicyContext(hc, pitch_range)
def test_major_key(self):
tonality = Tonality.create(ModalityType.Major, 'C', 0)
assert ModalityType.Major == tonality.modality_type
assert ModalityType.Major == tonality.modality.modality_type
assert 0 == tonality.modal_index
assert 'C' == tonality.diatonic_tone.diatonic_symbol
assert ['C', 'D', 'E', 'F', 'G', 'A', 'B',
'C'] == [t.diatonic_symbol for t in tonality.annotation]
def test_triad_generation(self):
diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("C"))
ret_types = [TertianChordType.Maj, TertianChordType.Min, TertianChordType.Min, TertianChordType.Maj,
TertianChordType.Maj,
TertianChordType.Min, TertianChordType.Dim]
for i in range(1, 8):
chord = TertianChordTemplate.get_triad(diatonic_tonality, i)
print(chord)
assert chord.chord_type.value == ret_types[i - 1]
def test_secondary_chord(self):
print('----- test_secondary_tonality -----')
diatonic_tonality = Tonality.create(ModalityType.Major,
DiatonicTone("C"))
chort_t_i = TertianChordTemplate.parse('tI')
chord_i = chort_t_i.create_chord(diatonic_tonality)
chord_v_ii = SecondaryChordTemplate.parse('V/ii').create_chord(
diatonic_tonality)
chord_vi_v = SecondaryChordTemplate.parse('vi/V').create_chord(
diatonic_tonality)
chord_t_ii = TertianChordTemplate.parse('tii')
chord_ii = chord_t_ii.create_chord(diatonic_tonality)
hc_track = HarmonicContextTrack()
hc_track.append(
HarmonicContext(diatonic_tonality, chord_i, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_v_ii, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_vi_v, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_ii, Duration(1)))
TestTFlip.print_hct(hc_track)
tune = [('C:5', (1, 1)), ('E:5', (1, 1)), ('E:5', (1, 1)),
('G:5', (1, 1))]
line = TestTFlip.build_line(tune)
cue = DiatonicPitch(5, 'd')
tflip = TDiatonicReflection(line, hc_track, cue)
temporal_extent = Interval(Fraction(0), Fraction(4))
score_line, score_hct = tflip.apply(temporal_extent, cue)
TestTFlip.print_notes(score_line)
TestTFlip.print_hct(score_hct)
notes = score_line.get_all_notes()
assert len(notes) == 4
assert str(notes[0].diatonic_pitch) == 'E:5'
assert str(notes[1].diatonic_pitch) == 'C#:5'
assert str(notes[2].diatonic_pitch) == 'C:5'
assert str(notes[3].diatonic_pitch) == 'A:4'
hc_list = score_hct.hc_list()
assert len(hc_list) == 4
assert hc_list[1].chord.primary_chord.chord_template.scale_degree == 7
assert {t[0].diatonic_symbol
for t in hc_list[1].chord.tones} == {'C#', 'E', 'G'}
assert hc_list[1].chord.primary_chord.chord_template.inversion == 3
assert hc_list[2].chord.primary_chord.chord_template.scale_degree == 7
assert {t[0].diatonic_symbol
for t in hc_list[2].chord.tones} == {'C', 'F#', 'A'}
assert hc_list[2].chord.primary_chord.chord_template.inversion == 3
def test_simplified_adapted_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('F'))
t_range = Tonality.create(ModalityType.MelodicMinor, DiatonicTone('G'))
f = TonalFunction(t_domain, t_range)
nt_domain = Tonality.create(ModalityType.Major, DiatonicTone('Ab'))
nt_range = Tonality.create(ModalityType.MelodicMinor,
DiatonicTone('e'))
pf = f.create_adapted_function(nt_domain, nt_range)
assert DiatonicToneCache.get_tone('E') == pf['Ab']
assert DiatonicToneCache.get_tone('F#') == pf['Bb']
assert DiatonicToneCache.get_tone('G') == pf['C']
assert DiatonicToneCache.get_tone('A') == pf['Db']
assert DiatonicToneCache.get_tone('B') == pf['Eb']
assert DiatonicToneCache.get_tone('C#') == pf['F']
assert DiatonicToneCache.get_tone('D#') == pf['G']
def test_simple_tonal_function(self):
t_domain = Tonality.create(ModalityType.Major, DiatonicTone('C'))
t_range = Tonality.create(ModalityType.Major, DiatonicTone('A'))
# default map between 2 tonalities of same cardinality.
f = TonalFunction(t_domain, t_range)
assert DiatonicToneCache.get_tone('A') == f['C']
assert DiatonicToneCache.get_tone('B') == f['D']
assert DiatonicToneCache.get_tone('C#') == f['E']
assert DiatonicToneCache.get_tone('D') == f['F']
assert DiatonicToneCache.get_tone('E') == f['G']
assert DiatonicToneCache.get_tone('F#') == f['A']
assert DiatonicToneCache.get_tone('G#') == f['B']
skeleton = f.extract_template()
assert [0, 1, 2, 3, 4, 5, 6] == skeleton.tonal_order
TestTonalFunction.print_function(f)
def test_simple_quartal(self):
diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("C"))
chord_list = ChordClassifier.classify(['e', 'a', 'd'], 'e', diatonic_tonality)
assert 1 == len(chord_list)
assert "PerPer" == str(chord_list[0].chord_type)
TestChordClassifier.print_chord_list('test_simple_quartal', chord_list)
chord_list = ChordClassifier.classify(['e', 'a', 'd', 'Bb'], 'e', diatonic_tonality)
assert 0 == len(chord_list)