AM

Dear @Cliff I find the idea genuinely interesting ... on first consideration a few issues come to mind. But maybe I’m missing something or misunderstanding certain aspects, so feel free to correct me or put things into perspective. Defining a piece through a small number of parameters feels too reductive to me, because musical dimensions are rarely independent. Things like form, harmony, rhythm, accentuation, etc. are tightly interconnected and can’t really be evaluated in isolation. So the parameters would need to be connected across different levels and hierarchically organized. A simple example would be harmony and rhythm: the way consonance and dissonance are treated is often directly linked to rhythmic structure and accent patterns, and this relationship is highly dependent on style or genre. What counts as “good” or “bad” harmonic tension only makes sense within a very specific stylistic context. This also means that any kind of rating system would have to operate within very clearly defined stylistic boundaries, both on a larger level (genre, style, compositional language) and on a smaller, more local level. On a more technical note, numerical ratings don’t really provide direction? If an algorithm generates a randomized twelve-tone row and I rate the result as “1” instead of “10”, the system has no idea why it failed or in which direction it should change — different intervals, an all-interval row, Webern-style cells, or something else entirely. Without explicit stylistic and aesthetic goals, such ratings don’t give the system much to work with? In roughly these areas, there has been research and various approaches for decades — see pioneers like David Cope or projects such as DeepBach, Bachbot, E.M.I. What I find artistically interesting about OPUSMODUS (or bach/maxmsp or ...) much more so, at least up to now, than AI or machine learning—is that it allows me to intervene very precisely in a structure or a specific aspect of a piece. I can simulate processes (sometimes randomized) and then begin with concrete, directionally guided (!) modifications, giving me specific control. This applies both on a global scale and at a very local level. In essence, it’s also a continuous generate-and-test process, but with a wider (and more specific) range of parameters—both objective and subjective—that I can consider within artistic, historical, and genre-specific contexts? Greetings André

I only had a quick look/read and built something like this: at level 0 you get a random pick of the pairs, at level 1 a sequence within a pair, and at level 2 a single value from a sequence of a pair. Was that what you meant? For me, level 0 is not the whole list (i.e. the outermost parentheses), but rather all the pairs inside the outermost parentheses. If I do (length alist), I get 7 here, not 1. So there are 3 levels possible (0 to 2) ;;; (setf alist '(((c4 e4 g4) (d4 fs4 a4)) ((c4 e4 g4) (b4 d4 fs4)) ((d4 fs4 a4) (e4 g4 b4)) ((e4 g4 b4) (fs4 a4 c4)) ((fs4 a4 c4) (g4 b4 d4)) ((g4 b4 d4) (a4 c4 e4)) ((a4 c4 e4) (b4 d4 fs4)))) (defun pick-from-level (alist level) (cond ((= level 0) (nth (random (length alist)) alist)) ((= level 1) (rnd-pick (nth (random (length alist)) alist))) ((= level 2) (rnd-pick (flatten alist))))) (pick-from-level alist 0) => ((g4 b4 d4) (a4 c4 e4)) (pick-from-level alist 1) => (c4 e4 g4) (pick-from-level alist 2) => b4If you want it nested—that is, pick from pick…—then you just need to nest the function. It will then always pick within the same level, either going down or up. (pick-from-level (pick-from-level alist 0) 0) => (fs4 a4 c4) "It will then always pick within the same level,..." : PATH not LEVEL

snippet-to-editor -> so nice! II really enjoy the workflow from OPUSMODUS to Sibelius. When you have some little ideas for material, you program a small function, experiment with it, then export/open it in SIBELIUS and continue working. Not generating full scores, but small units of material… exporting by snippet-to-editor. For example: (i could do it directly in SIBELIUS, but much easier via OPMO) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; binary-counting-rhythm -> counting from x to y // easy export to SIBELIUS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; to ensure the pattern is always the same length, the bit length for all decimal-to-binary conversions is adjusted to match the largest decimal number ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun dec-to-bin-rhythm (ilist) (let ((span (find-max (mapcar 'length (decimal-to-binary ilist))))) (loop for i in (binary-rhythm span ilist 1 :type 1) collect (loop for x in i when (< x 0) append (gen-repeat (abs x) 0) else collect x)))) (setf bitseq (dec-to-bin-rhythm (gen-integer 23 1))) ;; 5-bit (snippet-to-editor (omn-to-measure (make-omn :pitch '(cs3) :length (gen-length bitseq '1/8) :velocity '(mf) :articulation '(stacc)) '(4/4))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; SIBELIUS opens the file -> copy/paste to the actual score ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

very nice!!

Why limit a hoquetus to just four voices? Imagine it instead for fifty guitars dispersed throughout the space—not as a mere progression, but as a finely shaped structure articulated by a vector envelope. A concept piece, perhaps best experienced on a quiet Sunday evening 😅 Have a look at the (list-plot...)... (This essentially creates spatial and sonic structures similar to those in Ligeti’s Atmosphères or XENAKIS... and on this point stochastic method would be interesting ;-)) ;; 50 GUITARISTS should play a hocket in an "specific enevelope-order" (setf 50guits (list-plot (vector-map (gen-integer 1 50) (vector-to-envelope2 '(4.2456284 7.2268248 6.4440737) '(3.682579 8.78879 10.000002) (gen-noise 356) :segment (primes 12) :type 3)))) (progn (setf mat (make-omn :pitch '(e4) :length (gen-repeat 50 's))) ;; allvoices for 50 players (gen-hocket mat :density (gen-binary-for-hocket 50guits))) i like to be guitarist number one - just 2 notes to play!

everything okay with this code.... use binary... like janusz coded it... (progn (setf mat '(q c4 d4 e4 f4 g4 a4 b4 c5)) (gen-hocket mat :density '((1 0 0 0 1 0 0 0 0 0 1) (0 1 0 1 0 1 0 0 0 1 0) (0 0 1 0 0 0 1 0 1 0 0) (0 0 0 0 0 0 0 1 0 0 0))) (setf mv (merge-voices v1 v2 v3 v4))) and when you generate the binary seq with.... it's that simple. (defun gen-binary-for-hocket (alist) (let ((vlist (sort-asc (remove-duplicates alist)))) (loop for v in vlist collect (loop for i in alist when (= i v) collect 1 else collect 0)))) ;;; now with OPMO-function... (progn (setf mat '(q c4 d4 e4 f4 g4 a4 b4 c5)) (gen-hocket mat :density (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) (setf mv (merge-voices v1 v2 v3 v4)))

the great thing about Opusmodus is that you can code your own solutions for ideas, problems, or historical models – it gives you a lot of freedom. MAX/MSP, PWGL, or CLM are/were like that too… thx @janusz for your personal support! here is another solution for the traditional hocket... take it or leave it or code it in your own personal way ;-) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; generates hocket-voice (defun gen-hocket-voice (elist omnlist) (let ((omnevents (single-events omnlist)) (elist (gen-repeat 5 elist))) (loop repeat (length (single-events omnlist)) for cnt = 0 then (incf cnt) when (= (nth cnt elist) 1) collect (nth cnt omnevents) else collect (if (length-restp (car (nth cnt omnevents))) (nth cnt omnevents) (* -1 (car (flatten (omn :length (nth cnt omnevents))))))))) ;; splits isntruments for binary.. (defun gen-binary-for-hocket (alist) (let ((vlist (sort-asc (remove-duplicates alist)))) (loop for v in vlist collect (loop for i in alist when (= i v) collect 1 else collect 0)))) ;; each number is an instrumnet -> for voices (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) => ((1 0 0 0 1 0 0 0 0 0 1) (0 1 0 1 0 1 0 0 0 1 0) (0 0 1 0 0 0 1 0 1 0 0) (0 0 0 0 0 0 0 1 0 0 0)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; EXAMPLE ;; rnd-omn-seq (setf omn-seq (make-omn :pitch (make-scale 'c4 23) :length '(s) :span :pitch)) ;; voices 1-4 (setf v1 (gen-hocket-voice (first (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) omn-seq)) (setf v2 (gen-hocket-voice (second (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) omn-seq)) (setf v3 (gen-hocket-voice (third (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) omn-seq)) (setf v4 (gen-hocket-voice (fourth (gen-binary-for-hocket '(1 2 3 2 1 2 3 4 3 2 1))) omn-seq)) ;; check -> when chromatic scale then everything is okayx (merge-voices v1 v2 v3 v4)

If it weren’t exclusively stochastic, but if it were also possible to ‘filter’ the events through binary lists, then one could build interesting instrumentation matrices/trajectories (for example, using vector-envelopes that would then be mapped voice by voice into binary lists). Would that be an option?

a simple hocket-function - starting with an OMN-sequence (defun gen-hocket-voice (elist omnlist) (let ((omnevents (single-events omnlist))) (loop repeat (length (single-events omnlist)) for cnt = 0 then (incf cnt) when (= (nth cnt elist) 1) collect (nth cnt omnevents) else collect (if (length-restp (car (nth cnt omnevents))) (nth cnt omnevents) (* -1 (car (flatten (omn :length (nth cnt omnevents))))))))) ;; eveluate this (progn ;(setf omnseq '(s c4 mf cs4 d4 ds4 -q s e4 f4 -1 s fs4 g4 gs4 a4)) ; simple ;(setf omnseq (flatten (gen-rnd-omn 3 8 1 3 '(c4 cs4 d4 ds4 e4 f4 fs4 g4 gs4 a4) 's nil) )) ; more complex (setf omnseq (flatten (filter-first 5 (gen-rnd-omn 8 '(8 8 12 4) 2 4 '(c4 cs4 d4 ds4 e4 f4 fs4 g4 gs4 a4) 's '(p mp f) :rotate '(-1 2 0 1) :type 2)))) (setf events1 '(0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1)) ; an eventlist (setf events2 '(1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0)) ; another eventlist (setf events3 '(1 1 1 0 1 1 0 0 1 1 1 0 1 1 1 1 1 0 1 1 0 0 1 1 1 0 1 1)) ; another eventlist (setf instr1 (gen-hocket-voice events1 omnseq)) (setf instr2 (gen-hocket-voice events2 omnseq)) (setf instr3 (gen-hocket-voice events3 omnseq)) ;; check it -> if one voice then everything okay (merge-voices instr1 instr2 instr3))

some old stuff https://opusmodus.com/forums/topic/501-gen-hoquetus/

packed in a function ... as many voices you want... ;; packed in a function (defun gen-omn-by-events (elist plist rlist &key (vel 'p)) (loop repeat (length elist) for cnt = 0 then (incf cnt) when (= (nth cnt elist) 1) collect (list (nth cnt rlist) (nth cnt plist) vel) else collect (* -1 (nth cnt rlist )))) (setf events1 '(1 0 1 1 0 0 0 1 0 1 0 0 0 1 0 1 0 1 1 1 0 1 0 1)) ; an eventlist (setf events2 '(0 1 0 0 0 1 0 0 1 1 0 1 0 0 1 0 1 0 0 0 1 1 1 0)) ; another eventlist (setf events3 '(1 1 1 0 1 1 0 0 0 0 1 1 0 0 1 1 0 0 1 0 1 0 0 0)) ; another eventlist (setf instr1 (gen-omn-by-events events1 plist rlist :vel 'p)) (setf instr2 (gen-omn-by-events events2 plist rlist :vel 'f)) (setf instr3 (gen-omn-by-events events3 plist rlist :vel 'ppp)) ;; ........ ;; check it (merge-voices instr1 instr2 instr3)

a (very simple) more lispian version (setf l1 '(1 0 1 1 0 0 0 1 0 1 0 0 0 1 0 1 0 1 1 1 0 1 0 1)) ; an eventlist (setf l2 '(0 1 0 0 0 1 0 0 1 1 0 1 0 0 1 0 1 0 0 0 1 1 1 0)) ; another eventlist (setf plist (gen-repeat 2 (rnd-air :type :pitch))) ;; a rnd-pitch-seq (setf rlist (rnd-sample 50 '(1/16 2/16 3/16 5/16))) ;; a rnd-length-seq ;; voice 1 (setf instr1 (loop repeat (length l1) for cnt = 0 then (incf cnt) when (= (nth cnt l1) 1) collect (list (nth cnt rlist) (nth cnt plist) 'f) else collect (* -1 (nth cnt rlist)))) ;; voice 2 (setf instr2 (loop repeat (length l2) for cnt = 0 then (incf cnt) when (= (nth cnt l2) 1) collect (list (nth cnt rlist) (nth cnt plist) 'p) else collect (* -1 (nth cnt rlist )))) ;; check by MERGE (merge-voices instr1 instr2)

no problems on Version 4.0.30060 (4.0.30060) - Mac

(setf ints (permute '(1 2 3 4))) (setf chords (loop for i in ints append (chordize (interval-to-pitch i :start 'd4)))) (make-omn :pitch chords :length '(w) :span :pitch)

Here’s a small function I needed because I’m working with "binary counting patterns". All patterns must always have the same length (a fixed bit length determined by the largest value). (defun dec-to-bin-rhythm (ilist) (let ((span (find-max (mapcar 'length (decimal-to-binary ilist))))) (loop for i in (binary-rhythm span ilist 1 :type 1) collect (loop for x in i when (< x 0) append (gen-repeat (abs x) 0) else collect x)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; to ensure the pattern is always the same length, the bit length for all decimal-to-binary conversions is adjusted to match the largest decimal number ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (dec-to-bin-rhythm '(234234 1 23 110 )) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; binary-counting-rhythm -> counting from x to y ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setf bitseq (dec-to-bin-rhythm (gen-integer 1 145))) ;; 8-bit (omn-to-measure (make-omn :pitch '(c5) :length (gen-length bitseq '1/32) :velocity '(mf)) '(2/8)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; examples with list-plot ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (progn (setf bitseq (dec-to-bin-rhythm (gen-integer 1 79))) (length-list-plot (flatten bitseq) :join-points t :style :fill)) (progn (setf bitseq (dec-to-bin-rhythm (gen-integer 1 230 3))) ;; count with step 3 (length-list-plot (flatten bitseq) :join-points t :style :fill)) (progn (setf bitseq (dec-to-bin-rhythm (primes 50))) (length-list-plot (flatten bitseq) :join-points t :style :fill)) A "Binary Counting Filter": You can also think of it (a liitle bit) like Tom Johnson’s work — the filter/binary approach generates all possible combinations etc... (defun binary-count-filter (&key (type 'pos) (n 50) minp maxp minl maxl field (rhy '1/16)) (progn (setf n-chords n) (setf pseq (dec-to-bin-rhythm (gen-integer minp maxp))) (setf lseq (dec-to-bin-rhythm (gen-integer minl maxl)));(cellular-automaton lrule n-chords linit)) (setf positions (loop for i in pseq collect (position-item 1 i))) (setf chords (if (equal type 'neg) (loop for i in positions collect (chordize (remove-duplicates (melodize (position-remove i field))))) (loop for i in positions collect (chordize (position-filter i field))))) (setf lengths (loop for i in (flatten lseq) when (= i 1) collect rhy else collect (* -1 rhy))) (make-omn :pitch chords :length lengths :velocity '(ppp)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; examples counting 1 to 123 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; type: pos -> play/chordize the 1-values (binary-count-filter :type 'pos :minp 1 :maxp 123 :field (make-scale 'c4 11 :alt '(1 2 3 7)) :minl 1 :maxl 123 :rhy '1/16) ;; type: neg -> play/chordize the 0-values (binary-count-filter :type 'neg :minp 1 :maxp 123 :field (make-scale 'c4 11 :alt '(1 2 3 7)) :minl 1 :maxl 123 :rhy '1/16) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; 2 more examples with counting 23 to 255 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; type: pos -> play/chordize the 1-values (binary-count-filter :type 'pos :minp 23 :maxp 255 :field (make-scale 'c4 11 :alt '(1 2 3 7)) :minl 23 :maxl 255 :rhy '1/32) ;; type: pos -> play/chordize the 0-values (binary-count-filter :type 'neg :minp 23 :maxp 255 :field (make-scale 'c4 11 :alt '(1 2 3 7)) :minl 23 :maxl 255 :rhy '1/32)

Here's a little function that generates OMN-Seqs with CA-filter (pos/neg) with a CA-Rhy - both parameters independently. Have fun - André (defun cellular-automaton-filter (&key (type 'pos) (n 200) prule pinit lrule linit field (rhy '1/16)) (progn (setf n-chords n) (setf pseq (cellular-automaton prule n-chords pinit)) ;'(0 0 0 0 0 0 1 0 0 0 0 0 0))) (setf lseq (cellular-automaton lrule n-chords linit)) (setf positions (loop for i in pseq collect (position-item 1 i))) (setf chords (if (equal type 'neg) (loop for i in positions collect (chordize (position-remove i field))) (loop for i in positions collect (chordize (position-filter i field))) )) (setf lengths (loop for i in (flatten lseq) when (= i 1) collect rhy else collect (* -1 rhy))) (make-omn :pitch chords :length lengths :velocity '(ppp)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; type: pos -> play/chordize the 1-values (cellular-automaton-filter :type 'pos :prule 110 :pinit '(0 0 0 0 0 1 0 0 1 0 0 0 0 0 0) :field (gen-sieve '(f0 f7) '(6 3 4 6 3 4) :type :pitch) :lrule 26 :linit '(0 0 0 0 0 1 0 0 1 0 0 0 0 0 0) :rhy '1/20) ;; type: neg -> play/chordize the 0-values (cellular-automaton-filter :type 'neg :prule 110 :pinit '(0 0 0 0 0 1 0 0 1 0 0 0 0 0 0) :field (gen-sieve '(f0 f7) '(6 3 4 6 3 4) :type :pitch) :lrule 26 :linit '(0 0 0 0 0 1 0 0 1 0 0 0 0 0 0) :rhy '1/32)

Fixed intervals: each generation extracts a predefined interval-sequence. Within the simulation loop—which runs and visualizes multiple generations—users can choose whether to display intervals or absolute pitches. With every generation (or evaluation), the initial binary sequence is modified. This dynamic updating makes the specific behavior of each rule more apparent, allowing for clearer comparisons between different cellular automaton rules. (progn ;; set rule number ;(setf rule 12) (setf rule (random 257)) ;; set n simulations (setf sims 5) (loop repeat sims do (progn (setf intervals (pitch-to-interval (rnd-air :group :symmetric :type :pitch :seed 1234))) (setf seq (cellular-automaton rule 200 (gen-binary-rnd 1 11 1 3))) (setf positions (loop for i in seq collect (position-item 1 i))) (setf ilist (loop for i in positions collect (position-filter i intervals))) (setf plist (loop for i in ilist collect (interval-to-pitch i))) (setf plist2 (interval-to-pitch (flatten ilist)))) ;; intervals ; do (list-plot (flatten ilist) :join-points nil :style :fill) ;; pitches every gen starting on c4 ;do (pitch-list-plot (flatten plist) :join-points t :style :fill)) ;; pitches all (without gen restart) do (pitch-list-plot (flatten plist2) :join-points t :style :fill) do (sleep 1))) Bildschirmaufnahme 2025-06-28 um 16.35.52.mov

Here’s a small technical idea... just with a "random-chord" (progn (setf chord (rnd-sample-seq 10 (gen-sieve '(c3 g7) '(1 2 4 7 4 2) :type :pitch))) (setf rule30 (cellular-automaton 30 200 '(0 0 0 1 0 1 0 0 0 0))) (setf positions (loop for i in rule30 collect (position-item 1 i))) (setf chords (loop for i in positions collect (chordize (position-filter i chord)))) (pitch-list-plot (flatten chords) :join-chords t))https://plato.stanford.edu/entries/cellular-automata/supplement.html

Weird notation shows up when I merge the following voices—on their own, there’s no problem. ;; two versions (setf v1 '((-3he d4 pppp - d4 - d4) (-3he d4 pppp - d4 - -))) (setf v2 '((-7wq - eb5 pppp ten - eb5 ten - eb5 ten) (-7wq eb5 pppp ten - eb5 ten - - -))) (merge-voices v1 v2) (setf v1 '(-3he d4 pppp - d4 - d4 -3he d4 pppp - d4 - -)) (setf v2 '(-7wq - eb5 pppp ten - eb5 ten - eb5 ten -7wq eb5 pppp ten - eb5 ten - - -)) (merge-voices v1 v2)

The workflow with importing/exporting MusicXML is really great—it opens up a whole new way of working. Congratulations and thanks to Janusz and the OPMO team! Greetings André

https://www.cs.cmu.edu/~dst/LispBook/book.pdf https://gigamonkeys.com/book/ http://www.ulisp.com/show?1AAO https://lisp-lang.org/learn/

A little hint for the community? :-)

any solutions?

(defun reset-integer-sequence (alist &key (offset 0) (flatten nil)) (let ((min (find-min (flatten alist)))) (progn (setf alist (cond ((listp (car alist)) (loop for j in alist collect (loop for i in j collect (+ (- i min) offset)))) (t (loop for i in alist collect (+ (- i min) offset))))) (if (equal flatten t) (flatten alist) alist))))

I’m trying to merge two voices, but the grace notes get lost in the process. What do I need to do differently? Thanks for any advice! Greetings André (setf v1 '(-1/4 1/28 eb5 p ten a4 bb2 ff ten+marc (-acc 1/8 gs4 mf leg) 1/28 b4 ppppp ten -3/28)) (setf v2 '(-6/28 (-acc 1/8 f6 ff) 3/28 d4e9 pppp ten -5/28)) (merge-voices v1 v2) => (-7w. 7q^7h. d4e9 pppp ten eb5 p ten a4 bb2 ff ten+marc b4 ppppp ten -7h.)