Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
 
 
 
 
# Python 3.9 UTF-8
# Dimanche 28 mars 2021 à 19h 45m (premières lignes)
# Mardi 13 avril 2021 (Développement des tétracordes)
#
# Conçu par Vicenté Llavata Abreu alias Toumic
 
 
""" Script de construction des gammes musicales utilisant ces notes (C, D, E, F, G, A, B)
Explications:
    La création des gammes musicales englobe les notes & les intervalles dans une octave de 12 ½ tons,
    elle se concentre sur les tétracordes étant des corps de 4 notes. L'assemblage formé
    par les gammes gestionnaires de l'intervalle, assemble 2 modèles tétras superposés. La création
    tétracordique mène à une gammologie musicale à partir d'un simple cluster de 4 éléments."""
 
 
# Fichiers développés
"""..."""
# Fonction développement
"""..."""
# Déclarations des mémoires
tablT = []
dicoT, dicoM, dicoG = {}, {}, {} # Dictionnaires(Tétra,Mode,Gamme)
voirT = {}
yoyoT = [0]
mini0 = '1234'              # Tétracorde primaire
octave = 13         # 13 emplacements
maxi0 = (octave - len(mini0)) - 1
tetra0, tetra1, t234 = [], ['1', '2', '3', '4'], []
tablT.append(tetra1)
# Itérations
t1, t2, t3, t4 = 0, 1, 2, 3 # maxi0 = 9
u, u1, u2, u3, u4 = 0, 0, 0, 0, 0 # unité de blocage
x, stop, stop0, stop1 = 0, True, False, 5
# Opération Dico(mixam)
mixam = {} # Dépendances Degré(min/max)
""" Niveau T2 | MINI=1 MIDI=NULL MAXI=6 """
""" Niveau T3 | MINI=2 MIDI=T2+1 MAXI=7 """
""" Niveau T4 | MINI=3 MIDI=T3+1 MAXI=8 """
nt234= [[2,[1, 6]], [3,[2, 7]], [4,[3, 8]]]
j = -1
gamme = '1020340506078'     # Chromatisme naturel
notes = 'CDEFGABC'          # Notes musique
alter = ['', '+', 'x', '^', '^+', '^x', '-*', '°*', '*', '°', '-']
tabas, tahau = [], []       # Tétra*défaut
 
 
# Fonction couplage tétracordique
def couple():
    x, z = 0, 0
    for c in tablT:
        y, cyt, ctt = 0, [], []
        for t in tablT:
            l_ct = len(c) + len(t)              # Somme cas
            if octave >= l_ct:
                o_ct = octave - l_ct            # Différence
                if l_ct < octave and o_ct > 0:
                    for o in range(o_ct):
                        cyt.append('0')         # Vide zéro entre tétra
                ctt = []
                for t1 in t:
                    if t1 != '0':
                        t2 = str(int(t1) + 4)   # Vide zéro dans tétra
                    else:
                        t2 = '0'
                    ctt.append(t2)
                dicoM[z] = tabas[x] + tahau[y]
                """Suivre cot"""
                cot = c.copy()
                if len(cyt):
                    cot += cyt
                cot += ctt
                dicoT[z] = cot
                cyt = []
                y += 1
                z += 1
            # print(f'z{z} dicoT{dicoT[z]}\n')
        # if x == 2 and y == 2: break ####
        x += 1
    # for d in dicoT.values(): print(f'{d}\n')
    # for d in dicoM: print(f'{dicoM[d]}\n')
 
 
 
 
# Fonction format diatonique tétracordique
def diaton(uni, dia):
    """ Chromatisation des tétras bas/haut """
    # print(f'Fonc Unité:{uni} Diatonie:{dia}')
    x, oo, o1o, o8o = -1, 0, [], []
    for deg in dia:
        ego1, ego8 = '', ''
        oo = octave - len(dia)
        x += 1
        if int(deg) > 0:
            ged = str(int(deg) + 4)
            sign1 = x - gamme.index(deg) # BAS bémol/dièse
            sign8 = (x + oo) - gamme.index(ged) # HAUT bémol/dièse
            # print(f'Ged{ged}, sign8{sign8} x{x} oo{oo} dia{dia} gamme.index(ged){gamme.index(ged)}')
            if int(deg) > 0:
                # Signature dièse
                ego1 = alter[sign1]
                ego8 = alter[sign8]
            else:
                # Signature bémol
                ego1 = alter[sign1]
                ego8 = alter[sign8]
            ooo1 = str(notes[int(deg)-1] + ego1 + deg)
            ooo8 = str(notes[int(ged)-1] + ego8 + ged)
            # print(f'ego1&8 {ego1}{ego8}|ooo1&8{ooo1}{ooo8}')
            if ooo1[1] in alter:
                o1o.append(ooo1)
            else:
                o1o.append(ooo1[0])
            if ooo8[1] in alter:
                o8o.append(ooo8)
            else:
                o8o.append(ooo8[0])
    tabas.append(o1o)
    tahau.append(o8o)
    # print(f'Tabas {tabas[-1]}:{tahau[-1]} Tahau | Dia{dia}')
    # print(f'TableT{tablT}')
 
 
# Charge limite tétra
for i in tetra1:
    if i != '1':
        j += 1
        mixam[j] = nt234[j][1]
#print(f'Mixam {mixam}')
# Développement tétracordique
while stop:
    # Fonction fabrication
    def brique(nom, valeur, vrai):
        yoyoT[0] += 1
        voirT[yoyoT[0]] = 'FoncBric'
        # Vrai[1, 2, 4] Valeur(index) Nom(degré) Table[0]=['1', '2', '3', '4']
        rang = tablT[0].index(nom) # Index Nom Cluster[1,2,3,4]
        # print(f'_ Fonction nom:valeur {nom}:{valeur} Table {tablT[-1]} Vrai {vrai}|*FoncBric mox{maxi0}')
        vide, pose, terme, bric = 0, 0, vrai[-1], []
        # print(f'Rang={rang} pose={pose} vrai={vrai}')
        while 1: 
            if vide == 0:
                pose += 1
                bric.append('1')
                # print(f'Fonc(0)|{bric}|Vide={vide}')
                vide += 1
            if vide in vrai:
                pose += 1
                bric.append(str(pose))
                # print(f'Fonc(vrai)|{bric}|Vide={vide}')
                if vide == vrai[-1]:
                    tetra1 = [o for o in bric]
                    tablT.append(tetra1)
                    # print(f'_ Fonction _ {bric}| brique_voirT')
                    break
                vide += 1
            if vide not in vrai:
                bric.append('0')
                # print(f'Fonc(faux)|{bric}|Vide={vide}')
                vide += 1
 
 
    # print(f'--------------------------------------Champ:{len(tablT)}:{tablT[-1]}')
 
 
    """Niveaux : T's : Comptes(T234|Routes(U234 """
    if u4 == 0 and t4 <= maxi0 and t2 < 6:
        yoyoT[0] += 1
        voirT[yoyoT[0]] = 'Cond_U4'
        """ Niveau T4 | MINI=3 MIDI=T3+1 MAXI=8"""
        # Cycle T4 | True:STOP(T3,T2);GO(T4) | False:GO(T3)
        # print(f'***T4 True:STOP(T3,T2);GO(T4)|T4={t4} maxi0:{maxi0}')
        # print(f'| ifT4avant || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u3} | {tablT[-1]}')
        if (t4 + 1) > maxi0:
            u2, u3, u4 = 1, 0, 1 # .....    .....   .....       Tour Entier :GO(T3)
            # print(f'| ifT4ifaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
        else:
            t4 += 1
            u2, u3, u4 = 1, 1, 0 # .....    .....   .....       Tour Entier :GO(T4)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |GO(T4)bric')
            # print(f'| ifT4ifelseaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
            brique('4', t4, t234) # .....    .....   Fonction brique tétra
            t234 = []
    else:
        if t4 <= maxi0:
            # Ici U4 = 1 :(t4 <= maxi0)
            # print(f'elseIF:T4avant|False:GO(T4)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            u2, u3, u4 = 1, 1, 0 #     .....   .....   .....   False :GO(T4)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T4)bric')
            # print(f'elseIF:T4après|False:GO(T4)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            t234 = []
        else:
            # print(f'elseIFelse:T4avant|False:GO(T3)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            u2, u3, u4 = 1, 0, 1 #      .....    .....    .....     False:GO(T3)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T4)bric')
            # print(f'elseIFelse:T4après|False:GO(T3)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            t234 = []
 
 
    if u3 == 0 and t3 < maxi0:
        yoyoT[0] += 1
        voirT[yoyoT[0]] = 'Cond_U3'
        """ Niveau T3 | MINI=2 MIDI=T2+1 MAXI=7"""
        # Cycle T3 | True:GO(T4);STOP(T2);GO(T3) | False :GO(T2)
        # print(f'\n***T3 True:GO(T4);STOP(T2);GO(T3)|T3={t3} maxi0:{maxi0}')
        # print(f'| ifT3avant || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
        t3 += 1
        t4 = t3 + 1 # Opération Test(T3)/in
        if t4 <= maxi0:
            # Test(T3) Ici T4 <= maxi0(8)"""
            u2, u3, u4 = 1, 1, 0 # .....    .....   .....   .....   Tour unic :GO(T4)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |GO(T3)bric')
            # print(f'| ifT3ifaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
            brique('3', t3, t234) #      .....   .....   Fonction brique tétra
            t234 = []
        else:
            # Test(T3) Ici T4 > maxi0(8)"""
            t3 -= 1
            t4 -= 1
            u2, u3, u4 = 0, 1, 1 # .....    .....   .....   .....   Tour unic :GO(T2)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T3)bric')
            # print(f'| ifT3ifelseaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
            t234 = [] # Opération Test(T3)/Out
    else:
        # De :if u3 == 0 and t3 < maxi0: Soit(U3=1;
        if u3 == 1 and t4 <= maxi0:
            # print(f'elseIF:T3avant|False:GO(T4)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            u2, u3, u4 = 1, 1, 0 # .....    .....   .....   .....   False :GO(T4)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T3)bric')
            # print(f'elseIF:T3après|False:GO(T4)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            t234 = []
        else:
            # print(f'elseIFelse:T3avant|False:GO(T2)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            u2, u3, u4 = 0, 1, 1 # .....    .....   .....   .....   False :GO(T2)
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T3)bric')
            # print(f'elseIFelse:T3après|False:GO(T2)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            t234 = []
 
    if u2 == 0 and t2 < maxi0 - 1:
        yoyoT[0] += 1
        voirT[yoyoT[0]] = 'Cond_U2'
        """ Niveau T2 | MINI=1 MIDI=NULL MAXI=6 """
        # Cycle T2 | True:GO(T4):GO(T3):GO(T2) | False:OUT
        # print(f'\n***T2 True:GO(T4):GO(T3):GO(T2)|T2={t2} maxi0:{maxi0}')
        # print(f'| ifT2avant || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
        t2 += 1
        t3 = t2 + 1
        t4 = t3 + 1 # Opération Test(T2)/in
        if t4 <= maxi0:
            # Test(T2) Ici t4 <= maxi0(8)"""
            u2, u3, u4 = 1, 1, 0
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |GO(T2)bric')
            # print(f'| ifT2ifaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
            brique('2', t2, t234) # .....    .....   .....         Fonction brique tétra
            t234 = []
        else:
            # Test(T2) Ici t4 > maxi0(8)"""
            t2 -= 1
            t3 -= 1
            t4 -= 1
            u2, u3, u4 = 1, 1, 1 # Opération Test(T2)/Out
            """ Motif T234;Index Degrés"""
            t234 = [t2, t3, t4]
            # print(f'COMPTESindex: {t234} |STOP(T2)bric')
            # print(f'| ifT2ifelseaprès || T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} | {tablT[-1]}')
            t234 = []
            break
    else:
        # De u2 == 0 and t2 < maxi0 - 1:
        if t2 == mixam[0][1]:
            # print(f'elseIF:T2avant|False:STOP(T2)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4}')
            u2, u3, u4 = 1, 1, 1
            # print(f'elseIF:T2après|False:STOP(T2)|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4}')
            break
        else:
            # print(f'elseIFelse:T2avant|False:OUT|| T234;{t2},{t3},{t4} : U234;{u2},{u3},{u4} ')
            u2, u3, u4 = 1, 1, 0 # .....    .....   .....   .....   False:OUT             
# print(f'--------------------------------------Champ:{len(tablT)}:{tablT}:Nombre de tétras = {len(tablT)}')
unit = u
for t in range(len(tablT)):
    diaton(unit, tablT[unit])
    unit += 1
couple()


Pas besoin de présenter les tétracordes, parce qu’ils sont doublement incontournables au vocabulaire scientifique, et surtout ils vont par deux dans nouvelle / ancienne gamme musicale. L’un commence à la tonique et l'autre se termine à l'octave.
1234000005678
Dire l’un c’est dire l’autre, dans un état bipolaire hypermanent !

De manière classique le tétracorde a un état minimum de 4 notes (1,2,3,4), ces quatre notes sont liées au code quantique de la gamme naturelle.
CDEFGABC
Il est dit que la gamme naturelle est une diatonique à tonalité majeure…

Essayer de développer une logique gammique à partir de son plus petit élément clustérien, c’est connaitre le cluster relatif chromatique. En sachant que la gamme comporte cinq intervalles situés entre certaines notes.
BC D EF G A BC
Elle commence en Do© elle ne comporte pas d’altération, c’est naturel !

Le premier tétracorde trouvé est formé de quatre potes conjoints (), cette formation a un synonyme clustérien appelé « Cluster ».
Et quoi de plus simple que le dédoublement clustérien, obtenant un clone clustérien dont l’effet est bien échelonné.
1234
(.1278.)
5678
812345678
La programmation offre le moyen de développer un traitement codé…

Ligne 119 | # Charge limite tétra
Le cluster tétra trouvé est élémentaire, il ne comporte pas de poignée compréhensive sur laquelle s’appuyer ni déplacer. Mais on connait son taux de repli équivalant tétracordique (4), et sa capacité d’extension calculée en rapport chromatique-(12) diatonique-(7) octave-(2) cluster-(2). Les intervalles ne sont pas cités, ne sont pas existants, puis 5 intervalles + 7 notes = 1 2 34 5 6 7.
En sachant que l’élément tonique du tétracorde-(1) ne change pas de place, il a toujours la valeur 1.
# Opération Dico(mixam)
mixam = {} # Dépendances Degré(min/max)
""" Niveau T2 | MINI=1 MIDI=NULL MAXI=6 """
""" Niveau T3 | MINI=2 MIDI=T2+1 MAXI=7 """
""" Niveau T4 | MINI=3 MIDI=T3+1 MAXI=8 """
De Ligne 33 À Ligne 37

Ligne 125 | # Développement tétracordique
Cette fonction est séparée en deux parts ;
L’algorithme des membres tétracordiques :
Selon les estimations minima/maxima les tétras (T1, T2, T3, T4)
La priorité du cycle T4 de 3 à 8, étendu de six clusters :
1234|12304|…|123000004
L’incrémentation du T4 est prioritaire jusqu’à son maxima. En fin de boucle, l’algo incrémente le tétra voisin inférieur une seul fois.
Exemple du débutant :
1230004__ Tétracorde n°4
12300004_ Tétracorde n°5
123000004 Tétracorde n°6
12034____ Tétracorde n°7
120304___ Tétracorde n°8
La mise en forme des membres tétras :
La formation clustérienne lorsque les éléments T1, T2, T3, T4 se sont synchronisés, vient rendre visible les différentes positions diatoniques En remplaçant les intervalles par des zéros.

Ligne 80 | # Fonction format diatonique tétracordique
Cette fonction traite le premier cluster trouvé formé des chiffres de 1 à 4, ou bien C, D, E, F, et de zéros et intervalles. Ce tétra n’a pas encore ces valeurs 5, 6, 7, 8 nécessaires pour former la gamme idéale.
Alors elle prend le n°1 pour en faire le n°5. Ainsi quand elle traite le cluster n°1 1234, il en ressort 5678. En s’arrangeant pour garder le 1 à la tonique et le 8 à l’octave. Ce qui a comme résultat fictif ; 1234000005678.
En ce qui concerne la tonalité (#, b), soit l’apport altératif des notes. De cette fonction abouti un ensemble tétra entier, toujours de 1 à 4 pour des tonalités allant de 1 à 4 et de 5 à 8. Lignes 114-115 | tabas, tahau.

Ligne 45 | # Fonction couplage tétracordique
Une liste de tétras utiles a été tablée. Ligne 116 | tablT. Et la notion du format naturel de la gamme vue ci-dessus avec le positionnement de deux tétras, ou alors il s’agit d’un couplage premier clustérien.



La programmation continue avec la définition des gammes fondamentales prochainement.