AM

thank you torsten - this MIDI-thing is too complicated for me (i don't know how to send, nothing happens). TUNING works properly with UVIworkstation (ircam solo-instrments). so it stays a BLACKBOX-thing why conTimbre doesn't work

the only answer i got was that it works with "midi pitch bend" and with MAX. ConTimbre: "With Max you can just send floating point pitches, and with MIDI you can either send pitch bend values, but that always affects the whole voice. But you can also detune every key and, for example, use several Voices with the same timbre, but they have mutually detuned keyboards to get more than 128 pitches. " this will probably not solve the problem. maybe it would be best if OPMO's and ConTimbre's guys communicate directly? that would be in the interest of both companies...(?)

i have written them (CT) a mail now to get some more information

program-changes are no problem but how to make pitch-bend via opusmodus....? here is the MANUAL: ePlayer_Manual_Mac_english.pdf i know, but i will need microtonal-NOTATION

yes, of course - from "BOTs" to a lot of small simple FUNCTIONS... but: not very well/smart coded () - i'm musician but only an "amateur programmer" with few experience - and it's really NOT well documentated for other users. and another point, i have no idea how do that professionally with GUTHUB and these installation-things as ORDINARY text - no problem. perhaps i will share it like that on my website...

- it works not as it should for conTimbre. conTimbre works well with SIBELIUS (via pitch-bend-messages in the score like ~B0,64 or ~B0,90, like that) => no idea what i shoud do in OPMO? - TUNING: don't work with conTimbre - another thing is, i can't work well with OPMO+microtonality, when it's not possible to have microtonal-notation => so i will do it in SIBELIUS

perhaps OPMO could extend its GEN-ROTATE like that (or use this CODE for it)... not only single-steps, also a list of steps... ;;; SIMPLE FUNCTION (defun gen-rotate* (alist seq) (loop for i in alist collect (setf seq (gen-rotate i seq)))) ;;; EXAMPLES (list-plot (flatten (gen-rotate* '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18) '(1 2 3 4 5 6 7 8 9 10))) :join-points t :point-radius 0 :style :fill) (list-plot (gen-rotate* '(9 8 7 6 5 4 3 2 1) '(1 2 3 4 5 6 7 8 9 10)) :join-points t :point-radius 0 :style :fill) (list-plot (flatten (gen-rotate* '(1 2 3 4 5 4 3 2 1) '(1 2 3 4 5 6 7 8 9 10))) :join-points t :point-radius 0 :style :fill) (list-plot (gen-rotate* '(1 2 3 4 5 4 3 2 1) '(1 2 3 4 5 6 7 8 9 10)) :join-points t :point-radius 0 :style :fill)

yes, i saw this also (fermata and the stacc-effect) greetings andré

thank you torsten - as i see, i would need some help/support. but there is also no solution for microtonal-notation in opmo yet... but ...time will come

RESPELL/ENHARMONIC here is a solution for that (i hope i got all cases) - could be usefull in OPMO - it was/is a explode/compress-thing of the pitch-symbols and to think about all cases. please check it!! greetings andré (defun enharmonic* (pitches) (let ((liste '((cs db) (ds eb) (e fb) (es f) (fs gb) (gs ab) (as bb) (b cb) (bs c)))) (loop for n in pitches collect (let ((octave (car (last (explode n)))) (pitchname (compress (butlast (explode n))))) (append (compress (list (car (set-difference (loop for i in liste ;; cases with octave-change when (or (and (equal i '(bs c)) (equal pitchname 'bs)) (and (equal i '(b cb)) (equal pitchname 'b))) do (setf octave (1+ octave)) when (or (and (equal i '(bs c)) (equal pitchname 'c)) (and (equal i '(b cb)) (equal pitchname 'cb))) do (setf octave (1- octave)) ;; ordinary cases when (member pitchname i) append i) (list pitchname))) octave))))))) (enharmonic* '(fb4 fb4 cb5)) => (e4 e4 b4) (enharmonic* '(f4 b7)) => (es4 cb8) (enharmonic* '(bs4 cs5 cb5)) => (c5 db5 b4) (enharmonic* '(c6 gs7 gb4)) => (bs5 ab7 fs4)

thank you, torsten! by now I have noticed that too (equalp in LISP)

short question: is it possible to add a text-attribute to/above a rest? i didn't find a solution for that... for post-editing my score i would like to delete/augment/... specific values... for example: AUGMENT rest number 12, or DELETE pitch number 27 (like every EVENT woud has its number) - to do that i numbered all the pitches in the score, but seems not possible to number (by adding text-attributes) the rest-values?? it's no problem to extend the EVENTS by any extra-data-slots (i wrote such a function), but i don't know how to display text above RESTS? thanx for help andré

here are 2 sound-examples of such a process - evaluate the FUNCTIONS: incf/decf-alist and round-to - evaluate example with cmd2/cmd3 - have a look to the list-plot (progn (setf durations (rnd-number 10 1 19 :prob 0.4)) (setf seq1 (append (make-omn :length (gen-length (flatten (incf/decf-alist 100 (rnd-order durations) :steps (rnd-number 10 1 5 :prob 0.2) :end 2)) 32) :pitch '(c4) :velocity '(pp)) (make-omn :length (gen-length (flatten (incf/decf-alist 100 (rnd-order durations) :steps (rnd-number 10 1 5 :prob 0.2) :end 3)) 32) :pitch '(b4) :velocity '(f)) (make-omn :length (gen-length (reverse (flatten (incf/decf-alist 100 (rnd-order durations) :steps (rnd-number 10 1 5 :prob 0.2) :end 1))) 32) :pitch '(f4) :velocity '(mf))))) (length-list-plot (omn :length seq1)) (progn (setf durations (rnd-number 10 1 7 :prob 0.4)) (setf seq2 (make-omn :length (gen-length (append (reverse (flatten (incf/decf-alist 50 (setf list (rnd-order durations)) :steps (rnd-number 10 1 5 :prob 0.2) :end 2))) (flatten (incf/decf-alist 50 list :steps (rnd-number 10 1 5 :prob 0.2) :end 1))) 32) :pitch '(f4) :velocity '(mf)))) (length-list-plot (omn :length seq2))

a less flexible version but with nicer output/usage... greetings (defun round-to (number precision &optional (what #'round)) (let ((div (expt 10 precision))) (/ (funcall what (* number div)) div))) ;;; (defun incf/decf-alist (n alist &key (steps '(1 2)) (end 1)) (let ((span (round-to (/ n (length alist)) 0))) (progn (setf alist (loop for start in alist for step in (if (< (length steps) (length alist)) (filter-first (length alist) (loop repeat (length alist) append steps)) steps) when (> start end) collect (loop for i from start downto end by step collect i) else collect (loop for i from start to end by step collect i))) (setf alist (loop for i in alist collect (append i (gen-repeat (- span (length i)) end)))) (loop repeat (length (car alist)) for cnt = 0 then (incf cnt) collect (loop for i in alist collect (nth cnt i)))))) (list-plot (flatten (incf/decf-alist 90 '(9 8 7 1 7 30 8 7 6 1) :steps '(1 2 1 3 1 5 3 1 2 1) :end 11)) :join-points t) =>((9 8 7 1 7 30 8 7 6 1) (10 10 8 4 8 25 11 8 8 2) (11 11 9 7 9 20 11 9 10 3) (11 11 10 10 10 15 11 10 11 4) (11 11 11 11 11 11 11 11 11 5) (11 11 11 11 11 11 11 11 11 6) (11 11 11 11 11 11 11 11 11 7) (11 11 11 11 11 11 11 11 11 8) (11 11 11 11 11 11 11 11 11 9))

use it or not... greetings andré ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; count-up/down => not well coded but it works ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; A FUNCTION which counts a integer-list from its values (individual) ;;; to value B (all the same end-value :to (default is 1)) ;;; n => how many output values (approx: depends on input/round... was not important for my project) ;;; up or down (default is 'down) ;;; with variabel STEPS => sequencieally (horizontal) or with steps for each value individiual (vertical) ;;; with COUNT => means how many lists with same values (like "global-steps") ;;; SUB (defun round-to (number precision &optional (what #'round)) (let ((div (expt 10 precision))) (/ (funcall what (* number div)) div))) ;;; MAIN (defun count-up/down (n intlist &key (steps '(1)) (count 1) (type 'horizontal) (direction 'down) (to 1)) (let* ((cycles (round-to (/ (1- n) (length intlist)) 0)) (intlists (cond ((equal type 'horizontal) (loop repeat cycles for cnt = 0 then (incf cnt) for stp in (if (< (length steps) cycles) (filter-first cycles (flatten (gen-repeat cycles steps))) steps) when (= cnt 0) append (loop repeat count collect intlist) when (integerp (/ cnt count)) collect (setf intlist (if (equal direction 'down) (loop for i in intlist when (>= (- i stp) to) collect (- i stp) else collect to) (loop for i in intlist when (<= (+ i stp) to) collect (+ i stp) else collect to))) else collect intlist)) ((equal type 'vertical) (loop repeat cycles for cnt = 0 then (incf cnt) when (= cnt 0) append (loop repeat count collect intlist) when (integerp (/ cnt count)) collect (setf intlist (if (equal direction 'down) (loop for i in intlist for stp in steps when (>= (- i stp) to) collect (- i stp) else collect to) (loop for i in intlist for stp in steps when (<= (+ i stp) to) collect (+ i stp) else collect to))) else collect intlist))))) (loop repeat cycles for x in intlists collect x))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SIMPLE EXAMPLES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 9 8 7 6 7) :to 3 :direction 'down)) :join-points t) => ((9 8 7 6 7 9 8 7 6 7) (8 7 6 5 6 8 7 6 5 6) (7 6 5 4 5 7 6 5 4 5) (6 5 4 3 4 6 5 4 3 4) (5 4 3 3 3 5 4 3 3 3) (4 3 3 3 3 4 3 3 3 3) (3 3 3 3 3 3 3 3 3 3) (3 3 3 3 3 3 3 3 3 3) (3 3 3 3 3 3 3 3 3 3) (3 3 3 3 3 3 3 3 3 3)) (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 9 8 7 6 7) :count 2 :to 5 :direction 'down)) :join-points t) => ((9 8 7 6 7 9 8 7 6 7) (9 8 7 6 7 9 8 7 6 7) (8 7 6 5 6 8 7 6 5 6) (8 7 6 5 6 8 7 6 5 6) (7 6 5 5 5 7 6 5 5 5) (7 6 5 5 5 7 6 5 5 5) (6 5 5 5 5 6 5 5 5 5) (6 5 5 5 5 6 5 5 5 5) (5 5 5 5 5 5 5 5 5 5) (5 5 5 5 5 5 5 5 5 5)) (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 9 8 7 6 7) :to 15 :direction 'up)) :join-points t) => ((9 8 7 6 7 9 8 7 6 7) (10 9 8 7 8 10 9 8 7 8) (11 10 9 8 9 11 10 9 8 9) (12 11 10 9 10 12 11 10 9 10) (13 12 11 10 11 13 12 11 10 11) (14 13 12 11 12 14 13 12 11 12) (15 14 13 12 13 15 14 13 12 13) (15 15 14 13 14 15 15 14 13 14) (15 15 15 14 15 15 15 15 14 15) (15 15 15 15 15 15 15 15 15 15)) (list-plot (flatten (count-up/down 200 '(9 8 7 6 7 9 8 7 6 7) :count 2 :to 15 :direction 'up)) :join-points t) => ((9 8 7 6 7 9 8 7 6 7) (9 8 7 6 7 9 8 7 6 7) (10 9 8 7 8 10 9 8 7 8) (10 9 8 7 8 10 9 8 7 8) (11 10 9 8 9 11 10 9 8 9) (11 10 9 8 9 11 10 9 8 9) (12 11 10 9 10 12 11 10 9 10) (12 11 10 9 10 12 11 10 9 10) (13 12 11 10 11 13 12 11 10 11) (13 12 11 10 11 13 12 11 10 11) (14 13 12 11 12 14 13 12 11 12) (14 13 12 11 12 14 13 12 11 12) (15 14 13 12 13 15 14 13 12 13) (15 14 13 12 13 15 14 13 12 13) (15 15 14 13 14 15 15 14 13 14) (15 15 14 13 14 15 15 14 13 14) (15 15 15 14 15 15 15 15 14 15) (15 15 15 14 15 15 15 15 14 15) (15 15 15 15 15 15 15 15 15 15) (15 15 15 15 15 15 15 15 15 15)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; MORE COMPLEX/INTERESTING EXAMPLES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; horizontal means every cycle has a new step-value (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 15 8 7 6 7) :steps '(1 2 1 1 1 1 1 1 1 1) :type 'horizontal :to 2)) :join-points t) => ((9 8 7 6 7 15 8 7 6 7) (8 7 6 5 6 14 7 6 5 6) (6 5 4 3 4 12 5 4 3 4) (5 4 3 2 3 11 4 3 2 3) (4 3 2 2 2 10 3 2 2 2) (3 2 2 2 2 9 2 2 2 2) (2 2 2 2 2 8 2 2 2 2) (2 2 2 2 2 7 2 2 2 2) (2 2 2 2 2 6 2 2 2 2) (2 2 2 2 2 5 2 2 2 2)) ;; vertical means every value has its individual step (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 30 8 7 6 7) :steps '(1 2 1 1 1 5 1 1 1 1) :type 'vertical :to 2)) :join-points t) => ((9 8 7 6 7 30 8 7 6 7) (8 6 6 5 6 25 7 6 5 6) (7 4 5 4 5 20 6 5 4 5) (6 2 4 3 4 15 5 4 3 4) (5 2 3 2 3 10 4 3 2 3) (4 2 2 2 2 5 3 2 2 2) (3 2 2 2 2 2 2 2 2 2) (2 2 2 2 2 2 2 2 2 2) (2 2 2 2 2 2 2 2 2 2) (2 2 2 2 2 2 2 2 2 2)) (list-plot (flatten (count-up/down 100 '(9 8 7 6 7 30 8 7 6 7) :steps '(1 2 1 3 1 5 3 1 2 1) :type 'vertical :to 1)) :join-points t) could be extended: would be nice if the END-VALUE (:to) would/could be also "in between" the start values... start '(6 7 5 1 2 3 9 19) => :to 4 => values incf, and decf to 4

i did not realize that there is an OPMO-function for that in OPMO: (setf omn-seq '(s c4 ffff e e s e. s q q q q q)) (length-map '((1/16 mp) (2/16 pp) (3/16 ppp)) omn-seq) => (s c4 mp e pp c4 s mp e. ppp s mp q ffff c4 c4 c4 c4)

....you are totally right!!!! i did not know this function, i did not find it when i was searching so, perhaps somebody could need/read my function "as a LISP-example"... in OPMO: (setf omn-seq '(s c4 ffff ord e ord e ord s ord e. ord s ord q ord q q q q)) (length-map '((1/16 mute) (2/16 pizz) (3/16 arco)) omn-seq) => (s c4 ffff mute e pizz c4 pizz s mute e. arco s mute q ord c4 c4 c4 c4)

if you like to change the articulation of specific lengths (defun replace-articulation-of-a-length (omnseq length/articulation-map) (loop for i in (single-events (flatten omnseq)) when (length-restp (car i)) collect i else append (omn-replace :articulation (cadr (assoc (car (omn :length i)) length/articulation-map)) i))) (setf omn-seq '(s c4 ffff ord e ord e ord s ord e. ord s ord q ord q q q q)) (replace-articulation-of-a-length omn-seq '((1/16 mute) (2/16 pizz) (3/16 arco))) => (s c4 ffff mute e c4 ffff pizz e c4 ffff pizz s c4 ffff mute e. c4 ffff arco s c4 ffff mute q c4 ffff ord q c4 ffff q c4 ffff q c4 ffff q c4 ffff)

if you like to change dynamics/velocity of specific lengths (defun replace-velocity-of-a-length (omnseq length/velocity-map) (loop for i in (single-events (flatten omnseq)) when (length-restp (car i)) collect i else append (omn-replace :velocity (cadr (assoc (car (omn :length i)) length/velocity-map)) i))) (setf omn-seq '(s c4 ffff e e s e. s q q q q q)) (replace-velocity-of-a-length omn-seq '((1/16 mp) (2/16 pp) (3/16 ppp))) => (s c4 mp e c4 pp e c4 pp s c4 mp e. c4 ppp s c4 mp q c4 ffff q c4 ffff q c4 ffff q c4 ffff q c4 ffff)

in my personal view: - for algorithmic composition ...you have first to be a composer/musician - because it's a lot more about music then about code (i learned a little bit to code, because i was interested in this "kind of thinking" about art and music - so, i think, if you want to work with algorithms you have to handle some code (like in music you have to handle some pitches/sound/rhythms) - when you have a look to the history of algorithmic composition you see some software like: common music, open music, pwgl, patchwork, also supercollider or MAX etc, it has always to do with computer/code/algorithm. also PWGL, commonmusic, openmusic... are working with LISP (or parts of it), so i think, that's the thing. mostly i like in OPUSMODUS the direct connection to the SCORE etc... i like it also because it's very OPEN for some own things/code/ideas (because it's close to the basic COMMON LISP)... - you could work with all the EXAMPLES in the library, take it, do some smooth changes and have a look what happens... greetings andré

something like that

no problem on my OPMO

some LISP tutorials... http://lisp.plasticki.com/show?H9 https://curry.ateneo.net/~jpv/cs171/LispTutorial.pdf https://www.cs.cmu.edu/~dst/LispBook/book.pdf https://www.cs.umd.edu/~nau/cmsc421/norvig-lisp-style.pdf or paper in GERMAN... https://www.amazon.de/Programmieren-COMMON-LISP-Otto-Mayer/dp/3860257102

i think it's very helpful. you could code also your own FUNCTIONS - you would learn to understand how it works - and it helps to handle opusmodus. there is an enormous potential in it.... greetings andré

is there an RESPELL-function which would change sharps into flats and flats into sharps for single pitch-values? enharmonic changes.... like: (enharmonic 'cs4) => db4 (enharmonic 'db4) => cs4 but there is an other solution for an EQUALP* whicht is "independent" from pitch-name (enharmonic)... but a function like ENHARMONIC or EQUALP* could be useful (for pattern-match etc)... (defun equalp* (a b) (equal (pitch-to-midi a) (pitch-to-midi b))) (equalp* 'cs4 'db4) => t there is an EQUALP in the system (but not documented), and works like that (equalp 'cs4 'db4) => nil (equalp 'cs4 'cs4) => t :