Eastman School of Music
Revised by Alexander R. Brinkman
Eastman School of Music
Revised version of Manual Copyright <c> 1990 by Alexander R. BrinkmanVersion 1.1SCORE-11 copyright <c> 1982 & 1990 by Alexander R. Brinkman
Use is restricted by software license
Multiuser sites may make copies of this manual for internal use, so long as this copyright notice is included.
3 Keywords Descriptions
3.1 Keywords Requiring a Parameter Number
220.127.116.11 Ties in SCORE-11
18.104.22.168 Proximity Mode
3.1.7 Move and Movex
3.1.8 Random Selection
3.1.9 Rlist and Rnotes
3.1.10 Combining Keywords
3.2 Keywords Not Requiring a Parameter Number
3.2.6 Tfactor and Ampfac
3.3 CSOUND Statements
PART II: SCORE-11 Reference
4 Summary and Reference
Proximity, See Notes
Reciprocal Duration Code
Ties, See Rhythm
Time, See Score Time
Over the past decade computer sound generation has retained a fundamental separation between an instrument (a sequential “flow” of sound processing modules) and a score (note or event list), which turns the individual instruments on and off. The person working with computer generated sounds must define instruments to produce the sounds that he wishes, then specify how those various sounds interact.
An instrument is usually designed to accomplish a general task such as amplitude modulation or making a glissando between two pitches. In an instrument definition, however, several specifics (parameters) like pitch, volume, or timbre are usually left unresolved so that the instrument is capable of many similar but different sounds. Timing (rhythm) and these other specifics are notated in the score file for CSOUND. The CSOUND compiler reads this score file, finds out which instrument is asked to play, and then copies the parameters (or fields) of a note statement into this instrument for this particular note. So, if the fourth number (parameter) of a note statement is intended to store the pitch of a tone, then in the instrument definition there must be a place set aside (by using a temporary “p4”) which will later receive this value. This temporary variable (p4) must be located in a position within the instrument which properly affects the pitch (frequency) of the sound. The topic of instrument design is not covered in this manual.
The task of defining every note of a composition is not new to a composer. What is new in computer music is the depth of control over acoustic details. The composer who uses the computer must evaluate and express in numbers his musical ideas then notate them in a specific, totally resolved syntax. The user is free to type in directly to a score file the hundreds of individual note statements that make up a section of music. The probability of typographic errors alone is enough to discourage this method. Fortunately in most music several similar notes may be grouped together into a single event so that a more general specification can describe several notes. Foir instance, a crescendo over several hundred very short notes requires several hundred different amplitude values representing the increasing volume. Typing in several hundred note statements each with a slightly larger amplitude number would take forever. If the computer could be instructed to gradually increase the amplitude value over twenty seconds then life would be much simpler. This is the type of job that a note list preprocessor is designed to accomplish.
SCORE-11 (Brinkman, 1981 & 1990) is a note-list preprocessor for the CSOUND compiler, which was written by Barry Vercoe at MIT. SCORE-11 was written by Alexander Brinkman of the Eastman School of Music. The SCORE-11 input syntax is based, with some important extensions, on the well known “SCORE” program (used on the Stanford-Ircam MUS10 system) by Leland Smith (Smith, 1972 & 1980). A composer who is familiar with either preprocessor will have no problems changing to the other one. This will reduce dependency on a specific music system. Some features of SCORE were not implemented in SCORE-11. These are mostly the features that allow data to be copied from one instrument block to another. Several features wer added to SCORE-11 to make it very powerful.
SCORE-11 is written in the PASCAL programming language, increasing its potential for exportability. You will find SCORE-11 to be of great help in the process of defining the hundreds of events that make up a composition. In the following pages you will find a comprehensive manual introducing and describing in detail the various features of SCORE-11.
 SCORE-11 was originally designed for Vercoe’s MUSIC11 system. MUSIC11, which was written in PDP-11 assembly language, was replaced in 1986 by CSOUND, a version of the program written in the programming language C, and which runs on many different computer systems. SCORE-11 works well with either version of Vercoe’s program, which will be referred to as CSOUND in this manual except where the distinction is important.
Basics of SCORE-11
Any keyword may be abbreviated by the first two letters except for movexwhich is abbreviated by mx.
Keywords requiring a parameter number:
Keywords not using a parameter number:
5. instrument (valid as ‘i’)
6. parameter (valid as ‘p’)
12. ‘*’ followed by any CSOUND (or MUSIC11) score opcode
The output of SCORE-11 is a file containing a note list formatted in the proper syntax to be read by the CSOUND score file scanner. This file is in common ASCII coding, allowing you to type or edit the file at a terminal. This file will contain the information for many instruments, yet the data for one instrument is completed before another instrument begins it’s own list. In other words, all data for instrument 1 may precede that for instrument 2 even though they might be playing at the same time. When the CSOUND compiler reads this file it sorts it by the begin times of every note statement so that note statements from many instruments will be integrated. Bothe the SCORE-11 output file and the sorted note list are temporarily available to you. If you wish to save either of them you must rename it or else it will be written over when you use SCORE-11 or CSOUND again.
An input file to SCORE-11 is created by using the text editor. Once you have finished creating this input file you must execute SCORE-11, which will create an output file called sout(score output). To run SCORE-11 type:
where filename is your prepared input file. The output file (sout) will contain the result of your instructions specified in the input file. If you want to save this output, then rename it as follows:
mv sout newname
where newname is the new file name.
 This command will be different in an operating system other than UNIX.
When the music compiler reads a note list it first parses each note statement into “fields.” These fields are each assigned a “p” (parameter) number starting with the name of the instrument that is to play.
p1 p2 p3 p4 p5 p6 p7 etc.
i3 0.0 1.2 8.01 1000 1 .05
SCORE-11 makes some assumptions about the relationship between the instruments and the note statements. Parameters (or “p” numbers) one through five will have the same effect in all instruments. This convention should be followed if you expect all of the features of SCORE-11 to behave properly.
The SCORE-11 constant parameter meanings are:
p1 = Instrument number
p2 = Starting time for this note (in beats)
p3 = Duration for this note (in beats)
p4 = Pitch (or frequency)
p5 = Amplitude value (0 – 32000)
The maximum number of parameters allowed in a single note statement is 100. Parameters six through 100 may be anything that you wish, but the instrument’s temporary parameters will have specific expectations about what type of information it finds in a certain field of the note statement. Be careful that you know what a certain parameter will affect. If the instrument expects to find ten parameters, then any parameter after the tenth will be ignored. If, however, it only finds eight parameters and needs ten, an error condition will result and this entire statement will be ignored (the note will not play).
Within the input file to SCORE-11 you will be defining what data the parameters of the score will contain. Many instruments’ data can be defined within a single file. To keep them separated, the specifications for each instrument are contained within an “Instrument block” (I-block). The I-block is delimited by a line starting with the word instrument. This is followed by several lines each usually beginning with the word parameter. The I-block is terminated with a line beginning with the keyword end. Each statement in score must be terminated with a semicolon. The following is an example of an I-block:
instrument 1 0 10; < Instrument 1 starts at time
< 0 and plays for 10 beats.
parameter 3 1; < Each note lasts 1 beat
end; < This finishes the I-block
Notice the convention above that a “<” symbol begins a comment field. Comment fields last from a “<” until the end of the current line. Comments make it possible for you to document what you are doing. Comments are optional (although recommended) and are totally ignored by SCORE-11. Another convention is that any keyword may be abbreviated by its first two letters. The only exception to this is movex, which is abbreviated by mx. In addition, two common keywords may be shortened to one letter:
parameter = 'p'
instrument = 'i'
To make an instrument block easier to read it is helpful to indent all lines except for the instrument and end keyword lines. Sometimes it is helpful to inset some special character to set off sections of a command line. Spaces and commas serve this purpose in SCORE-11. The following lines are equivalent. They instruct instrument 3 to start at beat 5 and play for 10 beats.
i3 5 10;
instrument 3 5,10;
in3 5 10;
The information contained within an I-block affects only that instrument’s data (local data) but anything specified outsied an I-block will affect all instruments that follow (global data). This is very important in understanding the operation of SCORE-11.
Parameter statements in SCORE-11 are always terminated with a ‘;’. Any statement may span several lines by typing a “return” and then continuing the information on the next line. Don’t allow the screen to “wrap around” as SCORE-11 only expects lines up to eighty characters (one width of the screen).
There are two ways to specify how long SCORE-11 will put out note statements for a particular instrument. The first line of the I-block determines which method SCORE-11 will use. The first method is to notate the number of beats you wish the instrument to play. The basic format for this is:
instrument "number" "starting beat" "duration in beats"
instrument 3 2 6; < instrument 3 starts at
< beat 2 and plays for 6
The other method is to specify how many notes will be played by this instrument regardless of how long or short each note is. This basic format is:
instrument "number" "starting beat" 0 "number of notes"
instrument 3 10 0 134 < instrument 3 starts
< at beat 10 and
< plays 134 notes
The ‘0’ (zero) is needed as a place holder and should be typed between the “starting beat” and the “number of notes.”
All start and duration times are specified in score time. Score time is not necessarily a measurement of seconds but rather a measurement of beats or time units. If no tempo specification is made each beat is equal to one second (MM = 60). The tempo can be varied, or set to other values (e.g. MM = 96) by means of a tempo statement (see section 3.2.5). Tempo specification also allows you to make accelerandos and ritardandos.
SCORE-11 is set up to handle two types of numeric data: real numbers (numbers containing a decimal part) and integers (“whole” numbers not containing a decimal part). If you are expecting to output a real number then you must input a real number. The following statement will cause an interpolation from the number 1 to the number 10 over five beats:
p7 move 5 1 10;
The numbers output from this statement will all be integers (1, 2, 3, 4, 5, 6, 7, 8, 9, 10). The statement:
p7 move 5 1. 10.;
causes a similar interpolation, but because the decimal points were added the output will be real numbers (1.0, 2.333, 3.666, 4.75, …). Do not mix integer and real numbers as data. This can result in integers being output where you need decimal numbers. (We will come back to the move statement later).
Real numbers are rounded to three places in SCORE-11 output, although the program uses greater precision internally:
3.1416798 = 3.142
6.7934253 = 6.793
The folowing keywords require a parameter number to tell SCORE-11 which field of the note statement is to receive the result of computation. Any of the keywords can be used to put data into any parameter number. In section 3.1.2 we will see that these keywords can be combined, or “nested.” Remember that all SCORE-11 statements are terminated by semicolons.
The parameter that controls the duration times of the notes is p3. The number found in the third field of a note statement will be the duration in seconds of a single note. SCORE-11 has a keyword for entering timing data in a more musical notation. You can encode rhythms using numbers representing subdivisions of the beat. In SCORE-11 the default value for the beat is the quarter note with a duration of one second (MM = 60). We will see how to change both of these values later. In rhythm lists, each duration is represented by the reciprocal of the standard fractional duration (8 = eighth note, 4 = quarter note, etc.).
Rhythmic Value SCORE-11 code Time in Beats
Whole note 1 4.0
Half note 2 2.0
Quarter note 4 1.0
Eighth note 8 0.5
Sixteenth note 16 0.25
Thirty-second note 32 0.125
The duration code for any arbitrary subdivision can be determined by multiplying a duration code by the number of subdivisions of that duration code. For example each note of a triplet is encoded 12:
4 (a quarter note) X 3 (subdivisions in triplet) = 12 (code)
Similarly a fifth of a half note is encoded 10 [2 x 5] and a 67th of a whole note is encoded 67 [1 x 67]. A tied note is indicated by putting a comma between code values. This is an exception to the rule that commas are ignored – they must be used to specify a tied value. The rhythm
could be encoded as: 4 8 4 8 2
or 4 8 8, 8 8 2
Each different note must be separated by a slash ‘/’. This is used consistently in SCORE-11 when you build up a list of code numbers. So the above example becomes:
p3 rhythm 4/8/8,8/8/2;
 The slash actually terminates each item in a list, although it may be omitted before the semicolon at the end except when the last item is to be repeated: item/item/item/item//;
Any dotted rhythmic value may be specified by adding a dot ‘.’ after the note. Multiple dots have the same effect as in normal music notation.
is encoded p3 rh 4./8/8./16/2.;
A rest is indicated by preceding the rhythmic value of the rest with a minus sign ‘-‘. For “tied” rests place the minus before the first note only.
p3 rh 4/-4./8/4/-16/16/-16/16/-8./16/4;
p3 rh 4/-4,8/8/4/-16/16/-16/16/-8./16/4;
A duration that is repeated can be abbreviated using two methods. An added ‘/’ will repeat the previous value. If it is repeated more than one time you can either add more slashes (‘/’) or use a multiplier symbol. The multipliers are ‘*’ or ‘x’ in SCORE-11. The symbol will come after the initial value to be repeated and must be followed by an integer repetition count.
could be encoded
p3 rh 8./16/////8//12///4;
p3 rh 8./16*6/8*2/12*3/4;
Beware!! ‘2 * 8’ is not the same as ‘8 * 2’. The first is eight half notes, the second is two eighth notes. Using these rules many arbitrarily complex rhythms can be encoded. Another example:
is encoded as
p3 rh 4,20/20*4/6///-24/24*3/12,2;
Within the rhythm list you may also use a notation known as grouplets. A grouplet is introduced by a left parenthesis ‘(‘. This is followed by the rhythm code to be used as the time span for a rhythmic pattern, an equal sign ‘
‘=’, and the rhythmic pattern itself. The grouplet is terminated by a right parenthesis. Example:
Could be encoded: (2=4*3)
Read this as “in the time of a half note play three quarter notes.” Grouplets may be nested, i.e., grouplets may themselves contain grouplets. A more complex example using nested grouplets follows:
This would be encoded as
p3 rh (2=4/16/8/16/ (4=16//-16/16));
The multiplier symbols may be used in grouplets, and grouplets may tie into single notes or other grouplets:
p3 rh (2=4*3)/, (2=8*5);
Following the keyword rhythm, ties are encoded as commas, which may occur anywhere in rhythm code. The “tie” (comma) may be encoded after the first note or before the second note.
Code: p3 rh 2,4..; [or 2,/4.. or 2/,4..]
Code: p3 rh 4,/(4=8*3),/4; [4/,(4=8*3)/,4]
Code: p3 rh 4,/(2=4./8/4),/2;
Code: p3 rh 2/(4=8./16/8),*3/4;
Code: p3 rh (4=8./16/8)*,/4;
p3 rh (4=8/16/8)*3/,4;
Remember that grouplets may contain grouplets, and that grouplet “nesting” may be arbitrarily deep:
p3 rh (2,4.=(4=16/-32/32/16./32/16)/,4../16,/(4=8*3))/8;
The beat code word may be used to make some value other than a quarter note equal to a single time unit.
beat 2; < reset so that half note = 60
beat 4.; < reset so that dotted quarter = 60
beat 4; < set back to quarter note = 60
Once beat is changed it remains in effect until it is changed again (global data). Beat must precede rhythm to have effect.
If you specify that an instrument should play either 1) more notes than there are rhythmic values or 2) a longer duration than the cumulative total of the specified rhythmic values, then the entire list of rhythm codes will start over. This will occur until the instrument has exhausted its playing duration or its note quota. This can be very useful for creating rhythmic loops. For example,
could be encoded as:
i1 0 9; < play 9 time units
p3 rh 12///4./8; < use this rhythmic
The loop feature is valid for all list building keywords of SCORE-11. In the description of the various keyword unless it is noted that the keyword will not loop, you may assume that it will loop.
This keyword tells SCORE-11 that a list of numbers (real or integer) is to be entered into the parameter specified at the beginning of the statement. Instead of using rhythm for a note duration you may use numbers and directly enter time values. Commas have no meaning in this case.
Because in computer music we use numbers to represent changes in data, you will use numbers a great deal. The type of data printed in the SCORE-11 output file is consistent with the type of numbers in the numbers list, i.e., use decimal numbers to output real numbers; omit the decimal point to output integers.
As mentioned before, SCORE-11 expects the pitch information (at least the starting pitch) to be found in p4. One could enter the exact number of cycles per second (Hertz) into a pitch controlling parameter using numbers.
p4 nu 440/880/262.396// ...;
This obviously is tedious and forces one to have a table of Hertz values for the tempered scale around. CSOUND has several nomenclatures for pitch (still using numbers).
p4 nu 8.00/8.01/8.02/8.03 < Middle C to E flat
< in octave point
< pitch notation.
SCORE-11, however, has a much easier method for entering pitch data using names (including accidentals and octave designations). The octave that you specify will be in effect until you explicitly change it. Accidentals are specified by appending the letter ‘s’ (sharp) or ‘f’ (flat) after the note name. This has the effect of lowering (f) or raising (s) the pitch one tempered semitone. Double or triple accidentals are valid and simply require more symbols to be added to the note name.
p4 notes c/cs/d/df/c;
is equivalent to:
p4 no c/df/css/cs/dff;
The octave number is added after the accidental (if any). Middle C (261.63 Hertz) begins octave number four. Each C begins an octave and B terminates an octave. Middle C then is notated as ‘c4’. The B one semitone below is ‘b3’ and the B a major seventh above is ‘b4’. One semitone higher than ‘b4’ is ‘c5’. Remember that when you change octaves you muxt explicitly rename the octave.
 CSOUND does not use standard octave numbers. CSOUND designates the middle octave as octave 8. SCORE-11 adds 4 to each octave number on output when note lists are used, but not when number lists are used.
The chart below shows the standard octave designations.
When a melody is constantly going across an octave boundary the above method can be confusing and easily lead to errors. In proximity mode SCORE-11 assumes that no leaps larger than a perfect fourth will occur and will reset octave numbers to accomplish this effect. Thus if your melody constantly crosses octave boundaries it will be easier to code notes in the proximity mode. This mode is entered by typing a ‘p’ before a note name.
p4 notes c4/b3/d4/bf3/ef4;
can be encoded as:
p4 notes p c4/b/d/bf/ef;
In the proximity mode tritone leaps stay within the same octave class, i.e.:
p4 p c4/fs/c/b/f;
is equivalent to
p4 notes c4/fs/c/b3/f3;
Larger leaps can be accomplished by adding an octave number to a note:
p4 notes p c4//e3//f//g/bf/ef/c/bf;
is equivalent to
p4 notes p c4/c4/e3/e3/f3/f3/g3/ ... ;
Proximity mode is cancelled by typing an ‘o’ before a note name.
p4 no c4/p b/d/bf/o f/c;
is equivalent to
p4 notes c4/b3/d4/bf3/f3/c3;
You may turn the proximity mode on or off at any point in the note list.
Notes can also be used to put out mono-rhythmic chords. To indicate chords separate individual notes by a colon (‘:’).
p4 notes c4:e:g:/d:fs:a/ef:g:bf;
This would produce major chords in a rhythm defined by p3. Repeat slashes and multiplier symbols are valid and the looping feature also applies to notes.
If an ‘r’ is placed in the note list in place of a note name then a rest equal to the duration (p3) will result.
Another useful method for dealing with pitch data is the sets keyword. This allows the user to specify groups of pitches by note names and also specify how long this group (set) will be used for the pitch information. Many sets of pitches can be specified according to the harmonic changes. SCORE-11 will then pick notes randomly from the set in control. For instance:
p4 sets 10 c5 e g/12 d5 fs a4;
will choose for 10 beats (score time) from a C-major triad and then for 12 beats from the notes of a D-major triad. Sets does not limit the number of members in each group. The normal mode of sets is not to allow any repeated notes in the output (although common tones may exist between sets and cause repeats). If you wish to allow repeated notes, then preced the time definition with ‘r’. This places sets in the repeat mode. To return to normal (non-repeat) mode specify an ‘n’ before the time specification.
p4 sets r 5 ds4 e7 c6/n 5 c5 cs b4;
Numbers may also be used with sets.
p7 se 12 1000, 926, 440/r 5 500,12,14000;
(In the above example the use of commas to separate the numbers is optional).
A repeated slash will repeat the entire set for the time length indicated:
p4 sets 10 c5 e g///2 df gs a;
is another way of saying
p4 sets 10 c5 e g/10 c5 e g/10 c5 e g/2 df gs a;
p4 sets 30 c5 e g/2 df gs a;
The repeat characters ‘x’ and ‘*’ are not legal syntax for sets.
Funcs is a keyword very much like numbers, except that it should only be given integer data. It is used to put out function numbers referencing stored waveshapes in CSOUND (see f statements in the CSOUND refernce manual). Funcs will accept both the repeat slash and the multiplier symbols.
p10 fu 5//2//7*4/6/2/8; < use these functions
< for whatever p10 does
This SCORE-11 command is used to create changes in a parameter by specifying only breakpoints and letting a linear (straight line) or exponential (curved line) interpolator fill in the specifics. The following diagram shows linear and exponential curves:
The basic move syntax is:
move "number of beats for change" "first value" "second value"
In SCORE-11 parameter 5 is designated for the amplitude (volume) of an instrument. If the instrument plays 10 notes per second and you wish to make a simple crescendo for 10 seconds then diminuendo for 10 additional seconds you would notate this as:
instrument 5 0 20; < Play for 20 beats
p3 .1; < Play 10 notes per second
p4 no c4/d/e/f/g/a/b/c5; < Major scale
p5 move 10 1000 10000/10 10000 1000; < Crescendo and
As another example, suppose we wish the above instrument to start playing ten notes per beat and end up playing five notes per beat. To change this we will use an exponential move, which seems to be more “natural” for changes of tempo. Also the instrument will raise and lower the pitch as the amplitude raises and falls.
i5 0 20; < Play 20 beats
p3 movex 20 .1 .2; < Ritard
p4 move 10 c4 c6 / 10 c6 c4; < pitches
p5 move 10 1000 10000/10 10000 1000 < Amplitude
It is possible to change from exponential to linear (or vice versa) between sections of a move statement. The default for move is linear and for movex is exponential. The optional code ‘l’ (lower case L) is for linear and ‘x’ is for exponential. The following alternates between linear and exponential interpolations.
p5 movex 2 1 10/1 2 10 1/x 2 1 10/1 2 10 1;
If the ending value of a section is missing, the first value is continued for the time specified.
p17 move 2 10,20/2 10,20/2 40,40/2 40,20;
Unlike most keywords, move and movex will not loop. If the instrument plays longer than the cumulative move times, then the final value of the last section is sustained.
Although random selection in general will be discussed later, one variety of move will interpolate between two ranges of numbers rather than between two fixed numbers. Each range is specified with a lower and upper bound. SCORE-11 will then choose a value between these limits. In the following example a move over 15 beats will start between middle C and the F above, then gradually expand to a very wide range, resulting in a wedge shape. Rhythmic values are dictated by p3; at each time point the pitch is chosen randomly from values between the two curves.
p4 move 15 c4 f c2 c7;
Again, if the final value of “range2” is left off then it is assumed to be the same as the first value.
p12 move 10 100 500, 1000;
is equivalent to:
p12 move 10 100 500,1000 1000;
Multiple moves and repeated moves work as expected as do the ‘l’ and ‘x’ switches. The multipliers ‘*’ and ‘x’ also work with move.
p5 move 10 1. 10.*3;
Remember that SCORE-11 always differentiates between real numbers and integer numbers.
Single numbers or notes may be entered directly into a parameter.
p4 c5; < p4 will always be c5
p10 100.323 < p10 will always be 100.323
Every note that this instrument plays will have the same value for p4 and p10. Expanding upon this idea, it is possible to give a range of low and high values and allow SCORE-11 to pick a number between these bounds for each note. The range limits should be preceded with the number “1” (one), which means that 100% of the time choose a value between the next two numbers.
i5 0 0 50; < Instrument 5 plays 50 notes
p3 1 .1 .5 < Starting at time 0
< 100% of the time choose a
< duration somewhere between
< a tenth and a half of a
< beat (time unit).
end; < Terminate this I-block
Multiple ranges may be given in a single line. A number between 0 and 1 must precede each range. The sum of these “weight” numbers must not exceed a value of 1.1. If the values add upt o less than 1, then the final value will be increased until the total is equal to 1. This random selection works for note names as well.
p4 .25 c5 c6 .5 c2 e2 .25 c4 c5;
< The above will pick a pitch between c5 and c6
< 25% of the time, between c2 and e2 50% of the
< time, and between c4 and c5 the remaining 25%
Other keywords (move, sets) may not be used within random selection.
These keywords accept as input a list of ranges – either numbers (rlist) or note names (rnotes) – separated by slashes. The output will consist of one number (or note name) chosen from each range sequentially.
p4 rnotes c5 c6/f2 f3/c7 e3//;
This output wil first be a note between C5 and C6, then a note between F2 and F3, then two notes (because of the repeat ‘/’) between C7 and E3. If the total number of notes (or total playing time) requires more notes, then the list will loop producing different notes (still within the specified ranges). The repeat characters ‘x’ and ‘*’ are also valid when using these keywords.
p4 rnotes c5 c6 * 4/c7 g7 * 3;
will play 4 notes randomly selected within a range between C5 and C6, followed by three notes between C7 and G7.
Because of the flexible linked data structures used in SCORE-11 it is possible to combine keywords within one parameter, resulting in many interesting possibilities. This is accomplished by following the semicolon that terminates a p-statement with a new value specification without specifying a new parameter number. Consider the following examples:
i1 0 20;
p3 rh 4/8/8/4/8/8; < rhythm list
.1; < single short note
Instrument 1 will play “middle C” for 10 beats. The rhythm, controlled by p3 consists of a rhythm list followed by a single short (1/10 beat or second) value. the resulting rhythm pattern is quarter-eighth-quarter-eighth followed by a short note. This entire sequence then repeats until twenty beats have elapsed.
i2 0 20;
p3 rh 4/8/8; < rhythm list
se 20 .1 .2 .3 .4; < set of real numbers
Above, the rhythmic pattern in p3 of instrument 2 consists of a quarter note followed by two eighths and a short value that is chosen from the set of values .1, .2, .3, and .4 beats. Again, this series of three fixed values and one chosen randomly from a set of values repeats until 20 beats have passed.
i3 0 10;
p4 mo 10 c4 c6; < ascending pitches
mo 10 c7 c3; < descending pitches
p5 mo 10 1000 10000;
In this example instrument 3 plays short notes (1/10 beat) for 10 beats. P4 (pitch) alternates between two move statements, the first ascending from C4 to C6 and the second descending from C7 to C3. The dynamic (p5) is a crescendo. The result is a “double melody” played by alternate notes, with one part ascending and the other descending.
i4 0 10;
p4 mo 10 10 100; < move statement
1.0 500 600; < random selection
se 10 1000 2000 3000; < set of values
In the final example (above) p4 of instrument 4 uses three different types of statements. The first value is chosen by linear interpolation on the ramp from 10 to 100; the second is chosen randomly from the integers between 500 and 600; and the third is chosen from the set of values: 1000, 2000, and 3000. These three events cycle for 10 seconds, using durations of .15 beat.
If you are careful of the types of values that will result, you can combine any of the techniques discussed earlier in this chapter.
All of the previously described keywords required a parameter number that designated the affected p-field in the resulting note statement. In addition, there are several keywords that do not require a parameter number because their job is to affect parameters or variables that already exist.
SCORE-11 makes its random choices by obtaining a pseudo-random number from a mathematic process that simulates a series of random numbers. SCORE-11 begins by setting random number generator. This initial number is referred to as the seed. When you rerun a section using random selection you will get the same “random” sequence. You can get a different sequence by resetting the seed value. To reset the seed type:
The number following rseed may be in the range of 1 to 2147483647. Rseed may be reset as often as you wish either in an I-block (local data) or outside an I-block (global data). It is often placed as the first statement of the input file to SCORE-11. If you wish to return to the initial setting of the seed, its value is 7777. Rseed cannot be used with any other keyword.
Rrest (random rest) will affect the values to be placed in p3 (the duration) by making them negative. A negative value in p3 (remember rhythm) causes a note to become a rest of equal time value. Rrest must be followed by a number between 0 and 1, indicating the percentage of the time notes will become rests. 0 = 0% and 1 = 100%.
rrest .2; < 20% of the notes will be rests
Rrest may be reset as often as you wish (once per I-block). Rrest also may be followed by random selection, move statements, or other list producing keywords.
Rdeviation (random deviation) will cause a random number to be added or subtracted to or from the note’s starting time (p2). This number is usually rather small and is intended to take away some of the precision of the rhythmic values and give the rhythmic flow more “life” or “naturalness.” To limit the range of the random number you must specify a single value after the keyword.
rd .15 < randomly add a number from .15
< to -.15 to the starting time
Move and other keywords may be used with rd.
rd move 10 .1 .2; < move deviation over 10 seconds
< from .1 to .2
rd 1 .2 .01; < randomly reset rd between
< .2 and .01
Duty_factor (du) affects a note’s duration. Du however, has several different possible effects depending on the value following the keyword. Basically a “code” number will be added to the duty_factor to specify which genre of alteration you desire. This alteration affects only the note duration and does not change the attack points between notes as specified in rhythm.
a) If du is a number between 0.0 and 99.999 each note’s duration (p3) will be multiplied by du.
Example: If p3 = 1 and du = .5 then the new p3 will be .5 followed by a .5 second rest. If p3 = 1 and du = 2 then the new p3 will be 2. If there are several notes whose attck points are 1 second apart then there will be a 1 second overlap between notes. A slight overlap can be used to simulate legato articulation. A duty factor of less than 1 is used to simulate staccato articulation.
b) if du is between 100 and 199.999 the constant value du – 100 will be added to the current p3.
Example: if p3 = 2 and du = 102.35 then p3 = 2 + (102.35 – 100). P3 = 2 + 2.35 = 4.35.
c) If du is between 200.0 and 299.999 the constant du – 200 will be subtracted from the current p3. If du – 200 is greater than p3, then p3 becomes negative resulting in a rest.
Example: If p3 = 5 and du = 201.5 then the value subtracted is 201.5 – 200 = 1.5. P3 = 5 – 1.5 = 3.5. The attck points will still be 5 seconds apart because only this note’s duration was changed, not the data going into p3 from rhythm (or whatever is giving p3 its values).
d) if du is between 300 and 399.999 the note’s p3 is replaced with the value of du – 300. Again, the attack times are not affected; only the duration of the note changes.
Example: If p3 = 5 and du = 301.5 then p3 = 301.5 – 300 = 1.5. The information that originally established p3 (rhythm) now has determined how far apart the attack points are and du has determined the notes actual playing duration.
e) If du is greater than or equal to 400, then du – 400 will determine the number of cycles (periods) of a sound that will be heard. The duration of the note then is determined by its pitch.
Example: If p4 = 440 Hertz and du = 10 then p3 = 1/440 * 10 = .022. This is useful when imitating percussive sound such as a marimba, in which decay time is pitch dependent. The attack points are governed by the original p3 data. The pitch of the note is assumed to be found in p4 and may exist as note names, or CSOUND’s octave.decimal, or Hertz. CSOUND’s octave.pitch notation may not be used in p4. The I-block shown below
i2 0 0 10;
p3 rh 4/16////8//4;
p4 no as a4*4/a5//a6;
du 440; < play 40 cycles of each pitch
will result in the following output:
i2 0.000 0.182 7.09
i2 1.000 0.091 8.09
i2 1.250 0.091 8.09
i2 1.500 0.091 8.09
i2 1.750 0.091 8.09
i2 2.000 0.045 9.09
i2 2.500 0.045 9.09
i2 3.000 0.023 10.09
i2 4.000 0.182 7.09
i2 5.000 0.091 8.09
Any of the different du arrangements can also be represented using any keyword of SCORE-11.
du move 10 .6 1.2; < move du from .6 to
< 1.2 over 10 beats
du 1 .1 .2; < randomly choose from .1 to .2
du sets 5 .2 .1 100.5//5 400.5 405 .2;
< use these sets for du
du move 10 410 450; < change duration from 10
< cycles to 50 cycles over
< 10 beats.
Any of the keywords that loop will work when using them to control the duty_factor. Rrest, rdev, and du should be set within an I-block and they will be reset when leaving an I-block (local data).
Besides being able to enter a note’s duration in seconds resulting from a move command there is an easier way to achieve accelerandos and ritardandos. Using the tempo keyword a single instrument’s durations or all of the instruments’ durations may be altered. If the tempo statement appears outside an I-block (global data) all instruments will be affected. If the tempo statements appears within an I-block (local data) only that instrument will be affected. If there is both a global and a local tempo change then SCORE-11 will implement both changes. Be careful because a tempo warp on top of a tempo warp can produce bizarre results (maybe that is what you wanted).
The basic syntax is:
tempo ["type"] "time span" "first tempo" "second tempo"
tempo 10 60, 120; < Tempo moves over 10 beats
If the “second tempo” is missing then it is assumed to be identical to “first tempo” (tempo remains constant for the “time span.”
tempo 10 60; < tempo remains at 60 beats/minute
tempo 10 60 80//10 120/10 120 60;
Tempo above will accelerando over 10 beats from 60 to 80. This will be repeated (‘/’), then stay stable at 120 for 10 beats, then ritard to 60 over 10 beats.
tempo 80; < tempo is reset (usually global)
By default, Tempo uses exponential interpolation. Other rates of change can be specified by a “code” before the “time span.”
The “type” options are:
x = exponential (default)
xi = inverted exponential
l = linear
s = square (deeper curve)
si = inverted square
v d = variable
vi d = inverted variable
The linear curve uses linear interpolation between the two specified tempos. The inverted exponential curve uses the inverse of the exponential curve, i.e., tempo change is more rapid at the beginning of the curve and slower at the end. The “square” curve is similar to the exponential curve, but the curve is slightly “deeper.” The “variable curve” allows the user to control the depth of the curve. In this variation, the v or vi tempo flag is followed by a real (decimal) number, which indicates the “depth” of the curve. The value 2.0 yields a curve exactly like the s flag, and 1.0 yields a linear (straight line) change. A value d = 1.5 would be somewhere in between, and larger numbers, e.g. 3.0 or 4.0 will yield even deeper curves, i.e., slow rate of change at the beginning and very rapid change at the end of the time span. The depth variable should not be negative.
tempo v 2.5 10 60 120; < Use variable curve with
< depth factor 2.5.
< Change from 60 to 120
< beats/min over 10 beats
tempo vi 2.5 10 60 120; < Use inverse of the above
The tempo curve can be changed as often as desired. The tempo statement
tempo 1 10 30 50/x 10 60 80/xi 50 80 40;
indicates a linear change from 30 to 50 beats/minute over 10 beats followed by an exponential change from 60 to 80 beats/minute over 10 beats, and an inverted exponential change from 80 to 40 beats/minute over 50 beats.
Any tempo change resets the default and remains in effect until reset with a different code or when the instrument leaves the I-block (if tempo was local). Note also that “time span” is specified in beats. Before a tempo warp is applied the basic time unit is one second per beat.
After you have run SCORE-11 and seen or heard the results of the expansion, you may not like the overall amplitude, or perhaps the overall tempo is too slow or fast. If you used a lot of move and/or tempo statements, then the thought of adjusting each statement would be rather intimidating.
There are two global adjustments that can easily accomplish a massive tempo or amplitude adjustment. Tfactor acts as a multiplier that alters all data going into p3 after tfactor is set. Ampfac scales each value in p5, again by multiplication. These two adjustments can be set anywhere within the SCORE-11 input file but the most common place would be as the very first statements so that the entire file is adjusted. The setting of tfactor or ampfac is global and the value specified will remain until changed. The default values are both set at unity.
ampfac .5; < cut amplitude (p5) in half
tfactor 2; < play piece twice as fast
Any CSOUND score statement (see CSOUND Reference Manual) may be included in the SCORE-11 output by preceding it with an asterisk ‘*’. These statements must end with a ‘;’ as usual in SCORE-11. Many CSOUND statements depend upon an activation time; these will be properly handled by SCORE-11 and then sorted by CSOUND.
Valid CSOUND/MUSIC11 Score Statements are:
1. A Statement (advance statement; CSOUND only)
2. E Statement ( end statement) If any CSOUND statement follows the last
I-block of a SCORE-11 input file, it must be followed by an
3. F Statement (function definition)
4. I Statement (instrument or note statement)
5. P Statement (purge statement; MUSIC11 only)
6. S Statement (ends section)
7. T Statement (tempo statement)
8. Comment (begins with ';' in CSOUND, 'c' in MUSIC11)
All tempo adjustments within SCORE-11 will affect these CSOUND score statements so that you will be able to coordinate timings.
*i7 20 15 440 1000 10000 1 7 7.9
The above statement, less the asterisk, will be placed into the sout score file.
N.B. SCORE-11 in no way checks the syntax for these CSOUND/MUSIC11 statements. Errors can result if you have not properly specified any of the above CSOUND score statements. Don’t blame SCORE-11; first check your specifications!
Brinkman, Alexander R. “Data Structures for a Music-11 Preprocessor.” In Proceedings of the 1981 International Computer Music Association, 178-95. San Francisco, The Computer Music Association, 1981.
Brinkman, Alexander R. “Data Structures for a Note-List Preprocessor.” Computers in Music Research 1, no. 1 (1989): 75-101.
Smith, Leland. “SCORE – A Musician’s Approach to Computer Music.” Journal of the Audio Engineering Society, 20 (1972): 7-14.
Smith, Leland. “The ‘SCORE’ Program for Musical Input to Computers.” In Proceedings of the 1980 International Computer Music Conference. San Francisco: Computer Music Association, 1980.
Vercoe, Barry. CSOUND, A Manual for the Audio Processing System and Supporting Programs. Cambridge, Mass: MIT Media Lab, 1986.
Description: Ampfac scales amplitueds in score file by multiplying each output in p5 by some specified number. The initial value is 1.0. The setting of ampfac is global and the value specified remains in effect until changed;Syntax: ampfac <number>;Example: ampfac .75 < lower amplitude by 25%
Syntax: beat <reciprocal duration code>;
Example: beat 2; < set beat note to half note
beat 4. < set beat note to dotted quarter
Syntax: <pitch1>:<pitch2>:<pitch3>...<pitch n>;
Example: p4 no c4:e:g/d:fs:a/e:b;
Syntax: < anything
Example: < Comments that run for more
< than one line require a new
< comment at the beginning of
ampfac .75 < lower amplitude by 25%
CSOUND statements (*) Description: Any CSOUND or MUSIC11 statement can be entered directly in SCORE-11. the statement is preceded by an asterisk ‘*’ and continues to the end of the line. Timing information is adjusted for SCORE-11 tempo changes. SCORE-11 does not check the syntax of the CSOUND statement, it simply copies it to the output file.
Syntax: * <CSOUND statement>
Example: *i10 25.0 17.5 10 45 1000
*; this comment will be entered into the CSOUND
*; score file
Duty_Factor (du) Description: Adjusts the duration (p3) of notes, and has no effect on the attack points. This is useful for simulating different types of articulation. If the resulting value is negative, the note becomes a rest. There are several varieties depending on the value v following the keyword:
0.0 <= v >= 99.999: each notes duration is multiplied by v.
100 <= v >= 199.999: v - 100 is added to each note's duration.
200 <= v >= 299.999: v - 200 is subtracted from each note's duration.
300 <= v >= 399.999: v - 300 replaces each note's duration.
v > 400: v - 100 determines the number of cycles played.
Syntax: du <number>
Example: du .5; < shorten each note by half (staccato)
du 100.1 < add .1 beat to each dur. (legato)
du 200.1 < shorten each note by .1 beat
du 300.2 < each note's duration becomes .2 beats
du 410 < play 10 cycles of each note
Funcs (fu) Description: Like a number list, but should only be given integers. Funcs specifies a list of function numbers. This is not really neccessary, since it can be replaced by number lists in SCORE-11.
Syntax: funcs <integer list>
Example: p10 fu 1/4//7*4/2; < use these function numbers
< for whatever p10 does
Syntax: (<grouplet duration> = <rhythm for grouplet>)
Example: p3 rh (4=8/8/8); < quarter note triplet
p3 2/4/(4=8/8./16)/4 < list containing grouplet
p3 (2=4/4/(4=8*3)) < nested grouplet
Syntax: <instrumentt statement> <score-11 statements> <end statement>
Example: i1 0 5;
p3 rh 4/8*6/4;
p4 no c4/d/e/f/g/a/b/c5;
p5 fu 3;
p6 mo 5 1000 10000;
Instrument (i) Description: The first line of an instrument block, specifying which instrument is to play and for how long. The <starting time> and <duration> are specified in basic time units (beats).
Syntax: instrument <number> <starting time> <duration>;
or: instrument <number> <starting time> 0 <number of notes>;
Example: i1 0 10; < instrument 1 begins at beat 0 and
< plays for 10 beats;
i7 5 0 25; < instrument 7 begins at beat 5 and
< plays 25 notes;
Keywords Description: Words with special meaning in SCORE-11. The keyword requiring parameter numbers are: funcs, instrument, move, movex, notes, numbers, parameter, rhythms, rlist, rnotes, and sets. Keywords not using a prarmeter: ampfac, beat, duty_factor, end, instrument, parameter, rdeviation, rrests, rseed, tempo, and tfactor.
Syntax: All keywords can be abbreviated to the first two letters. Instrument and parameter can be abbreviated to one letter. All letters after the first one or two significant ones are ignored by SCORE-11. SCORE-11 is not case-sensitive, i.e., upper case letters are translated to lower case when read.
Example: Instrument 3 0 20; < all of these are equivalent
Instr 3 0 20;
in 3 0 20;
i3 0 20;
Lists Description: Many keywords take lists of values, which will be placed in appropriate parameters in note statements in the output file. The basic format is the same for each type of list. Each element of a list is terminated by a slash ‘/’, although this may be omitted before the semicolon that terminates the list. Each element may be a single value or a value followed by ‘*’ or ‘x’ and a repetition count. A repeated slash ‘/’ indicates that the previous element in the list is to be repeated. In addition, rhythm lists may contain grouplets. If the instrument requires more values than there are elements in the list, the values in the list are repeated cyclicly. This is useful of creating “loops.”
Syntax: keyword element-1/element-2/element-3/ ... /element-n;
Example: p3 rhythm 4/-8/8/4/8//2./(4=8*3);
p4 notes c4/cs/r/e/gs/g//;
p5 numbers 10000/1000*3;
p6 sets 10 1 3 5 7 9 11/5 2 4 6 8 10;
Move/Movex (mo/mx) Description: SCORE-11 statements that cause interpolation between values. Move is a linear interpolator and movex is an exponential. Move statements do not loop; if the instrument plays longer than the cumulative durations, the final value in the last move is sustained. The <duration> is specified in basic time units (beats). The values <value> may be numberic or note names. If integer values are used, integers are printed in the output; if real numbers are used, real numbers are printed; if note names are used, the output is in oct.pc notation rounded to the nearest equal tempered pitch. The move statement can take two or four values. The two-value form indicates interpolation between <value-1> and <value-2>. If <value-2> is omitted it is assumed to be identical to <value-1>. The four-value form indicates a starting range (<value-1> and <value-2>) and a terminal range (<value-3> and <value-4>). This indicates two curves, one from <value-1> and <value-3>, and another from <value-2> to <value-4>; whenever a value is required, it is chosen randomly between these two curves. If <value-4> is omitted it is assumed to be identical to <value-3>. Move and movex can also take lists of move segments terminated (or separated by) slashes, and segments can be repeated by the multipliers ‘x’ or ‘*’ as in other list types. Each segment can be preceded by one of the flags ‘x’ (exponential) or ‘l’ (linear), indicating whether the interpolation for this segment is to be linear or exponential. Thus the keyword indicates only the initial type, which may be overridden at any time.
Syntax: move[x] <duration> <value-1> <value-2>;
or: move[x] <duration> <value-1> <value-2> <value-3> <value-4>
Example: p5 mx 10 1000 10000; < exponential interpo-
< lation over 10 beats
< from 1000 to 10000
p6 mo 5 0.0 1.0/9 1.0 0.0; < linear interpolation
< from 0.0 to 1.0 over
< 5 beats and from 1.0
< to 0.0 over 9 beats
p4 mo 20 c3 c4 c6 c6; < notes chosen at ran-
< dom over 20 beats.
< starting range = c3-c4
< final is unison c6
Note Name Description: An element in a note list. The note is specified by a note name (c, d, e, f, g, a, b) optionally followed by accidentals (‘s’ = sharp, ‘f’ = flat) and an octave (0-8). Multiple accidentals are indicated by repeating the sharp or flat symbol. SCORE-11 uses standard octave numbers (4 = middle octave), and adds 4 to each octave on output for compatibility with CSOUND/MUSIC11. In addition to note lists, the numbers may be used in move statements, in random selection, and as single values in parameter statements.
Example: p4 de; < the note d in ocatve 3
pr efr; < e-flat in octave 4
p4 fss2; < f-double sharp in octave 2
Notes (no) Description: Note lists take a list of note names as arguments. The note names are specified as shown above. Normally the octave number stays in effect until it is changed, and the octave must be changed explicitly when necessary. In proximity mode no leaps larger than a perfect fourth occur unless the octave is reset explicitly, and tritone leaps are kept within the same octave. Proximity mode is entered and left at any time in a list by typing the flag ‘p’ (proximity) or ‘o’ (off) before a note name. The default is “off.” The letter ‘r’ in a note list indicates that the note is to be a rest.
Syntax: notes <note list>
Example: p4 no e4//r/t//r/e/d/c//d/e//d//;
p4 no g*3/ef/r/f*3/d/r;
p4 no p c5/b/c/d/e/f/b4/c;
Numbers (nu) Description: Number lists contain lists of numbers, which may be either integer or decimal. SCORE-11 matches it’s output to the input, i.e., an integer or real number in a number list results in the same type of value in the output file.
Syntax: numbers <number list>;
Example: p3 nu 1/.5 * 3/2/1//;
Numeric Representation Description: SCORE-11 uses real and integer numbers. Integers are whole numbers (with no fractional part). Real numbers use a decimal point to indicate a fractional part. In general the type of number entered in SCORE-11 is the same as the type output in the score file. Numbers are used often in computer music to represent all sorts of things, from amplitude to pitch frequencies (in cycles per second), to stereo placement. CSOUND also uses a number of different numeric pitch representations, e.g., octave.decimal, octave.pitchclass. Commas are not used, except to indicate ties in rhythm code. Decimal numbers may begin or end with the decimal point.
Syntax: integer: [+ or -]<digits>
real: [+ or -]<digits>.<digits>
Example: p4 4.06; < real numbers
p5 15000; < integers
Parameter (p) Description: The parameter keyword indicates the parameter number that will be affected by the following information. Parameter is followed by an integer number. The user specifies values for p3 …; p1 is obtained from the i-statement, and p2 is calculated by SCORE-11.
Syntax: parameter <number>;
Example: parameter 3 1; < parameter 3 has value 1
p4 c5; < parameter 4 is assigned c5
p5 15000; < parameter 5 has value 15000
p20 .25 < parameter 20 has value .25
Random Selection Description: Random selection allows random choice of values within specified limits. The syntax consists of a series of one or more 3-tuples in the form shown below. The <percent> is specified as a real number between 0 (0%) and 1.0 (100%). For each percent, <value-1> and <value-2> are the limits within which the random value is to be chosen. These limits may be real or integer numbers or note names. The sum of <percent-1> through <percent-n> must be less than or equal to 1.0. If the total is less than 1.0, the last <percent> is increased so that the total is 1.0.
Syntax: <percent-1><value-1><value-2> [ ... percent-n <value-1><value-2>]
Example: p3 1.0 1.0 5.0 < 100% of values between 1.0
< and 5.0
p4 .25 c2 g2 .75 c3 c5; < 25% between c2 and g2
< 75% between c3 and c5
Recriprocal Duration Code Description: In Reciprocal Duration Code each duration is encoded as the reciprocal of the standard fractional duration, e.g., 1 = whole note, 8 = half note, 16 = sixteenth note, etc. The duration for any arbitrary subdivision can be determined by multiplying a duration code by the nuimber of subdivisions of that code. For example each note in a triplet is 12
4 (a quarter note) x 3 (subdivisions in triplet) = 12 (code)
Similarly a fifth of a half note is encoded 10 [2×5] and a 56th of a whole note is encoded 56 [1×56].
Dots have the same meaning as in conventional music notation. A rest is indicated by a negative number. A tie is indicated by a comma. Reciprocal Duration Code can only follow the keyword rhythm, although you may use a “short” list of one element.
Syntax: <rcode> = <duration code>[<dots>]
<rdc> = [-]<rcode>[<comma><rcode>...]
Example: p4 rh 8.; < dotted eighth
p4 rh 4,8..; < quarter tied to doubly-
< dotted eighth
p4 rh -16; < a sixteenth rest
Rdeviation (rd) Description: Random deviation causes a random number to be added to or subtracted from each note’s starting time (p2). This number is usually rather small and is intended to take away some of the precision of the rhythmic values and to make the rhythmic flow seem more “natural.” Internally, a random number in the range + or – <number> is generated and added to a variable value (initially 0), which is then added to the note’s p2. This allows for a gradual drift in either direction, which should average out to 0 over time. The initial value of rdev is 0.0 (off). Move and other keywords can be used with rdeviation.
Syntax: rdeviation <number>;
Example: rd .15; < randomly add a number between -.15
< and .15 to cumulative random
rd mv 100 0 .2; < gradually increase random
< deveiation over 100 beats
Rests Description: Rests are indicated by negative numbers in the duration field (p3). A rest can be entered in a rhythm list as a negative number, and in a note list by an ‘r’. In a rhythm list, only the first number is negative in “tied” rests.
Syntax: rhythm: -<reciprocal duration code>
Example: p3 rh 4/-8,16/8; < rest in rhythm list
p3 rh 3/-8./8; < equal to the above
p3 nu 1.0/-.1/.5/1.25 < rest in number list
p4 no c4/r/cs/e/r//; < rests in note list
Rhythm (rh) Description: Elements in rhythm lists are values in reciprocal duration code and grouplets (see above). As in other list types, elements can be repeated by repeating the slash ‘/’ or by use of a repetition count. Beware: 4*8 is not the same as 8*4; the first is eight quarter notes, and the second is four eighth notes.
Syntax: rhythm <rhythm list>
Example: p4 rh 4/8//4./-8/16//;
p4 rh (4=8./16/8)*4;
p4 rh q,/(2=4/4/4),/2;
Rlist (rl) Description: Rlist accepts a list of 2-tuples separated by slashes. The output consists of one number chosen from within each range sequentially. the <values> may be real or integer numbers. As with other lists repeated slashes and repetition counts can be used to repeat elements, and the list repeats if extra values are needed.
Syntax: rlist <value-1> <value-2> [/<value-3> <value-4>
Example: p7 rl 10000 20000/500 700/800 1000/50 100;
< choose 1st value between 10000 and 20000
< choose 2nd value between 500 and 700
< choose 3rd value between 800 and 1000
< choose 4th value between 50 and 100
Syntax: rnotes <value-1> <value-2> [/<value-3> <value-4>
Example: p4 rn c4 b4//g5 b5/d2 bf7;
< choose 1st two notes between c4 and b4
< choose 3rd note between g5 and b5
< choose 4th note between d2 and b-flat 7.
Rseed (rs) Description: SCORE-11 makes its random choices by using a pseudo-random number generator of the linear congruential type. The seed value is initially set to 7777. You can reset the seed at any time via the rseed command, using any value between 0 and 2147483647. Rseed can be set either in an I-block (local data) or outside of one (global data). It cannot be used with any other keyword.
Syntax: rseed <integer>;
Example: rs 921; < set the random number seed to 921
rs 8912; < set the random number seed to 8912
rs 7777; < set the seed to original value
Score Time Description: All start and duration times are specified in score time. Score time is measured in beats or time units. If no tempo specification has been made, each beat is equal to one second (MM = 60). In rhythm codes the default beat note is the quarter note. Both tempo and beat note can be changed using the tempo and beat keywords.
Sets (se) Description: The sets keyword takes a list of sets of values in the syntax shown below. The <duration> field is specified in beats, and the values in each <set> are any number of values of the same type (integers, real numbers, or note names). When a value is required during a given time period, one of the values from the given <set> is chosen at random. In its normal mode, sets does not allow repeated elements, although common elements may exist between sets and cause repeats. Repeated values are allowed if the ‘repeat’ mode is turned on. This is accomplished by placing the flag ‘r’ before the <duration> field in any set segment; ‘n’ before a <duration> turns off the repeat feature. The repeated slash can be used with sets; repetition counts are not allowed.
Syntax: sets <duration-1><set-1>[/<duration-2><set-2>
Example: p4 se 10 c4 d e fs gs as/20 cs4 ds f g a b;
< choose notes from one whole-tone scale
< for 10 beats, then from the other whole-
< tone scale for 20 beats;
p8 se 12 1000 926 440/r 25 500 12 750 12000;
< for 12 beats choose from the three numbers
< change to new set of values for the next
< 25 beats and allow repeated elements
Tempo (te) Description: The tempo keyword enables one to make accellerandos and rithardandos in a powerful and flexible manner. If a tempo statement appears outside an I-block all instruments will be affected. If the tempo statement appears within an I-block only that instrument is affected. If there is both a global and a local tempo change, then SCORE-11 will implement both changes. The <timespan> is specified in beats. If <tempo-2> is omitted, it is assumed to be the same as <tempo-1>. Tempo uses exponential interpolation unless a different type is specified explicitly. SCORE-11 allows seven varieties of tempo change, indicated by a <type> flag just before the <timespan> field. The “type” options are:
x = exponential (default)
xi = inverted exponential
l = linear
s = square (deeper curve)
si = inverted square
v d = variable
vi d = inverted variable
The linear curve uses linear interpolation between the two specified tempos. The inverted exponential curve uses the inverse of the exponential curve, i.e., tempo change is more rapid at the beginning of the curve and slower at the end. the “square curve is similar to the exponential curve, but the curve is slightly “deeper.” The “variable curve” allows the user to control the depth of the curve. The v or vi flag is followed by a real (decimal) number, which indicates the “depth” of the curve. The value 2.0 is equivalent to the s flag, and 1.0 is linear. A value d = 1.5 is somewhere in between, and larger numbers, e.g., 3.0 or 4.0 will yield even deeper curves, i.i., slow rate of change at the beginning and very rapid change at the end of the time span. The depth variable should not be negative.
Tempo accepts lists of tempo changes. Any tempo chage resets the default and remains in effect until reset with a different code or when the I-block is terminated (for local tempos). Before a tempo warp is applied, the basic time unit is one second per beat.
Syntax: tempo [<type>]<timespan-1><tempo-1><tempo-2>
Example: te 10 60 120; < tempo changes from 60 to 120
< over 10 beats
te 10 60 80//10 120/10 120 60;
< accelerando over 10 beats from 60 to 80
< do same again (repeat slash)
< ritardando to MM=60 over 10 beats
Tfactor (tf) Description: Tfactor scales tempos in score file by multiplying each <tempo> specification by some specified number. The initial value is 1.0. The setting of tfactor is global and the value specified remains in effect until changed. It is commonly placed at the beginning of the score to make global adjustments.
Syntax: tfactor <number>;
Example: tf .9 < slow all tempos by 10%