opmo

To see what :bar-adjustments can do now, please check the 'Layout.opmo' document and the Layout doc in the System Library. I will add the :ignore-stems to our todo list.

I will check this when the time permits.

MusicXML (Notation): Fixes slur position in grand-staff layout, tempo (text) collision with starting note and tuplet brackets in grand-staff layout if rest length only. New: section and exclude options added to more functions as well as omn processing. Performance improvements (optimisation). best wishes, Janusz

Here it is: (defun tmap (tonality) (tonality-map `(,tonality :root b3 :map shift) (make-scale 'c4 12))) (tmap (pcs '3-2)) => (b3 c4 d4 b4 c5 d5 b5 c6 d6 b6 c7 d7)

The return is what you are looking for: (tonality-map '((pcs '3-2) :root b3 :map shift) (make-scale 'c4 12)) => (b3 c4 d4 b4 c5 d5 b5 c6 d6 b6 c7 d7) or I don't understand you question

Update to MusicXML notation display. Added functions working with OMN events: GEN-TRIM (gen-trim 12 '(q c4 mf e d4 e4)) => (q c4 mf e d4 e4 q c4 e d4 e4 q c4 e d4 e4 q c4 e d4 e4) (gen-trim '(12 4) '((e c4 mf d4) (e e4 mf s f4 g4))) => ((e c4 mf d4 c4 d4 c4 d4 c4 d4 c4 d4 c4 d4) (e e4 mf s f4 g4 e e4)) GEN-REPEAT (gen-repeat 3 '(s c4 q d4)) => (s c4 mf q d4 s c4 q d4 s c4 q d4) (gen-repeat '(3) '(q c4 d4 e4 f4 g4 a4)) => ((q c4 mf c4 c4) (q d4 mf d4 d4) (q e4 mf e4 e4) (q f4 mf f4 f4) (q g4 mf g4 g4) (q a4 mf a4 a4)) (gen-repeat 3 '((q c4 g4) (s c4 a4))) => ((q c4 mf g4) (s c4 mf a4) (q c4 mf g4) (s c4 mf a4) (q c4 mf g4) (s c4 mf a4)) (gen-repeat '(3) '((q c4 e g4) (s c4 a4) (e b4 d5 q fs5))) => ((q c4 mf e g4 q c4 e g4 q c4 e g4) (s c4 mf a4 c4 a4 c4 a4) (e b4 mf d5 q fs5 e b4 d5 q fs5 e b4 d5 q fs5)) (gen-repeat '(3 2) '((q c4 g4) (s c4 a4) (e b4 d5))) => ((q c4 mf g4 c4 g4 c4 g4) (s c4 mf a4 c4 a4) (e b4 mf d5 b4 d5 b4 d5)) GEN-REPEAT-SEQ (gen-repeat-seq 8 1 3 '(q c4 mf e cs4 s d4 s ds4)) => (q c4 mf e cs4 cs4 cs4 s d4 d4 d4 ds4) (gen-repeat-seq '(5 2 7 1) 1 2 '((q c4d4e4f4 p) (s c4 mp fs4) (e c4d4e4f4 f) (e c4 fs4 =) (e c4d4e4f4 p))) => ((q c4d4e4f4 p c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4) (s c4 mp fs4) (e c4d4e4f4 f c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4) (e c4 f) (e c4d4e4f4 p c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4)) Best wishes, Janusz

New: single-events sequence [Function] Arguments and Values: sequence omn sequence. Description: The function SINGLE-EVENTS brakes-up an omn sequence into a new list of single events (l p v a). (single-events '(s bb3 leg a3 mp leg g3 a3 f c4 f4 a4)) => ((s bb3 mf leg) (s a3 mp leg) (s g3 mp) (s a3 f) (s c4 f) (s f4 f) (s a4 f)) Examples: (single-events '((s bb3 leg a3 mp leg g3 a3 f c4 f4 a4) (-q s bb4 c5 mf stacc b4 c5 mf d5 eb5 fff f5 eb5 d5))) => (((s bb3 mf leg) (s a3 mp leg) (s g3 mp) (s a3 f) (s c4 f) (s f4 f) (s a4 f)) ((-q) (s bb4 mf) (s c5 mf stacc) (s b4 mf) (s c5 mf) (s d5 mf) (s eb5 fff) (s f5 fff) (s eb5 fff) (s d5 fff))) --------------------------------------------------------------- gen-steps step sequence &key seed [Function] Arguments and Values: step an integer or list of integers (number of steps). sequence a sequence. seed an integer or NIL. The default is NIL. Description: The function GEN-STEPS randomises the order of a sequence and returns it into the original sequence order, after a given number of steps. (gen-steps 12 '(0 1 2 3 4 5 6 7 8 9 10 11) :seed 43) => ((4 2 10 9 4 7 5 0 11 6 1 3) (4 2 2 9 4 7 5 0 11 6 1 3) (4 2 2 9 4 7 5 0 11 6 10 3) (4 2 2 9 4 7 5 0 11 9 10 3) (4 2 2 9 4 7 5 0 8 9 10 3) (4 2 2 9 4 7 5 7 8 9 10 3) (4 2 2 9 4 5 5 7 8 9 10 3) (0 2 2 9 4 5 5 7 8 9 10 3) (0 2 2 9 4 5 5 7 8 9 10 11) (0 2 2 9 4 5 6 7 8 9 10 11) (0 1 2 9 4 5 6 7 8 9 10 11) (0 1 2 3 4 5 6 7 8 9 10 11)) Examples: (gen-steps 6 '(c4 e4 g4 b4 f4 d4 b3) :seed 56) => ((a4 c4 f4 b4 e4 a4 d4) (c4 c4 f4 f4 e4 a4 d4) (c4 c4 f4 f4 e4 a4 b4) (c4 c4 e4 f4 e4 a4 b4) (c4 c4 e4 f4 g4 a4 b4) (c4 d4 e4 f4 g4 a4 b4)) OMN: (gen-steps 7 '(s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f - b4 ff c5 fff) :seed 45) => ((s g4 mf f4 mp c5 fff f4 mp g4 mf c4 ppp a4 f - b4 ff) (s g4 mf f4 mp c5 fff f4 mp g4 mf c4 ppp a4 f - c5 fff) (s g4 mf f4 mp e4 p f4 mp g4 mf c4 ppp a4 f - c5 fff) (s g4 mf d4 pp e4 p f4 mp g4 mf c4 ppp a4 f - c5 fff) (s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f a4 - c5 fff) (s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f - - c5 fff) (s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f - b4 ff c5 fff)) (pitch-variant (gen-steps '(3 4 5 4 3) '(s bb3 p a3 mp g3 a3 f c4 f4 a4 pp -q s bb4 c5 p b4 c5 mf d5 eb5 fff f5 eb5 d5) :seed 67) :variant '? :seed 3567) --------------------------------------------------------------- Added functions working with OMN events: (gen-crossover '((s bb3 p a3 mp g3) (s a3 f c4 f4 a4 pp)) '((-q s bb4 c5 p b4 c5 mf) (s d5 eb5 fff f5 eb5 d5)) :seed 45) => ((s bb3 p a3 mp c5 p b4 c5 mf) (-q s bb4 mf g3 mp) (s eb5 fff f5 eb5 d5) (s d5 mf a3 f c4 f4 a4 pp)) (gen-divide '(2 4 2) '(s c4 ppp d4 pp -q s e4 p f4 mp g4 mf a4 f b4 ff c5 fff)) => ((s c4 ppp d4 pp) (-q s e4 p f4 mp g4 mf) (s a4 f b4 ff) (s c5 fff)) (gen-interleave 2 '(s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f b4 ff c5 fff)) => ((s c4 ppp d4 pp) (s d4 pp e4 p) (s e4 p f4 mp) (s f4 mp g4 mf) (s g4 mf a4 f) (s a4 f b4 ff) (s b4 ff c5 fff)) (gen-interleave '((2) (3)) '((s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f b4 ff c5 fff) (s c4 ppp d4 pp e4 p f4 mp g4 mf a4 f b4 ff c5 fff)) :flatten t) => ((s c4 ppp d4 pp d4 e4 p e4 f4 mp f4 g4 mf g4 a4 f a4 b4 ff b4 c5 fff) (s c4 ppp d4 pp e4 p d4 pp e4 p f4 mp e4 p f4 mp g4 mf f4 mp g4 mf a4 f g4 mf a4 f b4 ff a4 f b4 ff c5 fff)) More to come... --------------------------------------------------------------- Notation: Articulation harm will display above the note now.

To share the .rtf files you need to compress the file first, the .rtf format file is a container file.

Velocity symbols displaying correctly now - no more repeat symbols on tied notes.

Fix to dynamic symbol repeats (one-note-dynamic). Extending the num attribiutes: num0 num1 num2 num3 num4 num5 num6 num7 num8 num9 num10 num11 num12 num-1 num-2 num-3 num-4 num-5 num-6 num-7 num-8 num-9 num-10 num-11 num-12

MIDI controller function: gen-dynamic-controller omn-sequence &key scale loop [Function] Arguments and Values: omn-sequence omn-form sequence. scale a floating point number from 0.1 to 2.0. The default is 1.0. loop Nil or T. The T (true) will loop the scale list to the count of the lists in the sequence. The default is Nil. Description: The GEN-DYNAMIC-CONTROLLER function generates controller values from the omn-sequence dynamic symbols. (setf omn '((h. eb4 pp tasto q g3 0<pp>0 ponte) (-e) (q gs4 fp tasto) (-s) (q a5 ffp) (-e) (q bb4 fffp) (-s) (q cs5 pf) (-s q. e5 fp -e.) (q cs5 p h. d5 pfp) (-q h. c5 pp) (h. gs3 0<ppp>0 ponte -e a4 p< tasto) (h. fs5 mp q bb3 0<pp>0 ponte) (q c5 p tasto h. e4 pfp) (-e) (q cs4 fp h d5 pp>pppp) (h. f4 pp>pppp))) (gen-dynamic-controller omn) => ((36 3/4) (:asc-desc 0 36 1/256 1/4) (0 1/8) (80 1/64) (:desc 30 25 1/256 15/64) (0 1/16) (91 1/64) (:desc 47 25 1/256 15/64) (0 1/8) (102 1/64) (:desc 56 25 1/256 15/64) (0 1/16) (25 1/64) (:asc 30 80 1/256 15/64) (0 1/16) (80 1/64) (:desc 30 25 1/256 23/64) (0 3/16) (47 1/4) (:asc-desc 23 80 1/256 3/4) (0 1/4) (36 3/4) (:asc-desc 0 25 1/256 3/4) (0 1/8) (:asc 47 58 1/256 1/8) (58 3/4) (:asc-desc 0 36 1/256 1/4) (47 1/4) (:asc-desc 23 80 1/256 3/4) (0 1/8) (80 1/64) (:desc 30 25 1/256 15/64) (:desc 36 14 1/256 1/2) (:desc 36 14 1/256 3/4)) This is the notation of the sequence, see above: Audio: Virtual Instrument: VSL: Violin Solo. The dynamic controller values are sent to CC11: Expression Examples: To scale up the controller values we set the :scale value higher than 1.0. To scale down the controller values we set the :scale value lower than 1.0. Here the scale value is 1.2: (gen-dynamic-controller omn :scale 1.2) => ((43 3/4) (:asc-desc 0 43 1/256 1/4) (0 1/8) (96 1/64) (:desc 36 30 1/256 15/64) (0 1/16) (109 1/64) (:desc 56 30 1/256 15/64) (0 1/8) (122 1/64) (:desc 67 30 1/256 15/64) (0 1/16) (30 1/64) (:asc 36 96 1/256 15/64) (0 1/16) (96 1/64) (:desc 36 30 1/256 23/64) (0 3/16) (56 1/4) (:asc-desc 24 96 1/256 3/4) (0 1/4) (43 3/4) (:asc-desc 0 30 1/256 3/4) (0 1/8) (:asc 56 70 1/256 1/8) (70 3/4) (:asc-desc 0 43 1/256 1/4) (56 1/4) (:asc-desc 24 96 1/256 3/4) (0 1/8) (96 1/64) (:desc 36 30 1/256 15/64) (:desc 43 17 1/256 1/2) (:desc 43 17 1/256 3/4)) To add more control to the dynamic of the sequence we can set each bar (a list) with their own scale value. In the example below the 4th value 1.0 will stay for all of the remaining bars (lists). (gen-dynamic-controller omn :scale '(1.0 1.1 1.2 1.0)) Adding loop to the scale keyword we are looping the scale values to the count of the lists in the sequence: (gen-dynamic-controller omn :scale '(1.0 1.1 1.2 1.0) :loop t) ;;;--------------------------------------------------------- ;;; SCORE EXAMPLE ;;;--------------------------------------------------------- It is important to use the same omn-sequence data that you are using in the DEF-SCORE instrument instance. (setf omn '((h. eb4 pp tasto q g3 0<pp>0 ponte) (-e) (q gs4 fp tasto) (-s) (q a5 ffp) (-e) (q bb4 fffp) (-s) (q cs5 pf) (-s q. e5 fp -e.) (q cs5 p h. d5 pfp) (-q h. c5 pp) (h. gs3 0<ppp>0 ponte -e a4 p< tasto) (h. fs5 mp q bb3 0<pp>0 ponte) (q c5 p tasto h. e4 pfp) (-e) (q cs4 fp h d5 pp>pppp) (h. f4 pp>pppp))) GM sound set: (def-score dynamic (:key-signature 'chromatic :time-signature (get-time-signature omn) :tempo 32 :layout (violin-layout 'vln)) (vln :omn omn :channel 1 :sound 'gm :volume 127 :program 'violin :controllers (11 (gen-dynamic-controller omn))) ) VSL sound set: (def-score dynamic (:key-signature 'chromatic :time-signature (get-time-signature omn) :tempo 32 :layout (violin-layout 'vln)) (vln :omn omn :port 0 :channel 1 :sound 'vsl-violin-solo :volume 127 :controllers (11 (gen-dynamic-controller omn))) ) --- best wishes, Janusz

New: omn-replace type new sequence &key section exclude [Function] Arguments and Values: type :length, :pitch :velocity and :articulation. new list or lists of one type values. sequence omn list or lists. section an integer or list of integers. Selected list or lists to process. The default is NIL. exclude an integer or list of integers. Excluded list or lists from process. The default is NIL. Description: This function replaces values of a given type with a list of new values. (setf omn '(e g6 f stacc e ab5 mp ten e c4 mf ten e cs5 ff)) (omn-replace :length 'q omn) => (q g6 f stacc ab5 mp ten c4 mf ten cs5 ff) (omn-replace :pitch 'c5 omn) => (e c5 f stacc mp ten mf ten ff) (omn-replace :velocity 'p omn) => (e g6 p stacc ab5 ten c4 ten cs5) (omn-replace :articulation 'tasto omn) => (e g6 f tasto ab5 mp tasto c4 mf tasto cs5 ff tasto) Examples: The NIL leaves the original values unchanged. (omn-replace :length '(q nil = h) omn) => (q g6 f stacc e ab5 mp ten c4 mf ten h cs5 ff) (omn-replace :pitch '(c5 nil = c5) omn) => (e c5 f stacc ab5 mp ten c4 mf ten c5 ff) (omn-replace :velocity '(p nil = f) omn) => (e g6 p stacc ab5 mp ten c4 mf ten cs5 f) (omn-replace :articulation '(tasto nil ponte nil) omn) => (e g6 f tasto ab5 mp ten c4 mf ponte cs5 ff) (setf omn2 '((e g6 f stacc ab5 mp ten c4 mf ten cs5 ff) (e c3 pp stacc s eb3 mf stacc a3 pp stacc e eb3 mf stacc s bb4 pp stacc e3 mf stacc e gs4 pp stacc s cs3 mf stacc fs4 pp stacc))) The list new is trimmed (loop) to the length of the sequence (omn-events): (omn-replace :length '((3q = = e) (s)) omn2) => ((3q g6 f stacc ab5 mp ten c4 mf ten e cs5 ff) (s c3 pp stacc eb3 mf stacc a3 pp stacc eb3 mf stacc bb4 pp stacc e3 mf stacc gs4 pp stacc cs3 mf stacc fs4 pp stacc)) (omn-replace :pitch '(c5 nil = c5) omn2) => ((e c5 f stacc ab5 mp ten c4 mf ten c5 ff) (e c5 pp stacc s eb3 mf stacc a3 pp stacc e c5 mf stacc s pp stacc e3 mf stacc e gs4 pp stacc s c5 mf stacc pp stacc)) (omn-replace :velocity '((p nil = f) (ff nil ff)) omn2) => ((e g6 p stacc ab5 mp ten c4 mf ten cs5 f) (e c3 ff stacc s eb3 mf stacc a3 ff stacc e eb3 stacc s bb4 pp stacc e3 ff stacc e gs4 stacc s cs3 mf stacc fs4 ff stacc)) (omn-replace :articulation '((stacc) (leg)) omn2) => ((e g6 f stacc ab5 mp stacc c4 mf stacc cs5 ff stacc) (e c3 pp leg s eb3 mf leg a3 pp leg e eb3 mf leg s bb4 pp leg e3 mf leg e gs4 pp leg s cs3 mf leg fs4 pp leg)) (omn-replace :articulation '((stacc) (leg)) (omn-replace :velocity '((p nil = f) (ff nil ff)) (omn-replace :pitch '(c5 nil = c5) (omn-replace :length '((3q = = e) (s)) omn2)))) => ((3q c5 p stacc ab5 mp stacc c4 mf stacc e c5 f stacc) (s c5 ff leg eb3 mf leg a3 ff leg c5 leg c5 pp leg e3 ff leg gs4 leg c5 mf leg ff leg))

Just install the bordeaux-threads library with the quicklisp installer before the cl-randist library. Here QuickLisp Beta you will find documents on how to use the quicklisp installer.

You can add the CL-RANDIST library with the quicklisp installer: (ql:quickload "cl-randist") How to install the QUICKLISP you will find here:

(length-divide 1 5 'd) => (2/5 2/5 2/5 2/5 2/5) Is this what you are looking for?

The maximum length-value is 1 (whole note 1/1). 4 = 1/4 2 = 1/2 etc... This could be changed, but we would need to use ratios or symbol length only. 4 would mean 4/1 and not 1/4

The PASSING-TONE function name changed to PASSING-INTERVALS. keyword :flatten change to :flat.

Here it is: (pitch-mix '((c4 d4 e4 gb4) (c4 b3 gb4 c4) (c4 b3 g4 ab4))) => (c4 d4b3 e4gb4g4 gb4c4ab4) (pitch-demix 1 '(c4 d4b3 e4fs4g4 gb4c4gs4)) => (c4 d4 e4 gs4) (pitch-demix 2 '(c4 d4b3 e4fs4g4 fs4c4gs4)) => (b3 fs4 fs4)

New: passing-intervals map sequence &key chord flat section exclude seed omn [Function] Arguments and Values: map list of integers (<interval> <steps>). sequence a sequence (omn-form list). chord NIL or T (includes or excludes chords from processing). The default is NIL. flat NIL or T. The default is NIL. section an integer or list of integers. Selected list or lists to process. The default is NIL. exclude an integer or list of integers. Excluded list or lists from process. The default is NIL. omn NIL or T. If true force OMN style output. The default is NIL. seed NIL or an integer. The default is NIL. Description: The function PASSING-INTERVALS inserts a set of steps (intervals) between given intervals and divides the length value by the number of the added steps. The length span of the output is unchanged. (setf omn1 '(q c4 d4 c4)) omn1 intervals: (2 -2) (passing-intervals '((2 (1 1)) (-2 (-1 -1))) omn1) => (e c4 mf cs4 d4 cs4 q c4) (setf omn2 '(q c4 d4 d4f4 g4)) omn2 intervals: (2 (0 3) 2) (passing-intervals '((2 (1 1)) (-2 (-1 -1)) (3 (1 1 1))) omn2) => (e c4 mf cs4 q d4 d4f4 g4) To add chords to the process we set the keyword :chord to T (passing-intervals '((2 (1 1)) (-2 (-1 -1)) (3 (1 1 1))) omn2 :chord t) => (e c4 mf cs4 q d4 e d4f4 fs4 q g4) Example: (setf map1 '((2 (1 1)) (-2 (-1 -1)) (3 (1 1 1)))) (setf sequence1 '(q c4 e4 g4 c5)) (passing-intervals map1 sequence1) => (q c4 mf 3q e4 f4 fs4 q g4 c5) Example with sublists: (setf sequence2 '((q gs4 gs4 f4 f4) (q d4 f4 b4 d5) (q f5 e5 gs4 e5) (q b4 d5 e5 f5) (q g5 e5 e5 e5) (h d5 gs4))) (passing-intervals map1 sequence2) => ((q gs4 mf gs4 f4 f4) (3q d4 mf eb4 e4 q f4 3q b4 c5 cs5 q d5) (q f5 mf e5 gs4 e5) (3q b4 mf c5 cs5 e d5 eb5 q e5 f5) (q g5 mf e5 e5 e5) (h d5 mf gs4)) To make the sublists into one continuing list (internally) we set the keyword :flat to T. (passing-intervals map1 sequence2 :flat t) => ((q gs4 mf gs4 f4 f4) (3q d4 eb4 e4 q f4 3q b4 c5 cs5 d5 eb5 e5) (q f5 e5 gs4 e5) (3q b4 c5 cs5 e d5 eb5 q e5 e f5 fs5) (q g5 e5 e5 e e eb5) (h d5 gs4)) (setf map2 '((2 (1 1)) (-2 (-1 -1)) (3 (1 1 1)) (4 (1 1 1 1)))) (setf sequence3 '(q bb3 a3 g3 a3c4f4 a4 bb4 c5 b4 c5d5eb5 f5 eb5 d5 c5)) (omn-to-time-signature (passing-intervals map2 sequence3) '(4 4)) => ((q bb3 mf e a3 gs3 g3 gs3 q a3c4f4) (q a4 e bb4 b4 q c5 b4) (q c5d5eb5 e f5 e5 q eb5 e d5 cs5) (q c5)) (passing-intervals map2 sequence3 :chord t) => ((q bb3 mf e a3 gs3 g3 gs3 s a3c4f4 fs4 g4 gs4) (q a4 e bb4 b4 q c5 b4) (e c5d5eb5 e5 f5 e5 q eb5 e d5 cs5) (q c5)) (setf sequence4 '((q c4 d4 e4 fs4 e a4 c5 q ds5 cs5) (q cs5 ds5 c5 a4 e fs4 e4 q d4 c4))) In the example below we use nested step sets. The interval 2 has two sets of steps and the interval 3 has four sets of steps to choose from. The step set is selected at random. (setf map4 '((-2 (1 1)) (2 (-1 -1) (-1 1 1)) (3 (1 1 1) (-1 -1 -1) (2 1) (1 2)))) (passing-intervals map4 sequence4 :seed 23) => ((3q c4 mf b3 c4 cs4 c4 cs4 e d4 cs4 c4 cs4 s eb4 e4 3e fs4 f4 e4 e eb4 e4 q f4) (3q cs5 mf c5 cs5 q d5 b4 gs4 s f4 fs4 g4 gs4 e a4 bb4 q b4)) (setf map5 '((-11 (6 -11) (-1 -1 -1 -1)) (-5 (1 1) (-1 1) (6 -11) (-1 -1 -1 -1)) (3 (1 2 1) (2 2 2) (2 1) (1 2 2 2)) (-3 (-1 -1 11) (2 2 2) (2 1) (1 2 2 2)) (20 (13 -11 13 -11)))) (setf sequence5 '((q f4 cs6 gs7 b7) (q c7 bb3 g3 e2) (e a0 fs4 d6 eb6))) (passing-intervals map5 sequence5 :flat t :seed 246) => ((s f4 mf fs5 g4 gs5 q a4 s e6 f6 g6 a6 b6 bb6 a6 gs6) (q g6 3q f3 e3 eb3 q d4 b2) (e e1 t cs5 d6 eb5 e6 e f5 fs5))

I would need to see the .scl file format.

I agree this would be useful indeed.

In order to use libraries you must define first with DEF-LIBRARY It is possible to assemble a library and its identifiers using the function CREATE-LIBRARY

If you are looking for few permutations: (gen-eval 12 '(rnd-order '(0 1 2 3 4 5 6 7 8 9 10 11)))

(pattern-map '(((pppp tasto) (ff tasto))) '(e. c4 pppp tasto d4 ponte e4)) => (e. c4 ff tasto d4 ponte e4)

You could do that with PATTERN-MAP.