AM

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 or PARTS https://www.youtube.com/channel/UCkBcN66Y0mYZ8EJ_ihZvkdg

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

here is a sketch for an alternative "binary-(or element-)layer-FUNCTION (defun element-layer (lists &key (rnd nil)) (let ((lists (if (null rnd) lists (rnd-order lists :list t)))) (car (last (loop for x in (rest lists) with list = (car lists) collect (setf list (loop for i in list with cnt = 0 when (equal i 0) collect (nth cnt x) and do (incf cnt) else collect i))))))) (element-layer (list '(1 0 0 1 1 0 0 1 0 0 0 0) '(0 2 3 0 4 5 0 6 0 7 8 0) '(11 12 13 14 15 16 17)) :rnd nil) => (1 11 2 1 1 3 12 1 4 5 13 6) ;;; hierarchic: every 0's will be replaced by the values from the next/sub-list...

testing videoplayer in OPMO.mov whitenoise.mov

you want to map some integers (in your case pc..) to attributes? like that? (position-filter '(0 1 2 3 4 5) '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte)) => (pizz arco ponte molto-ponte stacc stacc+pizz) (position-filter (pcs '6-Z10) '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte)) => (pizz arco molto-ponte stacc stacc+pizz ten+molto-ponte) or in pure CCL (loop for i in '(0 1 2 3 4 5) with attr-list = '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte) collect (nth i attr-list)) => (pizz arco ponte molto-ponte stacc stacc+pizz)

i've made different user folders... named: user editing user pattern matching .... ...or you could put all in the same... (i realized for my work, that most of the time i'm using a "coded function" only for a specific project/work. so i stopped it to put all special functions into my user library. now, i have the functions only in my project workspace...)

i do it like that... greetings andré

in german... https://www.amazon.de/Programmieren-COMMON-LISP-Otto-Mayer/dp/3860257102 (but without LOOP) https://www.tutorialspoint.com/lisp/index.htm https://lisptips.com https://www.youtube.com/channel/UCMV8p6Lb-bd6UZtTc_QD4zA