AM

Fixed in 3.0.29069

Of course, I will put the function back into the system with the next update.

First part of a work in progress for Orchestra based on spectral harmony (but quantised to 1/2 ton for that part...)
 

stephaneboussuge · Surabaya pour Orchestre Part 1 SB.

(defun gen-brownian-bridge (n startend &key (all-gen nil) (output 'integer) (span 5))   (let ((seq)         (liste startend))     (progn       (setf seq (append (list startend)                         (loop repeat n                               do (setf liste (filter-repeat 1 (loop repeat (1- (length liste))                                                                     for cnt = 0 then (incf cnt)                                                                     append (append (list (nth cnt liste)                                                                                           (pick (nth cnt liste)                                                                                                 (nth (1+ cnt) liste)                                                                                                 :span span)                                                                                          (nth (1+ cnt) liste))))))                               collect liste)))       (setf seq (if (equal all-gen t)                     seq                   (car (last seq))))       (if (equal output 'pitch)           (integer-to-pitch seq)         seq))))  
Small change otherwise you get:
Warning: Local Variable Initialization clause (the binding of liste) follows iteration clause(s) but will only be evaluated once.  

i like the concept of "brownian bridge" to produce complex curves from a to b, but not completely randomized or controlled. in the video you see all the generations for one evaluation...
 
how it could sound - mapped on different tonalities
 
 
 
Brownsche Brücke – Wikipedia
DE.WIKIPEDIA.ORG  
for understanding in OPMO:
 
axiom: start end
(50 23)
 
gen1 => 1 step
(50 8 23)
 
gen2  => 3 steps
(50 15 8 -3 23)
 
gen3 => 7 steps
(50 40 15 13 8 -14 -3 29 23)
 
gen4 => 15 steps
(50 58 40 33 15 22 13 4 8 4 -14 -16 -3 17 29 17 23)
 
...and so on
 
-------------------------------------------------------------------------------
 
some evaluations with same AXIOM:
 

Bildschirmaufnahme 2023-07-08 um 11.09.51.mov  
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; BROWNIAN BRIDGE -> could be use as a rnd-process from A to B (integers or pitches) ;;; if you have a look to example with ":all-gen t", you will see the process with all generations, how it works ;;; or take a look to: ;;; https://de.wikipedia.org/wiki/Wiener-Prozess#/media/File:BrownscheBewegung.png ;;; https://de.wikipedia.org/wiki/Brownsche_Brücke ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUB (defun pick (a b &key (span 5)) (let ((rnd1 (car (rnd-number 1 (+ a span) (- a span)))) (rnd2 (car (rnd-number 1 (+ b span) (- b span)))) (n)) (progn (setf n (car (rnd-number 1 rnd1 rnd2))) (if (or (= n a) (= n b)) (+ (rnd-pick '(1 -1)) n) n)))) (pick 2 3) ;;; MAIN ;;; MAIN (defun gen-brownian-bridge (n startend &key (all-gen nil) (output 'integer) (span 5)) (let ((seq)) (progn (setf seq (append (list startend) (loop repeat n with liste = startend do (setf liste (filter-repeat 1 (loop repeat (1- (length liste)) for cnt = 0 then (incf cnt) append (append (list (nth cnt liste) (pick (nth cnt liste) (nth (1+ cnt) liste) :span span) (nth (1+ cnt) liste)))))) collect liste))) (setf seq (if (equal all-gen t) seq (car (last seq)))) (if (equal output 'pitch) (integer-to-pitch seq) seq)))) ;;; EXAMPLES ;; SPAN influence -> span 2 (loop repeat 20 do (list-plot (gen-brownian-bridge 5 '(1.2 5.4) :span 2 :all-gen t) :zero-based t :point-radius 3 :join-points t) do (sleep 2)) ;; SPAN influence -> span 10 (list-plot (gen-brownian-bridge 5 '(50 23) :span 20 :all-gen t) :zero-based t :point-radius 3 :join-points t) ;;; SPAN default (5) (list-plot (gen-brownian-bridge 5 '(50 23) :all-gen t) :zero-based t :point-radius 3 :join-points t) (list-plot (gen-brownian-bridge 5 '(50 23)) :zero-based t :point-radius 3 :join-points t) (gen-brownian-bridge 5 '(50 23) :all-gen t :output 'pitch) (gen-brownian-bridge 5 '(50 23) :output 'pitch)  

i like the concept of "brownian bridge" to produce complex curves from a to b, but not completely randomized or controlled. in the video you see all the generations for one evaluation...
 
how it could sound - mapped on different tonalities
 
 
 
Brownsche Brücke – Wikipedia
DE.WIKIPEDIA.ORG  
for understanding in OPMO:
 
axiom: start end
(50 23)
 
gen1 => 1 step
(50 8 23)
 
gen2  => 3 steps
(50 15 8 -3 23)
 
gen3 => 7 steps
(50 40 15 13 8 -14 -3 29 23)
 
gen4 => 15 steps
(50 58 40 33 15 22 13 4 8 4 -14 -16 -3 17 29 17 23)
 
...and so on
 
-------------------------------------------------------------------------------
 
some evaluations with same AXIOM:
 

Bildschirmaufnahme 2023-07-08 um 11.09.51.mov  
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; BROWNIAN BRIDGE -> could be use as a rnd-process from A to B (integers or pitches) ;;; if you have a look to example with ":all-gen t", you will see the process with all generations, how it works ;;; or take a look to: ;;; https://de.wikipedia.org/wiki/Wiener-Prozess#/media/File:BrownscheBewegung.png ;;; https://de.wikipedia.org/wiki/Brownsche_Brücke ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUB (defun pick (a b &key (span 5)) (let ((rnd1 (car (rnd-number 1 (+ a span) (- a span)))) (rnd2 (car (rnd-number 1 (+ b span) (- b span)))) (n)) (progn (setf n (car (rnd-number 1 rnd1 rnd2))) (if (or (= n a) (= n b)) (+ (rnd-pick '(1 -1)) n) n)))) (pick 2 3) ;;; MAIN ;;; MAIN (defun gen-brownian-bridge (n startend &key (all-gen nil) (output 'integer) (span 5)) (let ((seq)) (progn (setf seq (append (list startend) (loop repeat n with liste = startend do (setf liste (filter-repeat 1 (loop repeat (1- (length liste)) for cnt = 0 then (incf cnt) append (append (list (nth cnt liste) (pick (nth cnt liste) (nth (1+ cnt) liste) :span span) (nth (1+ cnt) liste)))))) collect liste))) (setf seq (if (equal all-gen t) seq (car (last seq)))) (if (equal output 'pitch) (integer-to-pitch seq) seq)))) ;;; EXAMPLES ;; SPAN influence -> span 2 (loop repeat 20 do (list-plot (gen-brownian-bridge 5 '(1.2 5.4) :span 2 :all-gen t) :zero-based t :point-radius 3 :join-points t) do (sleep 2)) ;; SPAN influence -> span 10 (list-plot (gen-brownian-bridge 5 '(50 23) :span 20 :all-gen t) :zero-based t :point-radius 3 :join-points t) ;;; SPAN default (5) (list-plot (gen-brownian-bridge 5 '(50 23) :all-gen t) :zero-based t :point-radius 3 :join-points t) (list-plot (gen-brownian-bridge 5 '(50 23)) :zero-based t :point-radius 3 :join-points t) (gen-brownian-bridge 5 '(50 23) :all-gen t :output 'pitch) (gen-brownian-bridge 5 '(50 23) :output 'pitch)  

i like the concept of "brownian bridge" to produce complex curves from a to b, but not completely randomized or controlled. in the video you see all the generations for one evaluation...
 
how it could sound - mapped on different tonalities
 
 
 
Brownsche Brücke – Wikipedia
DE.WIKIPEDIA.ORG  
for understanding in OPMO:
 
axiom: start end
(50 23)
 
gen1 => 1 step
(50 8 23)
 
gen2  => 3 steps
(50 15 8 -3 23)
 
gen3 => 7 steps
(50 40 15 13 8 -14 -3 29 23)
 
gen4 => 15 steps
(50 58 40 33 15 22 13 4 8 4 -14 -16 -3 17 29 17 23)
 
...and so on
 
-------------------------------------------------------------------------------
 
some evaluations with same AXIOM:
 

Bildschirmaufnahme 2023-07-08 um 11.09.51.mov  
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; BROWNIAN BRIDGE -> could be use as a rnd-process from A to B (integers or pitches) ;;; if you have a look to example with ":all-gen t", you will see the process with all generations, how it works ;;; or take a look to: ;;; https://de.wikipedia.org/wiki/Wiener-Prozess#/media/File:BrownscheBewegung.png ;;; https://de.wikipedia.org/wiki/Brownsche_Brücke ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUB (defun pick (a b &key (span 5)) (let ((rnd1 (car (rnd-number 1 (+ a span) (- a span)))) (rnd2 (car (rnd-number 1 (+ b span) (- b span)))) (n)) (progn (setf n (car (rnd-number 1 rnd1 rnd2))) (if (or (= n a) (= n b)) (+ (rnd-pick '(1 -1)) n) n)))) (pick 2 3) ;;; MAIN ;;; MAIN (defun gen-brownian-bridge (n startend &key (all-gen nil) (output 'integer) (span 5)) (let ((seq)) (progn (setf seq (append (list startend) (loop repeat n with liste = startend do (setf liste (filter-repeat 1 (loop repeat (1- (length liste)) for cnt = 0 then (incf cnt) append (append (list (nth cnt liste) (pick (nth cnt liste) (nth (1+ cnt) liste) :span span) (nth (1+ cnt) liste)))))) collect liste))) (setf seq (if (equal all-gen t) seq (car (last seq)))) (if (equal output 'pitch) (integer-to-pitch seq) seq)))) ;;; EXAMPLES ;; SPAN influence -> span 2 (loop repeat 20 do (list-plot (gen-brownian-bridge 5 '(1.2 5.4) :span 2 :all-gen t) :zero-based t :point-radius 3 :join-points t) do (sleep 2)) ;; SPAN influence -> span 10 (list-plot (gen-brownian-bridge 5 '(50 23) :span 20 :all-gen t) :zero-based t :point-radius 3 :join-points t) ;;; SPAN default (5) (list-plot (gen-brownian-bridge 5 '(50 23) :all-gen t) :zero-based t :point-radius 3 :join-points t) (list-plot (gen-brownian-bridge 5 '(50 23)) :zero-based t :point-radius 3 :join-points t) (gen-brownian-bridge 5 '(50 23) :all-gen t :output 'pitch) (gen-brownian-bridge 5 '(50 23) :output 'pitch)  

3.0.29004
 
– New functions:
REMOVE-ATTRIBUTE REPEAT-ATTRIBUTE NTH-EVENT OMN-LAST-EVENT OMN-BUTLAST-EVENT
Happy coding,
Janusz

;;; quick-function (defun make-seq (&key (prob 0.5) (possible-pitches (make-scale 'c4 11))) ;; prob = length/rest-weight (make-omn :pitch (rnd-sample 10 possible-pitches) :length (gen-length (loop for i in (rnd-sum-to-size 20 10 '(1 2 3 4 5)) collect (if (probp prob) (* -1 i) i)) '1/16) :span :length)) ;;; EVAL (make-seq) (make-seq :possible-pitches (midi-to-pitch (gen-integer 10 110))) ;; with rnd-pitches of course... with 60bpm

smart 🙂

smart 🙂

(setf pitches (rnd-sample 12 (midi-to-pitch '(65 64 63 62 61 60))))  
If the tempo is 60 then the span is 5/4 etc...
 
(setf lengths (length-span 5/4 (rnd-sample 6 '(s -s e. q)))) (make-omn :length lengths :pitch pitches)

....or use some technology 😉
 
https://polytempo.zhdk.ch
 
Dirigierende Maschinen
WWW.TRANSCRIPT-VERLAG.DE Eine musik- und technikgeschichtliche Abhandlung zur musikalischen Aufführungspraxis mit technischer Tempovermittlung.  
 

Many years ago, I composed my inaugural string quartet, characterized by numerous tempo alterations for each instrument. Unfortunately, the notation—our primary means of communication—proved wholly ineffective.
 
In the present day, I frequently create compositions featuring varied tempos for individual instruments. However, I now ensure that the notation—a vital line of communication with the performer—is uniformly inscribed in a single tempo.
 
To facilitate this, I've developed the LENGTH-TO-TEMPO function. The concept of polytempo offers an intriguing structure, but its true potential is only realized when we manage to transcribe it into a consistent tempo for all.
 

New function:

GEN-ENVELOPE-TENDENCY
This function takes a list of data and adjusts the values to fit within the specified lower and upper envelope limits. If a value is outside the given envelope, the function will adjust it to fit within the envelope and all subsequent values in the list are also adjusted by the same amount, which helps to preserve the original shape of the data.
 
Examples:
 
(setf data (gen-brownian-motion 128 :seed 43))  

 
(setf len (length data)) (setf l-limit (envelope-samples '(0 0 1 -1 2 -1 3 -2 4 3 5 -1 6 0) len)) (setf u-limit (envelope-samples '(0 1 1 4 2 2 3 4 6 4) len)) (xy-plot (list l-limit u-limit) :join-points t)  

 
(setf adj (gen-envelope-tendency data l-limit u-limit :seed 12)) (list-plot adj :zero-based t :point-radius 2 :join-points t)  
 

 
With optional reflect T:
 
(setf ref (gen-envelope-tendency data l-limit u-limit :reflect t :seed 12)) (list-plot reflect :zero-based t :point-radius 2 :join-points t)  
 

 
Happy coding,
Janusz

I'll try to do a first proof of concept 🙂 Will start working on it this week to get a first impression of how complex this might be.
 
Will keep you informed.
 
Feel free to follow any progress: 
GitHub - willemdijkgraaf/MidiXmlToOMN: Converts Midi XML to OMN (OpusModus Notation)
GITHUB.COM Converts Midi XML to OMN (OpusModus Notation). Contribute to willemdijkgraaf/MidiXmlToOMN development by creating an account on GitHub.  

Great news 🙂
We would need to end up with DEF-SCORE, same as we do with the MIDI to Score function: MusicXML to Score.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; subfunction (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)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; check it out ;; command-1 (list-plot (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 6 22 9 73 28 68)) 3) :type 'integer)) 1/64) :value 1/64) :point-radius 2 :join-points t) (list-plot (length-staccato (gen-length (reset-integer-sequence (ffth 4 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 6 22 9 73 28 68)) 3) :type 'integer)) 1/64) :value 1/64) :point-radius 2 :join-points t)  
with 4 voices....
eval -> (command-3)
 
 
(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)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setf s1 (make-omn :pitch '(c1) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s2 (make-omn :pitch '(cs4) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s3 (make-omn :pitch '(d5) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s4 (make-omn :pitch '(ds7) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32))) (omn-to-time-signature (merge-voices s1 s2 s3 s4) '(4 4))  

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; subfunction (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)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; check it out ;; command-1 (list-plot (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 6 22 9 73 28 68)) 3) :type 'integer)) 1/64) :value 1/64) :point-radius 2 :join-points t) (list-plot (length-staccato (gen-length (reset-integer-sequence (ffth 4 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 6 22 9 73 28 68)) 3) :type 'integer)) 1/64) :value 1/64) :point-radius 2 :join-points t)  
with 4 voices....
eval -> (command-3)
 
 
(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)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (setf s1 (make-omn :pitch '(c1) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s2 (make-omn :pitch '(cs4) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 13 44 68 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s3 (make-omn :pitch '(d5) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32)) s4 (make-omn :pitch '(ds7) :length (length-staccato (gen-length (reset-integer-sequence (ffth 6 0.075 (x-b (rnd-order '(44 52 22 23 68 6 22 9 73 28 68)) 3) :type 'integer) :offset 4) 1/64) :value 1/32))) (omn-to-time-signature (merge-voices s1 s2 s3 s4) '(4 4))  

I will add to the function reflect -  ensures the simulated motion stays between the lower and upper limits by reflecting it at those limits.

How would a tendency mask be different to this?
(progn (setf bw (gen-brownian-motion 128 :seed 425)) (setf env1 '(-5.1 -2.3 1.5 -0.8 4.6 10.6)) (setf env2 '(1.0 1.2 -1.1 2.1 -0.3 -2.5)) (list-plot (vector-to-envelope2 env1 env2 bw)) )  

For me, I think that's perfect !
 
I know many of the OM functions but totally forgot about that one.
 
Thank you for the trick !
 
Best
 
S.

great!
 
(progn (setf r1 (gen-length '(11 13 7 17 13 11 17 23 19 2 17 5) 1/20)) (setf r2 (gen-length '(11 13 7 17 13 11) 1/8)) (unify-rhythms r1 r2))  

great!
 
(progn (setf r1 (gen-length '(11 13 7 17 13 11 17 23 19 2 17 5) 1/20)) (setf r2 (gen-length '(11 13 7 17 13 11) 1/8)) (unify-rhythms r1 r2))  

The new function UNIFY-RHYTHMS will solve your problem - 3.0.28916
 
Examples:
 
(setf l1 '(q e e 3q 3q 3q -e. s)) (setf l2 '(e e e. s -e e s -s s -s))  
(list l1 l2) ; select and press cmd-2  
 
(unify-rhythms l1 l2)
 
(setf r1 (rhythm-series 6 5 3/8 :length '(q. e. e s 3q))) (setf r2 (rhythm-series 6 4 1/2 :length '(q. e. e s 3q))) (setf r3 (rhythm-series 6 3 1/2 :length '(q. e. e s 3q)))  
(list r1 r2 r3) ; select and press cmd-2  

 
Now we merge all three voices to form a single entity:
 
(unify-rhythms r1 r2 r3)