perl aminipas.pl @ARGV > a.txt

perl mixaco.pl < minipas.txt > withac.txt
perl twelver.pl > b12.txt 
copy parm.txt+canonheader.txt+canonscore.txt+cancodascore.txt $nama
midi $nama 

perl solocanon.pl > b1.txt
perl bsolo.pl > b2.txt
copy parm.txt+canonscore.txt+cancodascore.txt $namb
midi  $namb

perl prevaco.pl < minipas.txt > tonalac.txt
perl tontoc.pl > c.txt  
copy parm.txt+tontohdr.txt+dblscore.txt+cancodascore.txt $namc
midi $namc 

$nama:	ax$random-$size,	e.g. ax2345-20 and ax2345-20.mid
$namb:	bx$random-$size, sometimes by$random-$size	e.g. bx2345-20 and bx2345-20.mid, or by2345-20 and by2345-20.mid
$namc:	dbl$random-$size,	e.g. cx2345-20 and cx2345-20.mid

• The program  bsolo.pl  may fail, and in this case the instruction

  perl  csolo.pl  > c2.txt

  will be executed instead. If any other step of  tri.pl  fails, $random is increased and  tri.pl  restarts.

• There is a parameter list, of the form

  rand_2345     size_20

  This means: initialize random generator with 2345, and make 20 motifs. The parameters are optional; they are also used in naming the score and midi files:

  sc2345-20 , sc2345-20.mid etc.

• The motifs, each repeated several times times form the basic strand. Each motif is repeated until its total duration is a multiple of 12 shorties. The strands are repeated, according to the augmentation, which may be (at random) 1:2 or 2:3 or 1:3.
  • augmentation 1:2
    

    The 1st voice plays twice the basic strand, with a random break before the repetition.
    The 2nd voice plays the basic strand once, one octave lower in augmentation (twice as slow).

  • augmentation 1:3
    

    The 1st voice plays three times the basic strand, with random breaks before the repetitions.
    The 2nd voice plays the basic strand once, one octave lower in augmentation (three times as slow).

  • augmentation 2:3
    

    The 1st voice plays twice the basic strand, with a random break before the repetition; each note twice as long as specified: 1 shorty becomes 2 shorties.
    The 2nd voice plays the basic strand once, one octave lower in augmentation (three times as slow, 1 shorty becomes 3 shorties)

  The 2nd voice enters after a random time, adding to unpredictability. One of the voices usually may play alone at the end of the canon, but for most of the piece the two voices play together.

• The first motif is generated (at random) as one of:
  1. part of a scale (major or minor)
  2. arpeggio, i.e. tones following each other at intervals of 3 or 4 semitones (at random), all in the same direction, up or down.
  3. equally spaced, i.e. tones following each other at intervals of n semitones, all in the same direction, up or down. The number n is picked at random, from the set 1,2,3,4,5,7 (no tritones).

• Each subsequent motif is a small change of the previous motif.

  • cancrizans: the motif played backwards
  • add one accident (flat or sharp) to one note in the motif
  • transpose the motif, by 1 or 2 semitones, up or down
  • add one note to the motif (should be consistent with its type: scale, arpeggio, equally spaced). The note may be added at either end.
  • add a rest to the motif, before it , after it or between any 2 notes
  • delete one note from the motif, at any position
  • fold two note in a chord, only if the chord is a minor/major third/sixth. (With a big grain of salt: either the motif is an arpeggio, or the distance from the first to last note in the chord is 3,4,8,9 semitones. The program would, for instance,   fold     C#,E,F    or    C,E,G# )
  • mix the notes in the motif (play them all, in random order). This, of course, destroys type: the motif, usually, no longer is equally spaced, a scale, or an arpeggio. In addition, the chords made by folding afterwards may be dissonant. Therefore, mixing is assigned a smaller probability than the other modifications. In addition, with high probability, the reordering swaps only one pair of contiguous notes.

• Up to now we only discussed the notes in the motifs, not their durations. The rhythm is governed by "measures" of 12 shorties, which may be:
  • 12/12, i.e. 4/4 with subdivision into triolets, or
  • 12/16, i.e. 3/4 with subdivision into eights or sixteenths.

  The notes get random durations, from 1 to 8 shorties. The total length in shorties of the motif determines how many times it is repeated: e.g. a motif of 15 shorties is repeated 4 times, to cover 5 times 12 shorties. There may be up to 12 repetitions, e.g. for motif lengths of 7, 17 or 25 shorties.

    

• DETAILS

  • aminipas.pl

    This creates the motifs, and produces the two voices in canon. The program writes an intermediate file minipas.txt, which is used by the programs  mixaco  and  prevaco  to add accompaniment. This file is just a list of shorties in 8 voices. The shorty is the smallest duration in the piece, either 1/16 or 1/12 (triolet), and all other durations are multiples of it. For instance, if the shorty is 1/16, a quarter note will be emitted in 4 records in minipas.txt .

    It also writes two other "communication files":

    1. information about the generated score, including the original parameters, is written on the file parm.txt
    2. the same information, plus a list of motives, is written on mot.txt

  • mixaco.pl

    The program uses as inputs  minipas.txt  and  parm.txt.

    Up to now there was no consideration of harmony; the two voices advance in canon, although each voice may have folds. This is why up to 8 midi channels may sound – in principle the 8 channels are the two hands of the piano soloist, playing single notes or chords; these are the 1st and 2nd voices in the canon.

    mixaco adds, for each shorty, an accompaniment chord which contains all the notes in these eight voices (sometimes this is impossible, nothing is added). The chords are plain triads, sevenths , ninths etc. in major or minor scales, limited to 4 distinct notes. They are also picked at random, without reference to some global rhythm or tonality. For instance:

    Assume the shorty is 1/16, and there is a quarter note sounding C,E in two voices. The 4 jiffies in the accompaniment might be:
    

    C,E,G,B♭     C,E,G     A,C,E     C,E,G,B    or
    C,E,G,B♭     C,E,G     A,C,E     C,E,G
                      etc...

    A single eighth note C may be accompanied by:
    

    C,E,G     A,C,E,G    or
    A,C,E     F,A,C    or
    C,E,G     F,A♭,C
                      etc...

    The combination canon+accompaniment is written to the file withac.txt.

  • prevaco.pl

    The program uses as inputs  minipas.txt  and  parm.txt.

    Similar to mixaco.pl,   but, as much as possible, it assigns identical accompaniment chord to identical simultaneous shorties in the canon voices. The resulting accompaniment changes less often, which allows for long arpeggios wehen played by the piano.
    The combination canon+accompaniment is written to the file tonalac.txt.

  • twelver.pl

    As its name implies, it is totally based on 12 shorties groups, or measures.
    • The program uses as input the files parm.txt and withac.txt.

    • First, we consider the harmony between the (up to) eight voices, to discover a cadence near the end, on which to end the piece (routines codall,   cadeval,   coda). This is done by gathering chords and checking versus a big list of acceptable cadences. If no cadence is available, twelver fails and the driver program tri.pl will restart amini, with a different random seed.

      If a cadence is found, then the durations of the notes around it are modified, to emphasize it. A few preceding chords are also reset to belong to the scale of the final cadence; also, there is a suitable rallentando at the coda. The coda is written to the file   cancodascore.txt   and the size of the text before coda is written to   can0n.txt,   for further use by   tontoc.pl.

      Because of the cadence, the canon is incomplete – voice 1 does not play the basic strand twice or thrice, and voice 2 does not play all the basic strand, only 'most of  ' that.

    • The notes before the coda will form the accompanied canon, to which the coda is later attached. The program analyses the notes, in segments of 12 notes (routine analy12). For each such segment, it decides how many voices – out of the 9 available on the chip – will be assigned to the piano soloist (right hand and left hand separately), and how many to the orchestral accompaniment. At present the accompaniment is played by strings only; I might add horns, but they don't blend well on my midi. There is also melody enrichment, by adding new voices based on the piano 'hands' or the accompaniment.

      Every time a motif starts in the canonic voices, there is a random instrumentation change: the motif may be assigned to some other instrument , not to the piano. This is done with small probability; the motif, obviously, gets transposed to the range of that instrument. Currently, I use a few wind instruments and the solo violin.

      There are truly random dynamics, written in the score. Every time you say:

      midi score

      different dynamics will be heard when you play score.mid (on the same notes and durations)

    • Finally, the score is written by the routine compr2scor, and processed to a midi file.

  • solocanon.pl

    This reads the motifs from  mot.txt,  and produces the files  nocoda$random-$size  and  nocoda$random-$size.mid . As their names implies, there is no coda, and the voices proceed independently to completion. However, the result may be interesting because there is built in randomness: every time you run

    midi   nocoda$random-$size

    you get a different   nocoda$random-$size.mid   with different dynamics and another entry time for voice 2.

    The program also writes an intermediate file  pasolo.txt,  to be used by the other programs  bsolo  and  csolo  to create a coda to conclude the piece. This file is just a list of shorties in 8 voices.

    • uses input  mot.txt
    • produces outputs  pasolo.txt,   nocoda$random-$size  and  nocoda$random-$size.mid 
    • based on  amini.pl

  • bsolo.pl

    Here we consider the harmony between the (up to) eight voices, to discover a cadence near the end, on which to end the piece. This is done by gathering chords and checking versus a big list of acceptable cadences. If none is found,   bsolo  exits and the driver program   tri.pl  will call   csolo,  to supply a coda otherwise.

    If a cadence is found, then the durations of the notes around it are modified, to emphasize it. A few preceding chords are also reset to belong to the scale of the final cadence. The coda is attached to the previous canon, with a suitable rallentando, and the score is written.

    • inputs:  mot.txt,  pasolo.txt
    • outputs:  canonscore.txt ,  cancodascore.txt . Both are volatile, used to produce  bx$random-$size .
    • based on  yabmini.pl

  • csolo.pl

    This is called only if  bsolo  fails, i.e. cannot discover a cadence. Then  csolo  looks for a long sequence of shorties, towards the end, all belonging to some scale (tonality) . It then supplies a final close in that scale, with the same procedure as above:

    • duration adjustment
    • rallentando
    • truncate the canon at the cadence

    The resulting files are  canonscore.txt ,  cancodascore.txt .
    • inputs:  mot.txt,  pasolo.txt
    • outputs:  canonscore.txt ,  cancodascore.txt . Both are volatile, used to produce  by$random-$size .
    • based on  cmini.pl

  • tontoc.pl

    This name is an abbreviation for "tonal toccata". Actually, the piano plays not a toccata (rapid repeated notes) but rather arpeggios over a wide range, trills and blocked chords. Well, at least all of them are tonal.
    • The program uses as input the files  parm.txt,   tonalac.txt   and   can0n.txt.

    • It calls first  pianoscor,  to write the piano parts, in up to 4 voices. In general, all the 4 voices are full.

    • Since almost every shorty has an accompaniment chord, the piano part is almost always active. The routine  toobusy  erases part of the accompaniment score (when the motifs are repeated more than 5 times) This is done at random, with probability 15%.

    • The routine  orxcor  fills in the orchestral parts, which play the canon. It uses strings and horns, and occasionaly the piano, if one hand is available ($FREHAND is true). There are up to 5 orchestral parts, some usually empty.

    • Crescendo/decrescendo instructions are added to all voices, by the routine  vvol  (vary volume). The volume levels are completely random, and each compilation of the score will generate a midi file with distinct dynamics.

    ---

    subroutines of twelver.pl

    ---

    • sub compr2scor

      This writes everything before the coda. Because of a bug (no, a feature!) it may overlap a little with the coda: the last notes of this score get repeated in the 1st five chords of the coda. Why not? the piece is not serial.
      In all voices, identical notes get slurred together (accross bars, sometimes accross motives). This irregular and busy series of attacks in the accompaniment produces a rather pleasant effect (i.e. I like it).

    • sub coda

      This sets up the coda instrumentation; all 9 midi channels, or voices, play (the routine codainstru, a really bad piece of code). Then it writes the coda score, which consists of precisely 5 chords of equal duration, followed by longer chords supporting the melodic cadence: LA SI DO or SI DO DO.

      The result is the file cancodascore.txt, which will serve as coda to both concerto movements.

    • sub analy12

      It takes as input the uniform table notes[voice][row] and produces the new table compr[voice][row] and the hash voices : number of columns (or voices) for:   right hand,   left hand,   accompaniment.
      The table notes has 16 voices/columns; compr has 9 voices/columns, for the 9 midi channels, but some may be empty. At each row of compr one may check how many voices/columns for the piano (two hands separately) and orchestral accompaniment.

    ---

    subroutines of tontoc.pl

    ---

    • sub pianoscor

      The piano parts are developed from 4-notes accompaniment chords, so they take up to 4 voices (in the range 5 to 8). The routine gathers in a chord all the identical accompaniment over contiguous shorties. If the chord is long, the piano plays Mannheim rockets on that chord (one hand, or both). If it is short, the piano plays a blocked chord in one hand, sometimes with a trill in the other. With a certain probability, both Mannheim rockets and trills are assigned to some other instrument, not the piano. In any case, there is a variable  $FREHAND,  set to true if at least one piano hand is not active. This is used later in  orxcor,  to add piano to the purely orchestral voices.

    • sub vvol

      vvol  simply follows each voice, and inserts a

      vvol rand/8+32 $dur

      instruction every 70 shorties or so.  $dur  is computed so the  vvols  don't overlap, and  rand/8+32  results – at play time – in a value between 32 and 63 (the midi dynamics are 0 to 63, and values below 20 are not audible on my computer)

    • sub pre2scor

      The four routines pianoscor, orxcor, toobusy  and  vvol create a new table  @pretxt,  as follows (in this example the shorty is 1/12, a triolet) :

                          pretxt

      	voice 0	voice 1	voice 2	voice 3	voice 4	voice 5	voice 6	voice 7	voice 8
      382	e5 1/12	nil				ins=BrightAcoustic e3 1/12	g3 1/12	b3 1/12	eb4 1/12
      383	f5 4/12	nil				c6 3/12	Ab5 3/12	r 3/12	ins=Clarinet tril 7 ( eb4 3/12 f )
      384	nil	nil				nil	nil	nil	nil
      385	nil	nil				nil	nil	nil	nil
      386	nil	d4 14/12					Bb4 1/12	d5 1/12	f5 1/12
      387	f#5 1/12	nil				d4 1/12	eb4 1/12	f#4 1/12	Bb4 1/12
      388	ins=StringEnsemble2 g3 1/12	nil					b5 1/12	d6 1/12	g6 1/12
      389	f#3 1/12	nil					f#4 1/12	a4 1/12	d5 1/12
      390	e3 1/12	nil				ins=AcousticGrand b4 1/12	ins=AcousticGrand d5 1/12	ins=AcousticGrand e5 1/12	ins=AcousticGrand g5 1/12
      391	f3 4/12	nil						d3 1/24 f3 1/24 Bb3 1/24 d4 1/24 f4 1/24 Bb4 1/24 d4 1/24 Bb3 1/24	Bb4 1/24 d5 1/24 f5 1/24 Bb5 1/24 d6 1/24 f6 1/24 Bb6 1/24 d7 1/24

      The table entries are text ready for the score, i.e. mostly notes or groups of notes, and also instructions: trill (), vvol , ins= , etc. Empty cells are rests, each lasting one shorty. The cells containing nil are meant to be ignored completely. For instance, voice0 plays at 383 f5 4/12; this is followed by 3 nil cells, because the note f lasts four shorties, so the next note – f#5 1/12 – starts at 387, nothing intervening.

                         All of the above is basically a memo to myself.

      The routine pre2scor converts the table to a score, by reading along each column (i.e. voice or channel). It copies notes and instructions, sums and outputs rests, and skips nils. This is the file  dblscore.txt.

    
    

    ---

    ---