JulioHerrlein

Dear Julio,
 
It is not a programmer standpoint, the function name is PCS-RHYTHM (Pitch Class Set).
You might need to look the binary functions or TIME-POINT-SYSTEM function.
(length-staccato (time-point-system (melodize 'c4d4e4f4g4a4b4) 's))  
Best, J

Check the output below. The above looks correct to me.
(pcs-prime-form (melodize 'c4d4e4f4g4a4)) => (0 2 4 5 7 9) (pcs-prime-form (melodize 'c4d4e4f4g4a4b4)) => (0 1 3 5 6 8 10)

Will have a look.

I did my own chord symbols for all the FORTE Structures (p. 361 of Dissertation ). Just in case...
Some have Strange names, specially the chords that contain a Chromatic Cluster.
Best,
Julio
 


 

 

 
 
 

Are you simply looking for an invert function, e.g., pitch-invert? 
 
(pitch-invert '(c4 d4 e4)) => (c4 bb3 gs3)  
This function inverts (mirrors) around the first pitch by default. If you are looking for retaining the original ambitus, you might want to instead you my function invert-in-ambitus (https://tanders.github.io/tot/sources/pitch.html#_g251910).
 
(invert-in-ambitus '(c4 e4 g4))  => (g4 eb4 c4)
BTW, when you are specifically talking about a harmonic context in which you are "mirroring" chords, there exist extensive music theories based on this idea already. The notion of minor chords as the mirror image of major chords, and its implications on harmonic functions (tonic, dominant, subdominant etc.) was in detail explored under the label of dualism by theorists like Hugo Riemann, Arthur von Öttingen and Sigfrid Karg-Elert. They also already generalised this notion for microtonal music. Likely independently of these theorists exploring the notion of dualism, Harry Partch's concept of otonality and utonality is also based on this idea, now firmly in the field of microtonal music. In microtonal harmonic theory I came across this notion also elsewhere (e.g., discussed by the composers and theorists of ekmelic music like Franz Richter Herf, which may have arrived there independently as well.
 
Anyway, this harmonic concept in general is so basic and fundamental that I would not be surprised it would have been studied by the likes of Pythagoras already...
 
Best,
Torsten

Dear All,
 
I'm trying to find a suitable workflow to make my choices easier.
One idea was to compose over a piano reduction, for easier manipulation.
Here's a way of doing that, with comments.
The MIDI FILE output is like this. I did NO EDITIONS at all in Musescore.This is the video of the MIDI output.
The XML output is the piano reduction.
Very convenient !
 
Best,
Julio
 

str_4tet_opusmodus.mov ;;;SEV CHORDS Basic Functions ;;;Harmonic Functions/Sets List (setf Srm7 (pcs-transpose 9 (pcs '4-26) :pitch)) (setf S7M (pcs-transpose 4 (pcs '4-20) :pitch)) (setf Trm7 (pcs-transpose 4 (pcs '4-26) :pitch)) (setf T7M (pcs-transpose -1 (pcs '4-20) :pitch)) (setf Tam7 (pcs-transpose 11 (pcs '4-26) :pitch)) (setf D7 (pcs-transpose 11 (pcs '4-27b) :pitch)) (setf hd (pcs-transpose 9 (pcs '4-27) :pitch)) ;;;Estabilishing a Basic Progressions (setf chordprog (chordize (list Srm7 S7M Trm7 T7M Tam7 S7M))) ;;;Repeating and transposing the progression (setf chordtrp-rpt (pitch-transpose-repeat '((0 3 5 4) (0 2 -2 -1) (0 5 1 -2) (7 12 10 -3)) chordprog)) ;;; Making suitable voicings to the progression (setf chordprogdrop (chordize-list (pitch-transpose-n '(0 -12 0 0) (pitch-melodize chordtrp-rpt)))) ;;;Using these dropped chords as the source (setf chordprgtrp chordprogdrop) ;;;Opcionally with more Voice-Leading, with a smooth transition between the chords ;(setf chordprgtrp (chord-closest-path (car chordprogdrop) (gen-divide 4 chordprogdrop))) ;;;Counting the number of chords to make rhythm repetitions ;(setf times (get-count (get-count chordprgtrp))) ;;;Optionally setting manually the repetitions (setf times 24) ;;;Eachnote assigned to a voice (setf voz1 (flatten (pitch-demix 1 chordprgtrp))) (setf voz2 (flatten (pitch-demix 2 chordprgtrp))) (setf voz3 (flatten (pitch-demix 3 chordprgtrp))) (setf voz4 (flatten (pitch-demix 4 chordprgtrp))) ;;;optionally processing the ambitus of the voices ;(setf vozamb1 (ambitus '(c4 c5) voz1) vozamb2 (ambitus '(f3 c5) voz2) vozamb3 (ambitus '(g3 g4) voz3) vozamb4 (ambitus '(c2 e3) voz4)) ;;; Or setting to instrument's ranges ;(setf vozamb1 (ambitus (ambitus-instrument 'flute) voz1)vozamb2 (ambitus (ambitus-instrument 'oboe) voz2) vozamb3 (ambitus (ambitus-instrument 'clarinet) voz3) vozamb4 (ambitus (ambitus-instrument 'bassoon) voz4)) ;;;or just using the resulting drops as given (setf vozamb1 voz1 vozamb2 voz2 vozamb3 voz3 vozamb4 voz4) ;;;RIT ;;;one rhythm to all (for checking the "chorale" writing) ;(setf r1 (gen-repeat times '(q)) r2 (gen-repeat times '(q)) r3 (gen-repeat times '(q)) r4 (gen-repeat times '(q))) ;;;Doing an homorhythmic section (all instruments play the same rhythms (setf homorhy (gen-repeat times '(q -q e q e h h -s s s s)) r1 homorhy r2 homorhy r3 homorhy r4 homorhy) ;;; Articulation for the homorhytm (setf arthomo '(ten stacc ord stacc ord ord leg leg ord)) ;;;OMN ASSEMBLAGE of the Lines (setf vozomn1 (make-omn :length r1 :pitch vozamb1 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn2 (make-omn :length r2 :pitch vozamb2 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn3 (make-omn :length r3 :pitch vozamb3 :articulation arthomo :velocity (rnd-order'(pp)))) (setf vozomn4 (make-omn :length r4 :pitch vozamb4 :articulation arthomo :velocity (rnd-order'(pp)))) ;;;--------------------------------------------------------- ;;; SCORE ;;;---------------------------------------------------------- (def-score voices (:title "Piano-Red-4-Voices" :subtitle "Estudos Polifônicos" :composer "Julio-Herrlein" :key-signature 'atonal :time-signature '(4 4) :tempo '("Meditativo" q 60) :layout (piano-solo-layout '(pno-rh1 pno-rh2) '(pno-lh pno-lh2))) (pno-rh1 :omn vozomn1 :channel 1 :sound 'gm :program 'Violin :volume 100) (pno-rh2 :omn vozomn2 :channel 2 :sound 'gm :program 'Violin :volume 70) (pno-lh :omn vozomn3 :channel 3 :sound 'gm :program 'Viola :volume 80) (pno-lh2 :omn vozomn4 :channel 4 :sound 'gm :program 'Cello :volume 80))  

Dear All,
 
I'm trying to find a suitable workflow to make my choices easier.
One idea was to compose over a piano reduction, for easier manipulation.
Here's a way of doing that, with comments.
The MIDI FILE output is like this. I did NO EDITIONS at all in Musescore.This is the video of the MIDI output.
The XML output is the piano reduction.
Very convenient !
 
Best,
Julio
 

str_4tet_opusmodus.mov ;;;SEV CHORDS Basic Functions ;;;Harmonic Functions/Sets List (setf Srm7 (pcs-transpose 9 (pcs '4-26) :pitch)) (setf S7M (pcs-transpose 4 (pcs '4-20) :pitch)) (setf Trm7 (pcs-transpose 4 (pcs '4-26) :pitch)) (setf T7M (pcs-transpose -1 (pcs '4-20) :pitch)) (setf Tam7 (pcs-transpose 11 (pcs '4-26) :pitch)) (setf D7 (pcs-transpose 11 (pcs '4-27b) :pitch)) (setf hd (pcs-transpose 9 (pcs '4-27) :pitch)) ;;;Estabilishing a Basic Progressions (setf chordprog (chordize (list Srm7 S7M Trm7 T7M Tam7 S7M))) ;;;Repeating and transposing the progression (setf chordtrp-rpt (pitch-transpose-repeat '((0 3 5 4) (0 2 -2 -1) (0 5 1 -2) (7 12 10 -3)) chordprog)) ;;; Making suitable voicings to the progression (setf chordprogdrop (chordize-list (pitch-transpose-n '(0 -12 0 0) (pitch-melodize chordtrp-rpt)))) ;;;Using these dropped chords as the source (setf chordprgtrp chordprogdrop) ;;;Opcionally with more Voice-Leading, with a smooth transition between the chords ;(setf chordprgtrp (chord-closest-path (car chordprogdrop) (gen-divide 4 chordprogdrop))) ;;;Counting the number of chords to make rhythm repetitions ;(setf times (get-count (get-count chordprgtrp))) ;;;Optionally setting manually the repetitions (setf times 24) ;;;Eachnote assigned to a voice (setf voz1 (flatten (pitch-demix 1 chordprgtrp))) (setf voz2 (flatten (pitch-demix 2 chordprgtrp))) (setf voz3 (flatten (pitch-demix 3 chordprgtrp))) (setf voz4 (flatten (pitch-demix 4 chordprgtrp))) ;;;optionally processing the ambitus of the voices ;(setf vozamb1 (ambitus '(c4 c5) voz1) vozamb2 (ambitus '(f3 c5) voz2) vozamb3 (ambitus '(g3 g4) voz3) vozamb4 (ambitus '(c2 e3) voz4)) ;;; Or setting to instrument's ranges ;(setf vozamb1 (ambitus (ambitus-instrument 'flute) voz1)vozamb2 (ambitus (ambitus-instrument 'oboe) voz2) vozamb3 (ambitus (ambitus-instrument 'clarinet) voz3) vozamb4 (ambitus (ambitus-instrument 'bassoon) voz4)) ;;;or just using the resulting drops as given (setf vozamb1 voz1 vozamb2 voz2 vozamb3 voz3 vozamb4 voz4) ;;;RIT ;;;one rhythm to all (for checking the "chorale" writing) ;(setf r1 (gen-repeat times '(q)) r2 (gen-repeat times '(q)) r3 (gen-repeat times '(q)) r4 (gen-repeat times '(q))) ;;;Doing an homorhythmic section (all instruments play the same rhythms (setf homorhy (gen-repeat times '(q -q e q e h h -s s s s)) r1 homorhy r2 homorhy r3 homorhy r4 homorhy) ;;; Articulation for the homorhytm (setf arthomo '(ten stacc ord stacc ord ord leg leg ord)) ;;;OMN ASSEMBLAGE of the Lines (setf vozomn1 (make-omn :length r1 :pitch vozamb1 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn2 (make-omn :length r2 :pitch vozamb2 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn3 (make-omn :length r3 :pitch vozamb3 :articulation arthomo :velocity (rnd-order'(pp)))) (setf vozomn4 (make-omn :length r4 :pitch vozamb4 :articulation arthomo :velocity (rnd-order'(pp)))) ;;;--------------------------------------------------------- ;;; SCORE ;;;---------------------------------------------------------- (def-score voices (:title "Piano-Red-4-Voices" :subtitle "Estudos Polifônicos" :composer "Julio-Herrlein" :key-signature 'atonal :time-signature '(4 4) :tempo '("Meditativo" q 60) :layout (piano-solo-layout '(pno-rh1 pno-rh2) '(pno-lh pno-lh2))) (pno-rh1 :omn vozomn1 :channel 1 :sound 'gm :program 'Violin :volume 100) (pno-rh2 :omn vozomn2 :channel 2 :sound 'gm :program 'Violin :volume 70) (pno-lh :omn vozomn3 :channel 3 :sound 'gm :program 'Viola :volume 80) (pno-lh2 :omn vozomn4 :channel 4 :sound 'gm :program 'Cello :volume 80))  

look closest-path and relative-closest-path.
 
S.

Shortly.

midi-to-omn will be super useful for me, thanks !
 
Stéphane
 

Not directly. First you need to import the midi file to score and then extract the pitches with OMN function.
I like the idea, maybe we will add this functionality in the future.

dear all
 
is there a quick way to import (or filter) only pitches and chords from a midi-file? if i only use these (nothing else from midi/xml)
 
thanx for a hint
andré

Dear All, 
 
One interesting thing that could be implemented as a function could be a form of generating Negative Harmony.
In the video below, there are some explanation of what it is and the origin in the Levy book.
It was a trendy topic due to the Jacob Collier interview. And there are a lot of fun videos making versions of pop tunes using negative harmony.
 
The way I understand it, it is simply a kind of mapping notes in relation to an axis, like in the figure below.
 

 
So we need a function that could map a note in any register to another note in the closest register to the first on.
So, any  C note will be mapped to G, all Db to F#, all D to F, all, Eb to E, all B to Ab, all Bb to A.
 
It´s also possible to generate other mappings as well.
 
I think that replace map or substitute map can do the job, but I´m not sure (I will try), but I find interesting to post it here to explore the idea.
 
All the best,
 
Julio
 
It´s kind of funny to sse in this por versions how every is upside down and how you can generate an entirely new song from exactly the same material.
 
 
 
POP TUNES with negative harmony:
 
 
 
 
 

Dear All, 
 
One interesting thing that could be implemented as a function could be a form of generating Negative Harmony.
In the video below, there are some explanation of what it is and the origin in the Levy book.
It was a trendy topic due to the Jacob Collier interview. And there are a lot of fun videos making versions of pop tunes using negative harmony.
 
The way I understand it, it is simply a kind of mapping notes in relation to an axis, like in the figure below.
 

 
So we need a function that could map a note in any register to another note in the closest register to the first on.
So, any  C note will be mapped to G, all Db to F#, all D to F, all, Eb to E, all B to Ab, all Bb to A.
 
It´s also possible to generate other mappings as well.
 
I think that replace map or substitute map can do the job, but I´m not sure (I will try), but I find interesting to post it here to explore the idea.
 
All the best,
 
Julio
 
It´s kind of funny to sse in this por versions how every is upside down and how you can generate an entirely new song from exactly the same material.
 
 
 
POP TUNES with negative harmony:
 
 
 
 
 

Dear All, 
 
One interesting thing that could be implemented as a function could be a form of generating Negative Harmony.
In the video below, there are some explanation of what it is and the origin in the Levy book.
It was a trendy topic due to the Jacob Collier interview. And there are a lot of fun videos making versions of pop tunes using negative harmony.
 
The way I understand it, it is simply a kind of mapping notes in relation to an axis, like in the figure below.
 

 
So we need a function that could map a note in any register to another note in the closest register to the first on.
So, any  C note will be mapped to G, all Db to F#, all D to F, all, Eb to E, all B to Ab, all Bb to A.
 
It´s also possible to generate other mappings as well.
 
I think that replace map or substitute map can do the job, but I´m not sure (I will try), but I find interesting to post it here to explore the idea.
 
All the best,
 
Julio
 
It´s kind of funny to sse in this por versions how every is upside down and how you can generate an entirely new song from exactly the same material.
 
 
 
POP TUNES with negative harmony:
 
 
 
 
 

Dear All, 
 
One interesting thing that could be implemented as a function could be a form of generating Negative Harmony.
In the video below, there are some explanation of what it is and the origin in the Levy book.
It was a trendy topic due to the Jacob Collier interview. And there are a lot of fun videos making versions of pop tunes using negative harmony.
 
The way I understand it, it is simply a kind of mapping notes in relation to an axis, like in the figure below.
 

 
So we need a function that could map a note in any register to another note in the closest register to the first on.
So, any  C note will be mapped to G, all Db to F#, all D to F, all, Eb to E, all B to Ab, all Bb to A.
 
It´s also possible to generate other mappings as well.
 
I think that replace map or substitute map can do the job, but I´m not sure (I will try), but I find interesting to post it here to explore the idea.
 
All the best,
 
Julio
 
It´s kind of funny to sse in this por versions how every is upside down and how you can generate an entirely new song from exactly the same material.
 
 
 
POP TUNES with negative harmony:
 
 
 
 
 

– Function name changes:
LENGTH-DIVIDE2 to LENGTH-SUBDIVISION
LENGTH-DIVIDE3 to LENGTH-SYNCOPATE

– Function update:
LENGTH-DIVIDE – changes to arguments.
LENGTH-SUBDIVISION – changes to arguments.
LENGTH-SYNCOPATE – changes to arguments.
POLYGON-RHYTHM – enable fixed sides polygon. 

– Note:
If you used any of the functions:
LENGTH-DIVIDE, LENGTH-DIVIDE2 or LENGTH-DIVIDE3 in your scores,
please check new documents in order to make the necessary correction.

– New:
Enable or disable the DO-VERBOSE macro. 
(defparameter *do-verbose* nil "Enable or disable traces printed by do-verbose.")  
 
length-divide
This function is able to divide number of lengths to a given division value. The :set and :ignore option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions.
 
(setf rhy '(1/4 1/4 1/4 1/4)) (length-divide '(2 2) rhy) => (1/8 1/8 1/4 1/4 1/8 1/8) (length-divide '(2 4) rhy) => (1/4 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/4)  
Example:
(length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34) => (1/4 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/8 1)  
In the example above only 1 length is divided by 2 - that is the 1/16. In the example below 4 lengths are divided by 2.
(length-divide '(4 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34) => (1/8 1/8 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/16 1/16 1/2 1/2) (length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :set 'min :seed 34) => (1/4 -1/8 1/32 1/32 1/16 -1/32 -3/32 1/8 1) (length-divide '(1 4) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :set 1/8 :seed 34) => (1/4 -1/8 1/16 1/16 -1/32 -3/32 1/32 1/32 1/32 1/32 1) (length-divide '((2 3) (1 2)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1)) :ignore 'max :seed 45) => ((1/4 -1/8 1/48 1/48 1/48 1/48 1/48 1/48) (1/64 1/64 -3/32 1/8 1)) (length-divide '((2 4) (1 2)) '((q -e s s) (s -e. e w)) :set 'max :ignore 1 :seed 65) => ((1/16 1/16 1/16 1/16 -1/8 1/16 1/64 1/64 1/64 1/64) (1/16 -3/16 1/16 1/16 1))
OMN:
(setf mat1 '(q c4 d4 e4 f4 g4 a4 b4)) (length-divide '(3 4) mat1 :seed 45) => (s d4 bb3 cs4 b3 cs4 eb4 c4 e4 q s g4 e4 eb4 fs4 q g4 a4 b4)
Symbol 'r will apply repeat function:
(length-divide '(3 4 r) mat1 :seed 45) => (s c4 c4 c4 c4 d4 d4 d4 d4 q e4 s f4 f4 f4 f4 q g4 a4 b4)
Here we use a set of interval values at the end of the division list:
(length-divide '(3 4 (13 0 1 13)) mat1 :seed 45) => (s cs5 c4 cs4 cs5 eb5 d4 eb4 eb5 q e4 s fs5 f4 fs4 fs5 q g4 a4 b4) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - - cs5 p =))) (length-divide '((1 4) (2 4) (2 5)) mat2 :seed 34) => ((e c4 p e4 mp t a4 f4 gs4 fs4 he c5 p) (q c4 f s b3 cs4 bb3 d4 q cs4 mp - d5 p s c5 e5 cs5 eb5) (q cs5 mf cs5 - - 5q eb5 p b4 c5 d5 eb5 c5 eb5 b4 d5 c5))
In the example below we assign three series of division values to variables s1, s2 and s3:
(setf s1 '(3 4 (6 12 18 24)) s2 '(3 4 ((13 1 13 0) (13 0 7 1) r)) s3 '(2 5 ((13 0 13 0 13) ?)) ) (length-divide (list s1 s2 s3) mat2 :seed 34) => ((e c4 p t bb4 mp e5 bb5 e6 cs5 g5 cs6 g6 et fs5 p c6 fs6 c7) (q c4 f s cs5 cs4 cs5 c4 q cs4 mp - s eb6 p d5 a5 eb5 d5 d5 d5 d5) (5q d6 mf cs5 d6 cs5 d6 q cs5 - - cs5 p 5q d5 eb5 c5 b4 d5))  
 
length-subdivision
This function is able to divide a list of lengths into a number of subdivisions derived from a given length segment value. The :type and :position option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions. This function is a more sophisticated version of LENGTH-DIVIDE. It produces fascinating variants on the simplest of note-lengths, as can be seen below.
 
(setf rhy '(1/4 1/4 1/4 1/4)) (length-subdivision '(2 1/8) rhy) => (1/8 1/8 1/8 1/8 1/8 1/8 1/8 1/8)
position 's (start):
(length-subdivision '(2 1/16) rhy :position 's) => (1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8)
position 'e (end):
(length-subdivision '(2 1/16) rhy :position 'e) => (1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16)
type 'r (rest), position 'e (end):
(length-subdivision '(2 1/16) rhy :type 'r :position 'e) => (-1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16)
type 'r (rest), position 's (end):
(length-subdivision '(2 s) rhy :type 'r :position 's) => (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8)
type at random, rest or note :
(length-subdivision '(2 s) rhy :type '? :position 's) => (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 1/8)
position and type at random:
(length-subdivision '(1 e) rhy :type '? :position '? :seed 34) => (1/16 1/8 1/16 1/8 1/8 -1/8 1/8 1/8 1/8) (length-subdivision '((2 5q) (1 3q)) rhy :type '? :position 's :seed 34) => (1/20 1/20 3/20 1/12 -1/6 1/20 1/20 3/20 1/12 -1/6) (length-subdivision '((2 5q) (1 3q) (1 e) (1 s)) rhy :seed 34) => (1/20 1/20 3/20 1/12 1/12 1/12 1/8 1/8 3/16 1/16)  
Example:
(setf rhy2 '((1/4 1/4 1/4 1/4) (1/4 1/4 1/4 1/4))) (length-subdivision '(1 e) rhy2 :seed 34) => ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8) (1/16 1/8 1/16 1/8 1/8 1/8 1/8 1/8 1/8)) (length-subdivision '((1 e) (1 3q)) rhy2 :seed 34) => ((1/8 1/8 1/12 1/12 1/12 1/8 1/8 1/6 1/12) (1/16 1/8 1/16 1/6 1/12 1/8 1/8 1/6 1/12)) (length-subdivision '(((1 e)) ((1 3q))) rhy2 :seed 34) => ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8) (1/12 1/12 1/12 1/6 1/12 1/12 1/6 1/6 1/12)) (length-subdivision '((3 3q) (1 e)) '((q -e e h) (s e. q h)) :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4) (1/16 3/16 1/8 1/8 1/8 1/12 1/12 1/12 1/8)) (length-subdivision '(((3 3q)) ((1 e))) '((q -e e h) (s e. q h)) :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4) (1/16 1/16 1/8 1/16 1/8 1/16 1/8 3/8)) (length-subdivision '(((2 3q)) ((1 e))) '((q -e e h) (s e. q h)) :type '? :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 -1/3) (1/16 -1/16 1/8 1/8 1/8 1/8 3/8))
OMN:
(setf mat1 '(q c4 d4 e4 f4 g4 a4 b4)) (length-subdivision '(1 e) mat1 :seed 45) => (s cs4 e b3 s d4 e cs4 e4 s f4 e fs4 s d4 e fs4 eb4 f4 a4 bb4 gs4 bb4 a4)
The symbol 'r (third value) will apply repeat function:
(length-subdivision '(1 e r) mat1 :seed 45) => (s c4 e s e d4 d4 s e4 e s e f4 f4 g4 g4 a4 a4 b4 b4)
Here we define the intervals (third value):
(length-subdivision '(1 e (13 0 13 0)) mat1 :seed 45) => (s cs5 e c4 s cs5 e eb5 d4 s f5 e e4 s f5 e fs5 f4 gs5 g4 bb5 a4 c6 b4) (length-subdivision '(4 s (13 0 13 0)) mat1 :seed 45) => (s cs5 c4 cs5 c4 eb5 d4 eb5 d4 f5 e4 f5 e4 fs5 f4 fs5 f4 gs5 g4 gs5 g4 bb5 a4 bb5 a4 c6 b4 c6 b4) (length-subdivision '(2 3q (13 0 13 0)) mat1 :type '(r n) :seed 45 :position '(e s s s e s s)) => (-3q cs5 c4 eb5 d4 eb5 f5 e4 - fs5 f4 fs5 - gs5 g4 bb5 a4 bb5 c6 b4 -) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - - cs5 p =))) (length-subdivision '((1 e (13 0 13 0)) (2 e (13 0 13 0)) (2 3q (13 0 13 0))) mat2 :type '? :seed 34) => ((e c4 p e4 mp g4 q cs6 p e c5 q cs6) (e cs5 f c4 cs5 c4 -3q d5 mp cs4 -q e eb6 p d5 eb6 d5) (-s e cs5 mf -s e d6 cs5 -q - 3e d6 p 3q cs5 d6 3e cs5 e d6 cs5)) (length-subdivision '(((1 e (13 0 13 0))) ((2 s (13 0 13 0))) ((2 3q r))) mat2 :type '? :seed 34) => ((e c4 p e4 mp g4 q cs6 p e c5 q cs6) (e cs5 f s c4 cs5 -e s cs5 c4 e d5 mp s cs4 d5 -q -s eb6 p d5 - eb6 d5 eb6 d5) (3q cs5 mf cs5 cs5 cs5 cs5 cs5 -q - 3q cs5 p cs5 - - cs5 cs5))  
In the example below we assign three series of values to variables s1, s2 and s3:
(setf s1 '(2 e (6 12 18 24)) s2 '(1 3q ((13 1 13 0) (13 0 7 1) r)) s3 '(3 5q ((13 0 13 0 13) ?)) ) (length-subdivision (list s1 s2 s3) mat2 :seed 23) => ((e c4 p 3e bb4 mp 3q e5 e cs6 cs5 p cs6 q.) (e fs4 f c5 3q cs5 cs4 cs5 5h mp 5q c4 g4 c4 -q e c4 p c4 3q d5 3h cs4) (e g5 mf cs6 3q d6 3h d5 -q - 5q d6 p cs5 cs5 5h e d6 cs5))  
 
 
length-syncopate
The function LENGTH-SYNCOPATE is a valuable way of bringing more rhythmic interest into a length list. The usual idea of syncopating rhythm is to 'choke' certain attacks so that the attack is delayed or pre-empted.
(setf rhy '(1/4 1/4 1/4 1/4)) (length-syncopate '(1 4) rhy) => (1/4 3/16 1/16 1/4 1/4) (length-syncopate '(2 4) rhy) => (1/16 3/16 1/4 3/16 1/16 1/4)  
Example:
(length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34) => (1/4 -1/8 1/16 1/64 3/64 -1/8 1/8 1)
In the example above only 1 length is divided by 4 (1, 3) - that is the 1/16. In the example below 2 values are divided by 3: (1, 2) and (2, 1).
(length-syncopate '(2 3) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34) => (1/4 -1/8 1/48 1/24 1/16 -1/8 1/8 2/3 1/3) (length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :set 1/8 :seed 34) => (1/4 -1/8 1/16 1/16 -1/8 1/32 3/32 1)
Example with :set for each list:
(length-syncopate '((2 3) (1 4)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1)) :set '(min 1/8) :seed 45) => ((1/4 -1/8 1/24 1/48 1/24 1/48) (1/32 -3/32 3/32 1/32 1)) (length-syncopate '((2 3) (1 5)) '((q -e s s) (s -e. q h)) :set 'max :ignore 'h :seed 65 :omn t) => ((3h 3q -e s 3s 3e) (s -e. 5q 5w h))
OMN:
(setf mat '(q c4 d4 e4 f4 g4 a4 b4)) (length-syncopate '(3 4) mat :seed 12) => (s b3 e. cs4 q d4 e. fs4 s d4 q f4 g4 a4 e. bb4 s c5)  
Here we use a set of interval values:
(length-syncopate '(3 4 ((13 0) (0 14) (1 13))) mat :seed 23) => (s cs5 e. c4 d4 s e5 q e4 f4 s gs4 e. gs5 q a4 b4) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - q cs5 stacc p = =)) (length-syncopate '((1 3 (-3 6)) (2 4 (6 0)) (2 5 (11 13))) mat2 :seed 34) => ((e c4 p e4 mp 3e 3q cs5 he c5 p) (q c4 f s fs4 e. c4 q cs4 mp - e. gs5 p s d5 q) (q cs5 mf cs5 - 5w c6 stacc 5q d6 stacc q cs5 p 5q c6 5w d6 q cs5))
 
 
polygon-rhythm
In the next three examples below we use a list of fixed polygon sides (non-symmetrical):
(circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 1) :points 16) To rotate the polygon we change the starting point value:
(circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 2) :points 16) (circle-rhythm-plot (polygon-rhythm '(0 2 5 7 10 12 13 15 16 18 19 21 23) 24 0) :points 24 :value 1/24)  
Best wishes,
JP

I agree, stemlets are better representation of the time signature.
I will ask James if we could add this to our system.
 

That is the main and most important point on the todo list i'm waiting for !
 
SB.

Looking forward to this. Now I´m trying to get some Ravel Piano scores onto OMN to make some tweaks.

May be try substitute map ? or pattern-map ?
 
S.

I Love pieces with Scores !! Thank you and congrats for the music, Stephane !
Sounds great !
Best,
Julio

too much code and too complicated to post - I do not have the time to write a manual.
 
it's a "machine" that creates multiple "brownian bridges" combined with "pitch-contour" and "add-rnd-dust".  it's an all-in-ONE tool/machine/bot...
 
I'm interested in repetition/difference in other contexts than traditional ones; but "brownian bridges" then resemble ornaments. when the sequences are short - brownian bridges are "rnd-processes" between 2 fixed points - then you will keep ornamental sequences between this 2 points/pitches...
 
(I did not work with a score, just coding and listening - it's only sketching/testing, not composing. and all the examples are "rnd-generated"/not-composed by the machine, you could produce more and more...)
 
some links:
 
Brownian bridge - Wikipedia
EN.WIKIPEDIA.ORG  
 
-> in OPMO
 

another example/experiment  - you hear 4 times the same "brownian-phrase"  but mapped on different tonalities...
 
   
 
untitled.aiff
 
a) diatonic/major
b) blues-heptatonic
c) chromatic
d) messiaen-modus
 
greetings
andré
 
 
 

The forthcoming POLYGON-RHYTHM function will allow you to think and compose in a clear symmetrical structures. The great amount of keywords (OPMO stile) makes this algorithm very powerful.
 
This is a short example using POLYGON-RHYTHM exclusively.
Instruments: VSL Tenor Sax and Jazz Drumset.