Fran et Jim
Fran Lejeune et
Jean-Michel Rolland
JEAN-MICHEL ROLLAND
Art Numérique - Digital Art

HOME

FRAN

JIM



DISOBEDIENCE
MUSIQUE GENERATIVE / GENERATIVE MUSIC

Existe en application pour Android (smartphones, tablettes et TV) sur : Google Play.





Diffusions :
o 07-08/2017 : FILE Hypersonica, Sao Paulo (Brésil)
Screenings :
o 07-08/2017 : FILE Hypersonica, Sao Paulo (Brazil)
GENESE

Suite à mes différentes expériences en Vjing interactif et en art génératif, je me lance dans la conception d’un travail de musique générative (ou de musique procédurale) avec Processing. Le principe est le suivant : dans un cadre que je lui aurai fourni, l’ordinateur décidera quelles notes jouer à quel moment. Je sais déjà que la principale difficulté sera de laisser assez de marge au hasard sans que le résultat soit trop anarchique. Parce que je suis un artiste plasticien autant qu’un musicien, je créerai des visuels en interaction avec le son.

Je commence par une première expérimentation très libre dans laquelle toutes les fréquences comprises entre 110 et 440 hertz sont disponibles. Les notes sont calculées par groupes de trois. Je demande à l’ordinateur, plutôt que d’utiliser une fonction "random" qui génère une valeur complètement au hasard, d’effectuer ses calculs avec la fonction "noise", algorithme appelé bruit de Perlin généralement utilisé pour créer des textures visuelles complexes. Cette fonction renvoie des valeurs comprises entre 0 et 1 qui ont l’air d’être choisies au hasard mais qui obéissent cependant à une logique mathématique.

Voici la ligne de code qui génère les notes :
GENESIS

Following my different experiences in interactive Vjing and generative art, I'm starting a new generative music (or procedural music) project with processing. Here's the basic principle : in a framework I will have provided, the computer will decide which notes to play at the right moment. I already know the main difficulty will be to let enough randomness without getting a too anarchic result. Because I'm a musician as well as a visual artist, I will create visuals interacting with the sound.

I'm beginning with a very free first experiment in which all the frequencies included between 110 and 440 hertz are available. The notes are calculated by groups of three. I'm asking the computer, rather than a "random" function that generates completely random values, to use the "noise" algorithm, also called Perlin noise and generally used to create complex visual textures. This function returns values between 0 and 1 that seem to be chosen randomly but that however obey to a nathematical logic.

Here's the line of code that generates the notes :
note[i] = 110 + noise(note[i])*330;

DISOBEDIENCE / PREPARATORY WORK #1


En entendant cette expérimentation, je m’aperçois que règne un grand désordre. La cause en est principalement l’utilisation de la totalité des fréquences comprises entre 110 hertz (LA1 - ou LA de la première octave) et 440 hertz (LA3 - ou LA de la troisième octave). En musique occidentale, on utilise pour les instrumentés frettés la gamme tempérée qui comporte douze demi-tons. Pour augmenter une note x0 de n demi-tons, il faut appliquer la formule suivante :
f(xn) = x0 * 2n/12. Par exemple, pour obtenir un DO2 à partir d’un LA1, on calcule : note = 110 * 23/12 ou note = 110 * 1,1892 = 130,812 hertz. Dans Processing, voici ce que cela donne, cette fois-ci en utilisant la fonction "random" :
Listening to this experiment, I realize it's a big disorder. The cause of it is mainly that every frequencies between 110 (A1 - or A in the first octave) and 440 (A3 - or A in the third octave) hertz are used. In occidental music, we used for fretted instruments the well-tempered scale that has twelve half-tones. To raise the pitch of a note x0 by a half-tone, one has to apply the following formula :
f(xn) = x0 * 2n/12. For example, to get C2 from a A1, we calculate : note = 110 * 23/12 or note = 110 * 1,1892 = 130,812 hertz. In Processing, here's the result, this time with a "random" function :
float facteur = int(random(-13, 13)) /12.0;
note[i] = note[i] * pow(2, facteur);

DISOBEDIENCE / PREPARATORY WORK #2


J’essaie, à seules fins d’expérimentations, de restreindre le nombre des notes jouées en ne laissant la possibilité à l’ordinateur de ne choisir qu’une note sur trois (LA, DO, MIb, FA#). I'm now trying, only in an experimental goal, to limit the number of played notes by letting the computer chosing only one note out of three (A, C, Eb, F#).
int valeur = int(random(5))*3;
float facteur = valeur/12.0;
note[i] = note[i] * pow(2, facteur);

DISOBEDIENCE / PREPARATORY WORK #3


Il me semble à présent intéressant de creuser du côté de la segmentation de l’octave en douze demi-tons. Cette règle peut-elle être brisée ? Peut-on imaginer une octave dans laquelle on ferait rentrer plus de douze notes ? Notre oreille, accoutumée à la musique occidentale depuis notre gestation, pourra-t-elle trouver harmonieuse une musique à ce point irrespectueuse ?
J'essaie de faire rentrer 16 notes dans une octave :
It seems interesting now to look at the segementation of the octave in twelve half-tones. Can this rule be broken ? Can we imagine an octave in which we would play more than twelve notes ? Can our ear, accustomed to occidental music since our gestation, find harmony in a so disrepectful music?
I try to play 16 notes in an octave:
float facteur = int(random(-17, 17))/16.0;
note[i] = note[i] * pow(2, facteur);
La gamme qui en résulte comporte avec 4 notes connues (La, Do, Mib et Fa#) et 12 nouvelles notes inconnues.

The resulting range has 4 known notes (A, C, Eb and F#) and 12 new unknown notes.

DISOBEDIENCE / PREPARATORY WORK #4


J’essaie maintenant une octave composée de neuf notes dans laquelle seront présents le La, le Do# et le Fa, plus 6 notes inconnues, en réintroduisant par la même occasion la fonction "noise" : I'm now trying an octave with nine notes in which we'll have the A, the C# and the F, plus 6 unknown notes, reintroducing by the way the "noise" function :
float facteur = int(map(noise(note[i]), 0, 1, -9, 9))/9.0;
note[i] = note[i] * pow(2, facteur);

DISOBEDIENCE / PREPARATORY WORK #5


Afin de pouvoir détecter la meilleure solution possible quant au fractionnement de l’octave, je crée une variable que j’appelle "fractions" et j’implémente une commande qui me permettra d’en changer la valeur avec les touches "+" et "-" de mon clavier d’ordinateur : To be able to chose the best octave segmentation, I create a new variable that I call "fractions" and I add a line of code that will allow me to change the value of "fractions" with the "+" and "-" keys of my computer keyboard :
facteur[i] = int(map(noise(note[i]), 0, 1, -fractions, fractions))/fractions;
note[i] = note[i] * pow(2, facteur[i]);
Lors du lancement du programme, une seule note est possible (fractions=1) et je vais pouvoir passer en revue toutes les combinaisons possibles en augmentant au fur et à mesure le nombre de fréquences possibles par octave. Faute de temps, je m’arrêterai à 53 notes par octave...

When I start, only one note is possible (fractions=1) and I will go through all possible combinations by increasing one by one the number of possible frequencies in an octave until I reach 53 notes per octave...

DISOBEDIENCE / PREPARATORY WORK #6


Il est loin d’être facile de trouver de l’harmonie en dehors des sentiers (re)battus... J’ai cependant été intéressé par la fragmentation en 31 notes. J’essaie cette combinaison pour voir si elle tient ses promesses sur la durée : It's quite difficult to find harmony outside the box... I've been however intersted in the 31 notes segmentation. I'm trying this combination to see if it's worth on a long time :
facteur[i] = int(map(noise(note[i]), 0, 1, -31, 31))/31;
note[i] = note[i] * pow(2, facteur[i]);

DISOBEDIENCE / PREPARATORY WORK #7


Cette musique me plaît mais je pense que je serai le seul à l’apprécier... J’en reviens donc à notre bonne vieille gamme tempérée pour produire une musique générative écoutable par à peu près tout le monde. En expérimentant, je trouve que, pour le choix des notes, la fonction sin() qui renvoie le sinus d’une valeur donne quelque chose de beaucoup plus intéressant. Voici mon nouveau code : I like this music but I think I'll be the only one to appreciate it... So I get back to our good old well-tempered scale to produce a generative music that can be listenable by almost everyone. While experimenting, I find that the sin() function (calculates the sinus of a value) returns more interesting sounds for chosing the notes. Here's my new code :
facteur[i] = int(map(sin(map(note[i], 0, 440, 0, TWO_PI)), -1, 1, -12, 12))/12;
note[i] = note[i] * pow(2, facteur[i]);

DISOBEDIENCE / PREPARATORY WORK #8


Ces deux lignes de code peuvent être simplifiées de la façon suivante : These two lines can be simplified this way :
note[i] = note[i] * pow(2.0, round(sin((note[i] / 440.0) * TWO_PI)*12)/12.0);
Je souhaite à présent, tout en conservant la fonction sin() pour le calcul des notes, modifier l’échelle de grandeur de cette fonction. Je crée une variable que j’appelle "ecart" et je l’inclue dans mon algorithme : Now, keeping the sin() function to calculate notes, I wish to modify its scale. I create a variable I call "ecart" and I include it in my algorithm :
note[i] = note[i] * pow(2.0, round(sin((note[i] / 440.0) * TWO_PI)*ecart)/12.0);
Je partirai avec un "ecart" de 6 et l’augmenterai de 1 unité toutes les 30 secondes. Les notes qui résulteront feront toujours partie de la gamme tempérée, c’est uniquement la méthode de calcul qui sera modifiée. I will begin with an "ecart" of 6 and will increase it one by one every 30 sconds. The resulting notes will still be in the well-tempered scale, it's just the calculation method that changes.
DISOBEDIENCE / PREPARATORY WORK #9


Le choix n’est pas simple mais j’opte pour un écart de 18. Avec ce calcul :
La1 devient Mib3
Lab1 devient Mi3
Si1 et Do2 deviennent Fa3
Do#2 et Ré2 deviennent Fa#3
Mib2 et Mi2 deviennent Fa3
Fa2 devient Mi3
Fa#2 devient Mib3
Sol2 devient Do#3
Lab2 devient Si2
La2 reste La2
Sib2 devient Sol2
Si2 devient Mi2
Do3 devient Ré2
Do#3 devient Do2
Ré3, Mib3 et Mi3 deviennent Sib1
Fa3 devient Do2
Fa#3 dvient Mib2
Sol3 devient Lab2
Lab3 devient Ré3
La3 reste La3

Remarques : les trois notes de départ, celles qui vont donner sa particularité à la composition, sont décidées par l’ordinateur par cette itération appelée une seule fois au lancement du programme :
The choice is not easy but I will keep an range of 18. With this method :
A1 becomes Eb3
Ab1 becomes E3
B1 et C2 become F3
C#2 et D2 become F#3
Eb2 et E2 become F3
F2 becomes E3
F#2 becomes Eb3
G2 becomes C#3
Ab2 becomes B2
A2 remains A2
Bb2 becomes G2
B2 becomes E2
C3 becomes D2
C#3 becomes C2
D3, Eb3 et E3 become Bb1
F3 becomes C2
F#3 dvient Eb2
G3 becomes Ab2
Ab3 becomes D3
A3 remains A3

Comment : the three very first notes, which are going to give the composition its particularity, are decided by the computer in this iteration called only once at the beginning of the process :
for (int i=0; i<3; i++) {
facteur[i] = int(random(-13, 13))/12;
note[i] = 110 * pow(2, facteur[i]*2); }
DISOBENDIENCE


Il y a donc 24*24*24 = 13 824 possibilités, et autant de "partitions" possibles. La vidéo que je produis dure 10 minutes mais le programme une fois lancé peut durer une éternité sans jamais se répéter. Cela fait de la musique générative pour 13 824 éternités...

Je me permets de passer de nombreux détails sous silence pour ne pas alourdir la rédaction de cet essai. Un point important que je n’ai pas abordé est par exemple la durée des notes et l’intervalle de temps entre elles... Si vous avez des questions sur ce travail, vous pouvez me les poser à jim.rolland@free.fr
So there are 24*24*24 = 13 824 possibilities, and as many possible "music sheets". The video I produce lasts 10 minutes but once the process started, it can last an eternity without never repeating itself. It makes generative music for 13 824 eternities...

I take the freedom not to give many details in order to avoid making this writing too cumbersome. An important point I haven't talked about is for example the duration of notes and the time interval between them... If you have any question about this piece of work, you can ask them to jim.rolland@free.fr