AM

Marvellous, Janusz, 
 
It will be a huge step in the system. And probably will be easier to make it compatible to many different systems, since it´s all Lisp-based stuff !
 
Looking forward to have it in Windows and make some cool videos showing it to people !!
No hurry ! Take your time !
 
Best !
Julio

The v.3.0 has a build in CL-COLLIDER library. With simple load you will be able to use SC (Super Collider) UGens, score and play it in OM 3.0.

We are making great progress. Tests taking some time, especially when you make a port (not trivial) and make sure, the new app works on new M1/2 and older macOS systems. 
 
There are many new functionalities (GUI) with a new Notation Viewer which you can see on the Announcement forum.
Better search, rewritten System Function (in PDF format, for better read) responsive MIDI Entry and more.
 
The v.3.0 is not only a port from CCL to LW system -  with a support for M1 - but a substantial upgrade to the existing system.
 
Asking 'when', 'you promised' etc... will not speedup the process.
I am one of you, wishing too, to use the new system for my own work.
 
Best wishes to all,
Janusz

We are already testing everything with 3.0 and all seams to work.
We want to release the new OM stable as possible.
 

Didn't you read this (the compatibility) when you made the update, bought a new computer? I always check that - always. Also with MaxMsp, Avid Sibelius, Pro Tools ...

 
 
 
SIBELIUS
i think AVID SIBELIUS is not yet officially ready for VENTURA either, and M1 only under the Rosetta 2 translation layer.
 
macOS 11 (Big Sur), OS12 (Monterey) and M1 Support for Avid Products
AVID.SECURE.FORCE.COM  
Music notation software, macOS Ventura, and Apple Silicon [updated] - Scoring Notes
WWW.SCORINGNOTES.COM How Sibelius, Finale, Dorico, MuseScore, and Notion are faring on Apple's Ventura operating system and Apple Silicon-powered hardware.  

If you have problems like registering etc.. please give us the direct note.
In the download pages is very clear what macOS system is supported.
In the next few days we release v.3.0 which will work in Ventura and M1.
 
I will make the refund for you shortly.

Absolutely not.
SB.

Amazing feature, Janusz !
 
This is new Notation Viewer is a very useful feature, especially for dealing with long excerpts of music. It really helps a lot when hearing the pieces to make decisions about the form, the duration of the textures.
Does it works also with the ps (preview score) function ?
 
Looking forward to see it in Windows machines !
 
All the best !
 
Julio 

I hope you like the upcoming Notation viewer. Opusmodus v.3.0 screenshot.
Coming soon.
 
OM-v.3.0-Notation-Viewer.mp4
 

There are still few thing to do mainly to do with license activation. I will release a few screenshots and short video about the new notation viewer this week.
Thank you for your patients.

dear all
 
conTimbre-library works (in the next update) perfect with TUNING  (midi-pitchbend) and PAN now. thanx to thomas hummel and janusz!
here are some simple sound examples...
 
ct-micro+pan2.aiff
ct-micro+pan3.aiff
ct-micro+pan.aiff
ct-micro+pan4.aiff

New short piece for Piano.
 
Stéphane
 
 
Instant1-V1Edit03Render1.mp3 instant1v1-01Edit3.pdf Instant1V1-01.opmo

an example with 2 pitches = 2 intervals, with microtonal quantification
 
(sort-asc (remove-duplicates (pitch-melodize (append (gen-summationsakkord '(3 5) :typ 'ks :gedachter-grundton 'db0 :quant nil) (gen-summationsakkord '(5 7) :typ 'ks :gedachter-grundton 'db0 :quant nil))))) (sort-asc (remove-duplicates (pitch-melodize (append (gen-summationsakkord '(3 5) :typ 'gs :gedachter-grundton 'db0 :quant nil) (gen-summationsakkord '(5 7) :typ 'gs :gedachter-grundton 'db0 :quant nil)))))  
 

here ist some code to generate "Summationsakkorde" (CLAUS KüHNL)... have a look to the PDF...
(from the book "Claus Kühnl: Beiträge zu einer HArmonielehre 2000" Friedrich Hofmeister Musikverlag. p.42+)
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun gen-summationsakkord (primaerint &key (n 10)(typ 'ks) (gedachter-grundton 'c0) (quant 1/2) (chord t)) (let ((partial-reihe (hertz-to-pitch (harmonics gedachter-grundton 100 :type :hertz) :quantize quant)) (partial-liste (remove-duplicates (append primaerint (list (sum primaerint)) (loop repeat n with k-int = (sum primaerint) with g-int = (sum primaerint) with a = (first primaerint) with b = (second primaerint) collect (cond ((equal typ 'ks) (setf k-int (+ (car primaerint) k-int))) ((equal typ 'gs) (setf g-int (+ (second primaerint) g-int))) ((equal typ 'fibo) (shiftf a b (+ a b))))))))) (if (null chord) (position-filter (x-b partial-liste 1) partial-reihe) (chordize (position-filter (x-b partial-liste 1) partial-reihe))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'gs :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'fibo :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2 :quant nil) (gen-summationsakkord '(3 4) :typ 'ks :gedachter-grundton 'f1) (gen-summationsakkord '(3 4) :typ 'gs :gedachter-grundton 'f1) (gen-summationsakkord '(3 4) :typ 'fibo :gedachter-grundton 'f1)  
Doc - 03.08.2022 - 20-41.pdf
 

an example with 2 pitches = 2 intervals, with microtonal quantification
 
(sort-asc (remove-duplicates (pitch-melodize (append (gen-summationsakkord '(3 5) :typ 'ks :gedachter-grundton 'db0 :quant nil) (gen-summationsakkord '(5 7) :typ 'ks :gedachter-grundton 'db0 :quant nil))))) (sort-asc (remove-duplicates (pitch-melodize (append (gen-summationsakkord '(3 5) :typ 'gs :gedachter-grundton 'db0 :quant nil) (gen-summationsakkord '(5 7) :typ 'gs :gedachter-grundton 'db0 :quant nil)))))  
 

here ist some code to generate "Summationsakkorde" (CLAUS KüHNL)... have a look to the PDF...
(from the book "Claus Kühnl: Beiträge zu einer HArmonielehre 2000" Friedrich Hofmeister Musikverlag. p.42+)
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun gen-summationsakkord (primaerint &key (n 10)(typ 'ks) (gedachter-grundton 'c0) (quant 1/2) (chord t)) (let ((partial-reihe (hertz-to-pitch (harmonics gedachter-grundton 100 :type :hertz) :quantize quant)) (partial-liste (remove-duplicates (append primaerint (list (sum primaerint)) (loop repeat n with k-int = (sum primaerint) with g-int = (sum primaerint) with a = (first primaerint) with b = (second primaerint) collect (cond ((equal typ 'ks) (setf k-int (+ (car primaerint) k-int))) ((equal typ 'gs) (setf g-int (+ (second primaerint) g-int))) ((equal typ 'fibo) (shiftf a b (+ a b))))))))) (if (null chord) (position-filter (x-b partial-liste 1) partial-reihe) (chordize (position-filter (x-b partial-liste 1) partial-reihe))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'gs :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'fibo :gedachter-grundton 'c2) (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2 :quant nil) (gen-summationsakkord '(3 4) :typ 'ks :gedachter-grundton 'f1) (gen-summationsakkord '(3 4) :typ 'gs :gedachter-grundton 'f1) (gen-summationsakkord '(3 4) :typ 'fibo :gedachter-grundton 'f1)  
Doc - 03.08.2022 - 20-41.pdf
 

here is a possible solution...
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; THE FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun gen-arpeggio (event &key (rhy'(1/28)) (legato nil)) (let* ((pitches (melodize (omn :pitch event))) (length (car (omn :length event))) (velo (car (omn :velocity event))) (art (car (omn :articulation event))) (rhy (gen-repeat 10 rhy)) (arpeggio-voices (loop repeat (length pitches) for i from 0 to (1- (length pitches)) for j in pitches for rhy in rhy collect (if (= i 0) (length-rational-quantize (list rhy j velo art) :round length) (length-rational-quantize (append (gen-length (list i) (* -1 rhy)) (list rhy) (list j) (list velo) (list art)) :round length))))) (assign-variable 'voice (if (null legato) arpeggio-voices (loop for x in arpeggio-voices collect (length-legato x)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; IT WORKS LIKE THAT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; type in ONE single-event (l p v a) with CHORD... for example: (setf event '(q c4e4g4b4 mf ten)) ;;; evaluate the function (with a arpeggio-length, for example :ryh 1/28) (gen-arpeggio event :rhy 1/28) ; now the the result are "bounded" on 4 voices/variables = the number of the chord-pitches ; => (voice1 voice2 voice3 voice4) ;;; list every variable, so you will have the four "arpeggio-rhythm/times", so you can use that for 4 parts on your score (list voice1) (list voice2) (list voice3) (list voice4) ;;; VARIANTS AND OPTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; if you choose ":legato t" => all the voices are like with PEDAL played (gen-arpeggio event :rhy 1/28 :legato t) ;;; if you want to put/merge all that into ONE VOICE just: (merge-voices voice1 voice2 voice3 voice4) => (7q c4 ten e4 ten g4 ten b4 ten -7h.) ;;; if you want to have different rhy's just do it like that (gen-arpeggio event :rhy '(1/28 1/20 1/12 1/8)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  
 

here is a possible solution...
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; THE FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun gen-arpeggio (event &key (rhy'(1/28)) (legato nil)) (let* ((pitches (melodize (omn :pitch event))) (length (car (omn :length event))) (velo (car (omn :velocity event))) (art (car (omn :articulation event))) (rhy (gen-repeat 10 rhy)) (arpeggio-voices (loop repeat (length pitches) for i from 0 to (1- (length pitches)) for j in pitches for rhy in rhy collect (if (= i 0) (length-rational-quantize (list rhy j velo art) :round length) (length-rational-quantize (append (gen-length (list i) (* -1 rhy)) (list rhy) (list j) (list velo) (list art)) :round length))))) (assign-variable 'voice (if (null legato) arpeggio-voices (loop for x in arpeggio-voices collect (length-legato x)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; IT WORKS LIKE THAT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; type in ONE single-event (l p v a) with CHORD... for example: (setf event '(q c4e4g4b4 mf ten)) ;;; evaluate the function (with a arpeggio-length, for example :ryh 1/28) (gen-arpeggio event :rhy 1/28) ; now the the result are "bounded" on 4 voices/variables = the number of the chord-pitches ; => (voice1 voice2 voice3 voice4) ;;; list every variable, so you will have the four "arpeggio-rhythm/times", so you can use that for 4 parts on your score (list voice1) (list voice2) (list voice3) (list voice4) ;;; VARIANTS AND OPTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; if you choose ":legato t" => all the voices are like with PEDAL played (gen-arpeggio event :rhy 1/28 :legato t) ;;; if you want to put/merge all that into ONE VOICE just: (merge-voices voice1 voice2 voice3 voice4) => (7q c4 ten e4 ten g4 ten b4 ten -7h.) ;;; if you want to have different rhy's just do it like that (gen-arpeggio event :rhy '(1/28 1/20 1/12 1/8)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  
 

here is a possible solution...
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; THE FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun gen-arpeggio (event &key (rhy'(1/28)) (legato nil)) (let* ((pitches (melodize (omn :pitch event))) (length (car (omn :length event))) (velo (car (omn :velocity event))) (art (car (omn :articulation event))) (rhy (gen-repeat 10 rhy)) (arpeggio-voices (loop repeat (length pitches) for i from 0 to (1- (length pitches)) for j in pitches for rhy in rhy collect (if (= i 0) (length-rational-quantize (list rhy j velo art) :round length) (length-rational-quantize (append (gen-length (list i) (* -1 rhy)) (list rhy) (list j) (list velo) (list art)) :round length))))) (assign-variable 'voice (if (null legato) arpeggio-voices (loop for x in arpeggio-voices collect (length-legato x)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; IT WORKS LIKE THAT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; type in ONE single-event (l p v a) with CHORD... for example: (setf event '(q c4e4g4b4 mf ten)) ;;; evaluate the function (with a arpeggio-length, for example :ryh 1/28) (gen-arpeggio event :rhy 1/28) ; now the the result are "bounded" on 4 voices/variables = the number of the chord-pitches ; => (voice1 voice2 voice3 voice4) ;;; list every variable, so you will have the four "arpeggio-rhythm/times", so you can use that for 4 parts on your score (list voice1) (list voice2) (list voice3) (list voice4) ;;; VARIANTS AND OPTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; if you choose ":legato t" => all the voices are like with PEDAL played (gen-arpeggio event :rhy 1/28 :legato t) ;;; if you want to put/merge all that into ONE VOICE just: (merge-voices voice1 voice2 voice3 voice4) => (7q c4 ten e4 ten g4 ten b4 ten -7h.) ;;; if you want to have different rhy's just do it like that (gen-arpeggio event :rhy '(1/28 1/20 1/12 1/8)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  
 

In many scores, Pierre Boulez use a lot of accacciatura or appoggiatura , for exemple like in Dérive (1984), a score composed for and based on the name SACHER (famous hexachord used also in "Message esquisse").
 
Here's a function to help to add such appoggiature in your score based on a list of rhythmic values.
There is a draft doc in French joined to the function definition.
 
Hope it could be useful for some of us and may be improved and better coded and refined.
 
My best to all of Opmo users.
 
SB.
 
gen-ornament.lisp gen-ornament.rtfd.zip

an idea (permutationsfaktor) used by HELMUT LACHENMANN for many of his pieces - to organize/build his strukturnetz.
from an article by PIETRO CAVALLOTTI ("Die Funktion des Strukturnetzes am Beispiel von Mouvement (- vor der Erstarrung)")
 

(defun permute-by-rule (n rule row) (append (list row) (loop repeat n collect (setf row (position-filter rule row))))) ;; row => a row (or a list) ;; n => number of generations ;; rule => new position/order in every generation - keep attention it's 0-based!!! => for 12 pitches use 0 to 11 (permute-by-rule 20 '(2 0 1 5 11 3 8 6 4 9 10 7) (make-scale 'c4 12))  

(defun permute-by-rule (n rule row) (append (list row) (loop repeat n collect (setf row (position-filter rule row))))) ;; row => a row (or a list) ;; n => number of generations ;; rule => new position/order in every generation - keep attention it's 0-based!!! => for 12 pitches use 0 to 11 (permute-by-rule 20 '(2 0 1 5 11 3 8 6 4 9 10 7) (make-scale 'c4 12))  

(defun permute-by-rule (n rule row) (append (list row) (loop repeat n collect (setf row (position-filter rule row))))) ;; row => a row (or a list) ;; n => number of generations ;; rule => new position/order in every generation - keep attention it's 0-based!!! => for 12 pitches use 0 to 11 (permute-by-rule 20 '(2 0 1 5 11 3 8 6 4 9 10 7) (make-scale 'c4 12))  

here is a function to MAP a 2d-field to chords (via intervals) // an idea i got from "Nierhaus - Algorithmic Composition" - Cellular Automata (p. 198). so you can "import/map" some GAME-OF-LIFE configurations or whatelse (a pixel photo?)  // the PITCH-MAPPING is like in Miranda's CAMUS.
 
 
;; FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun 2d-field-to-chord (matrix &key (start 'c4) (merge-chords nil)) (let* ((int-horizontal (x+b (loop for x in (loop for i in matrix collect (position-item 1 i)) when (not (null x)) collect x) 1)) (int-vertical (x+b (loop repeat (length matrix) for n = 0 then (incf n) when (not (null (position-item 1 (nth n matrix)))) collect n) 1)) (chords (loop for h in int-horizontal for v in int-vertical append (loop for z in h collect (chordize (interval-to-pitch (list z v) :start start)))))) (if (null merge-chords) chords (chord-pitch-unique (chordize (flatten chords)))))) ;; interval-matrix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; numbers are intervals (inverted order then in the book) ;; (different sizes are possible) (setf matrix #|1 2 3 4 5 6 7 8 9 etc..|# #|1|# '((1 0 0 0 0 0 0 0 0 0 0 0) #|2|# (0 1 0 0 0 0 0 0 0 0 0 0) #|3|# (0 0 1 0 0 0 0 0 0 0 0 0) #|4|# (0 0 0 0 0 0 0 0 0 0 0 0) #|5|# (0 0 0 0 0 0 0 0 0 0 0 0) #|6|# (0 0 0 0 0 0 0 0 0 0 0 0) #|7|# (0 0 0 0 0 0 0 0 0 0 0 0) #|etc..|# (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 1 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 1 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0))) (2d-field-to-chord matrix) (2d-field-to-chord matrix :start 'd4) (2d-field-to-chord matrix :merge-chords t) (2d-field-to-chord matrix :merge-chords t :start 'd4) ;; as a scale (sort-asc (melodize (2d-field-to-chord matrix :merge-chords t))) ;; with rnd-generated field (by probability) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.97) (1 0.03)))))) (2d-field-to-chord matrix)) (progn (setf matrix (loop repeat 32 collect (loop repeat 32 collect (prob-pick '((0 0.99) (1 0.01)))))) (2d-field-to-chord matrix :merge-chords t))