$HARMONY

This JavaScript module handles musical harmonic functions.
Module file is: harmony-1.0.0.min.js.

$HARMONY Methods

Notes

Method	Description
getRelativeNote	Renvoie, à partir de la note donnée, la note à distance de l'intervalle montant donné.
getRelativeNotes	Renvoie, à partir de la note donnée, la liste des notes à distance des l'intervalles montants donnés.
getEnharmonic	Renvoie la note enharmonique de la note donnée.
getLatinNote	Renvoie le nom latin de la note.

Tones

Method	Description
getFarthestTone	Renvoie le ton le plus éloigné du cycle des quintes.
getSimpleTone	Renvoie le ton enharmonique simple.
getKeyNotes	Renvoie la liste des notes associées à une clé choisie.

Tonalities

Method	Description
getToneOfTonality	Renvoie le ton de la tonalité choisie.
getToneAndMinor	Renvoie le ton et mode majeur ou mineur.
getToneAndMode	Renvoie le ton et le mode de la tonalité choisie.
getEnharmonicTone	Renvoie le ton enharmonique en majeur et mineur de la tonalité choisie.

Harmonic functions

Method	Description
getHarmonicFunction	Renvoie la fonction harmonique d'un accord au degré donné, dans une gamme donnée.

Chords

Method	Description
getNotesFromSignature	Renvoie la liste des notes de l'accord ayant la signature donnée et la note donnée comme fondamentale.
getChordNotes	Renvoie la liste des notes de l'accord choisi.
getChordNumberOfNote	Renvoie le nombre de note d'un accord à partir de sa signature.
getChordSignatureName	Renvoie le nom d'usage d'une signature, en français.
getChordName	Renvoie le nom d'usage d'un accord, en français.
getChordIntervals	Renvoie la liste des intervalles en jeux pour une signature.
getChordFondamental	Renvoie la note fondamentale de l'accord choisi.
getChordBass	Renvoie la note à la basse de l'accord choisi.
getChordSignature	Renvoie la signature de l'accord choisi.

Modes

Method	Description
getModeIntervals	Renvoie la liste des intervalles contituant un mode.
getModeStructure	Renvoie une liste de deux strings, le nom du pentacorde suivi du nom du tétracorde, du mode sélectionné.
isModeHarmonisable	Renvoie un booléen indiquant si le mode choisi peut-être harmonisé.
getModeName	Renvoie une string du nom du mode choisi, en français.
getModeNaturalName	Renvoie une string du nom du mode ancien choisi.
getModeNotes	Renvoie la liste des notes d'un mode donné, pour un ton donné.
getModeSignature	Renvoie la signature de l'accord d'un degré dans un mode donné.
getModeSignatures	Renvoie la liste des signatures d'un mode donné.
getModeFunctions	Renvoie la liste des fonctions harmoniques d'un mode donné.
getModeChords	Renvoie la liste des accords d'un mode donné.

Validation

Tests

Introduction aux concepts musicaux utilisés

Notes

On utilise les notes dans la notation anglaise, soit les lettres majuscules :
C (do), D (ré), E (mi), F (fa), G (sol), A (la), B (si).

Les altérations

(rien) : sans altération pour un note naturelle,
# : le dièse,
x : le double dièse,
b : le bémol,
bb : le double bémol.

Certaines fonctions générent dans les cas limites des altérations triples : X pour le triple dièse et bbb pour le triple bémol. Il est alors d'usage d'utiliser les enharmoniques.

Degrees

Les degrés sont encodés en string en notation romaine : 'I', 'II', 'III', 'IV', 'V', 'VI' et 'VII'.

Tones

Les tons sont encodés sous forme d'une string :
'Cb', 'Gb', 'Db', 'Ab', 'Eb', 'Bb', 'F', 'C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#', 'G#', 'D#', 'A#'.

Intervals

Les intervalles sont encodés sous forme d'une string (case sensitive) :

String	Description	String	Description
P1	unison	P8	octave juste
m2	seconde mineure	M7	septième majeure
M2	seconde majeure	m7	septième mineure
A2	seconde augmentée	D7	septième diminuée
D3	tierce diminuée	A6	sixte augmentée
m3	tierce mineure	M6	sixte majeure
M3	tierce majeure	m6	sixte mineure
A3	tierce augmenté	D6	sixte diminuée
D4	quarte diminuée	A5	quinte augmentée
P4	quarte juste	P5	quinte juste
A4	quarte augmentée	D5	quinte diminuée
m9	neuvième mineure	M9	neuvième majeure
A9	neuvième augmentée	TT	triton
P11	onzième juste	A11	onzième augmentée
m13	treizième mineure	M13	treizième majeure

Tonalities

Les tonalités sont constitués d'un ton et d'un mode majeur ou mineur. Elles sont encodées sous forme d'une string. Le premier caractère represente le mode : M pour majeur et m pour mineur. Suit après le ton.

String	Description	String	Description
MCb	do bémol majeur	mAb	la bémol mineur
MGb	sol bémol majeur	mEb	mi bémol mineur
MDb	ré bémol majeur	mBb	si bémol mineur
MAb	la bémol majeur	mF	fa mineur
MEb	mi bémol majeur	mC	do mineur
MBb	si bémol majeur	mG	sol mineur
MF	fa majeur	mD	ré mineur
MC	do majeur	mA	la mineur
MG	sol majeur	mE	mi mineur
MD	ré majeur	mB	si mineur
MA	la majeur	mF#	fa dièse mineur
ME	mi majeur	mC#	do dièse mineur
MB	si majeur	mG#	sol dièse mineur
MF#	fa dièse majeur	mD#	ré dièse mineur
MC#	do dièse majeur	mA#	la dièse mineur

Chord's signatures

String	Description	String	Description
(vide), Maj	majeur	m	mineur
°, dim	diminué	(#5), +5	augmenté
7	septième de dominante	M7, Δ7	majeure 7
m7	mineur 7	mM7	mineur, majeure 7
°7, dim7	diminué 7	m7b5, Ø7	demi-diminué
7#5	7 à quinte augmentée	6	majeur six
sus2	suspendu 2	sus4	suspendu 4
add2, add9	add 9	7sus4	7 suspendu 4

Modes

Les modes ou gammes, sont encodés par un nombre entier :

Mode	Description	Mode	Description
0	majeur diatonique, ionien	14	mineur harmonique
1	dorien	15	locrien 6
2	phrygien	16	ionien #5
3	lydien	17	dorien #4, roumain
4	mixolydien	18	superphrygien, andalous
5	mineur naturel, éolien	19	lydien #2
6	locrien	20	diminué
7	mineur mélodique, éolien	21	mineur naturel
8	javanais, dorien b2	22	locrien
9	lydien augmenté	23	majeur diatonique, ionien
10	lydien dominant, Bartók	24	dorien
11	mixolydien b13, hindou	25	phrygien
12	mineur diminué, éolien b5	26	lydien
13	superlocrien	27	mixolydien
28	éthiopien	29	napolitain
30	napolitain harmonique	31	gitan, gitan hongrois
32	tzigane, hongrois mineur	33	hongrois majeur
34	bohémien, byzantin	35	gypzy
36	enigmatic	37	Sebastian
38	indien	39	arabe
40	oriental	41	locrien majeur
42	persan	43	mixolydien augmenté
44	lydien mineur

Harmonic functions

Les fonctions harmoniques sont encodées par une string :

String	Description
T	Tonique, degré I à l'état fondamental
Ts	Tonique, degré I à l'état fondamental avec la sensible.
t	Tonique, degré I à l'état de renversement ou autre degré sans la sensible.
ts	Tonique, degré I à l'état de renversement ou autre degré avec la sensible.

D	Dominante, avec le triton tonal (sensible et quarte).
d	Dominante, avec la sensible mais sans la quarte.
Dst	Dominante, substitution tritonique, subV7 ou bII7 avec quarte et sensible.
D2	Dominante secondaire, V7/?.
D2st	Substitution tritonique de la dominante secondaire, subV7/?.

SD	Sous-dominante.
SD2	Sous-dominante secondaire.

Les fonctions des notes

$HARMONY.getRelativeNote(note, interval)

Renvoie, à partir de la note donnée, la note à distance de l'intervalle montant donné.

note : la note sélectionnée.
interval : l'intervalle sélectionné.
Par exemple 'P4' pour la quarte', 'P5' pour la quinte' et 'M7' pour la sensible'.

➜ Renvoie, à partir de la note donnée, la note à distance de l'intervalle montant donné.

note = $HARMONY.getRelativeNote('C', 'P4'); // returns 'F' quarte
note = $HARMONY.getRelativeNote('C#', 'P5'); // returns 'G#' quinte
note = $HARMONY.getRelativeNote('Cb', 'M7'); // returns 'Bb' sensible
note = $HARMONY.getRelativeNote('Cb', 'D5'); // returns 'Gbb'
note = $HARMONY.getRelativeNote('C#', 'A5'); // returns 'Gx'

$HARMONY.getRelativeNotes(note, intervals)

Renvoie, à partir de la note donnée, la liste des notes à distance des l'intervalles montants donnés.

note : la note sélectionnée.
intervals : la liste des intervalles sélectionnés.

➜ Renvoie, à partir de la note donnée, la liste des notes à distance des l'intervalles montants donnés.

notes = $HARMONY.getRelativeNotes('E', ['M3', 'P5', 'M7']);
// returns ['G#', 'B', 'D#']);
notes = $HARMONY.getRelativeNotes('F#', ['M2', 'M3', 'A4']);
// returns ['G#', 'A#', 'B#']);
notes = $HARMONY.getRelativeNotes('D', ['A5','P1','M6','M3','m2','P4']);
// returns ['A#', 'D', 'B', 'F#', 'Eb', 'G']

$HARMONY.getEnharmonic(tone)

Renvoie la note enharmonique de la note donnée.

tone : la note sélectionnée.

➜ Renvoie la note enharmonique de la note donnée.

note = $HARMONY.getEnharmonic('C'); // returns 'B#'
note = $HARMONY.getEnharmonic('C#'); // returns 'Db'
note = $HARMONY.getEnharmonic('E'); // returns 'Fb'
note = $HARMONY.getEnharmonic('F'); // returns 'E#'

$HARMONY.getLatinNote(note)

Renvoie le nom latin de la note.

note : la note sélectionnée.

➜ Renvoie le nom latin de la note.

note = $HARMONY.getLatinNote('C'); // returns 'do'
note = $HARMONY.getLatinNote('D'); // returns 'ré'
note = $HARMONY.getLatinNote('E'); // returns 'mi'
note = $HARMONY.getLatinNote('F'); // returns'fa'
note = $HARMONY.getLatinNote('G'); // returns 'sol'
note = $HARMONY.getLatinNote('A'); // returns 'la'
note = $HARMONY.getLatinNote('B'); // returns 'si'
note = $HARMONY.getLatinNote('C#'); // returns 'do#'
note = $HARMONY.getLatinNote('Cx'); // returns 'dox'
note = $HARMONY.getLatinNote('Cb'); // returns 'dob'
note = $HARMONY.getLatinNote('Cbb'); // returns 'dobb'

Les fonctions des tons

$HARMONY.getFarthestTone(tone)

Renvoie le ton le plus éloigné du cycle des quintes.

tone : le ton sélectionné.

➜ Renvoie le ton le plus éloigné du cycle des quintes.

tone = $HARMONY.getFarthestTone('C'); // returns 'Gb'
tone = $HARMONY.getFarthestTone('Bb'); // returns 'Fb'
tone = $HARMONY.getFarthestTone('C#'); // returns 'G'
tone = $HARMONY.getFarthestTone('F#'); // returns 'C'

$HARMONY.getSimpleTone(tone)

Renvoie le ton enharmonique simple.

tone : le ton sélectionné.

➜ Renvoie le ton enharmonique simple.

tone = $HARMONY.getSimpleTone('Cb'); // returns 'B'
tone = $HARMONY.getSimpleTone('B#'); // returns 'C';
tone = $HARMONY.getSimpleTone('E#'); // returns 'F'
tone = $HARMONY.getSimpleTone('Fb'); // returns 'E'
tone = $HARMONY.getSimpleTone('Bbb'); // returns 'A'
tone = $HARMONY.getSimpleTone('Cx'); // returns 'D'
tone = $HARMONY.getSimpleTone('C'); // returns 'C'
tone = $HARMONY.getSimpleTone('Bb'); // returns 'Bb'
tone = $HARMONY.getSimpleTone('A#'); // returns 'A#'

$HARMONY.getKeyNotes(key)

Renvoie la liste des notes associées à une clé choisie.

key : la clé sélectionnée.

➜ Renvoie la liste des notes associées à une clé choisie.

notes=$HARMONY.getKeyNotes('C'); // ['C','D','E','F','G','A','B']
notes=$HARMONY.getKeyNotes('Cm'); // ['C','D','Eb','F','G','Ab','Bb']
notes=$HARMONY.getKeyNotes('C#'); // ['C#','D#','E#','F#','G#','A#','B#']
notes=$HARMONY.getKeyNotes('C#m'); // ['C#','D#','E','F#','G#','A','B']
notes=$HARMONY.getKeyNotes('Cb'); //['Cb','Db','Eb','Fb','Gb','Ab','Bb']
notes=$HARMONY.getKeyNotes('A'); // ['A','B','C#','D','E','F#','G#']
notes=$HARMONY.getKeyNotes('Am'); // ['A','B','C','D','E','F','G']

Les fonctions des tonalités

$HARMONY.getToneOfTonality(tonality)

Renvoie le ton de la tonalité choisie.

tonality : la tonalité sélectionnée.

➜ Renvoie le ton de la tonalité choisie.

tone = $HARMONY.getToneOfTonality('MC'); // returns 'C'
tone = $HARMONY.getToneOfTonality('mC'); // returns 'C'
tone = $HARMONY.getToneOfTonality('MCb'); // returns 'Cb'
tone = $HARMONY.getToneOfTonality('MC#'); // returns 'C#'

$HARMONY.getToneAndMinor(tonality)

Renvoie le ton et mode majeur ou mineur.

tonality : la tonalité sélectionnée.

➜ Renvoie le ton et mode majeur ou mineur.

tone = $HARMONY.getToneAndMinor('MC');
// returns { tone: 'C', minor: false }
tone = $HARMONY.getToneAndMinor('mC');
// returns { tone: 'C', minor: true }

$HARMONY.getToneAndMode(tonality)

Renvoie le ton et le mode de la tonalité choisie.

tonality : la tonalité sélectionnée.

➜ Renvoie le ton et le mode de la tonalité choisie.

tone = $HARMONY.getToneAndMode('MC');
// returns { tone: 'C', mode: 0, minor: false }
tone = $HARMONY.getToneAndMode('mC');
// returns { tone: 'C', mode: 14, minor: true }

$HARMONY.getEnharmonicTone(tonality)

Renvoie le ton enharmonique en majeur et mineur de la tonalité choisie.

tonality : la tonalité sélectionnée.

➜ Renvoie le ton enharmonique en majeur et mineur de la tonalité choisie.

en = $HARMONY.getEnharmonicTone('MCb');
// returns { major: 'Cb', minor: 'B' }
en = $HARMONY.getEnharmonicTone('mA#');
// returns { minor: 'A#', major: 'Bb' }

Les fonctions des accords

$HARMONY.getNotesFromSignature(note, signature)

Renvoie la liste des notes de l'accord ayant la signature donnée et la note donnée comme fondamentale.

note : la note sélectionnée, fondamentale de l'accord.
signature : la signature sélectionnée.

➜ Renvoie la liste des notes de l'accord ayant la signature donnée et la note donnée comme fondamentale.

notes = $HARMONY.getNotesFromSignature('C', 'M7'); // ['C','E','G','B']
notes = $HARMONY.getNotesFromSignature('F#', ''); // ['F#','A#','C#']
notes = $HARMONY.getNotesFromSignature('A', '°7'); // ['A','C','Eb','Gb']

$HARMONY.getChordNotes(chord)

Renvoie la liste des notes de l'accord choisi.

chord : l'accord sélectionné.

➜ Renvoie la liste des notes de l'accord choisi.

notes = $HARMONY.getChordNotes('C°7'); // ['C', 'Eb', 'Gb', 'Bbb']
notes = $HARMONY.getChordNotes('Dbm'); // ['Db', 'Fb', 'Ab']);
notes = $HARMONY.getChordNotes('Em7'); // ['E', 'G', 'B', 'D']
notes = $HARMONY.getChordNotes('F#M7'); // ['F#', 'A#', 'C#', 'E#']
notes = $HARMONY.getChordNotes('G7#9'); // ['G', 'B', 'D', 'F', 'A#']
notes = $HARMONY.getChordNotes('F(#5)'); // ['F', 'A', 'C#']
notes = $HARMONY.getChordNotes('F#(#5)'); // ['F#', 'A#', 'Cx']
notes = $HARMONY.getChordNotes('Cm/Eb'); // ['Eb', 'G', 'C']
notes = $HARMONY.getChordNotes('Cm7/A'); // ['A', 'C', 'Eb', 'G', 'Bb']

$HARMONY.getChordNumberOfNote(signature)

Renvoie le nombre de note d'un accord à partir de sa signature.

signature : la signature sélectionnée.

➜ Renvoie le nombre de note d'un accord à partir de sa signature.

n = $HARMONY.getChordNumberOfNote(''); // returns 3
n = $HARMONY.getChordNumberOfNote('m'); // returns 3
n = $HARMONY.getChordNumberOfNote('7'); // returns 4
n = $HARMONY.getChordNumberOfNote('7b5'); // returns 4
n = $HARMONY.getChordNumberOfNote('7b9'); // returns 5

$HARMONY.getChordSignatureName(signature)

Renvoie le nom d'usage d'une signature en français.

signature : la signature sélectionnée.

➜ Renvoie le nom d'usage de l'accord choisi (en français).

name = $HARMONY.getChordSignatureName(''); // returns 'majeur'
name = $HARMONY.getChordSignatureName('m'); // returns 'mineur'
name = $HARMONY.getChordSignatureName('°'); // returns 'diminué'
name = $HARMONY.getChordSignatureName('+5'); // returns 'augmenté'
name = $HARMONY.getChordSignatureName('7'); // returns '7'
name = $HARMONY.getChordSignatureName('m7'); // returns 'mineur 7'
name = $HARMONY.getChordSignatureName('mM7'); // returns 'mineur, majeure 7'
name = $HARMONY.getChordSignatureName('M7'); // returns 'majeure 7'
name = $HARMONY.getChordSignatureName('m7b5'); // returns 'demi-diminué'
name = $HARMONY.getChordSignatureName('°7'); // returns 'diminué 7'
name = $HARMONY.getChordSignatureName('7b9'); // returns '7 bémol 9'
name = $HARMONY.getChordSignatureName('79'); // returns '7 majeure 9'
name = $HARMONY.getChordSignatureName('7#9'); // returns '7 dièse 9'
name = $HARMONY.getChordSignatureName('7sus4'); // returns '7 suspendu 4'

$HARMONY.getChordName(tone, signature, html)

Renvoie le nom d'usage d'un accord en français.

tone : le ton sélectionné.
signature : la signature sélectionnée.
html : format de la string de sortie, par défaut à true. Cela permet de mettre le nom de la note en italique.

➜ Renvoie le nom d'usage de l'accord choisi (en français).

name = $HARMONY.getChordName(''); // returns '<i>do</i> majeur'
name = $HARMONY.getChordName('A', 'm', false); // returns 'la mineur'
name = $HARMONY.getChordName('Eb', 'm7'); // returns'<i>mi bémol</i> mineur 7'
name = $HARMONY.getChordName('F#', 'M7', false);  // returns 'fa dièse majeure 7'
name = $HARMONY.getChordName('B', '°'); // returns '<i>si</i> diminué'
name = $HARMONY.getChordName('Bb', '7sus4', false);  // returns 'si bémol 7 suspendu 4'

$HARMONY.getChordIntervals(signature)

Renvoie la liste des intervalles en jeux pour une signature.

signature : la signature sélectionnée.

➜ Renvoie la liste des intervalles en jeux pour une signature.

intervals = $HARMONY.getChordIntervals(''); // ['M3', 'P5']
intervals = $HARMONY.getChordIntervals('m'); // ['m3', 'P5']
intervals = $HARMONY.getChordIntervals('m7'); // ['m3', 'P5', 'm7']
intervals = $HARMONY.getChordIntervals('M7'); // ['M3', 'P5', 'M7']
intervals = $HARMONY.getChordIntervals('7#9'); // ['M3','P5','m7','A9']

$HARMONY.getChordFondamental(chord)

Renvoie la note fondamentale de l'accord choisi.

chord : l'accord sélectionné.

➜ Renvoie la note fondamentale de l'accord choisi.

note = $HARMONY.getChordFondamental('C°7'); // returns 'C'
note = $HARMONY.getChordFondamental('Dbm'); // returns 'Db'
note = $HARMONY.getChordFondamental('A#M7'); // returns 'A#'
note = $HARMONY.getChordFondamental('Bm7b5'); // returns 'B'
note = $HARMONY.getChordFondamental('Bb(#5)'); // returns 'Bb'
note = $HARMONY.getChordFondamental('C/E'); // returns 'C'

$HARMONY.getChordBass(chord)

Renvoie la note à la basse de l'accord choisi.

chord : l'accord sélectionné.

➜ Renvoie la note à la basse de l'accord choisi.

bass = $HARMONY.getChordBass('C°7'); // returns 'C'
bass = $HARMONY.getChordBass('Dbm'); // returns 'Db'
bass = $HARMONY.getChordBass('C/E');  // returns 'E'
bass = $HARMONY.getChordBass('Cm/Ab');  // returns 'Ab'
bass = $HARMONY.getChordBass('Bbm7b5/F');  // returns 'F'

$HARMONY.getChordSignature(chord)

Renvoie la signature de l'accord choisi.

chord : l'accord sélectionné.

➜ Renvoie la signature de l'accord choisi.

sig = $HARMONY.getChordSignature('C°7'); // returns '°7'
sig = $HARMONY.getChordSignature('G#');  // returns ''
sig = $HARMONY.getChordSignature('Dbm'); // returns 'm'
sig = $HARMONY.getChordSignature('C/E');  // returns ''
sig = $HARMONY.getChordSignature('Bbm7b5/F');  // returns 'm7b5'

Les fonctions des modes

$HARMONY.getModeIntervals(mode)

Renvoie la liste des intervalles contituants un mode.

mode : le mode sélectionné.

➜ Renvoie une liste de string des intervalles dans l'ordre croissant des degrés.

intervals = $HARMONY.getModeIntervals(0); // mode majeur diatonique
// returns ['P1', 'M2', 'M3', 'P4', 'P5', 'M6', 'M7']

intervals = $HARMONY.getModeIntervals(7); // mode mineur mélodique
// returns ['P1', 'M2', 'm3', 'P4', 'P5', 'M6', 'M7']

intervals = $HARMONY.getModeIntervals(14); // mode mineur harmonique
// returns ['P1', 'M2', 'm3', 'P4', 'P5', 'm6', 'M7']

intervals = $HARMONY.getModeIntervals(21); // mode mineur naturel
// returns ['P1', 'M2', 'm3', 'P4', 'P5', 'm6', 'm7']

$HARMONY.getModeStructure(mode)

Renvoie une liste de deux strings, le nom du pentacorde suivi du nom du tétracorde.

mode : le mode sélectionné.

➜ Renvoie une liste de deux strings, le nom du pentacorde suivi du nom du tétracorde.

s = $HARMONY.getModeStructure(0); // mode majeur diatonique
// returns ['majeur', 'majeur']

s = $HARMONY.getModeStructure(7); // mode mineur mélodique
// returns ['mineur', 'majeur']

s = $HARMONY.getModeStructure(14); // mode mineur harmonique
// returns ['mineur', 'harmonique']

s = $HARMONY.getModeStructure(21); // mode mineur naturel
// returns ['mineur', 'phrygien']

$HARMONY.isModeHarmonisable(mode)

Renvoie un booléen indiquant si le mode choisi peut-être harmonisé ou non.

mode : le mode sélectionné.

➜ Renvoie true si le mode est harmonisable, false sinon.

b = $HARMONY.isModeHarmonisable(0); // true, 0 = mode majeur diatonique
b = $HARMONY.isModeHarmonisable(29); // false, 29 = mode napolitain

$HARMONY.getModeName(mode)

Renvoie une string du nom du mode choisi.

mode : le mode sélectionné.

➜ Renvoie une string du nom du mode choisi.

name = $HARMONY.getModeName(0); // returns "majeur diatonique"
name = $HARMONY.getModeName(7); // returns "mineur mélodique"
name = $HARMONY.getModeName(14); // returns "mineur harmonique"
name = $HARMONY.getModeName(21); // returns "mineur naturel"

$HARMONY.getModeNaturalName(mode)

Renvoie une string du nom du mode ancien choisi.

mode : le mode sélectionné.

➜ Renvoie une string du nom du mode ancien choisi.

name = $HARMONY.getModeNaturalName(0); // returns "ionien"
name = $HARMONY.getModeNaturalName(1); // returns "dorien"
name = $HARMONY.getModeNaturalName(2); // returns "phrygien"
name = $HARMONY.getModeNaturalName(3); // returns "lydien"
name = $HARMONY.getModeNaturalName(4); // returns "mixolydien"
name = $HARMONY.getModeNaturalName(5); // returns "éolien"
name = $HARMONY.getModeNaturalName(6); // returns "locrien"
name = $HARMONY.getModeNaturalName(14); // returns "mode I"
name = $HARMONY.getModeNaturalName(15); // returns "mode II"

$HARMONY.getModeNotes(mode, tone)

Renvoie la liste des notes d'un mode donné pour un ton donné.

mode : le mode sélectionné.
tone : le ton sélectionné.

➜ Renvoie une liste de string des notes dans l'ordre croissant des degrés.

notes = $HARMONY.getModeNotes(0, 'E'); // mode majeur diatonique, ton E
// returns ['E', 'F#', 'G#', 'A', 'B', 'C#', 'D#']

notes = $HARMONY.getModeNotes(7, 'C'); // mode mineur mélodique, ton C
// returns ['C', 'D', 'Eb', 'F', 'G', 'A', 'B']

notes = $HARMONY.getModeNotes(14, 'A#'); // mode mineur harmonique, ton A#
// returns ['A#', 'B#', 'C#', 'D#', 'E#', 'F#', 'Gx']

notes = $HARMONY.getModeNotes(21, 'Ab'); // mode mineur naturel, ton Ab
// returns ['Ab', 'Bb', 'Cb', 'Db', 'Eb', 'Fb', 'Gb']

$HARMONY.getModeSignature(mode, degree, bSeven)

Renvoie la signature de l'accord d'un degré dans un mode donné.

mode : le mode sélectionné.
degree : le degré sélectionné de 0 à 6.
bSeven : true pour une signature à quatre sons, false pour trois sons.

➜ Renvoie la signature de l'accord d'un degré dans un mode donné.

s = $HARMONY.getModeSignature(0, 1, false); // majeur diatonique, 2e degré
// returns 'm'
s = $HARMONY.getModeSignature(0, 6, true); // majeur diatonique, 7e degré
// returns 'Ø7'

$HARMONY.getModeSignatures(mode, bSeven)

Renvoie la liste des signatures d'un mode donné.

mode : le mode sélectionné.
bSeven : true pour une signature à quatre sons, false pour trois sons.

➜ Renvoie la liste de string des signatures dans l'ordre croissant des degrés.

s = $HARMONY.getModeSignatures(0, false); // majeur diatonique
// returns ['', 'm', 'm', '', '', 'm', '°']

s = $HARMONY.getModeSignatures(0, true); // mode majeur diatonique
// returns ['M7', 'm7', 'm7', 'M7', '7', 'm7', 'Ø7']

s = $HARMONY.getModeSignatures(7, false); // mode mineur mélodique
// returns ['m', 'm', '+5', '', '', '°', '°']

s = $HARMONY.getModeSignatures(7, true); // mode mineur mélodique
// returns ['mM7', 'm7', '+M7', '7', '7', 'Ø7', 'Ø7']

s = $HARMONY.getModeSignatures(14, false); // mode mineur harmonique
// returns ['m', '°', '+5', 'm', '', '', '°']

s = $HARMONY.getModeSignatures(14, true); // mode mineur harmonique
// returns ['mM7', 'Ø7', '+M7', 'm7', '7', 'M7', '°7']

s = $HARMONY.getModeSignatures(21, false); // mode mineur naturel
// returns ['m', '°', '', 'm', 'm', '', '']

$HARMONY.getModeFunctions(mode, bSeven)

Renvoie la liste des fonctions harmoniques d'un mode donné.

mode : le mode sélectionné.
bSeven : true pour une signature à quatre sons, false pour trois sons.

➜ Renvoie la liste de string des fonctions harmoniques dans l'ordre croissant des degrés.

f = $HARMONY.getModeFunctions(0, false); // majeur diatonique, 3 sons
// returns ['T',  'SD', 'd',  'SD', 'd', 't', 'D']

f = $HARMONY.getModeFunctions(0, true); // majeur diatonique, 4 sons
// returns ['Ts', 'SD', 'ts', 'SD', 'D', 't', 'D']

f = $HARMONY.getModeFunctions(14, false); // mineur harmonique, 3 sons
// returns ['T', 'SD', 'd', 'SD', 'd', 'SD', 'D']

f = $HARMONY.getModeFunctions(14, true); // mineur harmonique, 4 sons
// returns ['Ts', 'SD', 'ts', 'SD', 'D', 'SD', 'D']

$HARMONY.getModeChords(mode, tone, bSeven)

Renvoie la liste des accords d'un mode donné.

mode : le mode sélectionné.
tone : le ton sélectionné.
bSeven : true pour une signature à quatre sons, false pour trois sons.

➜ Renvoie la liste de string des accords dans l'ordre croissant des degrés.

chords = $HARMONY.getModeChords(0, 'I', false); // Degré I
// returns ['', 'm', 'm', '', '', 'm', '°']

chords = $HARMONY.getModeChords(0, 'I', true); // Degré I
// returns ['M7', 'm7', 'm7', 'M7', '7', 'm7', 'Ø7']

chords = $HARMONY.getModeChords(0, 'C', false); // majeur diatonique
// returns ['C', 'Dm', 'Em', 'F', 'G', 'Am', 'B°']

chords = $HARMONY.getModeChords(0, 'D', true); // majeur diatonique
// returns ['DM7', 'Em7', 'F#m7', 'GM7', 'A7', 'Bm7', 'C#Ø7']

chords = $HARMONY.getModeChords(7, 'E', false); // mode mineur mélodique
// returns ['Em', 'F#m', 'G+5', 'A', 'B', 'C#°', 'D#°']

chords = $HARMONY.getModeChords(7, 'F', true); // mode mineur mélodique
// returns ['FmM7', 'Gm7', 'Ab+M7', 'Bb7', 'C7', 'DØ7', 'EØ7']

chords = $HARMONY.getModeChords(14, 'G', false); // mode mineur harmonique
// returns ['Gm', 'A°', 'Bb+5', 'Cm', 'D', 'Eb', 'F#°']

chords = $HARMONY.getModeChords(14, 'A', true); // mode mineur harmonique
// returns ['AmM7', 'BØ7', 'C+M7', 'Dm7', 'E7', 'FM7', 'G#°7']

chords = $HARMONY.getModeChords(21, 'Bb', false); // mode mineur naturel
// returns ['Bbm', 'C°', 'Db', 'Ebm', 'Fm', 'Gb', 'Ab']

Les fonctions harmoniques

$HARMONY.getHarmonicFunction(intervals, degree, bSeven)

Renvoie la fonction harmonique d'un accord au degré donné dans une gamme donnée.

intervals : une liste de sept intervales décrivant la gamme sélectionnée.
degree : le degré sélectionné de 0 à 6.
bSeven : true pour une signature à quatre sons, false pour trois sons.

➜ Renvoie la fonction harmonique d'un accord au degré donné dans une gamme donnée.

var major = ['P1','M2','M3','P4','P5','M6','M7'];
fn = $HARMONY.getHarmonicFunction(major, 0, false); // returns 'T'
fn = $HARMONY.getHarmonicFunction(major, 0, true);  // returns 'Ts'
fn = $HARMONY.getHarmonicFunction(major, 2, true);  // returns 'ts'
fn = $HARMONY.getHarmonicFunction(major, 5, false); // returns 't'
fn = $HARMONY.getHarmonicFunction(major, 2, false); // returns 'd'
fn = $HARMONY.getHarmonicFunction(major, 4, false); // returns 'd'
fn = $HARMONY.getHarmonicFunction(major, 4, true);  // returns 'D'
fn = $HARMONY.getHarmonicFunction(major, 1, false); // returns 'SD'

Les fonctions harmoniques générées sont encodées par une string :

String	Description
T	Tonique, degré I à l'état fondamental
Ts	Tonique, degré I à l'état fondamental avec la sensible.
t	Tonique, degré I à l'état de renversement ou autre degré sans la sensible.
ts	Tonique, degré I à l'état de renversement ou autre degré avec la sensible.

D	Dominante, avec le triton tonal (sensible et quarte).
d	Dominante, avec la sensible mais sans la quarte.

SD	Sous-dominante.