when using vector-smooth my tendencies start around 0.1 but end >0.2 (should be around 0.1 as well)

How can I prevent that?

(setf tend-list
'(0.1 0.4 0.2 0.6 0.5 0.5 0.9 0.7 0.7 1 0.9 1.2 0.9 0.9 0.5 0.5 0.6 0.2 0.2 0.1))

(list-plot
(setf dur-mults
(loop for i in durlens
with seed = (init-seed 123)
collect
(vector-smooth 0.3
(gen-tendency i tend-list :variance 0.2))))
:zero-based t :join-points t)

Thanks for help, Achim

All previous rewrite functions used in conjunction for transformations.

Ciao !

https://opusmodus.com/forums/topic/4097-rewrite-len-function/#comment-14209

(setf expressao-omn '((s eb4 d4 e a4 -s s eb4) (h eb4 a4 -s eb4 d4 -s)

(e. d4 a4 eb4 d4)

(-q e f4 s c5 qs fs4)))

(rewrite-pit

(rewrite-dyn

(rewrite-len expressao-omn

'(h -e s q -h q -q s s s))

'(pp< ff mf fff p < < fff ppp fff mf fff p))

'(c4 g5))

https://opusmodus.com/forums/topic/4097-rewrite-len-function/#comment-14209

Function to rewrite lengths

BEst,

Julio

(defun rewrite-len (expressao-omn new-lengths-list)

"Substitui os comprimentos (lengths) de uma expressão OMN por uma lista fornecida,

repetindo-a ciclicamente e mantendo a estrutura de sublistas original."

(let* ((dis (disassemble-omn expressao-omn)) ;; Desmonta a expressão original [2]

(old-pit (getf dis :pitch)) ;; Extrai as alturas [4]

(old-vel (getf dis :velocity)) ;; Extrai as velocidades [4]

(old-art (getf dis :articulation)) ;; Extrai as articulações [4]

;; 1. Mapeia a estrutura original (quantidade de eventos por sublista)

;; Captura o número de elementos rítmicos em cada compasso [3, 5]

(structure (mapcar #'length (getf dis :length)))

(total-events (apply #'+ structure)) ;; Soma total de eventos [6]

;; 2. Gera a sequência rítmica cíclica com base no total de eventos

;; gen-trim estende a lista do usuário para preencher todos os espaços [3, 7]

(new-flat-lengths (gen-trim total-events new-lengths-list))

;; 3. Re-organiza os novos ritmos na estrutura de sublistas original [3, 8]

(new-structured-lengths (gen-divide structure new-flat-lengths)))

;; 4. Remonta o objeto OMN completo com os parâmetros preservados [3, 4]

(make-omn :pitch old-pit

:length new-structured-lengths

:velocity old-vel

:articulation old-art)))

;;USE

(setf expressao-omn '((s eb4 d4 e a4 -s s eb4) (h eb4 a4 -s eb4 d4 -s)

(e. d4 a4 eb4 d4)

(-q e f4 s c5 qs fs4)))

(omn-to-time-signature (rewrite-len expressao-omn '(h -e s q -h q -q s s s)) '(3 4))

;;RESULT

((h eb4 mf -e s d4 a4 tie) (e. a4 -h s eb4 mf tie) (e. eb4 mf -q s a4 eb4 d4 e eb4 tie) (q. eb4 -e s d4 mf e. a4 tie) (s a4 -h e. f4 mf tie) (s f4 mf -q s c5 fs4))

Here is one more function in the style of the previous one (rewrite-dyn). This time to rewrite pitches.

(defun rewrite-pit (expressao-omn pitch-list)

"Substitui as alturas de uma expressão OMN por uma lista customizada,

fazendo a repetição cíclica se a lista for menor que o número de notas."

(let* ((dis (disassemble-omn expressao-omn)) ;; Desmonta a expressão [3, 6]

(pitches (getf dis :pitch)) ;; Extrai alturas atuais

(lengths (getf dis :length)) ;; Extrai durações (inclui rests) [7]

(velocities (getf dis :velocity)) ;; Extrai dinâmicas [8]

(articulations (getf dis :articulation)) ;; Extrai articulações/ties [9, 10]

;; 1. Mapeia a quantidade de notas em cada sublista/compasso

(counts (mapcar #'length pitches)) ;; [2, 5]

;; 2. Calcula o total de eventos de nota para o preenchimento

(total-notes (apply #'+ (flatten counts))) ;; [2, 11]

;; 3. Gera a lista de novas alturas repetindo o padrão do usuário

(flat-pitches (gen-trim total-notes pitch-list)) ;; [2, 4]

;; 4. Redistribui as alturas na estrutura de sublistas original

(structured-pitches (gen-divide counts flat-pitches))) ;; [2, 5]

;; 5. Remonta o objeto OMN completo preservando os demais parâmetros

(make-omn :pitch structured-pitches

:length lengths

:velocity velocities

:articulation articulations))) ;; [2, 3]

;;USE

(setf expressao-omn '((s eb4 d4 e a4 -s s eb4 tie) (h eb4 a4 -s eb4 d4 -s tie)

(e. d4 a4 eb4 d4)

(-q e f4 s c5 qs fs4)))

Using both rewrite-dyn and rewrite-pit

(rewrite-pit expressao-omn '(c4 e4 d4 c4 c4))

(rewrite-dyn (rewrite-pit expressao-omn '(c4 e4 d4 c4 c4)) '(ff > p p< ff> pp ff p p< ff p mf ppp p < ff))

Best !!

Julio Herrlein

This is a very cool and easy to use function to rewrite dynamics.

Check it out. Hope you like it !

Best,

Julio

(defun rewrite-dyn (expressao-omn dynamic-list)

"Substitui as dinâmicas de uma expressão OMN por uma lista customizada,

fazendo a rotação cíclica se a lista for menor que o número de notas."

(let* ((dis (disassemble-omn expressao-omn)) ; [2, 3]

(pitches (getf dis :pitch))

(lengths (getf dis :length))

(articulations (getf dis :articulation))

;; 1. Mapeia a estrutura de cada sublista (quantidade de notas por compasso)

(counts (mapcar #'length pitches)) ; [6]

;; 2. Calcula o total de notas para gerar dinâmicas suficientes

(total-notes (apply #'+ (flatten counts))) ; [7]

;; 3. Cria a lista plana de dinâmicas repetindo o padrão do usuário [4]

(flat-vels (gen-trim total-notes dynamic-list))

;; 4. Redistribui as dinâmicas na estrutura de sublistas original [5]

(structured-vels (gen-divide counts flat-vels)))

;; 5. Remonta o objeto OMN completo com os novos parâmetros [3]

(make-omn :pitch pitches

:length lengths

:velocity structured-vels

:articulation articulations)))

;; USE

;; Exemplo 1: Dinâmicas simples

(setf expressao-omn '((s eb4 d4 e a4 -s s eb4 tie) (h eb4 a4 -s eb4 d4 -s tie)

(e. d4 a4 eb4 d4)

(-q e f4 s c5 qs fs4)))

(rewrite-dyn expressao-omn '(p mf ff))

;; >> ((s eb4 p d4 mf e a4 ff -s eb4 p tie) (h eb4 mf a4 ff -s eb4 p d4 mf - d4 ff tie) (e. d4 p a4 mf eb4 ff d4 p) (-q e f4 mf s c5 ff qs fs4 p))

;; Exemplo 2: Incluindo crescendos

(rewrite-dyn expressao-omn '(ff > p p< ff> pp ff p p< ff p mf ppp p < ff))

;; ((s eb4 ff d4 > e a4 p -s eb4 p< tie) (h eb4 ff> a4 pp -s eb4 ff d4 p - d4 p< tie) (e. d4 ff a4 p eb4 mf d4 ppp) (-q e f4 p s c5 < qs fs4 ff))

Sometime ago I was here searching for a function to displace rhtyhms by a length amount, not just like a list rotation.

Now I did this prototype. I think that this can be very useful, specially inside counterpoint dictums where patterns can be displaced ( I did not tried inside the counterpoint function but seems like it will work).

Hope it can be useful to you too.

All the best,

Julio

(defun shift-rhythm (rhythm shift-length &key span)

;"Moves rhythmic material by inserting a pause at the beginning.

;Use length-adjust to ensure the result fits within the span."

(let* ((rhy (flatten rhythm))

;;;; Ensures a linear list for processing

;; Adds the offset value as a negative pause at the beginning [5]

(with-offset (append (list (- (abs shift-length))) rhy))

;;Define the target span: either the requested one or the original rhythm.

(target-span (or span (get-span rhythm))))

;; The length-adjust function adjusts the total to the desired span [1].

;; With :position 'e (default), it removes or adds from the end of the list [6].

(length-adjust target-span with-offset :omn t :type 'r)))

;;; USE

;Exemplo 1: Span de 4/4 (1/1)

(setf ideia '(e c5 e d4 q f4 -h)) ;; Span original de 1/1

(shift-rhythm ideia 1/8 :span 3/4)

;; (-e e c5 d4 q f4 -e)

(shift-rhythm ideia 3/8 :span 5/4)

;; (-q. e c5 d4 q f4 -q.)

also with negative displacement

(setf ideia '(-h e c5 e d4 q f4 -h))

(shift-rhythm ideia -1/8 :span 7/4)

;;(-e -h e c5 d4 q f4 -h -e)

It could be perfected to deal with nested sublists and with different displacements for each sublist, like

(setf ideia '((-h e c5 e d4 q f4 -h)(-h e c5 e d4 q f4 -h.)(-h e c5 e d4 q f4 -q))

(shift-rhythm ideia '((-1/8) (2/16) (3/8)) :span 7/4)

etc

I did (with a little help of Notebooklm) this cool function whose function is to concatenate 2 diferent lists with sublists, merging the first sublist of the list A with the first sublist of list B, with the options
1) to choose how many elements of each list to use; and

2) the possibility of not only mix different numbers of elements in each list but also the possibility to select the starting element of the list to pick elements.

3) The function also consider each list as a rotating element: for example, if 5 elements are required from the list (1 2 3), starting in the first element, the result will be (1 2 3 1 2), if the start is on the second element, the result will be (2 3 1 2 3) and so on.

This is useful for me. Hope you like it.

Best,

Julio

(defun get-rotated-elements (lst start count)

"Extracts COUNT elements from LST starting at index START, wrapping around if needed."

(let ((len (length lst)))

(loop for i from 0 below count

collect (nth (mod (+ start i) len) lst))))

(defun merge-rotated-sublists (list-a list-b counts-a counts-b starts-a starts-b)

"Merges sublists from A and B based on specific counts and starting positions with rotation."

(mapcar #'(lambda (sub-a sub-b n m s-a s-b)

(append (get-rotated-elements sub-a s-a n)

(get-rotated-elements sub-b s-b m)))

list-a list-b counts-a counts-b starts-a starts-b))

Example of Usage

(setf list-a '((1 2 3 4) (a b c) (q w e r t)))

(setf list-b '((4 5 6 7) (d e f) (a s d f g)))

(merge-rotated-sublists list-a list-b '(2 1 5) '(1 5 3) '(0 2 2) '(0 0 1))

;; Result: ((1 2 4) (c d e f d e) (e r t q w s d f))

(merge-rotated-sublists list-a list-b '(2 7 1) '(4 3 7) '(0 0 0) '(1 1 0))

;((1 2 5 6 7 4) (a b c a b c a e f d) (q a s d f g a s))

Thanks a lot, Achim

((-w) (-w) (w cs6 <mp> -14c) (w c6 <mp> -31c) (w c6 <mp> -31c) (w c6 <mp> -31c) (w c6 <mp> -31c) (w c6 <mp> -31c) (w cs6 <mp> -49c) (w cs6 <mp> -49c) (w cs6 <mp> -49c) (w cs6 <mp> -49c) (w cs6 <mp> 5c) (w cs6 <mp> 5c) (w cs6 <mp> 5c) (w c6 <mp>) (w c6 <mp> 2c) (w c6 <mp> 2c) (w c6 <mp> 2c) (w c6 <mp> 2c) (w c6 <mp> 5c) (w c6 <mp> 5c) (w c6 <mp> 5c) (w a5 <mp> -31c) (w a5 <mp> -31c) (w a5 <mp> -31c) (w gs5 <mp> -14c))

(harmonics 'a2 8 :quantize nil :type :hertz)

I am getting

(110.0 220.0 329.62756 440.0 546.4174 659.2551 772.751 880.0)

but I am expecting

(110.0 220.0 330.0 440.0 550.0 660.0 770.0 880.0)

What am I understanding wrong?

Best, Achim

Achim

They have been algorithmically created in order to collect all the mathematically possible tonalities:

;; Complete Summary

;; ==============================================================

;; Ditonic‑note scales: 66

;; Tritonic‑note scales: 220

;; Tetratonic‑note scales: 495

;; Pentatonic‑note scales: 792

;; Hexatonic‑note scales: 924

;; Heptatonic‑note scales: 792

;; Octatonic‑note scales: 495

;; Nonatonic‑note scales: 220

;; Decatonic‑note scales: 66

;; Undecatonic‑note scales: 12

;; Total mathematical tonalities: 4082

Once executed, the tonalities are available in Opusmodus. Place the chosen (or both) lisp file(s) into your Extensions Folder.

Here are the starts of the two files:

(in-package :Opusmodus)

;;; ==============================================================

;;; Math‑Tonalities — Complete Output

;;; ==============================================================

;; ditonic‑note tonalities (66 total)

;; ---------------------------------------------------------------

;; Group 01 (starting on 0)

;; ----------------------------------------------

(create-tonality math-ditonic-01-001 '(0 1))

(create-tonality math-ditonic-01-002 '(0 2))

(create-tonality math-ditonic-01-003 '(0 3))

(create-tonality math-ditonic-01-004 '(0 4))

(create-tonality math-ditonic-01-005 '(0 5))

(create-tonality math-ditonic-01-006 '(0 6))

(create-tonality math-ditonic-01-007 '(0 7))

(create-tonality math-ditonic-01-008 '(0 8))

(create-tonality math-ditonic-01-009 '(0 9))

(create-tonality math-ditonic-01-010 '(0 10))

(create-tonality math-ditonic-01-011 '(0 11))

;; Group 02 (starting on 1)

;; ----------------------------------------------

(create-tonality math-ditonic-02-001 '(1 2))

(create-tonality math-ditonic-02-002 '(1 3))

(create-tonality math-ditonic-02-003 '(1 4))

(create-tonality math-ditonic-02-004 '(1 5))

(create-tonality math-ditonic-02-005 '(1 6))

......

(in-package :Opusmodus)

;;; ==============================================================

;;; Math‑Tonalities — Complete Output

;;; ==============================================================

;; Ditonic‑note tonalities (66 total)

;; ---------------------------------------------------------------

;; Group 01 (starting on 0)

;; ----------------------------------------------

(create-tonality math-02-tonic-01-001 '(0 1))

(create-tonality math-02-tonic-01-002 '(0 2))

(create-tonality math-02-tonic-01-003 '(0 3))

(create-tonality math-02-tonic-01-004 '(0 4))

(create-tonality math-02-tonic-01-005 '(0 5))

(create-tonality math-02-tonic-01-006 '(0 6))

(create-tonality math-02-tonic-01-007 '(0 7))

(create-tonality math-02-tonic-01-008 '(0 8))

(create-tonality math-02-tonic-01-009 '(0 9))

(create-tonality math-02-tonic-01-010 '(0 10))

(create-tonality math-02-tonic-01-011 '(0 11))

;; Group 02 (starting on 1)

;; ----------------------------------------------

(create-tonality math-02-tonic-02-001 '(1 2))

(create-tonality math-02-tonic-02-002 '(1 3))

(create-tonality math-02-tonic-02-003 '(1 4))

(create-tonality math-02-tonic-02-004 '(1 5))

(create-tonality math-02-tonic-02-005 '(1 6))

......Math-N-Tonic-Library-Creator.lisp

Math-Tonality-Library-Creator.lisp

With the audio tools in windows can we make some breakbeats, like chopping audio files, like beat slicing and starting in different parts of the audio file, like the video below (serato sample plugin), and also sync accurately with midi parts in Opusmodus ?

All the best !

Julio

SOME HISTORY

Here are some breakbeats (amen sample)

If possible, would be great to includ a sample of the amen beat inside the documentation with an example of breakbeat.

This function can also serve to launch samples of any nature for electroacoustic or mixed music.

Thank you for your help.

(setf accent '((q -q -q )

(e -e -e e -e -e)

(3q -3q -3q 3q -3q -3q 3q -3q -3q)

(s -s -s s -s -s s -s -s s -s -s)

(5q -5q -5q 5q -5q -5q 5q -5q -5q 5q -5q -5q 5q -5q -5q)

(6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q)

(7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q)

(8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q)

(8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q 8q -8q -8q)

(7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q 7q -7q -7q)

(6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q 6q -6q -6q)

(5q -5q -5q 5q -5q -5q 5q -5q -5q 5q -5q -5q 5q -5q -5q)

(s -s -s s -s -s s -s -s s -s -s)

(3q -3q -3q 3q -3q -3q 3q -3q -3q)

(e -e -e e -e -e)

(q -q -q)))

(setf pitacc '(e4 ;(1 notes)

e4 fs4 ;(2 notes)

e4 fs4 g4 ;(3 notes)

e4 fs4 g4 fs4 ;( 4 notes)

e4 fs4 g4 fs4 g4 ;(5 notes)

e4 fs4 g4 fs4 g4 a4 ;(6 notes)

e4 fs4 g4 fs4 g4 a4 g4 ;(7 notes)

e4 fs4 g4 fs4 g4 a4 g4 a4 ;(8 notes)

e4 fs4 g4 fs4 g4 a4 g4 a4 ;(8 notes)

e4 fs4 g4 fs4 g4 a4 g4 ;(7 notes)

e4 fs4 g4 fs4 g4 a4 ;(6 notes)

e4 fs4 g4 fs4 g4 ;(5 notes)

e4 fs4 g4 fs4 ;( 4 notes)

e4 fs4 g4 ;(3 notes)

e4 fs4 ;(2 notes)

e4 ;(1 notes)

))

(setf exo3acc (omn-to-time-signature (make-omn

:length accent

:pitch pitacc)

'(3 4)))

same with def-score

(def-score kona-score

(:title "kona"

:key-signature 'atonal

:time-signature '(3 4)

:tempo 50)

(instrument

:omn exo3acc

:channel 1

:sound 'gm

:program 'acoustic-grand-piano))

I have following questions:

What is "the sine wave corresponding to each note"?

I cannot change the coefficient of higher harmonics since I have only one coefficient argument. What does that mean?

Where can I find the explanation of "coefficients used in music theory"?

Where can I find the "mathematical approach" explained?

Thanks for help.

Achim

Jesper

(defun inf-ser (n &optional (offset 0) &aux tmp)

(loop for i to (1- n) do

(setf tmp 0)

(loop for bin in (decimal-to-binary i)

do

(setf tmp (if (zerop bin) (- tmp) (+ tmp bin))))

;(format t "~B = ~D~%" i tmp)

collect (+ tmp offset)))

(integer-to-pitch (inf-ser 128))

(integer-to-pitch (inf-ser 128 12))

I´m doing a function to extract the complementary set of notes.

For example:

1) Specify a set of notes, like a chord, Dm7

(setf note-list '(d5 f5 a5 c6))

Specify a tonality, like Cmajor or D dorian (same notes)

(expand-tonality '(c5 major))

Now, I want a function that gives me all the other available notes from the mode, except the chord tones (the first set of notes).

So, this function gives me exactly what I need (for ONE tonality at a time and ONE chord at a time):

(let ((rem (expand-tonality '(c5 major)))
      (super (ambitus '(c5 b5) note-list)))
  (loop for i in super
    do (setf rem (remove i rem))
    finally (return rem)))

Ok, this give me the right result, I.E., the complementary set of notes of C major in relation to Dm7

=> (e5 g5 b5)

The question is simple:

How can I do it for a list with many tonalities and many chords. How to do this recursively in nested lists, like

(setf note-list '((d5 f5 a5 c6)(eb4 gb4 bb4 db4)(fs4 as4 cs4)))

to sucessive tonalities, like:

(expand-tonality '((c5 major) (db4 major) (gb4 major)))

Since this WON´T work

(let ((rem (ambitus '(c5 b5) (expand-tonality '((c5 major) (db5 major) (gb5 major)))))
      (super (ambitus '(c5 b5) '((d5 f5 a5 c6)(eb4 gb4 bb4 db4)(fs4 as4 cs4)))))
  (loop for i in super
    do (setf rem (remove i rem))
    finally (return rem)))

The expected result, if the above worked would be:

 ((e5 g5 b5)  (f5 ab5 c5) (gs4 cb5 ds5))

Thanks in advance !!

Best !

Julio

Here is a proto-function idea... If Janusz or someone are interested in transform it in a core function, I think it could be interesting...

Sometimes I like to take a motive or chorale texture and use it to make a kind of accompaniment or texture ala Reich.

I created my way to do it, but it could be perfected in a better function and integrated in the core system.

Here is the idea:

;; Motive

(setf mat '(h c4 q. d4 e e4 -q w c4 h d4 q e4 -q))

;; small value

(setf fig-value '(e))

The "proto-function". What I could not achieve was how to make it respect the rests in the motive, but it works for generating the texture, respecting the pitch and length boundaries of the motive.

(flatten (make-omn

:pitch (omn :pitch (omn-to-time-signature mat (get-time-signature (omn-to-measure (length-legato mat) (flatten (length-legato (omn :length mat)))))))

:length (omn-to-time-signature

(length-span (get-span mat)

(gen-repeat 200 fig-value))

(get-time-signature (omn-to-measure (length-legato mat) (flatten (length-legato (omn :length mat))))))

))

RESULT

(e c4 mf c4 c4 c4 e d4 mf d4 d4 e e4 mf e4 e4 e c4 mf c4 c4 c4 c4 c4 c4 c4 e d4 mf d4 d4 d4 e e4 mf e4 e4 e4)

It could be perfected to result this:

(e c4 mf c4 c4 c4 d4 d4 d4 e4 -q e c4 c4 c4 c4 c4 c4 e c4 c4 d4 mf d4 d4 d4 e4 e4 -q)

Same texture with the fig-value set do 16th note

(setf fig-value '(s))

Best wishes,

Julio

I found a function that is missing documentation: 2d-matrix->linearized-upper-trangular. Would you mind explaining this briefly? I hope to see the documentation added to the next update.

Thanks!

For the composers and musicians among you following might seem trivial, so this post is probably only relevant for beginners like me (except for the question at the end of the post)

But for me it's all new and exploring and discovering new concepts is fascinating.

OM helps me a lot as learning tool to conceptualize and reuse in a principled, reproducible manner.

In Jazz for piano comping, the use of rootless shell-voicings is common as far as I have learned.

I have learned in a text book (Jeremy Siskind, Jazz Band Pianist), that typically for chord comping

• the bass pitch is removed as it's already covered by the bass player, see a question on that to community at the end of this post.

• the left hand plays the "essential tones" of the chord, which are 3rd and 7th

• the right hand plays the "color tones" of the chord, which are the 5th and 9th.

I have learned that there 2 types of voicings

• Type A: left-hand: 3rd below 7th; right-hand: 9th below 5th

• Type B is flipped version, so left-hand: 7th below 3rd; right-hand: 5th below 9th.

Here's a screenshot of the book were both voicings are demonstrated for 3 chords.

Now I have tried to reproduce this with OM and want to share my findings in this post.

Turns out, that

• Type A: is accomplished with drop-voicing :type '(2) :leading '(l)

• Type B: is accomplished with drop-voicing :type '(2) :leading '(h)

• and in both cases then splitting the chord to both hands with (split-chord 13 <> :lower-size 2 :upper-size 2)

Here's the code to reproduce the text book example:

(asdf:load-system :arrows)


(setf chord '((w (e3 m9))   ; e3g3b3d4fs4
              (w (d3 9))    ; d3fs3a3c4e4
              (w (bb2 maj9)); bb2d3f3a3c4
              ))

; Type A voicing
(setf chord-voiced-a
      (arrows:-<>
       ; remove bass from 5 note chord
       (loop for n in (reverse '(1 2 3 4))
        collect (pitch-demix n chord))
       (matrix-transpose)
       (mapcar 'pitch-mix <>)
       ; restore original length
       (omn-replace :length (omn :length chord) <>)
       ; voice-leading type a
       (drop-voicing :type '(2) :leading '(l))
       ; distribute to both hands
       (split-chord 13 <> :lower-size 2 :upper-size 2)
       ))


; Type B voicing
(setf chord-voiced-b
      (arrows:-<>
       ; remove bass from 5 note chord
       (loop for n in (reverse '(1 2 3 4))
        collect (pitch-demix n chord))
       (matrix-transpose)
       (mapcar 'pitch-mix <>)
       ; restore original length
       (omn-replace :length (omn :length chord) <>)
       ; voice-leading type a
       (drop-voicing :type '(2) :leading '(h))
       ; distribute to both hands
       (split-chord 13 <> :lower-size 2 :upper-size 2)
       ))

(setf rh-a (assemble-voices 1 chord-voiced-a))
(setf lh-a (assemble-voices 2 chord-voiced-a))
(setf rh-b (assemble-voices 1 chord-voiced-b))
(setf lh-b (assemble-voices 2 chord-voiced-b))

(ps 'gm 
    :title "Type A"
    :p (list rh-a lh-a))

(ps 'gm 
    :title "Type B"
    :p (list rh-b lh-b))

Result:

Question to community:

Are there smarter ways to remove the root pitch in a omn-notation chord-sequence like the one I defined in variable chord (which just drops the lowest pitch while retaining the other omn parameters like length from original) ?

Thanks for any hints.

I am taking my first steps into Opus Modus, and it is a big change from using Open Music. I'm trying not to miss the visual environment, which has always worked better for my brain, but there are definitely growing pains along the way.

I am trying to complete a fairly simple task, but I just cannot figure out which functions allow me to do so. I want to complete the following;

• Create a list B of length n and fill that list with elements randomly selected from list A.

  If list A contains ((1 2) (3 4) (5 6) (7 8) (9 0))

  And list B is length 2;

  We should be able to generate list B that contains two selections of those tuples now in their own list

  • Ex; A = ((3 4) (9 0))

I am attempting to create a sublist that selects from a pool of PC-sets, which I will then further modify. I plan to split each selected chord into two groups using gen-divide, which I have successfully implemented on a hardcoded set of chords.

I have drafted the following. However, substitute-map does not behave how I expected it to.

(setf set_1 '(0 1 3 5 7))

(setf permutes (permute set_1))

(substitute-map 'permutes '(0 1 2 3) (rndn 5 1 (length permutes)))

Additionally, I have found gen-loop, which does almost exactly what I want. However, as it loops the random selection, there is the possibility for it to select the same choice twice. Is there a way to avoid this? That is why, rather than looping a random selector, I wanted to just pick a set amount from my established list.

(gen-loop 5

(rnd-pick permutes)

)

=> ((7 5 3 1 0) (7 5 1 0 3) (1 5 0 3 7) (7 5 1 0 3) (0 5 7 1 3))

Thanks in advance!

The function closest-path is documented to voice-lead chords, which already in my view is a great use-case.

But do you know that it also helps to get a cohesive monophonic line from otherwise pretty scattered pitch collection as its often the result of a stochastic generation processes ?

Most of you will know this already, having a musician background and it might feel trivial (the mere name voice-leading already indicates it).

So I am writing this more to share my surprise and learning for those coming rather from „outside“.

I was so nudged by the docu which covers chords, so that I did not recognize that its highly generalizing.

Example:

;; Random noise
(setf vector (gen-noise 32 :seed 42))

;; Map to 3 Octaves
,; OK I am making this up, its just an example, 
;; showing what one can expect for stochastic material.

(setf pitch-mat (vector-to-pitch '(c3 c6) vector))
(pitch-list-plot pitch-mat)

With closest-path :

;; Voice leading also for melodies :-)
(setf pitch-mat-vl (closest-path pitch-mat))
(pitch-list-plot pitch-mat-vl)

• helps to prepare a binary-list for driving a do-timeline to play/pause solo-instruments with occasional multiplay,

• where a couple of constraints like probability and max multplay can be defined

• and one of many possible solutions is returned.

I tried with help of chat-gpt to code to do this.

Although tests look plausible I believe this is not a well coded function (robustness, edge cases, seed handling, etc).

Any thoughts ?

;;;
;;; n solo-instruments play in a band for l periods
;;; the ratio of multiplay is defined by r
;;; max-n instruments can play together
;;;
;;; Function which supports definition
;;; of binary list which can be passed to do-timeline
;;;


(defun gen-binary-solo (n l r max-n)
  "Generate a n binary sublists for n instruments.
   Each sublist has length l.
   Ratio r defines probaility for multiplay.
   Number max-n defined maximun allowed number 
   of instruments playing together."
  ;; validations
  (unless (and (integerp n) (>= n 1) (<= n 4))
    (error "n must be an integer between 1 and 4 inclusive"))
  (unless (and (integerp l) (> l 0))
    (error "l must be a positive integer"))
  (unless (and (numberp r) (>= r 0.0) (<= r 1.0))
    (error "r must be a number between 0 and 1"))
  (unless (and (integerp max-n) (>= max-n 1) (<= max-n n))
    (error "max-n must be integer between 1 and n"))

  (let* ((max-k (min max-n n))
         (multi-count (if (< max-k 2) 0 (round (* r l))))
         ;; indices 0..l-1
         (indices (loop for i from 0 below l collect i))
         ;; choose exactly multi-count distinct positions (partial Fisher-Yates)
         (multi-positions
          (let ((vec (coerce indices 'vector)))
            (loop for i from 0 below multi-count do
                  (rotatef (aref vec i)
                           (aref vec (+ i (random (- l i))))))
            (loop for i below multi-count collect (aref vec i))))
         (multi-hash (let ((h (make-hash-table :test 'eql)))
                       (dolist (pos multi-positions) (setf (gethash pos h) t))
                       h))
         ;; rows as arrays for efficient setting
         (rows (loop repeat n collect (make-array l :initial-element 0)))
         (min-k 2))

    ;; build columns for each time index
    (loop for time-idx from 0 below l do
          (let* ((is-multi (gethash time-idx multi-hash))
                 (k (if is-multi
                        (if (<= max-k min-k) min-k
                            ;; uniform integer in [2..max-k]
                            (+ min-k (random (1+ (- max-k min-k)))))
                        1))
                 ;; choose k distinct instruments (simple partial pick)
                 (available (loop for i below n collect i))
                 (chosen
                  (loop repeat k
                        for pick = (nth (random (length available)) available)
                        do (setf available (remove pick available))
                        collect pick)))
            (dolist (inst chosen)
              (setf (aref (nth inst rows) time-idx) 1))))

    ;; convert arrays back to lists and return
    (mapcar #'(lambda (arr) (coerce arr 'list)) rows)))


;; Tests

(gen-binary-solo 4 8 1 2)
=> ((1 1 1 0 0 1 1 0) 
    (1 1 0 0 0 0 0 0) 
    (0 0 0 1 1 1 0 1) 
    (0 0 1 1 1 0 1 1))

(gen-binary-solo 4 8 0 1)
=> ((1 0 1 0 0 0 0 0) 
    (0 1 0 1 0 0 1 1) 
    (0 0 0 0 1 0 0 0) 
    (0 0 0 0 0 1 0 0))


(gen-binary-solo 4 8 0.5 2)
=> ((1 0 0 0 1 1 0 0) 
    (0 1 0 0 0 0 1 1) 
    (0 0 1 1 0 0 1 1) 
    (0 1 0 1 0 0 0 0))

(gen-binary-solo 4 8 0.7 3)
=> ((1 0 0 0 1 0 1 0) 
    (1 1 1 1 1 0 1 0) 
    (0 0 0 0 0 1 1 1) 
    (1 1 1 0 0 0 0 1))

(gen-binary-solo 4 8 0.1 3)
=> ((0 0 0 0 0 1 0 0) 
    (0 1 0 1 0 0 1 1) 
    (1 0 1 0 1 0 0 0) 
    (0 0 1 0 0 0 0 0))

According to LCCOTO chords which are derived from a parent scale have a nice property as they all lean on the same lydian parent-scale- tonic, hence may feel similar in harmonic environment.

This may be used for various compositional purposes.

Example:

A G7 -> Cmaj7 cadence is in LCCOTO basically a movement of F-lydian-parent-scale-tonic to C-lydian-parent-scale-tonic.

Moving clockwise on circle of fifths with regards to parent scales tonic.

G7 is a chord on mode 2 in f-lydian.

Cmaj7 is chord on mode 1 in c-lydian.

According to LCCOTO it should be possible to exchange G7

by various other chords as long as they are derived from F-lydian parent scale or derived ones, like F-lydian augmented, etc.

For that a function I called "find-chord-in-parent-scale" may be useful.

New function

;;; ---------------------------------------------------------------------------
;;;
;;; Find chord in a parent scale according to LCCOTO 
;;; for a list of chords quality symbols and a list of parent scales
;;;
;;;   Conceptual framework: 
;;;   Lydian Chromatic Concept of Tonal Organization, LCCOTO
;;;   by George Russell, 1953, Concept Publishing Company) 
;;;
;;; This function helps to get all possible chords in a parent scale
;;; given their quality, i.e. maj, m7, sus2, 7, etc.
;;; Parameter "quality" must be a list with elemens which comply to OMs 
;;; definition of chord-symbols (see docu chord-symbols.pdf).
;;;
;;; The parameters scale and quality are lists.
;;; The return value is a nested list.
;;;
;;; Version 1, 2025-11-17
;;; Author: Cliff Scherer
;;;
;;;
;;; v1: initial version
;;; 
;;; ---------------------------------------------------------------------------


(defun find-chord-in-parent-scale (scale quality)
  "Find chords in a list of parent scales and a list of chord qualities"
  
  ;; Main function for one scale
  (defun find-chord-in-parent-scale-one-scale (scale quality)
  
    ;; Main function for one chord quality
    (defun find-chord-in-parent-scale-one-chord (scale quality)
      "Find chords in one parent scale for one chord quaity"

      ;; We use the lydian parent-scale with lydian tonic c
      (setf parent-scale (flatten  scale))
      (setf parent-scale-pcs (get-pcs (expand-tonality parent-scale)))

      ;; Next we define a chord symbol
      (setf chord-symbol quality)

      ;; Prepare all possible chords for symbol and pcs of scale
      (setf chord-symbol-candidates (cartesian 
                               (list (integer-to-pitch parent-scale-pcs) 
                                     chord-symbol)))

      ;; Get their PC
      (setf chord-pc-candidates (get-pcs (expand-chord chord-symbol-candidates)))

      ;; Test for intersection
      (setf test-intersect-pc (mapcar (lambda (x) (intersection x parent-scale-pcs))
                                      chord-pc-candidates))

      ;; Test for full intersection
      (setf chord-size (length (first chord-pc-candidates)))
      (setf test-intersect-pc-complete (mapcar (lambda (x) 
                                                 (equal (length x) chord-size))
                                               test-intersect-pc))

      ;; Return chord symbols
      (setf result (remove nil
                           (loop for test in test-intersect-pc-complete
                                 for chord in chord-symbol-candidates
                                 collect (if test chord nil))))

      result

      )

    (mapcar (lambda (x) (find-chord-in-parent-scale-one-chord scale x)) quality)

    )

  (mapcar (lambda (x) (find-chord-in-parent-scale-one-scale x quality)) scale)

  )



;; Tests ---
;;

(find-chord-in-parent-scale '((c lydian)) '((maj)))
;; ((((c4 maj) (d4 maj) (g4 maj))))

;; Use of the nested list result may require use of (multiple) flatten-sublist calls
(expand-chord (flatten-sublist (find-chord-in-parent-scale '((c lydian)) '((maj)))))
;; ((c4e4g4 d4fs4a4 g4b4d5))

(find-chord-in-parent-scale '((c lydian)) '((maj)(m7)))
;; (
;;  ( -> for scale
;;   ((c4 maj) (d4 maj) (g4 maj)) -> for first quality
;;   ((e4 m7) (a4 m7) (b4 m7)) -> for second quality
;;  )
;; )

;; Use
(expand-chord (flatten-sublist (find-chord-in-parent-scale '((c lydian)) '((maj)(m7)))))
;; ((c4e4g4 d4fs4a4 g4b4d5) (e4g4b4d5 a4c5e5g5 b4d5fs5a5))


(find-chord-in-parent-scale '((f lydian)(c lydian)) '((maj)(m7)))
;; (
;;  ( -> for first scale
;;   ((f4 maj) (g4 maj) (c4 maj)) -> for first quality
;;   ((a4 m7) (d4 m7) (e4 m7)) -> for second quality
;;  ) 
;;  ( -> for second scale
;;   ((c4 maj) (d4 maj) (g4 maj)) -> for first quality
;;   ((e4 m7) (a4 m7) (b4 m7)) -> for second quality
;;  )
;; )



;; Experiments to exchange G7 in V7->Cmaj7 ---

;; First the original -
(assemble-seq 
 (flatten-sublist (flatten-sublist  (find-chord-in-parent-scale '((f lydian)) '((7)))))
 '(c4 maj7))
;; ((g4 7) (c4 maj7))


;; Try m7 -
(assemble-seq 
 (first (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian)) '((m7))))))
 '(c4 maj7))
;; ((a4 m7) (c4 maj7))

(assemble-seq 
 (second (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian)) '((m7))))))
 '(c4 maj7))
;; ((d4 m7) (c4 maj7))

(assemble-seq 
 (third (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian)) '((m7))))))
 '(c4 maj7))
;; ((e4 m7) (c4 maj7))

;; Try maj7 -
(assemble-seq 
 (first (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian)) '((maj7))))))
 '(c4 maj7))
;; ((f4 maj7) (c4 maj7))

(assemble-seq 
 (second (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian)) '((maj7))))))
 '(c4 maj7))
;; ((c4 maj7) (c4 maj7)) :-)

;; Try dim7 -
(assemble-seq 
 (first (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian-diminished)) '((dim7))))))
 '(c4 maj7))
;; ((f4 dim7) (c4 maj7))

(assemble-seq 
 (second (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f lydian-diminished)) '((dim7))))))
 '(c4 maj7))
;; ((gs4 dim7) (c4 maj7))

;; Try 7/b5 -
(assemble-seq 
 (first (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f whole-half-tone-scale)) '((7/b5))))))
 '(c4 maj7))
;; ((g4 7/b5) (c4 maj7))

(assemble-seq 
 (second (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f whole-half-tone-scale)) '((7/b5))))))
 '(c4 maj7))
;; ((bb4 7/b5) (c4 maj7))

(assemble-seq 
 (third (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f whole-half-tone-scale)) '((7/b5))))))
 '(c4 maj7))
;; ((cs4 7/b5) (c4 maj7))


(assemble-seq 
 (fourth (flatten-sublist (flatten-sublist (find-chord-in-parent-scale '((f whole-half-tone-scale)) '((7/b5))))))
 '(c4 maj7))
;; ((e4 7/b5) (c4 maj7))


;; Stay inside similar parent scales with same tonic but vary the chord quality ---
;; See chord pregression below
(assemble-seq
 (find-chord-in-parent-scale '((f lydian)) '((maj7)(7/sus4)))
 (find-chord-in-parent-scale '((f lydian-augmented)) '((maj7)(aug)(m7)))
 (find-chord-in-parent-scale '((f lydian-diminished)) '((dim7)(aug)(m7)))
 (find-chord-in-parent-scale '((f lydian-b7)) '((m7)(7)(7/b5))))

Here's a first attempt (I am a LISP beginner) for a function which finds the parent scale for a list of chords.

;;; ---------------------------------------------------------------------------
;;;
;;; Find a Lydian Parent Scale for a Melody over a given chord list
;;;
;;; (Lydian Chromatic Scale Concept, George Russell) 
;;;
;;;   The returned list fulfills the condition that all chord pitches
;;;   are included in the scales.
;;;
;;;   By default only the 12 lydian scales are queried.
;;;   One can supply additional scales according to Russells concept. 
;;;   In case of ambiguities the scale which lowest tonal gravity is chosen.
;;;   
;;;
;;; Version 1, 2025-11-14
;;; Author: Cliff Scherer
;;;
;;; ---------------------------------------------------------------------------

(defun find-lydian-scale (chords &key (scales '(lydian)))
  
  "Find lydian parent scale for a list of chords"

  ;; Main function
  (defun find-lydian-scale-one-chord (chord scales)
    "Find lydian parent scale for one chord"

    ;; Define chord to play over
    (setf my-chord (flatten (get-pcs chord)))

    ;; Define all possibe parent scale candidates for testing
    (setf all-lydian-scales (cartesian (list '(c db d eb e f fs g gs a b bb)
                                             scales)))

    ;; Create PCS for those scales
    (setf all-lydian-pcs (get-pcs all-lydian-scales))

    ;; Create tuples for next step
    (setf test-pairs (mclist all-lydian-pcs 
                             (gen-repeat (length all-lydian-pcs) 
                                         (list my-chord))))

    ;; Query Intersection of these pairs, return PC which are common
    (setf test-intersect-pc (mapcar (lambda (x) 
                                      (intersection (first x) 
                                                    (second x)))
                                    test-pairs))


    ;; Query length of intersection; returns length
    ;; The scale with maximum overlap are good candidates
    ;; But one may further narrow down by checking which PC generates overlap
    (setf test-intersect-length (mclength test-intersect-pc))

    ;; Query which lydian principle scale has full intersetion
    ;; will be used as mask later
    (setf test-intersect-pc-complete (mapcar (lambda (x)
                                               (equal x (length my-chord)))
                                             test-intersect-length))

    ;; Create tuples for next step
    (setf test-pairs (mclist test-intersect-pc all-lydian-pcs))

    ;; Query the positions of common notes in the lydian scales
    ;; low values like 1 indicate close to total gravity
    (setf test-intersect-pos (loop for (a b) in test-pairs
                                   collect
                                     (loop for x in b
                                           for pos from 1
                                           when (member x a :test #'equal)
                                             collect pos)))

    ;; Sum the positions
    ;; low values should be preferred, provided...
    (setf test-intersect-pos-sum (mapcar (lambda (x)
                                           (sum x))
                                         test-intersect-pos))

    ;; Return the sums but only for scales which have complete intersection
    (setf test-intersect-pos-sum-masked
          (loop for m in test-intersect-pc-complete
                for n in test-intersect-pos-sum
                collect (if m n nil)))

    ;; Position of best scale
    (setf test-intersect-pos-sum-masked-pos
          (let* ((clean (remove nil test-intersect-pos-sum-masked))
                 (minval (when clean (apply #'min clean))))
            (loop for x in test-intersect-pos-sum-masked
                  for i from 0
                  when (equal x minval)
                    collect i)))

    ;; Finally prepare return value the symbolic name of the parent scale
    (setf result (mapcar (lambda (x)
                        (nth x all-lydian-scales))
                      test-intersect-pos-sum-masked-pos))

    (if (= 0 (length (remove nil test-intersect-pos-sum-masked)))
        (setf result '(nil)))

    result
       
    )

    (mapcar (lambda (x) (find-lydian-scale-one-chord x scales)) chords)
)

In the following a couple of tests:

;;; ----- Tests ------

;;; Ingoing ------
;;;


(setf chord '(c3e3g3))
(find-lydian-scale chord)
;; (((c lydian)))

(setf chord '((c maj)))
(find-lydian-scale chord)
;; (((c lydian)))

(setf chord '((c maj7)))
(find-lydian-scale chord)
;; (((c lydian)))

(setf chord '((d m7)))
(find-lydian-scale chord)
;; (((f lydian)))

(setf chord '((g 7)))
(find-lydian-scale chord)
;;(((f lydian)))

(setf chords '((c maj7)(d m7)(g 7)))
(find-lydian-scale chords)
(((c lydian)) ((f lydian)) ((f lydian)))

(setf chords '((d m7/b5)))
(find-lydian-scale chords)
;; (((gs lydian)))

(setf chord '((c 6)))
(find-lydian-scale chord)
;; (((c lydian)))

(setf chord '((d dim7)))
(find-lydian-scale chord)
;; ((nil))

(setf chord '((c aug)))
(find-lydian-scale chord)
;; ((nil))


;;; Allow more scales outgoing ------
;;;

;; According to George Russell 
(setf extended-lydian-principal-scales '(lydian 
                                         lydian-augmented
                                         lydian-diminished
                                         lydian-b7))

(setf chord '((d m7)))
(find-lydian-scale chord :scales extended-lydian-principal-scales)
;; (((f lydian) (f lydian-b7)))

(setf chord '((d dim7)))
(find-lydian-scale chord :scales extended-lydian-principal-scales)
;; (((d lydian-diminished) (f lydian-diminished) (gs lydian-diminished) (b lydian-diminished)))

(setf chord '((c aug)))
(find-lydian-scale chord :scales extended-lydian-principal-scales)
;; (((c lydian-augmented) (e lydian-augmented) (gs lydian-augmented)))



;;; Allow all including outgoing ------
;;;

;; According to George Russell 
(setf all-lydian-principal-scales '(lydian 
                                    lydian-augmented
                                    lydian-diminished
                                    lydian-b7
                                    whole-tone
                                    whole-half-tone-scale
                                    half-whole-tone-scale))

(setf chord '(c3e3g3))
(find-lydian-scale chord :scales all-lydian-principal-scales)
;; (((c lydian) (c lydian-b7)))

(setf chord '((d m7)))
(find-lydian-scale chord :scales all-lydian-principal-scales)
;; (((c whole-half-tone-scale) (a whole-half-tone-scale)))

(setf chords '((d m7/b5)))
(find-lydian-scale chords :scales all-lydian-principal-scales)
;; (((c whole-half-tone-scale)))

(setf chords '((d dim7)))
(find-lydian-scale chords :scales all-lydian-principal-scales)
;; (((d lydian-diminished) (f lydian-diminished) (gs lydian-diminished) (b lydian-diminished)))

Musical examples:

LCC1-A:

LCC1-B:

LCC1-C:

LCC1-D:

LCC1-A.aifLCC1-B.aifLCC1-C.aifLCC1-D.aif

Details:

;;;
;;; LCC1-A
;;;
;;; Basic only Lydian as parent scale candidate
;;;

;; Prepare some melody
(setf melody-pitch-mat (vector-to-pitch
                        '(c5 e6)
                        (vector-smooth 0.5 (gen-noise 64 :seed 41))))

(setf melody-omn (make-omn
                  :pitch melody-pitch-mat
                  :length (rhythm-series 4 9 4/4 :length '(q e) :seed 22807)
                  :velocity (gen-loop 4 (rnd-sample 4 '(mp mf p f)) :seed 41
                                      )))

;; ii-V-I Chordprogression
;;
(setf chords-omn '(w (a m7) mf
                   w (d m7)
                   w (g 7)
                   w (c maj7)))
(setf chords (omn :pitch chords-omn))
(setf chords-omn-mod (density 0.1 chords-omn :seed 40540))
(setf bass (density 0.18 (pitch-transpose -24 
                            (dechord chords-omn))
                    :seed 41))

;; Find Parent scales
(setf lydian-principal-scales (find-lydian-scale chords))
;; (((c lydian)) ((f lydian)) ((f lydian)) ((c lydian)))

;; Commit to one scale per chord in case on multiple options
(setf lydian-principal-scales-picked (rnd-pick lydian-principal-scales 
                                               :type 'list))
;; ((c lydian) (f lydian) (f lydian) (c lydian))

;; Apply scales tonality to melody
(setf t-map (tonality-series lydian-principal-scales-picked
                             :map 'octave))
(setf melody-t-mapped (filter-tie (tonality-map t-map  melody-omn)))

;; Preview
(ps 'gm
    :tempo 90
    :p (list melody-t-mapped (closest-path chords-omn-mod))
    :bass (list bass))

;;;
;;; LCC1-B
;;;
;;; Bit more Outgoing
;;;

;; Find Parent scales
(setf lydian-principal-scales (find-lydian-scale chords
                                                 :scales '(lydian
                                                           lydian-augmented
                                                           lydian-diminished
                                                           lydian-b7
                                                           whole-tone
                                                           )))
;; (((c lydian) (c lydian-b7)) 
;; ((f lydian) (f lydian-b7)) 
;; ((f lydian) (f lydian-augmented) (f lydian-diminished) (f lydian-b7)) 
;; ((c lydian)))


;; Commit to one scale per chord in case on multiple options
(setf lydian-principal-scales-picked (rnd-pick lydian-principal-scales 
                                               :type 'list :seed 229792))
;; ((c lydian-b7) (f lydian) (f lydian-b7) (c lydian))

;; Apply scales tonality to melody
(setf t-map (tonality-series lydian-principal-scales-picked
                             :map 'octave))
(setf melody-t-mapped (filter-tie (tonality-map t-map melody-omn )))

;; Preview
(ps 'gm
    :tempo 90
    :p (list melody-t-mapped (closest-path chords-omn-mod))
    :bass (list bass))

;;;
;;; LCC1-C
;;;
;;; Even more Outgoing
;;;

;; Find Parent scales
(setf lydian-principal-scales (find-lydian-scale chords
                                                 :scales '(lydian-augmented
                                                           lydian-diminished
                                                           lydian-b7
                                                           )))
;; (((c lydian-b7)) 
;; ((f lydian-b7)) 
;; ((f lydian-augmented) (f lydian-diminished) (f lydian-b7)) 
;; ((f lydian-diminished)))



;; Commit to one scale per chord in case on multiple options
(setf lydian-principal-scales-picked (rnd-pick lydian-principal-scales 
                                               :type 'list :seed 1))
;; ((c lydian-b7) (f lydian-b7) (f lydian-diminished) (f lydian-diminished))

;; Apply scales tonality to melody
(setf t-map (tonality-series lydian-principal-scales-picked
                             :map 'octave))
(setf melody-t-mapped (filter-tie (tonality-map t-map melody-omn )))

;; Preview
(ps 'gm
    :tempo 90
    :p (list melody-t-mapped (closest-path chords-omn-mod))
    :bass (list bass))

;;;
;;; LCC1-D
;;;
;;; Custom scales
;;;

;; Find Parent scales
(setf lydian-principal-scales (find-lydian-scale chords
                                                 :scales '(lydian
                                                           minor-hexatonic
                                                           mixolydian-hexatonic
                                                           )))
;; (((g mixolydian-hexatonic)) 
;; ((c mixolydian-hexatonic)) 
;; ((f lydian)) 
;; ((c lydian) (d mixolydian-hexatonic) (a minor-hexatonic)))


;; Commit to one scale per chord in case on multiple options
(setf lydian-principal-scales-picked (rnd-pick lydian-principal-scales 
                                               :type 'list :seed 229792))
;; ((g mixolydian-hexatonic) (c mixolydian-hexatonic) (f lydian) (d mixolydian-hexatonic))

;; Apply scales tonality to melody
(setf t-map (tonality-series lydian-principal-scales-picked
                             :map 'octave))
(setf melody-t-mapped (filter-tie (tonality-map t-map melody-omn )))

;; Preview
(ps 'gm
    :tempo 90
    :p (list melody-t-mapped (closest-path chords-omn-mod))
    :bass (list bass))

LCC1-A.aif

Is there a complete list of chords already included in OM? I would like to write, for example, am7b5/maj7 (a c eb g#), but it doesn't work.

Thank you for your help.