JulioHerrlein

Next - which will take some time - I will add all Opusmodus System Function with examples to our forum.

Here is the answer:
 

It's a really  interesting issue to study the different approaches of the post tonal Theory. The more hardcore atonal side does not consider prime and inverted form as different things,  ontologically but in fact, our tonal oriented ear really can tell the difference between a major and a minor triad as a clear episthemological distinction. 
Counting or not counting the inverted forms also have implications on the Problems of enumeration of the types of series,  as Frippertinger &  Lackner  recent studies related to group theory and a more modern approach to Hauer Tropes demonstrates. 
 
Best 
Julio 

Very  cool, Janusz! 
Im doing my doctoral dissertation now  and I'm doing some thing interesting related to rhythm that certainly could be transformed in a function. I'll tell you soon. This Will be useful there. 
 
Best 
Julio
 

It's a really  interesting issue to study the different approaches of the post tonal Theory. The more hardcore atonal side does not consider prime and inverted form as different things,  ontologically but in fact, our tonal oriented ear really can tell the difference between a major and a minor triad as a clear episthemological distinction. 
Counting or not counting the inverted forms also have implications on the Problems of enumeration of the types of series,  as Frippertinger &  Lackner  recent studies related to group theory and a more modern approach to Hauer Tropes demonstrates. 
 
Best 
Julio 

I agree totally !!!
 
S.

I will add the inverted form into to the system with the next update.

To do this I would need to rewrite the pitch class set functions.
The functions where based on Allen Forte 'The Structure of Atonal Music' book.

(pcs-analysis '(0 3 7)) ? pcs-analysis   Sequence: (0 3 7)   Set: 3-11   Prime Form: (0 3 7)   Pitch: (c4 eb4 g4)   Normal Order: (0 3 7)   Complement: (1 2 4 5 6 8 9 10 11)   Inversion: (0 9 5)   Vector: (0 0 1 1 1 0) (pcs-analysis '(0 4 7)) ? pcs-analysis   Sequence: (0 4 7)   Set: 3-11   Prime Form: (0 3 7)   Pitch: (c4 eb4 g4)   Normal Order: (0 4 7)   Complement: (1 2 3 5 6 8 9 10 11)   Inversion: (0 8 5)   Vector: (0 0 1 1 1 0)  
Note: The pitch output form PCS-ANALYSIS is the pitch form prime form.

Here is the answer:
 

Ver 2. will be able to import musicXML files and convert to omn.

Extended documentation and bug fix in do-timeline and do-timline2 functions if binary list.
 

here only c6 is in the treble clef.
(def-score grand (:key-signature 'atonal :time-signature '(2 8) :tempo 130 :octave-shift '(c2 c6) :flexible-clef t :layout (grand-layout 'pno)) (pno :omn (merge-voices '((e g3 c6) (e g1 g3))) :channel 1 :sound 'gm :program 0) )

Is this what you are looking for:
(setf sine (gen-sine 120 1 '(0.5 0.2 0.1) :phase 60)) (setf vec (add-sine-waves 4 120 4 0.6 :modulation sine)) (setf mat (vector-to-pitch '(g2 g7) vec)) (setf divide (gen-divide 6 mat)) (setf div1 (gen-collect 3 divide)) (setf div2 (gen-collect 3 divide :remain t)) (setf pich1 (rnd-octaves '(g2 b7) div1)) (setf pich2 (rnd-octaves '(c2 g7) div2)) (setf pitch (gen-mix pich1 pich2 :flatten t)) (setf velocity (rnd-sample 120 '(pp mp mf ff))) (setf omn1 (make-omn :length (rnd-sample 120 '(s -)) :pitch pich1 :velocity velocity :span :pitch)) (setf omn2 (make-omn :length (rnd-sample 120 '(s -)) :pitch pich2 :velocity velocity :span :pitch)) (def-score grand (:key-signature 'atonal :time-signature '(3 8) :tempo 130 :octave-shift '(c2 c6) :accidentals :all :layout (grand-layout 'pno)) (pno :omn (merge-voices omn1 omn2) :channel 1 :sound 'gm :program 0) )  
Note:
Accidentals types:
:accidentals :all
:accidentals :natural
:accidentals :cautionary
 
The :all-accidentals t is not correct.

If the LH and RH pitches are placed correctly then I would use piano-layout:
(def-score grand (:key-signature 'atonal :time-signature '(2 8) :tempo 130 :octave-shift '(c2 c6) ;:flexible-clef t :layout (piano-layout 'rh 'lh)) (lh :omn '(e g1 g3) :channel 1 :sound 'gm :program 0) (rh :omn '(e g3 c6)) )
 

Good solution indeed 🙂

Quartal example:
(harmonic-progression '(1 2 3 4 5 6 7) '(d4 natural-minor) :size 4 :step 3 :base 1 )  
Another example more complex:
(setf row (rnd-row :type :pitch :transpose 2)) (setf chords1 (harmonic-progression (rnd-number 24 -6 6) row :size (rnd-sample 24 '(3 4 5 6)) :step (rnd-sample 24 '(1 2 3 (2 3)(1 3))) )) S.

Here is an example of generation of harmonic progression with Opusmodus using chords rules defined with a transition table.
The technique presented here uses the concept of tonal degrees, but it is important to note that as you will see later in this article, this concept can be pushed quite far and quite outside the traditional tonal system.
 
First, we define some transition rules from degree to degree:
 
(setf transition       '((1 (4 1) (5 1) (6 2))         (2 (5 2) (4 1))         (3 (4 1))         (4 (5 1) (2 1))         (5 (1 3) (6 2) (4 1))         (6 (4 1))         (7 (1 1) (6 1))))  
So here is a transition rule saying  a 1st degree will be 2 times more likely to be followed by a sixth degree (1 (6 2)) as a 4th or 5th (1 (4 1) (5 1) ).
A second degree will be most likely followed by a 5th degree (2 (5 2) than a 4th (2 (4 1))
We define this way all the transition rules for each degree of the scale.
 
We now generate a sequence of degrees we call prog based on these rules with the function GEN-MARKOV-FROM-TRANSITIONS (for more information on Markov chains, you can consult:  https://en.wikipedia.org/wiki/Markov_chain ):
 
(setf prog (gen-markov-from-transitions transition :size 24 :start 1))  
which can for example give this result:
 
=> (1 5 1 4 2 4 2 4 2 5 6 4 5 1 5 6 4 5 1 5 6 4 2 5)
 
Because the function that we'll use to generate chords is based on a numbering starting from zero but our degrees generation is based on a numbering starting from 1, we will subtract 1 to each value of our list prog to able to provide our next function a number list starting from zero.
To do this, we use the MAPCAR Lisp function to apply -1 to each value of the list and we store the result in the variable prog.prep.
 
(setf prog.prep (mapcar (lambda(x) (- x 1)) prog)) => (0 4 0 3 1 3 1 3 1 4 5 3 4 0 4 5 3 4 0 4 5 3 1 4)
 
Now we generate chords using the HARMONIC-PROGRESSION function and store the result in the variable named chords:
 
(setf chords (harmonic-progression prog.prep '(d4 major)))   
The parameters passed to the function are our degrees List prog.prep and a scale with a root base (here d4).
 
Here is the output of this function in notation:
 

 
Of course, we are not limited to Major and Minor scales, we can use any scale or pitch structure available or generated by Opusmodus, here are some examples:
 
(setf chords (harmonic-progression prog.prep '(d4 messiaen-mode5)))
(setf chords (harmonic-progression prog.prep '(c4 acoustic-scale)                                     :root '(d4 f4 g4 e4 bb3)))  

 
(setf chords (harmonic-progression prog.prep '(d4e4fs4gs4as4c5ds5)                                     :root '(d4 f4 g4 e4 bb3)))  
 

 
A final example using the keyword :relative  enabling a smoother transition between chords with a relative voice leading between chords. 
 
(setf chords (harmonic-progression prog.prep '(d4e4fs4gs4as4c5ds5)                                     :root '(d4 f4 g4 e4 bb3)                                     :relative t))  
 

 
Once these chords generated, you can use them as you want in Opusmodus, map them on musical structures with TONALITY-MAP function or use them as basic materials to create reservoirs of pitch or other kind of pitch material.
 
SB.

yes, i know - i love to code a lot of things myself, and at the moment i'm not very virtuous in it. but I have found a solution - without rebuilding my big programs. with
(pprint-last-score) i can read and save the OMN, after evaluating and exporting xml/midi. so you were right, janusz, the solution was in the SYSTEM FUNCTIONS 🙂
thanx for help - torsten, stéphane & janusz

> Maybe a good idea would be some kind of FLUSH function that cleans the environment,
> so we don't need to close and reopen the program ;)
 
Setting (and overwriting!) "global variables" with setf results in side effects, which can be difficult to control. 
 
Because of that, experienced Lisp programmers use side effects like overwriting "global variables" only rarely and when really necessary, and instead work with constants and "local variables". 
 
For quick hacking or testing using setf is very convenient and should not be dismissed, but if you are looking for a way to avoid restarting to create a clean slate then use "local variables".
 
Best,
Torsten 
 
In Lisp parlance, these are dynamic and lexical variables, not quite the same thing as local and global variables in other languages, but perhaps these terms are more easy to understand :)

Just import your midi file to Opusmodus (OMN) script and start transforming :-)
added 1 minute later Direct midi input (keyboard) into OMN script will be introduce in version 2.0

evaluate this, and check out the midi-destinations-function -> shows you the ports
 
(midi-destinations)  

Fix to DO-TIMELINE and DO-TIMELINE2 functions when with T or NIL plus minor bug fixes.

(setf r1 '(s s -s) r2 '(s s -s) r3 '(-s -s e -s) r4 '(s -s s -e) r5 '(e -e -e s -s)) You need to flatten the list first: (setf seq (flatten (let ((r-lis nil)) (dotimes (i 10) (push (rnd-unique 5 '(1 2 3 4 5)) r-lis)) r-lis))) (setf r-list (assemble-section 'r seq))  
You could do that:
(setf r1 '(s s -s) r2 '(s s -s) r3 '(-s -s e -s) r4 '(s -s s -e) r5 '(e -e -e s -s)) (setf seq (flatten (gen-eval 10 '(rnd-unique 5 '(1 2 3 4 5))))) (setf r-list (assemble-section 'r seq))  

yes 
 
S.