Stephane Boussuge

one other interesting approach could be, to use l-systems on a "higher level"... (a lot of work to this is already made in OPENMUSIC)
a sequence like '(a b a c a d a a b a e ...) ;; as a "nonsense-l-system-example-seq"
could be used as a seq for FUNCTIONS... means:
 
an input/omn-seq would be transformed by an l-system-function-sequence, for example...
 
a = rotate pitches and lengths
b = invert pitches
c = sample-seq pitches
d = change velocities
 
so you could work with more complex input-gestalts... and when you are doing this on a second/third-level inside of such GESTALTS you will have something like this MODEL...
 
Hypercycle (chemistry) - Wikipedia
EN.WIKIPEDIA.ORG  
 
i think HANSPETER KYBURZ is "the MASTER" for L-SYSTEMS in MUSICAL COMPOSITION, and i he talked about this things in his lectures
 
Details - Hochschule für Musik Hanns Eisler Berlin
WWW.HFM-BERLIN.DE Hanspeter Kyburz - Wikipedia
EN.WIKIPEDIA.ORG  
famous pieces with/on this are:
 
CELLS
 
 
or
PARTS
 
 
 
 
 
https://www.youtube.com/channel/UCkBcN66Y0mYZ8EJ_ihZvkdg
 

here  a function... to barraqué's techniques
 
(defun serie-proliferantes (row) (let* ((ri_row (pitch-invert (gen-retrograde row))) (row (loop for z in (loop for x in (pitch-to-midi ri_row) collect (or (position x (pitch-to-midi row)) (position (- x 12) (pitch-to-midi row)) (position (+ x 12) (pitch-to-midi row)))) collect (nth z ri_row)))) row)) (serie-proliferantes '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)) => (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)  
Jean Barraqué — Wikipédia
FR.WIKIPEDIA.ORG  
seen here:
https://www.amazon.de/Jean-Barraqué-Musik-Konzepte-Heinz-Klaus-Metzger/dp/3883774499
 
page 19-20
 
 

 

 

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

With Stephane's help, I learned that a possible number of intervals to process in each list is a random choice. What is more, each parameter in this function, including the number of possible intervals to process, is applied recursively to the last processed subset of intervals.
 
Janusz- 
Might it be possible to add :cycle-intervals and :cycle-num options the interval-expansion-series function? Those options would allow for the interval transformation parameters cycled in place of random.
 
Thanks!
Zvony

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

Thanks. Wouldn't it be nice to add it to the official documentation?
 

(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)))  

HI,
 
here's the fixed version, I've missed a list function in the previous one.
Thank you for pointing out !
 
Best
 
Stephane
 
;;; Looping the process ;;; ============================ (setf seq (gen-loop 4 ;; nb d'itération du process (progn ;; process (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 vn (assemble-seq (loop for s in seq collect (nth 0 s)))) (setf va (assemble-seq (loop for s in seq collect (nth 1 s)))) (setf vc (assemble-seq (loop for s in seq collect (nth 2 s)))) (ps 'gm :vn (list vn) :va (list va) :vc (list vc) :tempo 88 ) ;;; THE SAME PROCESS WITH ADDED MUTE/PLAY SYSTEM ;;; Looping the process ;;; ============================ (setf seq (gen-loop 4 ;; nb d'itération du process (progn ;; process (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))) )))) ) ;;; Mute/play (do-timeline2 '(ph1 ph2 ph3) (binary-invert (matrix-transpose (gen-group (rnd-sample 7 '(0 1)) :size size))) '(gen-pause x) ) ))) (setf vn (assemble-seq (loop for s in seq collect (nth 0 s)))) (setf va (assemble-seq (loop for s in seq collect (nth 1 s)))) (setf vc (assemble-seq (loop for s in seq collect (nth 2 s)))) (ps 'gm :vn (list vn) :va (list va) :vc (list vc) :tempo 88 )  

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)  
 
 

Another possible way:
 
(setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13))) (setf rhythm (mapcar (lambda(x) (euclidean-rhythm 16 4 16 's :type 2 :seed x)) seeds)) SB.

Another possible way:
 
(setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13))) (setf rhythm (mapcar (lambda(x) (euclidean-rhythm 16 4 16 's :type 2 :seed x)) seeds)) SB.

Thanks, Andre ! I will check the Lachenmann piece, for sure.
 
I was thinking in a possible algorithm for such function:
 
1) Take an OMN expression
2) Calculate the empty spaces (rest space)
3) Fill the spaces with notes, based on each gap, using a predefined quantization (1/16, 1/8, random, etc) and a filling density level (0-100 %,  of the space)
4) Fill the spaces with predefined pitch lists, motifs, rhythmmic sets, etc,  that can be trimmed, rotated and start on any note
5) Fill the spaces like mentioned before with some pitch quality control (tonality-map) and pitch melodic direction control (up, down, repeat, vector).
6) Fill the spaces like before with any predefined method
 
populate-spaces
populate-gap
fill-spaces
fill-gap
 
This would be really useful, IMHO.
 
All the best !
Julio

I will have a think.

Something like this
 

 
For a more refined Idea, this population could be oriented by tonality-map for chord-guided notes and some vector (for melodic directions).
 
Thanks, Stephane
I´ll try your suggestion
 

I've experimented different approach to this in past.
One of the possible way is to use passing-interval function to populate between you anchor chords.
 
SB.

An ambient piece based on a Fibonacci series.

 
SB.
FibonacciMeditation.opmo

Ambient soundtrack, thanks to gen-controller function for the algorithmic parameters automation ;-)

 
SB.

I use HARMONIC-PATH function to apply harmony when I want to keep the voice leading of my applied chords.
 
HARMONIC-PATH change totally the harmonic content when applying. TONALITY-MAP just "map" pitches on closest other pitches.
 
Try to use as path some chords with a very typical classical and well defined voice leading with both functions on a more complex material and you will see the difference .
 
S.

I use HARMONIC-PATH function to apply harmony when I want to keep the voice leading of my applied chords.
 
HARMONIC-PATH change totally the harmonic content when applying. TONALITY-MAP just "map" pitches on closest other pitches.
 
Try to use as path some chords with a very typical classical and well defined voice leading with both functions on a more complex material and you will see the difference .
 
S.

Dear Rangarajan,
You can use the :size parameter in the harmonic-progression function to create 4 pitch chords.
 
S.
 

A small solo cello piece composed this evening.
 
   
 
 
Stéphane
 
WaitingIntoTheRoom.opmo WaitingIntoTheRoomForSoloCello.mp3