opmo

I would suggest to make the sound-sets setup. There is no need to separate the articulations.

New: Two new menu items: 'PPrint Expression' and PPrint Last Score'. PPrint Expression (Snippet) Place the mouse cursor at the end of the expression and press ⌃⌥⇥ The function PPRINT-LAST-SCORE prints a def-score-form of the *last-score* with the bar numbers in the Listener. MIDI Import to score has a new header and is using PPrint with the bar numbers by default. The function PPRINT-INSTRUMENT prints instrument values of a given score with the bar numbers in the Listener. Examples: (progn (setf size 200) (setf vector (add-triangle-waves 4 size 1 0.6 :modulation (gen-triangle size 1 '(0.5 0.4 0.3 0.6) :modulation (gen-triangle size 1 0.3 :phase 180)))) (setf pitches (gen-divide 4 (vector-to-pitch '(g1 g6) vector))) (setf transpose (pitch-transpose -12 pitches)) (setf variants (pitch-variant transpose :variant '?)) (setf length (rnd-sample 120 '(s e s s))) (setf time (span pitches length)) (setf dynamics '(p mf ff)) (def-score add-triangle (:title "Waves Add-Triangle" :composer "Janusz Podrazik" :copyright "© 2014 Opusmodus" :key-signature 'chromatic :time-signature (get-time-signature time) :tempo 120 :flexible-clef t :octave-shift '(c2 c6) :layout (piano-solo-layout 'rh 'lh :ignore-velocity t)) (rh :length time :pitch pitches :velocity (rnd-sample size dynamics) :sound 'gm :channel 1 :program 'acoustic-grand-piano) (lh :length time :pitch variants :velocity (rnd-sample size dynamics))) ) (pprint-instrument 'add-triangle 'rh) The rh instrument output in the Listener: (setf rh '(#|1|# (s g1 p gs1 ff a1 p b1 ff) #|2|# (s c2 ff cs2 p d2 mf e2 p) #|3|# (s f2 p fs2 mf g2 ff e a2 mf) #|4|# (s b2 c3 cs3 eb3 ff) #|5|# (s e3 mf f3 p e fs3 a3 ff) #|6|# (e bb3 mf s b3 ff c4 e4) #|7|# (s e4 mf e f4 s p b4) #|8|# (e b4 ff s p mf fs5 ff) #|9|# (e fs5 p f5 ff s e cs6) #|10|# (s cs6 p c6 ff b5 g6) #|11|# (e g6 mf s p f6 ff e g6 mf) #|12|# (s g6 g6 p ff e fs6 p) #|13|# (s g6 p mf e p s fs6) #|14|# (s fs6 mf fs6 fs6 fs6) #|15|# (s fs6 p ff p ff) #|16|# (e fs6 p s ff p e f6 ff) #|17|# (s fs6 ff e p s ff f6 p) #|18|# (s f6 p fs6 ff e s f6 p) #|19|# (e f6 ff s fs6 e p f6) #|20|# (s f6 ff p e fs6 mf s f6 p) #|21|# (s f6 p f6 f6 mf e ff) #|22|# (s f6 p ff p f6) #|23|# (s f6 mf f6 f6 p mf) #|24|# (s f6 p e s mf ff) #|25|# (s f6 p e e s) #|26|# (s f6 p mf ff mf) #|27|# (e f6 f6 e6 s f6) #|28|# (s f6 ff e e6 p s eb6 f6 ff) #|29|# (s f6 mf e6 p d6 mf f6) #|30|# (s f6 ff e e6 p s d6 f6 mf) #|31|# (s f6 e6 p cs6 mf f6) #|32|# (s f6 f6 cs6 p f6) #|33|# (s f6 mf f6 cs6 p e fs6 mf) #|34|# (s f6 e6 bb5 f6) #|35|# (s e6 b5 e f5 p eb6 ff) #|36|# (e bb5 ff s fs5 mf cs5 p a5 mf) #|37|# (s e5 p e c5 s gs4 mf d5 ff) #|38|# (e bb4 mf s fs4 p d4 mf g4) #|39|# (e e4 ff d4 s b3 mf e eb4 ff) #|40|# (s cs4 mf bb3 p gs3 ff c4 p) #|41|# (e a3 p s ff b3 mf e gs3 ff) #|42|# (s bb3 mf c4 ff d4 p e b3) #|43|# (s cs4 mf eb4 e f4 ff s eb4) #|44|# (s e4 p fs4 ff gs4 p fs4) #|45|# (s g4 ff a4 p bb4 a4) #|46|# (e bb4 mf s c5 p cs5 ff e c5) #|47|# (s cs5 ff e eb5 mf s e5 ff eb5 mf) #|48|# (s e5 ff fs5 e g5 mf s fs5 ff) #|49|# (e g5 p s gs5 ff e a5 mf a5) #|50|# (s bb5 p b5 mf e c6 ff s mf) )) Best wishes, JP

(omn-merge-ties '(q a4 stacc+tie e gliss+tie)) => (q. a4 stacc+gliss+tie) (omn-merge-ties '(q a4 stacc+tie e gliss)) => (q. a4 stacc+gliss)

(apply #'mapcar #'list '((1 3 5) (2 4 6)))

(matrix-transpose '((1 2 3) (a b c) (4 5 6)))

At the beginning of the score: (init-seed 32) added 5 minutes later You could use few of them between blocks of expressions - more control :-)

(binary-to-decimal '(1 1 0)) => 6 (decimal-to-binary '(9 3 6 1 10 11)) => ((1 0 0 1) (1 1) (1 1 0) (1) (1 0 1 0) (1 0 1 1))

(get-count '(a b c d e)) => 5 Examples: (setf seql '((2/16 1/16 -1/16) (1/16 2/16 -1/16) (1/4) (1/1))) (setf seqp '((c4 d4 e4 f4 g4 a4) (bb4 ab4 gb4 e4 db4 c4))) (setf seqb '((0 1 0 0 1 0 0 1) (1 0 0 1 1 0 0 1))) The :length keyword, counts how many length notes or length rests are in a sequence. (get-count seql :length :note) => (2 2 1 1) The sum of all length-notes in the sequence: (get-count seql :length :note :sum t) => 6 The ordinary count: (get-count seqp) => (6 6) The item keyword, counts a specific item in the sequence: (get-count seql :item 1/4) => (0 0 1 0) (get-count seqp :item 'bb4) => (0 1) (get-count seqp :sum t) => 12 (get-count seqb) => (8 8) (get-count seqb :item 1 :sum t) => 7

The notation in your examples are correct. The 23w length value is a tuplet and is a 23rd part of the whole note. The best thing I would suggest is to spend some time to read the introduction to OMN. This way you will progress without to much frustration. Experimentation is the way to learn but the basics are paramount. Here are the documents I suggest to read: Introduction to OMN 1st Element - Length 2nd Element - Pitch 3rd Element - Velocity 4th Element - Attribute (Articulation) The Length, Pitch and Velocity are essentials to understand. This will give you a good basis to play, explore and experiment with Opusmodus. Next, check the 'Snippet.opmo' examples. This document illustrates the omn grammar. After that I would go through the Howto documentation. All this will take no more than a few hours. All the document you’ll find in the Utilities/Documentation panel on the right - second icon. As for the prime numbers - simple example. First we generate a few prime numbers: (setf pnum (primes-to 10)) => (2 3 5 7) Now the duration with our prime numbers: (setf len (gen-length pnum '1/16)) => (1/8 3/16 5/16 7/16) And a few more: (setf my-lengths (gen-eval 12 '(rnd-order len))) => ((5/16 1/8 3/16 7/16) (1/8 5/16 3/16 7/16) (5/16 3/16 1/8 7/16) (1/8 3/16 5/16 7/16) (3/16 5/16 1/8 7/16) (7/16 5/16 3/16 1/8) (7/16 3/16 5/16 1/8) (5/16 7/16 3/16 1/8) (3/16 1/8 5/16 7/16) (1/8 3/16 5/16 7/16) (5/16 7/16 3/16 1/8) (3/16 5/16 7/16 1/8)) Now we generate a 12tone row (at random): (setf my-pitches (rnd-row :type :pitch)) => (c4 b4 bb4 fs4 f4 d4 g4 cs4 eb4 a4 e4 gs4) The MAKE-OMN funtion allows us to put all our parameters together: (setf my-mat (make-omn :length my-lengths :pitch my-pitches)) => ((qs c4 e. eb4 e e4 q.. a4) (e. f4 q.. fs4 qs b4 e g4) (q.. d4 qs cs4 e gs4 e. bb4) (e. c4 q.. eb4 qs e4 e a4) (e f4 q.. fs4 qs b4 e. g4) (e d4 q.. cs4 e. gs4 qs bb4) (e c4 qs eb4 e. e4 q.. a4) (e f4 qs fs4 q.. b4 e. g4) (e. d4 qs cs4 q.. gs4 e bb4) (q.. c4 qs eb4 e e4 e. a4) (e f4 e. fs4 qs b4 q.. g4) (q.. d4 qs cs4 e gs4 e. bb4)) Here we use the TONALITY-MAP function to force the minor scale on our material. (tonality-map '(minor :map step) my-mat) => ((qs c4 e. eb4 e f4 q.. bb4) (e. f4 q.. qs bb4 e g4) (q.. d4 qs e gs4 e. bb4) (e. c4 q.. eb4 qs f4 e gs4) (e f4 q.. qs bb4 e. g4) (e d4 q.. e. gs4 qs bb4) (e c4 qs eb4 e. q.. bb4) (e f4 qs q.. bb4 e. g4) (e. d4 qs q.. gs4 e bb4) (q.. c4 qs eb4 e e. gs4) (e f4 e. qs c5 q.. g4) (q.. d4 qs e gs4 e. bb4)) What about lessons with Stephane Boussuge, here is the link to the request: https://opusmodus.com/lessons.html Best, JP

Some changes to the Text & Lyrics tools. If you used one of them please check the new functions. The text-to-pitch function is replaced with TEXT-MAP with more options and functionality. text-map map text &key flat rnd-order otherwise seed [Function] Arguments and Values: map a list of lists (<letter><symbol>) text a string, a string list list of a list of letters. flat T or NIL. The default is T. rnd-order T or NIL. The default is NIL. otherwise Nil, symbol or list of symbols. The default is NIL. seed an integer - ensure the same result each time the code is evaluated. The default is NIL. Description: This function converts a body of text into any symbol (parameter). It’s a further way to use words ("text") or a list of letters to create parametric material. Notice, that the function creates lists for each word and that punctuation is ignored. In the following examples we will map a text to integers. First we create a map: (defparameter *map-integer1* '(((a à á â ã ä å æ ą) 0) (b 1) ((c ç ć) 2) (d 3) ((e è é ê ë ę) 4) (f 5) (g 6) (h 7) ((i ì î ï) 8) (j 9) (k 10) ((l ł) 11) (m 12) ((n ñ ń) 13) ((o ò ó ô õ ö) 14) (p 15) (q 16) (r 17) ((s ś) 18) (t 19) ((u ù ú û ü) 20) (v 21) (w 22) (x 23) ((y ý ÿ) 24) ((z ż ź) 25))) (setf text '("To be, or not to be, that is the question")) (text-map *map-integer1* text) => ((19 14) (1 4) (14 17) (13 14 19) (19 14) (1 4) (19 7 0 19) (8 18) (19 7 4) (16 20 4 18 19 8 14 13)) In the following map each letter is mapped into a list of two integer values. The letter (a à á â ã ä å æ ą) is mapped to 0 and -12. Every time the letter (a à á â ã ä å æ ą) is processed, 0 or -12 integer is picked at random. (defparameter *map-integer2* '(((a à á â ã ä å æ ą) (0 -12)) (b (1 -1)) ((c ç ć) (2 -2)) (d (3 -3)) ((e è é ê ë ę) (4 -4)) (f (5 -5)) (g (6 -6)) (h (7 -7)) ((i ì î ï) (8 -8)) (j (9 -9)) (k (10 -10)) ((l ł) (11 -11)) (m (12 -12)) ((n ñ ń) (13 -13)) ((o ò ó ô õ ö) (14 -14)) (p (15 -15)) (q (16 -16)) (r (17 -14)) ((s ś) (18 -18)) (t (19 -19)) ((u ù ú û ü) (20 -20)) (v (21 -21)) (w (22 -22)) (x (23 -23)) ((y ý ÿ) (24 -24)) ((z ż ź) (25 -25)))) (text-map *map-integer2* text) => ((19 -14) (-1 -4) (14 17) (-13 -14 -19) (-19 -14) (1 4) (19 7 0 -19) (-8 18) (19 -7 -4) (-16 20 -4 -18 19 8 -14 -13)) (text-map *map-integer2* text) => ((-19 14) (1 -4) (-14 17) (13 14 19) (19 14) (1 4) (19 7 0 19) (8 18) (19 -7 -4) (16 20 4 18 -19 8 -14 -13)) A seed will ensure the same result each time the code is evaluated: (text-map *map-integer2* text :seed 48) => ((19 -14) (1 -4) (14 -14) (-13 -14 19) (19 -14) (-1 4) (19 7 -12 -19) (8 18) (-19 -7 4) (16 -20 -4 18 19 -8 -14 -13)) In the following examples we map a text to lengths. If a letter is mapped to a nested list ((e e. s)) then the entire list is selected. (defparameter *map-length* '(((a à á â ã ä å æ ą) ((s s s))) (b ((s e s))) ((c ç ć) ((e s s))) (d ((s s e))) ((e è é ê ë ę) ((e e. s))) (f ((q e. s))) (g ((e. e s))) (h ((q s s))) ((i ì î ï) ((s e. e))) (j ((s e. e))) (k ((s s q))) ((l ł) ((e s e.))) (m ((e e e))) ((n ñ ń) ((e q e))) ((o ò ó ô õ ö) ((q e e))) (p ((e e q))) (q ((q q. e))) (r ((h q. e))) ((s ś) ((q e q.))) (t ((h e e))) ((u ù ú û ü) ((e q. q))) (v ((q. e h))) (w ((e e h))) (x ((q e q.))) ((y ý ÿ) ((q q q))) ((z ż ź) ((q h q))))) (text-map *map-length* text) => ((h e e q e e) (s e s e e. s) (q e e h q. e) (e q e q e e h e e) (h e e q e e) (s e s e e. s) (h e e q s s s s s h e e) (s e. e q e q.) (h e e q s s e e. s) (q q. e e q. q e e. s q e q. h e e s e. e q e e e q e)) (text-map *map-length* text :flat nil) => ((h e e) (q e e) (s e s) (e e. s) (q e e) (h q. e) (e q e) (q e e) (h e e) (h e e) (q e e) (s e s) (e e. s) (h e e) (q s s) (s s s) (h e e) (s e. e) (q e q.) (h e e) (q s s) (e e. s) (q q. e) (e q. q) (e e. s) (q e q.) (h e e) (s e. e) (q e e) (e q e)) With the rnd-order option we can randomise the order of the elements in the list: (text-map *map-length* text :flat nil :rnd-order t) => ((h e e) (q e e) (s e s) (s e. e) (e e q) (h e q.) (e q e) (e q e) (h e e) (h e e) (e q e) (s e s) (s e e.) (e h e) (q s s) (s s s) (e e h) (e. e s) (q. q e) (e h e) (s q s) (s e e.) (q. e q) (q. e q) (s e e.) (q q. e) (e h e) (s e e.) (e q e) (e e q)) In the following examples we map text to pitches. First we create a simple map with a letter mapped to a single pitch: (defparameter *map-pitch1* '(((a à á â ã ä å æ ą) c3) (b cs3) ((c ç ć) d3) (d eb3) ((e è é ê ë ę) e3) (f f3) (g fs3) (h g3) ((i ì î ï) gs3) (j a4) (k bb3) ((l ł) b3) (m c4) ((n ñ ń) cs4) ((o ò ó ô õ ö) d4) (p eb4) (q e4) (r f4) ((s ś) fs4) (t g4) ((u ù ú û ü) gs4) (v a4) (w bb4) (x b4) ((y ý ÿ) c5) ((z ż ź) cs5))) (text-map *map-pitch1* text) => ((g4 d4) (cs3 e3) (d4 f4) (cs4 d4 g4) (g4 d4) (cs3 e3) (g4 g3 c3 g4) (gs3 fs4) (g4 g3 e3) (e4 gs4 e3 fs4 g4 gs3 d4 cs4)) Here we map a letter to a list of two pitches: (defparameter *map-pitch2* '(((a à á â ã ä å æ ą) (c4 c3)) (b (cs4 b3)) ((c ç ć) (d4 bb3)) (d (eb4 a3)) ((e è é ê ë ę) (e4 gs3)) (f (f4 g3)) (g (fs4 fs3)) (h (g4 f3)) ((i ì î ï) (gs4 e3)) (j (a4 eb3)) (k (bb4 d3)) ((l ł) (b4 cs3)) (m (c5 c3)) ((n ñ ń) (cs5 b2)) ((o ò ó ô õ ö) (d5 bb2)) (p (eb5 a2)) (q (e5 gs2)) (r (f5 g2)) ((s ś) (fs5 fs2)) (t (g5 f2)) ((u ù ú û ü) (gs5 e2)) (v (a5 eb2)) (w (bb5 d2)) (x (b5 cs2)) ((y ý ÿ) (c6 c2)) ((z ż ź) (cs6 b1)))) (text-map *map-pitch2* text) => ((g5 bb2) (b3 e4) (bb2 f5) (b2 d5 f2) (f2 d5) (b3 gs3) (f2 f3 c4 f2) (gs4 fs5) (g5 g4 gs3) (gs2 gs5 gs3 fs2 f2 gs4 bb2 cs5)) Example with a velocity map: (defparameter *map-velocity* '(((a à á â ã ä å æ ą) ppp) (b ppp) ((c ç ć) ppp) (d pp) ((e è é ê ë ę) pp) (f pp) (g p) (h p) ((i ì î ï) p) (j mp) (k mp) ((l ł) mp) (m mf) ((n ñ ń) mf) ((o ò ó ô õ ö) mf) (p f) (q f) (r f) ((s ś) ff) (t ff) ((u ù ú û ü) ff) (v fff) (w fff) (x fff) ((y ý ÿ) ffff) ((z ż ź) ffff))) (text-map *map-velocity* '(o p u s m o d u s)) => (mf f ff ff mf mf pp ff ff) Example with binary map: (defparameter *map-binary* '(((a à á â ã ä å æ ą) ((1))) (b ((1 0))) ((c ç ć) ((1 1))) (d ((1 0 0))) ((e è é ê ë ę) ((1 0 1))) (f ((1 1 0))) (g ((1 1 1))) (h ((1 0 0 0))) ((i ì î ï) ((1 0 0 1))) (j ((1 0 1 0))) (k ((1 0 1 1))) ((l ł) ((1 1 0 0))) (m ((1 1 0 1))) ((n ñ ń) ((1 1 1 0))) ((o ò ó ô õ ö) ((1 1 1 1))) (p ((1 0 0 0 0))) (q ((1 0 0 0 1))) (r ((1 0 0 1 0))) ((s ś) ((1 0 0 1 1))) (t ((1 0 1 0 0))) ((u ù ú û ü) ((1 0 1 0 1))) (v ((1 0 1 1 0))) (w ((1 0 1 1 1))) (x ((1 1 0 0 0))) ((y ý ÿ) ((1 1 0 0 1))) ((z ż ź) ((1 1 0 1 0))))) (text-map *map-binary* '(o p u s m o d u s)) => ((1 1 1 1) (1 0 0 0 0) (1 0 1 0 1) (1 0 0 1 1) (1 1 0 1) (1 1 1 1) (1 0 0) (1 0 1 0 1) (1 0 0 1 1)) Example with otherwise option. (setf map4 '((e e3) (f f3) (g fs3) (h g3) (i gs3) (j a4) (k bb3) (l b3) (m c4) (n cs4) (o d4))) (text-map map4 '(o p u s m o d u s)) => (d4 c4 d4) The result of the expression above is not equal to the length of the (o p u s m o d u s) list because the letters d, p, s and u are not in the map. Use the otherwise option to get the same count: (text-map map4 '(o p u s m o d u s) :otherwise '((eb4e5) (f3fs4))) => (d4 (eb4e5) (f3fs4) (eb4e5) c4 d4 (eb4e5) (f3fs4) (f3fs4)) In the following examples our maps are created algorithmically: (setf map (mapcar 'list (make-alphabet) (integer-to-pitch (gen-integer-step 0 26 '(1 -2 3 1))))) => ((a c4) (b cs4) (c b3) (d d4) (e eb4) (f e4) (g d4) (h f4) (i fs4) (j g4) (k f4) (l gs4) (m a4) (n bb4) (o gs4) (p b4) (q c5) (r cs5) (s b4) (t d5) (u eb5) (v e5) (w d5) (x f5) (y fs5) (z g5)) (text-map map text) => ((d5 gs4) (cs4 eb4) (gs4 cs5) (bb4 gs4 d5) (d5 gs4) (cs4 eb4) (d5 f4 c4 d5) (fs4 b4) (d5 f4 eb4) (c5 eb5 eb4 b4 d5 fs4 gs4 bb4)) (setf map2 (mapcar 'list (make-alphabet) (mapcar 'list (integer-to-pitch (gen-integer-step 0 26 '(1 -2 3 1))) (integer-to-pitch (gen-integer-step -6 26 '(1 -2 3 1)))))) => ((a (c4 fs3)) (b (cs4 g3)) (c (b3 f3)) (d (d4 gs3)) (e (eb4 a3)) (f (e4 bb3)) (g (d4 gs3)) (h (f4 b3)) (i (fs4 c4)) (j (g4 cs4)) (k (f4 b3)) (l (gs4 d4)) (m (a4 eb4)) (n (bb4 e4)) (o (gs4 d4)) (p (b4 f4)) (q (c5 fs4)) (r (cs5 g4)) (s (b4 f4)) (t (d5 gs4)) (u (eb5 a4)) (v (e5 bb4)) (w (d5 gs4)) (x (f5 b4)) (y (fs5 c5)) (z (g5 cs5))) (text-map map2 text :seed 63) => ((d5 d4) (g3 a3) (d4 cs5) (bb4 gs4 d5) (d5 d4) (g3 a3) (d5 b3 c4 d5) (c4 f4) (d5 f4 eb4) (c5 eb5 eb4 b4 d5 c4 gs4 bb4)) In the next example we map a group of letters to a group of pitches. Example: a = (c4 cs4 d4) b = (c4 cs4 d4) and c = (c4 cs4 d4) etc... (setf map3 (mapcar 'list (gen-divide 3 (make-alphabet)) (integer-to-pitch (gen-divide 3 (gen-integer 26))))) => (((a b c) (c4 cs4 d4)) ((d e f) (eb4 e4 f4)) ((g h i) (fs4 g4 gs4)) ((j k l) (a4 bb4 b4)) ((m n o) (c5 cs5 d5)) ((p q r) (eb5 e5 f5)) ((s t u) (fs5 g5 gs5)) ((v w x) (a5 bb5 b5)) ((y z) (c6 cs6 d6))) (text-map map3 text) => ((g5 c5) (cs4 f4) (c5 f5) (cs5 d5 g5) (gs5 d5) (c4 f4) (fs5 gs4 d4 g5) (g4 fs5) (gs5 g4 f4) (e5 gs5 f4 fs5 g5 gs4 c5 d5)) => ((gs5 c5) (c4 e4) (c5 eb5) (c5 c5 g5) (gs5 c5) (c4 e4) (g5 gs4 cs4 fs5) (gs4 fs5) (gs5 fs4 e4) (eb5 gs5 eb4 fs5 gs5 fs4 cs5 c5)) => . . . Best wishes to all, JP

What kind of bug is it.

This is not a trivial thing to do because the function has to deal with so many cases. Please give me a REAL example of the use of double nested lists, especially with omn symbols.

It is in our TODO list.

Good idea, make sense

New: POSITION-SWAP The function POSITION-SWAP swaps the positions of the items within a list. (position-swap '(0 2) '(0 1 2 3 4 5 6)) => (2 1 0 3 4 5 6) (position-swap '((0 2) (3 5)) '(c4 d4 e4 f4 g4 a4 b4)) => (e4 d4 c4 a4 g4 f4 b4) (position-swap '((0 2) (3 5)) '(c4 d4 e4 f4 g4 a4 b4) :seq t) => ((e4 d4 c4 f4 g4 a4 b4) (e4 d4 c4 a4 g4 f4 b4)) (position-swap '((0 2) (3 5)) '(e c4 f d4 p s e4 mp f4 g4 f a4) :seq t) => ((s e4 mp e d4 p c4 f s f4 mp g4 f a4) (s e4 mp e d4 p c4 f s a4 g4 f4 mp))

Thank you Patrick.

New: additional keyword :map in TEXT-TO-PITCH, LETTER-TO-INTEGER and INTEGER-TO-LETTER. --------------------------------------------------- TEXT-TO-PITCH Example with a defined :map (setf map (gen-combine (make-alphabet) (gen-integer-step 0 26 '(1 -2 3 1)))) => ((a 0) (b 1) (c -1) (d 2) (e 3) (f 4) (g 2) (h 5) (i 6) (j 7) (k 5) (l 8) (m 9) (n 10) (o 8) (p 11) (q 12) (r 13) (s 11) (t 14) (u 15) (v 16) (w 14) (x 17) (y 18) (z 19)) (text-to-pitch '("To be, or not to be, that is the question") :map map) => ((d5 gs4) (cs4 eb4) (gs4 cs5) (bb4 gs4 d5) (d5 gs4) (cs4 eb4) (d5 f4 c4 d5) (fs4 b4) (d5 f4 eb4) (c5 eb5 eb4 b4 d5 fs4 gs4 bb4)) --------------------------------------------------- LETTER-TO-INTEGER (letter-to-integer '(a b c f g h) :map '((a 0) (b 6) (c 13) (f -11) (g -13) (h 2))) => (0 6 13 -11 -13 2) --------------------------------------------------- INTEGER-TO-LETTER (integer-to-letter '(0 1 2 5) :map '((0 a) (1 c) (2 e) (5 g))) => (a c e g) --------------------------------------------------- Fix to MAKE-OMN length-symbol conversion.

Opusmodus 1.2.21986 fixed the bug.

The bug is in the MAKE-OMN function - the conversion to ratios and back - which is not necessary here. I will have a look.

Excellent example, thank you Stephane

Patrick please check your score the scale1 values are missing.

All this like title, composer, footer etc... will be part of the version 2.0

In OM we don't use double nested list. '(((h q) (h)) ((h. q) (h)) ((h. h) (h))) what is the purpose of this.

The argument encode is mentioned now in 23 functions (documents) - version 1.2.21977

With nested lists: (defun get-proportions (sequence &key abs) (do-verbose ("get-proportions") (flet ((get-proportions-l (sequence &key abs) (let* ((length (omn-length sequence)) (den (remove-duplicates (loop for i in length collect (denominator (abs i))) :from-end t))) (loop for i in length collect (if abs (* (abs i) (apply #'lcm den)) (* i (apply #'lcm den))))))) (if (listsp sequence) (loop for i in sequence collect (get-proportions-l i :abs abs)) (get-proportions-l sequence :abs abs))))) (get-proportions '(5q 5q 5q 5q 5q -e -s t t -q)) => (8 8 8 8 8 -20 -10 5 5 -40) (get-proportions '((-e -t t t t) (t t t t t -s. -q))) => ((-4 -1 1 1 1) (1 1 1 1 1 -3 -8))