AM

liitle example: here a little extra-function -> splittering am melody... + hoquetus.4 (take the function from last post) regards andré ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;gen-hoquetus.4 + time-splittered-melody;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;andré meier / 27-4-2016 ;;;hoquetus.4 with a extra-funny-melody-splittered-function ;;;good night and good luck! ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;extra-functions;;;;;;;;;splittering-melody;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun weighted-t/nil (on-weight) (let ((off-weight (- 1 on-weight))) (weighted-random (list (list 't on-weight) (list 'nil off-weight))))) (defun splittering-length-seq (lengths &key (possible-lengths '(1 2 3 4)) (rest-weight 0.5) (rhy-factor 1/32)) (loop for i in lengths when (> i 0) collect (loop for j in (rnd-sum i possible-lengths) collect (if (equal (weighted-t/nil rest-weight) 't) (* j -1 rhy-factor) (* j rhy-factor))) else collect (list (* i rhy-factor)))) (defun add-pitch-seq-to-splittered-length-seq (length-seq pitch-seq) (loop for i in length-seq with cnt = 0 append (loop for j in i when (> j 0) collect (nth cnt pitch-seq)) do (incf cnt) when (> cnt (length pitch-seq)) do (setq cnt 0))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun time-splitterd-melody (length-seq pitch-seq &key (possible-lengths '(1 2 3 4)) (rest-weight 0.5) (rhy-factor 1/32)) (make-omn :length (setq lengths (splittering-length-seq length-seq :possible-lengths possible-lengths :rest-weight rest-weight :rhy-factor rhy-factor)) :pitch (add-pitch-seq-to-splittered-length-seq lengths pitch-seq))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;OMN_EXAMPLE HOQUETUS + TIME_SPLTTERED_MELODY :;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setq values (flatten (time-splitterd-melody '(16 16 16 16 16 16 16 16 16 16 32 16 16 32) '(c5 d5 e5 c5 c5 d5 e5 c5 e5 f5 g5 e5 f5 g5) :rest-weight 0.5))) (setq lengths (omn :length values)) (setq pitches (omn :pitch values)) (setq pos-durations (car (last (loop for i in lengths with cnt = 0 when (> i 0) collect (incf cnt))))) (setq instrumentation (loop repeat pos-durations collect (rnd-pick '(((pno ponte ppp)) ; only an example ((vn pizz p)) ((vn pizz f) (va ponte f)) ((pno tasto ff)) ((pno pizz fff)) ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp)) ((trp mute pp) (vn ponte mf)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-score hoquetus.4 (:key-signature '(c maj) :time-signature '(4 4) :tempo '(120) :layout (bracket-group (trumpet-layout 'trumpet) (piano-grand-layout 'piano) (violin-layout 'violin) (viola-layout 'viola) (violoncello-layout 'violoncello))) (trumpet :omn (gen-hoquetus.4 'trp :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (piano :omn (gen-hoquetus.4 'pno :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violin :omn (gen-hoquetus.4 'vn :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (viola :omn (gen-hoquetus.4 'va :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violoncello :omn (gen-hoquetus.4 'vc :pitch pitches :length lengths :instrument-list instrumentation) :channel 1))

;; gen-hoquetus.4 https://en.wikipedia.org/wiki/Hocket ;;; andré meier / 27-4-2016 ;;; write a instrumentation-list (instrument + techniques + velocity), pitch-list ;;; and length-list. the gen-hoquetus-function will split the melody ;;; off... in any possibilities, techniques/articulations/velocities will be added ;;; this is only a function i coded for my actual work... perhaps you could use ;;; it or code it properly :-) ;;; HAVE FUN! regards, andré (setq instrumentation '(((pno ponte ppp)) ((vn pizz p)) ((vn pizz f) (va ponte f)) ((pno tasto ff)) ((pno pizz fff)) ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp)) ((trp mute pp) (vn ponte mf)))) ;; mainfuction: (defun gen-hoquetus.4 (filtered-instrument &key pitch length instrument-list) (let ((events (generate-events.4 length pitch :optional_data instrument-list))) (filtering-color.4 filtered-instrument events))) (gen-hoquetus.4 'vn :pitch '(c4 d4 e5 f6) :length '(1/32 2/32 3/32 4/32) :instrument-list instrumentation) ;; subfunctions (defun generate-events.4 (durations pitches &key (velocity '(mf)) (articulation '(-)) (optional_data 'nil)) (loop repeat (length durations) with cnt-d = 0 with cnt-rest = 0 when (> (nth cnt-d durations) 0) collect (list (nth cnt-d durations) (nth cnt-rest pitches) (nth cnt-rest velocity) (nth cnt-rest articulation) (nth cnt-rest optional_data)) and do (incf cnt-rest) and do (incf cnt-d) else collect (list (nth cnt-d durations) 'nil 'nil 'nil 'nil) and do (incf cnt-d))) (generate-events.4 '(1 2 -3 4) '(60 61 62) :optional_data instrumentation) (defun filtering-color.4 (selected-color event-stream) (loop for i in event-stream with match = 0 append (loop for x in (fifth i) when (equal (first x) selected-color) do (setq articulation (second x) velocity (third x)) and do (setq match 1)) when (and (= match 1) (> (first i) 0)) append (list (first i) (second i) velocity articulation) else collect (* -1 (abs (first i))) do (setq match 0))) (filtering-color.4 'vn (generate-events.4 (gen-length '(1 -100 2 3 4 5) 1/32) '(c4 d4 e4 e5) :optional_data instrumentation)) ;; OMN_EXAMPLE: (setq pitches (midi-to-pitch '(60 61 62 63 64 65 66 67 68 69 70))) ; only an example (setq lengths (gen-length '(1 2 3 -4 5 6 5 -4 3 -2 1) 1/16)) ; only an example (setq instrumentation (loop repeat 10 collect (rnd-pick '(((pno ponte ppp)) ; only an example ((vn pizz p)) ((vn pizz f) (va ponte f)) ((pno tasto ff)) ((pno pizz fff)) ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp)) ((trp mute pp) (vn ponte mf)))))) (def-score hoquetus.4 (:key-signature '(c maj) :time-signature '(4 4) :tempo '(120) :layout (bracket-group (trumpet-layout 'trumpet) (piano-grand-layout 'piano) (violin-layout 'violin) (viola-layout 'viola) (violoncello-layout 'violoncello))) (trumpet :omn (gen-hoquetus.4 'trp :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (piano :omn (gen-hoquetus.4 'pno :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violin :omn (gen-hoquetus.4 'vn :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (viola :omn (gen-hoquetus.4 'va :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violoncello :omn (gen-hoquetus.4 'vc :pitch pitches :length lengths :instrument-list instrumentation) :channel 1))

a new question/wish for piano or any special-techniques on any instrument like perhaps: "guirro fingernail" or "hit the conductor!" :-), i would like to write this as a articulation/technique-name (like now pizz..).. so that i could map it with (def-sound-set..) thanx! andré

(def-sound-set gm-violin :programs (:group violin ord 40 tasto 42 ponte 44 pizz 46 slap 48 legno-batt 50 batt+legno 60 ;;; -> no program-change sended arco 52))

thank you!! it works with the "define articulations names", but not with "+" = it sends no programm-change (but written "legno battuto" in score...) ?

i would like to define my own articulations (because in CONTIMBRE http://www.contimbre.com you have lot of possibilities with programm-changes... and for mapping i have to define it properly) ::::::::::::::: (setq articulations '(arco - - pizz - -));; -> that works fine because ord-omn (setq articulations '(arco - - pizz - - legno-battuto - whatever - - - - );; -> i would like to write such user-defined expressions -> is there a possibilty? ::::::::::::::: (setq vn (make-omn :length lengths :pitch pitches :articulation articulations)) ;; but here is the omn-error with my own expressions, is there any solution? ::::::::::::::: if it would work i could map like this: (def-sound-set gm-violin :programs (:group violin arco 40 legno-battuto 50 pizz 60 whatever 70)) (def-score example (:key-signature 'chromatic :time-signature '(4 4) :tempo '(q 70) :layout (violin-layout 'violin)) (violin :omn vn :channel 1 :sound 'gm-violin)) :::::::::::::::

in lisp -> create OMN with (midi-to-pitch)... (setq half-row (loop repeat 13 with interval with stack = 60 with cnt = 0 when (oddp cnt) do (setq interval 13) when (evenp cnt) do (setq interval -11) when (= cnt 0) collect stack else collect (setq stack (+ stack interval)) do (incf cnt))) (midi-to-pitch (append half-row (reverse (butlast half-row))))

...technically, such pattern-match-things are - for my opinion - interesting when you write one value after the other (step by step with all paramters parallel), and then check all the time (every gen-cycle) the output on PATTERNS, and when there is a match you can change the gen-rules... data-structure with EVENTS like that... (defstruct event duration pitch velocity rhy reading_rate optional_data) (setf bot-1 (make-event)) ... and in every cycle you could write/GENERATE an EVENT (Excerpt) do (setf bot-1 (make-event :duration data :pitch (setq pitch-1 (nth seq-cnt-1 pitchfield)) :velocity (rnd-walk-in-chord '(1 0 -1) velocityfield velocity) :rhy (rnd-walk-in-chord '(1 -1) rhyfield rhy-1) :reading_rate 1; (rnd-pick'(1 2 3)) :optional_data (rnd-pick '(a b c d e)))) and then you check it (every cycle) for patterns... and if MATCH you could change the GEN-part the GEN-rules ... like a small robot who tries "to move in the world or to recognize the world"...

dear rangarajan i think the motif-map-function has a PATTERN-MATCH inside, but it "replaces the MATCH", (like in a contextual-rewrite), but perhaps i don't use the name/expression "pattern-match" in a wright/correct way... i'm more composer/musician then programmer :-) here's a very basic example for am SIMPLE/PURE PATTERN MATCH: a rnd-gen-value-list (to show how you could use it), with a PATTERN-MATCH-prog who scans it. the next value - after a complete match - will be changed into a rest... but you also could start a sub-function then who do what ever you want...? (when you change the code) in a concrete project i coded it also in a more complex way - kind of "nontrivial-machines" (as an experiment) -> PATTERNmatch in pitches changes the DURATIONS, PATTERNmatch in durations changes pitches or timbre... and so on... like a "dynamic-interaction-network"... sorry for my bad english... regards andré FUNCTION - FOR A SIMPLE EXAMPLE (defun pattern_cogn (liste pattern) (loop for z in liste with cnt = 0 with pattern_cnt = 0 collect z ;;;check a value - if it's a match -> incf counter when (or (eq (nth cnt pattern) z) (eq '? (nth cnt pattern))) do (incf pattern_cnt) and do (incf cnt) else do (setq cnt (setq pattern_cnt 0)) ;;; if the pattern is MATCHED (=> counter = length pattern) -> the output changes ... for example, the next value will be a rest ;;; = consequence when (eq pattern_cnt (length pattern)) collect (* z -1) and do (setq cnt (setq pattern_cnt 0)))) FUNCTION-EVAL (pattern_cogn (loop repeat 100 collect (1+ (random 5))) ; generates rnd-values -> TO SEARCH IN IT '(4 ? 2)) ; pattern to search (here with wildcard) WHEN PATTERN MATCH THEN NEXT VALUE (* -1)

short question (i didn't read the whole documentation)... when i use/work with pattern-matching, i've done it with WILDCARDS ... is there any aspect of that in the motif-map function? or is a "ordinary pattern-matching-function" in OM? like that: pattern to search/replace '(0 1 ? 3) this is musically interesting, because it works with "fuzziness".... regards, andré

okay, i understand... i'm "not working" with '(q e q...), i'm always working with NUMBERS (with pitches too). it's easier to write/handle the values, easier to do my own specific code (and multipy, add... whatever) - only on "def-score" i'm changing the representation by generating OMN... regards, andré

you could do it like this on "pure-LISP-level" (setf lengths '(1/4 2/8 3/8 4/4)) (loop for i in lengths with repl = (random (length lengths)) for cnt = 0 then (incf cnt) when (= cnt repl) collect (* i -1) else collect i) best wishes andré

short question... when will the "tuplet-bugs" be fixed...it's not possible for me to work with this bug... thanx a lot andré

cool!!!! :-) thanx!!!

it don't works!? no score-display > Error: OMN Parse Error: fail > While executing: omn-to-ast, in process Listener-1(7). > Type cmd-. to abort, cmd-\ for a list of available restarts. > Type :? for other options.

perhaps with a non-overlapping structure of the voices? and perhaps the tuplet-5/tuplet-3 will be shown as tuplet-15...

ok, thanx! i see my "wishes" are a little bit special - but perhaps OPUSMODUS can do that (without ties... or...) andré example.sib

hi all i would like to MERGE/FIT the following 3-layer-voices(-EXAMPLE) into a ONE-layer-voice (with complex rhythms) - is it possible in OPUSMODUS? thanx for help! andré EXAMPLE: (setf voices (merge-voices (make-omn :length (gen-length '(1 2 3 4 5 6 7 8) 1/20) :pitch '(c4) :velocity '(pppp ppp pp p)) (make-omn :length (gen-length '(1 2 3 4 5 6 7 8) 1/8) :pitch '(c5) :velocity '(pppp ppp pp p)) (make-omn :length (gen-length '(1 2 3 4 5 6 7 8) 1/12) :pitch '(c6) :velocity '(pppp ppp pp p)))) (def-score example (:key-signature 'atonal :time-signature '(4 4) :tempo '(96) :layout (treble-layout '3-layers)) (3-layers :omn voices :channel 1 :sound 'gm :program 1))

more informations: bug (with the 1/20) only when i start with a pitch. when the first value is a rest everthing seems to be okay!

interesting bug: have a look at the 1/20-layer (c6) -> midi sounds correct (!), notation is wrong ;;;;;;;;;;;;;;;;;;;; (setf duration1 '(8 5 3 2 3 5 8)) (setf duration2 '(8 5 3 2 3 5 8)) (setf duration3 '(8 5 3 2 3 5 8)) (setf voices (merge-voices (make-omn :length (gen-length duration1 1/20) :pitch '(c6)) (make-omn :length (gen-length duration2 1/32) :pitch '(b4)) (make-omn :length(gen-length duration3 1/8) :pitch '(as2)))) (def-score voices (:key-signature '(c maj) :time-signature '(4 4) :tempo '(60)) (piano :omn voices :channel 1 :sound 'gm :program 0)) (display-midi (compile-score 'voices) :display :quick-view) ;;;;;;;;;;;;;;;;;;;;

thanx, but midi don't like such VALUES :-( - so it works only for notation (or sibelius/finale)... for the future it would be nice for my work (and perhaps interesting for other composers), when the time/rhythm-things could be more flexible - i think the biggest bounderies in opusmodus are the time/rhythm-things and it's notation (paper/pencil is the most flexible way, and i don't want to be a limited by software). if you work really "experimental" you want to map rhythm-values in a complexer way... for me it would be great and very nice, when it would be possible to notate/play such rhy-sequences like '(1/4 1/4 1/12 1/12 3/16 1/16....) with values that are not completing 1/4. at the moment OPUSMODUS is "correcting" this... (would be nice to have irregular time-signatures or bars with no time-signature!!!).... in my work for example: i have programmed BOTS/non-trivial-machines, who are generating values "step-by-step" and the inner-state of the non-trivial-machine always changes its datas/memory (in a rnd-way). the result is, that the rhythm-values all the times are changing (more or less like in the special-bars-examples). and because it's not possible to calculate the output of the non-trivial-machine (that's the natural constitution of them), it's not possible to "fit the rhyhm-values" into prefiexed-bar-structures. that's a problem for my work and so i have to write such strange programs who fix the complicated rhy-changes :-) thanx for your great work!!! andré

a solution: perhaps it's interesting for anyone (or as an example for OPMUSMODUS-implementation) - a simple function (programmed by a friend and myself) - not very smart but it (should) work(s) :-) greetings a. (defun time-sign-changes (durations rhys &key (complex-bars 'nil)) (if (equal complex-bars 'nil) (loop for i in durations for j in rhys with sum = 0 with last-j = (first durations) when (and (/= j last-j) (/= sum 0)) collect (list (numerator sum) (denominator sum) 1) into bag and do (setq sum 0) do (setq sum (+ sum (abs (* i j)))) when (> sum 1/4) collect '(1 4 1) into bag and do (setq sum (- sum 1/4)) do (setq last-j j) finally (return (append bag (list (list (numerator sum) (denominator sum) 1))))) (loop for i in durations for j in rhys with sum = 0 with last-j = (first durations) when (and (/= j last-j) (/= sum 0)) collect (list (numerator sum) (denominator sum) 1) into bag and do (setq sum 0) do (setq sum (+ sum (abs (* i j)))) when (> sum 1/2) collect '(1 2 1) into bag and do (setq sum (- sum 1/2)) do (setq last-j j) finally (return (append bag (list (list (numerator sum) (denominator sum) 1))))))) (setq durations '(-1 2 3 4 3 2 -5 4 3 2 4 3 1 7)) (setq rhythms '(1/32 1/32 1/32 1/32 1/20 1/20 1/20 1/20 1/20 1/12 1/12 1/12)) ;;creating the lengths (setq lengths (loop for i in durations for j in rhythms collect (* i j))) ;; creating the bar-changes -> :complex-bars 'nil or 't (setq bars (time-sign-changes durations rhythms :complex-bars 'nil)) (def-score solo (:title "example" :key-signature 'atonal :time-signature bars :tempo '90 :layout (treble-layout 'example)) (example :omn (make-omn :pitch '(c4) :length lengths) :channel 1 :volume 100 :sound 'gm))

thanx for the anwser... first example: it's possible to do this, i can realize with "special-bars" like 2/3 or 5/20 - by a little (self-made) lisp-function - so it works...

seems to be a bug... evaluate this: (make-omn :pitch '(c5 c3 c2 c3 c4) :length '(-2/12 2/12 -1/12 6/12 -1/12 3/12 1/12) :velocity '(mf)) after the 6/12 the next value -1/12 is shown as -1/8 in the score score

when i evaluate this: (make-omn :pitch '(c5) :length '(3/12 -1/12 4/12 -1/20 3/20 1/20) :velocity '(mf)) the result is wrong (look at (3/12 -1/12 4/12).... but i would like to notate something like valeur ajoutée isn't it possible? thanx a.