kramann.info
© Guido Kramann

HelloAOG -- Workshop zu Arithmetic Operation Grammar (Deutsche Version)

(EN google-translate)

(PL google-translate)

english version, see:

90_AOGdogma/09_HelloAOG

Sketch für den Workshop am 03.06.2024:

HelloAOG2024.zip

Arithmetic Operation Grammar (AOG) ist als Kompositionsmethode jenseits der ausgetretenen Pfade klassischer Theorie, aber auch jenseits etablierter neuer Strömungen konzipiert worden [1],[2].

Damit kann diese Methode Laien einen alternativen Zugang zum Komponieren geben. Einen einfachen Zugang zum Komponieren auch für Laien zu gewährleisten, ist wiederum unter anderem auch Ziel der Bewegung Ubiquitous Music, weshalb es bereits einige Beiträge mit AOG auf dem jährlichen Symposium zu Ubiquitous Music gegeben hat [3],[4],[5].

Nun stellt sich die Frage, wie man eine solch abseitige Technik didaktisch sinnvoll vermitteln kann, die sich an keine der etablierten Strukturen anlehnt. Der vorliegende Workshop nimmt als Ausgangspunkt das Programmieren in Java/Processing. Strukturen von AOG werden zunächst als Java-Code vorgestellt und danach in kompakterer Weise durch die Sprachmittel von AOG ersetzt. Das Bekannte, aus dem heraus das Neue entwickelt wird, ist also keine musikalische Theorie, sondern eine Programmiersprache. Dies ist aufgrund der besonderen Eigenheiten von AOG machbar, die im folgenden kurz vorgestellt werden:

Arithmetic Operation Grammar (AOG) ist eine generative symbolische Sprache zum Erzeugen musikalischer Strukturen.
Die zeitliche Abfolge der Natürlichen Zahlen beginnend bei Null, bildet hierbei den Ausgangspunkt.
Variierende Zahlenfolgen werden durch Anwendung arithmetischer Operationen auf diese zeitliche Abfolge gebildet.
Bei jeder auftretenden Zahl werden nur die darin enthaltenen Primfaktoren 2,3,5 und 7 jeweils bis zu einer begrenzten Anzahl herausgenommen und deren Produkt als Frequenz interpretiert, um dann beispielsweise den nächstgelegenen Miditon als Ton anzuspielen.
Ein gewisser Anteil der Zahlen liefert demzufolge keinen spielbaren Ton. Rhythmus und Tonhöhe sind hier somit so eng miteinander verzahnt, dass sie nicht getrennt voneinander behandelt werden können.
Dieser Nachteil wird aus der Überzeugung heraus in Kauf genommen, dass die Folge der Natürlichen Zahlen und auch die sich aus ihr mittels der Operationen ergebenden Transformationen bereits eine Struktur aufweist, die in gewissem Sinne musikalisch genannt werden kann.
Um diesen Nachteil etwas auszugleichen, wird AOG typischerweise mittels Softwarewerkzeugen umgesetzt, die ein unmittelbares klangliches Feedback zu den aktuell eingegebenen Symbolfolgen geben.
Mehrstimmigkeit wird gewonnen, indem ähnliche, aber nicht ganz identische Abfolgen von Operationen auf die Folge der natürlichen Zahlen parallel ausgeführt werden.
Die auftretenden Frequenzen müssen nicht notwendigerweise auf die Frequenz des jeweils nächsten Miditones gerundet werden. Die Frequenzen können auch unverändert genommen werden, sie können mit einem konstanten Faktor versehen werden, oder/und auf eine andere EMO-Skala mit logarithmisch gleich verteilten Tonhöhen übertreagen werden. Somit ist Mikrotonalität in natürlicher Weise möglich.

Literatur

[1] Kramann, G.: Generative Grammar Based on Arithmetic Operations for Realtime Composition. CMMR 2019, pp. 346--360.

[2] This is a preprint of "Composing by Laypeople: A Broader Perspective Provided by Arithmetic Operation Grammar". The article is published in Computer Music Journal Volume 44, No. 1, Spring of 2021, published by The MIT Press.

[3] Kramann, G.: The Lifeworld Context in Comprovizational Tools for Laypeople - A Phenomenological Approach to Explain Ease-To-Learn Aspects in User Interfaces. Ubimus 2021, https://dei.fe.up.pt/ubimus

[4] Kramann, G.: Submission of some Music Pieces for UbiMus2022 with Special Consideration of the Respective Developed User Interface for the Respective Generation Software. Ubimus 2022, ubimus2022.unespar.edu.br

[5] Kramann, G.: AOGscript - Design of a Stand-Alone Scripting Language for the Generation of Music. Ubimus 2023, ulster.ac.uk/conference/ubimus

Warum kann man sagen, dass die Folge der natürlichen Zahlen eine musikalische Struktur hat?

Bild 0-1: Inner prime-factor-structure of natural numbers.

Bild 0-2: Inner prime-factor-structure of natural numbers2.

1. Getting Started

HelloAOG.zip -- Processing-Sketch, der nachfolgend verwendet wird, Version: HelloAOGdev021 27.05.2024.

Laden Sie die aktuelle Version von Processing für Ihr Betriebssystem herunter und installieren Sie sie (processing.org)
Suchen Sie Ihren Sketchordner (Linux: ~/sketchfolder, Windows: Ihr_home_Ordner/Processing) und entpacken Sie dort HelloAOG.zip
Starten Sie Processing und suchen Sie unter Datei -> Sketchbook -> HelloAOG
Starten Sie HelloAOG, indem Sie die Play-Taste drücken.

Wenn Sie den Sketch erfolgreich gestartet haben bekommen Sie folgendes zu sehen und zu hören:

Bild 0-3: Screenshot des laufenden Programms HelloAOG.

helloaog.mp4

helloaog.ogg

Der ganze Workshop ist so aufgebaut, dass es in der Regel reicht, im Haupttab des Sketches zu arbeiten. Die anderen Tabs brauchen Sie nicht zu beachten und sie werden hier auch nicht besprochen. Im Haupttab finden Sie vordefinierte Variablen und die setup()- und die draw()-Methode. Zunächst im konkreten Fall wären das die nachfolgend dargestellten Code-Zeilen:

//version: HelloAOGdev020_workshop_BASIS 27.05.2024
int NUMBER_OF_VOICES=1;//4;
//Try to vary if stuttering in sound appears:
int SAMPLE_RATE=11025; //8000 11025 22050 44100 48000
int BUFFER_SIZE=16; //16 32 64 128 256 512
public void setup()
{
    size(640,480);
    frameRate(2);
    configure();
}
public void draw()
{
    vis.draw();
    vis.step();
    
    A=2520/(T%7+2);  
    tone1.play(A,100);
    T++;
}

Code 0-1: HelloAOG

Erläuterungen:

Zunächst werden nur die letzten drei Zeilen der draw()-Methode betrachtet:

A=2520/(T%7+2);  
tone1.play(A,100);
T++;

Code 0-2: Letzte drei Zeilen der draw()-Methode.

2520=2*2*2*3*3*5*7
T%7+2 liefert für T=0,1,2,3,...: 2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,3,4,...
Für T=0,1,2,3,... ist dann A: 1260, 840, 630, 504, 420, 360, 315, 1260, 840,...
Fasst man diese sich zyklisch wiederholende Zahlenfolge als Frequenzen auf, so stehen die entsprechenden Tönen ein einfachen Frequenzverhältnissen zueinander.
tone1.play(A,100); ... spielt einen Ton mit der in der Variablen A gespeicherten Frequenz und der Lautstärke 100.
Die draw()-Methode wird zyklisch aufgerufen, wegen frameRate(2); zweimal pro Sekunde. Jedesmal wird durch T++ T um eins erhöht.

Mehr Erläuterungen:

Bei dem vorliegenden Beispiel werden die auftretenden mittels der Modulo-Division (Rest-Division, Operator % in Java und C++) Zahlen begrenzt.
Die Verwendung von 2520 als Zahl als Dividend gewährleistet, dass das Ergebnis Frequenzen im hörbaren Bereich entspricht.
Durch die Verwendung einer Zahl als Dividend, die nur kleine Primfaktoren enthält, wird sogleich ein wichtiges Prinzip bei AOG eingeführt: Die gespielten Frequenzen setzen sich nur aus kleinen Primfaktoren 2,3,5 und 7 zusammen, bzw. nur Zahlen, die dieser Bedingung genügen kommen als zu spielende Töne in Betracht.

Falls Ihr Computer den Sound nicht richtig darstellt, könnten Sie versuchen das Problem durch Änderung der Sample-Rate und der Puffergröße zu beheben, siehe Sketch. Eine andere Möglichkeit wäre, zu versuchen dem Java-Prozess eine höhere Priorität zu geben. Schließlich wäre auch möglich, ein externes Midi-Device anzusteuern, anstatt den Sound mit Java-Mitteln direkt zu erzeugen. Hierzu wäre folgendes nötig (nur dann):

Installieren Sie die Library "The MidiBus" von Severin Smith innerhalb von Processing (Online-Verbindung erforderlich): Sketch -> Import Library -> add Library -> The MidiBus.
Gehen Sie im Sketch HelloAOG auf den Tab MIDI und entfernen Sie die Auskommentierung ganz am Anfang /* und ganz am Ende */.
Passen Sie Zeile 9 in Tab CONFIGURE an: String NAME_MIDI_DEVICE="VirMIDI [hw:3,2,0]"; (Beim Start werden die Namen der Midi-Devices in dem Terminal angezeigt.)
Ersetzen Sie Zeile 18 im Hauptprogramm (Tab HelloAOG) durch piano.play(0,A,40); UND ZUSÄTZLICH piano.perform();
Wenn Ihr Midi-Device verfügbar ist, sollte es nun von HelloAOG aus angesteuert werden.
ALTERNATIV BEFINDET SICH NACHFOLGEND DER SKETCH HelloAOGmidi, BEI DEM DIE HIER GENANNTEN ANPASSUNGEN BEREITS VORGENOMMEN WURDEN:

HelloAOGmidi.zip -- MIDI VERSION von HelloAOG, Version: HelloAOGdev021 27.05.2024.

2. Ausnutzen der unendlichen Weite der natürlichen Zahlen

Die vorangehende Formel 2520/(T%7+2) sorgt dafür, dass nur harmonisch zueinander passende Frequenzen gespielt werden.
Jedoch sorgt die Modulodivision für eine immer gleiche Abfolge.
Im folgenden werden bei jeder Zahl T maximal die Menge an Primfaktoren 2,3,5 und 7 herausgeholt, wie sie in 2520 vorhanden sind.
Dieser Vorgang wird im weiteren Verlauf als REDUKTION bezeichnet.
Hierdurch tritt die komplexe Verteilung der Primfaktoren in der Folge der Natürlichen Zahlen hörbar hervor.
Ändern Sie dazu die draw()-Methode in folgender Weise:

public void draw()
{
    vis.draw();
    vis.step();
    
    A=2520;
    X=T;  
    B=1;
    while(A>=2 && A%2==0 && X>=2 && X%2==0) {A/=2;X/=2;B*=2;}
    while(A>=3 && A%3==0 && X>=3 && X%3==0) {A/=3;X/=3;B*=3;}
    while(A>=5 && A%5==0 && X>=5 && X%5==0) {A/=5;X/=5;B*=5;}
    while(A>=7 && A%7==0 && X>=7 && X%7==0) {A/=7;X/=7;B*=7;}

    tone1.play(A,100); //AOG-Syntax: T,2520
    //tone1.play(B,100); //AOG-Syntax: T.2520
    T++;
}

Code 0-3: Veränderte draw()-Methode: Extraktion der Primfaktoren 2,3,5,7 aus T und A, so weit es bei beiden geht.

HelloAOG_2.zip -- Wie oben modifizierter Sketch direkt zum Herunterladen.

3. Verwendung der generativen symbolischen Skriptsprache Arithmetic Operation Grammar (AOG) innerhalb von Java/Processing

Die beiden Beispiele von 1. und 2. sollen nun alternativ mittels eines Interpreters von AOG umgesetzt werden.
Dies erlaubt eine kompaktere Schreibweise, bei der man schneller etwas variieren kann.
Als Austauschmedium zwischen Java und AOG dienen die vordefinierten Integer-Variablen A bis Z.
Innerhalb von AOG kann auf diese lesend zugegriffen werden, indem man sie hinschreibt.
Schreibt man sie innerhalb von AOG als Kleinbuchstaben hin, erfolgt ein Schreibzugriff.

Das erste Beispiel, also A=2520/(T%7+2) kann in AOG so formuliert werden:
2520/(T%7+2)a
Mit der Angabe a am Ende wird das, was in der Zeile bislang berechnet wurde auf A übertragen.
Die Umsetzung erfolgt durch Übergabe des Ausdrucks als Strings an den AOG-Interpreter evel(...):

public void draw()
{
    vis.draw();
    vis.step();
    
    eval("2520/(T%7+2)a");
    tone1.play(A,100);
    T++;
}

Code 0-4: Beispiel von 1., jedoch unter Verwendung des AOG-Interpreters umgesetzt.

HelloAOG_3.zip -- Obiges Beispiel als Sketch.

Wie bereits durch die Kommentare im Beispiel bei 2. angedeutet, existieren besondere Operatoren, um die Reduktion vorzunehmen.
Das Beispiel bei 2. kann darum mit AOG wie folgt umgesetzt werden:

public void draw()
{
    vis.draw();
    vis.step();
    
    eval("T,2520a");
    tone1.play(A,100);
    T++;
}

Code 0-5: Beispiel bei 2. mit AOG umgesetzt.

4. Ein komplexeres Beispiel mit vier Stimmen zyklisch aus Datei ausgelesen

Um schnell Änderungen vornehmen zu können, kann von AOG auch eine Datei zyklisch interpretiert werden.
Im Projektordner im Sketch HelloAOG finden Sie die Textdatei aogscript.txt
Sie hat folgenden Inhalt:

123*(10-(T/48%10))p
T/2*P%5+1*96+(3*96)a
T/3*P%7+1*48+(3*48)*(T%2=0)*(T/2%6>0)b
T/4*P%5+1*12+(3*12)*(T%4=0)*(T/3%4>0)c
T/3*P%7+1*24+(3*24)*(T%3=0)*(T/4%3>0)d

Code 0-6: Inhalt der Datei aogscript.txt

Damit diese Dateil von AOG zyklisch interpretiert wird, kann das Hauptprogramm in folgneder Weise geändert werden:

Beachten Sie: NUMBER_OF_VOICES=4; und frameRate(8);

//version: HelloAOGdev021 27.05.2024
int NUMBER_OF_VOICES=4;//4;
//Try to vary if stuttering in sound appears:
int SAMPLE_RATE=11025; //8000 11025 22050 44100 48000
int BUFFER_SIZE=16; //16 32 64 128 256 512
public void setup()
{
    size(640,480);
    frameRate(8);
    configure();
}
public void draw()
{
    vis.draw();
    vis.step();
    
    evalFile("aogscript.txt");
    
    tone1.play(A,100);
    tone2.play(B,150);
    tone3.play(C,200);
    tone4.play(D,250);
    T++;
}

Code 0-7: Modifizierter Haupttab zur Interpretation einer Datei.

HelloAOG_4.zip

Bild 0-4: Screenshot zu HelloAOG_4

Erläuterungen

Von Klammern () abgesehen, führt AOG alle Operationen in ihrer natürlichen Reihenfolge aus. * wird beispielsweise nicht vor + ausgeführt.
123*(10-(T/48%10))p erzeugt eine Abfolge von Vielfachen von 123 und speichert sie in P.
T/2*P%5+1*96+(3*96)a Die Hälfte von T wird zu einer kleinen Zahl gemacht, die dann mit 96 multipliziert wird.
T/3*P%7+1*48+(3*48)*(T%2=0)*(T/2%6>0)b Ein Drittel von T wird zu einer kleinen Zahl gemacht, die dann mit 48 multipliziert wird.
(T%2=0)*(T/2%6>0) sind Schaltvorgänge und liefern jeweils entweder 0 (false), oder 1 (true).

https://youtu.be/wmYh8JLMz_c -- Umsetzung mit Disklavier.

Tatsächlich lässt sich aus einem bereits fertig gestellten komplexen Skript im Nachhinein nur schwer ergründen, was es macht.
Typischerweise entstehen solche komplexen AOG-Skripte aus einer kleinen Keimzelle heraus, die interaktiv unter Ausnutzung des akustischen Feedbacks nach und nach erweitert wird.
So könnte man mit einer einfachen Formel nur für eine Stimme beginnen, diese langsam erweitern und Variationen davon für andere Stimmen bilden.
Die nachfolgende Übung geht genau so vor.
Es wird zunächst eine Keimzelle vorgegeben und ein wenig variiert und der Prozess dann an die Teilnehmenden zur individuellen Weiterführung übergeben:

5. Übung

Aus einer Keimzelle wird nach und nach in mehreren Schritten eine Komposition entwickelt, indem strukturelle Ideen als Veränderungen im Code implementiert und anhand des klanglichen Feedbacks immer wieder kontrolliert und korrigiert werden.

Einige Zwischenstation werden nachfolgend gezeigt.

Als Übung können Sie versuchen, diese Zwischenstationen als Ausgangspunkt für eigene, neue Entwicklungen zu benutzen.

Um das klangliche Feedback so ansprechend wie möglich zu gestalten, wurde eine etwas erweiterte Version der Software benutzt, die ein Disklavier ansteuert und dort auch die Möglichkeit bietet, das Sustain-Pedal zu steuern, das Tempo zu ändern und die Frequenzen vor ihrer Umwandlung in Miditöne mit einem prozentualen Faktor zu multiplizieren. Der Code lässt sich von diesen Besonderheiten aber auch auf die oben gegebene Stand-alone-Softwareversion übertragen. Nachfolgend findet sich die verwendete Erweiterung der Software:

HelloAOG_4_MIDI_NEU001.zip

COMPROVIZATION#1

100p    #P==Percent  frequency = 0.01*PERCENT*A..H
127s    #S==Sustain  0..127
60q     #Q==Frame Rate FPS, BPM = FPS*20
T,2520a #Extract 2,3,5,7 in 2520 which are also in T and send to A

Code 0-8: COMPROVIZATION#1

https://youtu.be/w-HKJGzeA3o -- COMPROVIZATION#1 Video

COMPROVIZATION#2

100p    #P==Percent  frequency = 0.01*PERCENT*A..H
127s    #S==Sustain  0..127
60q     #Q==Frame Rate FPS, BPM = FPS*20
7*5*9*8*(T/6%6+1)i   #I==changing base number
T,Ik #
K*(K>109)*(K<1639)*(T/12%3>0)a #set range, add breaks

Code 0-9: COMPROVIZATION#2

https://youtu.be/MtX20kGha1o -- COMPROVIZATION#2 Video

COMPROVIZATION#3

100p    #P==Percent  frequency = 0.01*PERCENT*A..H
127s    #S==Sustain  0..127
60q     #Q==Frame Rate FPS, BPM = FPS*20
7*5*9*8*(T/6%6+1)i   #I==changing base number
T%6+9000+(T/96*96)u  #Repetitions by controling time
U,Ik #
K*(K>109)*(K<1639)*(T/12%3>0)a #set range, add breaks

Code 0-10: COMPROVIZATION#3

https://youtu.be/peEL5YQJgHo -- COMPROVIZATION#3 Video

COMPROVIZATION#4

T/36%10+1*60p    #changing percentage
T/48%2*127s      #alternating sustain
60q     #Q==Frame Rate FPS, BPM = FPS*20
7*5*9*8*(T/6%6+1)i   #I==changing base number
T%6+9000+(T/96*96)u  #Repetitions by controling time
U,Ik #
K*(K>109)*(K<1639)*(T/12%3>0)a #set range, add breaks

Code 0-11: COMPROVIZATION#4

https://youtu.be/ETqAotU73bA -- COMPROVIZATION#4 Video

...und viele viele Iterationsschritte später:

COMPROVIZATION#5

T/24%10+1*(30+(T/48%5*5))p    #smaller percentage
T/48%2*60+60s    #alternating sustain
15q              #slower
7*5*9*8*(T/96%6+1)i      
T%(3+(T/3%3))+9000+(T/12*6)u     #Repetitions by controling time
T%6+9000+(T/24*12)v    #varying time structure
T%12+9000+(T/48*24)y    #varying time structure
T%24+9000+(T/96*48)z    #varying time structure
U+12w
V+24x
U/1*(U%1=0),(I*1)k   #systematically introduce variations in other voices
W/1*(W%1=0),(I*1)l
V/2*(V%2=0),(I*2)m
X/3*(X%3=0),(I*3)n

K*(K>109)*(K<1639)*(U/12%3>0)a #set range, add breaks
L*(L>109)*(L<1639)*(V/18%4>0)b 
M*(M>109)*(M<1639)*(Y/24%6>0)c 
N*(N>109)*(N<1639)*(Z/36%8>0)d

Code 0-12: COMPROVIZATION#5

https://youtu.be/-Ub04lzx7K0 -- COMPROVIZATION#5 Video

LICENSE

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.