Jump to content

AM

Members
  • Content Count

    544
  • Joined

  • Last visited

Posts posted by AM


  1. too much code and too complicated to post - I do not have the time to write a manual.

     

    it's a "machine" that creates multiple "brownian bridges" combined with "pitch-contour" and "add-rnd-dust".  it's an all-in-ONE tool/machine/bot...

     

    I'm interested in repetition/difference in other contexts than traditional ones; but "brownian bridges" then resemble ornaments. when the sequences are short - brownian bridges are "rnd-processes" between 2 fixed points - then you will keep ornamental sequences between this 2 points/pitches...

     

    (I did not work with a score, just coding and listening - it's only sketching/testing, not composing. and all the examples are "rnd-generated"/not-composed by the machine, you could produce more and more...)

     

    some links:

     

    Brownian_bridge.png
    EN.WIKIPEDIA.ORG

     

     

    -> in OPMO

     


  2. perhaps you have some better ideas - ...perhaps with range/ambitus... sometimes in trouble - but i only use it for my current work, and so it's no problem 🙂

     

    could be nice if you could do the add-system also with an external list input -> not fibonacci or primes or sum, but perhaps also with any integer or float list. so MODIFY-function could be done with any DATA...

     

    and perhaps it could be also nice for LENGTH and DYNAMICS, i would like that (all-in-one)


  3. generate some examples...

     

    
    ;;; evaluate shift-cmd-e
    
    (progn
      ;gen a sieve
      (setf sieve (gen-sieve '((c0 c5) (c3 c6) (c4 c8))
                            '((14 1 2) (5 5 1 2) (6 2 1))
                            :type :pitch))
    
      ; gen a line inside the sieve
      (setf sample (append (gen-rotate (random 8) 
                                       (pick-sample-from-center sieve (rnd-pick '(7 11))))
                         ))
    
      (pitch-list-plot
       (list
        ; gen modified loines with "compr/expand-melody"
        (setf line1 sample)
    
        (setf line2 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 1
                                          :shift -5))
    
        (setf line3 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 2
                                          :shift -8))
    
        (setf line4 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 3
                                          :shift -11)))
       
       :join-points t)
    
    
    
      (setf chordseq (loop 
                       for i in line1
                       for j in line2
                       for k in line3
                       for l in line4
                       
                       append (chordize (list i j k l)))))
    
    
    
    
    ;;; ecvaluate with command2
    (setf omn (list 's chordseq))
    (setf omn (flatten (list 't line1 '-h 't line2 '-h 't line3 '-h 't line4)))

     


  4. greetings

    andré

    ;;; MODIFY THE PITCH CONTOUR inside a pitchfield or tonality
    ;;; please evaluate the example and have a look to the contours
    
    ;;; subfunction
    
    (defun position-items (items alist)
      (loop 
        for item in items
        append (position-item item alist)))
    
    
    ;;; function
    
    (defun compr/expand-melody (melody field &key (type 'add) (n 1) (shift 0))
      (let* ((ints (loop for i in  (difference 
                                    (position-items (pitch-to-midi melody) 
                                                    (pitch-to-midi field)))
                     collect (cond ((equal type 'add)
                                    (cond ((<= i -1)
                                           (- i n))
                                          ((>= i 1)
                                           (+ i n))
                                          (t i)))
    
                                   ((equal type 'fibonacci)
                                    (cond ((>= i 1)
                                           (+ i (fibonacci i)))
                                          ((<= i -1)
                                           (- i (fibonacci (abs i))))
                                          (t i)))
    
                                   ((equal type 'summativ)
                                    (cond ((>= i 1)
                                           (+ i (+ i n)))
                                          ((<= i -1)
                                           (- i (+ (abs i) n)))
                                          (t i)))))))
    
        (position-filter
         (x+b (interval-to-integer ints :start (car  (position-items melody field))) shift)
         field)))
    
    
    
    ;;; expand 1a
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 2)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 3)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 5)
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    ;;; expand 1b => using shift (changed startposition)
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 1
                             :shift 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 2
                             :shift 2)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 3
                             :shift 3)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 5
                             :shift 4)
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; compress 
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -2)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -3)
    
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; expand 2 with fibonacci
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'fibonacci)
        
        (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; expand 3 summativ
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'summativ
                             :n 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'summativ
                             :n 2)
    
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))

     

     

    some evaluations -> different melodic contours (rnd / in a sieve) and its expansions

     


  5. dear all

     

    is there a possibility to change the PAN in every EVENT?

    1)

    like '((q c4 mp pan-30) (e c3 pp pan100))  

    would be interesting for LIVE-CODING

    is there something predifined? like it will come up with microtonality/tuning

     

    2)

    and why does it work with simple-midi-sound (a list in :pan) and not with a player like conTimbre (there is something i don't understand with midi/players/etc)?

     

    thanx for a  hint

    andré

     

    an example:
    
    (setf omn '((5q c4 5q 5q 5q 5q 5q 5q 5q) 
                (-q)
                (e e e e e) 
                (-q)
                (7q 7q)
                (3q 3q) 
                (-q)
                (5q 5q 5q) 
                (7q 7q) 
                (3q 3q 3q 3q) 
                (e e) 
                (-q)
                (3q 3q 3q 3q 3q) 
                (e e e e e)))
    
    ;;;
    
    (def-score signature
               (:title "signature"
                       :key-signature 'atonal   
                       :time-signature '(4 4) 
                       :tempo 60)
      (instr
       ;:port 0 
       :omn (omn-replace :velocity (pick-norepeat 100 '(pppp ppppp ppp ppp pp p)) (length-diminution 4 (gen-repeat 10 omn)))
       :tuning (gen-white-noise 100 :scale 0.1)
       :pan '(1 1 1 1 1 1 1 1 10 30 1 1 1 100 100 80 77 15 100 100 100)
       :channel 1
       :sound 'gm-trumpet))
     

     


  6. I got a trial version of the new conTimbre-player-maxpatch (from thomas hummel), now the opusmodus-tuning also works well in conTimbre.

    I think it will be in the next update ... 🙂

     

    ...i like it more in cents then in float...

    (defun cents-to-tuning (centlist)
      (a*x 0.01 centlist))
    
    (cents-to-tuning '(-14 +50 5))
    => (-0.14 0.5 0.049999997)

     


  7. i already did that 🙂

    (defun add-rnd-dust (omnseq &key (span '(0.1)) (seed nil) (quantize '(1 2 3 4 5 6 7 8 9)) (scale 1.0) (tolerance 0.05))
      (let ((rhy (omn :length omnseq))
            (sp))
        (progn 
          (setf rhy (loop 
                      with cnt = 0
                      for i in rhy
    
                      do (setf sp (nth cnt span))
    
                      when (not (null seed))
                      do (incf seed)
                      
                      when (> i 0) 
                      collect   (+ i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      else collect (- i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      
                      when (< cnt (1- (length span)))
                      do (incf cnt)))
    
          (make-omn :length (quantize (float-to-ratio  rhy :ratio 1/1) quantize :scale scale :tolerance tolerance)
                    :pitch (omn :pitch omnseq)
                    :velocity (omn :velocity omnseq)
                    :articulation (omn :articulation omnseq)))))

     


  8. an example: 

     

    this is the BASIC-version (without "dust"):

    all mapped in 1/32 - retrograde sorting processes (with GEN-SORT):

    pitch-process from chromatic to 12tone-row (by sort) and from sorted length-values (all 1/32,

    then all 1/16 etc... to more complex/mixed pattern (by sort))

     

    Bildschirmfoto 2019-04-26 um 10.49.17.png

     

     

    with this setup:

     

    Bildschirmfoto 2019-04-26 um 10.49.48.png

     

     

    the result with some "dust":

    if you you have a look to the span-list above (compare with the new score) you will see:

    no change at the beginning, then more and more randomized (or made flexible).

     

    Bildschirmfoto 2019-04-26 um 10.48.35.png

     


  9. ;;; ADD-RND-DUST TO LENGTHS
    ;;; this function adding RANDOMLY some "dust" to the LENGTHS, so it will be like a little rubato,
    ;;; or "humanizing"-effect. the ADD-SPAN is in percent (0.1 = 10%) on each length-value. 
    
    (defun add-rnd-dust (omnseq &key (span '(0.1)) (seed nil) (quantize '(1 2 3 4 5 6 7 8 9)))
      (let ((rhy (omn :length omnseq))
            (sp))
        (progn 
          (setf rhy (loop 
                      with cnt = 0
                      for i in rhy
    
                      do (setf sp (nth cnt span))
    
                      when (not (null seed))
                      do (incf seed)
                      
                      when (> i 0) 
                      collect   (+ i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      else collect (- i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      
                      when (< cnt (1- (length span)))
                      do (incf cnt)))
    
          (make-omn :length (quantize (float-to-ratio  rhy :ratio 1/1) quantize)
                    :pitch (omn :pitch omnseq)
                    :velocity (omn :velocity omnseq)
                    :articulation (omn :articulation omnseq)))))
    
    
    
    ;;; EXAMPLE
    
    (add-rnd-dust '(h c3 h. d3 -h q. f3 q g3) 
                  :span '(0.5 0.3 0.2 0.1) 
                  :quantize '(1 2 3 4 8) 
                  :seed 123)
    
    => (ht c3 h.s. d3 -e -q -t e.._3h f3 3q_q g3)
        
    (add-rnd-dust '(q c3 q d3 q e3 q f3 q g3) 
                  ;;possible add-span per value (1 = 100% of the value, 0.5 = 50% etc.) 
                  ;;if it's a list, it will stay on the last value of the span-list
                  :span '(0.4 0.3 0 0 2) 
                  ;;how to quantize new lengths
                  :quantize '(1 2 4 8) 
                  :seed 123)
    
    => (q c3 qt d3 q e3 f3 hs. g3)
    
    
    (add-rnd-dust '(h c3 h. d3 h e3 q. f3 q g3) 
                  :span '(0.5) ;; = every value max-add 50%
                  :quantize '(1 2 3 4 8) 
                  :seed 2999)
    
    => (hs. c3 wt d3 3w.e e3 3wq. f3 q g3)
    
    
    (add-rnd-dust '(q c3 q d3 q e3 q f3 q g3) 
                  :span '(0.4 0.3 0 0 2) 
                  :quantize '(1 2 4 8) 
                  :seed 1111)
    
    => (qt c3 qs d3 q e3 f3 q... g3)
    
    
    (add-rnd-dust '(h c3 h d3 h e3 h f3 h g3) 
                  :span '(0.3 0.2 0.1 0 0.2) 
                  :quantize '(1 2 4 3 5) 
                  :seed 2999)
    
    => (5dh. c3 5dhq. d3 h e3 f3 he g3)

     


  10. the only problem seems to be, that it only works with CCL 1.12 on mojave... but this is not the official actual version in apple's appstore. so it don't work with 1.11.... 😕 

     

    does anyone know how to fix this problem?


  11. dear all

     

    does anyone have experience with an implementation of LISP in maxmsp?

    i'm looking for: "Max handling real time input, output, timing and control, letting Lisp handle variable handling and of course the processing of large amounts of data"

     

    max_desktop-edited-bg-1500px.jpg
    CYCLING74.COM

    Tools for sound, graphics, and interactivity

     

    does anyone tested this?

     

    3069010?s=400&v=4
    GITHUB.COM

    Lisper is an easy to use interface between Max/MSP and Common Lisp - thealexgraham/lisper

     

    thanx for a hint

    andré


  12. "My focus is on the ever-changing relationship that composers have with rules and procedures."

     

    some ideas/names...?

     

    => MOZART  https://en.wikipedia.org/wiki/Musikalisches_Würfelspiel

    => the LIGETI-analysis of BOULEZ's STRUCTURES ?

    => MESSIAEN in general: https://monoskop.org/File:Messiaen_Olivier_The_Technique_of_My_Musical_Language.pdf, or  specific "MODE DE VALEURS ET D'INTENSITÉS"

    => GOTTFRIED MICHAEL KöNIG

    => XENAKIS (the "ST"-pieces?)

    => HAUER https://de.wikipedia.org/wiki/Zwölftonspiel

     

     

     

     


  13. 1 hour ago, JulioHerrlein said:

    Thanks a lot, André !

    I´m trying to use your famous loops !

    All the Best !

    Happy 2019 !

    Julio

     

     

    i know, LOOPS are not very LISPian! but for me the most simple way "to think such processes" (more intuitive then recursion/iteration). and when the function/code is not to large it's not that important...

×
×
  • Create New...