AM's Content - Page 7

March 16, 20214 yr

real LISP knowledge is very helpful for me. i think it's enough if you know (work with) the fundamentals - like... list/append/cons/loop/loop-inside-a-loop/progn/push/pop/collect/defun... ...

so that you can code your specific solutions!

greetings

andré

find-bar

February 22, 20214 yr

i know 😀 i'm not a programmer, but it probably makes sense to be able to enter both variants/formats for some functions, but not for others...

find-bar

February 22, 20214 yr

you have to put the bar-numbers into a list... i makes sense in my opinion - perhaps you want to "find" more then one bar...

(find-bar '(1 2) mat)
=> ((c4 db4 ab4 f4 g4 bb4) (a4 eb4 b4 e4 d4 gb4))

Score audition and notation

in Support & Troubleshooting

February 7, 20214 yr

have a look here...?

goeyvaerts-rotation

Posted February 6, 20214 yr

dear all

here's a function (revised, should work correct now) to work with rotations - based on the work of karel goeyvaerts

(defun goeyvaerts-rotation* (&key pitches 
                                 static-pitches
                                 generations
                                 goeyvaerts-transpose-interval
                                 (direction 'up)
                                 low-border
                                 high-border
                                 correction-interval)

  (let ((pitches (filter-remove (pitch-to-midi static-pitches) (pitch-to-midi pitches))))
    (midi-to-pitch (append  (list (append pitches (pitch-to-midi static-pitches)))

                            (cond ((equal direction 'up)
                                   (loop repeat generations
                                     for x in (gen-repeat 50 goeyvaerts-transpose-interval)
                                     collect (append 
                                              (setf pitches (append (loop for i in pitches
                                                                      
                                                                      when (> (+ i x) (pitch-to-midi high-border))
                                                                      collect (+ x (- i (abs correction-interval)))
                                                                      else collect (+ i x))))
                                              (pitch-to-midi static-pitches))))

                                  ((equal direction 'down)
                                   (loop repeat generations
                                     for x in (gen-repeat 50 goeyvaerts-transpose-interval)
                                     collect (append 
                                              (setf pitches (append (loop for i in pitches
                                                                      
                                                                      when (< (- i x)  (pitch-to-midi low-border))
                                                                      collect (+ i correction-interval)
                                                                      else collect (- i x))))
                                              (pitch-to-midi static-pitches)))))))))

EXAMPLE:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; an example with multiple objects inside a chord / GOEYVAERTS uses it woth octave-rotations and with static pitches
;;; here i do it different....

;;; :goeyvaerts-transpose-interval => in every generation the elements are transposed by next interval (circular)
;;; :static-pitches =>  will not rotate!!
;;; :high-border => if a pitch  is higher then this it will be transposed down by :correction-interval

;;; EVALUATE THIS

(setf groups (loop for i in (goeyvaerts-rotation* :pitches '(b3 d4 eb4 gb4 f5 e5 g5 ab5 a4 bb4 db5 c6)
                                                  :static-pitches nil;'(e4 eb5)
                                                  :direction 'up
                                                  :generations 20
                                                  :goeyvaerts-transpose-interval '(2 3 5 7 5 3)
                                                  :low-border 'a2
                                                  :high-border 'eb6
                                                  :correction-interval -36)

               collect  (gen-divide '(5 3 2 2) i)))

;;; AND THIS / cmd1 => so you see the chords an see the rotation etc..

(setf chordized-groups (loop for i in groups 
                         collect (chordize i)))


=> you see the process of the elements

Jean Barraqué - "séries proliférantes"

February 4, 20214 yr

violà... now it works fine 🙂 - OPMO could integrate it....

it's easier than i thought: a single index-series is read from the r-i and only this one is used! similar to LACHEMANN, only he determines this index-series himself (for that i coded this simple row-permutation-function)...

greetings

a.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; SUB
(defun row-permutation (n row rules  &key (one-based nil))
  (let* ((rules (if (equal one-based t)
                 (mapcar '1- rules)
                 rules)))
  (loop repeat n
    collect (setf row (position-filter rules row)))))

;;; MAIN
(defun serie-proliferantes (n row)
  (let ((index-no (loop for x in (pitch-to-midi (pitch-invert (gen-retrograde row)))
                    collect (or (position x (pitch-to-midi row))
                                (position (- x 12)
                                          (pitch-to-midi row)) 
                                (position (+ x 12) 
                                          (pitch-to-midi row))))))
    (list row
          (pitch-invert (gen-retrograde row))
          
    (row-permutation n  (pitch-invert (gen-retrograde row)) index-no))))
                  
(serie-proliferantes 6 '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4))

=> ((c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4)
   ((fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) (bb4 fs4 cs5 g4 gs4 a4 d5 c5 f4 b4 eb5 e5)
    (e5 bb4 g4 cs5 c5 fs4 gs4 a4 b4 f4 d5 eb5) (eb5 e5 cs5 g4 a4 bb4 c5 fs4 f4 b4 gs4 d5)
    (d5 eb5 g4 cs5 fs4 e5 a4 bb4 b4 f4 c5 gs4) (gs4 d5 cs5 g4 bb4 eb5 fs4 e5 f4 b4 a4 c5)))

row-permutation

Posted February 4, 20214 yr

row-permutation (with rule) for n-generations

(defun row-permutation (n row rules  &key (one-based nil))
  (let ((rules (if (equal one-based t)
                 (mapcar '1- rules)
                 rules)))
  (loop repeat n
    collect (setf row (position-filter rules row)))))


(row-permutation 5 '(a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) '(0 1 6 5 2 3 7 8 11 9 4 10))
=> ((a4 gs4 eb5 c5 cs5 e5 d5 bb4 f4 g4 b4) (a4 e5 cs5 gs4 eb5 d5 bb4 b4 f4 c5 g4) (a4 d5 eb5 e5 cs5 bb4 b4 g4 f4 gs4 c5) (a4 bb4 cs5 d5 eb5 b4 g4 c5 f4 e5 gs4) (a4 b4 eb5 bb4 cs5 g4 c5 gs4 f4 d5 e5))

(row-permutation 5 '(a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) '(1 4 6 5 2 3 7 8 11 9 10 12) :one-based t)
=> ((a4 g4 gs4 eb5 c5 cs5 e5 d5 bb4 f4 b4 fs4) (a4 eb5 cs5 c5 g4 gs4 e5 d5 b4 bb4 f4 fs4) (a4 c5 gs4 g4 eb5 cs5 e5 d5 f4 b4 bb4 fs4) (a4 g4 cs5 eb5 c5 gs4 e5 d5 bb4 f4 b4 fs4) (a4 eb5 gs4 c5 g4 cs5 e5 d5 b4 bb4 f4 fs4))

Jean Barraqué - "séries proliférantes"

thanks, julio...

could you have a quick look to the function? and to the article from didier.... perhaps you see my mistake (or the mistake in the article) subito 🙂 ?

barraqué described the mechanism and it seems easy to code it. but where is the mistake with more then 3 gens?

perhaps didier has an idea?

Jean Barraqué - "séries proliférantes"

thanks, julio...!!!

if i got it right, it works like this:

1. take a basic row

2. the r-i of the basic row

3. read the positions of all pitches of the r-i within the basic row

4. apply this positionlist to r-i

=> outout is :

ordre 0 => basic row

ordre 1 => r-i

ordre 2 => proliferante 1

= more or less ONE GEN of production

...

so the question could be: is ordre 1 the new basic row, or proliferante 1 ... to produce the next GEN?

here is some code to check it... i have no idea at the moment... 😕

;;; ONE GEN

(defun serie-proliferantes (row)
  (let* ((basic_row row)
         (ri_row (pitch-invert (gen-retrograde row)))
         
         (row (loop for z in (loop for x in (pitch-to-midi ri_row)
                               collect (or (position x (pitch-to-midi row))
                                           (position (- x 12)
                                                     (pitch-to-midi row)) 
                                           (position (+ x 12) 
                                                     (pitch-to-midi row))))
           
                collect (nth z ri_row))))

    (list basic_row ri_row row)))

;;;; X GENS

(defun serie-proliferantes** (n row)
  (loop repeat n
    collect (setf x (serie-proliferantes row))
    do (setf row (third x)))) ;; when you write here second/third x => then it would be ordre 1
                              ; ;or prolifer 1 as new starting point

(serie-proliferantes** 3 '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4))

Jean Barraqué - "séries proliférantes"

i tried to program it briefly for several generations, but I didn't quite get it - something i do not understand....

so i got wrong outputs after 3 generations... maybe OPMO would like to CODE this? 🙂

this is my new version... but when i have i look to the barraqué-examples (order 0 - x)... there is a different output after 3 gens...

Ordre 0: C Ab G Db E D Bb Eb B F Gb A (c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)

Ordre 1: A C Db G Eb Ab E D F B Bb Gb (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4)

Ordre 2: Gb A G Db D C Eb Ab B F E Bb (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)

Ordre 3: Bb Gb Db G Ab A D C F B Eb E (bb4 e4 eb5 a4 c5 f4 gs4 fs4 g4 cs5 b4 d5) ???? wrong...

Ordre 4: E Bb G Db C Gb Ab A B F D Eb

Ordre 5: Eb E Db G A Bb C Gb F B Ab D

Ordre 6: D Eb G Db Gb E A Bb B F C Ab

Ordre 7: Ab D Db G Bb Eb Gb E F B A C

efun serie-proliferantes* (basicrow &key (gen 10)(ordre nil))
  (let* ((row basicrow)
         (ri_row (pitch-invert (gen-retrograde basicrow)))
         (serie (cons basicrow
                      (loop repeat gen
                        append (list ri_row 
                               (setf row (loop for z in (loop for x in (pitch-to-midi ri_row)
                                                          collect (or (position x (pitch-to-midi row))
                                                                      (position (- x 12)
                                                                                (pitch-to-midi row)) 
                                                                      (position (+ x 12) 
                                                                                (pitch-to-midi row))))
                                           
                                           collect (nth z ri_row))))
                        do (setf ri_row (pitch-invert (gen-retrograde row)))))))


    (if (not (null ordre))
      (position-filter ordre serie)
      serie)))

(serie-proliferantes* '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4))
=> ((c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4)
    (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) (bb4 e4 eb5 a4 c5 f4 gs4 fs4 g4 cs5 b4 d5)
    (d5 b4 gs4 e4 f4 cs5 fs4 bb4 eb5 a4 g4 c5) (c5 f5 eb5 a4 d5 fs5 b4 g5 gs5 e5 cs5 bb4)
    (bb4 d5 gs5 e5 c5 b4 f5 cs5 eb5 a4 fs5 g5) (g5 gs5 f6 b5 cs6 a5 eb6 d6 bb5 fs5 c6 e6)
    (e6 f6 eb6 a5 d6 fs5 bb5 gs5 g5 c6 cs6 b5) (b5 a5 bb5 eb6 d6 c6 e6 gs5 cs6 g5 f5 fs5)
    (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6)
    (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6) (c6 eb6 d6 gs5 f5 bb5 e6 cs6 b5 g5 a5 fs5)
    (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6)
    (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6) (c6 eb6 d6 gs5 f5 bb5 e6 cs6 b5 g5 a5 fs5)
    (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6)
    (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6))

Jean Barraqué - "séries proliférantes"

thank you for the LINKS, i will read the papers!

greetings

andré

Jean Barraqué - "séries proliférantes"

February 1, 20214 yr

thanx, dear julio.

the "serialists" often have suitable concepts for formalization 😄

greetings

andré

L-System

January 31, 20214 yr

one other interesting approach could be, to use l-systems on a "higher level"... (a lot of work to this is already made in OPENMUSIC)

a sequence like '(a b a c a d a a b a e ...) ;; as a "nonsense-l-system-example-seq"

could be used as a seq for FUNCTIONS... means:

an input/omn-seq would be transformed by an l-system-function-sequence, for example...

a = rotate pitches and lengths

b = invert pitches

c = sample-seq pitches

d = change velocities

so you could work with more complex input-gestalts... and when you are doing this on a second/third-level inside of such GESTALTS you will have something like this MODEL...

Hypercycle (chemistry) - Wikipedia

EN.WIKIPEDIA.ORG

i think HANSPETER KYBURZ is "the MASTER" for L-SYSTEMS in MUSICAL COMPOSITION, and i he talked about this things in his lectures

Details - Hochschule für Musik Hanns Eisler Berlin

WWW.HFM-BERLIN.DE

Hanspeter Kyburz - Wikipedia

EN.WIKIPEDIA.ORG

famous pieces with/on this are:

CELLS

Stephane Boussuge and lviklund
2

L-System

January 31, 20214 yr

Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz - PDF Kostenfreier Download

DOCPLAYER.ORG

Hochschule für Musik Hanns Eisler Abteilung D Charlottenstr Berlin Masterarbeit Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz Eres Holz 30. April 2012 Inhaltsverzeichnis

Jean Barraqué - "séries proliférantes"

Posted January 30, 20214 yr

here a function... to barraqué's techniques


(defun serie-proliferantes (row)
  (let* ((ri_row (pitch-invert (gen-retrograde row)))
         (row (loop for z in (loop for x in (pitch-to-midi ri_row)
                          collect (or (position x (pitch-to-midi row))
                                      (position (- x 12)
                                                (pitch-to-midi row)) 
                                      (position (+ x 12) 
                                                (pitch-to-midi row))))
           
                collect (nth z ri_row))))

    row))


(serie-proliferantes '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4  f4 fs4 a4))
=> (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)

Jean Barraqué — Wikipédia

FR.WIKIPEDIA.ORG

seen here:

https://www.amazon.de/Jean-Barraqué-Musik-Konzepte-Heinz-Klaus-Metzger/dp/3883774499

page 19-20

Stephane Boussuge and opmo
2

Distribute rhythm

December 29, 20204 yr

perhaps some (old) hocket-function... ?

convert-to-binary

Posted December 27, 20204 yr

for my current project i have to CONVERT/MAP pitches/lengths/velocity or MIDI into a binary sequence. so i coded this simple FUNCTION... feel free to use/adapt....

greetings

andré


(defun fill-to-x-bit (listseq &key (bitlength 7))
  (loop for i in listseq
    when (< (length i) bitlength)
    collect (append (gen-repeat (- bitlength (length i)) 0) i)
    else collect i))

;;;; CONVERT PITCH/LENGTH or VELOCITY TO BINARY INFORMATION

(defun convert-to-binary (alist &key (parameter 'pitch) (length-resolution 127) (velocity-resolution 127) (pitch-resolution 127) (event nil)  (bitlength 7))
  (let ((pitch) (length) (velocity)
        (alist (progn 
                 (setf alist (cond ((stringp alist)
                                    (flatten (midi-to-omn alist :instrument 1)))
                                   (t alist)))
                 
                 (if (omn-formp alist)
                   (cond ((equal parameter 'pitch)
                          (setf alist (omn :pitch alist)))
                         ((equal parameter 'length)
                          (setf alist (omn :length alist)))
                         ((equal parameter 'velocity)
                          (setf alist (omn :velocity alist)))
                         ((equal event 't)
                          (setf alist (single-events alist))))
                         alist))))
                           
    (if (null event)
      (cond ((pitchp (car alist))
             (progn
               (setf alist  (pitch-to-midi (pitch-melodize alist)))
               (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                  (- (find-max alist) (find-min alist))
                                                                  pitch-resolution) alist)) :bitlength bitlength)))
            
            ((lengthp (car alist))
             (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
            
            ((velocityp (car alist))
             (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  alist))) :bitlength bitlength)))

      (progn 
        (setf pitch (progn
                      (setf alist  (pitch-to-midi (pitch-melodize  (omn :pitch alist))))
                      (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                         (- (find-max alist) (find-min alist))
                                                                         pitch-resolution) alist)) :bitlength bitlength)))
        (setf length (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
        (setf velocity (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  (omn :velocity alist))))  :bitlength bitlength))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 15)
(convert-to-binary '(-e e -q h e) :bitlength 15)
(convert-to-binary '(p p ffff mp ) :bitlength 15)

Stephane Boussuge, JulioHerrlein and opmo
2
1

Looking for Repeating Function

https://www.amazon.de/Differenzen-Poststrukturalistische-Beispiel-Lachenmann-Ferneyhough/dp/3931264157

December 23, 20204 yr

i'm very interested in!! thx to you JULIO!!! 🙂

strukturnetz is not a piece, it's "a kind of technique" he used 🙂

you could read about it here:

listen here...

the STRUKTURNETZ is also "notated" in the score (on top)

Custom Seed List

December 23, 20204 yr

like that? should work...

it "loops" x-times (depends on length of seeds-list) and collect the rhythms...

(setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13)))


(setf rhythm (loop for i in seeds 
               collect (euclidean-rhythm 16 4 16 's :type 2 :seed i)))

perhaps there is an OPMO-solution, this is LISP

JulioHerrlein and NagyMusic
2

Looking for Repeating Function