$HARMONY


This JavaScript module handles musical harmonic functions.


Module file is: harmony-1.0.0.min.js.

$HARMONY Methods

Notes

MethodDescription
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

MethodDescription
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

MethodDescription
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

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

Chords

MethodDescription
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

MethodDescription
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

Introduction aux concepts musicaux utilisés

Notes

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

Les altérations

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) :

StringDescription StringDescription
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.

StringDescription StringDescription
MCb do bémol majeur mAb la bémol mineur
MGb sol bémol majeur mEb mi bémol mineur
MDb 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 mineur
MC do majeur mA la mineur
MG sol majeur mE mi mineur
MD 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# dièse mineur
MC# do dièse majeur mA# la dièse mineur

Chord's signatures

StringDescription StringDescription
(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 :

ModeDescription ModeDescription
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é.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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.

➜ 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é.

➜ 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é.

➜ 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é.

➜ 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é.

➜ 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é.

➜ 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.

➜ 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.