LANDLUBBER NOVEMBER, 1999

OUTSIDE LINKS
  Solitaire
Context and Computer Composition

 

ROW 12:
The Algorithm

The algorithm counts through all possible 12-tone rows, skipping any that don't follow the rules. That is, it starts with E E E E E E E E E E E E and counts up from there to E Eb Eb Eb Eb Eb Eb Eb Eb Eb Eb Eb. Every note is recorded in the same octave.

While it's counting, it keeps track of two things: the notes that have been used and the intervals that have been used. As soon as it encounters a used note or interval, it abandons the current note and tries the next one.

Here's an example:

The row is initialized to E E E E E E E E E E E E, but only the first note is examined at the beginning. The rest of the row is ignored. So we start with

E

No problems! Add a note:

E E

We see that the E has already been used, so the second note is incremented to F.

E F
the intervals are now: (m2)

E is unused, and the semitone from E to F is also unused, so this is legal. We move on:

E F E

E is used, so we increment to F. F is used, so we go to F#:

E F F#
intervals: (m2) (m2)

Now we have all unused notes, but the semitone is used twice. So we must raise the F# to G:

E F G
intervals: (m2) (M2)

That works, so we continue adding notes and changing them when they don't fit.

Just like when counting, sometimes the digits have to roll over. Let's look at this partial row:

E F G F# Bb Ab B
intervals: (m2) (M2) (M7) (M3) (m7) (m3)

Good so far. But what can come next?

Obviously, we can't reuse E, F, F#, G, Ab, Bb, or B. The remaining notes are A, C, C#, D, and Eb. Examine each one in turn:

  • B to A is a minor seventh, which was used from Bb to Ab.
  • B to C is a semitone, which was used from E to F.
  • B to C# is a whole tone, which was used from F to G.
  • B to D is a minor third, which was used from Ab(G#) to B.
  • B to Eb(D#) is a major third, which was used from F# to Bb(A#).

So there are no notes that can be used. The algorithm counts up from E to Eb, discarding every note.

When the final Eb is reached and discarded, we decide that the last note in the row is unusable. Even though it follows the rules, nothing can come after it, so it is incremented. We would then try:

E F G F# Bb Ab C

When we finally reach a row that works, it is saved in the MIDI file. This is the first one:

E F G F# B D C Ab Eb A C# Bb

(m2) (M2) (M7) (P4) (m3) (m7) (m6) (P5)

Then, since we're counting through everything, we continue by incrementing the last note. We know that there are no other choices for the very last note, so the next row tried would be:

E F G F# B D C Ab Eb A D

That's the whole algorithm.

The result is that successive rows in the file start the same way, and the first different note is a small step higher each time. Because of the symmetries involved, the rows in the second half of the file are the same as the ones in the first half, inverted (i.e., row# 1 is the same as row# 3856 upside-down).

row#1:    E F  G  F# B D  C  Ab Eb A C# Bb
row#3856: E Eb C# D  A F# Ab C  F  B G  Bb

The Copyright Information

ROW 12: a MIDI file of tone rows
Copyright (C) 1999  Mike Ciul
This information is free; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This work is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this work; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

copyright © 1999 MIKE CIUL HOME