greetings

andré

 

;;; ---------------------------------------------------------------------------------------------------
;;; because i'm working with numbered-events (to have some more control) i has to code
;;; a specific tranposition-function, which is transposing on specific spans/positions
;;; ---------------------------------------------------------------------------------------------------

;;; SUB

(defun and-span (n a b)
  (and (>= n a)
       (<= n b)))

;;; MAIN

(defun transpose-on-event-number (omn-list &key positions/transpose-list)
  (loop 
    for i in (single-events omn-list)
    for cnt = 0 then (incf cnt)
    with position-list = (loop for x in positions/transpose-list collect (car x))
    with transpose-list = (loop for y in positions/transpose-list collect (rest y))
    with cnt2 = 0


    when (and (and-span cnt (car (nth cnt2 position-list)) (cadr (nth cnt2 position-list)))
              (not (length-restp (car (omn :length i)))))

    collect (pitch-transpose-n (nth cnt2 transpose-list)  i)
    else collect i

    when (and (= cnt  (cadr (nth cnt2 position-list)))
              (< cnt (cadar (last position-list))))
    do (incf cnt2)))
    

;;; ZERO-based (like in lisp)
(transpose-on-event-number '(q g4 -q q g4 g4 g4 g4 g4 g4 g4 g4)
                           :positions/transpose-list '(((0 5) 1)
                                                       ((6 7) -3)
                                                       ((8 9) 12)))

=> ((q gs4 mf) (-q) (q gs4 mf) (q gs4 mf) (q gs4 mf) (q gs4 mf) (q e4 mf) (q e4 mf) (q g5 mf) (q g5 mf))

 

what you could do with it? 

a precise "projection on a curve" of a generated OMN (in this example: a 12-tone-row, which is been permuted (by a SORTING-algorithm) from start to end, till it's a symmetrical scale)

 

Very interesting, André !

Two things:

1) How it works over chord lists, like '(c4e4g4) ? The chord is counted as one item in the span, or each note counts as one item ?

2) Would be interesting to have an argument for an "span-ignore-pauses" option, while doing the span, because the way you write the pause will chanbe the span function. Sometimes it can be good and sometimes not, depending on the desired effect. For example (-q -q) counts as 2 items, while (-h) counts as one item.

 

Best,

Julio

it's not a common solution, only a specific for my project... 

 

1) it should also work with chords - because it's made for EVENTS it's always one chord = one event

2) of course, you have to decide/check if you like to merge rests or not => because i'm filtering the texture by a binary-seq (binaries from a jpeg, like a sieve) it's not the idea to merge the rests, but you could do that in a seperate step. but in my case every note/event (before filtering) is numbered, so with/when BINARY-FILTER/SIEVE you will keep the numbering concise.

 

For span-ignore-pause, use the function gen-swallow

 

SB.

 

 

thanx for the span-ignore-pause-HINT! ...but it makes no sense to me - when you are working with EVENTS (by numbering it) - to ignore some of them 😉

the idea behind this concept is, that you could work with a (finished) score by changing some parameters or enlarge rests - like a kind of "post-production". in this way it's not necessary to go deep inside you generating-algorithms, you can only change things a little bit like in a notation-software (i think it's on that level). some months ago i had the idea to do such changes (post...) by positions with BARS/BEATS - but at the moment i think it's much better to signify the EVENTS and work directly on them. less errors and easy to code such post...-functions.

 

With EDIT-EVENT (ver1.3) function you will be able to edit any parameter in any given bar:

(edit-event '(
              (0 0 '(pitch-transpose 12 x) :pitch)
              (0 2 '(chord-inversion 2 x) :pitch)
              (0 3 '(pitch-variant x :variant 'i) :pitch)
              (2 1 '(chord-inversion 1 x) :pitch)
              (2 2 '(chord-inversion 1 (pitch-transpose 12 x)) :pitch)
              (3 1 '(chord-inversion 1 (pitch-transpose 12 x)) :pitch)
              (3 2 '(chord-inversion 2 x) :pitch)
              (3 3 '(chord-inversion 2 x) :pitch)
              (3 5 '(chord-inversion 4 x) :pitch)
              (3 6 'g3e4c5 :pitch)
              )
            '((e c2 c3e3g3 c3e3g3 c3e3g3) (e f2 c3f3a3 c3f3a3 c3f3a3)
              (e e2 e3g3c4 e3g3c4 e3g3c4) (e gs2 e3b3 e3b3 e3b3 g2 d3g3b3 d3g3b3 d3g3b3)))
              
=> ((e c3 mf c3e3g3 g3c4e4 c3gs2f2)
    (e f2 c3f3a3 c3f3a3 c3f3a3)
    (e e2 mf g3c4e4 g4c5e5 e3g3c4)
    (e gs2 mf b4e5 e4b4 e4b4 g2 g4b4d5 g3e4c5 d3g3b3))

 

with BAR and BEAT? that's great JANUSZ, you are always two steps ahead or "MILES AHEAD" (trumpeter's joke :-))

 

but WHEN will be the RELEASE? 🤓

53 minutes ago, opmo said:

With EDIT-EVENT (ver1.3) function you will be able to edit any parameter in any given bar:

(edit-event '(
              (0 0 '(pitch-transpose 12 x) :pitch)
              (0 2 '(chord-inversion 2 x) :pitch)
              (0 3 '(pitch-variant x :variant 'i) :pitch)
              (2 1 '(chord-inversion 1 x) :pitch)
              (2 2 '(chord-inversion 1 (pitch-transpose 12 x)) :pitch)
              (3 1 '(chord-inversion 1 (pitch-transpose 12 x)) :pitch)
              (3 2 '(chord-inversion 2 x) :pitch)
              (3 3 '(chord-inversion 2 x) :pitch)
              (3 5 '(chord-inversion 4 x) :pitch)
              (3 6 'g3e4c5 :pitch)
              )
            '((e c2 c3e3g3 c3e3g3 c3e3g3) (e f2 c3f3a3 c3f3a3 c3f3a3)
              (e e2 e3g3c4 e3g3c4 e3g3c4) (e gs2 e3b3 e3b3 e3b3 g2 d3g3b3 d3g3b3 d3g3b3)))
              
=> ((e c3 mf c3e3g3 g3c4e4 c3gs2f2)
    (e f2 c3f3a3 c3f3a3 c3f3a3)
    (e e2 mf g3c4e4 g4c5e5 e3g3c4)
    (e gs2 mf b4e5 e4b4 e4b4 g2 g4b4d5 g3e4c5 d3g3b3))

 

WOWWWWWWW !!!!

This version is getting better every day !!!

Best !

Julio