opmo

Yes, Opusmodus works very well with Sibelius and NotePerformer, I'm using it that way very often.
If you use Sibelius as default score editor in your Mac to open musicxml files, you can just use my function (last-score-to-editor) at the end of your file and when you evaluate the Opusmodus script (evaluate-all) , it will open directly into Sibelius.
 
Attached to this post, the function definition of (last-score-to-editor) to put in your Opusmodus  extensions folder.
 
Best
 
Stéphane
 
last-score-to-editor.lisp

2.1.26209

– New Functions:
CHORD-DERIVE - Chord rotation method developed by Pierre Boulez. RHYTHMIC-LEVEL - Returns a list of rhythmic levels derived from a span and its division, according to given proportions. RP - This function result derives from a pair-list and returns a number of repeats on a given item.  
– Additions:
PITCH-VARIANT - additional variant symbol 'a (random order).
  Downloads

2.1.26209

– New Functions:
CHORD-DERIVE - Chord rotation method developed by Pierre Boulez. RHYTHMIC-LEVEL - Returns a list of rhythmic levels derived from a span and its division, according to given proportions. RP - This function result derives from a pair-list and returns a number of repeats on a given item.  
– Additions:
PITCH-VARIANT - additional variant symbol 'a (random order).
  Downloads

Yes of corse, just thinking how to organize my stuff, thanks for the super quick response!

you could do:
(create-library 'test 'testing 'bla                 '((a b c) (e f g))                 :file "test1"                  )  
which will create a file 'test1.opmo' in the ~/Opusmodus/Def-Libraries/Def-Library:
(in-package :Opusmodus) ;; Library | Opusmodus Version 2.1.26194M | 2021-01-25 10:30:52 (def-library test (:section testing bla0 '(a b c) bla1 '(e f g))) #| Examples: (library 'test 'testing 'bla0) (library 'test 'testing nil :random 5) (library 'test 'testing nil :collect '(0 3 5)) |#  
🙂
 
 

Two variations on Chopin 28-4
 
   
 
   
 
Janusz

After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. 
While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good 🙂  Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. 

 
Fenv (Function Envelopes)
 
There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ).
 
 
 
Cluster Engine and Cluster Rules
 
Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL.
 
You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at
 
Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them.  These PWGL tutorials go much further than I do in the above-mentioned video.
 
Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g.,  the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials.
 
So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package.
 
Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at
fdsdbmascagni
SITES.GOOGLE.COM  
Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then.
 

TOT
 
Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). 

Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... 
 
Best,
Torsten
 

I am sharing here the score of some piece I did some time ago with Opusmodus and which I will touch upon in my presentation at the forthcoming Opusmodus convention. 
 
Unfortunately, I only have a score for this and no recording. 
 
Torsten
Torsten Anders - 2017 - Aschenputtel - for Flute Solo.pdf

I have created a 24-bar piece in Opusmodus. I use 10 instruments including Kalimba, Ghatam, Nadhaswaram, Mridangam, and Udukkai. Played through Reaper. The instruments are from UVI and Propellerhead Reason.
 
 
- Rangarajan

(setf res '(progn              (setf size 4)              (list               (setf ph1 (ambitus                          '(g3 g6)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd4 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))                              (setf ph2 (ambitus                          '(c3 g5)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd3 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))                              (setf ph3 (ambitus                          '(c2 e4)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd2 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))))) (setf seq (gen-loop 4 (eval res)))  

(setf res '(progn              (setf size 4)              (list               (setf ph1 (ambitus                          '(g3 g6)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd4 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))                              (setf ph2 (ambitus                          '(c3 g5)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd3 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))                              (setf ph3 (ambitus                          '(c2 e4)                          (filter-tie                           (make-omn                            :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd2 12 :alt '(2 1 3)))))                            :length (gen-loop size (length-legato (rnd-sample 12 '(s -s -s))))                            :velocity (rnd-pick '((pp)(p)(mp)(mf)(f)))                            ))))))) (setf seq (gen-loop 4 (eval res)))  

Here it is:
(setf stimme1 '((h d4 q a4 g4) (q a4 e4 h f4) (h e4 g4) (q f4 e4 d4 cs4) (h d4 q a4 a4))) (setf pitch (omn :pitch stimme1)) (setf len1 (length-rest-series '(2 2 2 2 2 2 2 2) '((1/2 1/4 1/4) (1/4 1/4 1/2) (1/2 1/2) (1/4 1/4 1/4 1/4) (1/2 1/4 1/4)))) => ((1/2 -1/4 1/4) (-1/4 1/4 -1/2) (1/2 -1/2) (1/4 -1/4 1/4 -1/4) (1/2 -1/4 1/4)) (setf len2 (length-rest-series '(1 2 2 2 2 2 2 2 2) '((1/2 1/4 1/4) (1/4 1/4 1/2) (1/2 1/2) (1/4 1/4 1/4 1/4) (1/2 1/4 1/4)))) => ((-1/2 1/4 -1/4) (1/4 -1/4 1/2) (-1/2 1/2) (-1/4 1/4 -1/4 1/4) (-1/2 1/4 -1/4)) (make-omn :length len1 :pitch (gen-swallow len1 pitch)) => ((h d4 -q g4) (-q e4 -h) (h e4 -) (q f4 - d4 -) (h d4 -q a4)) (make-omn :length len2 :pitch (gen-swallow len2 pitch)) => ((-h q a4 -) (q a4 - h f4) (-h g4) (-q e4 - cs4) (-h q a4 -))

for my current project i have to CONVERT/MAP pitches/lengths/velocity or MIDI into a binary sequence. so i coded this simple FUNCTION... feel free to use/adapt....
 
greetings
andré
 
 
(defun fill-to-x-bit (listseq &key (bitlength 7)) (loop for i in listseq when (< (length i) bitlength) collect (append (gen-repeat (- bitlength (length i)) 0) i) else collect i)) ;;;; CONVERT PITCH/LENGTH or VELOCITY TO BINARY INFORMATION (defun convert-to-binary (alist &key (parameter 'pitch) (length-resolution 127) (velocity-resolution 127) (pitch-resolution 127) (event nil) (bitlength 7)) (let ((pitch) (length) (velocity) (alist (progn (setf alist (cond ((stringp alist) (flatten (midi-to-omn alist :instrument 1))) (t alist))) (if (omn-formp alist) (cond ((equal parameter 'pitch) (setf alist (omn :pitch alist))) ((equal parameter 'length) (setf alist (omn :length alist))) ((equal parameter 'velocity) (setf alist (omn :velocity alist))) ((equal event 't) (setf alist (single-events alist)))) alist)))) (if (null event) (cond ((pitchp (car alist)) (progn (setf alist (pitch-to-midi (pitch-melodize alist))) (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution) (- (find-max alist) (find-min alist)) pitch-resolution) alist)) :bitlength bitlength))) ((lengthp (car alist)) (fill-to-x-bit (decimal-to-binary (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength)) ((velocityp (car alist)) (fill-to-x-bit (decimal-to-binary (vector-round 1 velocity-resolution (get-velocity alist))) :bitlength bitlength))) (progn (setf pitch (progn (setf alist (pitch-to-midi (pitch-melodize (omn :pitch alist)))) (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution) (- (find-max alist) (find-min alist)) pitch-resolution) alist)) :bitlength bitlength))) (setf length (fill-to-x-bit (decimal-to-binary (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength)) (setf velocity (fill-to-x-bit (decimal-to-binary (vector-round 1 velocity-resolution (get-velocity (omn :velocity alist)))) :bitlength bitlength)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 15) (convert-to-binary '(-e e -q h e) :bitlength 15) (convert-to-binary '(p p ffff mp ) :bitlength 15)  
 
 

I will have a think.

I will have a think.

I will have a think.

Will be implemented in the next update.
 
All you need to do is to add a line of code (below) into the ~/Opusmodus/Extensions/User Source.lisp file.
 
(defparameter *snippet-clef-default* :treble-down8)  

Thanks for pointing me in the right direction. I was able to arrive at the solution using the CHORD-INVERSION function. 

 
(setf chord '(c4d4e4)) (setf rot-size (get-chord-size chord)) => (3) (setf str-rot3       (pitch-transpose-start        0        (sort-asc         (pitch-melodize          (mclist           (flatten            (chord-inversion rot-size chord :root t :series t))))))) => ((c4 d4 e4) (c4 d4 bb4) (c4 gs4 bb4) (c4 d4 e4)) (chordize str-rot3) (chordize str-rot3) ((c4d4e4) (c4d4bb4) (c4gs4bb4) (c4d4e4))  
 
 
 

The input needs to be 12-tone row.

Maybe this helps:
(setf row '(c4 eb4 gs4 g4 a4 d4 fs4 cs4 bb4 b4 f4 e4)) (setf str-rot (pitch-transpose-start 0 (sort-asc (pitch-melodize (mclist (flatten (strawinski-rotation row :remove t))))))) => ((c4 f4 fs4 a4 bb4 c5) (c4 e4 bb4 bb4 cs5 f5) (c4 cs4 cs4 cs5 cs5 d5) (c4 e4 g4 g4 cs5 f5) (c4 d4 eb4 fs4 g4 c5) (c4 cs4 f4 g4 gs4 eb5) (c4 d4 e4 gs4 b4 f5) (c4 cs4 d4 bb4 b4 c5) (c4 fs4 a4 cs5 eb5 f5) (c4 g4 gs4 bb4 d5 eb5) (c4 d4 eb4 fs4 g4 c5) (c4 e4 g4 g4 cs5 f5) (c4 cs4 cs4 cs5 cs5 d5) (c4 e4 bb4 bb4 cs5 f5) (c4 f4 fs4 a4 bb4 c5) (c4 g4 gs4 bb4 d5 eb5) (c4 fs4 a4 cs5 eb5 f5) (c4 cs4 d4 bb4 b4 c5) (c4 d4 e4 gs4 b4 f5) (c4 cs4 f4 g4 gs4 eb5)) (chordize str-rot) => ((c4f4fs4a4bb4c5) (c4e4bb4bb4cs5f5) (c4cs4cs4cs5cs5d5) (c4e4g4g4cs5f5) (c4d4eb4fs4g4c5) (c4cs4f4g4gs4eb5) (c4d4e4gs4b4f5) (c4cs4d4bb4b4c5) (c4fs4a4cs5eb5f5) (c4g4gs4bb4d5eb5) (c4d4eb4fs4g4c5) (c4e4g4g4cs5f5) (c4cs4cs4cs5cs5d5) (c4e4bb4bb4cs5f5) (c4f4fs4a4bb4c5) (c4g4gs4bb4d5eb5) (c4fs4a4cs5eb5f5) (c4cs4d4bb4b4c5) (c4d4e4gs4b4f5) (c4cs4f4g4gs4eb5))  
or
(setf row '(c4 eb4 gs4 g4 a4 d4 fs4 cs4 bb4 b4 f4 e4)) (setf str-rot2       (pitch-transpose-start        0        (sort-asc         (strawinski-rotation row :remove t :chord nil)))) => ((c4 cs4 f4 fs4 g4) (c4 d4 g4 gs4 a4) (c4 d4 eb4 g4 a4)     (c4 d4 eb4 gs4 a4) (c4 d4 eb4 g4 gs4) (c4 eb4 g4 gs4 a4)     (c4 eb4 e4 a4 bb4) (c4 cs4 d4 fs4 g4) (c4 eb4 e4 f4 bb4)     (c4 eb4 e4 f4 a4) (c4 eb4 f4 a4 bb4) (c4 e4 f4 a4 bb4)     (c4 cs4 d4 fs4 g4) (c4 cs4 d4 g4 a4) (c4 d4 fs4 g4 a4)     (c4 cs4 fs4 g4 a4) (c4 cs4 f4 fs4 gs4) (c4 cs4 d4 fs4 a4)     (c4 cs4 fs4 g4 bb4) (c4 cs4 f4 fs4 g4) (c4 f4 fs4 g4 bb4)     (c4 e4 f4 fs4 a4) (c4 cs4 f4 g4 bb4) (c4 cs4 f4 fs4 bb4)) (chordize str-rot2) => ((c4cs4f4fs4g4) (c4d4g4gs4a4) (c4d4eb4g4a4) (c4d4eb4gs4a4)     (c4d4eb4g4gs4) (c4eb4g4gs4a4) (c4eb4e4a4bb4) (c4cs4d4fs4g4)     (c4eb4e4f4bb4) (c4eb4e4f4a4) (c4eb4f4a4bb4) (c4e4f4a4bb4)     (c4cs4d4fs4g4) (c4cs4d4g4a4) (c4d4fs4g4a4) (c4cs4fs4g4a4)     (c4cs4f4fs4gs4) (c4cs4d4fs4a4) (c4cs4fs4g4bb4) (c4cs4f4fs4g4)     (c4f4fs4g4bb4) (c4e4f4fs4a4) (c4cs4f4g4bb4) (c4cs4f4fs4bb4))  

Okay, it works easily and well with my setup: simply copy the "emacs-opusmodus.el" into your local quicklisp directory and modify Emacs's init.el to add
 
(load (expand-file-name "$HOME/quicklisp/emacs-opusmodus.el")) (load-opusmodus-slime) (opusmodus-options)  
This allows me to run up a REPL against SBCL (M-x slime) or against OM (M-x slime-connect)

Hi.
 
I've just started with OM2 and I'm finding the emacs/slime setup a touch confusing (there has obviously been lots of work on this part of OM over the years of this forum). Basically, I run my current emacs setup with an exisiting slime setup (I do some dev work using SBCL). Is there a "correct" way of adding or modifying  emacs-opusmodus.el to work with an existing setup? Or can I simply copy it, and hack it as needed?
 
TIA and loving OM 🙂
 
.. m.

or...
 
(loop for x from 7 downto 1 for y from 1 to 7 collect (list x 3 y))  

make 3 lists and mix them 🙂

For some recent is not working if in Extensions folder.

Is this what you are looking for:
 
(setf ph1 (ambitus            '(g3 g6)            (filter-tie             (make-omn              :pitch (gen-loop size (interval-ambitus 6 (rnd-sample 12 (make-scale 'd4 12 :alt '(2 1 3)))))              :length (gen-loop size (length-legato (rnd-sample 4 '(s -s))))              :velocity (rnd-sample 12 '((pp)(p)(mp)(mf)(f)))              :span :pitch              ))))  
By default the span in length. If you wan't pitch to be the master then :span :pitch will do the trick.