Algorithmic Composition
(with Csound and HTML5)

26 March 2018

Universidad Nacional de Quilmes, Buenos Aires

Michael Gogins

Irreducible Productions

http://michaelgogins.tumblr.com

About Me

• Born in 1950, Salt Lake City, Utah, United States.
• I was a music student for two years, but my degree is in comparative religion.
• Independent composer since 1983, music programmer since 1991.
• I present mostly things related to my own work.
• There are many more approaches to algorithmic composition and to sound synthesis than I can show you here.

• These are online slides that you can view from any Web browser.
• My talk is mainly about algorithmic composition; however, some of my examples are live and actually run in Web browsers using Csound with HTML5.
• I briefly introduce Csound and HTML5 so you can better understand what you are seeing.

Csound

• You already know Csound... the software sound synthesis system, or sound programming language, written by Barry Vercoe in 1985.
• Runs on Linux, OS X, Windows, Android, iOS, Raspberry Pi, Web browsers, and more.
• APIs in C, C++, Java, JavaScript, Python, Lua, Lisp, and more.
• Precisely because Csound is so old, it has a vast library of features, instruments, examples, etc.

HTML5

• HTML5 is the name for standards defining HTML, JavaScript, and many other things on the Web.
• It is an open standard, but follows the lead of Google, Apple, Mozilla, etc.
• JavaScript is the programming language of the Web, enabling different objects in the browser to be programmed, interact, etc.
• HTML5 is highly secure due to the browser sandbox.
• It is versionless: everything from the old days still runs, and in the future will continue to run.

Csound and HTML5

• Several environments run Csound in the JavaScript context of a Web page:
  • csound.node
  • Csound for WebAssembly
  • Csound for Android

• Csound in each of these environments has the same interface; many pieces play in all environments.
• Algorithmic compositions can be written in JavaScript.
• My Silencio library provides a number of compositional algorithms.
• Check out Gibber for another HTML5 music playground!

Csound+NW.js+HTML5

• Csound compiled as a C++ addon runs in NW.js on desktop operating systems.
• Csound runs as native code, multi-threaded, with native audio.
• This is the most performant option.

WebAssembly

• WebAssembly is a new Web standard for running compiled code on the Web.
• JavaScript is fast, but WebAssembly can run just as fast as C.
• WebAssembly can be compiled from source code written in C, C++, Rust, and more.
• WebAssembly modules with JavaScript APIs can, of course, call each other.
• WebAssembly might turn out to be a new universal computing platform.

Csound+WebAssembly+HTML5

• Csound compiled for WebAssembly runs in major browsers and NW.js, and on desktop and mobile operating systems.
• Audio performance with Web Audio is OK for light pieces, not good for demanding pieces.
• This is the most portable option.
• Audio performance may improve in time as Web Audio is improved, but there are serious issues.

Csound/HTML5

Algorithmic Composition

• An algorithm is an effective procedure, i.e., one that can be performed by following instructions without needing to understand them, and stops with a definite result.
• This is a fundamental concept of mathematics, and this is the technical definition.
• Algorithmic composition is the art of composing music by writing or using algorithms.

• Why bother? After all, you can already compose music without using any algorithms.
• Can you?
  • The rules of voice-leading are algorithmic.
  • Canon and fugue are algorithmic.
  • The rules of harmony are algorithmic.
  • Developing variation is algorithmic.
  • The musical dice game of 1787 is a definite algorithm.

Computerized Algorithms = Programs

• A computerized algorithm is called a program.
• Computers run algorithms much faster than people can. This is an advantage -- not a qualitative advantage, but a major convenience.
• Certain algorithms are computationally irreducible. It is impossible to predict the results of such algorithms without running them.
• Irreducibility is a qualitative advantage. It amplifies the human imagination.

A Few Kinds of Compositional Algorithms (more here)

• Random variables
• Markov processes and parody generators
• Chaotic dynamical systems
• Iterated function systems
• Lindenmayer systems
• Minimalist procedures
• Pattern languages
• Genetic algorithms
• Machine learning

Problems of Algorithmic Composition

• Not all aspects of music have known algorithms.
• Even with good algorithms, there is too much garbage.
• Algorithmic composition is rooted in early 20th century music, e.g. serialism, aleatoric music.
• Tonal music, extended tonality, and contemporary trends are not so well represented.
• Algorithmic procedures have not been applied much to acousmatic pieces.

Mathematical Music Theory

• Just as atonal theory applies group theory to serialism, so neo-Riemannian theory applies abstract algebra to chord transformations and voice-leading.
• A chord space is a metric space in which each chord is a separate point, and each pitch of a chord is represented by a separate dimension (Tymoczko 2006). Triads are 3-dimensional, seventh chords 4-dimensional, etc.
• Many more kinds of mathematical music theory!

• Group generators (T, I, T/I, Q/K) for basic symmetries of chord spaces (e.g. octave equivalence, transpositional equivalence, inversional equivalence, set type equivalence [Callender, Quinn, Tymoczko 2008]) can be used to generate or transform scores.
• These operations are not exactly tonal, as they lack key and cadence.
• However, I feel they are beautiful and can generate large-scale musical structures.

Trichords (OPC)

Chord Types (OPTC)

Set Classes (OPTIC)

Two Dualities (Python)

Where is the irreducibility?

def createMusicModel(self): print 'CREATING MUSIC MODEL...' print import GeneralizedContextualGroup self.gcg = GeneralizedContextualGroup.GeneralizedContextualGroup() self.gcg.setAxiom('pcs1 V+47 WC R45 a3 Q5 R50 a4 R55 a3 R60 a4 R65 a3 ') self.gcg.addRule('pcs1', 'P(0,4,7,11,14)') self.gcg.addRule('a3', 'a3k a3q a3 a3') self.gcg.addRule('a3k', 'K WV') self.gcg.addRule('a3q', 'Q3 K D/1.25 WV Q3 V+1 D*1.25 WC') self.gcg.addRule('a4', 'L*2 a4k a4q D/1.25 a4 D/1.25 a4 D*1.25 D*1.25 L/2') self.gcg.addRule('a4k', 'K WV') self.gcg.addRule('a4q', 'Q4 WV Q4 K V+4 WC') # HERE IS THE IRREDUCIBILITY! self.gcg.setIterationCount(2) self.gcg.debug = True self.gcg.generate() self.rescale = CsoundAC.Rescale() self.rescale.setRescale( CsoundAC.Event.TIME, True, False, (1.0 / 40.0), 120 ) self.rescale.setRescale( CsoundAC.Event.INSTRUMENT, True, False, 1, 3.99 ) self.rescale.setRescale( CsoundAC.Event.KEY, True, False, 37, 36 ) self.rescale.setRescale( CsoundAC.Event.VELOCITY, True, True, 43, 17 ) self.rescale.setRescale( CsoundAC.Event.PAN, True, True, 0.05, 0.9 ) self.rescale.addChild(self.gcg) self.model.addChild(self.rescale)

Scrims (HTML5)

• Shows WHY HTML5 is such a big deal!
• Interactive visual music: an animated voyage through variations on the hopalong fractal.
• The performer controls, in real time:
  • Parameters of the hopalong fractal.
  • Mapping of fractal points to musical notes.
  • Neo-Riemannian transformations of notes.
  • Parameters of Csound instruments/effects.

Compositional Process

Different composers have different methods. This is me. But I think there are some lessons.

Irreducible algorithms produce complex patterns from simpler inputs. These patterns often have intrinsic beauty. That is because chaos and fractals generate much of the beauty in Nature.

This reminds me of Aristotle's thesis that "art is the imitation of Nature."

In this case the imitation is not on the surface of appearances, but on the deeper level of process.

Generated patterns cannot be used raw.

They must first be mapped to musical dimensions such as pitch and time.

Sometimes the mapped patterns must be further transformed.

Then the score must be arranged and balanced.

This is an iterative procedure.

Each of my pieces is always a single program. Sometimes the program generates several patterns that are combined in a collage.

I work in a text editor with a key binding that instantly runs the piece in real time.

This greatly speeds up the edit, render, listen, edit, ... cycle typical of computer composition.

I write a dozen or so pieces until one seems interesting.

Then I tweak the program repeatedly, the generative parameters, the transformations, the arrangement, etc.

While Csound runs in real time, I use interactive controls to tweak the instrument sounds and balance.

It's hard to improve a piece in one place without breaking it in another place.

There's a lot of listening, over and over.

If the piece pulls me in, if it makes me listen, I know I have something.

If it not only pulls me in but doesn't have jarring flaws or awkward moments, I know I have something for you.

Blue Leaves 4e (C++)

Where is the irreducibility?

/** * Generators are lambdas with the same signature as the following example. * The pen is the current position of a "pen" in the score. The pen is * "written" by appending it to the score. Additional events can be computed * based on the parameters of the function, and also appended to the score. * The function can, and usually does, move the pen to a new position before * returning it. */ auto generator = [&](const csound::Event &pen, int depth, csound::Score &score, csound::VoiceleadingNode &voiceleader) { csound::Event result = pen; return result; }; /** * Computes a deterministic, finite recurrent iterated function system by * recursively applying a set of generators (transformations) to a pen * which represents the position of a "pen" on a "score." The entries in * the transitions matrix represent open or closed paths of recurrence through * the tree of calls. Because the pen is passed by value, it is in effect * copied at each call of a generator and at each layer of recursion. The * generators may or may not append a local copy of the pen to the score, * thus "writing" a "note" or other event on the "score." */ void recurrent(std::vector< std::function<csound::Event(const csound::Event &,int, csound::Score &, csound::VoiceleadingNode &)> > &generators, Eigen::MatrixXd &transitions, int depth, int transformationIndex, const csound::Event pen, csound::Score &score, csound::VoiceleadingNode &voiceleader) { depth = depth - 1; if (depth == 0) { return; } // std::printf("recurrent(depth: %3d index: %3d %s)\n", depth, transformationIndex, pen.toString().c_str()); // Index is that of the current transformation. The column vector at that index determines which // transformations may be applied. for (int transitionIndex = 0, transitionN = transitions.rows(); transitionIndex < transitionN; ++transitionIndex) { if (transitions(transformationIndex, transitionIndex)) { auto newCursor = generators[transitionIndex](pen, depth, score, voiceleader); recurrent(generators, transitions, depth, transitionIndex, newCursor, score, voiceleader); } } } std::vector<std::function<csound::Event(const csound::Event &, int, csound::Score &, csound::VoiceleadingNode &)>> generators; auto g1 = [](const csound::Event &pen_, int depth, csound::Score &score, csound::VoiceleadingNode &voiceleader) { csound::Event pen = pen_; if (depth <= 1) { return pen; } pen[csound::Event::TIME] = pen[csound::Event::TIME] * .7 + .25; pen[csound::Event::KEY] = pen[csound::Event::KEY] + 3.105; pen[csound::Event::INSTRUMENT] = 4.0 * 1.0 + double(depth % 4); pen[csound::Event::VELOCITY] = 1.0; pen[csound::Event::PAN] = .875; score.append(pen); if (depth > 2) { voiceleader.C(pen[csound::Event::TIME], "A7b9"); } return pen; }; generators.push_back(g1); auto g2 = [](const csound::Event &pen_, int depth, csound::Score &score, csound::VoiceleadingNode &voiceleader) { csound::Event pen = pen_; if (depth <= 2) { return pen; } pen[csound::Event::TIME] = pen[csound::Event::TIME] * .7464 - .203487; pen[csound::Event::KEY] = pen[csound::Event::KEY] *.99 + 3.0; pen[csound::Event::INSTRUMENT] = 4.0 * 2.0 + double(depth % 4); pen[csound::Event::VELOCITY] = 2.0; pen[csound::Event::PAN] = .675; score.append(pen); return pen; }; generators.push_back(g2); auto g3 = [](const csound::Event &pen_, int depth, csound::Score &score, csound::VoiceleadingNode &voiceleader) { csound::Event pen = pen_; if (depth <= 1) { return pen; } pen[csound::Event::TIME] = pen[csound::Event::TIME] * .65 - .23; pen[csound::Event::KEY] = pen[csound::Event::KEY] - 3.07; pen[csound::Event::INSTRUMENT] = 4.0 * 3.0 + double(depth % 4); pen[csound::Event::VELOCITY] = 1.0; pen[csound::Event::PAN] = -.675; score.append(pen); return pen; }; generators.push_back(g3); auto g4 = [](const csound::Event &pen_, int depth, csound::Score &score, csound::VoiceleadingNode &voiceleader) { csound::Event pen = pen_; if (depth <= 0) { return pen; } pen[csound::Event::TIME] = pen[csound::Event::TIME] * .79 + .2; pen[csound::Event::KEY] = pen[csound::Event::KEY] - 4.25; pen[csound::Event::INSTRUMENT] = 4.0 * 4.0 + double(depth % 4); pen[csound::Event::VELOCITY] = 2.0; pen[csound::Event::PAN] = -.875; if (depth > 2) { voiceleader.C(pen[csound::Event::TIME], "Dm9"); } return pen; }; generators.push_back(g4); // Generate the score. csound::Event pen = {1,1,144,0,1,1,0,0,0,0,1}; pen[csound::Event::DURATION] = 0.0125; Eigen::MatrixXd transitions(4,4); transitions << 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1; csound::ScoreNode scoreNode; csound::VoiceleadingNode voiceleadingNode; voiceleadingNode.setModality({0., 2., 5., 7., 11.}); voiceleadingNode.addChild(&scoreNode); model.addChild(&voiceleadingNode); csound::Score &score = scoreNode.getScore(); // THE IRREDUCIBILITY IS IN THESE 9 ITERATIONS! recurrent(generators, transitions, 9, 0, pen, score, voiceleadingNode);

Thank you!

Questions?