AM

i know i'm not a programmer, but it probably makes sense to be able to enter both variants/formats for some functions, but not for others...

you have to put the bar-numbers into a list... i makes sense in my opinion - perhaps you want to "find" more then one bar... (find-bar '(1 2) mat) => ((c4 db4 ab4 f4 g4 bb4) (a4 eb4 b4 e4 d4 gb4))

have a look here...?

dear all here's a function (revised, should work correct now) to work with rotations - based on the work of karel goeyvaerts (defun goeyvaerts-rotation* (&key pitches static-pitches generations goeyvaerts-transpose-interval (direction 'up) low-border high-border correction-interval) (let ((pitches (filter-remove (pitch-to-midi static-pitches) (pitch-to-midi pitches)))) (midi-to-pitch (append (list (append pitches (pitch-to-midi static-pitches))) (cond ((equal direction 'up) (loop repeat generations for x in (gen-repeat 50 goeyvaerts-transpose-interval) collect (append (setf pitches (append (loop for i in pitches when (> (+ i x) (pitch-to-midi high-border)) collect (+ x (- i (abs correction-interval))) else collect (+ i x)))) (pitch-to-midi static-pitches)))) ((equal direction 'down) (loop repeat generations for x in (gen-repeat 50 goeyvaerts-transpose-interval) collect (append (setf pitches (append (loop for i in pitches when (< (- i x) (pitch-to-midi low-border)) collect (+ i correction-interval) else collect (- i x)))) (pitch-to-midi static-pitches))))))))) EXAMPLE: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; an example with multiple objects inside a chord / GOEYVAERTS uses it woth octave-rotations and with static pitches ;;; here i do it different.... ;;; :goeyvaerts-transpose-interval => in every generation the elements are transposed by next interval (circular) ;;; :static-pitches => will not rotate!! ;;; :high-border => if a pitch is higher then this it will be transposed down by :correction-interval ;;; EVALUATE THIS (setf groups (loop for i in (goeyvaerts-rotation* :pitches '(b3 d4 eb4 gb4 f5 e5 g5 ab5 a4 bb4 db5 c6) :static-pitches nil;'(e4 eb5) :direction 'up :generations 20 :goeyvaerts-transpose-interval '(2 3 5 7 5 3) :low-border 'a2 :high-border 'eb6 :correction-interval -36) collect (gen-divide '(5 3 2 2) i))) ;;; AND THIS / cmd1 => so you see the chords an see the rotation etc.. (setf chordized-groups (loop for i in groups collect (chordize i))) => you see the process of the elements

violà... now it works fine - OPMO could integrate it.... it's easier than i thought: a single index-series is read from the r-i and only this one is used! similar to LACHEMANN, only he determines this index-series himself (for that i coded this simple row-permutation-function)... greetings a. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUB (defun row-permutation (n row rules &key (one-based nil)) (let* ((rules (if (equal one-based t) (mapcar '1- rules) rules))) (loop repeat n collect (setf row (position-filter rules row))))) ;;; MAIN (defun serie-proliferantes (n row) (let ((index-no (loop for x in (pitch-to-midi (pitch-invert (gen-retrograde row))) collect (or (position x (pitch-to-midi row)) (position (- x 12) (pitch-to-midi row)) (position (+ x 12) (pitch-to-midi row)))))) (list row (pitch-invert (gen-retrograde row)) (row-permutation n (pitch-invert (gen-retrograde row)) index-no)))) (serie-proliferantes 6 '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)) => ((c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) ((fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) (bb4 fs4 cs5 g4 gs4 a4 d5 c5 f4 b4 eb5 e5) (e5 bb4 g4 cs5 c5 fs4 gs4 a4 b4 f4 d5 eb5) (eb5 e5 cs5 g4 a4 bb4 c5 fs4 f4 b4 gs4 d5) (d5 eb5 g4 cs5 fs4 e5 a4 bb4 b4 f4 c5 gs4) (gs4 d5 cs5 g4 bb4 eb5 fs4 e5 f4 b4 a4 c5)))

row-permutation (with rule) for n-generations (defun row-permutation (n row rules &key (one-based nil)) (let ((rules (if (equal one-based t) (mapcar '1- rules) rules))) (loop repeat n collect (setf row (position-filter rules row))))) (row-permutation 5 '(a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) '(0 1 6 5 2 3 7 8 11 9 4 10)) => ((a4 gs4 eb5 c5 cs5 e5 d5 bb4 f4 g4 b4) (a4 e5 cs5 gs4 eb5 d5 bb4 b4 f4 c5 g4) (a4 d5 eb5 e5 cs5 bb4 b4 g4 f4 gs4 c5) (a4 bb4 cs5 d5 eb5 b4 g4 c5 f4 e5 gs4) (a4 b4 eb5 bb4 cs5 g4 c5 gs4 f4 d5 e5)) (row-permutation 5 '(a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) '(1 4 6 5 2 3 7 8 11 9 10 12) :one-based t) => ((a4 g4 gs4 eb5 c5 cs5 e5 d5 bb4 f4 b4 fs4) (a4 eb5 cs5 c5 g4 gs4 e5 d5 b4 bb4 f4 fs4) (a4 c5 gs4 g4 eb5 cs5 e5 d5 f4 b4 bb4 fs4) (a4 g4 cs5 eb5 c5 gs4 e5 d5 bb4 f4 b4 fs4) (a4 eb5 gs4 c5 g4 cs5 e5 d5 b4 bb4 f4 fs4))

thanks, julio... could you have a quick look to the function? and to the article from didier.... perhaps you see my mistake (or the mistake in the article) subito ? barraqué described the mechanism and it seems easy to code it. but where is the mistake with more then 3 gens? perhaps didier has an idea?

thanks, julio...!!! if i got it right, it works like this: 1. take a basic row 2. the r-i of the basic row 3. read the positions of all pitches of the r-i within the basic row 4. apply this positionlist to r-i => outout is : ordre 0 => basic row ordre 1 => r-i ordre 2 => proliferante 1 = more or less ONE GEN of production ... so the question could be: is ordre 1 the new basic row, or proliferante 1 ... to produce the next GEN? here is some code to check it... i have no idea at the moment... ;;; ONE GEN (defun serie-proliferantes (row) (let* ((basic_row row) (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)))) (list basic_row ri_row row))) ;;;; X GENS (defun serie-proliferantes** (n row) (loop repeat n collect (setf x (serie-proliferantes row)) do (setf row (third x)))) ;; when you write here second/third x => then it would be ordre 1 ; ;or prolifer 1 as new starting point (serie-proliferantes** 3 '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4))

i tried to program it briefly for several generations, but I didn't quite get it - something i do not understand.... so i got wrong outputs after 3 generations... maybe OPMO would like to CODE this? this is my new version... but when i have i look to the barraqué-examples (order 0 - x)... there is a different output after 3 gens... Ordre 0: C Ab G Db E D Bb Eb B F Gb A (c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) Ordre 1: A C Db G Eb Ab E D F B Bb Gb (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) Ordre 2: Gb A G Db D C Eb Ab B F E Bb (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) Ordre 3: Bb Gb Db G Ab A D C F B Eb E (bb4 e4 eb5 a4 c5 f4 gs4 fs4 g4 cs5 b4 d5) ???? wrong... Ordre 4: E Bb G Db C Gb Ab A B F D Eb Ordre 5: Eb E Db G A Bb C Gb F B Ab D Ordre 6: D Eb G Db Gb E A Bb B F C Ab Ordre 7: Ab D Db G Bb Eb Gb E F B A C efun serie-proliferantes* (basicrow &key (gen 10)(ordre nil)) (let* ((row basicrow) (ri_row (pitch-invert (gen-retrograde basicrow))) (serie (cons basicrow (loop repeat gen append (list ri_row (setf 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)))) do (setf ri_row (pitch-invert (gen-retrograde row))))))) (if (not (null ordre)) (position-filter ordre serie) serie))) (serie-proliferantes* '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4)) => ((c5 ab4 g4 db5 e4 d4 bb4 eb4 b4 f4 fs4 a4) (a4 c5 cs5 g4 eb5 gs4 e5 d5 f4 b4 bb4 fs4) (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4) (bb4 e4 eb5 a4 c5 f4 gs4 fs4 g4 cs5 b4 d5) (d5 b4 gs4 e4 f4 cs5 fs4 bb4 eb5 a4 g4 c5) (c5 f5 eb5 a4 d5 fs5 b4 g5 gs5 e5 cs5 bb4) (bb4 d5 gs5 e5 c5 b4 f5 cs5 eb5 a4 fs5 g5) (g5 gs5 f6 b5 cs6 a5 eb6 d6 bb5 fs5 c6 e6) (e6 f6 eb6 a5 d6 fs5 bb5 gs5 g5 c6 cs6 b5) (b5 a5 bb5 eb6 d6 c6 e6 gs5 cs6 g5 f5 fs5) (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6) (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6) (c6 eb6 d6 gs5 f5 bb5 e6 cs6 b5 g5 a5 fs5) (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6) (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6) (c6 eb6 d6 gs5 f5 bb5 e6 cs6 b5 g5 a5 fs5) (fs5 eb6 e6 bb5 d6 g5 b5 gs5 f5 cs6 a5 c6) (c6 eb6 b5 g6 e6 cs6 f6 bb5 d6 gs5 a5 fs6) (fs6 eb6 f6 cs6 b5 gs5 d6 g6 e6 bb5 a5 c6))

thank you for the LINKS, i will read the papers! greetings andré

thanx, dear julio. the "serialists" often have suitable concepts for formalization greetings andré

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

Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz - PDF Kostenfreier Download DOCPLAYER.ORG Hochschule für Musik Hanns Eisler Abteilung D Charlottenstr Berlin Masterarbeit Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz Eres Holz 30. April 2012 Inhaltsverzeichnis

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

perhaps some (old) hocket-function... ?

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'm very interested in!! thx to you JULIO!!! strukturnetz is not a piece, it's "a kind of technique" he used you could read about it here: https://www.amazon.de/Differenzen-Poststrukturalistische-Beispiel-Lachenmann-Ferneyhough/dp/3931264157 listen here... the STRUKTURNETZ is also "notated" in the score (on top)

like that? should work... it "loops" x-times (depends on length of seeds-list) and collect the rhythms... (setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13))) (setf rhythm (loop for i in seeds collect (euclidean-rhythm 16 4 16 's :type 2 :seed i))) perhaps there is an OPMO-solution, this is LISP

would be interesting. it has quite some (distant?) aspects of LACHENMANN's "strukturnetz", and could be nice to work in such an direction...

dear ole i have no "preseted" soundsets for my work... in my current "sketch" i'm using/something something like this.. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (add-text-attributes '(e-bow "e-bow") '(harm-I "harm-1") '(harm-II "harm-II") '(harm-III "harm-III") '(harm-IV "harm-IV") '(harm-V "harm-V") '(harm-VI "harm-VI")) (def-sound-set gm-guitar :programs (:group guitar ord 0 bartok-pizz 1 tap 2 ponte 3 harm-I 4 harm-II 5 harm-III 6 harm-IV 7 harm-V 8 harm-VI 9)) (def-sound-set gm-vibraphone :programs (:group vibraphone ord 0 tap 2)) (def-sound-set gm-piano :programs (:group piano ord 0 e-bow 1)) for this CT-setup... git vibra pno.cePlayerOrc

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

i have been working with conTimbre for a long time and it is exactly what i was looking for. playing techniques can easily be done by OPMO or SIBELIUS (vst3) via program changes. it has a great many different playing techniques. I always found IRCAM_LIB to be very inadequate, as there were not enough playing techniques etc. / you can also control CT via OSC (and as standalone or via MAXMSP). when I wrote for ensemble with additional e-player, CT-live always worked very well. (The only negative point I could say is that there are a few SAMPLES that weren't played / recorded very well. But with the size of the library, that's okay with me)

Dear all Today I dealt briefly how to control PROCESSING (software and programming language) by Midi. There is a great interface for this: "rwmidi" by Giuseppe Torre. You can download and install it, it works fine! A short Video (no Sound) with a very simple Processing Example movie.mov I think this is a good combination if you want to visualize your midi output (or just use de midi-data in realtime) or if you want to program a separate VISUAL track in OPMO. Here is a small example (I can't program usable in PROCESSING yet, sorry :-)) Downloads etc. are here ... https://processing.org https://gitlab.com/giuseppetorre/rwmidi-revival-master here's a video, how to install etc... https://www.youtube.com/watch?v=7iFUenT5B68&feature=youtu.be and as an attachm. my "sketch" in processing sketch_Processing_from_Midi.pde Greetings André P.S. I think there ist also a way to send data by OSC

thanks... i will post the CODE and some videos etc. when i have finished the work - premiere will be in november... greetings andré

dear all here's an example (from my current work)... this little video shows how i generate/display SCORE (instrumental parts) on a screen + virtual conductor (piano part). the example is "nonsense", but shows how it looks/works... you see the bars (generating), the cue, beat... and the arrow (that shows you where to read/play) ...also you hear some bad (sry) sound-simulation of the setup. in this way i can generate a whole piece in realtime on STAGE (all musicians will read their part from their own screen). this one will be for 5 instruments, ePlayer and modular synthesizer. during the performance an algorithm (or some data-streams) will generate the piece in OPMO. with OSC i can send all datas (score, beat, tempo..) from OPMO to POLYTEMPO-NETWORK (https://polytempo.zhdk.ch) and work and coordinate different independent tempo layers, conducting etc... for more POLYTEMPO informations... have a look here: https://polytempo.zhdk.ch greetings andré IMG_0083.MOV