3.1.2. Realisation

Mit Hilfe von etwas Lisp Code

;;;
;;; Pierre Boulez: Structures Ia:
;;;
;;; Die pitch-classes der Zwölftonreihe im Original und Umkehrung
;;; (0=c, 1=cis, 2=d, ... 11=h):

(defparameter *original*  '(3 2 9  8  7 6 4 1 0 10 5 11))
(defparameter *umkehrung* '(3 4 9 10 11 0 2 5 6  8 1  7))

;;; Structures 1a, Piano 1 Seite 1:

(sprout
 (process
   with timescale = 0.1
   for pitch-class in *original*
   for oktave in '(8 5 5 2 3 6 7 6 3 1 4 3)
   for rhythm in '(12 11 9 10 3 6 7 1 2 8 4 5)
   output (new midi
            :keynum (+ (* oktave 12) pitch-class)
            :duration (* timescale rhythm)
            :amplitude 1.0)
   wait (* timescale rhythm)))

;;; Verkapselung durch Definition als Funktion:

(defun pno1-1a ()
  (process
    with timescale = 0.125
    for pitch-class in *original*
    for oktave in '(8 5 5 2 3 6 7 6 3 1 4 3)
    for rhythm in '(12 11 9 10 3 6 7 1 2 8 4 5)
    output (new midi
             :keynum (+ (* oktave 12) pitch-class)
             :duration (* timescale rhythm)
             :amplitude 1.0
             :channel 0)
    wait (* timescale rhythm)))

;; spielen:

(sprout (pno1-1a))

;;; Piano 2 Seite 1:

(defun pno2-1a ()
  (process
    with timescale = 0.125
    for pitch-class in *umkehrung*
    for oktave in '(8 3 5 1 3 7 5 4 6 2 6 8)
    for rhythm in '(5 8 6 4 3 9 2 1 7 11 10 12)
    output (new midi
             :keynum (+ (* oktave 12) pitch-class)
             :duration (* timescale rhythm)
             :amplitude 0.6
             :channel 1)
    wait (* timescale rhythm)))

;; spielen:

(sprout (pno2-1a))

;; Beide zusammen spielen:

(progn
  (sprout (pno1-1a))
  (sprout (pno2-1a)))

;; Für Fortgeschrittene: Besser wäre es, das Ganze als Prozess zu
;; definieren. Dafür muss aber vor den Funktionsnamen die Zeichenfolge
;; "#'" geschrieben werden und die Funktion muss mit der Funktion
;; "funcall" aufgerufen werden:

(sprout
 (process
   for fn in (list #'pno1-1a #'pno2-1a)
   sprout (funcall fn)
   wait 0))