Xenakis: Graphical Score

Graphical Score and Anaylisis of ›N’Shima‹ by Iannis Xenakis

Details

Iannis Xenakis, N’Shima: Analyse als experimentelle Sprachkomposition

Wie gezeigt wird, sind die statistischen Gestalten der aus der Verbindung von RANDOM WALKS und sprachlichem Material resultierenden Klangstrukturen keineswegs über das gesamte Stück gleichförmig verteilt und auch nicht als zufällige Ausprägungen einer einzelnen zugrundeliegenden Verteilungsfunktion zu deuten. Ihre Unterschiedlichkeit in der Verteilung von Dauern und Intervallen muss somit als eine unterschiedliche Beschaffenheit der ihnen zugrunde liegenden Verteilungsfunktionen aufgefasst werden. Die Veränderung dieser statistischen Gestalten im Verlauf von N’SHIMA wird auf Basis der zuvor angestellten Untersuchungen beobachtet.
Extremwerte der Ereignisdichte können als Höhepunkte gelten, denn sie sind nach Xenakis‘ Ästhetik der Wahrscheinlichkeit die signifikantesten Gestalten und erzeugen aufgrund ihrer Seltenheit die größte Aufmerksamkeit. Die Extremwerte der Ereignisdichte lassen sich in Abschnitt 7 (niedrige Dichte) und 8 (hohe Dichte) in direkter Nachbarschaft beobachten. Die RANDOM WALKS sind derartig miteinander oder mit Haltetönen oder Pausen montiert, dass sich Abschnitte des Werks in ihrer Dichte unterscheiden und Xenakis durch solchermaßen geplante Anordnung den Verlauf der Dichte auf makroskopischer Ebene steuern kann. Die Dichte der einzelnen RANDOM WALKS wiederum steuert Xenakis durch die Konfiguration der ihnen zugrunde liegenden Wahrscheinlichkeitsverteilungen.

Die Interpretation der Ergebnisse zeigt, dass Xenakis, indem er das Modell der RANDOM WALKS auf die Formalisierte Musik und ein spezifisch interpretierten Modell von Sprache anwendet, eine eigenständige Form der Sprachkomposition kreiert. Er macht sein Denken in Modellen damit besonders konsequent für das Komponieren mit sprachlichem Material nutzbar. Indem er Sprache ebenfalls als Modell auffasst und dessen Bestandteile Prosodie, Sprachrhythmus oder Klanglichkeit der Phoneme durch seine an außermusikalischen Modellen orientierten Kompositionstechniken steuert, schafft er eine abstrakte musikalisierte Form von Sprache, die seinen Verfahrensweisen der Formalisierten Musik entspricht. Das dominante Bezugsystem ist weder die Sprache noch die Musik, sondern jene stochastischen und naturwissenschaftlichen Gesetze und Formeln, mit denen Xenakis Strukturen außerhalb der Zeit erzeugt. Sie nehmen die Rolle eines „Katalysators“ ein, der in Xenakis‘ Verständnis von Sprachkomposition, wie er es in N’SHIMA vorführt, hilft, die heterogenen Ausgangsmaterialien zu einem Gemeinsamen reagieren zu lassen. Dies entspricht in besonderer Weise dem der Analyse zugrunde gelegten Definition einer Sprachkomposition, in der Sprache und Musik keine hierarchischen Verhältnisse zueinander bilden, sondern eine Verschmelzung und eine Neubelegung mit Bedeutung stattfindet.

Analyse der Random Walks

Ein ästhetisches Nachvollziehen der klanglichen Strukturen von N’SHIMA muss sich zunächst mit der Frage nach der Beschaffenheit statistischer Verteilungen beschäftigen. Durch ihre Beobachtung lassen sich Aussagen über Gestalten, Struktur, Form und ästhetische Standpunkte treffen.
Xenakis‘ Grundidee, makroskopische Klanggestalten durch statistische Verteilungen von Dauern und Intervallen zu erzeugen, ist auch in N’SHIMA anzutreffen. Im Fall dieses Werkes realisiert Xenakis diese Grundstrategie des Basissystems „Individualstil“ durch die Anwendung seiner Technik der Random Walks. Indem er Dauern und Intervalle im Sinne seines Konzeptes der Formalisierten Musik nach Regeln der Wahrscheinlichkeitsrechnung berechnet, entstehen Klanggestalten. Diese für die Kompositionstechnik der Random Walks charakteristischen Klanggestalten weisen wiederum unterschiedliche Ausprägungen ihrer Merkmale auf, was auf die unterschiedliche Konfiguration der Wahrscheinlichkeitsberechnungen zugrundeliegenden Formeln zurückzuführen ist.
Um über die Beschaffenheit der Random Walks und den formalen Aufbau von N’SHIMA tiefergehende Aussagen treffen zu können, wurden die Vektor-Koordinaten der Glissandolinien

der im ersten Schritt angefertigten grafischen Partitur durch ein Skript in Adobe Illustrator extrahiert und analysiert. Den im theoretischen Teil wiedergegebenen Recherchen entsprechend wurden die Random Walks anschließend auf ihre Eigenschaften hin untersucht.
Jeder einzelne Schritt (oder: jedes Ereignis E) eines Random Walks wird als einzelnes Glissando hinsichtlich seiner Dauer ∆t und seiner Zielfrequenz ∆f analysiert. Da 1/16-Noten die kürzesten Notenlängen bei N’SHIMA darstellen,63 werden die Dauern innerhalb eines Rasters von 1/16-Notenwerten analysiert. Den Intervallen wiederum unterliegt ein Raster von Vierteltönen, weshalb dementsprechend die Einheit Viertelton zugrunde gelegt wurde. Durch die Kenntnis der Dauern und Intervalle aller Einzelereignisse eines Random Walks lässt sich die Beschaffenheit der zugrunde liegenden Wahrscheinlichkeitsverteilungen analysieren.
Im unten ersichtlichen Beispiel die folgenden Intervalle vor: +1, +2, -3, -2, +3, -2, -1, +4, -2, +3, -2, -2. Die entsprechenden Dauern der Einzelereignisse betragen: 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 2. Damit lässt sich das Diagramm anfertigen, welches die Verteilung der Dauen und Intervallgrößen darstellt.

Ergebnis: Charakteristische statistische Gestalten der Random Walks

Nachdem die Rohdaten für sämtliche bei N’SHIMA auftretenden Random Walks wie oben beschrieben gewonnen wurden, konnten diese nun neben ihren hörbaren Eigenschaften zusätzlich anhand ihrer statistischen Eigenschaften auf ihre Ähnlichkeit hin beurteilt werden. Die Analyse der graphischen Darstellung der Rohdaten aller Random Walks (vgl. Anhang B) zeigt, dass die auftretenden Random Walks sich anhand der Dichteverteilungen ihrer Dauern- und Intervallwerte in Gruppen einteilen lassen. Die charakteristischen statistischen Gestalten dieser Gruppen sind in den Grafiken unten wiedergegeben. Ihre Eigenschaften sind direkt auf die von Xenakis gewählte Konfiguration der

Wahrscheinlichkeitsverteilungen zurückzuführen. Da die Dichteverteilungen der Dauern- und Intervallwerte das Resultat von Verteilungsfunktionen darstellen, lassen sich durch ihre Betrachtung Rückschlüsse auf die von Xenakis konkret verwendete Verteilungsfunktion ziehen. Es zeigen sich für Dauer und Intervallgröße der formalisierten Random Walks zwei bzw. drei signifikant verschiedene Gestalten. Wie in weiteren Analysen zu sehen sein wird treten diese statistischen Gestalten nicht gleichförmig über das gesamte Stück auf. Vielmehr zeigt sich ein Muster in ihrer Verwendung, welches N’SHIMA in seinem Klanglichen Verlauf strukturiert.

Beispiel: Statistische Analysen einiger Random Walks aus Abschnitt 1

Beispiel: Statistische Analysen einiger Random Walks aus Abschnitt 3

Script zur Erfassung der statistischen Daten der Random Walk – Strukturen

 if (activeDocument.selection [0])
{  

//------------------------------------------------------------------------------------------------------------
// Grundlegende Variablen und Arrays definieren
//------------------------------------------------------------------------------------------------------------
    //      var brushIndex = prompt ( "Select the brush index you want: [0-" + (docBrushes.length - 1) + "]", ' ' );
    var sel=activeDocument.selection[0].pathPoints;
    var ank=new Array(); 
    var i=0;
    var punkte = new Array(); 
    var MMfaktor = 0.3514598;   // zur Umrechnung von Points in Millimeter

    // Dauern in 1/16-Noten. Längere Notenwerte als 8/16=1/2 werden nicht ueberprueft, 
    // da diese als Haltenoten angesehen werden und somit innerhalb der Random Walks 
    // nicht auftreten.
        var dauer = new Array(0,0,0,0,0,0,0,0);

     // Intervalle von -40/4 bis 40/4
        var intervallsPos = new Array(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
        var intervallsNeg = new Array(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);        

    // Kontinuierliche Liste aller Dauern zwischen zwei Tönen anlegen
        var dauernliste = new Array();
     // Kontinuierliche Liste aller Intervalle zwischen zwei Tönen anlegen
        var intervallliste = new Array();
     // Kontinuierliche Liste aller Tonhöhen anlegen
        var yPosList = new Array();

    // Liste der Pfadpunkte in Array Punkte umgruppieren und diesen Array so
    // sortieren, dass die Punkte mit kleinstem x-Wert links sind (manche Random Walks
    // der Partitur wurden von rechts nach links gezeichnet und würden daher
    // falsch herum analysiert
        //alert (sel[0].anchor[0]);

     for(i=0;i<sel.length ;i++){ 
            punkte[i] = new Array();
            //punkte[i][0] = Math.round(sel[i].anchor[0]);
            //punkte[i][1] = Math.round(sel[i].anchor[1]);
            punkte[i][0] = sel[i].anchor[0];
            punkte[i][1] = sel[i].anchor[1] ;
     }
     punkte.sort(function(a, b){return a[0] - b[0];});

    // Ursprung des Pfades berechnen (=erster Pfadpunkt)
        oxPos=Math.round(punkte[0][0] * MMfaktor);
        oyPos=Math.round(punkte[0][1] * MMfaktor);
        var originX = oxPos;
        var originY = oyPos;

//------------------------------------------------------------------------------------------------------------
//  Ausgewählten Random Walk analysieren | Tondauern und Intervalle, Ablegen in Listen
//------------------------------------------------------------------------------------------------------------       

    for(i=0;i<sel.length ;i++)
    { 
        // Convert coordinates from point to millimeters
            xMM = punkte[i][0] * MMfaktor;
            yMM = punkte[i][1] * MMfaktor;
        // round  millimeters
            xPos=Math.round(xMM*2);
            yPos=Math.round(yMM);
        // append coordinates to list
            ank.push(Math.abs (xPos-oxPos)); 
            ank.push((yPos-oyPos));    
        // Liste aller y-Positionen erstellen
            currY = (yPos)-originY; //y-Position (=Tonhöhe) des aktuellen Punkts berechnen 
            yPosList.push(currY);

        // Zaehlen der auftretendenTondauern
        // ------------------------------------------------------
            if (i>0){
                lastX = Math.round(punkte[i-1][0] * MMfaktor *2);
                lastX2= (punkte[i-1][0] * MMfaktor);
                xPosOld = lastX-originX*2;

                wert = (xPos-originX*2)-xPosOld;
                dauer[(wert)-1] ++;
                dauernliste.push(wert); 
             }

        // Zaehlen der auftretenden Intervalle
        // ------------------------------------------------------
            if (i>0){
                yPosOld = (Math.round(punkte[i-1][1] * MMfaktor)-oyPos);
                // wenn Intervall positiv (nach oben)
                if (((yPos-oyPos)-yPosOld) > 0){
                    intervallsPos[((yPos-oyPos))-yPosOld] ++;                
                }
                // wenn Intervall negativ (nach unten)
                if (((yPos-oyPos)-yPosOld) < 0){
                    intervallsNeg[Math.abs((yPos-oyPos)-yPosOld)] ++;
                }
                // wenn Intervall 0 (keine Tonhoehenveränderung)
                if (((yPos-oyPos)-yPosOld) == 0){
                    intervallsPos[0] ++;
                    intervallsNeg[0] ++;
                }
                     intervallliste.push(Math.abs((yPos-oyPos)-yPosOld));
               // intervallliste.push((yPos-oyPos)-yPosOld);
            }
    }
        // Bestimmung der Gesamtdauer des RWs
        // -------------------------      -----------------------------
                    var sumDauerRW = 0;                  
                    for(i=0;i<dauernliste.length ;i++)
                    { 
                        sumDauerRW = sumDauerRW+dauernliste[i];
                     }
                 //alert(intervallsPos              );

        // Durchschnitt und Varianz aller Dauern und Intervalle des Random Walks berechnen
        var avgDauer = durchschnitt(dauernliste); 
        var variDauer = varianz(dauernliste, avgDauer);
        var avgIntervall = durchschnitt(intervallliste);
        var variIntervall = varianz(intervallliste, avgIntervall);
        var avgTonhöhe = durchschnitt(yPosList);     
        var sumDauer = 0; 

 //------------------------------------------------------------------------------------------------------------
//  Visuelle Ausgabe in Illustrator (Labels)
//------------------------------------------------------------------------------------------------------------   
        var docRef = activeDocument;       
        var activeAB = docRef.artboards[docRef.artboards.getActiveArtboardIndex()];

        // Ursprungskoordinaten für visuelle Ausgabe ermitteln
        diagramX = punkte[0][0];   
        diagramY = activeAB.artboardRect[1]-150; 

        // Aussehen von Linien definieren
        var colorBorder = new RGBColor; 
        var colorBorder2= new RGBColor; 
        var colorFill= new RGBColor; 
        colorBorder.red = 0; colorBorder.blue = 0; colorBorder.green = 0;           
        colorBorder2.red = 100; colorBorder2.blue = 100; colorBorder2.green = 100; 
        colorFill.red = 255; colorFill.blue = 255; colorFill.green = 255; 
        //itemRef.strokeWidth = 0.25; itemRef.strokeColor = colorBorder; itemRef.fillColor = colorFill;

         // Ankerlinie von RW zu Diagramm ziehen
        p = activeDocument.activeLayer.pathItems.add();
        with(p){
                setEntirePath(Array( Array(punkte[0][0]+1, punkte[0][1]), Array(punkte[0][0]+1, activeAB.artboardRect[1]-48)));
                filled = false;
                stroked = true;
                strokeColor = colorBorder;
                strokeWidth = 2;
         }

        // schwarzes Rechteck erstellen
        var rectBlack = activeDocument.activeLayer.pathItems.rectangle(activeAB.artboardRect[1]-48,punkte[0][0],30,51.903+0.2         );
            with(rectBlack){
                filled = true;
                stroked = true;
                fillColor = colorBorder;
                strokeColor = colorBorder;
                strokeWidth = 0;
             }
        // weisse Linie ziehen
        lineWhite = activeDocument.activeLayer.pathItems.add();
            with(lineWhite){
                setEntirePath(Array( Array(diagramX, diagramY+50), Array(diagramX+30, diagramY+50)));
                filled = false;
                stroked = true;
                strokeColor = colorFill;
                strokeWidth = 0.2;
               }
         lineWhite2 = activeDocument.activeLayer.pathItems.add();
            with(lineWhite2){
                setEntirePath(Array( Array(diagramX, diagramY+98), Array(diagramX+30 , diagramY+98    )));
                filled = false;
                stroked = true;
                strokeColor = colorFill;
                strokeWidth = 0.2;
               }
          lineWhite3 = activeDocument.activeLayer.pathItems.add();
            with(lineWhite3){
                setEntirePath(Array( Array(diagramX, diagramY+82), Array(diagramX+30 , diagramY+82)));
                filled = false;
                stroked = true;
                strokeColor = colorFill;
                strokeWidth = 0.2;
               }
           lineWhite4 = activeDocument.activeLayer.pathItems.add();
            with(lineWhite4){
                setEntirePath(Array( Array(diagramX, diagramY+66), Array(diagramX+30 , diagramY+66)));
                filled = false;
                stroked = true;
                strokeColor = colorFill;
                strokeWidth = 0.2;
               }
        // schwarze Linie ziehen
        /*lineBlack = activeDocument.activeLayer.pathItems.add();
            with(lineBlack){
                setEntirePath(Array( Array(diagramX+30, diagramY+50), Array(diagramX+130, diagramY+50)));
                filled = false;        
                stroked = true;
                strokeColor = colorBorder;
                strokeWidth = 0.2;
               }*/

        // Dauern als Diagramm ausgeben

        dLines = new Array();
        for(i=0;i< dauer.length ;i++) {
            dLines[i] = activeDocument.activeLayer.pathItems.add();
            with(dLines[i]){
                setEntirePath(Array( Array((diagramX+34)+(i*4), diagramY+50), Array((diagramX+34)+(i*4), diagramY+50+(dauer[i]*2))));
                filled = false;
                stroked = true;
                strokeColor = colorBorder;
                strokeWidth = 0.5;
            }
        }

        // Intervalle als Diagramm ausgeben
                //intervalleX = punkte[0][0]+60;   
                //intervalleY = activeAB.artboardRect[1]-150;
                intervalleX = diagramX+75;
                intervalleY = diagramY+51;
                iLinesNeg = new Array();
                iLinesPos = new Array();
                var counter = 0;
                for(i=intervallsNeg.length;i >= 0 ;i--) {
                    counter ++;
                    if (intervallsNeg[i] != 0){
                        iLinesNeg[i] = activeDocument.activeLayer.pathItems.add();
                        with(iLinesNeg[i]){
                            //setEntirePath(Array( Array(intervalleX+(counter*2), intervalleY), Array(intervalleX+(counter*2), intervalleY+(intervallsNeg[i]*2))));
                            setEntirePath(Array( Array(intervalleX, intervalleY-((i)*2)-1), Array(intervalleX+(intervallsNeg[i]*2), intervalleY-((i)*2)-1)));
                            filled = false;
                            stroked = true;
                            strokeColor = colorBorder;
                            strokeWidth = 0.5;
                        }
                    }
                }
                //diagramX = punkte[0][0]+60+82;                                            
                for(i=0;i< intervallsPos.length ;i++) {
                    if (intervallsPos[i] != 0){

                        iLinesPos[i] = activeDocument.activeLayer.pathItems.add();
                        with(iLinesPos[i]){
                            //setEntirePath(Array( Array(intervalleX+(i*2), intervalleY), Array(intervalleX+(i*2), intervalleY+(intervallsPos[i]*2))));
                            setEntirePath(Array( Array(intervalleX, intervalleY +(i*2)-1), Array(intervalleX+(intervallsPos[i]*2), intervalleY+(i*2)-1)));
                            filled = false;
                            stroked = true;
                            strokeColor = colorBorder;
                            strokeWidth = 0.5;
                        } 
                    }

                }

     //alert(intervallsNeg);
    // 3,2,3,4,0,1,
    // 3,1,0,3,1

        // Beschriftungen 
        // ------------------------------------------------------
            // Werte Berechnen und auf 3 Nachkommastellen begrenzen
                sdtAbwDauer = Math.sqrt(variDauer);
                sdtAbwIntervalle = Math.sqrt(variIntervall);
                avgDauer = avgDauer.toFixed(3);
                variDauer = variDauer.toFixed(3);
                sdtAbwDauer = sdtAbwDauer.toFixed(3);
                avgIntervall = avgIntervall.toFixed(3);
                variIntervall = variIntervall.toFixed(3);
                sdtAbwIntervalle = sdtAbwIntervalle.toFixed(3);
                avgTonhöhe = avgTonhöhe.toFixed(3);

            var textX = diagramX+1; ;
            var textY = diagramY-2; ;

            try {
                var charStyle = activeDocument.characterStyles.add("FliessText");
            }
                catch (e){
            }
            try {
                var labelStyle = activeDocument.characterStyles.add("LabelText");
            }
                catch (e){
            }
            try {
                var diagrammStyle = activeDocument.characterStyles.add("DiagrammText");
            }
                catch (e){
            }
            var charAttr = charStyle.characterAttributes; 
                    charAttr.size = 1.8; 
                    charAttr.fillColor = colorFill;
                    charAttr.tracking = -20;
                    //charAttr.leading = 200;
                    try{
                        charAttr.textFont=app.textFonts.getByName("DINPro-Regular");
                    }
                    catch(e){alert(e)}

           var numberRW = labelStyle.characterAttributes;  
                    with(numberRW){
                        size = 14; 
                        fillColor = colorFill;
                        tracking = -20;           
                        try{
                            textFont=app.textFonts.getByName("DINPro-Bold");
                        }
                        catch(e){alert(e)}

                     }

             var diagrammLabel = diagrammStyle.characterAttributes;  
                    with(diagrammLabel){
                        size = 1.2; 
                        fillColor = colorBorder;
                        tracking = +100;           
                        try{
                            textFont=app.textFonts.getByName("DINPro-Regular");
                        }
                        catch(e){alert(e)}

                     }

                // Beschriftung für Intervalldiagramm
                var intervallPosValueText = new Array(); 
                var intervallNegValueText = new Array(); 
                var rechteckePos = new Array();
                var rechteckeNeg = new Array();

                for(i=0;i< intervallsPos.length ;i++) {
                    if (intervallsPos[i] != 0){
                        intervallPosValueText[i] = docRef.textFrames.add(); 
                        //var rechtecke[i] = activeDocument.activeLayer.pathItems.rectangle(activeAB.artboardRect[1]-50,punkte[0][0],30,70);
                        rechteckePos[i] = activeDocument.activeLayer.pathItems.rectangle(diagramY+50.8+(i*2),intervalleX+(intervallsPos[i]*2)+0.6,2,1.5);
                        with(rechteckePos[i]){
                            filled = true;
                            stroked = true;
                            fillColor = colorFill;
                            strokeColor = colorFill;
                            strokeWidth = 0;
                         }
                       // intervallValueText[i].top = diagramY+62+(dauer[i]*2); 
                        intervallPosValueText[i].top = diagramY+59.6+(i*2);
                       // intervallValueText[i].left = (textX+32.6)+i*4;
                        intervallPosValueText[i].left = intervalleX+(intervallsPos[i]*2)+1;
                        diagrammStyle.applyTo(intervallPosValueText[i].textRange);
                        intervallPosValueText[i].contents = intervallsPos[i];
                    }
                 }

                for(i=0;i< intervallsNeg.length ;i++) {
                    if (intervallsNeg[i] != 0){
                        intervallNegValueText[i] = docRef.textFrames.add(); 
                        rechteckeNeg[i] = activeDocument.activeLayer.pathItems.rectangle(diagramY+50.8-(i*2),intervalleX+(intervallsNeg[i]*2)+0.6,2,1.5);
                        with(rechteckeNeg[i]){
                            filled = true;
                            stroked = true;
                            fillColor = colorFill;
                            strokeColor = colorFill;
                            strokeWidth = 0;
                         }
                       // intervallValueText[i].top = diagramY+62+(dauer[i]*2); 
                        intervallNegValueText[i].top = diagramY+59.6-(     i*2);
                       // intervallValueText[i].left = (textX+32.6)+i*4;
                        intervallNegValueText[i].left = intervalleX+(intervallsNeg[i]*2)+1 ;
                        diagrammStyle.applyTo(intervallNegValueText[i].textRange);
                        intervallNegValueText[i].contents = intervallsNeg[i];
                    }
                 }

                // Beschriftung für Dauerndiagramm
                 var dauerLegText = new Array();   
                    var dauerValueText = new Array(); 

                    for(i=0;i< dauer.length ;i++) {
                        dauerLegText[i] = docRef.textFrames.add();
                        dauerLegText[i].top = diagramY+55; 
                        dauerLegText[i].left = (textX+36)+i*4;
                        dauerLegText[i].rotate(-90);
                        diagrammStyle.applyTo(dauerLegText[i].textRange);
                        dauerLegText[i].contents = (i+1)+"/16";
                    }

                    for(i=0;i< dauer.length ;i++) {
                        rechteckePos[i] = activeDocument.activeLayer.pathItems.rectangle(diagramY+53+(dauer[i]*2),(textX+32.3)+i*4,2,1.5);
                        with(rechteckePos[i]){
                            filled = true;
                            stroked = true;
                            fillColor = colorFill;
                            strokeColor = colorFill;
                            strokeWidth = 0;
                         }
                        dauerValueText[i] = docRef.textFrames.add(); 
                        dauerValueText[i].top = diagramY+62+(dauer[i]*2); 
                        dauerValueText[i].left = (textX+32.6)+i*4;
                        diagrammStyle.applyTo(dauerValueText[i].textRange);
                        dauerValueText[i].contents = dauer[i];
                    }

            var dauerLabel = docRef.textFrames.add();
            var ereignisdichte = (sel.length-1)/sumDauerRW;
            var ereignisdauer = sumDauerRW/(sel.length-1);
            dauerLabel.contents = "Summe der Ereignisse: "+(sel.length-1)+"\r\r";
            dauerLabel.contents += "Dauern\r";
            dauerLabel.contents += "Durchschn. Ereignisdauer: "+avgDauer+"\r";
            dauerLabel.contents += "Varianz: "+variDauer+"\r";
            dauerLabel.contents += "Standardabweichung: "+sdtAbwDauer+"\r";
            dauerLabel.contents += "Gesamtdauer des RW: "+sumDauerRW+"\r\r\r";

            dauerLabel.contents += "Intervalle\r";
            dauerLabel.contents += "Durchschn. Intervalle: "+avgIntervall+"\r";
            dauerLabel.contents += "Varianz: "+variIntervall+"\r";
            dauerLabel.contents += "Standardabweichung: "+sdtAbwIntervalle+"\r\r\r\r";
            dauerLabel.contents += "Durchschn. Tonhöhe: "+avgTonhöhe+"\r";  
            dauerLabel.contents += "Durchschn. Ereignisdichte: "+ereignisdichte.toFixed(3)+"\r"; 
            dauerLabel.contents += "Durchschn. Ereignisdauer: "+ereignisdauer.toFixed(3)+"\r"; 

            dauerLabel.top = diagramY+109.5;             
            dauerLabel.left = diagramX+1.5;
            charStyle.applyTo(dauerLabel.textRange);
            redraw();

//------------------------------------------------------------------------------------------------------------
// Schreiben der Textdatei
//------------------------------------------------------------------------------------------------------------   

    /*
    // gezaehlte Dauern ausgeben
    ank.push("\n\n",dauer);
    // gezaehlte positive Intervalle  ausgeben
    ank.push("\n\n",intervallsPos);
    // gezaehlte negative Intervalle ausgeben
    ank.push("\n\n",intervallsNeg);

    ank.push("\n\n",dauernliste);

     var txtFile =  new File( "~/Desktop/Pfade/Ankerpfad.txt" );  
    txtFile = txtFile.saveDlg();
    if( txtFile!='' )
    {
        //Open the file for writing.    
        var out = txtFile.open( 'e'); 
        txtFile.encoding = "UTF-8"; 
        txtFile.lineFeed = "Unix"; //convert to UNIX linefeed 
        txtFile.writeln(ank);
        txtFile.close();    
        txtFile.execute();   
    }*/
}

//------------------------------------------------------------------------------------------------------------
// Funktionen
//------------------------------------------------------------------------------------------------------------ 

    function durchschnitt(werteliste) {
        var sumDauer = 0;        
        var avgDauer = 0;

        for(i=0;i<werteliste.length ;i++)
        { 
            sumDauer = sumDauer+werteliste[i];
         }
        avgDauer = sumDauer/werteliste.length;
        return avgDauer;
     }

     function varianz(werteliste, durchschnitt) {
        var varianzDauer = 0;
        var s =0;
        for(i=0;i<werteliste.length ;i++)
        { 
            s= s+(werteliste[i]-durchschnitt)*(werteliste[i]-durchschnitt);
         }

        varianzDauer = s/werteliste.length;
        return varianzDauer;
     }