Opusmodus 1.3.24952

opmo · August 14, 2019

– Function name changes:

LENGTH-DIVIDE2 to LENGTH-SUBDIVISION
LENGTH-DIVIDE3 to LENGTH-SYNCOPATE

– Function update:
LENGTH-DIVIDE – changes to arguments.
LENGTH-SUBDIVISION – changes to arguments.
LENGTH-SYNCOPATE – changes to arguments.
POLYGON-RHYTHM – enable fixed sides polygon.

– Note:
If you used any of the functions:
LENGTH-DIVIDE, LENGTH-DIVIDE2 or LENGTH-DIVIDE3 in your scores,
please check new documents in order to make the necessary correction.

– New:
Enable or disable the DO-VERBOSE macro.

(defparameter *do-verbose* nil
 "Enable or disable traces printed by do-verbose.")

length-divide

This function is able to divide number of lengths to a given division value. The :set and :ignore option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions.

(setf rhy '(1/4 1/4 1/4 1/4))

(length-divide '(2 2) rhy)
=> (1/8 1/8 1/4 1/4 1/8 1/8)

(length-divide '(2 4) rhy)
=> (1/4 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/4)

Example:

(length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34)
=> (1/4 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/8 1)

In the example above only 1 length is divided by 2 - that is the 1/16. In the example below 4 lengths are divided by 2.

(length-divide '(4 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34)
=> (1/8 1/8 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/16 1/16 1/2 1/2)

(length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1)
               :set 'min :seed 34)
=> (1/4 -1/8 1/32 1/32 1/16 -1/32 -3/32 1/8 1)

(length-divide '(1 4) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1)
               :set 1/8 :seed 34)
=> (1/4 -1/8 1/16 1/16 -1/32 -3/32 1/32 1/32 1/32 1/32 1)

(length-divide '((2 3) (1 2)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1))
               :ignore 'max :seed 45)
=> ((1/4 -1/8 1/48 1/48 1/48 1/48 1/48 1/48)
    (1/64 1/64 -3/32 1/8 1))

(length-divide '((2 4) (1 2)) '((q -e s s) (s -e. e w))
               :set 'max :ignore 1 :seed 65)
=> ((1/16 1/16 1/16 1/16 -1/8 1/16 1/64 1/64 1/64 1/64)
    (1/16 -3/16 1/16 1/16 1))

OMN:

(setf mat1 '(q c4 d4 e4 f4 g4 a4 b4))

(length-divide '(3 4) mat1 :seed 45)
=> (s d4 bb3 cs4 b3 cs4 eb4 c4 e4 q s g4 e4 eb4 fs4 q g4 a4 b4)

Symbol 'r will apply repeat function:

(length-divide '(3 4 r) mat1 :seed 45)
=> (s c4 c4 c4 c4 d4 d4 d4 d4 q e4 s f4 f4 f4 f4 q g4 a4 b4)

Here we use a set of interval values at the end of the division list:

(length-divide '(3 4 (13 0 1 13)) mat1 :seed 45)
=> (s cs5 c4 cs4 cs5 eb5 d4 eb4 eb5 q e4 s fs5 f4 fs4 fs5 q g4 a4 b4)

(setf mat2 '((e c4 p e4 mp g4 he c5 p)
             (q c4 f c4 cs4 mp - d5 p d5)
             (q cs5 mf = - - cs5 p =)))

(length-divide '((1 4) (2 4) (2 5)) mat2 :seed 34)
=> ((e c4 p e4 mp t a4 f4 gs4 fs4 he c5 p)
    (q c4 f s b3 cs4 bb3 d4 q cs4 mp - d5 p s c5 e5 cs5 eb5)
    (q cs5 mf cs5 - - 5q eb5 p b4 c5 d5 eb5 c5 eb5 b4 d5 c5))

In the example below we assign three series of division values to variables s1, s2 and s3:

(setf
 s1 '(3 4 (6 12 18 24))
 s2 '(3 4 ((13 1 13 0) (13 0 7 1) r))
 s3 '(2 5 ((13 0 13 0 13) ?))
 )

(length-divide (list s1 s2 s3) mat2 :seed 34)
=> ((e c4 p t bb4 mp e5 bb5 e6 cs5 g5 cs6 g6 et fs5 p c6 fs6 c7)
    (q c4 f s cs5 cs4 cs5 c4 q cs4 mp - s eb6 p d5 a5 eb5 d5 d5 d5 d5)
    (5q d6 mf cs5 d6 cs5 d6 q cs5 - - cs5 p 5q d5 eb5 c5 b4 d5))

length-subdivision

This function is able to divide a list of lengths into a number of subdivisions derived from a given length segment value. The :type and :position option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions. This function is a more sophisticated version of LENGTH-DIVIDE. It produces fascinating variants on the simplest of note-lengths, as can be seen below.

(setf rhy '(1/4 1/4 1/4 1/4))

(length-subdivision '(2 1/8) rhy)
=> (1/8 1/8 1/8 1/8 1/8 1/8 1/8 1/8)

position 's (start):

(length-subdivision '(2 1/16) rhy :position 's)
=> (1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8)

position 'e (end):

(length-subdivision '(2 1/16) rhy :position 'e)
=> (1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16)

type 'r (rest), position 'e (end):

(length-subdivision '(2 1/16) rhy :type 'r :position 'e)
=> (-1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16)

type 'r (rest), position 's (end):

(length-subdivision '(2 s) rhy :type 'r :position 's)
=> (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8)

type at random, rest or note :

(length-subdivision '(2 s) rhy :type '? :position 's)
=> (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 1/8)

position and type at random:

(length-subdivision '(1 e) rhy :type '? :position '? :seed 34)
=> (1/16 1/8 1/16 1/8 1/8 -1/8 1/8 1/8 1/8)

(length-subdivision '((2 5q) (1 3q)) rhy :type '? :position 's :seed 34)
=> (1/20 1/20 3/20 1/12 -1/6 1/20 1/20 3/20 1/12 -1/6)

(length-subdivision '((2 5q) (1 3q) (1 e) (1 s)) rhy :seed 34)
=> (1/20 1/20 3/20 1/12 1/12 1/12 1/8 1/8 3/16 1/16)

Example:

(setf rhy2 '((1/4 1/4 1/4 1/4) (1/4 1/4 1/4 1/4)))

(length-subdivision '(1 e) rhy2 :seed 34)
=> ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8)
    (1/16 1/8 1/16 1/8 1/8 1/8 1/8 1/8 1/8))

(length-subdivision '((1 e) (1 3q)) rhy2 :seed 34)
=> ((1/8 1/8 1/12 1/12 1/12 1/8 1/8 1/6 1/12)
    (1/16 1/8 1/16 1/6 1/12 1/8 1/8 1/6 1/12))

(length-subdivision '(((1 e)) ((1 3q))) rhy2 :seed 34)
=> ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8)
    (1/12 1/12 1/12 1/6 1/12 1/12 1/6 1/6 1/12))

(length-subdivision '((3 3q) (1 e)) '((q -e e h) (s e. q h)) :seed 65)
=> ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4)
    (1/16 3/16 1/8 1/8 1/8 1/12 1/12 1/12 1/8))

(length-subdivision '(((3 3q)) ((1 e))) '((q -e e h) (s e. q h)) :seed 65)
=> ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4)
    (1/16 1/16 1/8 1/16 1/8 1/16 1/8 3/8))

(length-subdivision '(((2 3q)) ((1 e))) '((q -e e h) (s e. q h))
                :type '? :seed 65)
=> ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 -1/3)
    (1/16 -1/16 1/8 1/8 1/8 1/8 3/8))

OMN:

(setf mat1 '(q c4 d4 e4 f4 g4 a4 b4))

(length-subdivision '(1 e) mat1 :seed 45)
=> (s cs4 e b3 s d4 e cs4 e4 s f4 e fs4
    s d4 e fs4 eb4 f4 a4 bb4 gs4 bb4 a4)

The symbol 'r (third value) will apply repeat function:

(length-subdivision '(1 e r) mat1 :seed 45)
=> (s c4 e s e d4 d4 s e4 e s e f4 f4 g4 g4 a4 a4 b4 b4)

Here we define the intervals (third value):

(length-subdivision '(1 e (13 0 13 0)) mat1 :seed 45)
=> (s cs5 e c4 s cs5 e eb5 d4 s f5 e e4 s f5 e fs5 f4 gs5 g4 bb5 a4 c6 b4)

(length-subdivision '(4 s (13 0 13 0)) mat1 :seed 45)
=> (s cs5 c4 cs5 c4 eb5 d4 eb5 d4 f5 e4 f5 e4 fs5 f4
      fs5 f4 gs5 g4 gs5 g4 bb5 a4 bb5 a4 c6 b4 c6 b4)

(length-subdivision '(2 3q (13 0 13 0)) mat1
                :type '(r n) :seed 45 :position '(e s s s e s s))
=> (-3q cs5 c4 eb5 d4 eb5 f5 e4 - fs5 f4 fs5 - gs5 g4 bb5 a4 bb5 c6 b4 -)

(setf mat2 '((e c4 p e4 mp g4 he c5 p)
             (q c4 f c4 cs4 mp - d5 p d5)
             (q cs5 mf = - - cs5 p =)))

(length-subdivision '((1 e (13 0 13 0)) (2 e (13 0 13 0)) (2 3q (13 0 13 0)))
                mat2 :type '? :seed 34)
=> ((e c4 p e4 mp g4 q cs6 p e c5 q cs6)
    (e cs5 f c4 cs5 c4 -3q d5 mp cs4 -q e eb6 p d5 eb6 d5)
    (-s e cs5 mf -s e d6 cs5 -q - 3e d6 p 3q cs5 d6 3e cs5 e d6 cs5))

(length-subdivision '(((1 e (13 0 13 0))) ((2 s (13 0 13 0))) ((2 3q r)))
                mat2 :type '? :seed 34)
=> ((e c4 p e4 mp g4 q cs6 p e c5 q cs6)
    (e cs5 f s c4 cs5 -e s cs5 c4 e d5 mp s cs4 d5 -q -s eb6 p d5 - eb6 d5 eb6 d5)
    (3q cs5 mf cs5 cs5 cs5 cs5 cs5 -q - 3q cs5 p cs5 - - cs5 cs5))

In the example below we assign three series of values to variables s1, s2 and s3:

(setf
 s1 '(2 e (6 12 18 24))
 s2 '(1 3q ((13 1 13 0) (13 0 7 1) r))
 s3 '(3 5q ((13 0 13 0 13) ?))
 )

(length-subdivision (list s1 s2 s3) mat2 :seed 23)
=> ((e c4 p 3e bb4 mp 3q e5 e cs6 cs5 p cs6 q.)
    (e fs4 f c5 3q cs5 cs4 cs5 5h mp 5q c4 g4 c4 -q e c4 p c4 3q d5 3h cs4)
    (e g5 mf cs6 3q d6 3h d5 -q - 5q d6 p cs5 cs5 5h e d6 cs5))

length-syncopate

The function LENGTH-SYNCOPATE is a valuable way of bringing more rhythmic interest into a length list. The usual idea of syncopating rhythm is to 'choke' certain attacks so that the attack is delayed or pre-empted.

(setf rhy '(1/4 1/4 1/4 1/4))

(length-syncopate '(1 4) rhy)
=> (1/4 3/16 1/16 1/4 1/4)

(length-syncopate '(2 4) rhy)
=> (1/16 3/16 1/4 3/16 1/16 1/4)

Example:

(length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34)
=> (1/4 -1/8 1/16 1/64 3/64 -1/8 1/8 1)

In the example above only 1 length is divided by 4 (1, 3) - that is the 1/16. In the example below 2 values are divided by 3: (1, 2) and (2, 1).

(length-syncopate '(2 3) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34)
=> (1/4 -1/8 1/48 1/24 1/16 -1/8 1/8 2/3 1/3)

(length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1)
               :set 1/8 :seed 34)
=> (1/4 -1/8 1/16 1/16 -1/8 1/32 3/32 1)

Example with :set for each list:

(length-syncopate '((2 3) (1 4)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1))
               :set '(min 1/8) :seed 45)
=> ((1/4 -1/8 1/24 1/48 1/24 1/48) (1/32 -3/32 3/32 1/32 1))

(length-syncopate '((2 3) (1 5)) '((q -e s s) (s -e. q h))
               :set 'max :ignore 'h :seed 65 :omn t)
=> ((3h 3q -e s 3s 3e) (s -e. 5q 5w h))

OMN:

(setf mat '(q c4 d4 e4 f4 g4 a4 b4))

(length-syncopate '(3 4) mat :seed 12)
=> (s b3 e. cs4 q d4 e. fs4 s d4 q f4 g4 a4 e. bb4 s c5)

Here we use a set of interval values:

(length-syncopate '(3 4 ((13 0) (0 14) (1 13))) mat :seed 23)
=> (s cs5 e. c4 d4 s e5 q e4 f4 s gs4 e. gs5 q a4 b4)

(setf mat2 '((e c4 p e4 mp g4 he c5 p)
             (q c4 f c4 cs4 mp - d5 p d5)
             (q cs5 mf = - q cs5 stacc p = =))

(length-syncopate '((1 3 (-3 6)) (2 4 (6 0)) (2 5 (11 13)))
                  mat2 :seed 34)
=> ((e c4 p e4 mp 3e 3q cs5 he c5 p)
    (q c4 f s fs4 e. c4 q cs4 mp - e. gs5 p s d5 q)
    (q cs5 mf cs5 - 5w c6 stacc 5q d6 stacc q cs5 p 5q c6 5w d6 q cs5))

polygon-rhythm

In the next three examples below we use a list of fixed polygon sides (non-symmetrical):

(circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 1) :points 16)

To rotate the polygon we change the starting point value:

(circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 2) :points 16)

(circle-rhythm-plot
 (polygon-rhythm '(0 2 5 7 10 12 13 15 16 18 19 21 23) 24 0)
 :points 24 :value 1/24)

Best wishes,

JP

Sign In

Opusmodus 1.3.24952

Recommended Posts

opmo

Link to comment

Share on other sites

Browser

Documents

Examples

GUI

Activity

Downloads

Buy

Important Information