All Activity

I usually utillize the Activity Monitor for this, to stop the scsynth process. That way you don't have to open Supercollider (since you can boot the server again from OM)

Yes, correct.

For example 2: (make-omn :pitch (flatten (closest-path (harmonic-progression '((5)(5)(1)) '((db major) (c major) (c major)) :base 1 :size 4))) :length '(h h w )) Correct ?

For example 1: (closest-path (flatten (harmonic-progression '((5) (5) (5) (1)) '((d major) (g major) (c major) (c major)) :base 1 :size 4))) Correct ?

Thx Stephane, I do not understand how the function should be of any help for the examples 1&2. Can you elaborate? Example 3 yes understood.

harmonic-progression degree scale &key size step root row chord flatten base

The chord symbols for both look odd, can this be adjusted?

Beginners question: Does OM have system functions which simplify programmatic defining chord progressions in a advanced functional harmony style (i.e for Jazz) beyond normal diatonic harmony. These function may comply to Riemann nomenclature, i.e. utilizing as input a landing tonic. Examples: I want 4 chords, the tonic T i(c4 maj7) is the final chord, before lets approach it with a sequence of chained secondary dominants. I want the tritone substitution of a V7 chord, like g4 7, before playing c maj7. I want II/V progression before arriving at tonic.

wow !! Beautiful feedback ! Yes, Stephane ! This idea is inspiring ! Nice quartet ! Thank you all !! Best ! Julio

And playing a bit around this function: (setf melo-set '(d4 fs4 gs4 e4 b4 a4)) (setf res (permu melo-set)) (setf size 24) (setf mel1.pch (rnd-sample size res)) (setf mel2.pch (rnd-sample size res)) (setf mel3.pch (rnd-sample size res)) (setf mel4.pch (rnd-sample size res)) (setf len-set '(q e e -q s s s s)) (setf lenres (gen-loop 8 (rnd-order len-set))) (setf len1 (rnd-sample size lenres)) (setf len2 (rnd-sample size lenres)) (setf len3 (rnd-sample size lenres)) (setf len4 (rnd-sample size lenres)) (setf line1 (make-omn :pitch mel1.pch :length len1)) (setf line2 (make-omn :pitch mel2.pch :length len2)) (setf line3 (make-omn :pitch mel3.pch :length len3)) (setf line4 (make-omn :pitch mel4.pch :length len4)) (setf vn1 (ambitus 'violin (pitch-transpose 12 line1))) (setf vn2 (ambitus 'violin (pitch-transpose 0 line2))) (setf vla (ambitus 'viola (pitch-transpose -12 line3))) (setf vlc (ambitus 'cello (pitch-transpose -24 line4))) (ps 'gm :sq (list vn1 vn2 vla vlc))

Thank you Julio for this cool and fun idea. As a more general function: (defun permu (set) (do-verbose ("permu") (let ((n (length set))) (loop for i in (combination2 n set) when (and (equal (first set) (first i)) (equal n (length (find-unique i)))) collect i))))

less computation: (setf perm (do-verbose ("rotation") (loop for i in (combination2 7 '(c4 d4 e4 f4 g4 a4 b4)) when (and (equal 'c4 (first i)) (equal 7 (length (find-unique i)))) collect i))) (circle-pitch-plot (rnd-pick perm) :sort nil ;:remove-duplicates t :join-first nil :point-radius 6)

Thanks a lot !! No problem ! This is cool and generate some kind of diatonic version for Hauer stuff This was my inspiration to this Idea... barak schmool (@schmeinstein) • Instagram reel WWW.INSTAGRAM.COM 171 likes, 9 comments - schmeinstein on May 31, 2024: "all the notes of C major, once each. you can play these phrases forwards or backwards, even reflect them about the note D, and they still...". VERY COOL ! Thanks ! (setf diat-permute (loop for i in (combination2 7 '(1 2 3 4 5 6 7)) when (and (equal 1 (first i)) (equal 7 (length (find-unique i)))) collect i)) (setf diatonic-tropes (substitute-map '(c4 d4 e4 f4 g4 a4 b4) '(1 2 3 4 5 6 7) diat-permute)) (circle-pitch-plot (flatten (list (rnd-pick diatonic-tropes ))) :sort nil ;:remove-duplicates t :join-first nil :point-radius 6)

will stop the endless printing (do-verbose ("rotation") (loop for i in (combination2 7 '(1 2 3 4 5 6 7)) when (and (equal 1 (first i)) (equal 7 (length (find-unique i)))) collect i))

YES !!! This is the solution I was searching ! Best ! (loop for i in (combination2 7 '(1 2 3 4 5 6 7)) when (and (equal 1 (first i)) (equal 7 (length (find-unique i)))) collect i)

Thanks a lot for your time and patience, my dear friends ! But, actually, I need to remove the redundant permutations, not to generate. I just wanted to make sure I have all the prime permutations. Here is the result of the first 720 permutations of the diatonic scale. looks like the algorithm of the function start with all notes begining in C , then in D, then in E. I hope that the batch that starts all on C (the example below), contains all the permutations (the prime ones), but I´m not sure, I would need to check it manually... Is it rigth ? The algorithm is doing like this (starting in every note at each 720 permutations) ? Best ! Julio Dear Janusz I need the reverse of what you did From this set of combinations ((1 2 3 4) (1 3 2 4) (1 2 4 3) (1 4 2 3) (1 3 4 2) (1 4 3 2)) filter to get only the generator (1 2 3 4) Best

If you want only lists starting with 1: (loop for i in (combination2 4 '(1 2 3 4)) when (and (equal 1 (first i)) (equal 4 (length (find-unique i)))) collect i) => ((1 2 3 4) (1 3 2 4) (1 2 4 3) (1 4 2 3) (1 3 4 2) (1 4 3 2)) or (loop for i in (combination2 4 '(1 2 3 4)) when (and (equal 1 (first i)) (contain-itemsp '(1 2 3 4) i)) collect i) => ((1 2 3 4) (1 3 2 4) (1 2 4 3) (1 4 2 3) (1 3 4 2) (1 4 3 2)) results with 1 in second position: (loop for i in (combination2 4 '(1 2 3 4)) when (and (equal 1 (second i)) (contain-itemsp '(1 2 3 4) i)) collect i) => ((2 1 3 4) (3 1 2 4) (2 1 4 3) (4 1 2 3) (3 1 4 2) (4 1 3 2))

(gen-rotate :left '(1 2 3 4) :type 'list) => ((1 2 3 4) (4 1 2 3) (3 4 1 2) (2 3 4 1)) (gen-rotate :left '(1 2 3 4 5 6 7) :type 'list) => ((1 2 3 4 5 6 7) (7 1 2 3 4 5 6) (6 7 1 2 3 4 5) (5 6 7 1 2 3 4) (4 5 6 7 1 2 3) (3 4 5 6 7 1 2) (2 3 4 5 6 7 1)) You should avoid permute function etc... The best way to pick a possible set is the rnd-order function. Rotation sets without the starting list: (rest (gen-rotate :right '(1 2 3 4) :type 'list)) => ((2 3 4 1) (3 4 1 2) (4 1 2 3)) (rest (gen-rotate :right '(1 2 3 4 5 6 7) :type 'list)) => ((2 3 4 5 6 7 1) (3 4 5 6 7 1 2) (4 5 6 7 1 2 3) (5 6 7 1 2 3 4) (6 7 1 2 3 4 5) (7 1 2 3 4 5 6))

While playing around with it, I found that this only works reliably when there are no duplicate items in the list to be permuted. So, it's neither perfect nor universally applicable, but as long as the caveat is understood it does the job. Cheers, Jon

Julio, The easiest procedure for eliminating the rotations is to perform the permutations on all but the first (or last) item in the list, and then append that item back to the front (or back) of the list. For example: (defun perms-no-rots (lst) (let ((perms (permute (cdr lst)))) (loop for x in perms collect (append (list (car lst)) x)))) I'm still a Lisp rookie, so there might be better, cleaner, more Lisp-y ways to do it, but it seems to work: (perms-no-rots '(1 2 3 4)) ==> ((1 2 3 4) (1 2 4 3) (1 3 2 4) (1 3 4 2) (1 4 2 3) (1 4 3 2)) (perms-no-rots '(1 2 3 4 5)) ==> ((1 2 3 4 5) (1 2 3 5 4) (1 2 4 3 5) (1 2 4 5 3) (1 2 5 3 4) (1 2 5 4 3) (1 3 2 4 5) (1 3 2 5 4) (1 3 4 2 5) (1 3 4 5 2) (1 3 5 2 4) (1 3 5 4 2) (1 4 2 3 5) (1 4 2 5 3) (1 4 3 2 5) (1 4 3 5 2) (1 4 5 2 3) (1 4 5 3 2) (1 5 2 3 4) (1 5 2 4 3) (1 5 3 2 4) (1 5 3 4 2) (1 5 4 2 3) (1 5 4 3 2)) Edit: Here's another version I came up with after sending the version above. It is maybe a little nicer to read since I replaced `(append (list....` with `(cons...` : (defun perms-no-rots (lst) (let ((perms (permute (cdr lst)))) (loop for x in perms collect (cons (car lst) x)))) Cheers, Jon

Dear Janusz and friends, I´m back to the subject of permutations. The expression below brings all the permutations for a diatonic scale (or any other set you might want to do). (setf diat-permute (permute '(1 2 3 4 5 6 7))) (substitute-map '(c4 d4 e4 f4 g4 a4 b4) '(1 2 3 4 5 6 7) diat-permute) But the list is too long and redundant (I got also a stack overflow when trying to make a snippet out of it (but this is another problem...) The question I´d like to ask is for a function for filtering the rotational variations of a set, to exclude a large number of unnecessary permutations. For Example: (1 3 4 2) is rotationally the same as (3 4 2 1 ), (4 2 1 3) and (2 1 3 4), so there is no need of the 4 permutations, since musically you can just use the rotations. The same goes for other cardinalities (2 4 3 1 5 6 7) is the rotationally the same that (4 3 1 5 6 7 2) (3 1 5 6 7 2 4) (1 5 6 7 2 4 3) (5 6 7 2 4 3 1) (6 7 2 4 3 1 5) and (7 2 4 3 1 5 6), there is no need for 7 versions of it. I´d like to have a function to get only the "parent" of each rotational set, a kind of rotate-permute function. It´s a very musical way to think about it. Can someone help ? All the best ! Thanks

Thx @opmo understood, so keyword :root is not really what is typically tought as chord root (if I exclude pcs theory). :low seems to be the "new" root. Feedback, even if pcs-theory-wise justified, OM-API is a bit counter-intuitive here in my humble users point of view. At least I suggest to make an extra note in the documentation so that other do not fall into the same trap as I did. Yes I know the existing example indicates this surprise already, but please add your pcs "justification", this will explain the rationale. (dechord (chord-inversion 0 (expand-chord '(c4 maj7))) :pitch 'low) -> ((c4)) and (dechord (chord-inversion 1 (expand-chord '(c4 maj7))) :pitch 'low) -> ((e4))

(pcs-normal-order (melodize 'c4e4g4b4)) => (11 0 4 7) Yes, the :pitch 'low will return the lowest pitch in the chord.

I have the following chord progression: (setf chords '((w (c4 maj7)) (w (a4 m7)) (w (d4 m7)) (w (g4 7)) ; (w (c4 maj7)) (h (a4 m7/b5)) (h (a4 m7)) (h (d4 m7/b5)) (h (d4 m7)) (w (g4 7)) )) When evaluating following expression on it ... (dechord chords :pitch 'root) ... I get following result in the listener: ((w b4 mf) (w e5 mf) (w a4 mf) (w b4 mf) (w b4 mf) (h g5 mf) (h e5 mf) (h c5 mf) (h a4 mf) (w b4 mf)) I expected the roots. Am I doing something wrong? --- EDIT: Just played around with the other keyword options... :pitch 'low ... return the expected result. Still I am confused. Can someone explain the result with :pitch ‘root ?