some changes

Author: fxdole

book/14-b-methods-of-writing-csound-scores.md

@@ -184,6 +184,7 @@ written:
 
 To test this, first save this file as _print.py_ in the same folder
 where your .csd examples are:
+
 ```python
 
 from sys import argv
@@ -219,7 +220,7 @@ And again a complaint about the invalid score file:
 
 To get rid of the complaints we must write the score file. This is a simple example, saved as _test.py_:
 
-``` python
+```python
 from sys import argv
 print("Script = '%s'" % argv[0])
 print("File to read = '%s'" % argv[1])
@@ -230,7 +231,7 @@ with open(argv[2], 'w') as out:
 
 Which is called in this Csound file:
 
-``` csound-csd 
+```csound-csd
 <CsoundSynthesizer>
 <CsInstruments>
 instr 1

book/15-e-GS-fr-01.md

@@ -1,6 +1,7 @@
 # 01 Bonjour Csound
 
 ## Ce que vous apprendrez dans ce tutoriel
+
 - Comment créer et émettre un son sinusoïdal
 - Que sont les **opcodes** dans Csound
 - Quelle est la signification de l’**audio rate / fréquence d’échantillonnage** dans Csound
@@ -9,22 +10,24 @@
 - Qu’est-ce qu’une **partition/score** Csound
 
 ## Qu’est-ce qu’un oscillateur sinusoïdal / sine oscillator
+
 Une onde sinusoïdale peut être considérée comme l’élément sonore le plus élémentaire au monde. Quand nous dessinons une onde sinusoïdale comme un graphique montrant son amplitude au cours du temps, elle ressemble à ça :
 
 ![Onde sinusoïdale serpent](../resources/images/01-GS-01-sine.png)
 
-
-
 Pour produire une onde sinusoïdale, Csound utilise un oscillateur. Un oscillateur nécessite certaines entrées pour fonctionner :
+
 1. Une amplitude maximum de sortie. Ce qui résultera en un son plus ou moins fort.
 2. Le nombre de périodes (cycles) par seconde à générer. Ce qui résultera en un son plus ou moins aigüe ou grave. L’unité est le _Hertz(Hz)_. 1000 Hz signifie qu’une sinusoïde comporte 1000 périodes par seconde.
 
 ## Un oscillateur sinusoïdal dans Csound : Opcode et Arguments
+
 Csound dispose de nombreux oscillateurs différents. (vous pouvez trouver [ici](https://flossmanual.csound.com/how-to/opcodes) quelques descriptions et comparaisons.) Dans cet exemple, nous utilisons l’opcode `poscil`, qui signifie _precise oscillator_.
 
 Un **opcode** est une unité de traitement dans Csound, comparable à un _object_ dans PureData ou Max, ou un _UGen_ dans SuperCollider. Si vous êtes familier des langages de programmation, vous pouvez considérer un opcode comme une _building fonction / fonction intégrée_.
 
 Les entrées d’un opcode sont appelées **arguments** et sont écrites entre parenthèses immédiatement après le nom de l’opcode. Donc `poscil(0.2,400)` signifie : L’opcode `poscil` prend deux arguments en entrée :
+
 - Le premier argument est le nombre `0.2`.
 - Le second argument est le nombre `400`.
 
@@ -34,7 +37,8 @@ Cette manière d’écrire du code est commune à de nombreux langages de progra
 Note : Il existe une autre manière d’écrire du code Csound. Si vous voulez en apprendre plus sur ce sujet, voyez la section "Deux façons d’écrire du code dans Csound" à la fin de ce tutoriel.
 
 ## Le flux d’un signal et son code
-Nous créons maintenant une onde sinusoïdale d’une amplitude de 0.2 et de 400 cycles par seconde (Hz).  
+
+Nous créons maintenant une onde sinusoïdale d’une amplitude de 0.2 et de 400 cycles par seconde (Hz).
 Nous nommerons ce signal _aSine_ car il s’agit d’un signal **a**udio. Le caractère **a** au début du nom de la variable signifie exactement ça.
 
 Un signal audio est un signal qui produit une nouvelle valeur à chaque sample/échantillon. (Apprenez-en davantage [ici](https://flossmanual.csound.com/basics/digital-audio) sur les samples et les _sample rates / taux d’échantillonnage_).
@@ -46,6 +50,7 @@ aSine = poscil:a(0.2,400)
 Cela signifie : Le signal _aSine_ est créé par l’opcode `poscil` au taux audio / audio rate (`:a`), et les entrées pour `poscil` sont 0.2 pour l’amplitude, et 400 pour la fréquence.
 
 Pour sortir le signal (pour que nous puissions l’entendre), nous introduisons l’opcode `outall`. Cet opcode envoie un signal audio à tous les canaux de sortie disponibles.
+
 ```
 outall(aSine)
 ```
@@ -54,7 +59,7 @@ Notez que le signal _aSine_ est d’abord la sortie de l’oscillateur, puis dev
 
 Nous pouvons dessiner le flux de ce programme comme ceci :
 
-![Flux de signal et code Csound pour un oscillateur sinusoïdal et une sortie.](../resources/images/01-GS-01-a.png){width=80%}  
+![Flux de signal et code Csound pour un oscillateur sinusoïdal et une sortie.](../resources/images/01-GS-01-a.png){width=80%}
 
 Au milieu, vous voyez le flux du signal, avec des symbols pour l’oscillateur et la sortie. Vous pouvez les imaginer comme les modules d’un synthétiseur, connectés par un cable nommé _aSine_.
 
@@ -63,11 +68,14 @@ Sur le côté gauche, vous voyez la chaine entre les entrées, l’opcode et la
 À droite, vous voyez le code Csound correspondant. Chaque ligne de code représente une chaine _entrée -> opcode -> sortie_, dans la forme _sortie = opcode(entrée)_. La ligne `outall(aSine)` n’a pas de sortie vers Csound, car elle envoie l’audio au matériel (comme l’objet `dac~` dans PD ou Max).
 
 ## Votre premier instrument Csound
+
 Dans Csound, tous les oscillateurs, filtres, lecteurs d’échantillons / sample players, et autres unités de traitement sont encapsulés dans un **instrument**. Un instrument comporte les mots-clé :
+
 - `instr` à son début
 - et `endin` à sa fin.
 
 Après le mot-clé `instr`, séparé par un espace, nous assignons un nombre (1, 2, 3, …) ou un nom à l’instrument. Nommons notre instrument "Hello", et tapons le code que nous venons de discuter :
+
 ```
 instr Hello
     aSine = poscil:a(0.2,400)
@@ -76,6 +84,7 @@ endin
 ```
 
 ### Exemple
+
 Nous somme maintenant prêt à exécuter notre code. Tout ce qui nous reste à faire est d’inclure le code de notre instrument dans un fichier Csound complet.
 
 Regardez le code de l’exemple. Pouvez-vous repérer le code de l’instrument ?
@@ -107,18 +116,23 @@ i "Bonjour" 0 2
 </CsScore>
 </CsoundSynthesizer>
 ```
+
 #### La partition / score Csound
 
 En bas de notre exemple de code, vous voyez ceci :
+
 ```
 <CsScore>
 i "Bonjour" 0 2
 </CsScore>
 ```
+
 C’est la section **Partition / Score** du fichier .csd. Elle commence par la balise \<CsScore> et se termine par la balise \</CsScore>. Entre ces deux balises, il y a cette ligne de partition :
+
 ```
 i "Bonjour" 0 2
 ```
+
 Chaque colonne (champ de paramètre / parameter field) spécifie une certaine information :
 
 - `"Bonjour"` : L’instrument auquel cette ligne de partition se réfère.
@@ -142,16 +156,20 @@ Chaque colonne (champ de paramètre / parameter field) spécifie une certaine in
 ## Opcodes, Mots-Clés et termes que vous avez appris dans ce tutoriel
 
 ### Opcodes
+
 - `poscil:a(Amplitude,Frequence)` : oscillateur au taux audio, avec entrées d’amplitude et de fréquence.
 - `outall(aSignal)` : envoie _aSignal_ vers les canaux de sortie physiques.
 
 ### Mots-clés
+
 - `instr ... endin` sont les mots-clés qui commencent et finissent une définition d’instrument.
 
 ### Termes
+
 - Un signal à la _fréquence audio / audio rate_ ou _a-rate_ est mis à jour à chaque sample/échantillon.
 
 ## Avançons…
+
 Avec le tutoriel suivant : [02_Bonjour Fréquences](15-f-GS-fr-02.md)
 
 ## Ou lisez quelques informations supplémentaires ici
@@ -175,33 +193,45 @@ Bien que la réalité sonore soit un peu plus complexe, cela montre que les onde
 Vous trouverez plus d'informations à ce sujet dans le chapitre [Synthèse additive](https://flossmanual.csound.com/sound-synthesis/additive-synthesis) et dans le chapitre [Résynthèse spectrale](https://flossmanual.csound.com/sound-modification/fourier-analysis-spectral-processing) de ce livre.
 
 ### Deux façons d’écrire du code dans Csound : la façon Traditionnelle, et la façon fonctionnelle
+
 Vous êtes peut-être surpris de voir le code Csound écrit de la façon décrite ci-dessus. En fait, la façon classique d’écrire du code Csound ressemble à ceci :
+
 ```
 aSine poscil 0.2, 400
     outall aSine
 ```
+
 Vous pouvez sans problème continuer d’écrire le code Csound ainsi. Les raisons pour lesquelles j’utilise l’écriture fonctionnelle dans ce tutoriel sont :
+
 1. Nous sommes tous familiarisés avec cette manière de déclarer une variable `y` à gauche comme étant la somme d’une autre variable `x` plus deux : `y = x + 2`.
 2. Comme mentionné plus haut, la plupart des langages de programmation utilisent une syntaxe similaire, dans la forme `sortie = fonction(arguments)`. Donc pour les personnes ayant quelques connaissances en programmation, c’est une aide à l’apprentissage de Csound.
 3. Le style fonctionnel d’écrire du code Csound a toujours existé dans des expressions comme `ampdb(-10)` ou `ftlen(giTable)`. Ce n’est donc pas totalement nouveau, mais plutôt une extension.
 4. Chaque fois que nous voulons utiliser une expression comme argument (vous en apprendrez plus à ce sujet dans le [tutoriel 6](15-j-GS-fr-06.md)), nous devons écrire le code de cette manière. Il est donc bon de l’utiliser en permanence pour plus de cohérence.
 
+<<<<<<< HEAD
 NOTE DU TRADUCTEUR pour les francophones : Sauf dans les commentaires où ça ne pose aucun problème, n’utilisez que des caractères ASCII dans vos programmes.
 J’ai essayé et chez moi ça plante. Donc pas de lettres accentuées, pas de œ et autres signes propres au français.
+=======
+   NOTE DU TRADUCTEUR pour les francophones : Sauf dans les commentaires où ça ne pose aucun
+   problème, n’utilisez que des caractères ASCII dans vos programmes. J’ai essayé et chez moi ça plante. Donc pas de lettres accentuées, pas de œ et autres signes propres au français.
+>>>>>>> c9576890a19c871cb299cf2796c5d68c80ef27f0
 
 ## Au sujet de ces tutoriels
+
 Ce _Guide de démarrage_ a été écrit par Joachim Heintz en 2023. Il est basé sur de nombreuses expériences d’enseignement de Csound auprès de jeunes compositeurs.
 
 J’espère que ce tutoriel permettra à davantage de musiciens de réaliser à quel point il était et reste admirable et fructueux de transformer le plus ancien langage de programmation audio en un langage moderne, sans perdre aucune composition réalisée avec Csound, même écrite il y a de nombreuses années.
 
 Chaque tutoriel comporte une première partie à lire _impérativement_, suivie d’une partie facultative (dans laquelle se trouvent bien sûr les choses les plus intéressantes). Pour que quelque chose au moins dans ce monde soit stable, chaque partie à lire _impérativement_ comporte cinq rubriques, et chaque partie à lire _facultativement_ en comporte trois. En fait, j’avais prévu 4+3, mais j’ai demandé à Csound qui m’a répondu :
+
 ```
 if 4+3 == 7 then
     "Écrivez ce Tutoriel!\n"
 else
     8!
 endif
 ```
+
 J’ai pris cela comme une révélation et j’ai opté pour 5+3 entêtes, afin de satisfaire également l’exigence `8!`. D’après mon expérience, il vaut toujours mieux satisfaire les deux dieux d’une branche conditionnelle.
 
 Les parties "À lire absolument" comprennent également une section "À faire absolument". Tout d’abord un exemple central, oui très central, substantiel, opportun, agréable et bien sûr très instructif. Puis une section "Essayez vous-même" qui représente en quelque sorte le revers de la médaille : Autant il est facile d’appuyer sur le bouton "Exécuter/Run", autant il sera peut-être difficile de résoudre ces maudits exercices. Mais, pour citer John Ffitch : "Nous sommes tous passés par là…".

book/15-f-GS-fr-02.md

@@ -9,9 +9,9 @@
 
 - Comment un **document .csd** Csound est structuré :
 
-    - Que sont les **CsOptions** et
+  - Que sont les **CsOptions** et
 
-    - Qu’est-ce que la section **CsInstruments** ou **orchestra**.
+  - Qu’est-ce que la section **CsInstruments** ou **orchestra**.
 
 ## Une ligne pour la fréquence
 
@@ -27,21 +27,36 @@ Le cas le plus simple de ce genre de mouvement est une ligne. Nous avons besoin
 
 Voici une ligne qui se déplace de 500 à 400 en 0.5 secondes, et qui reste à 400 pendant 1.5 secondes :
 
-![Ligne de fréquence.](../resources/images/01-GS-02-a.png)  
+![Ligne de fréquence.](../resources/images/01-GS-02-a.png)
 
+    Note : Acoustiquement, cette façon d’appliquer un _glissando_ est discutable.
+    Nous en parlerons dans le [Tutoriel 05](15-i-GS-fr-05.md).
 
+<<<<<<< HEAD
 Note : Acoustiquement, cette façon d’appliquer un _glissando_ est discutable. Nous en parlerons dans le [Tutoriel 05](15-i-GS-fr-05.md).
 
 Note 2 : Ne devrions-nous pas dire : "Voici une ligne qui se déplace depuis 500 Hz jusqu’à 400 Hz, en 0.5 secondes", plutôt que "Voici une ligne qui se déplace depuis 500 jusqu’à 400 en 0.5 secondes" ? Non. La ligne produit des nombres. Ces nombres peuvent être utilisés pour des fréquences, mais peuvent avoir une signification différente dans un autre contexte.
+=======
+    Note 2 : Ne devrions-nous pas dire : "Voici une ligne qui se déplace
+    depuis 500 Hz jusqu'à 400 Hz,
+    en 0.5 secondes",
+    plutôt que "Voici une ligne qui se déplace depuis 500 jusqu'à 400
+    en 05 secondes" ?
+    Non. La ligne produit des nombres. Ces nombres peuvent être utilisés
+    pour des fréquences,
+    mais peuvent avoir une signification différente dans un autre contexte.
+>>>>>>> c9576890a19c871cb299cf2796c5d68c80ef27f0
 
 ## Une ligne Dessinée avec l’opcode 'linseg'
 
 Dans Csound, nous créons ce genre de ligne avec l’opcode `linseg`, qui signifie "linear segments / segments linéaires". Ici, nous n’avons besoin que d’un seul segment qui se déplace de 500 à 400 en 0.5 secondes.
 
 Voici le code Csound pour ce mouvement linéaire :
+
 ```
 kFreq = linseg:k(500, 0.5, 400)
 ```
+
 ## Signal k-rate (à la fréquence de contrôle)
 
 Un signal est quelque chose dont les valeurs changent au cours du temps. Mais qu’est-ce que le temps dans une application audio comme Csound ?
@@ -50,14 +65,14 @@ Le temps fondamental est donné par la **sample rate / fréquence d’échantill
 
 La seconde résolution temporelle possible dans Csound est moins fine. Elle ne calcule pas une nouvelle valeur à chaque échantillon, mais seulement par **groupe d’échantillons**. Cette résolution temporelle est appelée **control rate / fréquence de contrôle**.
 
-![audio rate vs control rate](../resources/images/01-GS-02-b.png)  
-
+![audio rate vs control rate](../resources/images/01-GS-02-b.png)
 
 Les variable Csound qui comportent un **k** comme premier caractère, utilisent la fréquence de contrôle / control rate. Leurs valeurs sont mises à jour à la fréquence de contrôle. C’est la raison pour laquelle nous écrivons _**k**Freq_.
 
 Après l’opcode, avant la parenthèse, nous plaçons `:k` pour signifier que cet opcode utilise la fréquence de contrôle comme résolution temporelle.
 
 Je recommande toujours d’utiliser **k** ou **a** aux deux positions :
+
 - À gauche de la variable, et aussi
 - à droite, juste après le opcode.
 
@@ -70,7 +85,7 @@ Vous en apprendre plus sur _k-rate_ dans le prochain tutoriel.
 
 ## Exemple
 
-Appuyez sur le bouton "Play". Vous entendrez un son dont la hauteur descend.  
+Appuyez sur le bouton "Play". Vous entendrez un son dont la hauteur descend.
 Pouvez-vous voir comment la ligne mobile est introduite dans l’oscillateur ?
 
 ```
@@ -102,7 +117,7 @@ i "Bonjour" 0 2
 
 Si vous examinez le code de notre instrument, vous constaterez qu’il existe un schéma commun :
 
-![Input output insertions](../resources/images/01-GS-02-c.png)  
+![Input output insertions](../resources/images/01-GS-02-c.png)
 
 - La première ligne produit un signal et le stocke dans la variable _kFreq_. Cette variable est ensuite utilisée comme entrée dans la seconde ligne.
 
@@ -123,6 +138,7 @@ Comme vous pouvez le voir, ces trois paires de balises sont englobées entre une
 ```
 <CsoundSynthesizer>...</CsoundSynthesizer>
 ```
+
 Cette dernière paire de balises définit les limites d’écriture pour le programme Csound. En d’autre termes : Ce que nous écrivons hors de ces limites est ignoré par Csound.
 
 ## Essayez-le vous-même
@@ -179,7 +195,7 @@ endin
 
 Si vous exécutez ce code, vous entendrez que `line` comporte une importante différence par rapport à `linseg` : il ne s’arrête pas à la valeur-cible, mais continue son mouvement :
 
-![line vs linseg](../resources/images/01-GS-02-d.png)  
+![line vs linseg](../resources/images/01-GS-02-d.png)
 
 Les cas d’utilisation de `line` ne sont pas courants. Je recommande donc toujours d’utiliser `linseg`, sauf exception.
 
@@ -251,7 +267,6 @@ aSine = poscil:a(0.2,aFreq)
 outall(aSine)
 ```
 
-
 Un simple avis :
 
 - Utilisez toujours _a-rate_ quand ça améliore le son.