Jump to content

Stephane Boussuge

Moderators
  • Content count

    448
  • Joined

  • Last visited

  • Days Won

    118

Reputation Activity

  1. Like
    Stephane Boussuge reacted to AM in find-intervals*   
    function edited - some small changes...
     
    extended:
    :intervals '(1 2 3) -> all these interval-combinations are shown
    or
    :intervals 2 (like before)
     
    new:
    :reduced-interval T or NIL (default NIL) -> when T only basic-intervals search (not 1 = 1 & 13 & 25, only in ONE octave)
     
     
    small example
     
    ;;; SIEVE with SYMM_STRUCTURE (setf sieve1 (pitch-transpose -6 (integer-to-pitch (gen-sieve '((0 39) (0 40)) '((5) (7)))))) (pitch-to-interval sieve1) ;;; search/permutate interval-combinations (setf pitchlist (find-intervals* sieve1 :intervals '(1 2 3) :reduced-interval t :chord nil)) (setf pitchlist (rnd-unique (length pitchlist) pitchlist)) ;;; change direction of the interval-pairs (setf pitchlist (loop for i in pitchlist when (prob? 0.4) collect (reverse i) else collect i)) ;;; remove immediate repetitions (setf pitchlist (filter-repeat 1 (flatten pitchlist))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-score sieve-scan (:title "sieve-scan" :key-signature 'atonal :time-signature '(4 4) :tempo 90) (instrument :omn (make-omn :pitch pitchlist :length '(t) :velocity '(p) :span :pitch) :channel 1 :sound 'gm :program 'acoustic-grand-piano)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  
  2. Like
    Stephane Boussuge reacted to AM in filter-repeat for pairs?   
    is there a possibility to filter some "combinations"?
    when i have a seq like that:
     
    (a4 gs4 a4 gs4 a4 fs4 gs4 g5 bb5 g5 gs4) i want to filter all immediate repetitions with pattern-length = 2
    the result would be:
     
    (a4 gs4 a4 fs4 gs4 g5 bb5 g5 gs4) because a4-gs4 is the pair that repeats
     
     
  3. Like
    Stephane Boussuge reacted to AM in find-intervals*   
    i coded it to analyze a pitchfield
     
    ;;; a function witch filters/shows you all pitch-combinations by INTERVAL-SIZE ;;; from 1 to 11 ("octave-independent") ;;; for example you are interested to see all FIFTH-combinations in a SIEVE ;;; or to LIST all resulting/ordered intervals (defun equal/or (n alist) (car (loop for i in alist when (equal i n) collect 't))) ;;; FUNCTION (defun find-intervals* (pitch-seq &key (intervals 'all) (chord nil) (reduced-interval nil)) (let ((combs (combination 2 pitch-seq)) (ints) (int) (all-comb-pitches-intervals)) (progn (setf ints (loop for i in combs do (setf int (car (pitch-to-interval i))) when (>= int 0) collect (cond ((and (>= int 12) (<= int 24) (equal reduced-interval nil)) (- int 12)) ((and (>= int 24) (equal reduced-interval nil)) (- int 24)) (t int)))) (setf all-comb-pitches-intervals (loop for i from 1 upto 11 append (loop for j in (loop for x in combs for y in ints collect (cons y x)) when (= (car j) i) collect j))) (if (equal intervals 'all+int) all-comb-pitches-intervals (if (equal intervals 'all) (loop for i in all-comb-pitches-intervals when (equal chord t) collect (chordize (rest i)) else collect (rest i)) (loop for i in all-comb-pitches-intervals when (if (listp intervals) (equal/or (car i) intervals) (= (car i) intervals)); when (= (car i) intervals) collect (if (equal chord t) (chordize (rest i)) (rest i)))))))) ;;; EXAMPLES (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals '(1 5 7) ;; as list :reduced-interval t ;; -> only on/in the same octave :chord nil) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals '(1 3 7) :chord t) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 'all :chord t) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 2 :chord t) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 3) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 5) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 7) (find-intervals* (gen-sieve '(c3 g7) '(3 1 5) :type :pitch) :intervals 'all)  
    other example -> cmd3
     
    (setf seq (gen-sieve '(f3 fs6) '(4 2 1 1 1 2 4 7) :type :pitch)) ;(setf seq (gen-sieve '(f3 fs6) '(7 4 2 1 1 1 2 4) :type :pitch)) ;(setf seq '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6)) (append (find-intervals* seq :intervals 1 :chord t) (find-intervals* seq :intervals 2 :chord t) (find-intervals* seq :intervals 5 :chord t) (find-intervals* seq :intervals 6 :chord t) (find-intervals* seq :intervals 8 :chord t)) (find-intervals* seq :intervals 'all :chord t) ;;; with interval-sizes in output-format (find-intervals* seq :intervals 'all+int) => ((1 a3 bb5) (1 b3 c4) (1 b3 c6) (1 c4 cs4) (1 cs4 d4) (1 cs4 d6) (1 d4 eb5) (1 gs4 a5) (1 a5 bb5) (1 bb5 b5) (1 b5 c6) (2 f3 g5) (2 a3 b3) (2 a3 b5) (2 b3 cs4) (2 c4 d4) (2 c4 d6) (2 cs4 eb5) (2 d4 e4) (2 e4 fs6) (2 gs4 bb5) (2 g5 a5) (2 a5 b5) (2 bb5 c6) (2 c6 d6) (3 f3 gs4) (3 a3 c4) (3 a3 c6) (3 b3 d4) (3 b3 d6) (3 c4 eb5) (3 cs4 e4) (3 e4 g5) (3 gs4 b5) (3 eb5 fs6) (3 g5 bb5) (3 a5 c6) (3 b5 d6) (4 f3 a3) (4 f3 a5) (4 a3 cs4) (4 b3 eb5) (4 c4 e4) (4 d4 fs6) (4 e4 gs4) (4 gs4 c6) (4 eb5 g5) (4 g5 b5) (4 bb5 d6) (4 d6 fs6) (5 f3 bb5) (5 a3 d4) (5 a3 d6) (5 b3 e4) (5 cs4 fs6) (5 d4 g5) (5 e4 a5) (5 g5 c6) (5 a5 d6) (6 f3 b3) (6 f3 b5) (6 a3 eb5) (6 c4 fs6) (6 cs4 g5) (6 d4 gs4) (6 e4 bb5) (6 gs4 d6) (6 eb5 a5) (6 c6 fs6) (7 f3 c4) (7 f3 c6) (7 a3 e4) (7 b3 fs6) (7 c4 g5) (7 cs4 gs4) (7 d4 a5) (7 e4 b5) (7 gs4 eb5) (7 eb5 bb5) (7 g5 d6) (7 b5 fs6) (8 f3 cs4) (8 b3 g5) (8 c4 gs4) (8 cs4 a5) (8 d4 bb5) (8 e4 c6) (8 eb5 b5) (8 bb5 fs6) (9 f3 d4) (9 f3 d6) (9 a3 fs6) (9 b3 gs4) (9 c4 a5) (9 cs4 bb5) (9 d4 b5) (9 eb5 c6) (9 a5 fs6) (10 f3 eb5) (10 a3 g5) (10 b3 a5) (10 c4 bb5) (10 cs4 b5) (10 d4 c6) (10 e4 d6) (10 gs4 fs6) (11 f3 e4) (11 a3 gs4) (11 b3 bb5) (11 c4 b5) (11 cs4 c6) (11 e4 eb5) (11 gs4 g5) (11 eb5 d6) (11 g5 fs6))  
     
    perhaps OPMO could extend it to an omn-format-FILTER - so that all other pitches (not matched pitches/sets) would be repaced by rests? would be interesting to work like that with pitchfields/sieves.
    so you could choose ...for example: "want to have all FIFTHS including a pitch like C or Eb or Gs (octave independent)...? 
  4. Like
    Stephane Boussuge reacted to AM in rnd-walk in a pitchfield with specific interval-control   
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; rnd-walk in a pitchfield - with interval-control ;;; ;;; this is a little function which does an rnd-walk in a special way ;;; the function is checking all possible interval-pairs first inside the pitchfield ;;; so that is on one hand all the time "inside" the pitchfield/sieve, but also only ;;; uses the :POSSIBLE-INTERVALS, so you could control the "interval-color" of the walk ;;; in an non-chromatic-pitchfield/sieve ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun enlarge-intervals (possible-intervals &key (octaves 2)) (let ((possible-intervals (append possible-intervals (loop repeat octaves for i = 12 then (incf i 12) append (x+b possible-intervals i))))) (append possible-intervals (neg! possible-intervals)))) ;(enlarge-intervals '(2 3 4)) ;;;;;;;;;;; (defun special-rnd-walk (n &key pitchfield startpitch possible-intervals (interval-octaves 2)) (let ((int-list (loop for i in pitchfield collect (list (pitch-to-midi i) (loop for x in pitchfield with int do (setf int (car (pitch-to-interval (list i x)))) when (/= int 0) collect int)))) (possible-intervals (enlarge-intervals possible-intervals :octaves interval-octaves))) (append (list startpitch) (midi-to-pitch (loop repeat n with int with pitch = (pitch-to-midi startpitch) do (setf int (rnd-pick (filter-preserve possible-intervals (cadr (assoc pitch int-list))))) when (null int) do (setf int (rnd-pick (cadr (assoc pitch int-list)))) collect (setf pitch (pitch-to-midi (cadr (interval-to-pitch (list int) :start (midi-to-pitch pitch)))))))))) ;;;;;;;;;;; EXAMPLES ;;; rnd-walk in a "chromatic-field" - as the most easiest example/way ;;; => so all possible-intervals could be used -> THE ORDINARY WAY... (special-rnd-walk 20 :startpitch 'cs4 :pitchfield '(gs3 a3 bb3 b3 c4 cs4 d4 ds4 e4 f4 fs4 g4 gs4 a4) :possible-intervals '(1 2 3)) ;;; BUT have a look to the next examples!!! ;;; rnd-walk in a PITCHFIELD -> the function is checking all possible interval-pairs inside the pitchfield ;;; so that the rnd-walk INSIDE the PITCHFIELD could be done with specific intervals (if they are inside the field) ;;; COMPARE THE RESULT with the PITCHFIELD!!! ;;; (setf pitchfield '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6)) ;;; "interval-color" of the walk is made with :possible-intervals (special-rnd-walk 5 :startpitch 'ds4 :pitchfield '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6) :possible-intervals '(1 2 3)) ; + octaves of this intervals (special-rnd-walk 10 :startpitch 'ds4 :pitchfield '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6) :possible-intervals '(1 3 4 5) :interval-octaves 0) ;;; reduced interval-span (special-rnd-walk 10 :startpitch 'ds4 :pitchfield '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6) :possible-intervals '(5 6 7)) ; + octaves of this intervals  
    more examples -> SOUND
     
    ;;; rnd-versions so you will here the different interval-colors inside the pitchfield (setf seq (gen-sieve '(f3 fs6) '(4 2 1 1 1 2 4 7) :type :pitch)) ;(setf seq (gen-sieve '(f3 fs6) '(7 4 2 1 1 1 2 4) :type :pitch)) ;(setf seq '(gs3 cs4 ds4 g4 a4 b4 d5 e5 fs5 bb5 c6 f6)) (setf pitchlist (special-rnd-walk (rnd-pick '(3 5 7 11)) :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals (rnd-pick '((1 2) (3 4) (5 6 7))) :interval-octaves 3)) (def-score intervals (:title "walk" :key-signature 'atonal :time-signature '(4 4) :tempo 90) (instrument :omn (make-omn :pitch pitchlist :length '(t) :span :pitch) :channel 1 :sound 'gm :program 'acoustic-grand-piano))  
     
    ;;; rnd-walk in SIEVE only with intervals '(5 6 8) (setf seq (gen-sieve '((c4 g7) (c2 g7)) '((2 1 10) (3 5)) :type :pitch)) (setf pitchlist (special-rnd-walk 30 :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals '(5 6 8))) (def-score intervals (:title "intervals" :key-signature 'atonal :time-signature '(4 4) :tempo 90) (instrument :omn (make-omn :pitch pitchlist :length '(t) :span :pitch) :channel 1 :sound 'gm :program 'acoustic-grand-piano))  
     
    (setf seq (gen-sieve '((c2 g7) (c2 g7)) '((2 1 10) (3 5)) :type :pitch)) ;;; EXAMPLE with changes -> all inside the same SIEVE (setf pitchlist (append (special-rnd-walk 50 :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals '(1)) ; minor second (special-rnd-walk 50 :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals '(2)) ; major second (special-rnd-walk 50 :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals '(3 4)) ;thirds (special-rnd-walk 50 :startpitch (rnd-pick seq) :pitchfield seq :possible-intervals '(5 7)))) ; fourth-fifth (def-score intervals (:title "intervals" :key-signature 'atonal :time-signature '(4 4) :tempo 90) (instrument :omn (make-omn :pitch pitchlist :length '(t) :span :pitch) :channel 1 :sound 'gm :program 'acoustic-grand-piano))  
  5. Thanks
    Stephane Boussuge got a reaction from opmo in Piano Trio "Slonimsky" Movement 1   
    Hi,
     
    here's for study purpose the Opusmodus score of the first movement of my piano trio.
     
    All the best to the wonderful Opusmodus users community !
     
    SB.

     
     
    PianoTrio-SlonimskyV2.opmo
  6. Thanks
    Stephane Boussuge got a reaction from opmo in Piano Trio "Slonimsky" Movement 1   
    Hi,
     
    here's for study purpose the Opusmodus score of the first movement of my piano trio.
     
    All the best to the wonderful Opusmodus users community !
     
    SB.

     
     
    PianoTrio-SlonimskyV2.opmo
  7. Like
    Stephane Boussuge reacted to opmo in Opusmodus 1.2.23374   
    View File Opusmodus 1.2.23374
    New: GEN-CHORD-SERIES
    I think many of you will love the new function 
     
    The function GEN-CHORD-SERIES builds chords using a scale in three types of harmonic steps: fifth (default), fourth and third.
    The scale needs to be in a range between c4 and b4 (0 11) and the root must be an element of the scale.
     
    Method 1
     
    Fifth:
    (c4 g4 d5 a5 e6 b6 f7) (d4 a4 e5 b5 f6 c7 g7) (e4 b4 f5 c6 g6 d7 a7) (f4 c5 g5 d6 a6 e7 b7) (g4 d5 a5 e6 b6 f7 c8) (a4 e5 b5 f6 c7 g7 d8) (b4 f5 c6 g6 d7 a7 e8)  
    Fourth:
    (c4 f4 b4 e5 a5 d6 g6) (d4 g4 c5 f5 b5 e6 a6) (e4 a4 d5 g5 c6 f6 b6) (f4 b4 e5 a5 d6 g6 c7) (g4 c5 f5 b5 e6 a6 d7) (a4 d5 g5 c6 f6 b6 e7) (b4 e5 a5 d6 g6 c7 f7)  
    Third:
    (c4 e4 g4 b4 d5 f5 a5) (d5 f5 a5 c6 e6 g6 b6) (e4 g4 b4 d5 f5 a5 c6) (f4 a4 c5 e5 g5 b5 d6) (g4 b4 d5 f5 a5 c6 e6) (a4 c5 e5 g5 b5 d6 f6) (b4 d5 f5 a5 c6 e6 g6)  
    Method 2 (intervals)
     
    Fifth: (7 7 7 7 7 7 -5 -5 -5 -5 -5)
    Fourth: (5 5 5 5 5 5 5 -7 -7 -7 -7)
    Third: (3 3 3 4 3 3 3 4 3 3 3)
     
    For example if the root is fs4 and the type is 5 (fifth) then the map we use is: (f4 c5 g5 d6 a6 e7 b7). In method 1 it doesn’t matter whether the notes are natural, sharp, or flat.
     
    Let’s examine the three types:
     
    (setf hexachord '(d4 eb4 fs4 g4 a4 bb4))
     
    Fifth:
     
    (gen-chord-series hexachord 'fs4) => (fs4g4d5a5eb6bb5)
     
    Third:
    (gen-chord-series hexachord 'fs4 :type 3) => (fs4a4eb5g5bb5d6)
     
    Fourth:
    (gen-chord-series hexachord 'fs4 :type 4) => (fs4bb4eb5a5d6g5)
     
     
    Examples:
     
    Building chords using a hexachord scale:
     
    (gen-chord-series hexachord 'fs4 :type 3 :segment t) => (fs4eb5bb5 a4g5d6)
     
     
    With the segment option set to T we divide the chord into two segments by selecting every other second note:
     
     
    (gen-chord-series hexachord '(fs4 fs4)                   :type 3                   :width '(30 24)                   :segment t) => (fs4eb5bb5 a4g5d6 fs4eb5bb5 a4g5d5)
     
     
    Below the type is selected at random:
     
     
    (gen-chord-series hexachord '(fs4 a4 d4)                   :type '? :segment '? :seed 56) => (fs4bb4eb5a5d6g5 a4d5g5fs6bb5eb6 d4a4g5 fs4eb5bb5)
     
     
    In the next few examples we use a list of width values (ambitus) - each value assigned to each chord:
     
    (gen-chord-series hexachord hexachord                   :type 3 :width '(30 24 36 12)) => (d4fs4a4eb5g5bb5 eb4g4bb4d5fs5a5 fs4a4eb5g5bb5d6     g4bb4d4fs4a4eb4 a4eb5g5bb5d6fs6 bb4d5fs5a5eb5g5)
     
     
    Please note, if the root list length is bigger than the width list length then the width list values will be looped:
     
    (gen-chord-series hexachord hexachord                   :type 4 :width '(30 24 36 12)) => (d4g4fs5bb5eb6a5 eb4a4d5g5fs5bb5 fs4bb4eb5a5d6g6     g4fs4bb4eb4a4d4 a4d5g5fs6bb5eb6 bb4eb5a5d5g5fs5)
     
    (gen-chord-series hexachord hexachord                   :width '(30 24 36 12)) => (d4a4eb5bb5fs6g5 eb4bb4fs5g5d5a5 fs4g4d5a5eb6bb6    g4d4a4eb4bb4fs4 a4eb5bb5fs6g5d6 bb4fs5g5d5a5eb5)
     
     
    (gen-chord-series hexachord hexachord                   :type '?                   :width '(30 24 36 12)                   :segment t                   :seed 23) => (d4a4g5 fs4eb5bb5 eb4fs5d5 bb4g5a5 fs4eb5d6 bb4a5g6     g4d4a4 bb4fs4eb4 a4g5d6 eb5bb5fs6 bb4a5g5 eb5d5fs5)
     
    Building chords using C Major scale:
     
    (setf c-major '(c4 d4 e4 f4 g4 a4 b4))
     
     
    (gen-chord-series c-major c-major :width 36) => (c4g4d5a5e6b6f6 d4a4e5b5f6c7g6 e4b4f5c6g6d6a6     f4c5g5d6a6e6b6 g4d5a5e6b6f6c7 a4e5b5f6c7g6d6 b4f5c6g6d6a6e6)
     
    (gen-chord-series c-major c-major :type 3 :width 36) => (c4e4g4b4d5f5a5 d4f4a4c5e5g5b5 e4g4b4d5f5a5c6     f4a4c5e5g5b5d6 g4b4d5f5a5c6e6 a4c5e5g5b5d6f6 b4d5f5a5c6e6g6)
     
     
    (gen-chord-series c-major c-major :type 4 :width 36) => (c4f4b4e5a5d6g6 d4g4c5f5b5e6a6 e4a4d5g5c6f6b6     f4b4e5a5d6g6c7 g4c5f5b5e6a6d6 a4d5g5c6f6b6e6 b4e5a5d6g6c7f6)
     
    Here we use transposition values for each chord or segments:
     
     
    (gen-chord-series c-major '(b4 f4 d4 c4 e4 g4 a4)                   :type '?                   :width 36                   :segment t                   :seed 45                   :transpose '(0 6 -1 13)) => (b4a5g6f6 e5d6c7 b4cs6eb6f6 fs5gs6bb6 cs4gs4eb5bb5 e4b4fs5     cs5gs5eb6bb6 f5c6fs6 e4f5g6a6 b4c6d6 cs5eb6f6fs6 gs5bb6b6     gs4eb5bb5e6 b4fs5cs6)
     
     
    (gen-chord-series c-major (rnd-order c-major :seed 543)                   :type '?                   :width '(12 12 18 24 30 36 36)                   :segment t                   :seed 5462) => (a4e4b4f4 c5g4d4 d4c5b4a4 g4f4e4 e4b4f5c5 g4d5a4 b4c6d5e5     f5g5a5 c4b4a5g5 f4e5d6 g4a5b6c7 d5e6f6 f4e5d6c7 b4a5g6)
     
    (gen-chord-series c-major '(f4 b4 d4) :width 12 :type 3 :chord nil) => ((f4 a4 c5 e4 g4 b4 d4) (b4 d4 f4 a4 c5 e4 g4) (d4 f4 a4 c5 e4 g4 b4))
     
     
    (gen-chord-series c-major '(f4 b4 d4) :width 12 :type 4 :chord nil) => ((f4 b4 e4 a4 d4 g4 c5) (b4 e4 a4 d4 g4 c5 f4) (d4 g4 c5 f4 b4 e4 a4))
     
     
    (gen-chord-series c-major '(f4 b4 d4) :width '(36 24 28) :chord nil) => ((f4 c5 g5 d6 a6 e6 b6) (b4 f5 c6 g5 d5 a5 e5) (d4 a4 e5 b5 f5 c6 g5))
     
    Some more examples with method 1 and method 2:
     
    (setf a-scale '(c4 eb4 e4 g4 gs4 b4))
     
    First with method 1 (default):
     
    (gen-chord-series a-scale a-scale                   :type '(4 4 5 5 4 3) :width 36 :segment t) => (c4eb5g5 b4e5gs5 eb4g4c5 e4gs4b5 e4g4c5 eb4gs4b5     g4c5eb6 gs4b5e6 gs4c5eb6 g4b5e6 b4e5gs5 eb5g5c6)
    Now with method 2:
     
    (gen-chord-series a-scale a-scale                   :type '(4 4 5 5 4 3)                   :method 2                   :width 36                   :segment t) => (c4eb5e6 g4gs5b6 eb4b4e5 gs4c5g5 e4g5c6 b4gs5eb6     g4e5eb6 c5b5gs6 gs4b5c7 eb5e6g6 b4c6e6 gs5eb6g6)  

     
    (setf chrom '(c4 cs4 d4 ds4 e4 f4 fs4 g4 gs4 a4 bb4 b4)) (gen-chord-series chrom chrom :method 1 :width 36)
     
     
    (gen-chord-series chrom chrom :method 2 :width 36)
     
    (gen-chord-series chrom chrom :method 1 :width 36 :segment t)
     
    (gen-chord-series chrom chrom :method 2 :width 36 :segment t)
     
    As we can see there are endless possibilities. Just copy a few of the expressions to your Composer (Editor) and start exploring.
     
    Best wishes,
    Janusz
    Submitter opmo Submitted 05/13/2018 Category Opusmodus Latest Release  
  8. Thanks
    Stephane Boussuge got a reaction from opmo in Piano Trio "Slonimsky" Movement 1   
    Hi,
     
    here's for study purpose the Opusmodus score of the first movement of my piano trio.
     
    All the best to the wonderful Opusmodus users community !
     
    SB.

     
     
    PianoTrio-SlonimskyV2.opmo
  9. Like
    Stephane Boussuge got a reaction from hujairi in Opusmodus 1.2.23291   
    Thank you very much, the spectra option in tonality map is exactly what i'm looking for. Wonderful tool !!!
     
    Thanks a lot
     
    S.
     
  10. Like
    Stephane Boussuge reacted to opmo in tonality-map: controlling in which octave tones occur   
    I will make some changes to the TONALITY-MAP which will allow us to use scales lager then an octave.
  11. Thanks
    Stephane Boussuge got a reaction from JulioHerrlein in mapping integer?   
    With vector-map function, you can map anything:
     
    (vector-map (expand-tonality '(c4 messiaen-mode5)) '(0 1 2 3 4 2 1 5 3 1)) SB.
  12. Thanks
    Stephane Boussuge got a reaction from JulioHerrlein in mapping integer?   
    With vector-map function, you can map anything:
     
    (vector-map (expand-tonality '(c4 messiaen-mode5)) '(0 1 2 3 4 2 1 5 3 1)) SB.
  13. Like
    Stephane Boussuge reacted to AM in sorting algorithms   
    MIN/MAX-SORT
     
    a new function: min/max -> 1. max-pitch, 2. min-pitch, 3.rest of the seq .... starting next gen.... have a look at the list-plot.
     
     
    minmax-sort.opmo
    functions.opmo
     
    ;;; ordinary examples (make-omn :pitch (setf n (sorting (vector-to-pitch'(g4 eb5) (gen-white-noise 40)) :algorithm 'min/max)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (vector-to-pitch'(g4 eb5) (gen-white-noise 40)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (vector-to-pitch'(c4 bb5) (gen-white-noise 40)) :algorithm 'min/max)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (vector-to-pitch'(c4 bb5) (gen-white-noise 40)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (rnd-order '(g4 gs4 a4 bb4 b4 c5 cs5 d5 eb5 e5 f5 fs5)) :algorithm 'min/max)) :length (gen-repeat (length n) (append (gen-repeat 12 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (rnd-order '(g4 gs4 a4 bb4 b4 c5 cs5 d5 eb5 e5 f5 fs5)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 12 '(t)) (list '-e)))) ;;; combined with filter-tie -> ties all pitch repetitions!! (filter-tie (make-omn :pitch (setf n (sorting (vector-to-pitch'(c4 bb5) (gen-white-noise 40)) :algorithm 'min/max)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e))))) (filter-tie (make-omn :pitch (setf n (sorting (vector-to-pitch'(c4 bb5) (gen-white-noise 40)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e))))) ;;; THREE SCORES with min/max (def-score example-score (:key-signature 'atonal :time-signature '(4 4) :tempo 120 :layout (piano-solo-layout 'rhand 'lhand)) (rhand :omn (make-omn :pitch (setf n (sorting (rnd-order '(g6 gs6 a6 bb6 b6 c7 cs7 d7 eb7 e7 f7 fs7)) :algorithm 'min/max :n '<)) :length (gen-repeat (length n) (append (gen-repeat 12 '(t)) (list '-e)))) :channel 1 :sound 'gm :program 0) (lhand :omn (make-omn :pitch (setf n (sorting (rnd-order '(g1 gs1 a1 bb1 b1 c2 cs2 d2 eb2 e2 f2 fs2)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 12 '(t)) (list '-e)))) :channel 2)) (def-score example-score (:key-signature 'atonal :time-signature '(4 4) :tempo 120 :layout (piano-solo-layout 'rhand 'lhand)) (rhand :omn (filter-tie (make-omn :pitch (setf n (sorting (rnd-repeat 100 '(g6 gs6 a6 bb6 b6 c7 cs7 d7 eb7 e7 f7 fs7)) :algorithm 'min/max :n '<)) :length (gen-repeat (length n) (append (gen-repeat 100 '(t)) (list '-e))))) :channel 1 :sound 'gm :program 0) (lhand :omn (filter-tie (make-omn :pitch (setf n (sorting (rnd-repeat 100 '(g1 gs1 a1 bb1 b1 c2 cs2 d2 eb2 e2 f2 fs2)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 100 '(t)) (list '-e))))) :channel 2)) (def-score example-score (:key-signature 'atonal :time-signature '(4 4) :tempo 120 :layout (piano-solo-layout 'rhand 'lhand)) (rhand :omn (filter-tie (make-omn :pitch (setf n (sorting (rnd-repeat 100 '(g6 gs6 a6 bb6 b6 c7 cs7)) :algorithm 'min/max :n '<)) :length (gen-repeat (length n) (append (gen-repeat 100 '(t)) (list '-e))))) :channel 1 :sound 'gm :program 0) (lhand :omn (filter-tie (make-omn :pitch (setf n (sorting (rnd-repeat 100 '(c2 cs2 d2 eb2 e2 f2 fs2)) :algorithm 'min/max :n '>)) :length (gen-repeat (length n) (append (gen-repeat 100 '(t)) (list '-e))))) :channel 2))  
  14. Like
    Stephane Boussuge reacted to AM in sorting algorithms   
    i solved the problems. here is a workspace/files to experiment with SORTING ALGORITHMS 
    thanx to torsten and philippe!
     
    greetings
    andré
     
    functions.opmo
    abstract examples.opmo
    sound examples.opmo
    sorting algorithms.opmows
  15. Like
    Stephane Boussuge reacted to torstenanders in tonality-map: controlling in which octave tones occur   
    I like how the function tonality-map allows specifying some input harmony (called tonality) and raw music, where the "raw" music is then quasi-quantised into the given harmony. 
     
    However, I would like to control in which octaves specific tones are allowed to occur. tonality-map allows specifying an underlying harmony that ranges over multiple octaves, but it seems that internally only octave-less pitch classes are used, and any tone in the harmony can occur in any octave in the result. By contrast, in the spectral tradition of music thinking, you change the underlying spectrum if you scramble in which octaves pitches occur. For example, if you have a spectrum or chord that approximates the overtone series, then that spectrum sounds rather consonant, regardless how far up in the overtone series you allow tones to be included. However, if you then randomly octave-transpose the pitches of this spectrum/chord, then it can become much more dissonant, without changing any pitch classes.
     
    To be more specific here is a dummy example with simple traditional chords where tones are distributed across octaves in a certain way. 
     
    (tonality-map   ;; underlying harmony or spectra  '((c4g4e5b5d6) (g3d4b5f5a4))  ;; input music  '((h c4f5 cs4fs5) (d4g5 cs4gs5) (eb4as5 f4a5) (e4gs5 c4gs5))  ;; harmonic rhythm  :time '(w w w_w)) => ((h c4e5 c4g5) (h a3d5 g3d5) (h e4b5 e4b5) (h e4g5 c4g5))  
    As you can see, the tone G in the first tonality occurs only in octave 4, but in the result, in the second chord of the first bar (still following the first tonality) we have a g5 instead. Now, you might feel that the g5 does not musically do any harm, but in the second tonality, there is an A only in octave 6, while in the function output in the related third chord the A occurs three octaves lower in octave 3, where it greatly increases the dissonance degree of this chord/scale. 
     
    So, is there a way to restrict the octaves of tones in the result to be restricted to the octaves of these tones in the respective tonalities? Alternatively, is there another function that complements tonality-map, where I can force some "raw" music to follow some underlying harmony with a given harmonic rhythm, and where the octaves of the resulting pitches can be restricted?
     
    Thank you! 
     
    Best,
    Torsten
  16. Like
    Stephane Boussuge got a reaction from JulioHerrlein in Classical accomp. Example   
    Here's the rendering of the score "Classical Accomp Example" i've made for the last version of Opusmodus.
     

     
  17. Like
    Stephane Boussuge got a reaction from JulioHerrlein in Classical accomp. Example   
    Here's the rendering of the score "Classical Accomp Example" i've made for the last version of Opusmodus.
     

     
  18. Like
    Stephane Boussuge got a reaction from JulioHerrlein in Classical accomp. Example   
    Here's the rendering of the score "Classical Accomp Example" i've made for the last version of Opusmodus.
     

     
  19. Like
    Stephane Boussuge reacted to opmo in Opusmodus 1.2.23227   
    View File Opusmodus 1.2.23227
    I have devoted few days to extend our functions verbose. All function will print now more information with the parameters of the variables and keywords used. I think this will help with you with your work and will speed up the learning of the various functions options.
     
    Examples:
    (add-sine-waves  4 24 1 0.6  :modulation  (gen-sine 24 1 (sort-asc '(0.5 0.4 0.3 0.6 0.2 0.9))            :modulation (gen-sine 24 1 0.9 :phase 180))) ;; Listener gen-sine, res: 24 freq: 1 amplitude: 0.9 phase: 180 modulation: nil float-format: single-float gen-sine, res: 24 freq: 1 amplitude: (0.2 0.3 0.4 0.5 0.6 0.9) phase: nil modulation: t float-format: single-float add-sine-waves, niter: 4 res: 24 freq: 1 amplitude: 0.6 phase: nil modulation: t float-format: single-float => (0.0 0.3163039 0.65313345 0.99170077 1.2972221 1.5567598 1.4981123 1.5781916 1.5118134 1.2951372     1.0774696 0.9499778 1.3709285 1.4553853 1.4857507 1.1464057 1.0752162 1.4443256 0.89989895     0.93597645 1.102749 1.5229248 1.1551269 0.73289376) (pitch-figurate 2 '(c4 as3 b3 fs4 e4 f4) :seed 65) ;; Listener ? pitch-figurate, count: 2 interval: ? variant: nil parallel-invert: nil ambitus: piano seed: 65 => (c4 bb3 b3 fs4 e4 fs4 f4 fs4) (gen-binary-rnd 3 8 1 3 :seed 89) ;; Listener ? gen-binary-rnd, size: 3 level: 8 low: 1 high 3 start: nil rotate: 0 seed: 89 => ((0 1 1 1 0 0 0 1) (1 1 1 0 1 0 0 0) (0 1 1 1 0 0 0 1))  
    Best wishes,
    JP
    Submitter opmo Submitted 04/17/2018 Category Opusmodus Latest Release  
  20. Like
    Stephane Boussuge got a reaction from Jorvd in Scaling Velocity Vectors   
    (setf rh-a-dynamics (gen-eval 8 '(vector-to-velocity (random* 0.7) (random* 0.9) (vector-range 0.55 0.69 (gen-white-noise 5 :seed 12))))) S.
  21. Like
    Stephane Boussuge reacted to lviklund in Posting seed value   
    Thx a lot. Great feature.
    Is it possible to implement the same when doing audition-omn-snippet?
  22. Like
    Stephane Boussuge reacted to opmo in Posting seed value   
    I think it will help us to work even more freely and this is what we expect from Opusmodus :-) Thank you for the suggestion.
  23. Like
    Stephane Boussuge reacted to opmo in Opusmodus 1.2.23173   
    View File Opusmodus 1.2.23173
    New:
    The DO-VERBOSE (which prints function name into the Listener) will print now as well the random seed values if function with random seed is used.
    This new functionality allows you to lock the randomisation with the printed random seed if desired.
     

     
    The revised documentation (with function examples) illustrate how to make a print of the random seed in your own functions using the DO-VERBOSE macro.
    Documents:
    INIT-SEED
    RND-SEED
    RANDOM*
    CHOOSE-OPTION
     
    Best wishes,
    Janusz
    Submitter opmo Submitted 04/08/2018 Category Opusmodus Latest Release  
  24. Like
    Stephane Boussuge reacted to opmo in Posting seed value   
    I found a way to display an internal seed if seed is nil (random process).
     
    Example without a seed (each time different result):
    (rnd-number 12 1 10) ? rnd-number :seed 678732 => (10 6 10 6 1 9 5 6 10 2 4 2)  
    Now the same function with a manually "lock" using the :seed
    (rnd-number 12 1 10 :seed 678732) ? rnd-number :seed 678732 => (10 6 10 6 1 9 5 6 10 2 4 2)  
    (rnd-pick '((q c4 p d4 ff s a4 stacc) (s e4 app q c5 d5 pp))) ? rnd-pick :seed 598336 => (q c4 p d4 ff s a4 stacc)  

     
    I hope everybody will be happy with the solution  :-)
    To add this functionality to all the functions using random seed will take some time to do.
    Hopefully tomorrow :-)
     
    Best,
    Janusz
  25. Like
    Stephane Boussuge got a reaction from hujairi in Chord Inversions & Arpeggios   
    (list (chord-inversion 1 (expand-chord '(c4 69)))) S.
×