Jump to content
Sign in to follow this  
opmo

Opusmodus 1.3.24711

Recommended Posts

1.3.24711 

 

– Function name changes: 

hexachord-complement to: GET-HEXACHORD-COMPLEMENT
gen-ac-hexachord to: GET-AC-HEXACHORD
ac-hexachord-complement-form-set to: GET-AC-HEXACHORD-COMPLEMENT-FORM-SET

– New functions:

  • get-density
  • filter-density

 

– New directory in System Library: Analysis.

Fixed:
– velocity-to-dynamic

 

 

GET-DENSITY

The function GET-DENSITY returns a density value (between 0.0 and 1.0) derived from quantitative measurements in a given sequence. There are four density types: :length, :pitch, :velocity and nil. The density information can be used in an analytical and compositional manner.

 

Length density:

(get-density '(s s s s s s s s))
=> 1.0
(get-density '(s s -s s -s s -s s))
=> 0.62
(get-density '(-q e -e q. s))
=> 0.33555558
(get-density '(e.. s s s q s s s t -t s t))
=> 0.8336364
(get-density '(-q -e -t t t t t t -q -s. t t t))
=> 0.25
(get-density '((-w) (-w) (-w) (-w)
               (-h -e -t = -s. t -s. t -s)
               (-t = -s. e s = = = = = = = = = -s.)
               (-w) (-w) (-w)
               (-h -e -t = = = = = -s. =)
               (e.. s = = q s = = t - s t)
               (-t s t - s t - s t - s t - s t - s t - s t - = -s)
               (-t = -q -s. e t -s. s -e. t = =)
               (t = = = = = = = = = = = = s -e. s -e. t = =)))
=> (0.0 0.0 0.0 0.0 0.089999974 0.74833333 0.0 0.0 0.0
    0.22666669 0.8336364 0.69 0.3185714 0.62)

 

Pitch density:

(get-density 'c4e4g4)
=> 0.38888893
(get-density 'c4ds4fs4a4)
=> 0.41666666
(get-density '((bb3 e3 bb2 a4 b4 d5)
               (b2 bb2 b3 b4 c7 c5)
               (eb3 gs3 gs2 a5 cs7 cs4)))
=> (0.48333335 0.8166667 0.8833334)

 

Velocity density:

(get-density '(pp pp p p mp mp mf mf f f))
=> 0.30833334
(get-density '((pp< < < ff> > > > >)
               (p< < < < mf< < < <)
               (f> > > > > p p p)))
=> (0.4010417 0.38020834 0.30729166)

 

OMN:

(setf
p00 '(-h.)
p01 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf
      -e 3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4)

p02 '(t d4 < leg eb4 < leg g4 < leg bb4 q. a4 marc t fs4 mf leg
      gs4 leg e. c5 e b4 t f5 leg e5 leg d5 leg eb5 3q bb5 >
      a4 > bb5 > e a4 pp stacc -e)

p03 '(q d5 leg eb5 3q g4 stacc bb4 stacc a4 stacc e. cs4 marc
      s gs4 leg q gs4 -q)

p04 '(q. fs5 pp 3e c5 < leg b4 < leg f4 e d5 mf s eb5 leg g5 leg
      bb5 leg a5 e fs5 leg fs5 3e gs4 > stacc c5 > stacc b5 > stacc
      t f5 pp e.. e5)

p05 '(-q. e d4 pp q. eb5 mf e g4 q bb4 a4)
p06 '(q cs4 pp -q t gs4 marc e.. fs4 mf leg e c4 -e t b4 leg f4 q.. e4 pp)
p07 '(-q e d4 leg eb4 h g4 mf leg q. g4 > -e)
p08 '(s bb4 pp leg a4 h. db4 t gs4 mp fs4 < c5 < b4 q f5 marc e5)
)

(setf pattern (assemble-seq p00 p01 p02 p03 p04 p05 p06 p07 p08))

 

density.png

 

Type nil returns a mean value derived from the three main types:

(get-density pattern)
=> (0.0 0.3716961 0.47591507 0.343125 0.49027777
    0.36222222 0.41116783 0.2487963 0.45833334)

 

Length density:

(get-density pattern :type :length)
=> (0.0 0.5680555 0.7047059 0.36791664 0.8072916
    0.25333333 0.44183674 0.24291666 0.73148143)

 

Pitch density:

(get-density pattern :type :pitch)
=> (0.0 0.27272728 0.375 0.33333334 0.36666667
    0.5 0.45833334 0.1388889 0.3333333)

 

Velocity density:

(get-density pattern :type :velocity)
=> (0.0 0.27430555 0.34803924 0.32812503 0.296875
    0.33333334 0.33333334 0.36458337 0.3101852)

 

FILTER-DENSITY

The function FILTER-DENSITY analyses all bars in a given sequence and returns a new sequence based on the list of density values and their order.

 

A short demonstration on how the density information, taken from a number of patterns can be used in a compositional manner.

(setf
 p00 '(-w.)
 p01 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf
       -e 3q gs5 > leg fs5 > leg c5 > b4 pp leg f4 leg e4)
 p02 '(t d4 < leg eb4 < leg g4 < leg bb4 q. a4 marc t fs4 mf leg gs4 leg
       e. c5 e b4 t f5 leg e5 leg d5 leg eb5 3q bb5 > a4 > bb5 >
       e a4 pp stacc -e)
 p03 '(q d5 leg eb5 3q g4 stacc bb4 stacc a4 stacc e. cs4 marc
       s gs4 leg q gs4 -q)
 p04 '(q. fs5 pp 3e c5 < leg b4 < leg f4 e d5 mf s eb5 leg g5 leg bb5 leg
       a5 e fs5 leg fs5 3e gs4 > stacc c5 > stacc b5 > stacc t f5 pp e.. e5)
 p05 '(-q. e d4 pp q. eb5 mf e g4 q bb4 a4)
 p06 '(q cs4 pp -q t gs4 marc e.. fs4 mf leg e c4 -e t b4 leg f4 q.. e4 pp)
 p07 '(-q e d4 leg eb4 h g4 mf leg q. g4 > -e)
 p08 '(s bb4 pp leg a4 h. db4 t gs4 mp fs4 < c5 < b4 q f5 f marc e5)
 p09 '(h. eb4 pp q g3 -e q gs4 mf -s a5 p tie)
 p10 '(e. a5 -e q bb4 mf -s q cs5 p -s q. e5 mf -e.)
 p11 '(q cs5 p h. d5 mf -q c5 pp tie)
 p12 '(h c5 pp h. gs3 -e a4 p)
 p13 '(h. fs5 mp q bb3 c5 p e4 mf tie)
 p14 '(h e4 -e q cs4 mp h d5 p e f4)

 mat (assemble-seq p00 p01 p02 p03 p04
                   p05 p06 p07 p08 p09
                   p10 p11 p12 p13 p14)
)

(progn
  (setf
   ;bars  1   2   3   4   5   6   7   8   9  10  11  12  13  14
   p1 '(0.2 0.0 0.2 0.0 0.2 0.3 0.8 0.2 0.3 0.0 0.2 0.2 0.0 0.1)
   p2 '(0.0 0.2 0.6 0.3 0.0 0.5 0.2 0.7 0.0 0.2 0.0 0.2 0.3 0.2)
   p3 '(0.2 0.7 0.0 0.0 0.2 0.3 0.2 0.0 0.7 0.0 0.3 0.2 0.5 0.1)
   p4 '(0.1 0.0 0.0 0.2 0.8 0.2 0.0 0.2 0.2 0.0 0.2 0.2 0.3 0.2)
   p5 '(0.0 0.0 0.2 0.0 0.2 0.0 0.1 0.0 0.0 0.8 0.2 0.2 0.2 0.1)
   )
  (setf
   v1 (filter-density p1 mat :type :length :seed 253)
   v2 (filter-density p2 mat :type :length :seed 743)
   v3 (filter-density p3 mat :type :length :seed 545)
   v4 (filter-density p4 mat :type :length :seed 987)
   v5 (filter-density p5 mat :type :length :seed 234)
   )
  (setf
   fl (unfold 'eg '(t7 v? (a0-12 1) dyn fl) v1)
   ob (unfold 'eg '(t7 i (a0-12 (3 6 8)) dyn ob) v2)
   cl (unfold 'eg '(t7 v? (a0-12 (2 9 14)) (ra 9) dyn cl) v3)
   hn (unfold 'eg '(t-5 t-12 ra rol dyn hn) v4)
   bn (unfold 'eg '(t-5 t-12 i rol dyn bn) v5)
   )
  (ps 'gm :w5 (list fl ob cl hn bn) :tempo 68)
  )

 

Best wishes,

JP

Share this post


Link to post
Share on other sites

Thanks Janusz, These tools seem to be very interesting for musical analysis.

Best wishes.

Didier 

Share this post


Link to post
Share on other sites

Yes, for analysis GET-DENSITY and for composition FILTER-DENSITY.

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Sign in to follow this  

  • Similar Topics

    • By opmo
      We are happy to announce the Italian version of Opusmodus is almost ready and will be released with the forthcoming update version 1.4.
      The entire Opusmodus documentation was translated by Prof. Marco Giommoni.


       
      Best wishes,
      Janusz
    • By opmo
      – 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
    • By opmo
      – Update:
      SNIPPET – length snippet will display without a line staff.

      To display the length SNIPPET line staff, set the *SNIPPET-LENGTH-LINE* to T. 
      (defparameter *snippet-length-line* T "Enable or disable the length snippet line staff display.") The default is: NIL

      – Fixes:
      Bug fix found in length conversion to length-symbols function.
      Missing OM Developer documents (English version).
       
      Best wishes,
      Janusz
×
×
  • Create New...