opmo

My understanding of what you are trying to do is that you should explore loop, here are few examples which might help you with your work:
 
(loop for i in '(1 4 1 4) when (not (equal 1 i)) counting i) => 2 (loop for i in '(8 6 8 7 4 3 3 6 2 2 9 7) counting (evenp i) into evens counting (oddp i) into odds summing i into total maximizing i into max minimizing i into min finally (return (list min max total evens odds))) => (2 9 65 7 5) (loop for i in '(1 2 3) when (> i 1) return i) => 2 ;;; Position (loop for i in '(1 4 1 4) with cnt = -1 for n = (incf cnt) when (not (equal 1 i)) collect n) => (1 3) (loop for i from 1 to 100 if (evenp i) minimize i into min-even and maximize i into max-even and unless (zerop (mod i 4)) sum i into even-not-fours-total end and sum i into even-total else minimize i into min-odd and maximize i into max-odd and when (zerop (mod i 5)) sum i into fives-total end and sum i into odd-total finally (return (list min-even max-even min-odd max-odd even-total odd-total fives-total even-not-fours-total))) => (2 100 1 99 2550 2500 500 1250) (loop repeat 10 collect (random 10000)) => (4338 3277 1359 1272 3755 711 4365 828 4652 2346) (loop repeat 5 for x = 0 then y for y = 1 then (+ x y) collect y) => (1 2 4 8 16) (loop repeat 5 for y = 1 then (+ x y) for x = 0 then y collect y) => (1 1 2 4 8) (loop repeat 5 for x = 0 then y and y = 1 then (+ x y) collect y) => (1 1 2 3 5) (loop for i in '(1 2 3) when (> i 1) return i) => 2 (loop for i across #(1 2 3) do (print i)) => 1 => 2 => 3 => nil (loop for x from 1 to 3 collect (loop for y from 1 to x collect y)) => ((1) (1 2) (1 2 3)) (loop for x from 1 to 3 for y = (* x 10) collect y) => (10 20 30) (loop repeat 10 for x = (random 100) if (evenp x) collect x into evens else collect x into odds finally (return (values evens odds))) => (52 94 86 50 8 50) => (85 27 1 39) (loop for x in '(1 2 3 4 5) until (> x 3) collect x) => (1 2 3) (loop for x in '(1 2 3 4 5) while (< x 4) do (format t "x is ~a~&" x) collect x) => x is 1 => x is 2 => x is 3 => (1 2 3) (loop named loop-1 for x from 0 to 10 by 2 do (loop for y from 0 to 100 by (1+ (random 3)) when (< x y) do (return-from loop-1 (values x y)))) => 0 => 2 (loop for x in '(foo 2) thereis (numberp x)) => t (loop for x in '(foo 2) never (numberp x)) => nil (loop for x in '(foo 2) always (numberp x)) => nil (loop for i from 1 to 3 count (oddp i)) => 2 (loop for i from 1 to 3 sum i) => 6 (loop for i from 1 to 3 maximize (mod i 3)) => 2 (loop for (a b) in '((x 1) (y 2) (z 3)) collect (list b a)) => ((1 x) (2 y) (3 z)) (loop for (x . y) in '((1 . a) (2 . b) (3 . c)) collect y) => (a b c) ;;; Use nil to ignore a term: (loop for (a nil) in '((x 1) (y 2) (z 3)) collect a) => (x y z) (loop for i upto 10 collect i) => (0 1 2 3 4 5 6 7 8 9 10) (loop for i from 0 downto -10 collect i) => (0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10) (loop for i in (list 10 20 30 40) collect i) => (10 20 30 40) (loop for i in (list 10 20 30 40) by #'cddr collect i) => (10 30) (loop for x on (list 10 20 30) collect x) => ((10 20 30) (20 30) (30)) (loop for x on (list 10 20 30 40) by #'cddr collect x) => ((10 20 30 40) (30 40))  
Tutorial for the Common Lisp Loop Macro
WWW.AI.SRI.COM  
Loop, iteration, mapping
LISPCOOKBOOK.GITHUB.IO A collection of examples of using Common Lisp  

Exactly, Stephane !!
 
This is precisely the way I´m working.
I´d like to share with you in the forum the complete process for generating the score.
Goes like this:
And with this new function it will became easier !!
Best,
Julio
 
;;; Julio Herrlein ;;;Compositional Process - String Quartet ;;; CHORALE - MIDI GUITAR RECORDED (progn (setf pitmidi2 '(a3b3e4ab4 gs3ds4g4bb4 cs3a3b3e4 gs2f3as3d4)) (assign-variable 'ch pitmidi2) ;;;FASTER PITCH-DEMIX using Array (setf chordarray (build-array (sort-desc (melodize (mclist pitmidi2))))) (setf size (get-count pitmidi2)) ;;; v1rp - repeating 16 notes (setf chrptimes '(16)) (assign-variable 'v1rp (gen-repeat chrptimes (mclist (get-array 0 0 size chordarray :direction 'down)))) (assign-variable 'v2rp (gen-repeat chrptimes (mclist (get-array 0 1 size chordarray :direction 'down)))) (assign-variable 'v3rp (gen-repeat chrptimes (mclist (get-array 0 2 size chordarray :direction 'down)))) (assign-variable 'v4rp (gen-repeat chrptimes (mclist (get-array 0 3 size chordarray :direction 'down)))) ;;; repeating notes material ;;; VOZ 1 a 4 (setf vrpt1 '(v1rp0 v1rp1 v1rp2 v1rp3)) (setf vrpt2 '(v2rp0 v2rp1 v2rp2 v2rp3)) (setf vrpt3 '(v3rp0 v3rp1 v3rp2 v3rp3)) (setf vrpt4 '(v4rp0 v4rp1 v4rp2 v4rp3)) ;;;MELODIC MATERIAL - arpeggios or custom material ;;VL 1 (assign-variable 'melch1- (gen-repeat '(4) (ambitus-octaves 'e4 1 (pitch-rotate 1 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml1 '(melch1-0 melch1-1 melch1-2 melch1-3)) ;;VL 2 (assign-variable 'melch2- (gen-repeat '(4) (ambitus-octaves 'e3 1 (pitch-rotate 0 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml2 '(melch2-0 melch2-1 melch2-2 melch2-3)) ;; VIOLA (assign-variable 'melch3- (gen-repeat '(4) (ambitus-octaves 'e3 1 (pitch-rotate -2 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml3 '(melch3-0 melch3-1 melch3-2 melch3-3)) ;; CELLO (assign-variable 'melch4- (gen-repeat '(4) (ambitus-octaves 'e2 1 (pitch-rotate -1 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml4 '(melch4-0 melch4-1 melch4-2 melch4-3)) ;;; MIXING LISTS (repeated notes and melodic fragments) (setf list1 vrpt1) (setf list1b vml1) (setf v1dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list1 list1b)))))) (setf list2 vrpt2) (setf list2b vml2) (setf v2dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list2 list2b)))))) (setf list3 vrpt3) (setf list3b vml3) (setf v3dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list3 list3b)))))) (setf list4 vrpt4) (setf list4b vml4) (setf v4dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list4 list4b)))))) ;;; Length Map atualizado - 8 FEV (setf len-map1 '((e (stacc)) (s (ord)) (h (long)) (h. (long)) (w (long)))) (setf len-map2 '((e (list (rnd-pick '(mf f)))) (s (mf)) (e. (mf)) (h (p<f)) (h. (p<f)) (w (P<f>p))(wq (P<f>p))(wh (P<f>p))(wh. (P<f>p))(ww (P<f>p)))) ;;;RITMOS ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 12 mar B (setf rv1 (gen-repeat 5 (gen-divide '(3 7) (gen-repeat 5 '(q e. s s s s s h_e s s))))) (setf rv2 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-e eh -e eh))))) (setf rv3 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-q qq -q qq))))) (setf rv4 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-q. eq -q. eq))))) (setf timesig '(6 4 1)) (setf timesigs '((6 4 1) (6 4 1))) (setf timesig-proc (butlast (gen-divide 3 (span (flatten v1dt) timesigs)))) ) ;;;FINAL DO PROGN INITIALIZE ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;BUG TRACKING #3 11 mar ;;; Mudando o :span de :pitch para :length, ;;faz com que cada vez que recomeça a lista de length os acordes partem do início;;isso pode ser interessante e os ritmos estão com o comportamento esperado (progn ;(setf timesig '(6 4 1)) (setf vh1-2 (make-omn :length rv1 :pitch (span rv1 v1dt) :span :length :velocity (length-map len-map2 rv1 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv1 :otherwise '(ord) :repeat t))) (setf vh2-2 (make-omn :length rv2 :pitch (span rv2 v2dt) :span :length :velocity (length-map len-map2 rv2 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv2 :otherwise '(ord) :repeat t))) (setf vh3-2 (make-omn :length rv3 :pitch (span rv3 v3dt) :span :length :velocity (length-map len-map2 rv3 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv3 :otherwise '(ord) :repeat t))) (setf vh4-2 (make-omn :length rv4 :pitch (span rv4 v4dt) :span :length :velocity (length-map len-map2 rv4 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv4 :otherwise '(ord) :repeat t))) (ps 'gm :sq ;(list (pitch-transpose 12 vh1-2) vh2-2 vh3-2 vh4-2) (list (pitch-transpose 12 (ambitus 'violin vh1-2)) (ambitus 'violin vh2-2) (ambitus 'viola vh3-2) (ambitus 'cello vh4-2)) :key-signature 'atonal ;;;obs: abrindo o time sig aqui, faz bypass do omn-to-time-signature acima :time-signature timesig-proc ;time-signature timesig :tempo 80 :title "STR 4tet" :display :window)) ;;;>>>>>>>>>>>>> F I N A L <<<<<<<<<<<<<<<<< ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  

i've experimented a bit with pitch alignment for controlling harmony, here's what I tried. Hope it could help.
;;; Pich alignment with binaries ;;; Proof of concept (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf pch '(c4 d4 e4 f4 g4 a4 b4 c5 b4 a4 g4 f4 e4 d4 c4)) (setf pch1 (binary-map bin1 pch)) (setf pch2 (binary-map bin2 pch)) (setf pch3 (binary-map bin3 pch)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :fl (list omn2) :fl (list omn3)) ) ;;; Now with intervals (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf pch '(c4 d4 e4 f4 g4 a4 b4 c5 b4 a4 g4 f4 e4 d4 c4)) (setf pch1 (binary-map bin1 pch)) (setf pch2 (binary-map bin2 (pitch-transpose-n '(-4 -3 -7) pch1))) (setf pch3 (binary-map bin3 (pitch-transpose-n '(-17 -20 -19) pch1))) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) ;;; Pitch generation from choral with 7th chords (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf chords (gen-chord3 '(d3 f3 e3 a3) '((10 16)))) (setf cpch1 (pitch-demix 1 chords)) (setf cpch2 (pitch-demix 2 chords)) (setf cpch3 (pitch-demix 3 chords)) (setf pch1 (binary-map bin1 cpch1)) (setf pch2 (binary-map bin2 cpch2)) (setf pch3 (binary-map bin3 cpch3)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) ;;; Same as above but with chord change only on every bar (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf chords (gen-chord3 '(d3 f3 e3 a3) '((10 16)))) (setf cpch1 (mclist (pitch-demix 1 chords))) (setf cpch2 (mclist (pitch-demix 2 chords))) (setf cpch3 (mclist (pitch-demix 3 chords))) (setf pch1 (binary-map bin1 cpch1)) (setf pch2 (binary-map bin2 cpch2)) (setf pch3 (binary-map bin3 cpch3)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) SB.

Julio, you need to do that before and not in the make-omn.

You saved me from the bullets

(setf list1 '(v1rp0 v1rp1 v1rp2 v1rp3 v1rp4)) (setf list2 '(melch1-0 melch1-1 melch1-2 melch1-3 melch1-4)) (matrix-transpose (list list1 list2)) => ((v1rp0 melch1-0) (v1rp1 melch1-1) (v1rp2 melch1-2) (v1rp3 melch1-3) (v1rp4 melch1-4))  
or
(setf mat1 '((c4 db4) (ab4 f4) (g4 bb4) (a4 eb4) (b4 e4) (d4 gb4))) (setf mat2 '((db4 ab4) (f4 g4) (bb4 a4) (eb4 b4) (e4 d4) (gb4 c4))) (gen-mix mat1 mat2) => ((c4 db4) (db4 ab4) (ab4 f4) (f4 g4) (g4 bb4) (bb4 a4)     (a4 eb4) (eb4 b4) (b4 e4) (e4 d4) (d4 gb4) (gb4 c4))  

(setf mat0 '(c4 d4 cs5)) (setf mat1 '(c4 db4 ds7)) (setf mat2 '(d4 e4 c5)) (setf mat3 '(d4 eb4 cs5)) (setf mat4 '(d4 f4 c5)) (setf mat5 '(d4 g4 c5)) (setf mat6 '(d4 a4 c5)) (setf mat7 '(e4 a4 c5)) (setf mat8 '(f4 a4 c5)) (setf mat9 '(g4 a4 c5)) (setf mat10 '(a4 a4 c5)) (setf mat11 '(b4 a4 c5)) (setf array (build-array (list (assemble-seq mat0 mat1 mat2 mat3) (assemble-seq mat4 mat5 mat6 mat7) (assemble-seq mat8 mat9 mat10 mat11)))) (get-array 0 1 2 array :direction 'down) => ((c4 db4 ds7) (d4 g4 c5))
In your variables mat0 was missing.

With OMN-DICTUM you are able to edit and make any correction into your score.

Is fixed already with FT function inside - next update.
 
(ft '(1 3 6..9 11)) => (1 3 6 7 8 9 11) (ft '0..12) => (0 1 2 3 4 5 6 7 8 9 10 11 12) (ft '0..-12) => (0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12) (ft '(1 3 6..9 11)) => (1 3 6 7 8 9 11) (ft '(0..12 11..0)) => (0 1 2 3 4 5 6 7 8 9 10 11 12 11 10 9 8 7 6 5 4 3 2 1 0)  

Fixed in 2.1.26237

Depends on what you want to do with the generated material.
Useful function:
unfold, omn-dictum, find-bar, position-item, position-replace, position-swap
 
Many functions allow you to edit selected bars:
:section (numbers)
 
(pprint-last-score) could help as well with bar numbers.
 
Enable 'Bar Number Display' in the Preferences/Notation

here it is:

here it is:

Please to hear 🙂

Don't use tie in lengths only:
(setf rv1 '(w s s s s_q -q s s s s -q -q -q -q q -q -q h -q h. -e. s s s s s s e s -s e._q -q))  

I would use OMN-DICTUM instead of LENGTH-MAP.

When I installed the latest version, I had to clean the cache to have it working properly. Best !

Interesting Free VST Orchestral Plugin from BBC.
Nice for pedagogical purpose (it´s free for students)
Best,
Julio
 
 

Thanks, André !
 
It´s interesting to note that it relates to the idea of what is considered among the forms of the any 12 tone row.
The question is if the proliferant series resultant are some kind of transposition, inversion, rotation, retrogradation or multiplication of the original tone row.
 
In the studies about the enumeration of tone rows this is a decisive point. What is considered to be related or derived of a first tone row ?
I´m not absolutely sure about it, but I´m using this as a reflection...
So, maybe we can consider the following as byproducts of a given 12 tone aggregate, in original (O) form:
 
1) There wil be 12 transpositions of  (O)
2) the Inverted Form ( I ) and 12 transpositions of it;
3) the Retrograde Form ( R ) and 12 transpositions of it;
4) the Retrograde Inversion Form ( RI ) and 12 transpositions of it;
 
This (O, R, RI and I) sums 48 derived rows of one 12-tone aggregate and this is the basic matrix.
 
This is the trivial 12-tone theory, but beyond that, what can we consider as being derived from the same ordered set ?
It´s not difficult to accept that all rotations of a 12-tone ordered set are derived from it. Take for example this Opus 25 tone row from "Arnie":
 
E–F–G–D♭–G♭–E♭–A♭–D–B–C–A–B♭  (O, rot 0)
    F–G–D♭–G♭–E♭–A♭–D–B–C–A–B♭-E (O, rot 1)
        G–D♭–G♭–E♭–A♭–D–B–C–A–B♭-E-F (O, Rot 2)
            D♭–G♭–E♭–A♭–D–B–C–A–B♭-E-F-G  (etc)
                  G♭–E♭–A♭–D–B–C–A–B♭-E-F-G-Db
                        E♭–A♭–D–B–C–A–B♭-E-F-G-Db-Gb
                             A♭–D–B–C–A–B♭-E-F-G-Db-Gb-Eb
                                   D–B–C–A–B♭-E-F-G-Db-Gb-Eb-Ab
                                       B–C–A–B♭-E-F-G-Db-Gb-Eb-Ab-D
                                           C–A–B♭-E-F-G-Db-Gb-Eb-Ab-D-B
                                               A–B♭-E-F-G-Db-Gb-Eb-Ab-D-B-C
                                                   B♭-E-F-G-Db-Gb-Eb-Ab-D-B-C-A
                                                        E-F-G-Db-Gb-Eb-Ab-D-B-C-Bb
 
1) The 12 rotations of ( O ) and all this transpositions (144)
1) The 12 rotations of ( I ) and all this transpositions (144)
1) The 12 rotations of ( R ) and all this transpositions (144)
1) The 12 rotations of ( RI ) and all this transpositions (144)
 
So, thinking this way, there are actually 576 derived forms of one each 12-tone row.
In some special cases, the ( I ) can be the same of some retrograde or transposing form, in the case of invariance. 
The same goes for some types of hexachordal combinatoriality. 
 
And there are the multiplication series...
 
Just some food for thoughts
 
All the best !
 
Julio

Thank you for this function / script regarding "les séries proliférantes". By carrying out a research on the book "Jean Barraqué, Ecrits" and published by the "publications of the Sorbonne" I discovered this site around Jean Barraqué and in particular examples of the scores and the booklets of "Séquence (1950-55) , "Le temps restitué (1959)", "... au delà du hasard (1959)", "Chant après chant (1966)" and "Concerto (1968)". I tell myself that under the documentation that might be of interest to members :
 
Bärenreiter Verlag - Download
WWW.BAERENREITER.COM Concerning "Ecrits Jean Barraqué, réunis, présentées et annotées par Laurent Feneyrou", for those who read French, I found a communication and an article published on the site "Entretemps". The communication to "Samedi d'Entretemps of October 26, 2002," Jean Barraqué: de l'écrit, le devenir" by Franck C. Yeznikan, evokes in particular the analyzes published in the book on Beethoven, Debussy, Webern, Messiaen:
 
Jean Barraqué : de l'écrit, le devenir
WWW.ENTRETEMPS.ASSO.FR  
"Le Souci du Développement chez Barraqué" by François Nicolas, published in Entretemps n ° 5 in 1987, evokes the two main references of Barraqué according to the author, "Beethoven and Debussy ", his admiration of Webern and Schubert. Without forgetting the interest and taste of Barraqué concerning musical analysis.

And to stay on topic on "les séries proliférantes", a theoretical explanation on this technique developed by Barraqué to escape the immutable intervallic structures of series  : 
 
Le souci du développement chez Barraqué
WWW.ENTRETEMPS.ASSO.FR  

here  a function... to barraqué's techniques
 
(defun serie-proliferantes (row) (let* ((ri_row (pitch-invert (gen-retrograde row))) (row (loop for z in (loop for x in (pitch-to-midi ri_row) collect (or (position x (pitch-to-midi row)) (position (- x 12) (pitch-to-midi row)) (position (+ x 12) (pitch-to-midi row)))) collect (nth z ri_row)))) row)) (serie-proliferantes '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)) => (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)  
Jean Barraqué — Wikipédia
FR.WIKIPEDIA.ORG  
seen here:
https://www.amazon.de/Jean-Barraqué-Musik-Konzepte-Heinz-Klaus-Metzger/dp/3883774499
 
page 19-20
 
 

 

 

violà... now it works fine 🙂  - OPMO could integrate it....  
 
it's easier than i thought: a single index-series is read from the r-i and only this one is used! similar to LACHEMANN, only he determines this index-series himself (for that i coded this simple row-permutation-function)...
 
greetings
a.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUB (defun row-permutation (n row rules &key (one-based nil)) (let* ((rules (if (equal one-based t) (mapcar '1- rules) rules))) (loop repeat n collect (setf row (position-filter rules row))))) ;;; MAIN (defun serie-proliferantes (n row) (let ((index-no (loop for x in (pitch-to-midi (pitch-invert (gen-retrograde row))) collect (or (position x (pitch-to-midi row)) (position (- x 12) (pitch-to-midi row)) (position (+ x 12) (pitch-to-midi row)))))) (list row (pitch-invert (gen-retrograde row)) (row-permutation n (pitch-invert (gen-retrograde row)) index-no)))) (serie-proliferantes 6 '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)) => ((c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) ((fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) (bb4 fs4 cs5 g4 gs4 a4 d5 c5 f4 b4 eb5 e5) (e5 bb4 g4 cs5 c5 fs4 gs4 a4 b4 f4 d5 eb5) (eb5 e5 cs5 g4 a4 bb4 c5 fs4 f4 b4 gs4 d5) (d5 eb5 g4 cs5 fs4 e5 a4 bb4 b4 f4 c5 gs4) (gs4 d5 cs5 g4 bb4 eb5 fs4 e5 f4 b4 a4 c5)))  

Recorded LiveCoding improvisation performance.

 
SB.

This is how it works, but I will extend the length to cover all possible positions.
 
(setf test '(c4 d4 e4 fs5 e4)) (position-insert '(1 3 5 7 9) 'b3 test) => (c4 b3 d4 b3 e4 b3 fs5 b3 e4 b3)