Hello,

 

I'm making a presentation on 12-tone composition in an educational context. While my focus is on a 12-tone map (including OMN and OpusModus code) I want to begin with some more simple examples e.g. a Canon, a Fugue, first second and third species counterpoint.

 

While I can create a canon, counterpoint and a fugue myself with a bit of time, it would be much less time-consuming for me if I were able to use existing examples. Is there an existing library of OMN examples of these types of compositions?

If not, I'm happy to post mine once I'm done.

Tom

Such an example will be very useful indeed.

Looking forward to see how you made it work.

Best, J

Dear Friends,

 

Here 's a way to produce chords from 12 tone rows (Schoenberg opus 25 row):

(setf op25arnie '(e4 f4 g4 cs4 fs4 ds4 gs4 d4 b4 c4 a4 as4))

(respell (gen-chord2 20 '(3 3 3 1) op25arnie))

Hope it helps a little.

 

Best,

Julio

 

 

Also check this !

And the Nigel Morgan Parametric Composition book, of course !

More specific, to keep track of the row:

(setf op29webernLib (expand-libraries '(library vienna webern r19)))
(setf rowint (pitch-to-integer op29webernLib))
(setf pitches (gen-repeat 10 op29webernLib))
(setf lengths (span pitches (gen-repeat 10 '(s s s s -s s e -s s s -s e e -q q))))
(setf text
      (span pitches rowint))
(def-score Stage-1
           (:key-signature 'chromatic 
            :time-signature '(4 4) 
            :tempo 80
            :layout (treble-layout 'piano-rh))
  (piano-rh
   :length lengths
   :pitch pitches
   :text text
   ;:velocity dynamics
   :channel 1
   :sound 'gm
   :program 'acoustic-grand-piano)
)

Best,

Julio

(setf op25arnie '(e4 f4 g4 cs4 fs4 ds4 gs4 d4 b4 c4 a4 as4))

(respell (gen-chord2 20 '(3) op25arnie :offset '(2 1 2 3)))

Using the :offset parameter in the gen-chord2 function could be interesting too, for example for keeping notes between chords for smoother transitions with common tones.

 

S.

Thank you for the help everyone! These are great for my section on serialism.

 

I've switched my focus to serialism and neural networks (I found an example that generates content from simple Irish Folk songs in .mid files). My focus is on the ever-changing relationship that composers have with rules and procedures.

 

https://www.mathworks.com/matlabcentral/fileexchange/69632-code-for-webinar-deep-learning-for-signals-and-sound

 

Tom

"My focus is on the ever-changing relationship that composers have with rules and procedures."

 

some ideas/names...?

 

=> MOZART  https://en.wikipedia.org/wiki/Musikalisches_Würfelspiel

=> the LIGETI-analysis of BOULEZ's STRUCTURES ?

=> MESSIAEN in general: https://monoskop.org/File:Messiaen_Olivier_The_Technique_of_My_Musical_Language.pdf, or  specific "MODE DE VALEURS ET D'INTENSITÉS"

=> GOTTFRIED MICHAEL KöNIG

=> XENAKIS (the "ST"-pieces?)

=> HAUER https://de.wikipedia.org/wiki/Zwölftonspiel

 

 

 

 

> While I can create a canon, counterpoint and a fugue myself with a bit of time, it would be much less time-consuming for me if I were able to use existing examples. Is there an existing library of OMN examples of these types of compositions?

 

I cannot offer ready-made examples, but a constraint-based library with various counterpoint (and also harmony) rules ready-made.  

 

Cluster engine implements the constraint solver, and many functions for applying user-defined rules to various score contexts in a flexible way (e.g., consecutive notes in certain voices, simultaneous notes across voices at certain metric positions etc). 

https://github.com/tanders/cluster-engine

 

Cluster rules provides a collection of ready-made rules for the cluster engine library.

https://github.com/tanders/cluster-rules

 

Both libraries were initially developed for PWGL, but we ported them to plain Common Lisp to make them usable, e.g., in Opusmodus (where I already used both) and the Max<->Lisp interface I just mentioned in other message.

 

There are some demo/test examples that come with the library (https://github.com/tanders/cluster-rules/blob/master/tests/first-tests.lisp). More extensive documentation (tutorials) are available with the original PWGL versions of the libraries.

 

Some code to smoothly interface the Cluster Library with Opusmodus is part of my tot library (e.g. in the file https://github.com/tanders/tot/blob/master/sources/constraints.lisp). For example, there are means to transform Cluster Library scores into Opusmodus scores (actually, my variant of it, see the docs) and some more complex functions that could be seen as example use cases. For example, the function revise-score-harmonically, expects an existing score that you might create with whatever Opusmodus methods, and some underlying harmony definitions, and that re-harmonises the score accordingly, taking some counterpoint rules etc. into account.

 

I hope the available doc of these packages helps (of which there is also some HTML version online). I cannot provide any more help at this stage, as I am currently extremely busy in my new job...

 

Best,

Torsten

Thanks for a very informative post. Would someone be willing to explain the four integers included in the 

:offset '(2 1 2 3)

parameter from Stephane's reply? It is clear why the parameter is used; I just hope to better understand the purpose of the integer(s) used in order to better control the parameter.

 

Many thanks!

>> While I can create a canon, counterpoint and a fugue myself with a bit of time, it would be much less time-consuming for me if I were able to use existing examples. Is there an existing library of OMN examples of these types of compositions?

> I cannot offer ready-made examples, but a constraint-based library with various counterpoint (and also harmony) rules ready-made.  

 

Following up my own comments, some entry level introduction to the libraries Cluster Engine and Cluster rules is offered by a video I prepared for my students last autumn.

 

https://www.youtube.com/watch?v=xPXIRmH9rZc&list=PLmbpscTxjn_DrdDXD5v7z0GzQRNKM5VyQ&index=9

 

This video uses PWGL instead of Openmusic, but you only need to mentally replace PWGL boxes with Lisp functions of the same name to get pretty much the equivalent Opusmusic code. Also, this tutorial only scratches the surface of what can be done with these libraries, but I hope it can give an initial idea how things are approached in these libraries and for going beyond that a relatively easy approach is simply to study the pre-programmed rules in the Cluster Rules library and trying to combine rules for your own purposes. Once you miss a specific rule you would like to have, the library Cluster Engine provides the tools for defining your own rules on a high level of abstraction (specifically, it provides many abstractions that help to easily apply your rule to a specific score context, like the pitches of simultaneous notes of certain parts). 

 

This video is the last of a series of introduction-level videos on algorithmic composition with PWGL... 

 

https://www.youtube.com/playlist?list=PLmbpscTxjn_DrdDXD5v7z0GzQRNKM5VyQ

 

Thanks, Torsten. This is very informative.

All the best,

Zvony

The integers are the number of pitch to shift for the offset.

If chords size parameter is 3, an offset of 1 will keep 2 pitch in common, offset of 2 will keep one pitch etc...

(gen-chord2 8 3 '(c4 d4 e4 f4 g4 a4 b4 c5 d5 e5 f5 g5 a5 b5) :offset '(0 1 2 3 0 3 2 1))
=> (c4d4e4 d4e4f4 f4g4a4 b4c5d5 b4c5d5 e5f5g5 g5a5b5 a5b5c4)

The :offset is the shift into the pitch list but related from chord to chord.

Another example for clarity:

(gen-chord2 2 3 '(c4 d4 e4 f4 g4 a4 b4 c5 d5 e5 f5 g5 a5 b5) :offset '(1 5))
=> (d4e4f4 b4c5d5)

SB.

Many thanks, Stephane. This is very helpful!