Noon

An event is the basic building block we are dealing with.

It can represent any MIDI event, such as a note or a control change.

It is represented using a Clojure map.

A score is a collection of events, represented using a Clojure set.

The option map lets you specify what you want to do with your score.

• :midi true Write the score as a MIDI file. Default to false.

• :bpm <number> Set the tempo to <number> beats per minute. Default value is 60.

• :play true Play the score. Default to false.

• :filename <path> Setting the name and location of emitted files. File extensions will be appended to this filename.

• :tracks {<track-idx> <sequencer> ...} Set each track index to a javax.sound.midi.Sequencer. This library comes with 4 nice soundfonts that sound way better than the built-in one (:default):

  1. :squid
  2. :chorium
  3. :fluid
  4. :airfont

example:

In addition to those soundfonts, you can send the output of noon to any output device available on your machine.

As we've just seen, we can create a score with the score function. With no arguments, it simply returns the default score containing only a middle C.

The score function can take any number of arguments, each one being a score transformation.

These transformations are applied in order to the default score.

As a convenience, this thin noon.eval/noon wrapper lets you play a score with fewer keystrokes:

Which is roughly equivalent to:

More concretely:

We can set the current pitch by using pitch vars.

Pitch vars names consist of a pitch-class name followed by an octave offset. (pitch classes are simply musical notes names like C, Db, F#, E, Bbb, Fx (x mean double sharp)). The middle C is named C0, the C above is C1, the C below is C-1.

Here some examples of pitches:

Pitches are not often used as is; we will prefer more relative constructs like intervals, patterns, etc. But it may be a little overwhelming to start with, so for now, we will use them to introduce the basic building blocks of the system.

We can operate on durations by multiplying or dividing them.

There is also a more flexible (and verbose) way to build duration transformations:

Those 3 forms return a transformation that can be used in score or play

Velocity is the force with which a note is played, and it is vitally important for making MIDI performances sound human.

In MIDI, the velocity is a number between 0 and 127.

For easier notation, 12 levels of velocity are defined as vars.

Like for duration there is also a more flexible form:

We can compose any number of transformations together using a clojure vector.

The play and score forms, when given several arguments, are doing exactly this:

Using the lin function, we can create our first melody. The lin function takes an arbitrary number of transformations and concatenate their results into one score.

lin accepts any valid transformation; here we are using composite transformations.

Using the par function, we can stack things up.

A pianissimo, double-duration, Csus4 chord:

By default, we are using general MIDI to emit sounds. It is not the most exciting way to play MIDI, but it is everywhere and gives you rapid feedback without extra setup.

Of course, if you want to use fancy VSTs in a proper DAW, you can; one of the features of this library is to export MIDI files, after all.

Here's how you can leverage general MIDI sounds:

You can look at what is available here

In most of the tunes we write, we want several instruments to play together.

In MIDI, there is this concept of a channel; it serves the purpose of separating different streams of events.

It is now time to brings intervals into the equation, pitches were nice for introduction purposes but lacks the flexibility that intervals have. When musicians think about music, they do not think in precise pitches most of the time, they more often thinks of scales, intervals, degrees, melodic contour etc… Those higher level abstractions are available in this system and in fact it is the whole point of it. Some really nice libraries already exists to deal with low levels aspects of music notation and sound synthesis.

In noon there is two types of intervals: steps and shifts.

As we have seen, lin let you create a succession of events:

Let's try to go further with it by composing it with another lin:

Let see what happens here:

3 transformations are chained:

1. We are dividing the duration of our base note by 8.
2. We are creating a series of 3 notes using chromatic intervals (diminished triad C,Eb,Gb).
3. Then this 3 notes score is passed to each member of the second lin expression, each one transposing it from the indicated chromatic interval.

tup stands for tuplet and is analogous to lin but keep the duration of the given score unchanged.

The resulting notes are fitted into the duration of the base note.

Like lin it can of course be chained with other transformations, as an example, here is a classic jazz melodic pattern.

dup stands for duplicate and let you repeat a score n times.

rep let you apply a transformation several times in a row accumulating intermediate results.

A melody of 8 successive major thirds (4 semitones):

Be careful, with more complex transformations it can quickly become hairy:

You can remove the input score at the start of the result by giving an extra argument:

fit is used to make a transformation fit the current duration of the score. The 2 previous transformations introduced: dup and rep, are changing the score duration, but sometimes we want to transform our score in place, stretching or compressing it, in the same way tup is acting.

In fact tup is just a composition of fit and lin.

The composition of fit and rep is also defined as rup for lack of a better name:

A fitted version of dup also exists under the name dupt

concat the results of the given transformation n times

it is the same thing as:

the fitted version of nlin

lin> stands for accumulative concatenation, it accumulates the given transformations concatenating the intermediate results.

tup> is doing the same as lin>, except it maintains the score original duration.

the chans function is doing the same thing as par except that it put each element on a separate MIDI channel.

To be more precise, it puts each of its arguments on subsequent MIDI channels starting at the current one. By default, we are on channel 0, so here the C will stay on channel 0, the Eb will go on channel 1, and the G on channel 2.

When we want more fine control, we can use the chan function, which works like vel and dur.

We can achieve the same thing as the first expression of the section using par and chan, like this:

Tracks are a way of not being limited to only 16 channels; you can create virtually as many as you want. Most of the time, 16 channels are enough, but who knows… The tracks function works exactly like the chans function, except that it operates on the :track entry of events.

By default we are on track 0. So the second argument of tracks goes on track 1. Like with channels we can be more precise by using the track function.

Variadic functions have a 'star' counterpart that accepts a sequence instead of variadic arguments.

Is similar to:

or

It eases things a bit when using Clojure to generate arguments for those functions, avoiding the need to write apply everywhere.

Maps can be used to compose event transformations.

one-of randomly picks one of the given transformations and applies it.

maybe is very similar to one-of, except it has a chance to do nothing (identity transformation).

probs gives you more control over the probability of occurrence of the given transformations.

any-that is similar to one-of, except it takes an extra first argument that checks if the picked transformation is valid.

A melody of 60 notes using the 6 given intervals while remaining within the given pitch bounds:

The within-pitch-bounds? is just a score transformation that returns the score unchanged if it is within the given bounds; otherwise, it returns nil. Any function of this kind can be used as the first argument to any-that.

The ! macro can be useful to deal with raw non-deterministic expressions. Here is the docstring:

Takes a non-deterministic expression resulting in a score transformation. Returns a score transformation that wraps the expression so that it is evaluated each time the transformation is used.

As in the previous example, building a tup or a lin with a shuffled sequence of transformations is quite fun.

So, two shortcuts are defined:

So far, we've seen 3 types of intervals: chromatic steps, diatonic steps, and octaves (aka tonic shifts). Let's see the two remaining kinds of steps.

These four types of steps can be seen as belonging to 4 successive layers built on each other.

1. chromatic: [0 1 2 3 4 5 6 7 8 9 10 11] the chromatic layer, 12 successive semitones
2. diatonic: [0 2 4 5 7 9 11] we select indexes from the above layer (chromatic) to form the diatonic layer (here the major scale)
3. structural: [0 2 4] same here but based on the diatonic layer to form the structural layer (here the basic triad)
4. tonic: [0] the root

As you can see, the chromatic layers and tonic layers are trivial, so they are omitted in the harmonic context representation.

The harmonic context can be found under the :pitch key of any event.

The :origin key holds the pitch from where our layers start (in both directions).

The :position key holds a map with the 4 layers indexes

• :t tonic

• :s structural

• :d diatonic

• :c chromatic

At last, we will understand the nuance between steps and shifts. To do so, let's compare tonic steps and tonic shifts (aka octaves).

At first glance they seems to be equivalent:

In this case, they are indeed equivalent; in each case, a C1 is played. But how about this?

In the first expression (the shift), we have transposed the score (an E0 note) by 1 tonic layer index. In the second one (the step), we have stepped to the next tonic layer index.

In practice, apart from octaves, shifts are not used so often; that's the reason why they don't have defined vars as steps have. They are mainly used in more complex harmonic operations (voice leading, etc.).

One of the most common things we want to control when generating melodies is the range.

Rotating a melody is a way to evolve it while preserving its identity.

Another way to transform a melody while preserving a bit of its identity is to permute it. But for long melodies, a random permutation can make it so distant from the original that it misses the point. For this reason, permutations are ordered and requested by complexity (similarity degree with the original).

In the following example, you can get a sense of the effect of deriving a melody from simple transformations.

The idea of contour is quite simple. When you see a melody on a score or a piano roll, by linking the successive notes, you can make a line. This line has a certain shape; some melodies with different notes share the same shape (contour). The contour of a melody greatly contributes to its identification by the listener. So by keeping a contour and changing the notes, we can ensure a kind of continuity in our melodic developments.

For instance those different melodies are all sharing the same contour: [0 2 1 2]

You can clearly hear the similarity between these.

One simple way to build a melody is to concatenate some little fragments one after another, building the next fragment on the last note of the previous one.

There are several ways to do this:

The simple-line function is built on top of the more general function noon.lib.melody/line.

As we've seen earlier, we can use the duration-related transformations to write simple rhythms.

This is not a pretty way to write it! We can use the _ shortcut instead of same, and the tup function to make this a bit more readable.

We can also use the dupt function if we prefer.

We could have done it like this too:

There is a function to help write a rhythm this way:

Writing those kinds of rhythms is not the funniest thing to do, of course; let's see how we can generate and transform rhythms.

The main tool we have at our disposal to create a rhythm is the noon.lib.melody/gen-tup.

Once we have written or generated a rhythm, we may want to make it evolve. Here are some functions that can help.

In musical terms, a voicing is a particular arrangement of a chord. When we speak of a chord like, for instance, G7, we are not specifying the precise way we will arrange its components.

It can be played in closed position:

Inverted (first inversion)

Or dropped (drop 2)

and many other ways…

A chord progression is simply a succession of different chords, cyclic or not.

Experimenting with passing notes:

A rich harmonic sequence using V I progressions over a tritonal modulation cycle (like Giant Step).