AM

(defun permute-by-rule (n rule row) (append (list row) (loop repeat n collect (setf row (position-filter rule row))))) ;; row => a row (or a list) ;; n => number of generations ;; rule => new position/order in every generation - keep attention it's 0-based!!! => for 12 pitches use 0 to 11 (permute-by-rule 20 '(2 0 1 5 11 3 8 6 4 9 10 7) (make-scale 'c4 12))

here is a function to MAP a 2d-field to chords (via intervals) // an idea i got from "Nierhaus - Algorithmic Composition" - Cellular Automata (p. 198). so you can "import/map" some GAME-OF-LIFE configurations or whatelse (a pixel photo?) // the PITCH-MAPPING is like in Miranda's CAMUS. ;; FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun 2d-field-to-chord (matrix &key (start 'c4) (merge-chords nil)) (let* ((int-horizontal (x+b (loop for x in (loop for i in matrix collect (position-item 1 i)) when (not (null x)) collect x) 1)) (int-vertical (x+b (loop repeat (length matrix) for n = 0 then (incf n) when (not (null (position-item 1 (nth n matrix)))) collect n) 1)) (chords (loop for h in int-horizontal for v in int-vertical append (loop for z in h collect (chordize (interval-to-pitch (list z v) :start start)))))) (if (null merge-chords) chords (chord-pitch-unique (chordize (flatten chords)))))) ;; interval-matrix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; numbers are intervals (inverted order then in the book) ;; (different sizes are possible) (setf matrix #|1 2 3 4 5 6 7 8 9 etc..|# #|1|# '((1 0 0 0 0 0 0 0 0 0 0 0) #|2|# (0 1 0 0 0 0 0 0 0 0 0 0) #|3|# (0 0 1 0 0 0 0 0 0 0 0 0) #|4|# (0 0 0 0 0 0 0 0 0 0 0 0) #|5|# (0 0 0 0 0 0 0 0 0 0 0 0) #|6|# (0 0 0 0 0 0 0 0 0 0 0 0) #|7|# (0 0 0 0 0 0 0 0 0 0 0 0) #|etc..|# (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 1 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 1 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0))) (2d-field-to-chord matrix) (2d-field-to-chord matrix :start 'd4) (2d-field-to-chord matrix :merge-chords t) (2d-field-to-chord matrix :merge-chords t :start 'd4) ;; as a scale (sort-asc (melodize (2d-field-to-chord matrix :merge-chords t))) ;; with rnd-generated field (by probability) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.97) (1 0.03)))))) (2d-field-to-chord matrix)) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.99) (1 0.01)))))) (2d-field-to-chord matrix :merge-chords t))

yes, but it's - in my opinion - not very clear like that. difference: what you see and... what you get... i always write it like this: '((-e e a3f4d5 q f4d5a5) (q a3e4c5 q e4c5a5) (-e e a3g4e5 h g4e5a5))) it makes more practical sense to me ... but my functions works for BOTH

violà... here's a solution... but: you have a wrong OMN-structure in your code (-e a3f4d5 q ... => a rest followed by a pitch, i corrected it (setf omnlist '((-e q f4d5a5) (q a3e4c5 q e4c5a5) (-e h g4e5a5))) (defun countbeats (omnlist &key (denom '1/8)) (loop for i in omnlist collect (/ (sum (abs! (flatten (omn :length i)))) denom))) (countbeats omnlist) => (3 4 5) (countbeats omnlist :denom 1/16) => (6 8 10)

your code would be very interesting

here is a pure LISP/CCL solution (loop for i from 1 to 100 collect (list (1+ (random 2)) i)) => ((1 1) (2 2) (2 3) (2 4) (1 5) (1 6) (1 7) (2 8) (1 9) (1 10) (1 11) (1 12) (2 13) (2 14) (1 15) (2 16) (2 17) (2 18) (2 19) (2 20) (1 21) (2 22) (2 23) (1 24) (2 25) (2 26) (1 27) (2 28) (2 29) (2 30) (2 31) (2 32) (2 33) (1 34) (2 35) (2 36) (1 37) (1 38) (2 39) (1 40) (1 41) (1 42) (1 43) (2 44) (2 45) (2 46) (2 47) (1 48) (2 49) (1 50) (2 51) (1 52) (2 53) (1 54) (1 55) (1 56) (2 57) (2 58) (1 59) (2 60) (1 61) (1 62) (1 63) (2 64) (1 65) (1 66) (2 67) (1 68) (1 69) (2 70) (2 71) (2 72) (1 73) (1 74) (2 75) (1 76) (1 77) (2 78) (2 79) (1 80) (2 81) (2 82) (1 83) (2 84) (2 85) (1 86) (1 87) (2 88) (2 89) (1 90) (2 91) (1 92) (1 93) (1 94) (2 95) (2 96) (2 97) (1 98) (1 99) (2 100)) as a function (defun pairs (n) (loop for i from 1 to n collect (list (1+ (random 2)) i))) (pairs 200)

if you are interested, i could show you some SOFTWARE to calculate really special tempo curves, in a very handy way. just write me a PM....

step by step => every code-line for itself cmd-E! i have also some LATENCY with conTimbre-player... but that's LISP in realtime the score player wasn't even intended to play things in parallel (i made a HACK from a HACK :-)). for precise POLYTEMPO things it is best to work via OSC and an external PLAYER (that's how I do it). I only need it in OPMO for sketching

i am very thankful for the HACK. lisp is not a language for real-time things, but for me it suits the approximate simulation perfectly!! thanx janusz!! but: you can try out how it is not to evaluate everything at once, step by step, maybe then there will be less LATENCY?

unfortunately i have no experience with DAW + polytempo... i always needed it for live-instrumental music

thanx, stephane! you are my OPMO-function-MASTER!

you will have the same DURATION when the pitch-loop and tempo-loop (tempo-progression = TIME) have the same length. so you have to stop the pitch-seq at the end of your BAR/tempo-seq!!! process should equal !? (gen-integer 110 60) (gen-integer 61 111)

great function, stephane!! little extension/different mapping ;;; a slightly extended version of stephane's FUNCTION ;;; with integer-output so you could map it on pitchfields/chords (defun pitch-trajectory* (nbpitch range tendency &key (variance 0.5) (type :around) (quantize 1/2) (smooth 1) filter-repeat seed (output 'int) (int-range '(0 24)) ) (setf seed (rnd-seed seed)) (do-verbose ("pitch-trajectory :seed ~s" seed) (let* ((values (gen-tendency nbpitch tendency :variance variance :type type :seed (seed))) (smoothedval (vector-smooth smooth values)) (out (cond ((equal output 'pitch) (vector-to-pitch range smoothedval :quantize quantize)) ((equal output 'int) (vector-round (car int-range) (cadr int-range) smoothedval))))) (if filter-repeat (filter-repeat filter-repeat out) out)))) ;;; pitch-ouput like in stephane's version (pitch-list-plot (pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1) :filter-repeat 1 :variance 0.8 :output 'pitch )) ;;; integer-output for MAPPING (list-plot (pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1) :filter-repeat 1 :variance 0.8 :output 'int :int-range '(0 23) )) ;;; MAPPING the integers on a scale or pitchfield (loop for i in (pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1) :filter-repeat 1 :variance 0.8 :output 'int :int-range '(0 23)) with scale = (make-scale 'c2 24 :alt '(1 2)) collect (nth i scale)) (loop for i in (pitch-trajectory* 128 '(fs3 g5) '(0.1 3 0.1) :filter-repeat 1 :variance 0.9 :output 'int :int-range '(0 23)) with scale = (make-scale 'c2 24 :alt '(2 1 6 5 4)) collect (nth i scale)) ;;; an example with MAPPING and SAMPLING (progn (setf seq (loop for i in (pitch-trajectory* 64 '(fs3 g5) '(0.1 3 0.1) :filter-repeat 1 :variance 0.4 :output 'int :int-range '(0 23)) with scale = (make-scale 'c2 24 :alt '(2 1 6 5 4)) collect (nth i scale))) (make-omn :pitch (loop repeat 20 collect (rnd-sample-seq (rnd-pick '(11 17 29)) seq)) :length (pick-norepeat 20 '(t t. s -t. -t)) :span :pitch))

great, that it works fine now! greetings andré

halleluja!!! thanks!!!!

POLYTEMPO: here is an easy solution to play POLYTEMPO-textures in OPMO in every "play-tempo-stream" you can write for 4 instruments... then put it in (progn... // then choose different tempos and PLAY it greetings andré p.s. if you want to do it like CONLON then write a list with tempos/beats in :tempo-curve ... example: "tempoverlauf per BEAT" ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; damit kannst du einfach dann OMN's eingeben, pro tempo-stream 4 instrumente und dann abspielen, ;; streams überlagernd abspielen (defun play-tempo-stream (&key (inst1 nil) (inst2 nil) (inst3 nil) (inst4 nil) (port 0) (tempo-curve 60)) (def-score stream (:key-signature 'chromatic :time-signature (get-time-signature (omn-to-time-signature inst1 '(1 4))) :tempo tempo-curve :layout (list (bracket-group (treble-layout 'inst1) (treble-layout 'inst2) (treble-layout 'inst3) (treble-layout 'inst4)))) (inst1 :omn inst1 :port port :channel 1 :pan 20) (inst2 :omn inst2 :port port :channel 2 :pan 20) (inst3 :omn inst3 :port port :channel 3 :pan 20) (inst4 :omn inst4 :port port :channel 4 :pan 20)) (score-player 'stream)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; some "random omn" to play (setf p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e 3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; 3 streams mit je 3 instrumenten ;; konstantes tempo (progn (play-tempo-stream :inst1 p1 :inst2 p1 :inst3 (gen-retrograde p1) :tempo-curve 30 :port 0) (play-tempo-stream :inst1 (pitch-transpose 11 p1) :inst2 (pitch-transpose 12 p1) :inst3 (pitch-transpose 13 (gen-retrograde p1)) :tempo-curve 50 :port 0) (play-tempo-stream :inst1 (pitch-transpose -11 p1) :inst2 (pitch-transpose -12 p1) :inst3 (pitch-transpose -13 (gen-retrograde p1)) :tempo-curve 70 :port 0)) ;;; tempoverlauf per BEAT (progn (play-tempo-stream :inst1 p1 :inst2 p1 :inst3 (gen-retrograde p1) :tempo-curve '((100 1) (160 1) (172 1)) ;; tempo per beat :port 0) (play-tempo-stream :inst1 (pitch-transpose 11 p1) :inst2 (pitch-transpose 12 p1) :inst3 (pitch-transpose 13 (gen-retrograde p1)) :tempo-curve '((122 1) (177 1) (201 1)) ;; tempo per beat :port 0) (play-tempo-stream :inst1 (pitch-transpose -11 p1) :inst2 (pitch-transpose -12 p1) :inst3 (pitch-transpose -13 (gen-retrograde p1)) :tempo-curve '((63 1) (62 1) (67 1)) ;; tempo per beat :port 0))

thanx to all, but the problem is not solved, try?! (def-instrument-set group1 :instruments (:group group1 :trumpet (:layout trumpet-layout :port 0 :channel 1 :pan (pan 0) :volume 92) :piano (:layout piano-grand-layout :port 0 :channel 2 :pan (pan 10) :volume 92) :sine (:layout treble-layout :port 0 :channel 3 :pan (pan -10) :volume 92) :noise (:layout treble-layout :port 0 :channel 4 :pan (pan -5) :volume 92))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setf p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e 3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4)) (ps 'group1 :trumpet p1 :piano (list (gen-retrograde p1) (gen-retrograde p1)) :tempo '((88 1) (89 1) (100 1)) :time-signature '(1 4 10)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

why does the trumpet and the piano part both "sended" and displayed as "trumpet", played only on channel 1 ? i do not understand what's my mistake... thanx for some help (def-instrument-set group1 :instruments (:group group1 :trumpet (:layout trumpet-layout :port 0 :channel 1 :sound 'gm-trumpet :pan (pan 0) :volume 92) :piano (:layout piano-layout :port 0 :channel 2 :sound 'gm-piano :pan (pan 10) :volume 92) :sine (:layout treble-layout :port 0 :channel 2 :sound 'gm :controllers nil :pan (pan -10) :volume 92) :noise (:layout treble-layout :port 0 :channel 2 :sound 'gm :controllers nil :pan (pan -5) :volume 92))) (midi-destinations) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setf p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e 3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4)) (ps 'group1 :trumpet p1 :piano (gen-retrograde p1) :output :midi :tempo '((88 1) (89 1) (100 1)) :time-signature '(1 4 10))

ANTON WEBERN - Variationen für Klavier Op.27, I converted into BINARY INFORMATION // "Verdoppelung der Welt" // (inspired by Armin Nassehi's Book "Muster - Theorie der digitalten Gesellschaft") Bildschirmaufnahme 2022-01-29 um 13.10.42.mov

but happend again the solution is to quit/start OPMO - but not a big problem, i'm happy...

this little CONCEPTUAL project goes on: converting "something" (musical paramters in this case) into a binary form and reconvert it (binary back into musical parameters) => like kind of A/D-D/A-converters and have a look how "the reality is different/changing", experimenting with mapping/resolution etc... i don't think primarily musically with this work but more technically and see what results from that. ;;; SUB (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)) (defun length/rest-to-binary (alist) (loop for i in alist when (length-restp i) collect 0 else collect 1)) ;;;; CONVERTING PITCH/LENGTH or VELOCITY TO BINARY INFORMATION (defun convert-to-binary (alist &key (parameter 'pitch) (lengthspan '(24 100)) (velocity-resolution 127) (pitch-resolution 127) (bitlength 7)) (let ( (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)))) alist)))) (cond ((pitchp (car alist)) (progn (setf alist (pitch-to-midi (pitch-melodize alist))) (fill-to-x-bit (decimal-to-binary (vector-round 1 (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 (car lengthspan) (cadr lengthspan) (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))))) ;;;; CONVERTING BINARY INFORMATION BACK TO OMN (defun convert-to-omn (binlist &key (parameter 'pitch) (lengthspan '4/4) (length/rest nil) (velocityspan '(pppp ffff)) (pitchspan '(c3 c5)) (bitlength 8)) (let ((binlist (gen-divide bitlength (flatten binlist)))) (cond ((equal parameter 'pitch) (midi-to-pitch (vector-round (car (pitch-to-midi pitchspan)) (cadr (pitch-to-midi pitchspan)) (binary-to-decimal binlist)))) ((equal parameter 'length) (if (null length/rest) (gen-length-constant (binary-to-decimal binlist) lengthspan) (loop for i in (gen-length-constant (binary-to-decimal binlist) lengthspan) for j in length/rest when (= j 0) collect (* i -1) else collect i))) ((equal parameter 'velocity) (vector-to-velocity (car (get-velocity (list (car velocityspan)))) (car (get-velocity (list (cadr velocityspan)))) (loop for i in (binary-to-decimal binlist) collect (* i (float (/ 1 (sum (binary-to-decimal binlist))))))))))) evaluate here and you see the original and reconverted SAMPLE ;;; SOME EXAMPLES OF THE PROCESS SEQ to BINARY, THEN MAPPED BACK TO OMN ;;; IF THE BITLENGTHS ARE DIFFERENT YOU GET DIFFERENT RESulTS ;;; ALSO DIFFERENT RESULTS WITH VELOCITY / LENGTHS => it depends on RESOLUTION etc... ;; cmd-E or cmd-1 (pitch-list-plot (list (setf seq '(c4 cs5 fs3 c5 f5) );; original (convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted :bitlength 32 :pitchspan (get-ambitus seq :type :pitch))) :join-points t) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (length-list-plot (list (setf seq '(-e e -q h e)) ;; original (convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted :parameter 'length :length/rest (length/rest-to-binary seq) :bitlength 32 :lengthspan '4/4)) :join-points t) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (velocity-list-plot (list (setf seq '(p p ffff mp )) ;; original (convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted :parameter 'velocity :bitlength 32 :velocityspan '(ppp mf))) :join-points t) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

i restarted opusmodus and now it works

also this do not work (setf voice1 '(-d_whs s f4 ppp g4 e4 fs4 e4 fs4 fs4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s cs4 g4 - fs4 e4 d4 fs4 -d_whs s fs4 g4 e4 e4 fs4 e4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s f4 f4 fs4 fs4 e4 e4 e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s f4 f4 g4 g4 f4 f4 f4 -d_whs s d4 d4 -e s d4 - f4 -d_whs s e4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s d4 g4 - e4 fs4 - e4 -d_whs s f4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s d4 eb4 -e s d4 - e4)) (omn-to-time-signature voice1 '(4 4)) > Error: There is no applicable method for the generic function: > #<standard-generic-function omn-symbol #x3020009144EF> > when called with arguments: > (nil) > While executing: #<ccl::standard-kernel-method no-applicable-method (t)>, in process Listener-2(8). > Type cmd-/ to continue, cmd-. to abort, cmd-\ for a list of available restarts. > If continued: Try calling it again > Type :? for other options.

it's not working on my system