Mod

java.lang.Object
- jm.music.tools.Mod

All Implemented Interfaces:

Alignments, DrumMap, Durations, Dynamics, Frequencies, Noises, Panning, Pitches, ProgramChanges, RhythmValues, Scales, Tunings, Volumes, Waveforms, JMC
```
public class Mod
extends java.lang.Object
implements JMC
```
A utility class that handles the modification of the basic jMusic types.

Field Summary
- Fields inherited from interface jm.JMC
  AMPLITUDE, DEBUG, DYNAMIC, EIGHT_BIT, FREQUENCY, KEY_SIG_EVT, MONO, NO_DENOMINATOR, NO_INSTRUMENT, NO_KEY_QUALITY, NO_KEY_SIGNATURE, NO_NUMERATOR, OCTAPHONIC, PAN, PITCH, PROG_EVT, QUADRAPHONIC, RHYTHM, SIXTEEN_BIT, STEREO, TEMP_EVT, THIRTY_TWO_BIT, TIME_SIG_EVT, VERBOSE
- Fields inherited from interface jm.constants.Durations
  C, CD, CDD, CROTCHET, CROTCHET_TRIPLET, CT, DC, DDC, DDEN, DDHN, DDM, DDQ, DDQN, DEMI_SEMI_QUAVER, DEMI_SEMI_QUAVER_TRIPLET, DEN, DHN, DM, DOTTED_CROTCHET, DOTTED_EIGHTH_NOTE, DOTTED_HALF_NOTE, DOTTED_MINIM, DOTTED_QUARTER_NOTE, DOTTED_QUAVER, DOTTED_SEMI_QUAVER, DOTTED_SIXTEENTH_NOTE, DOUBLE_DOTTED_CROTCHET, DOUBLE_DOTTED_EIGHTH_NOTE, DOUBLE_DOTTED_HALF_NOTE, DOUBLE_DOTTED_MINIM, DOUBLE_DOTTED_QUARTER_NOTE, DOUBLE_DOTTED_QUAVER, DQ, DQN, DSN, DSQ, DSQT, EIGHTH_NOTE, EIGHTH_NOTE_TRIPLET, EN, ENT, HALF_NOTE, HALF_NOTE_TRIPLET, HN, HNT, M, MD, MDD, MINIM, MINIM_TRIPLET, MT, Q, QD, QDD, QN, QNT, QT, QUARTER_NOTE, QUARTER_NOTE_TRIPLET, QUAVER, QUAVER_TRIPLET, SB, SEMI_QUAVER, SEMI_QUAVER_TRIPLET, SEMIBREVE, SIXTEENTH_NOTE, SIXTEENTH_NOTE_TRIPLET, SN, SNT, SQ, SQD, SQT, THIRTYSECOND_NOTE, THIRTYSECOND_NOTE_TRIPLET, TN, TNT, TSN, TSNT, WHOLE_NOTE, WN
- Fields inherited from interface jm.constants.Pitches
  a0, A0, a1, A1, a2, A2, a3, A3, a4, A4, a5, A5, a6, A6, a7, A7, a8, A8, af0, AF0, af1, AF1, af2, AF2, af3, AF3, af4, AF4, af5, AF5, af6, AF6, af7, AF7, af8, AF8, afn1, AFN1, an1, AN1, as0, AS0, as1, AS1, as2, AS2, as3, AS3, as4, AS4, as5, AS5, as6, AS6, as7, AS7, as8, AS8, asn1, ASN1, b0, B0, b1, B1, b2, B2, b3, B3, b4, B4, b5, B5, b6, B6, b7, B7, b8, B8, bf0, BF0, bf1, BF1, bf2, BF2, bf3, BF3, bf4, BF4, bf5, BF5, bf6, BF6, bf7, BF7, bf8, BF8, bfn1, BFN1, bn1, BN1, bs0, BS0, bs1, BS1, bs2, BS2, bs3, BS3, bs4, BS4, bs5, BS5, bs6, BS6, bs7, BS7, bs8, BS8, bsn1, BSN1, c0, C0, c1, C1, c2, C2, c3, C3, c4, C4, c5, C5, c6, C6, c7, C7, c8, C8, c9, C9, cf0, CF0, cf1, CF1, cf2, CF2, cf3, CF3, cf4, CF4, cf5, CF5, cf6, CF6, cf7, CF7, cf8, CF8, cf9, CF9, cn1, CN1, cs0, CS0, cs1, CS1, cs2, CS2, cs3, CS3, cs4, CS4, cs5, CS5, cs6, CS6, cs7, CS7, cs8, CS8, cs9, CS9, csn1, CSN1, d0, D0, d1, D1, d2, D2, d3, D3, d4, D4, d5, D5, d6, D6, d7, D7, d8, D8, d9, D9, df0, DF0, df1, DF1, df2, DF2, df3, DF3, df4, DF4, df5, DF5, df6, DF6, df7, DF7, df8, DF8, df9, DF9, dfn1, DFN1, dn1, DN1, ds0, DS0, ds1, DS1, ds2, DS2, ds3, DS3, ds4, DS4, ds5, DS5, ds6, DS6, ds7, DS7, ds8, DS8, ds9, DS9, dsn1, DSN1, e0, E0, e1, E1, e2, E2, e3, E3, e4, E4, e5, E5, e6, E6, e7, E7, e8, E8, e9, E9, ef0, EF0, ef1, EF1, ef2, EF2, ef3, EF3, ef4, EF4, ef5, EF5, ef6, EF6, ef7, EF7, ef8, EF8, ef9, EF9, efn1, EFN1, en1, EN1, es0, ES0, es1, ES1, es2, ES2, es3, ES3, es4, ES4, es5, ES5, es6, ES6, es7, ES7, es8, ES8, es9, ES9, esn1, ESN1, f0, F0, f1, F1, f2, F2, f3, F3, f4, F4, f5, F5, f6, F6, f7, F7, f8, F8, f9, F9, ff0, FF0, ff1, FF1, ff2, FF2, ff3, FF3, ff4, FF4, ff5, FF5, ff6, FF6, ff7, FF7, ff8, FF8, ff9, FF9, ffn1, FFN1, fn1, FN1, fs0, FS0, fs1, FS1, fs2, FS2, fs3, FS3, fs4, FS4, fs5, FS5, fs6, FS6, fs7, FS7, fs8, FS8, fs9, FS9, fsn1, FSN1, g0, G0, g1, G1, g2, G2, g3, G3, g4, G4, g5, G5, g6, G6, g7, G7, g8, G8, g9, G9, gf0, GF0, gf1, GF1, gf2, GF2, gf3, GF3, gf4, GF4, gf5, GF5, gf6, GF6, gf7, GF7, gf8, GF8, gf9, GF9, gfn1, GFN1, gn1, GN1, gs0, GS0, gs1, GS1, gs2, GS2, gs3, GS3, gs4, GS4, gs5, GS5, gs6, GS6, gs7, GS7, gs8, GS8, gsn1, GSN1, REST
- Fields inherited from interface jm.constants.Frequencies
  FRQ
- Fields inherited from interface jm.constants.Tunings
  EQUAL, JUST, MEAN, PYTHAGOREAN
- Fields inherited from interface jm.constants.Volumes
  F, FF, FFF, FORTE, FORTISSIMO, MEZZO_FORTE, MEZZO_PIANO, MF, MP, P, PIANISSIMO, PP, PPP, SILENT
- Fields inherited from interface jm.constants.Panning
  PAN_CENTER, PAN_CENTRE, PAN_LEFT, PAN_RIGHT
- Fields inherited from interface jm.constants.ProgramChanges
  AAH, ABASS, AC_GUITAR, ACCORDION, ACOUSTIC_BASS, ACOUSTIC_GRAND, ACOUSTIC_GUITAR, AGOGO, AHHS, ALTO, ALTO_SAX, ALTO_SAXOPHONE, APPLAUSE, ATMOSPHERE, BAG_PIPES, BAGPIPE, BAGPIPES, BANDNEON, BANJO, BARI, BARI_SAX, BARITONE, BARITONE_SAX, BARITONE_SAXOPHONE, BASS, BASSOON, BELL, BELLS, BIRD, BOTTLE, BOTTLE_BLOW, BOWED_GLASS, BRASS, BREATH, BREATHNOISE, BRIGHT_ACOUSTIC, BRIGHTNESS, CALLOPE, CELESTA, CELESTE, CELLO, CGUITAR, CHARANG, CHIFFER, CHIFFER_LEAD, CHOIR, CHURCH_ORGAN, CLAR, CLARINET, CLAV, CLAVINET, CLEAN_GUITAR, CONCERTINA, CONTRA_BASS, CONTRABASS, CRYSTAL, CYMBAL, DGUITAR, DIST_GUITAR, DISTORTED_GUITAR, DOUBLE_BASS, DROPS, DRUM, DX_EPIANO, EBASS, ECHO, ECHO_DROP, ECHO_DROPS, ECHOS, EL_BASS, EL_GUITAR, ELECTRIC_BASS, ELECTRIC_GRAND, ELECTRIC_GUITAR, ELECTRIC_ORGAN, ELECTRIC_PIANO, ELPIANO, ENGLISH_HORN, EPIANO, EPIANO2, FANTASIA, FBASS, FIDDLE, FINGERED_BASS, FLUTE, FRENCH_HORN, FRET, FRET_NOISE, FRETLESS, FRETLESS_BASS, FRETNOISE, FRETS, GLOCK, GLOCKENSPIEL, GMSAW_WAVE, GMSQUARE_WAVE, GOBLIN, GT_HARMONICS, GUITAR, GUITAR_HARMONICS, GUNSHOT, HALO, HALO_PAD, HAMMOND_ORGAN, HARMONICA, HARMONICS, HARP, HARPSICHORD, HELICOPTER, HONKYTONK, HONKYTONK_PIANO, HORN, ICE_RAIN, ICERAIN, JAZZ_GUITAR, JAZZ_ORGAN, JGUITAR, KALIMBA, KOTO, MARIMBA, METAL_PAD, MGUITAR, MUSIC_BOX, MUTED_GUITAR, MUTED_TRUMPET, NGUITAR, NYLON_GUITAR, OBOE, OCARINA, OGUITAR, OOH, OOHS, ORCHESTRA_HIT, ORGAN, ORGAN2, ORGAN3, OVERDRIVE_GUITAR, PAD, PAN_FLUTE, PANFLUTE, PBASS, PHONE, PIANO, PIANO_ACCORDION, PIC, PICC, PICCOLO, PICKED_BASS, PIPE_ORGAN, PIPES, PITZ, PIZZ, PIZZICATO_STRINGS, POLY_SYNTH, POLYSYNTH, PSTRINGS, RAIN, RECORDER, REED_ORGAN, REVERSE_CYMBAL, RHODES, SAW, SAWTOOTH, SAX, SAXOPHONE, SBASS, SEA, SEASHORE, SFX, SGUITAR, SHAKUHACHI, SHAMISEN, SHANNAI, SITAR, SLAP, SLAP_BASS, SLAP_BASS_1, SLAP_BASS_2, SLOW_STRINGS, SOLO_VOX, SOP, SOPRANO, SOPRANO_SAX, SOPRANO_SAXOPHONE, SOUNDEFFECTS, SOUNDFX, SOUNDTRACK, SPACE_VOICE, SQUARE, STAR_THEME, STEEL_DRUM, STEEL_DRUMS, STEEL_GUITAR, STEELDRUM, STEELDRUMS, STR, STREAM, STRING_ENSEMBLE_1, STRING_ENSEMBLE_2, STRINGS, SWEEP, SWEEP_PAD, SYN_CALLIOPE, SYNTH_BASS, SYNTH_BASS_1, SYNTH_BASS_2, SYNTH_BRASS, SYNTH_BRASS_1, SYNTH_BRASS_2, SYNTH_CALLIOPE, SYNTH_DRUM, SYNTH_DRUMS, SYNTH_STRINGS, SYNTH_STRINGS_1, SYNTH_STRINGS_2, SYNVOX, TAIKO, TELEPHONE, TENOR, TENOR_SAX, TENOR_SAXOPHONE, THUMB_PIANO, THUNDER, TIMP, TIMPANI, TINKLE_BELL, TOM, TOM_TOM, TOM_TOMS, TOMS, TREMOLO, TREMOLO_STRINGS, TROMBONE, TRUMPET, TUBA, TUBULAR_BELL, TUBULAR_BELLS, VIBES, VIBRAPHONE, VIOLA, VIOLIN, VIOLIN_CELLO, VOICE, VOX, WARM_PAD, WHISTLE, WIND, WOODBLOCK, WOODBLOCKS, XYLOPHONE
- Fields inherited from interface jm.constants.DrumMap
  ACOUSTIC_BASS_DRUM, ACOUSTIC_SNARE, BASS_DRUM_1, CABASA, CHINESE_CYMBAL, CLAVES, CLOSED_HI_HAT, COWBELL, CRASH_CYMBAL_1, CRASH_CYMBAL_2, ELECTRIC_SNARE, HAND_CLAP, HI_BONGO, HI_MID_TOM, HI_WOOD_BLOCK, HIGH_AGOGO, HIGH_FLOOR_TOM, HIGH_TIMBALE, HIGH_TOM, LONG_GUIRO, LONG_WHISTLE, LOW_AGOGO, LOW_BONGO, LOW_CONGA, LOW_FLOOR_TOM, LOW_MID_TOM, LOW_TIMBALE, LOW_TOM, LOW_WOOD_BLOCK, MARACAS, MUTE_CUICA, MUTE_HI_CONGA, MUTE_TRIANGLE, OPEN_CUICA, OPEN_HI_CONGA, OPEN_HI_HAT, OPEN_TRIANGLE, PEDAL_HI_HAT, RIDE_BELL, RIDE_CYMBAL_1, RIDE_CYMBAL_2, SHORT_GUIRO, SHORT_WHISTLE, SIDE_STICK, SPLASH_CYMBAL, TAMBOURINE, VIBRASLAP
- Fields inherited from interface jm.constants.Scales
  AEOLIAN_SCALE, BLUES_SCALE, CHROMATIC_SCALE, DIATONIC_MINOR_SCALE, DORIAN_SCALE, HARMONIC_MINOR_SCALE, INDIAN_SCALE, LYDIAN_SCALE, MAJOR_SCALE, MELODIC_MINOR_SCALE, MINOR_SCALE, MIXOLYDIAN_SCALE, NATURAL_MINOR_SCALE, PENTATONIC_SCALE, TURKISH_SCALE
- Fields inherited from interface jm.constants.Waveforms
  COSINE_WAVE, PULSE_WAVE, SABERSAW_WAVE, SAWDOWN_WAVE, SAWTOOTH_WAVE, SINE_WAVE, SQUARE_WAVE, TRIANGLE_WAVE
- Fields inherited from interface jm.constants.Noises
  BROWN_NOISE, FRACTAL_NOISE, SMOOTH_NOISE, STEP_NOISE, WHITE_NOISE
- Fields inherited from interface jm.constants.Alignments
  AFTER, BEFORE, CENTER_ALIGN, CENTER_ON_END, CENTER_ON_START, CENTRE_ALIGN, CENTRE_ON_END, CENTRE_ON_START, END_ON_CENTER, END_ON_CENTRE, END_TOGETHER, START_ON_CENTER, START_ON_CENTRE, START_TOGETHER

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`accent(Phrase phrase, double meter)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
`static void`	`accent(Phrase phrase, double meter, double[] accentedBeats)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
`static void`	`accent(Phrase phrase, double meter, double[] accentedBeats, int accentAmount)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter.
`static void`	`accents(CPhrase cphrase, double meter)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
`static void`	`accents(CPhrase cphrase, double meter, double[] accentedBeats)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
`static void`	`accents(CPhrase cphrase, double meter, double[] accentedBeats, int accentAmount)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter.
`static void`	`accents(Part part, double meter)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
`static void`	`accents(Part part, double meter, double[] accentedBeats)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
`static void`	`accents(Part part, double meter, double[] accentedBeats, int accentAmount)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter.
`static void`	`accents(Phrase phrase, double meter)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
`static void`	`accents(Phrase phrase, double meter, double[] accentedBeats)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
`static void`	`accents(Phrase phrase, double meter, double[] accentedBeats, int accentAmount)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter.
`static void`	`accents(Score score, double meter)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
`static void`	`accents(Score score, double meter, double[] accentedBeats)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
`static void`	`accents(Score score, double meter, double[] accentedBeats, int accentAmount)` Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter.
`static void`	`addToDuration(CPhrase cphrase, double amount)` Vary the duration of each note in the cphrase by the specified amount.
`static void`	`addToDuration(Part part, double amount)` Vary the duration of each note in the part by the specified amount.
`static void`	`addToDuration(Phrase phrase, double amount)` Vary the duration of each note in the phrase by the specified amount.
`static void`	`addToDuration(Score score, double amount)` Vary the duration of each note in the score by the specified amount.
`static void`	`addToLength(CPhrase cphrase, double amount)` Vary both the rhythm value and duration of each note in the phrase by the specified amount.
`static void`	`addToLength(Part part, double amount)` Vary both the rhythm value and duration of each note in the part by the specified amount.
`static void`	`addToLength(Phrase phrase, double amount)` Vary both the rhythm value and duration of each note in the phrase by the specified amount.
`static void`	`addToLength(Score score, double amount)` Vary both the rhythm value and duration of each note in the Score by the specified amount.
`static void`	`addToRhythmValue(CPhrase cphrase, double amount)` Vary the rhythm value of each note in the cphrase by the specified amount.
`static void`	`addToRhythmValue(Part part, double amount)` Vary the rhythm value of each note in the part by the specified amount.
`static void`	`addToRhythmValue(Phrase phrase, double amount)` Vary the rhythm value of each note in the phrase by the specified amount.
`static void`	`addToRhythmValue(Score score, double amount)` Vary the rhythm value of each note in the Score by the specified amount.
`static void`	`append(CPhrase cphrase1, CPhrase cphrase2)` Adds a second CPhrase to the end of the first.
`static void`	`append(Note note1, Note note2)` Appends the duration and rhythm value of the second note onto the first.
`static void`	`append(Part part1, Part part2)` Adds a second part to the end of this one.
`static void`	`append(Part part1, Part part2, double fromLoc)` Adds a second part to this one starting from a specified location
`static void`	`append(Phrase phrase1, Phrase phrase2)` Adds phrase2 to the end of phrase1.
`static void`	`append(Score score1, Score score2)` Adds a second score to the end of this one.
`static void`	`bounce(CPhrase cphrase)` Adjusts all Notes' pan value to alternate between extreme left and right from note to note.
`static void`	`bounce(Part part)` Adjusts all Notes' pan value to alternate between extreme left and right from note to note.
`static void`	`bounce(Phrase phrase)` Adjusts all Note pan values to alternate between extreme left and right from note to note.
`static void`	`bounce(Score score)` Adjusts all Notes' pan value to alternate between extreme left and right from note to note.
`static void`	`changeLength(Phrase phrase, double newLength)` Alters the phrase so that it's notes are stretched or compressed until the phrase is the length specified.
`static void`	`compress(CPhrase cphrase, double ratio)` A compressor/expander routine.
`static void`	`compress(Part part, double ratio)` A compressor/expander routine.
`static void`	`compress(Phrase phrase, double ratio)` A compressor/expander routine.
`static void`	`compress(Score score, double ratio)` A compressor/expander routine.
`static void`	`consolidate(Part p)` packs all of the phrases within this part into a single phrase
`static void`	`consolidate(Score score)` Pack all phrases from parts with the same channel into one part.
`static void`	`crescendo(Phrase phrase, double startTime, double endTime, int startDynamic, int endDynamic)`
`static void`	`cycle(Part part, double to)` A version of Cycle that works for parts
`static void`	`cycle(Phrase phrase, double numBeats)` Extends the `phrase` by repeating it until it is as long as the specified length.
`static void`	`cycle(Phrase phrase, int numNotes)` Extends the `phrase` by repeating it until it contains the number of notes as specified by `numNotes`.
`static void`	`decrescendo(Phrase phrase, double startTime, double endTime, int startDynamic, int endDynamic)`
`static void`	`diatonicInvert(Phrase phrase, int[] scale, int root)`
`static void`	`diminuendo(Phrase phrase, double startTime, double endTime, int startDynamic, int endDynamic)`
`static void`	`elongate(CPhrase cphrase, double scaleFactor)` Lengthen each note in the CPhrase.
`static void`	`elongate(Part part, double scaleFactor)` Stretch the time of each note in each phrase by the `scaleFactor`
`static void`	`elongate(Phrase phrase, double scaleFactor)` Stretch the time of each note in the phrase by `scaleFactor`
`static void`	`elongate(Score score, double scaleFactor)` Stretch the time of each note in each phrase by the `scaleFactor`
`static void`	`expandIntervals(CPhrase cphrase, double amount)` Vary the interval between notes scaling by the specified amount to each interval.
`static void`	`expandIntervals(Part part, double amount)` Vary the interval between notes scaling by the specified amount to each interval.
`static void`	`expandIntervals(Phrase phrase, double amount)` Vary the interval between notes scaling by the specified amount to each interval.
`static void`	`expandIntervals(Score score, double amount)` Vary the interval between notes scaling by the specified amount to each interval.
`static void`	`fadeIn(CPhrase cphrase, double fadeLength)` Linearly fades in the CPhrase
`static void`	`fadeIn(CPhrase cphrase, double fadeLength, double cphraseStartTime)` Linearly fades in the CPhrase.
`static void`	`fadeIn(Part part, double fadeLength)` Linearly fades in the Part.
`static void`	`fadeIn(Part part, double fadeLength, double partStartTime)` Linearly fades in the Part.
`static void`	`fadeIn(Phrase phrase, double fadeLength)` Linearly fades in the `phrase`.
`static void`	`fadeIn(Phrase phrase, double fadeLength, double phraseStartTime)` Linearly fades in the `phrase`, with the fade beginning before the `phrase`.
`static void`	`fadeIn(Score score, double fadeLength)` Linearly fades in the Score.
`static void`	`fadeOut(CPhrase cphrase, double fadeLength)` Linearly fades out the CPhrase.
`static void`	`fadeOut(CPhrase cphrase, double fadeLength, double cphraseEndTime)` Linearly fades out the CPhrase.
`static void`	`fadeOut(Part part, double fadeLength)` Linearly fades out the Part.
`static void`	`fadeOut(Part part, double fadeLength, double partEndTime)` Linearly fades out the Part.
`static void`	`fadeOut(Phrase phrase, double fadeLength)` Linearly fades out the `phrase`.
`static void`	`fadeOut(Phrase phrase, double fadeLength, double phraseEndTime)` Linearly fades out the `phrase`, with the fade ending after the phrase ends.
`static void`	`fadeOut(Score score, double fadeLength)` Linearly fades out the Score.
`static void`	`fillRests(CPhrase cphrase)` Lengthens notes followed by a rest in the `CPhrase` by creating one longer note and deleting the rest.
`static void`	`fillRests(Part part)` Lengthens notes followed by a rest in the `part` by creating one longer note and deleting the rest.
`static void`	`fillRests(Phrase phrase)` Lengthens notes followed by a rest in the `phrase` by creating one longer note and deleting the rest.
`static void`	`fillRests(Score score)` Lengthens notes followed by a rest in the `score` by creating one longer note and deleting the rest.
`static void`	`increaseDuration(CPhrase cphrase, double multiplyer)` Vary the duration of each note in the phrase by the multiplyer.
`static void`	`increaseDuration(Part part, double multiplyer)` Vary the duration of each note in the part by the multiplyer.
`static void`	`increaseDuration(Phrase phrase, double multiplyer)` Vary the duration of each note in the phrase by the multiplyer.
`static void`	`increaseDuration(Score score, double multiplyer)` Vary the duration of each note in the score by the multiplyer.
`static void`	`increaseDynamic(Part p, int amount)` Increases the dynamic by a certain amount - obviously a negative number will decrease it.
`static void`	`increaseDynamic(Phrase phr, int amount)` increases the dynamic by a certain amount - obviously a negative number will decrease it
`static void`	`increaseDynamic(Score s, int amount)` increases the dynamic by a certain amount - obviously a negative number will decrease it
`static void`	`inversion(Phrase phrase)` Mirror the pitch of notes in the phrase around the first note's pitch.
`static void`	`invert(Phrase phrase)`
`static void`	`merge(CPhrase cphrase1, CPhrase cphrase2)` Combines the phrases from a second CPhrase into the first.
`static void`	`merge(Part part1, Part part2)` Combines the phrases from a second part into this one.
`static void`	`merge(Score score1, Score score2)` Combines the parts from a second score into the first one.
`static void`	`mutate(Phrase phrase)` Mutates the `phrase` by changing one pitch and one rhythm value.
`static void`	`mutate(Phrase phrase, int pitchCount, int[] scale)` Mutates the `phrase` by changing pitches and rhythm values.
`static void`	`mutate(Phrase phrase, int pitchCount, int rhythmCount, int[] pitches, int lowestPitch, int highestPitch, double[] rhythms)` Mutates the `phrase` by changing pitches and rhythm values.
`static void`	`normalise(CPhrase cphrase)` Increases dynamic values so that the loudest is at maxiumim level.
`static void`	`normalise(Part part)` Increases dynamic values so that the loudest is at maxiumim level.
`static void`	`normalise(Phrase phrase)` Increases dynamic values so that the loudest is at maxiumim level.
`static void`	`normalise(Score score)` Increases dynamic values so that the loudest is at maxiumim level.
`static void`	`palindrome(Phrase phrase)` Extend the phrase by adding all notes backwards, repeating the last note of the phrase.
`static void`	`palindrome(Phrase phrase, boolean repeatLastNote)` Extend the phrase by adding all notes backwards.
`static void`	`quantise(CPhrase cphrase, double qValue)` Quantise the cphrase.
`static void`	`quantise(Part part, double qValue)` Quantise the `part`.
`static void`	`quantise(Phrase phrase, double qValue)` Quantises the rhythm values of notes in the `phrase`.
`static void`	`quantise(Score score, double qValue)` Quantise all the rhythm values of notes in this score.
`static void`	`quantize(CPhrase cphrase, double qValue)` Quantize the cphrase.
`static void`	`quantize(CPhrase cphrase, double qValue, int[] mode, int key)` Quantise all the phrases in this CPhrase.
`static void`	`quantize(Part part, double qValue)` Quantize the `part`.
`static void`	`quantize(Part part, double qValue, int[] mode, int key)` Quantize all the phrases in this part, both rhythmic and pitch elements.
`static void`	`quantize(Phrase phrase, double qValue)` Quantizes the `phrase`.
`static void`	`quantize(Phrase phrase, double qValue, int[] mode, int key)` Aligns all rhythmValues of notes in a phrase to the closest beat subdivision and all note pitches to be members of the specified mode.
`static void`	`quantize(Score score, double qValue)` Quantize rhythm values of all the parts in this score.
`static void`	`quantize(Score score, double qValue, int[] mode, int key)` Quantize all the rhythm values and pitches in this score.
`static void`	`quantizePitch(Note note, int[] mode, int key)` Shift the pitch down until it corresponds to a pitch in the specified mode.
`static void`	`randomize(CPhrase cphrase, int pitchVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(CPhrase cphrase, int pitchVariation, double rhythmVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(CPhrase cphrase, int pitchVariation, double rhythmVariation, int dynamicVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Part part, int pitchVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Part part, int pitchVariation, double rhythmVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Part part, int pitchVariation, double rhythmVariation, int dynamicVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Phrase phrase, int pitchVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Phrase phrase, int pitchVariation, double rhythmVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Phrase phrase, int pitchVariation, double rhythmVariation, int dynamicVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Score score, int pitchVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Score score, int pitchVariation, double rhythmVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`randomize(Score score, int pitchVariation, double rhythmVariation, int dynamicVariation)` Adjusts Note values to any value plus or minus a specified amount.
`static void`	`repeat(CPhrase cphrase)` Makes the CPhrase twice as long by repeating it once.
`static void`	`repeat(CPhrase cphrase, double startLoc, double endLoc)` Loops a section of a the CPhrase once
`static void`	`repeat(CPhrase cphrase, int times)` Makes the CPhrase n times as long by repeating.
`static void`	`repeat(CPhrase cphrase, int times, double startLoc, double endLoc)` Loops a section of the CPhrase n times.
`static void`	`repeat(Part part)` Makes the Part twice as long by repeating it once.
`static void`	`repeat(Part part, double startLoc, double endLoc)` Loops a section of a the Part once
`static void`	`repeat(Part part, int times)` Makes the Part n times as long by repeating.
`static void`	`repeat(Part part, int times, double startLoc, double endLoc)` Loops a section of the Part n times.
`static void`	`repeat(Phrase phrase)` Appends a copy of the `phrase` to the end of itself.
`static void`	`repeat(Phrase phrase, double startLoc, double endLoc)` Places a duplicate of a section of a phrase immediately after the end of the section.
`static void`	`repeat(Phrase phrase, int n)` Makes the `phrase` `n` times as long by repeating.
`static void`	`repeat(Phrase phrase, int times, double startLoc, double endLoc)` Loops a section of `phrase` `n` times.
`static void`	`repeat(Score score)` Makes a the `score twice times as long by repeating`
`static void`	`repeat(Score score, int times)` Loops the `score` `n` times.
`static void`	`retrograde(Phrase phrase)` Reverse the order of notes in the phrase.
`static void`	`rotate(Phrase phrase)` Move the notes around the phrase, first becoming second, second becoming third, and so forth with last becoming first.
`static void`	`rotate(Phrase phrase, int numSteps)` Move the notes around a number of steps as specified by `numSteps` which each step involving the first note becoming the second, second the third, and so forth with the last becoming first.
`static void`	`shake(CPhrase cphrase, int amount)` Randomise the dynamic values of notes up to a specified amount either side of the current value.
`static void`	`shake(Part part, int amount)` Randomise the dynamic values of notes up to a specified amount either side of the current value.
`static void`	`shake(Phrase phrase)` Randomly adjusts Note dynamic values to create uneven loudness.
`static void`	`shake(Phrase phrase, int amount)` Randomly adjusts all Notes' dynamic value to create uneven loudness.
`static void`	`shake(Score score, int amount)` Randomise the dynamic values of notes up to a specified amount either side of the current value.
`static void`	`shuffle(CPhrase cphrase)` Randomly order notes within each phrase.
`static void`	`shuffle(Part part)` Randomly order notes within each phrase.
`static void`	`shuffle(Phrase phrase)` Randomise the order of notes in the phrase without repeating any note.
`static void`	`shuffle(Score score)` Randomly order notes within each phrase.
`static void`	`slurDown(CPhrase cphrase, int numberOfNotes)` All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurDown(Part part, int numberOfNotes)` All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurDown(Phrase phrase)` All descending sequences of notes are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurDown(Phrase phrase, int numberOfNotes)` All descending sequences of the number of notes or more are slured by having the duration of all but the last note extended to 100% of the rhythm value.
`static void`	`slurDown(Score score, int numberOfNotes)` All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurUp(CPhrase cphrase, int numberOfNotes)` All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurUp(Part part, int numberOfNotes)` All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurUp(Phrase phrase)` All ascending sequences of notes are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurUp(Phrase phrase, int numberOfNotes)` All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`slurUp(Score score, int numberOfNotes)` All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value.
`static void`	`spread(CPhrase cphrase)` Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum.
`static void`	`spread(Part part)` Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum.
`static void`	`spread(Phrase phrase)` Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum.
`static void`	`spread(Score score)` Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum.
`static void`	`tiePitches(CPhrase cphrase)` Joins consecutive notes in each `CPhrase` that have the same pitch, creating one longer note.
`static void`	`tiePitches(Part part)` Joins consecutive notes in each `phrase` that have the same pitch, creating one longer note.
`static void`	`tiePitches(Phrase phrase)` Joins consecutive notes in the `phrase` that have the same pitch, creating one longer note.
`static void`	`tiePitches(Score score)` Joins consecutive notes in each `phrase` that have the same pitch, creating one longer note.
`static void`	`tieRests(CPhrase cphrase)` Joins consecutive rests in each `CPhrase` creating one longer note.
`static void`	`tieRests(Part part)` Joins consecutive rests in each `part` creating one longer note.
`static void`	`tieRests(Phrase phrase)` Joins consecutive rests in the `phrase` creating one longer note.
`static void`	`tieRests(Score score)` Joins consecutive rests in each `phrase` creating one longer note.
`static void`	`transpose(CPhrase cphrase, int trans)` Transposes the `cphrase`.
`static void`	`transpose(CPhrase cphrase, int transposition, int[] mode, int key)` Transpose the CPhrase up or down in scale degrees.
`static void`	`transpose(Note note, int transposition)` Transpose the note up or down in semitones.
`static void`	`transpose(Note note, int transposition, int[] mode, int key)` Transpose the phrase up or down in scale degrees.
`static void`	`transpose(Part part, int transposition)` Transpose the part up or down in semitone steps.
`static void`	`transpose(Part part, int degrees, int[] mode, int key)` Transpose the Part up or down in scale degrees.
`static void`	`transpose(Phrase phrase, int transposition)` Transpose the phrase up or down in semitones.
`static void`	`transpose(Phrase phrase, int transposition, int[] mode, int key)` Transpose the phrase up or down in scale degrees.
`static void`	`transpose(Score scr, int transposition)` Transpose a Score
`static void`	`transpose(Score score, int degrees, int[] mode, int key)` Transpose the score up or down in scale degrees.
`static void`	`varyLength(CPhrase cphrase, double minLength, double maxLength)` Adjusts all Notes' duration values to vary randomly between specified values from note to note.
`static void`	`varyLength(Part part, double minLength, double maxLength)` Adjusts all Notes' duration values to vary randomly between specified values from note to note.
`static void`	`varyLength(Phrase phrase, double minLength, double maxLength)` Adjusts all Note duration values to vary randomly between specified values from note to note.
`static void`	`varyLength(Score score, double minLength, double maxLength)` Adjusts all Notes' duration values to vary randomly between specified values from note to note.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - append
```
public static void append(Note note1,
          Note note2)
```
    Appends the duration and rhythm value of the second note onto the first.
    The second note remains unchanged. If either note1 or note2 is null then this method does nothing.
    
    Parameters:
    note1 - Note that absorbs the rhythm features
    note2 - Note that passes on its rhythm features
  - transpose
```
public static void transpose(Note note,
             int transposition)
```
    Transpose the note up or down in semitones.
    If note is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range.
    
    Parameters:
    note - The Note to be transposed
    transposition - the amount to transpose in semitones
  - transpose
```
public static void transpose(Note note,
             int transposition,
             int[] mode,
             int key)
```
    Transpose the phrase up or down in scale degrees.
    If note is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range. Transposition is in diatonic steps. For example in C major the note C transposed 1 will become D, transposed 4 will become G, and transposed by 7 will beome C an octave above. This can be somewhat unintuitive so be careful.
    
    Parameters:
    note - Note to be transposed
    transposition - the amount to transpose in semitones
    mode - the scale to use for the transposition (the JMC has some scale constants)
    key - the chromatic note to be used as the root of the mode. i.e., 0 = C, 1 = C# etc.
  - quantizePitch
```
public static void quantizePitch(Note note,
                 int[] mode,
                 int key)
```
    Shift the pitch down until it corresponds to a pitch in the specified mode.
    
    Parameters:
    note - Note to be qantized
    mode - the scale to use for the process (the JMC has some scale constants)
    key - the chromatic note to be used as the root of the mode. i.e., 0 = C, 1 = C# etc.
  - crescendo
```
public static final void crescendo(Phrase phrase,
             double startTime,
             double endTime,
             int startDynamic,
             int endDynamic)
```
  - diminuendo
```
public static final void diminuendo(Phrase phrase,
              double startTime,
              double endTime,
              int startDynamic,
              int endDynamic)
```
  - decrescendo
```
public static final void decrescendo(Phrase phrase,
               double startTime,
               double endTime,
               int startDynamic,
               int endDynamic)
```
  - transpose
```
public static void transpose(Phrase phrase,
             int transposition)
```
    Transpose the phrase up or down in semitones.
    If phrase is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range.
    
    Parameters:
    phrase - Phrase to be transposed
    transposition - the amount to transpose in semitones
  - transpose
```
public static void transpose(Phrase phrase,
             int transposition,
             int[] mode,
             int key)
```
    Transpose the phrase up or down in scale degrees.
    If phrase is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range. Transposition is in diatonic steps. For example in C major the note C transposed 1 will become D, transposed 4 will become G, and transposed by 7 will beome C an octave above. This can be somewhat unintuitive so be careful.
    
    Parameters:
    phrase - Phrase to be transposed
    transposition - the amount to transpose in semitones
    mode - the scale to use for the transposition
    key - the chromatic note to be used as the rooth of the mode. i.e., 0 = C, 1 = C# etc.
  - repeat
```
public static void repeat(Phrase phrase)
```
    Appends a copy of the phrase to the end of itself.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - Phrase to be repeated
  - repeat
```
public static void repeat(Phrase phrase,
          int n)
```
    Makes the phrase n times as long by repeating.
    If phrase is null or n is less than on then this method does nothing.
    
    Parameters:
    phrase - Phrase to be repeated
    n - integer representing the number of repeats, 1 will leave the phrase unchanged, 2 a single added repetitions, and so forth
  - repeat
```
public static void repeat(Phrase phrase,
          double startLoc,
          double endLoc)
```
    Places a duplicate of a section of a phrase immediately after the end of the section.
    If phrase is null; or startLoc is greater than or equal to endLoc then this method does nothing.
    
    Parameters:
    phrase - Phrase with section to be repeated
    startLoc - double describing the time of the beginning of the repeated section, in crotchets.
    endLoc - double describing the time of the end of the repeated section, in crotchets.
  - repeat
```
public static void repeat(Phrase phrase,
          int times,
          double startLoc,
          double endLoc)
```
    Loops a section of phrase n times.
    If phrase is null; startLoc is greater than or equal to endLoc; or n is less than one then this method does nothing.
    
    Parameters:
    phrase - Phrase with section to be repeated
    times - integer representing the number of repeats
    startLoc - double describing the time of the beginning of the repeated section, in crotchets.
    endLoc - double describing the time of the end of the repeated section, in crotchets.
  - increaseDynamic
```
public static void increaseDynamic(Phrase phr,
                   int amount)
```
    increases the dynamic by a certain amount -
    obviously a negative number will decrease it
    
    Parameters:
    Phrase - the phase that is to be affected
    int - the amount that it is to be affected by
  - fadeIn
```
public static void fadeIn(Phrase phrase,
          double fadeLength)
```
    Linearly fades in the phrase.
    If phrase is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be faded
    fadelength - double describing the number of beats (crotchets) to fade over
  - fadeIn
```
public static void fadeIn(Phrase phrase,
          double fadeLength,
          double phraseStartTime)
```
    Linearly fades in the phrase, with the fade beginning before the phrase.
    This is mainly used by when fading multiple Phrases of a Part.
    If phrase is null; fadeLength is less than or equal to zero; phraseStart is less than zero; or fadeLength is less than or equal to phraseStart then this method does nothing.
    
    Parameters:
    phrase - Phrase to be faded
    fadeLength - double describing the duration of the fade, in crotchets
    phraseStartTime - double describing how far into the fade the phrase starts
  - fadeOut
```
public static void fadeOut(Phrase phrase,
           double fadeLength)
```
    Linearly fades out the phrase.
    If phrase is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be faded
    fadeLength - double describing the duration of the fade out in crotchets
  - fadeOut
```
public static void fadeOut(Phrase phrase,
           double fadeLength,
           double phraseEndTime)
```
    Linearly fades out the phrase, with the fade ending after the phrase ends.
    This method is mainly used by a Part when fading multiple Phrases.
    If phrase is null; fadeLength is less than or equal to zero; phraseEndTime is less than zero; or fadeLength is less than phraseEndTime then this method does nothing.
    
    Parameters:
    phrase - Phrase to be faded
    fadeLength - double describing the duration of the fade out in crotchets
    phraseEndTime - double describing the length of time, in crotchets, between the end of the phrase and the end of the fade.
  - compress
```
public static void compress(Phrase phrase,
            double ratio)
```
    A compressor/expander routine. Compression ratio numbers between 0 and 1 compress, values larger than 1 expand. Negative values invert the dynamic about the mean.
    This compression applies only to the volume, technically the dynamic, of the notes. It will multiply the difference between each of the notes' dynmaics and the average dynamic, by the compression factor. Thus, a ratio of zero will change every note's volume to the average volume; one will leave every note unchanged; and two will make every note's volume twice as far from the mean;
    Negative values will have a similar affect but leave the dynamic of each note on the other side of the mean.
    Note also that if the dynamic is expanded to a value greater than MAX_DYNAMIC or less than MIN_DYNAMIC then the dynamic will be set to a value as described in the Note.setDynamic(int) method.
    Finally, if phrase is null then this method will do nothing.
    
    Parameters:
    phrase - Phrase to be expanded/compressed
    ratio - double describing the compression factor.
  - append
```
public static void append(Phrase phrase1,
          Phrase phrase2)
```
    Adds phrase2 to the end of phrase1.
    If either phrase1 or phrase2 is null then this method does nothing.
    
    Parameters:
    phrase1 - the base Phrase
    phrase2 - the Phrase to be appended
  - quantize
```
public static void quantize(Phrase phrase,
            double qValue)
```
    Quantizes the phrase. See quantise(Phrase, double) for more details.
    
    Parameters:
    phrase - Phrase to be quantized
    qValue - the rhythm value to quantize to, in crotchets
  - quantise
```
public static void quantise(Phrase phrase,
            double qValue)
```
    Quantises the rhythm values of notes in the phrase. See quantise(Phrase, double) for more details.
    
    Parameters:
    phrase - Phrase to be quantized
    qValue - the rhythm value to quantize to, in crotchets
  - quantize
```
public static void quantize(Phrase phrase,
            double qValue,
            int[] mode,
            int key)
```
    Aligns all rhythmValues of notes in a phrase to the closest beat subdivision and all note pitches to be members of the specified mode.
    This is a basic quantisation that doesn't take into account a note's offset, duration or position within a phrase. Each note is quantised by changing it's rhythm value to a integer multiple of qValue.
    As an example of how this might cause unwanted side-effects consider quantising the three notes in a quaver triple, to the qValue of 0.25. Each note's rhythm value is slightly less than a quaver, so is quantised to exactly a quaver. Together the three notes now extend over a dotted crotchet, whereas previously they occupied only a crotchet. If this triple was in a larger phrase all notes beyond the triplet would begin a quaver later. In common time this would have the effect of syncopating the rhythm.
    If phrase is null or qValue is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be quantised.
    qValue - the beat subdivision value to quantise to, in crotchets
    mode - the scale to use for the transposition (the JMC has some scale constants)
    key - the chromatic note to be used as the root of the mode. i.e., 0 = C, 1 = C# etc.
  - cycle
```
public static void cycle(Phrase phrase,
         int numNotes)
```
    Extends the phrase by repeating it until it contains the number of notes as specified by numNotes.
    The repetitions work in the same manner as repeat(jm.music.data.Phrase), except that the final repetition will not be a complete copy of the original phrase if the note count is reached before the repetition is completed.
    If phrase is null or if numNotes is less than or equal to the number of notes in the phrase then this method does nothing.
    
    Parameters:
    phrase - Phrase to be cycled
    numbNotes - the number of notes in the final phrase
  - cycle
```
public static void cycle(Phrase phrase,
         double numBeats)
```
    Extends the phrase by repeating it until it is as long as the specified length.
    The repetitions work in the same manner as repeat(jm.music.data.Phrase), except that the final repetition will not be a complete copy of the original phrase if the rhythm value count is reached before the repetition is completed.
    This method does not truncate the last note to make the final phrase exactly equal to numBeats. It guarantee that the final phrase is at least numBeats but may be greater depending on the rhythm value of the last note added.
    If phrase is null or if numNotes is less than or equal to the number of notes in the phrase then this method does nothing.
    
    Parameters:
    phrase - Phrase to be cycled
    numBeats - double describing the minimum length of the final phrase, in crotchets
  - shuffle
```
public static void shuffle(Phrase phrase)
```
    Randomise the order of notes in the phrase without repeating any note.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - Phrase to be shuffled
  - palindrome
```
public static void palindrome(Phrase phrase)
```
    Extend the phrase by adding all notes backwards, repeating the last note of the phrase.
    If phrase is null this method does nothing.
    
    Parameters:
    phrase - Phrase to be extended with its mirror
  - palindrome
```
public static void palindrome(Phrase phrase,
              boolean repeatLastNote)
```
    Extend the phrase by adding all notes backwards.
    If phrase is null this method does nothing.
    
    Parameters:
    phrase - Phras to be extended with its mirror
    repeatLastNote - boolean specifying whether the last note is to be repeated
  - rotate
```
public static void rotate(Phrase phrase)
```
    Move the notes around the phrase, first becoming second, second becoming third, and so forth with last becoming first.
    If phrase is null this method does nothing.
    
    Parameters:
    phrase - Phrase whose notes are to be rotated
  - rotate
```
public static void rotate(Phrase phrase,
          int numSteps)
```
    Move the notes around a number of steps as specified by numSteps which each step involving the first note becoming the second, second the third, and so forth with the last becoming first.
    If phrase is null this method does nothing.
    
    Parameters:
    phrase - Phrase whose notes are to be rotated
    int - number of steps
  - retrograde
```
public static void retrograde(Phrase phrase)
```
    Reverse the order of notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - Phrase to be mirrored
  - inversion
```
public static void inversion(Phrase phrase)
```
    Mirror the pitch of notes in the phrase around the first note's pitch. The order of the notes is not affected it is only the pitches that are mirrored. That is, notes which are n semitones above the first pitch will be changed to be n semitones below.
    For exact details of what happens when pitches are shifted below MIN_PITCH or above MAX_PITCH see the description for Note.setPitch(int)
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - Phrase to be inverted
  - invert
```
public static void invert(Phrase phrase)
```
  - diatonicInvert
```
public static void diatonicInvert(Phrase phrase,
                  int[] scale,
                  int root)
```
  - changeLength
```
public static void changeLength(Phrase phrase,
                double newLength)
```
    Alters the phrase so that it's notes are stretched or compressed until the phrase is the length specified. This method works in the same manner as elongate, except it takes an absolute length parameter not a ratio.
    If phrase is null or newLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be lengthened
    newLength - double describing the number of beats to change the phrase to.
  - elongate
```
public static void elongate(Phrase phrase,
            double scaleFactor)
```
    Stretch the time of each note in the phrase by scaleFactor
    If phrase is null or scaleFactor is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be lengthened
    scaleFactor - double describing the scale factor
  - accents
```
public static void accents(Phrase phrase,
           double meter)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
    The dynamic of each note starting on the beat will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase whose beats are to accented
    meter - double describing the number of croctets per bar/measure
  - accent
```
public static void accent(Phrase phrase,
          double meter)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
    The dynamic of each note starting on the beat will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase whose beats are to accented
    meter - double describing the number of croctets per bar/measure
  - accents
```
public static void accents(Phrase phrase,
           double meter,
           double[] accentedBeats)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Each accented note's dynamic will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
  - accent
```
public static void accent(Phrase phrase,
          double meter,
          double[] accentedBeats)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Each accented note's dynamic will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
  - accents
```
public static void accents(Phrase phrase,
           double meter,
           double[] accentedBeats,
           int accentAmount)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter. The meter is the total beat length of the bar/measure, while the array of accented beats is the times within the bar at which an accent should be made. For example, 6/8 time would be implied by a meter of 3 and a accent array of {0.0, 1.5}.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Accented beats will have their dynamic increased by accentAmount. If this causes the dynamic to be above MAX_DYNAMIC or below MIN_DYNAMIC (when accentAmount) then the dynamic will be set to a value as described by Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
    accentAmount - integer describing the value that the dynamic of accented beats are increased by.
  - accent
```
public static void accent(Phrase phrase,
          double meter,
          double[] accentedBeats,
          int accentAmount)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter. The meter is the total beat length of the bar/measure, while the array of accented beats is the times within the bar at which an accent should be made. For example, 6/8 time would be implied by a meter of 3 and a accent array of {0.0, 1.5}.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Accented beats will have their dynamic increased by accentAmount. If this causes the dynamic to be above MAX_DYNAMIC or below MIN_DYNAMIC (when accentAmount) then the dynamic will be set to a value as described by Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If phrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    phrase - Phrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
    accentAmount - integer describing the value that the dynamic of accented beats are increased by.
  - normalise
```
public static void normalise(Phrase phrase)
```
    Increases dynamic values so that the loudest is at maxiumim level. This process only effects the dynamic value of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - the Phrase to be effected
  - shake
```
public static void shake(Phrase phrase)
```
    Randomly adjusts Note dynamic values to create uneven loudness. This process only effects the dynamic value of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - the Phrase to be effected
  - shake
```
public static void shake(Phrase phrase,
         int amount)
```
    Randomly adjusts all Notes' dynamic value to create uneven loudness. This process only effects the dynamic value of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
    int - The amount of effect - e.g., 5 will be +-5 from the current amount
  - mutate
```
public static void mutate(Phrase phrase)
```
    Mutates the phrase by changing one pitch and one rhythm value.
    
    Parameters:
    Phrase - Phrase to be mutated
  - mutate
```
public static void mutate(Phrase phrase,
          int pitchCount,
          int[] scale)
```
    Mutates the phrase by changing pitches and rhythm values. The number of pitches and rhythm values to change can be set, and the pitches and rhythmValues to select from can be specified. The notes within the phrase to change are selected at random. The scale values need to be within 0-11 and will typically use the JMC scale constants.
    
    Parameters:
    Phrase - Phrase to be mutated
    int - pitchCount The number of notes to have pitch altered
    double - rhythmCount The number of notes to have thier rhythm altered
    int[] - pitches The scale values from which to select for relacements
    int - lowestPitch The smallest value a relacement pitch can be
    int - highestPitch The largest value a replacement pitch can be
    double[] - rhythms The rhyythm values from which to select replacements
  - mutate
```
public static void mutate(Phrase phrase,
          int pitchCount,
          int rhythmCount,
          int[] pitches,
          int lowestPitch,
          int highestPitch,
          double[] rhythms)
```
    Mutates the phrase by changing pitches and rhythm values. The number of pitches and rhythm values to change can be set, and the pitches and rhythmValues to select from can be specified. The notes within the phrase to change are selected at random. The scale values need to be within 0-11 and will typically use the JMC scale constants.
    
    Parameters:
    Phrase - Phrase to be mutated
    int - pitchCount The number of notes to have pitch altered
    double - rhythmCount The number of notes to have thier rhythm altered
    int[] - pitches The scale values from which to select for relacements
    int - lowestPitch The smallest value a relacement pitch can be
    int - highestPitch The largest value a replacement pitch can be
    double[] - rhythms The rhyythm values from which to select replacements
  - tiePitches
```
public static void tiePitches(Phrase phrase)
```
    Joins consecutive notes in the phrase that have the same pitch, creating one longer note. This is simmilar to the musical function of a tie. All note in the phrase meeting the conditions are effected. This modification may reduce the overall note count.
    
    Parameters:
    Phrase - Phrase to be processed
  - tieRests
```
public static void tieRests(Phrase phrase)
```
    Joins consecutive rests in the phrase creating one longer note. This is simmilar to the musical function of a tie. This modification may reduce the overall rest count.
    
    Parameters:
    Phrase - Phrase to be processed
  - fillRests
```
public static void fillRests(Phrase phrase)
```
    Lengthens notes followed by a rest in the phrase by creating one longer note and deleting the rest. This modification may reduce the overall note count in the phrase, be careful that use of this method does not to cause array out of bounds exceptions.
    
    Parameters:
    Phrase - Phrase to be processed
  - spread
```
public static void spread(Phrase phrase)
```
    Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum. This process only effects the pan value of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - the Phrase to be effected
  - bounce
```
public static void bounce(Phrase phrase)
```
    Adjusts all Note pan values to alternate between extreme left and right from note to note. This process only effects the pan value of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
  - varyLength
```
public static void varyLength(Phrase phrase,
              double minLength,
              double maxLength)
```
    Adjusts all Note duration values to vary randomly between specified values from note to note. This process only effects the duration attribute of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
    minlength - The shortest possible duration
    maxlength - The longest possible duration
  - randomize
```
public static void randomize(Phrase phrase,
             int pitchVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
    pitchVariation - The degree of pitch change to apply.
  - randomize
```
public static void randomize(Phrase phrase,
             int pitchVariation,
             double rhythmVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
  - randomize
```
public static void randomize(Phrase phrase,
             int pitchVariation,
             double rhythmVariation,
             int dynamicVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the phrase.
    If phrase is null then this method does nothing.
    
    Parameters:
    phrase - The Phrase to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
    dynamicVariation - The degree of dynamic change to apply.
  - slurUp
```
public static void slurUp(Phrase phrase)
```
    All ascending sequences of notes are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Phrase - The phrase to be modified.
  - slurDown
```
public static void slurDown(Phrase phrase)
```
    All descending sequences of notes are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Phrase - The phrase to be modified.
  - slurUp
```
public static void slurUp(Phrase phrase,
          int numberOfNotes)
```
    All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Phrase - The phrase to be modified.
    int - The number of notes in a row to consitute a sequence
  - slurDown
```
public static void slurDown(Phrase phrase,
            int numberOfNotes)
```
    All descending sequences of the number of notes or more are slured by having the duration of all but the last note extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Phrase - The phrase to be modified.
    int - The number of notes in a row to consitute a sequence
  - increaseDuration
```
public static void increaseDuration(Phrase phrase,
                    double multiplyer)
```
    Vary the duration of each note in the phrase by the multiplyer.
    
    Parameters:
    Phrase - The phrase to be modified.
    double - The amount to multiply the duration by.
  - addToDuration
```
public static void addToDuration(Phrase phrase,
                 double amount)
```
    Vary the duration of each note in the phrase by the specified amount.
    
    Parameters:
    Phrase - The phrase to be modified.
    double - The amount to add to the duration.
  - addToRhythmValue
```
public static void addToRhythmValue(Phrase phrase,
                    double amount)
```
    Vary the rhythm value of each note in the phrase by the specified amount.
    
    Parameters:
    Phrase - The phrase to be modified.
    double - The amount to add.
  - addToLength
```
public static void addToLength(Phrase phrase,
               double amount)
```
    Vary both the rhythm value and duration of each note in the phrase by the specified amount.
    
    Parameters:
    phrase - The phrase to be modified.
    double - The amount to add.
  - expandIntervals
```
public static void expandIntervals(Phrase phrase,
                   double amount)
```
    Vary the interval between notes scaling by the specified amount to each interval.
    
    Parameters:
    phrase - - The phrase to be modified.
    amount - - The scaling multiplyer for the intervals, i.e., 2.0 doubles width.
  - transpose
```
public static void transpose(CPhrase cphrase,
             int trans)
```
    Transposes the cphrase.
    If cphrase is null then this method does nothing. If the pitch is transposed to a value greater than MAX_PITCH or less than MIN_DYNAMIC then the pitch will be set to a value as described in the Note.setPitch(int) method.
    
    Parameters:
    cphrase - CPhrase to be transposed
    transpose - integer describing the amount to transpose in semitones
  - transpose
```
public static void transpose(CPhrase cphrase,
             int transposition,
             int[] mode,
             int key)
```
    Transpose the CPhrase up or down in scale degrees.
    If cphrase is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range. Transposition is in diatonic steps. For example in C major the note C transposed 1 will become D, transposed 4 will become G, and transposed by 7 will beome C an octave above. This can be somewhat unintuitive so be careful.
    
    Parameters:
    cphrase - CPhrase to be transposed
    transposition - the amount to transpose in semitones
    mode - the scale to use for the transposition
    key - the chromatic note to be used as the rooth of the mode. i.e., 0 = C, 1 = C# etc.
  - repeat
```
public static void repeat(CPhrase cphrase)
```
    Makes the CPhrase twice as long by repeating it once.
    If cphrase is null this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be repeated
  - repeat
```
public static void repeat(CPhrase cphrase,
          int times)
```
    Makes the CPhrase n times as long by repeating.
    If cphrase is null or times is less than one this mthod does nothing.
    
    Parameters:
    cphrase - CPhrase to be repeated
    times - number of repeats (default is 1)
  - repeat
```
public static void repeat(CPhrase cphrase,
          double startLoc,
          double endLoc)
```
    Loops a section of a the CPhrase once
    If cphrase is null; or startLoc is greater than or equal to endLoc then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be repeated
    startLoc - location of the loop start in beats
    endLoc - location of the loop end in beats
  - repeat
```
public static void repeat(CPhrase cphrase,
          int times,
          double startLoc,
          double endLoc)
```
    Loops a section of the CPhrase n times.
    If cphrase is null; startLoc is greater than or equal to endLoc; or n is less than one then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be repeated
    times - int number of repeats (default is 1)
    double - location of the loop start in beats
    double - location of the loop end in beats
  - fadeIn
```
public static void fadeIn(CPhrase cphrase,
          double fadeLength)
```
    Linearly fades in the CPhrase
    If cphrase is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be faded
    fadeLength - double describing the time of the fade, in crotchets.
  - fadeIn
```
public static void fadeIn(CPhrase cphrase,
          double fadeLength,
          double cphraseStartTime)
```
    Linearly fades in the CPhrase.
    If cphrase is null; fadeLength is less than or equal to zero; cphraseStartTime is less than zero; or fadeLength is less than or equal to cphraseStartTime then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be faded
    fadeLength - double describing the time of the fade, in crotchets
    cpharseStartTime - double describing how far into the fade the phrase starts.
  - fadeOut
```
public static void fadeOut(CPhrase cphrase,
           double fadeLength)
```
    Linearly fades out the CPhrase.
    If cphrase is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be faded
    fadeLength - double describing the time of the fade out in crotchets
  - fadeOut
```
public static void fadeOut(CPhrase cphrase,
           double fadeLength,
           double cphraseEndTime)
```
    Linearly fades out the CPhrase.
    If cphrase is null; fadeLength is less than or equal to zero; cphraseEndTime is less than zero; or fadeLength is less than cphraseEndTime then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be faded
    fadeLength - double describing the time of the fade out in crotchets
    phraseEndTime - double describing the length of time, in crothcets, between the end of the phrase and the end of the fade.
  - compress
```
public static void compress(CPhrase cphrase,
            double ratio)
```
    A compressor/expander routine. Compression ratio numbers between 0 and 1 compress, values larger than 1 expand.
    See compress(Phrase, double) for further details.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be compressed
    retio - double describing the compression factor.
  - append
```
public static void append(CPhrase cphrase1,
          CPhrase cphrase2)
```
    Adds a second CPhrase to the end of the first.
    If cphrase1 or cphrase2 is null then this method does nothing.
    
    Parameters:
    cphrase1 - the base CPhrase
    cphrase2 - CPhrase to be appended
  - merge
```
public static void merge(CPhrase cphrase1,
         CPhrase cphrase2)
```
    Combines the phrases from a second CPhrase into the first.
    If cphrase1 or cphrase2 is null then this method does nothing.
    
    Parameters:
    cphrase1 - the base CPhrase
    cphrase2 - the CPhrase to be merged with the first
  - quantize
```
public static void quantize(CPhrase cphrase,
            double qValue)
```
    Quantize the cphrase.
    See quantise(CPhrase, double).
    
    Parameters:
    cphrase - CPhrase to be quantized
    qValue - the amount to quantize to
  - quantise
```
public static void quantise(CPhrase cphrase,
            double qValue)
```
    Quantise the cphrase.
    See quantise(CPhrase, double).
    
    Parameters:
    cphrase - CPhrase to be quantized
    qValue - the amount to quantize to
  - quantize
```
public static void quantize(CPhrase cphrase,
            double qValue,
            int[] mode,
            int key)
```
    Quantise all the phrases in this CPhrase.
    See quantise(Phrase, double) for further details.
    If cphrase is null or qValue is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be quantised
    qValue - the amount to quantise to
  - shuffle
```
public static void shuffle(CPhrase cphrase)
```
    Randomly order notes within each phrase.
    
    Parameters:
    cphrase - -The CPhrase that contains phrases to be shuffled
  - cycle
```
public static void cycle(Part part,
         double to)
```
    A version of Cycle that works for parts
    
    Parameters:
    Part - the part to cycle
    double - position of where it should cycle to
  - elongate
```
public static void elongate(CPhrase cphrase,
            double scaleFactor)
```
    Lengthen each note in the CPhrase.
    See elongate(Phrase, double) for further details.
    If cphrase is null or scaleFactor is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be lengthened
    scaleFactor - double describing the scale factor
  - accents
```
public static void accents(CPhrase cphrase,
           double meter)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
    The dynamic of each note starting on the beat will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    If cphrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be accented
    meter - double describing the number of croctets per bar/measure
  - accents
```
public static void accents(CPhrase cphrase,
           double meter,
           double[] accentedBeats)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Each accented note's dynamic will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If cphrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
  - accents
```
public static void accents(CPhrase cphrase,
           double meter,
           double[] accentedBeats,
           int accentAmount)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter. The meter is the total beat length of the bar/measure, while the array of accented beats is the times within the bar at which an accent should be made. For example, 6/8 time would be implied by a meter of 3 and a accent array of {0.0, 1.5}.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Accented beats will have their dynamic increased by accentAmount. If this causes the dynamic to be above MAX_DYNAMIC or below MIN_DYNAMIC (when accentAmount) then the dynamic will be set to a value as described by Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If cphrase is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    cphrase - CPhrase to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
    accentAmount - integer describing the value that the dynamic of accented beats are increased by.
  - normalise
```
public static void normalise(CPhrase cphrase)
```
    Increases dynamic values so that the loudest is at maxiumim level.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - the CPhrase to be effected
  - spread
```
public static void spread(CPhrase cphrase)
```
    Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum. This process only effects the pan value of the notes in the cphrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - the CPhrase to be effected
  - bounce
```
public static void bounce(CPhrase cphrase)
```
    Adjusts all Notes' pan value to alternate between extreme left and right from note to note. This process only effects the pan value of the notes in the cphrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - The CPhrase to be effected
  - tiePitches
```
public static void tiePitches(CPhrase cphrase)
```
    Joins consecutive notes in each CPhrase that have the same pitch, creating one longer note. This is simmilar to the musical function of a tie. All note in the phrase meeting the conditions are effected. This modification may reduce the overall note count.
    
    Parameters:
    CPhrase - CPhrase to be processed
  - tieRests
```
public static void tieRests(CPhrase cphrase)
```
    Joins consecutive rests in each CPhrase creating one longer note. This is simmilar to the musical function of a tie. This modification may reduce the overall rest count.
    
    Parameters:
    CPhrase - CPhrase to be processed
  - fillRests
```
public static void fillRests(CPhrase cphrase)
```
    Lengthens notes followed by a rest in the CPhrase by creating one longer note and deleting the rest. This modification may reduce the overall note count in the phrase, be careful that use of this method does not to cause array out of bounds exceptions.
    
    Parameters:
    CPhrase - CPhrase to be processed
  - varyLength
```
public static void varyLength(CPhrase cphrase,
              double minLength,
              double maxLength)
```
    Adjusts all Notes' duration values to vary randomly between specified values from note to note. This process only effects the duration attribute of the notes in the phrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - The CPhrase to be effected
    minlength - The shortest possible duration
    maxlength - The longest possible duration
  - randomize
```
public static void randomize(CPhrase cphrase,
             int pitchVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the cphrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - The CPhrase to be effected
    pitchVariation - The degree of pitch change to apply.
  - randomize
```
public static void randomize(CPhrase cphrase,
             int pitchVariation,
             double rhythmVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm and duration, dynamic, and pan values of the notes in the cphrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - The CPhrase to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
  - randomize
```
public static void randomize(CPhrase cphrase,
             int pitchVariation,
             double rhythmVariation,
             int dynamicVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm and duration, dynamic, and pan values of the notes in the cphrase.
    If cphrase is null then this method does nothing.
    
    Parameters:
    cphrase - The CPhrase to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
    dynamicVariation - The degree of dynamic change to apply.
  - slurUp
```
public static void slurUp(CPhrase cphrase,
          int numberOfNotes)
```
    All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    CPhrase - The cphrase to be modified.
    int - The number of notes in a row to consitute a sequence
  - slurDown
```
public static void slurDown(CPhrase cphrase,
            int numberOfNotes)
```
    All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    CPhrase - The cphrase to be modified.
    int - The number of notes in a row to consitute a sequence
  - increaseDuration
```
public static void increaseDuration(CPhrase cphrase,
                    double multiplyer)
```
    Vary the duration of each note in the phrase by the multiplyer.
    
    Parameters:
    CPhrase - The cphrase to be modified.
    double - The amount to multiply the duration by.
  - addToDuration
```
public static void addToDuration(CPhrase cphrase,
                 double amount)
```
    Vary the duration of each note in the cphrase by the specified amount.
    
    Parameters:
    cphrase - - The cphrase to be modified.
    amount - - The number of beats to add to the duration.
  - addToRhythmValue
```
public static void addToRhythmValue(CPhrase cphrase,
                    double amount)
```
    Vary the rhythm value of each note in the cphrase by the specified amount.
    
    Parameters:
    cphrase - - The phrase to be modified.
    amount - - The number of beats to add.
  - addToLength
```
public static void addToLength(CPhrase cphrase,
               double amount)
```
    Vary both the rhythm value and duration of each note in the phrase by the specified amount.
    
    Parameters:
    cphrase - - The cphrase to be modified.
    amount - - The number of beats to add.
  - expandIntervals
```
public static void expandIntervals(CPhrase cphrase,
                   double amount)
```
    Vary the interval between notes scaling by the specified amount to each interval.
    
    Parameters:
    cphrase - - The CPhrase to be modified.
    amount - - The scaling multiplyer for the intervals, i.e., 2.0 doubles width.
  - shake
```
public static void shake(CPhrase cphrase,
         int amount)
```
    Randomise the dynamic values of notes up to a specified amount either side of the current value.
    
    Parameters:
    cphrase - - The CPhrase to be modified.
    amount - - The dynamic change possible either side of the curent dynamic.
  - repeat
```
public static void repeat(Part part)
```
    Makes the Part twice as long by repeating it once.
    If part is null this method does nothing.
    
    Parameters:
    part - Part to be repeated
  - repeat
```
public static void repeat(Part part,
          int times)
```
    Makes the Part n times as long by repeating.
    If part is null or times is less than one this method does nothing.
    
    Parameters:
    cphrase - Part to be repeated
    times - number of repeats (default is 1)
  - repeat
```
public static void repeat(Part part,
          double startLoc,
          double endLoc)
```
    Loops a section of a the Part once
    If part is null; or startLoc is greater than or equal to endLoc then this method does nothing.
    
    Parameters:
    part - Part to be repeated
    startLoc - location of the loop start in beats
    endLoc - location of the loop end in beats
  - repeat
```
public static void repeat(Part part,
          int times,
          double startLoc,
          double endLoc)
```
    Loops a section of the Part n times.
    If part is null; startLoc is greater than or equal to endLoc; or n is less than one then this method does nothing.
    
    Parameters:
    part - Part to be repeated
    times - int number of repeats (default is 1)
    double - location of the loop start in beats
    double - location of the loop end in beats
  - transpose
```
public static void transpose(Part part,
             int transposition)
```
    Transpose the part up or down in semitone steps. This transposition is chromatic, not diatonic.
    
    Parameters:
    part - the Part to be transposed
    transposition - the number of semitone steps to shift the pitch
  - transpose
```
public static void transpose(Part part,
             int degrees,
             int[] mode,
             int key)
```
    Transpose the Part up or down in scale degrees.
    If part is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range. Transposition is in diatonic steps. For example in C major the note C transposed 1 will become D, transposed 4 will become G, and transposed by 7 will beome C an octave above. This can be somewhat unintuitive so be careful.
    
    Parameters:
    part - Part to be transposed
    degrees - the number of scale degrees to transpose
    mode - the scale to use for the transposition
    key - the chromatic note to be used as the rooth of the mode. i.e., 0 = C, 1 = C# etc.
  - compress
```
public static void compress(Part part,
            double ratio)
```
    A compressor/expander routine. Compression ratio numbers between 0 and 1 compress, values larger than 1 expand.
    This is a basic compression routine and is not perfect. Specifically, each phrase compresses relative to itself, not to the overall part as might be expected.
    If part is null then this method does nothing.
    
    Parameters:
    part - Part to be compressed
    ratio - double describing the compression factor
  - append
```
public static void append(Part part1,
          Part part2)
```
    Adds a second part to the end of this one.
    If part1 or part2 is null then this method does nothing.
    
    Parameters:
    part1 - the base Part
    part2 - the Part to be appended
  - append
```
public static void append(Part part1,
          Part part2,
          double fromLoc)
```
    Adds a second part to this one starting from a specified location
    If part1 or part2 is null
    
    Parameters:
    part1 - the base Part
    part2 - the Part to be appended
    fromLoc - double describing the start time for the second part to be appended
  - increaseDynamic
```
public static void increaseDynamic(Part p,
                   int amount)
```
    Increases the dynamic by a certain amount -
    obviously a negative number will decrease it.
    
    Parameters:
    Part - the part that is to be affected
    int - the amount that it is to be affected by
  - fadeIn
```
public static void fadeIn(Part part,
          double fadeLength)
```
    Linearly fades in the Part.
    If part is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be faded
    fadelength - double describing the number of crotchets to fade over
  - fadeIn
```
public static void fadeIn(Part part,
          double fadeLength,
          double partStartTime)
```
    Linearly fades in the Part.
    If part is null; fadeLength is less than or equal to zero; phraseStart is less than zero; or fadeLength is less than or equal to phraseStart then this method does nothing.
    
    Parameters:
    part - Part to be faded
    fadeLength - double describing the duration of the fade, in crotchets
    partStartTime - double describing how far into the fade the part starts
  - fadeOut
```
public static void fadeOut(Part part,
           double fadeLength)
```
    Linearly fades out the Part.
    If part is null; or if fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be faded
    fadeLength - double describing the duration of the fade out in crotchets
  - fadeOut
```
public static void fadeOut(Part part,
           double fadeLength,
           double partEndTime)
```
    Linearly fades out the Part.
    If part is null; fadeLength is less than or equal to zero; phraseEndTime is less than zero; or fadeLength is less than phraseEndTime then this method does nothing.
    
    Parameters:
    part - Part to be faded
    fadeLength - double describing the duration of the fade out in crotchets
    partEndTime - double describing the length of time, in crotchets, between the end of the part and the end of the fade.
  - merge
```
public static void merge(Part part1,
         Part part2)
```
    Combines the phrases from a second part into this one.
    If part1 or part2 is null this method does nothing.
    
    Parameters:
    part1 - the base Part
    part2 - the Part to be merged to the first
  - quantize
```
public static void quantize(Part part,
            double qValue)
```
    Quantize the part.
    See quantise(Part, double).
    
    Parameters:
    part - Part to be quantized
    qValue - the amount to quantize to
  - quantise
```
public static void quantise(Part part,
            double qValue)
```
    Quantise the part.
    See quantise(Part, double).
    
    Parameters:
    part - Part to be quantized
    qValue - the amount to quantize to
  - quantize
```
public static void quantize(Part part,
            double qValue,
            int[] mode,
            int key)
```
    Quantize all the phrases in this part, both rhythmic and pitch elements.
    See quantise(Phrase, double) for details.
    If part is null or qValue is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be quantised
    double - - the amount to quantise too
  - shuffle
```
public static void shuffle(Part part)
```
    Randomly order notes within each phrase.
    
    Parameters:
    part - -The Part that contains phrases to be shuffled
  - accents
```
public static void accents(Part part,
           double meter)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure.
    The dynamic of each note starting on the beat will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    If part is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be accented
    meter - double describing the number of croctets per bar/measure
  - accents
```
public static void accents(Part part,
           double meter,
           double[] accentedBeats)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Each accented note's dynamic will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If part is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
  - accents
```
public static void accents(Part part,
           double meter,
           double[] accentedBeats,
           int accentAmount)
```
    Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter. The meter is the total beat length of the bar/measure, while the array of accented beats is the times within the bar at which an accent should be made. For example, 6/8 time would be implied by a meter of 3 and a accent array of {0.0, 1.5}.
    accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets.
    Accented beats will have their dynamic increased by accentAmount. If this causes the dynamic to be above MAX_DYNAMIC or below MIN_DYNAMIC (when accentAmount) then the dynamic will be set to a value as described by Note.setDynamic(int).
    Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing.
    If part is null or meter is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be accented
    meter - double describing the number of croctets per bar/measure
    accentedBeats - double array describing the time of the accents in the bar.
    accentAmount - integer describing the value that the dynamic of accented beats are increased by.
  - normalise
```
public static void normalise(Part part)
```
    Increases dynamic values so that the loudest is at maxiumim level.
    If part is null then this method does nothing.
    
    Parameters:
    part - the Part to be effected
  - elongate
```
public static void elongate(Part part,
            double scaleFactor)
```
    Stretch the time of each note in each phrase by the scaleFactor
    If phrase is null or scaleFactor is less than or equal to zero then this method does nothing.
    
    Parameters:
    part - Part to be lengthened
    scaleFactor - double describing the scale factor
  - tiePitches
```
public static void tiePitches(Part part)
```
    Joins consecutive notes in each phrase that have the same pitch, creating one longer note. This is simmilar to the musical function of a tie. All note in the phrase meeting the conditions are effected. This modification may reduce the overall note count.
    
    Parameters:
    Part - Part to be processed
  - tieRests
```
public static void tieRests(Part part)
```
    Joins consecutive rests in each part creating one longer note. This is simmilar to the musical function of a tie. This modification may reduce the overall rest count.
    
    Parameters:
    part - Part to be processed
  - fillRests
```
public static void fillRests(Part part)
```
    Lengthens notes followed by a rest in the part by creating one longer note and deleting the rest. This modification may reduce the overall note count in the phrase, be careful that use of this method does not to cause array out of bounds exceptions.
    
    Parameters:
    Part - Part to be processed
  - spread
```
public static void spread(Part part)
```
    Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum. This process only effects the pan value of the notes in the part.
    If part is null then this method does nothing.
    
    Parameters:
    part - the Part to be effected
  - bounce
```
public static void bounce(Part part)
```
    Adjusts all Notes' pan value to alternate between extreme left and right from note to note. This process only effects the pan value of the notes in the part.
    If part is null then this method does nothing.
    
    Parameters:
    part - The Part to be effected
  - varyLength
```
public static void varyLength(Part part,
              double minLength,
              double maxLength)
```
    Adjusts all Notes' duration values to vary randomly between specified values from note to note. This process only effects the duration attribute of the notes in the phrase.
    If Part is null then this method does nothing.
    
    Parameters:
    part - The Part to be effected
    minlength - The shortest possible duration
    maxlength - The longest possible duration
  - randomize
```
public static void randomize(Part part,
             int pitchVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm and duration, dynamic, and pan values of the notes in the part.
    If Part is null then this method does nothing.
    
    Parameters:
    part - The Part to be effected
    pitchVariation - The degree of pitch change to apply.
  - randomize
```
public static void randomize(Part part,
             int pitchVariation,
             double rhythmVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm and duration, dynamic, and pan values of the notes in the part.
    If Part is null then this method does nothing.
    
    Parameters:
    part - The Part to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
  - randomize
```
public static void randomize(Part part,
             int pitchVariation,
             double rhythmVariation,
             int dynamicVariation)
```
    Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm and duration, dynamic, and pan values of the notes in the part.
    If Part is null then this method does nothing.
    
    Parameters:
    part - The Part to be effected
    pitchVariation - The degree of pitch change to apply.
    rhythmVariation - The degree of rhythm value change to apply.
    dynamicVariation - The degree of dynamic change to apply.
  - slurUp
```
public static void slurUp(Part part,
          int numberOfNotes)
```
    All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Part - The part to be modified.
    int - The number of notes in a row to consitute a sequence
  - slurDown
```
public static void slurDown(Part part,
            int numberOfNotes)
```
    All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results.
    
    Parameters:
    Part - The part to be modified.
    int - The number of notes in a row to consitute a sequence
  - increaseDuration
```
public static void increaseDuration(Part part,
                    double multiplyer)
```
    Vary the duration of each note in the part by the multiplyer.
    
    Parameters:
    Part - The part to be modified.
    double - The amount to multiply the duration by.
  - addToDuration
```
public static void addToDuration(Part part,
                 double amount)
```
    Vary the duration of each note in the part by the specified amount.
    
    Parameters:
    part - - The Part to be modified.
    amount - - The number of beats to add to the duration.
  - addToRhythmValue
```
public static void addToRhythmValue(Part part,
                    double amount)
```
    Vary the rhythm value of each note in the part by the specified amount.
    
    Parameters:
    part - - The Part to be modified.
    amount - - The number of beats to add.
  - addToLength
```
public static void addToLength(Part part,
               double amount)
```
    Vary both the rhythm value and duration of each note in the part by the specified amount.
    
    Parameters:
    part - - The Part to be modified.
    amount - - The number of beats to add.
  - expandIntervals
```
public static void expandIntervals(Part part,
                   double amount)
```
    Vary the interval between notes scaling by the specified amount to each interval.
    
    Parameters:
    part - - The Part to be modified.
    amount - - The scaling multiplyer for the intervals, i.e., 2.0 doubles width.
  - shake
```
public static void shake(Part part,
         int amount)
```
    Randomise the dynamic values of notes up to a specified amount either side of the current value.
    
    Parameters:
    part - - The Part to be modified.
    amount - - The dynamic change possible either side of the curent dynamic.
  - consolidate
```
public static void consolidate(Part p)
```
    packs all of the phrases within this part into a single phrase
  - transpose
```
public static void transpose(Score scr,
             int transposition)
```
    Transpose a Score
    
    Parameters:
    score - Score to be faded
    transposition - The number of semitones to transpose by
  - transpose
```
public static void transpose(Score score,
             int degrees,
             int[] mode,
             int key)
```
    Transpose the score up or down in scale degrees.
    If score is null then this method does nothing. If the transposition shifts a pitch above MAX_PITCH or below MIN_PITCH, the pitch will probably cap at those values. See the description of Note.setPitch(int) method for exact details of what occurs when trying to set the pitch beyond the allowed range. Transposition is in diatonic steps. For example in C major the note C transposed 1 will become D, transposed 4 will become G, and transposed by 7 will beome C an octave above. This can be somewhat unintuitive so be careful.
    
    Parameters:
    score - Score to be transposed
    degrees - the amount to transpose in scale steps
    mode - the scale to use for the transposition
    key - the chromatic note to be used as the rooth of the mode. i.e., 0 = C, 1 = C# etc.
  - fadeIn
```
public static void fadeIn(Score score,
          double fadeLength)
```
    Linearly fades in the Score.
    See fadeIn(Phrase, double).
    If score is null or fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    score - Score to be faded
    fadelength - double describing the number of crotchets to fade over
  - increaseDynamic
```
public static void increaseDynamic(Score s,
                   int amount)
```
    increases the dynamic by a certain amount -
    obviously a negative number will decrease it
    
    Parameters:
    Score - the score that is to be affected
    int - the amount
  - fadeOut
```
public static void fadeOut(Score score,
           double fadeLength)
```
    Linearly fades out the Score.
    See fadeOut(Phrase, double).
    If score is null or fadeLength is less than or equal to zero then this method does nothing.
    
    Parameters:
    score - Score to be faded
    fadelength - double describing the number of crotchets to fade over
  - compress
```
public static void compress(Score score,
            double ratio)
```
    A compressor/expander routine. Compression ratio numbers between 0 and 1 compress, values larger than 1 expand.
    See compress(Part, double).
    If score is null then this method does nothing.
    
    Parameters:
    score - Score to be expanded/compressed
    ratio - double describing the compression factor
  - repeat
```
public static void repeat(Score score)
```
    Makes a the score twice times as long by repeating If score is null then this method does nothing.
    Parameters: score - Score to be repeated
  repeat public static void repeat(Score score, int times) Loops the score n times. If score is null or times is less than one then this method does nothing. Parameters: score - Score to be repeated times - integer representing the number of repeats append public static void append(Score score1, Score score2) Adds a second score to the end of this one. If score1 or score2 is null then this method does nothing. Parameters: score1 - the base Score score2 - the Score to be appended merge public static void merge(Score score1, Score score2) Combines the parts from a second score into the first one. Parts on an existing channel will have phases extracted and added to that part, otherwise a part with a unique channel number will be added. If score1 or score2 is null then this method does nothing. Parameters: score1 - the base score score2 - the Score to be merged to the base score quantize public static void quantize(Score score, double qValue) Quantize rhythm values of all the parts in this score. American spelling to save frustration! See quantise(Score, double). Parameters: score - Score to quantize qValue - double describing the amount to quantize to quantise public static void quantise(Score score, double qValue) Quantise all the rhythm values of notes in this score. See quantise(Score, double). Parameters: score - Score to quantize qValue - double describing the amount to quantize to quantize public static void quantize(Score score, double qValue, int[] mode, int key) Quantize all the rhythm values and pitches in this score. See quantise(Phrase, double). If score is null or qValue is less than or equal to zero then this method does nothing. Parameters: score - Score to quantise qValue - double describing the amount to quantise to mode - The scale to quantize pitch values to, e.g., MAJOR_SCALE key - The key of the mode. e.g., 0 = C, 1 = C# etc. shuffle public static void shuffle(Score score) Randomly order notes within each phrase. Parameters: score - -The Score that contains phrases to be shuffled accents public static void accents(Score score, double meter) Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by emphasising the first beat of each bar/measure. The dynamic of each note starting on the beat will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int). If score is null or meter is less than or equal to zero then this method does nothing. Parameters: score - Score whose beats are to be accented meter - double describing the number of crochets per bar/measure accents public static void accents(Score score, double meter, double[] accentedBeats) Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter by accenting specified beats within each bar/measure. accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets. Each accented note's dynamic will be increased by 20. If this raises the dynamic above MAX_DYNAMIC then the dynamic will be set to a value as described in Note.setDynamic(int). Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing. If score is null or meter is less than or equal to zero then this method does nothing. Parameters: score - Score to be accented meter - double describing the number of croctets per bar/measure accentedBeats - double array describing the time of the accents in the bar. accents public static void accents(Score score, double meter, double[] accentedBeats, int accentAmount) Increase the dynamic of notes at regularly occuring pulse locations which generates the sound of regular meter. The meter is the total beat length of the bar/measure, while the array of accented beats is the times within the bar at which an accent should be made. For example, 6/8 time would be implied by a meter of 3 and a accent array of {0.0, 1.5}. accentedBeats is an array of values describing where the accents begin relative to the start of each bar, in crochets. Accented beats will have their dynamic increased by accentAmount. If this causes the dynamic to be above MAX_DYNAMIC or below MIN_DYNAMIC (when accentAmount) then the dynamic will be set to a value as described by Note.setDynamic(int). Each of the double values in accentedBeats must be greater than or equal to zero and less than meter or this method does nothing. If score is null or meter is less than or equal to zero then this method does nothing. Parameters: score - Score to be accented meter - double describing the number of croctets per bar/measure accentedBeats - double array describing the time of the accents in the bar. accentAmount - integer describing the value that the dynamic of accented beats are increased by. normalise public static void normalise(Score score) Increases dynamic values so that the loudest is at maxiumim level. If score is null then this method does nothing. Parameters: score - the Score to be effected consolidate public static void consolidate(Score score) Pack all phrases from parts with the same channel into one part. Data from all parts with the same channel is consolidated into one part. This is often useful after appending several scores with simmilar instrumentation. If score is null then this method does nothing. Parameters: score - the Score to be effected elongate public static void elongate(Score score, double scaleFactor) Stretch the time of each note in each phrase by the scaleFactor If phrase is null or scaleFactor is less than or equal to zero then this method does nothing. Parameters: score - Score to be lengthened scaleFactor - double describing the scale factor tiePitches public static void tiePitches(Score score) Joins consecutive notes in each phrase that have the same pitch, creating one longer note. This is simmilar to the musical function of a tie. All note in the phrase meeting the conditions are effected. This modification may reduce the overall note count. Parameters: score - Score to be processed tieRests public static void tieRests(Score score) Joins consecutive rests in each phrase creating one longer note. This is simmilar to the musical function of a tie. This modification may reduce the overall rest count. Parameters: score - Score to be processed fillRests public static void fillRests(Score score) Lengthens notes followed by a rest in the score by creating one longer note and deleting the rest. This modification may reduce the overall note count in the phrase, be careful that use of this method does not to cause array out of bounds exceptions. Parameters: Score - Score to be processed spread public static void spread(Score score) Randomly adjusts all Notes' pan value to create an even spread acroos the stereo spectrum. This process only effects the pan value of the notes in the score. If score is null then this method does nothing. Parameters: cphrase - the CPhrase to be effected bounce public static void bounce(Score score) Adjusts all Notes' pan value to alternate between extreme left and right from note to note. This process only effects the pan value of the notes in the score. If score is null then this method does nothing. Parameters: score - The Score to be effected varyLength public static void varyLength(Score score, double minLength, double maxLength) Adjusts all Notes' duration values to vary randomly between specified values from note to note. This process only effects the duration attribute of the notes in the phrase. If the Score is null then this method does nothing. Parameters: score - The Score to be effected minlength - The shortest possible duration maxlength - The longest possible duration randomize public static void randomize(Score score, int pitchVariation) Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the score. If Score is null then this method does nothing. Parameters: score - The Score to be effected pitchVariation - The degree of pitch change to apply. randomize public static void randomize(Score score, int pitchVariation, double rhythmVariation) Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the score. If score is null then this method does nothing. Parameters: score - The Score to be effected pitchVariation - The degree of pitch change to apply. rhythmVariation - The degree of rhythm value change to apply. randomize public static void randomize(Score score, int pitchVariation, double rhythmVariation, int dynamicVariation) Adjusts Note values to any value plus or minus a specified amount. This process can effect pitch, rhythm & duration, dynamic, and pan values of the notes in the score. If Score is null then this method does nothing. Parameters: score - The Score to be effected pitchVariation - The degree of pitch change to apply. rhythmVariation - The degree of rhythm value change to apply. dynamicVariation - The degree of dynamic change to apply. slurUp public static void slurUp(Score score, int numberOfNotes) All ascending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results. Parameters: Score - The score to be modified. int - The number of notes in a row to consitute a sequence slurDown public static void slurDown(Score score, int numberOfNotes) All descending sequences of the number of notes or more are slured by having thier duration extended to 100% of the rhythm value. This algorithm assumes notes are arranged in the standard monophonic series used by jMusic. Notes with durations longer than rhythm values will produce unintended results. Parameters: Score - The score to be modified. int - The number of notes in a row to consitute a sequence increaseDuration public static void increaseDuration(Score score, double multiplyer) Vary the duration of each note in the score by the multiplyer. Parameters: Score - The score to be modified. double - The amount to multiply the duration by. addToDuration public static void addToDuration(Score score, double amount) Vary the duration of each note in the score by the specified amount. Parameters: score - - The Score to be modified. amount - - The number of beats to add to the duration. addToRhythmValue public static void addToRhythmValue(Score score, double amount) Vary the rhythm value of each note in the Score by the specified amount. Parameters: score - - The Score to be modified. amount - - The number of beats to add. addToLength public static void addToLength(Score score, double amount) Vary both the rhythm value and duration of each note in the Score by the specified amount. Parameters: score - - The Score to be modified. amount - - The number of beats to add. expandIntervals public static void expandIntervals(Score score, double amount) Vary the interval between notes scaling by the specified amount to each interval. Parameters: score - - The Score to be modified. amount - - The scaling multiplyer for the intervals, i.e., 2.0 doubles width. shake public static void shake(Score score, int amount) Randomise the dynamic values of notes up to a specified amount either side of the current value. Parameters: score - - The score to be modified. amount - - The dynamic change possible either side of the curent dynamic.

Class Mod

Field Summary

Fields inherited from interface jm.JMC

Fields inherited from interface jm.constants.Durations

Fields inherited from interface jm.constants.Pitches

Fields inherited from interface jm.constants.Frequencies

Fields inherited from interface jm.constants.Tunings

Fields inherited from interface jm.constants.Volumes

Fields inherited from interface jm.constants.Panning

Fields inherited from interface jm.constants.ProgramChanges

Fields inherited from interface jm.constants.DrumMap

Fields inherited from interface jm.constants.Scales

Fields inherited from interface jm.constants.Waveforms

Fields inherited from interface jm.constants.Noises

Fields inherited from interface jm.constants.Alignments

Method Summary

Methods inherited from class java.lang.Object

Method Detail

append

transpose

transpose

quantizePitch

crescendo

diminuendo

decrescendo

transpose

transpose

repeat

repeat

repeat

repeat

increaseDynamic

fadeIn

fadeIn

fadeOut

fadeOut

compress

append

quantize

quantise

quantize

cycle

cycle

shuffle

palindrome

palindrome

rotate

rotate

retrograde

inversion

invert

diatonicInvert

changeLength

elongate

accents

accent

accents

accent

accents

accent

normalise

shake

shake

mutate

mutate

mutate

tiePitches

tieRests

fillRests

spread

bounce

varyLength

randomize

randomize

randomize

slurUp

slurDown

slurUp

slurDown

increaseDuration