JulioHerrlein

Ok, thanks  for the explanation!
And in the meantime I did get why position-insert does not work on the omn level,  so sorry for the noise!

(setf omn4 '((e b4 fs5 e3 a5) (e e5 b5 c4) (e g5 a4 eb3 d4) (e c6 b5 a4) (e c5 eb5 gs4) (e b4 f5 f5 fs5 gs5 a5) (e cs4 g4 c6) (e gs5))) (dictum '((:butlast leg :bar (1 3 6)) (:apply stacc :bar (2 4 5)) (:any e :apply q :bar (1 3 6)) (:first p :bar 1) (:apply < :bar 1 :event 2..4) (:apply < :bar 2 :event 1..2) (:apply ff :bar 4) (:apply > :bar 5) (:first pp :bar 7) (:apply < :bar 7 :event 2..3) (:apply fff :bar 8) (:last fermata :bar 8)) omn4) S.

More control:
(twelve-tone-matrix '(3 11 10 2 1 0 6 4 7 5 9 8)) Original Prime Order: (3 11 10 2 1 0 6 4 7 5 9 8) Pitch: (eb4 b4 bb4 d4 cs4 c4 fs4 e4 g4 f4 a4 gs4) I 0 8 7 11 10 9 3 1 4 2 6 5 0 3 11 10 2 1 0 6 4 7 5 9 8 4 7 3 2 6 5 4 10 8 11 9 1 0 5 8 4 3 7 6 5 11 9 0 10 2 1 1 4 0 11 3 2 1 7 5 8 6 10 9 2 5 1 0 4 3 2 8 6 9 7 11 10 P 3 6 2 1 5 4 3 9 7 10 8 0 11 R 9 0 8 7 11 10 9 3 1 4 2 6 5 11 2 10 9 1 0 11 5 3 6 4 8 7 8 11 7 6 10 9 8 2 0 3 1 5 4 10 1 9 8 0 11 10 4 2 5 3 7 6 6 9 5 4 8 7 6 0 10 1 11 3 2 7 10 6 5 9 8 7 1 11 2 0 4 3 RI (setf array        (build-array        (row-matrix '(3 11 10 2 1 0 6 4 7 5 9 8)))) (get-array 11 7 6 array :direction 'right) => (11 2 0 4 3 10) (get-array 11 7 6 array :direction 'up) => (11 10 2 0 3 1)  

FOUND IT !!!
 
(get-form-set '(0 4 9 10 5 3 8 7 1 2 11 6) 'r7)
 
 

Dear Julio, I just had this flash of an idea of converting the trichords (and then all forte numbers) into rhythms, and googled and of course some brilliant person has done it all and completely. Thank you! Will explore your dissertation (with help from google translate) May have to dip my toe into OM (i only use max/msp for programming) I really like your music idiomatic, embodied and expressive, when you could easily have created MIDI output. Great guitar playing. Question: have you/anyone explored forte numbers instead of 12 for say 5, 7, 8, 16, n units (for its use in meters, and - back to pitch - diatonic and microtonal use?

The DICTUM function is design to be the last function you are using in your composition - manual and rule base edit.
Therefore there is no need for variables here.
 
The dictum itself can be a list of variables:
(setf 3-dm1 '( (:range (7q e.) :apply (dechord x)) (:range (7q s) :apply marc) (:range (h. 1) :apply (pfp2-a pfp)) (:range (ws 2) :apply (pfp3-a pfp)) (:any q :apply ponte) (:any e :apply ric) (:apply marc :bar (1 157)) ;(:apply spicc :bar (4)) (:apply mart :bar (178 179 180 181)) (:butlast leg :bar (158)) (:apply tasto :bar (53 59 61 156 166 167)) (:sub (-q) :bar (10 13 21 33 34 35 36)) ) 3-dm2 '((:range (7q e.) :apply (dechord x)) (:range (7q s) :apply marc) (:range (h. 1) :apply (pfp2-a pfp)) (:range (ws 2) :apply (pfp3-a pfp)) (:any q :apply ponte) (:any e :apply ric) (:apply marc :bar (1)) ;(:apply spicc :bar (4)) (:apply mart :bar (177)) (:apply leg :bar (157)) (:butlast leg :bar (158 170 182)) (:apply tasto :bar (21 59 60 156 166 167)) (:sub (-q) :bar (19 39 42 74)) ) 3-dm3 '( (:range (7q e.) :apply (dechord x)) (:range (7q s) :apply marc) (:range (h. 1) :apply (pfp2-a pfp)) (:range (ws 2) :apply (pfp3-a pfp)) (:any q :apply ponte) (:any e :apply ric) (:apply marc :bar (1 3 5 6 7)) (:apply ric :bar (4)) (:apply spicc :bar (168)) (:apply leg :bar (157)) (:butlast leg :bar (158 182)) (:apply tasto :bar (21 53 59 60 155 156 166 167)) (:sub (-q) :bar (39 42 47 50 51 61 68 71)) ) 3-dm4 '( (:range (7q e.) :apply (dechord x)) (:range (7q s) :apply marc) (:range (h. 1) :apply (pfp2-a pfp)) (:range (ws 2) :apply (pfp3-a pfp)) (:any q :apply ponte) (:any e :apply ric) (:apply marc :bar (1)) ;(:apply ric :bar (4)) (:apply leg :bar (157)) (:butlast leg :bar (158 170 182)) (:apply tasto :bar (53 59 61 155 156 166 167)) (:sub (-q) :bar (11 12 16 18)) ) ) (setf 3-v1 (dictum 3-dm1 3-v1) 3-v2 (dictum 3-dm2 3-v2) 3-v3 (dictum 3-dm3 3-v3) 3-v4 (dictum 3-dm4 3-v4) )  

Hi,
 
(setf test '((q a4 mf e a4 p e gs4 f e4 mp g4 p) (q a4 e e gs4 e4 d4))) (setf one '(1 3)) (dictum '(:remove :event :bar 1 :event one) test) This gives an error, is there a way to use variables for keywords?
 
Thanks and Happy Easter everybody 🙂
 
Edit: Just checked another function (randomly choosen). Here a variable for a keyword works fine.
My guess is that it has to do with the quotation mark inside the dictum, is there a way around this?
 
(setf test-2 '((q a4 mf e a4 p e gs4 f e4 mp g4 p) (q a4 e e gs4 e4 d4) (e e4 g4 e4 g4 q a4))) (setf sec '(0 2)) (pitch-transpose '(7 -5 ) test-2 :section sec) ==>((q e5 e p eb5 f b4 mp d5 p) (q a4 p e e gs4 e4 d4) (e b3 p d4 b3 d4 q e4))  

Lovely idea ! Eduardo Reck Miranda was born in my city, Porto Alegre / Brasil  ! Best !
https://www.exxoshost.co.uk/atari/mirror/myatari/issues/jul2002/camus.htm

here is a function to MAP a 2d-field to chords (via intervals) // an idea i got from "Nierhaus - Algorithmic Composition" - Cellular Automata (p. 198). so you can "import/map" some GAME-OF-LIFE configurations or whatelse (a pixel photo?)  // the PITCH-MAPPING is like in Miranda's CAMUS.
 
 
;; FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun 2d-field-to-chord (matrix &key (start 'c4) (merge-chords nil)) (let* ((int-horizontal (x+b (loop for x in (loop for i in matrix collect (position-item 1 i)) when (not (null x)) collect x) 1)) (int-vertical (x+b (loop repeat (length matrix) for n = 0 then (incf n) when (not (null (position-item 1 (nth n matrix)))) collect n) 1)) (chords (loop for h in int-horizontal for v in int-vertical append (loop for z in h collect (chordize (interval-to-pitch (list z v) :start start)))))) (if (null merge-chords) chords (chord-pitch-unique (chordize (flatten chords)))))) ;; interval-matrix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; numbers are intervals (inverted order then in the book) ;; (different sizes are possible) (setf matrix #|1 2 3 4 5 6 7 8 9 etc..|# #|1|# '((1 0 0 0 0 0 0 0 0 0 0 0) #|2|# (0 1 0 0 0 0 0 0 0 0 0 0) #|3|# (0 0 1 0 0 0 0 0 0 0 0 0) #|4|# (0 0 0 0 0 0 0 0 0 0 0 0) #|5|# (0 0 0 0 0 0 0 0 0 0 0 0) #|6|# (0 0 0 0 0 0 0 0 0 0 0 0) #|7|# (0 0 0 0 0 0 0 0 0 0 0 0) #|etc..|# (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 1 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 1 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0))) (2d-field-to-chord matrix) (2d-field-to-chord matrix :start 'd4) (2d-field-to-chord matrix :merge-chords t) (2d-field-to-chord matrix :merge-chords t :start 'd4) ;; as a scale (sort-asc (melodize (2d-field-to-chord matrix :merge-chords t))) ;; with rnd-generated field (by probability) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.97) (1 0.03)))))) (2d-field-to-chord matrix)) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.99) (1 0.01)))))) (2d-field-to-chord matrix :merge-chords t))  

 
 
 

May be length-span ?

After we figure out the pattern sequence, gen-sive or make-scale do the job.
added 1 minute later PATT # 1
(make-scale 'c4 12 :alt '(1 5)) This is why I love Opusmodus !
Best !!
Julio

Thanks @JulioHerrlein for hints. The number of functions is so huge 🙂 So much to learn and apply 🙂 

Regards
Cliff

Say we have as base material 2 list sequences a and b in omn or other musical OM forms (i.e. pitch series), which are generated by some algorithm.
There will be cases where you want to calculate on sets of this material.
 
Is there a OM function which helps to calculate set operations for both?
Foregive me if I missed something in the excellent docu.
 
If not, consider to implement the 3 elementary types of set operations: 
- union: the set with holds all elements of a and b
- intersect: the set which holds the elements found in a and b, but excludes those which only occur in a resp. b. 
- setdiff: the set which holds all elements in a which are not elements in b
 
Needless to say that set functions will discard duplicates.
I am sure there are LISP functions for this, but they probably won't generalize  to OM related data structure?
 
Regards
Cliff

Thank you @JulioHerrlein for your suggestions. Could not solve it yet, I seem to struggle with Cubase.

I'm working on a series of piano pieces. Here're two of the movements. Special thanks to Janusz and Stéphane for their invaluable feedback and ideas! Thanks for listening - comments welcome!
 
1.mp3
3.mp3
 
- Zvony

(defun comb-to-sum (n)   (let ((nums (gen-integer 1 n))         (x 0))     (find-unique      (sort-asc       (flatten-sublist        (loop repeat n          for i = (combination2 (incf x) nums)          collect (loop for c in i                    if (= (sum c) n)                    collect c))))))) (comb-to-sum 3) => ((3) (1 2) (1 1 1)) (comb-to-sum 5) => ((5) (1 4) (2 3) (1 1 3) (1 2 2) (1 1 1 2) (1 1 1 1 1))  
If you need the function in the OM system I could add it with the next update.
In what context you are using this combination?

2.2.26891

– New Functions:
PITCH-PROGRESSION RND-BEAT-ORDER RECONSTRUCT-OMN
– Fixed:
RND-ORDER init seed bug  
Downloads

your code would be very interesting 🙂

Short variation for piano.
Best wishes,
Janusz
 
Vienna Variations.mp3

It is also possible to map on pitch fields that way:
 
;;; Mapping on pitch-field (pitch-list-plot (tonality-map (append (chordize (make-scale 'c2 24 :alt '(2 1 6 5 4))) '(:map 'step )) (pitch-trajectory 128 '(0 23) '(0.1 1 0.1) :filter-repeat 1 :variance 0.8 )))  
You can use different fields that way:
 
(setf pfields (list (chordize (make-scale 'c2 24 :alt '(2 1 6 5 4))) (chordize (make-scale 'c2 24 :alt '(3 1 2 4))) (chordize (make-scale 'c2 24 :alt '(2 2 2 1))) )) (setf path (tonality-series pfields :map '(step))) (pitch-list-plot (tonality-map path (gen-eval 3 '(pitch-trajectory 128 '(0 23) '(0.1 1 0.1) :filter-repeat 1 :variance 0.2 )) ))  
And also use the :time parameter from tonality-map system if you use OMN expression:
 
;;; Example with omn without :time parameter (pitch-list-plot (tonality-map path (gen-filter-euclidean 12 16 11 16 (pitch-trajectory 128 '(0 23) '(0.1 1 0.1) :filter-repeat 1 :variance 0.2 ) 's) )) ;;; Same with :time parameter (pitch-list-plot (tonality-map path (gen-filter-euclidean 12 16 11 16 (pitch-trajectory 128 '(0 23) '(0.1 1 0.1) :filter-repeat 1 :variance 0.2 ) 's) :time '(h w))) S.

thanx, stephane! you are my OPMO-function-MASTER! 🙂
 

I did the SCORE-PLAYER for Andre. I will make a documentation for it soon.

2.2.26880
 
– New function:
GET-BEATS ATTRIBUTE-SERIES  
– Changes:
PITCH-EXPANSION-VARIANT now PITCH-SEGMENT-VARIANT GET-EVENTS - additional functionality  
Downloads
 
 
GET-BEATS
 
The function GET-BEATS allows you to assemble a new sequence from a number of beats of a given bar and a given omn sequence. The beat value is taken from the bar time-signature. The variant - if defined - is applied to the entire bar before the beat collection.
 
Examples:
(setf omn '((q c4 eb4 g4 bb4) (h g3f4cs5 p c5))) (get-beats '(1 1) omn) => (q c4 mf eb4 g4 bb4) (get-beats '(1 1 1) omn) => (q c4 mf) (get-beats '(1 1 (1 4)) omn) => (q c4 mf bb4) (get-beats '((1 1 (1 3))              (1 2 1)) omn) => ((q c4 mf g4) (q g3f4cs5 p tie)) (get-beats '((1 1 (1 3) r)              (1 2 1 i)) omn) => ((q bb4 mf eb4) (q g3a2cs2 p tie))  
Collecting beat values from two voices with variant set to '? (at random):
(setf seq1 '((s g4 pp e s cs5 c4 -e s fs5 g4 mf q s gs5 mp e)         (s a3 f g4 pp e s gs5 gs5 -e s a3 gs4 mf q s a5 mp a5)) seq2  '((h e4f5 p c5a4) (h b3d3 gs4eb2fs3) (h bb2g5cs5 gs4d4eb2)          (w bb2 mp) (h g3f4cs5 p c5) (h fs5a5b3 e4b3) (h bb2)          (w e2eb4) (h c5cs6 a5) (h f4g3 gs4d3) (h fs5 bb2fs5g3)          (h d3e5eb4 gs4) (h a2c6 f2) (h b0 cs6c5) (h gs4d3))) (get-beats '((1 1 1 ?)              (2 3 2 ?)              (1 2 2..4 ?)              (2 5 2 ?)) (list seq1 seq2) :seed 42) => ((s gs5 pp e s fs5)     (q g5cs5bb2 p)     (s gs5 pp a5 -e s a5 gs5 mf e gs4 tie gs4 s g4 mp a3)     (q g3f4cs5 p))  
Collecting beat values from four voices:
(setf cello1 '((s g2 p d3 b3 a3 b3 d3 b3 d3)                (s g2 d3 b3 a3 b3 d3 b3 d3))       cello2 '((s g2 p e3 c4 b3 mf c4 e3 c4 e3)                (s g2 e3 c4 b3 c4 e3 c4 e3))       cello3 '((s g2 mf fs3 c4 b3 c4 fs3 c4 fs3)                (s g2 fs3 c4 b3 c4 fs3 c4 fs3))       cello4 '((s g2 mf g3 b3 a3 b3 g3 b3 g3)                (s g2 g3 b3 a3 b3 g3 b3 fs3))) (get-beats '((1 1 2 ?)              (2 1 2 ri)              (3 2 2 ?)              (4 2 1 ?)              (2 2 2 ?)              (3 2 2 ?))            (list cello1 cello2 cello3 cello4)            :seed 59) => ((s a3 p g2 b3 b3)     (s a2 mf gs2 e3 cs4)     (s c4 mf c4 fs3 fs3)     (s g2 mf g3 a3 b3)     (s c4 mf c4 e3 e3)     (s b3 mf c4 c4 c4))  
 
 
ATTRIBUTE-SERIES
 
The function ATTRIBUTE-SERIES inserts a series of attributes into an omn-form sequence. The series list consists of two values: attribute and its count.
 
Examples:
(attribute-series '(leg 8) '(s g2 d3 b3 a3 b3 d3 b3 d3 g2 d3 b3 a3 b3 d3 b3 d3))
 
(attribute-series '((leg 4) (- 4)) '(s g2 d3 b3 a3 b3 d3 b3 d3 g2 d3 b3 a3 b3 d3 b3 d3))
 
(setf omn       (make-omn        :length '(s)        :pitch (vector-to-pitch '(c2 c5) (gen-sine 64 5 .4))        :span :pitch))
 
(attribute-series '((leg 4) (stacc 4)) omn)
 
 
In this example we generate the attribute values and its count separately:
(setf attr (rnd-sample 12 '(leg stacc -))) => (- - stacc stacc leg - leg - leg stacc leg stacc) (setf div (rnd-sample 12 '(2 3 4 5))) => (4 2 3 5 2 5 4 5 5 5 3 4)  
The next step is to create lists with two values each containing attribute and its count. The MCLIST function helps us to create such lists:
(setf series (mclist attr div)) => ((- 4) (- 2) (stacc 3) (stacc 5) (leg 2) (- 5)     (leg 4) (- 5) (leg 5) (stacc 5) (leg 3) (stacc 4)) (attribute-series series omn)  

 
 
 
PITCH-SEGMENT-VARIANT
 
This function returns a number of segments of a sequence from an existing list or lists with a defined variant. The segment is defined by the size value (percent) and the number of returned segments. The segment start position is defined by the position value.
 
(pitch-segment-variant '(c4 d4 e4 f4 g4 a4 b4)                         :percent 50                         :segment 1                         :position 's                         :variant 'r) => (b4 a4 g4 f4)  
 
Examples:
 
In the following example the segment count is set to 2. The first segment is 50 percent in size with a retrograde variant, while the second segment is 30 percent in size with an inversion variant:
(pitch-segment-variant '(c4 d4 e4 f4 g4 a4 b4)                         :percent '(50 30)                         :segment 2                         :position 'e                         :variant '(r i)) => ((f4 e4 d4 c4) (eb3 cs3))  
To retain the initial sequence in the result we set the :initial option to T. The :lists option set to NIL will flatten the entire process:
(pitch-segment-variant '(c4 d4 e4 f4 g4 a4 b4)                        :percent '(50 30)                        :segment 2                        :position 'e                        :variant '(r i)                        :initial t                        :lists nil) => (c4 d4 e4 f4 g4 a4 b4 f4 e4 d4 c4 eb3 cs3)  
(setf omn       (omn-to-time-signature        (make-omn         :length '(s)         :pitch (vector-to-pitch '(c2 c5) (gen-sine 64 5 .4))         :span :pitch)        '(4 4)))
 
 
The following expression will return 4 segments each 15 percent in size taken from every bar. Each segment is transposed by 13 semitones. The total of return bars is 16 (4 bars x 4 segments):
(pitch-segment-variant omn :percent 15 :segment 4 :position '? :variant '? :transpose 13 :seed 32)
 
 
(pitch-segment-variant omn :percent '((20) (30) (40) (100)) :segment '(1 2 3 4) :position '? :variant '? :transpose '((0) (13)) :seed 32)
 
 
In this example every segment in each bar has its own size, start position, variant and transposition value:
(setf percent '((30 50 20) (20 50 70) (40 60 70) (50 20 70))) (setf transp '((0 0 0) (13 0 0) (0 0 13) (0 0 13))) (pitch-segment-variant omn :percent percent :segment 3 :position '? :variant '? :transpose transp :seed 32)
 
 
(pitch-segment-variant omn :percent (gen-eval 3 '(rnd-sample 3 '(40 50 60 80 20 70)) :seed 45) :segment 3 :position '? :variant '? :omit '(a d ad da p) :transpose (gen-eval 3 '(rnd-sample 3 '(0 13)) :seed 35) :seed 45)
 
 
More examples:
 
(progn   (init-seed 53)      (setf segments         (quantize          (pitch-segment-variant           (library 'maderna 'serenata-per-un-satellite nil :random 12)           :percent 20           :segment '(1 2 1 2 1 2)           :position '?           :variant '?           :transpose 6)          '(1 2 3 4 5 6 7 8)))      (ps 'gm :treble (list segments)       :tempo 72)      (init-seed nil)   )
 
 
(progn   (init-seed 34)      (setf segments         (quantize          (pitch-segment-variant           (library 'maderna 'serenata-per-un-satellite nil :random 12)           :percent 20           :segment '(1 2 1 2 1 2)           :position '?           :variant '?           :transpose 6)          '(1 2 3 4 5 6 7 8)))      (ps 'gm :treble (list segments)       :tempo 72)      (init-seed nil)   )
 
 
 
Best wishes,
Janusz

Actually, what I'm finding works well is just to load the MIDI into Musescore and use the Midi Entry function under the Tools menu in OM to record the pitches. So my workflow is fine.