Jump to content

AM

Members
  • Content Count

    538
  • Joined

  • Last visited

Posts posted by AM


  1. 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)


  2. 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)))

     


  3. 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

     


  4. 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))
     

     


  5. 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)

     


  6. 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)))))

     


  7. 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

     


  8. ;;; 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)

     


  9. 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?


  10. "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

     

     

     

     


  11. 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...


  12. have fun...

    greetings

    andré

     

    ;;; here is a MULTI-GEN-SORT -------------------------
    ;;; you could interlace different processes of SORTING
    
    
    (defun multi-gen-sort (lists &key (types nil) (sorts '>)  (steps nil) (seed nil))
      (let* ((sorted-lists (loop 
                            for i in lists
                            for cnt = 0 then (incf cnt)
                            collect (gen-sort i 
                                              :type (if (listp types)
                                                      (nth cnt types)
                                                      types)
                                              :sort (if (listp sorts)
                                                      (nth cnt sorts)
                                                      sorts)
                                              :step (if (listp steps)
                                                      (nth cnt steps)
                                                      steps)
                                              :seed seed))))
    
        (flatten (loop repeat (find-max (loop for i in sorted-lists collect (length i)))
                   for cnt = 0 then (incf cnt)
                   collect (loop for i in (reverse sorted-lists)
                             collect (nth cnt i))))))
        
    
    ;;; some examples
    
    
    (pitch-list-plot
     (flatten 
      (multi-gen-sort (list (expand-tonality '(c5 'chromatic)) 
                            (expand-tonality '(c3 'chromatic))
                            (expand-tonality '(c4 'chromatic))
                            (expand-tonality '(c6 'chromatic)))
                      :types '(selection insertion min-max selection)
                      :sorts '(> > > >)
                      :steps '(7 6 7 3)))
     :join-points t :point-radius 0 :style :fill)
    
    
    (pitch-list-plot
     (flatten 
      (multi-gen-sort (list (rnd-order (expand-tonality '(c5 'chromatic))) 
                            (rnd-order (expand-tonality '(c3 'chromatic)))
                            (rnd-order (expand-tonality '(c6 'chromatic)))
                            (rnd-order (expand-tonality '(c4 'chromatic))))
                      :types '(insertion selection min-max selection)
                      :sorts '(> < < >)
                      :steps '(5 3 7 nil)))
     :join-points t :point-radius 0 :style :fill)
    
    
    
    (pitch-list-plot
     (flatten 
      (multi-gen-sort (list (rnd-order (expand-tonality '(c6 'chromatic))) 
                            (rnd-order (expand-tonality '(c5 'chromatic)))
                            (rnd-order (expand-tonality '(c4 'chromatic)))
                            (rnd-order (expand-tonality '(c3 'chromatic))))
                      :types '(selection nil insertion min-max)
                      :sorts '(< > < >)
                      :steps '(4 4 4 4)))
     :join-points t :point-radius 0 :style :fill)
    
    
    
    (pitch-list-plot
     (filter-repeat 1
                    (flatten 
                     
                     (multi-gen-sort (list (rnd-order (expand-tonality '(c4 'chromatic))) 
                                           (rnd-order (expand-tonality '(cs4 'chromatic)))
                                           (rnd-order (expand-tonality '(d4 'chromatic)))
                                           (rnd-order (expand-tonality '(ds4 'chromatic))))
                                     :types '(insertion selection min-max selection)
                                     :sorts '(> < > <)
                                     :steps '(5 5 5 5))))
                    :join-points t :point-radius 0 :style :fill)
    
                                       
                                       
    ;;; a SORT2 :-)
    
    (pitch-list-plot
     (flatten 
      (gen-sort
       (flatten 
        (multi-gen-sort (list (rnd-order (expand-tonality '(c6 'chromatic))) 
                              (rnd-order (expand-tonality '(c5 'chromatic)))
                              (rnd-order (expand-tonality '(c4 'chromatic)))
                              (rnd-order (expand-tonality '(c3 'chromatic))))
                        :types '(selection nil insertion min-max)
                        :sorts '(< > > >)
                        :steps '(3 3 3 3)))
       :type 'insertion
       :step 7
       :sort '>))
     :join-points t :point-radius 0 :style :fill)

     

    some examples:

     

    exp1.jpeg

     

    exp2.jpeg

     

    exp4.jpeg

     

     

     

    a sorted mulit-gen-sort:

     

    exp3.jpeg

     

     


  13. hi julio

     

    it's too complicated to share the code...the FUNCTION is made for a specific idea of the work (not common), so it's made for MY need...

    here is a short sketch of the work... (part of it)

     

    a) generating a pitch-sequence => by using a 12-tone-seq + its expansion by a sorting-algorithm (with GEN-SORT) => an INTERVAL-order mutates to a SCALE (see the list-plot)

    b) pitches are projected on a sequence of symmetrical expanding/compressing FIELDS (with CHORD-CONTR...) => you see how the pitch-seq is contracted/exapnded in "space"

     

    - result is a kind of interference of this processes => at the end you see (in list-plot) that the interference is going more and more to ONE LEVEL - to a SCALE 

    - so its a kind of inside/out. the inherent structure, the inherent process/order is more and more recognizable during the process (start with compr/exp. 12-tone-row to the simple SCALE)

     

     

    example.jpeg

     

     

    the project is a bit larger. this sequence (which rhythm is based on a binary-event-filter (data of a jpeg of an artist))  is only the structural background (some ideas developed by LACHENMANN) - on this NET (the score you see) there will be other GESTALTS/MOTIFS etc...

    because my needs are such specific to my and my idea - most of the functions i had to code for myself, or modify/enlarge the OPMO functions, great that this is possible on this platform.

     

    sorry a bit complicated and i can't not describe it properly with a few words¬†ūüßź

     

     

     

     

×
×
  • Create New...