AM

Members

600

1. 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-interval
2. gen-brownian-bridge

something new... greetings andré ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; BROWNIAN BRIDGE -> could be use as a rnd-process from A to B (integers or pitches) ;;; if you have a look to example with ":all-gen t", you will see the process with all generations, how it works ;;; or take a look to: ;;; https://de.wikipedia.org/wiki/Wiener-Prozess#/media/File:BrownscheBewegung.png ;;; https://de.wikipedia.org/wiki/Brownsche_Brücke ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3. gen-puls*

a very simple, but useful little function... (defun gen-puls* (n tuplet period &key (stacc nil)) (gen-length (loop repeat n with period = (if (equal stacc t) (list 1 (neg! (1- period))) period) collect period) tuplet)) ;;; option: stacc or ord (gen-puls* 10 1/32 13) => (13/32 13/32 13/32 13/32 13/32 13/32 13/32 13/32 13/32 13/32) (gen-puls* 10 1/32 13 :stacc t) => (1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/32 -3/8 1/3
4. mapping <gen-sort> by <tonality-map>

like this (?)... ;;; mapping to MAJOR (setf sort-seq (integer-to-pitch (flatten (gen-sort (rnd-order (gen-integer 24)) :type 'selection)))) (def-score example-score (:key-signature 'atonal :time-signature '(4 4) :tempo 90 :layout (treble-layout 'seq)) (seq :omn (make-omn :pitch (setf n (tonality-map '(major :map step :root 'c4) sort-seq)) :length (gen-repeat (length (flatten n)) '(t))))) ;;; mapping to MESSIAEN-mode (setf sort-seq (integer-to-pitch (flatten (ge
5. mapping integer?

thanks stephane! it seems that's the function i was looking for ... but not exaxtly... seems not to work "with integers larger then highest scale-pitch" (only in 1 octave?) (vector-map (expand-tonality '(c4 messiaen-mode5)) '(0 12 13 14 1 2 3 4 2 1 5 3 1)) => (c4 g4 b4 b4 c4 cs4 cs4 cs4 cs4 c4 f4 cs4 c4) with my function - the whole range possible, also with "mixed" toanlities (setf seq (flatten (gen-sort (rnd-order (gen-integer 24) :seed 49) :type 'selection))) (integer-to-tonality seq '(messiaen-mode4 messiaen-mode5
6. mapping integer?

i coded a function now, that maps all integers to all TONALITIES, like i want it... SORTING OLIVIER's MODI and going crazy ;;; SUB (defun multiple-expand-tonality (&key startpitch octaves tonality) (remove-duplicates ;remove is for "cutting" if there are too much pitches (OMN loops last octave!) (loop repeat octaves with pitch = startpitch with cnt = 0 when (= cnt (length tonality)) do (setq cnt 0) append (expand-tonality (list pitch (nth cnt tonality))) do (incf cnt) do (setq pitch (car (pitch-transpose 12 (list pitch)))))))
7. mapping integer?

in LISP (loop for i in '(0 1 2 3 4 2 1 5 3 1) collect (nth i (expand-tonality '(c4 messiaen-mode5))))
8. mapping integer?

hi all, what is the OPMO-function to map an integer-seq like (11 22 9 4 3 1 10 21 23 20 8 0 13 6 24 16 7 14 17 19 2 18 15 5 12) to a scale -> 0 has to be lowest pitch of the scale etc... no problem to solve it via LISP-code, but what is the correct OPMO-function to map it on TONALITIES? thanx andré
9. morph* - an alternative version

greetings andré p.s. it's the PITCH-version of "shift-length-proportions", i've worked with these things a long time ago... in COMMON MUSIC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;; a function which transforms a pattern (each pitch linearly and independent) to another pattern ;;;; by interval "STEP" ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SUBFUNCTION (defun compare (start end &key (step 1)) (list (loop for i in start for j in end
10. code sorting algorithms

okay, i see... and waht is the default? i think whole process (all steps) would be good
11. shift-length-proportions / morph

shift-length-proportions a bit like gen-morph for LENGTHS. every item of a length-list will change linear till the endpattern is reached. ;;; subfunction (defun compare (start end &key (step 1/32)) (list (loop for i in start for j in end when (/= i j) collect (if (> i 0) (if (< i j) (+ i step) (- i step)) (if (> i j) (- i step) (+ i step)))
12. code 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-rep
13. code sorting algorithms

you're welcome my favorites are: (make-omn :pitch (setf n (sorting (vector-to-pitch'(g3 bb5) (gen-white-noise 40)) :algorithm 'selection)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e)))) (make-omn :pitch (setf n (sorting (vector-to-pitch'(g3 bb5) (gen-white-noise 40)) :algorithm 'insertion)) :length (gen-repeat (length n) (append (gen-repeat 40 '(t)) (list '-e))))
14. code sorting algorithms

you could add if you like, but perhaps... CODE it better! and, perhaps it's possible for you to make it working with CHORDS? this sorting-thing could be also used (if you pick single generations) for producing "variants" of a motif - with more or less difference from/to an original. - i have some more plans - based on musical ideas - for SORTING functions. when it's coded i'll send it to you at "SOURCE CODE" - so you can have a look what is interesting for you. i'd like to work also a bit on MORPH-things (how to "morph" a gestalt into another).
15. code 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
16. bubble-sort

for a musical research project where i work with the sorting processes of different sorting algorithms (bubble-sort, heap-sort ...), i have to program such algorithms myself. the ide is that not only the end result of the algorithm is visible but also the constant changes (the mechansim). here the first: bubble-sort. very simple and inelegant programmed - but the thing i need to have :-) bubble-sort: https://en.wikipedia.org/wiki/Bubble_sort have a look to different sorting algorithms: greetings andré ;;; bubble-s
17. code sorting algorithms

great... but unfortunately, i'm looking for a whole range of different sorting algorithms - which are working by steps...
18. code sorting algorithms

thanks janusz, what kind of SORTING ALGORITHM is GEN-MORPH using? greetings andré p.s. here some different algorithms in LISP but without "generation-output" https://gist.github.com/llibra/2948765
19. code sorting algorithms

hm, but isn't it replacing (rnd), and not sorting? would like to code exactly something like this this: 15 Sorting Algorithms in 6 Minutes ...to SHOW the process of sorting algorithms....
20. code sorting algorithms

hi all i'm looking for different SORTING ALGORITHMS in LISP - no problem to find (different) in the WWW... but: i would like to have as OUTPUT-result ALL generations of the SORTING-process and not only the LAST one - i'm interested in the PROCESS!! thanks for some help or any idea? (for once i do not want to code it myself :-)) greetings andré
21. implemented Quantisation?

great! merry christmas
22. Length-Legato opposite function

it was necessary to re-organize "OMN with ties" by "omn-merge-ties" first... and find a solution if staccato-length = length ... added 2 minutes later you're welcome... it's a bit like "BRAINFOOD" solving such things... but TORSTEN is the "code-master" for the complicated things!! so, i have to compose now, the real hard work.
23. Length-Legato opposite function

the solution... (defun length-staccato (n alist) (let ((newlengths) (new-omn (omn-merge-ties (flatten alist))) (time-sign (get-time-signature alist))) (progn (setf newlengths (loop for i in (omn :length new-omn) when (> i 0) append (if (= n i) (list i) (list n (* -1 (abs (- i n))))) else collect i)) (if (omn-formp alist) (omn-to-time-signature (make-omn :length newlength
24. Length-Legato opposite function

dear julio i don't know if there is a solution in the om-library... coded quickly one for your problem... the basic-rhythms (denominator) should stay constant like in your examples, then it works... first value has to be your "stacc-length", second your omn-list or a length-list, have a look to the example... greetings andré (defun length-staccato (n alist) (let ((newlengths (loop for i in (omn :length alist) when (> i 0) append (list n (* -1 (abs (- i n)))) else collect i))) (
25. Multiple/Simultaneous Voices, Each With Different BPM's?

polytempo-discussion in OM (years ago) https://opusmodus.com/forums/topic/353-how-to-write-a-polytempo-score/?tab=comments#comment-910 --- technology for live realisation (how to conduct it) by real musicians -> by polytempo-network: https://www.facebook.com/Philippe-Kocher-Composer-31442199213/ http://philippekocher.ch/#109 http://polytempo.zhdk.ch i used this technology already for 2 pieces... also for my next work. greetings andré
×

• Lessons