AM

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)) with this setup: 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).

@janusz: if you try the function a few times (without seed) , you will see (by cmd1), that sometimes the last TIE isn't there. i think QUANTIZE is doing this little bug... (but perhaps only a xml-display-thing?)

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

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?

dear all does anyone have experience with an implementation of LISP in maxmsp? i'm looking for: "Max handling real time input, output, timing and control, letting Lisp handle variable handling and of course the processing of large amounts of data" Cycling '74 CYCLING74.COM Tools for sound, graphics, and interactivity does anyone tested this? thealexgraham/lisper GITHUB.COM Lisper is an easy to use interface between Max/MSP and Common Lisp - thealexgraham/lisper thanx for a hint andré

"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

i took the old one - it worked well

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

(loop for i in (gen-divide 2 '(c 4 d 5 e 3 c 6 eb 4)) collect (compress i)) => (c4 d5 e3 c6 eb4) i didn't read you posts precisely. only the last ONE ...but you could use COMPRESS...?

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: a sorted mulit-gen-sort:

you should also share your ideas/thoughts/concepts!!??

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) 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 🧐

BUG is fixed now. should work correct!

;;; THIS FUNCTION DOING SYMM TRANSPOSITIONS TO CONRACT (OR EXPAND, depends on INTERVAL) A CHORD or PITCH-SEQ ;;; default setting: it changes in every generation the highest and lowest pitch by an OCTAVE ;;; by changing :position (see examples) you could change which position should be changed/transposed ;;; default interval is 12 ;;; FUNCTION (defun chord-contraction/expansion (n pitchlist &key (position nil) (interval 12) (chord nil)) (let* ((pitchlist (if (chordp (car pitchlist)) (melodize pitchlist) pitchlist)) (position (if (null position) (list 0 (1- (length pitchlist))) (if (listp position) position (list position (- (1- (length pitchlist)) position))))) (pitchlist (cons pitchlist (loop repeat n collect (setf pitchlist (sort-asc (flatten (position-replace position (list (pitch-transpose interval (list (nth (car position) pitchlist))) (pitch-transpose (neg! interval) (list (nth (cadr position) pitchlist)))) pitchlist)))))))) (if (null chord) pitchlist (chordize pitchlist)))) ;;; EXAMPLES: evaluate by cmd3 (setf 12-tone-field '(f3 fs3 gs3 c4 d4 e4 b4 cs5 eb5 g5 a5 bb5)) (chord-contraction/expansion 4 12-tone-field :chord t) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4d4e4f4bb4b4cs5eb5g5a5) (gs3c4d4e4f4fs4a4bb4b4cs5eb5g5) (c4d4e4f4fs4g4gs4a4bb4b4cs5eb5) (d4eb4e4f4fs4g4gs4a4bb4b4c5cs5)) (chord-contraction/expansion 4 12-tone-field :chord t :interval 48) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (bb1fs3gs3c4d4e4b4cs5eb5g5a5f7) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (bb1fs3gs3c4d4e4b4cs5eb5g5a5f7) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5)) ;;; with spezific positions (inner change) (chord-contraction/expansion 4 12-tone-field :chord t :position 3) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (f3fs3gs3d4eb4e4b4c5cs5g5a5bb5) (f3fs3gs3cs4eb4e4b4c5d5g5a5bb5) (f3fs3gs3d4eb4e4b4c5cs5g5a5bb5) (f3fs3gs3cs4eb4e4b4c5d5g5a5bb5)) (chord-contraction/expansion 4 12-tone-field :chord t :position '(0 5)) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (e3fs3gs3c4d4f4b4cs5eb5g5a5bb5) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (e3fs3gs3c4d4f4b4cs5eb5g5a5bb5) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5)) ;;;; with different intervals (chord-contraction/expansion 4 12-tone-field :chord t :interval 11) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4d4e4e4b4b4cs5eb5g5a5) (gs3c4d4e4e4f4bb4b4b4cs5eb5g5) (c4d4e4e4f4g4gs4bb4b4b4cs5eb5) (d4e4e4e4f4g4gs4bb4b4b4b4cs5)) (chord-contraction/expansion 4 12-tone-field :chord t :interval 7) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4c4d4e4b4cs5eb5eb5g5a5) (gs3c4c4cs4d4e4b4cs5d5eb5eb5g5) (c4c4cs4d4eb4e4b4c5cs5d5eb5eb5) (c4cs4d4eb4e4g4gs4b4c5cs5d5eb5))

often helpful in PATTERN MATCH things... (like in OPMO pattern-match-functions) here is a short IDEA for an octave-independent PITCH-PATTERN-MATCHP with possible WILDCARD, perhaps could help you... ;;;-------------------------------------------------------------- ;;; PITCH PATTERN-MATCHP octave-independent ;;;-------------------------------------------------------------- ;;; SUB (defun convert-pitch (pitches) (loop for i in pitches when (pitchp i) collect (compress (butlast (explode i))) else collect i)) ;;; MAIN (defun pitch-pattern-matchp (pitchlist pattern) (let ((pitchlist (convert-pitch pitchlist)) (pattern (convert-pitch pattern))) (pattern-matchp pitchlist pattern))) (pitch-pattern-matchp '(c4 d4 eb4 f4 g4) '(c ? e)) => nil (pitch-pattern-matchp '(c4 d4 eb4 f4 g4) '(c ? eb)) => t

a kind of MERGE-SORT -> sorry for bad coding i didn't find a better solution -> perhaps a new SORT for GEN-SORT... (defun kind-of-merge-sort (alist) (progn (setf alist (mcflatten (loop repeat 30 do (setf alist (loop for i in (gen-divide 2 alist) collect (sort-asc (flatten i)))) collect alist))) (loop repeat (length alist) for cnt = 0 then (incf cnt) when (not (equal (nth cnt alist) (nth (1+ cnt) alist))) collect (nth cnt alist)))) (list-plot (flatten (kind-of-merge-sort (rnd-order (gen-integer 0 20)))) :join-points t :point-radius 0 :style :fill)

thanx stephane! ...but when you have a look on the output... (gen-retrograde durations1 :omn t) => ((t s t) (t 13/96 3q) (5h = 3/35 7q = = = = 3/35 5h =) (3q 13/96 t) (t s t)) or with FLATTEN: (gen-retrograde (flatten durations1) :omn t) => (t s t 3q 13/96 t 5h = 3/35 7q = = = = 3/35 5h = t 13/96 3q t s t) the "original notation" with no troubles => ((t s t) (3q 3e_s. t) (5h 5h 5q_7q 7q 7q 7q 7q 7q 7q_5q 5h 5h) (t s._3e 3q) (t s t))

for some score-display it would be very very useful if when EVAL etc... (or use any of the OPMO-functions) OMN-notation would be displayed and not changing to RATIOS... have a look to this example: it's written like that, because then the display is very smart. when i use "rnd-pick" or other functions it changes from OMN to RATIO... very ugly then. is there an internal solution for that or another trick? thanx for help a. ;; NICE DISPLAY BY CMD3 (setf durations1 (list '(t s t) '(3q 3e_s. t) '(5h 5h 5q_7q 7q 7q 7q 7q 7q 7q_5q 5h 5h) '(t s._3e 3q) '(t s t) )) => ((t s t) (3q 3e_s. t) (5h 5h 5q_7q 7q 7q 7q 7q 7q 7q_5q 5h 5h) (t s._3e 3q) (t s t)) ;;; UGLY DISPLAY BY CMD3 because of the OPMO-fuction (gen-retrograde durations1) ;; should result the same rhythm => ((1/32 1/16 1/32) (1/32 13/96 1/12) (1/10 1/10 3/35 1/28 1/28 1/28 1/28 1/28 3/35 1/10 1/10) (1/12 13/96 1/32) (1/32 1/16 1/32)) ;;; the same (rnd-pick durations1) => (1/32 13/96 1/12) ;;; OKAY because LISP and not OPMO (nth 0 durations1) => (t s t) a practical example: ;;; WORKS => because in the last step it's on LISP-level (setf durations (list '(t s t) '(3q 3e_s. t) '(5h 5h 5q_7q 7q 7q 7q 7q 7q 7q_5q 5h 5h) '(t s._3e 3q) '(t s t) '(t t t t) '(5q 5q 5q 5q 5q) '(3q 3q 3q) '(7q 7q 7q 7q 7q 7q 7q))) (setf morph-list (flatten (gen-morph 7 '(0 1 2 3) '(4 5 6 7)))) ;;cmd3 (setf newdurations (loop for i in morph-list append (nth i durations))) ;;; DON'T WORK => because OMPO chanhig the format to RATIOS (setf durations1 (list '(t s t) '(3q 3e_s. t) '(5h 5h 5q_7q 7q 7q 7q 7q 7q 7q_5q 5h 5h) '(t s._3e 3q) '(t s t))) (setf durations2 (list '(t t t t) '(5q 5q 5q 5q 5q) '(3q 3q 3q) '(7q 7q 7q 7q 7q 7q 7q))) ;;cmd3 (setf newdurations (flatten (gen-morph 7 durations1 durations2)))

with BAR and BEAT? that's great JANUSZ, you are always two steps ahead or "MILES AHEAD" (trumpeter's joke :-)) but WHEN will be the RELEASE? 🤓

thanx for the span-ignore-pause-HINT! ...but it makes no sense to me - when you are working with EVENTS (by numbering it) - to ignore some of them 😉 the idea behind this concept is, that you could work with a (finished) score by changing some parameters or enlarge rests - like a kind of "post-production". in this way it's not necessary to go deep inside you generating-algorithms, you can only change things a little bit like in a notation-software (i think it's on that level). some months ago i had the idea to do such changes (post...) by positions with BARS/BEATS - but at the moment i think it's much better to signify the EVENTS and work directly on them. less errors and easy to code such post...-functions.

to use the function which works on event-numbers, first you have to number it (the score), so that you could work with this afterwards... ;;; ADD numbers to text attributes (can do that in your setup), then ADD number to events ;;; have a look to the example. after that, easy to use REPLACE-ON-EVENT-NUMBER etc... (defun add-numbers-to-text-attributes (a b) (loop for i from a to b append (add-text-attributes (list (compress (list 'nr i)) (write-to-string i))))) (add-numbers-to-text-attributes 0 100) (defun add-num-to-events (omnlist) (loop for x in (single-events omnlist) for i from 0 to (length (single-events omnlist)) when (omn-formp x) collect (omn-replace :articulation (list (compress (list 'nr i))) x) else collect x)) ;;; evaluate cmd3 (setf seq (add-num-to-events '(-q q c4 mp -q -q e e e e e q c4 mp -q -q q c4 mp -q))) => ((-q) (q c4 mp nr1) (-q) (-q) (e c4 mp nr4) (e c4 mp nr5) (e c4 mp nr6) (e c4 mp nr7) (e c4 mp nr8) (q c4 mp nr9) (-q) (-q) (q c4 mp nr12) (-q))

the same idea with INSERT/REPLACE (defun replace-on-event-number (omn-list &key position/list (type 'replace) (output nil)) (progn (setf omn-list (loop for i in (single-events omn-list) for cnt = 0 then (incf cnt) with position-list = (loop for x in position/list collect (car x)) with list = (loop for y in position/list collect (rest y)) with cnt2 = 0 when (= cnt (nth cnt2 position-list)) collect (cond ((equal type 'replace) (if (listp (nth cnt2 list)) (flatten (nth cnt2 list)) (nth cnt2 list))) ((equal type 'add) (list i (nth cnt2 list)))) else collect i when (and (= cnt (nth cnt2 position-list)) (< cnt (car (last position-list)))) do (incf cnt2))) (if (equal output 'flatten) (flatten omn-list) omn-list))) ;;; EXAMPLES REPLACE (replace-on-event-number '(q g4 -q q g4 g4 g4 -q g4 g4 g4 g4) :position/list '((1 (q g5d5)) (5 -q)) :type 'replace) => ((q g4 mf) (q g5d5) (q g4 mf) (q g4 mf) (q g4 mf) (-q) (q g4 mf) (q g4 mf) (q g4 mf) (q g4 mf)) (replace-on-event-number '(q g4 -q q g4 g4 g4 -q g4 g4 g4 g4) :position/list '((1 (q g5d5)) (5 -q)) :type 'replace :output 'flatten) => (q g4 mf q g5d5 q g4 mf q g4 mf q g4 mf -q q g4 mf q g4 mf q g4 mf q g4 mf) ;;; EXAMPLES ADD (replace-on-event-number '(q g4 -q q g4 g4 g4 -q g4 g4 g4 g4) :position/list '((1 -e.) (5 -w)) :type 'add :output nil) => ((q g4 mf) ((-q) (-e.)) (q g4 mf) (q g4 mf) (q g4 mf) ((-q) (-w)) (q g4 mf) (q g4 mf) (q g4 mf) (q g4 mf)) (replace-on-event-number '(q g4 -q q g4 g4 g4 -q g4 g4 g4 g4) :position/list '((1 (w g6 ffff)) (5 -w)) :type 'add :output 'flatten) => (q g4 mf -q w g6 ffff q g4 mf q g4 mf q g4 mf -q -w q g4 mf q g4 mf q g4 mf q g4 mf) ;;;;

it's not a common solution, only a specific for my project... 1) it should also work with chords - because it's made for EVENTS it's always one chord = one event 2) of course, you have to decide/check if you like to merge rests or not => because i'm filtering the texture by a binary-seq (binaries from a jpeg, like a sieve) it's not the idea to merge the rests, but you could do that in a seperate step. but in my case every note/event (before filtering) is numbered, so with/when BINARY-FILTER/SIEVE you will keep the numbering concise.

what you could do with it? a precise "projection on a curve" of a generated OMN (in this example: a 12-tone-row, which is been permuted (by a SORTING-algorithm) from start to end, till it's a symmetrical scale)

greetings andré ;;; --------------------------------------------------------------------------------------------------- ;;; because i'm working with numbered-events (to have some more control) i has to code ;;; a specific tranposition-function, which is transposing on specific spans/positions ;;; --------------------------------------------------------------------------------------------------- ;;; SUB (defun and-span (n a b) (and (>= n a) (<= n b))) ;;; MAIN (defun transpose-on-event-number (omn-list &key positions/transpose-list) (loop for i in (single-events omn-list) for cnt = 0 then (incf cnt) with position-list = (loop for x in positions/transpose-list collect (car x)) with transpose-list = (loop for y in positions/transpose-list collect (rest y)) with cnt2 = 0 when (and (and-span cnt (car (nth cnt2 position-list)) (cadr (nth cnt2 position-list))) (not (length-restp (car (omn :length i))))) collect (pitch-transpose-n (nth cnt2 transpose-list) i) else collect i when (and (= cnt (cadr (nth cnt2 position-list))) (< cnt (cadar (last position-list)))) do (incf cnt2))) ;;; ZERO-based (like in lisp) (transpose-on-event-number '(q g4 -q q g4 g4 g4 g4 g4 g4 g4 g4) :positions/transpose-list '(((0 5) 1) ((6 7) -3) ((8 9) 12))) => ((q gs4 mf) (-q) (q gs4 mf) (q gs4 mf) (q gs4 mf) (q gs4 mf) (q e4 mf) (q e4 mf) (q g5 mf) (q g5 mf))