PolyphonGeneticComposer

compose

## Class PolyphonGeneticComposer

- java.lang.Object
- - compose.PolyphonGeneticComposer

-     public class PolyphonGeneticComposer
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private java.util.ArrayList<jm.music.data.Part>` | `alParts` ArrayList mit Begleitungen
    `private int[][]` | `beatTransitions` Array fuer die Taktuebergaenge (Zeilen-/Spaltenreihenfolge 0-11 : C, C#, D, E, Eb, F, F#, G, Ab, A, Bb, B)
    `private int` | `category` ID der verwendeten/entstehenden Kategorie (Genre)
    `private boolean` | `Crossover` gibt an, welche Arten der Taktveraenderung verwendet werden sollen
    `private double` | `fitness` >= dieser Grenze werden die Takte behalten
    `private int[]` | `instruments` Array der IDs der zu verwendeten Instrumente (200 entspricht Percussion)
    `private java.lang.String` | `key` Tonart der neuen Komposition
    `private boolean` | `major` Dur (major): true, Moll (minor): false
    `private MIDIMelodicInstrument[]` | `mmi` gibt an, welche Instrumente Melodie, Akkord oder zufaellig spielt
    `private boolean` | `Mutation` gibt an, welche Arten der Taktveraenderung verwendet werden sollen
    `private boolean` | `NPointCrossover` gibt an, welche Arten der Taktveraenderung verwendet werden sollen
    `private int` | `numerator` Anzahl der Viertelnoten pro Takt
    `private static int` | `PPQN` Pulses Per Quarter Note
    `private java.lang.String` | `pw` password
    `private jm.music.data.Score` | `score` die Komposition
    `private static int` | `STARTSIZE` Anzahl der Motive pro Instrument, die als Grundpopulation dienen sollen
    `private int` | `tempo` BPM (Beats per Minute)
    `private int` | `tracklength` Laenge des MIDI-Tracks in Sekunden
    `private java.lang.String[]` | `transposeStep` Halbtonschritte beim Transponieren
    `private java.lang.String` | `url` DB-Url
    `private java.lang.String` | `user` username
    `private int[]` | `volumes` Volume of each Part

  - ### Constructor Summary

    Constructors
    Constructor and Description

    `PolyphonGeneticComposer(int category, int tempo, int tracklength, int[] instruments, int[] volumes, int startPopulation, double fitness, java.lang.String key, java.lang.String user, java.lang.String pw, java.lang.String url, ComposingStatusDialog csd, boolean Crossover, boolean NPointCrossover, boolean Mutation)`
    Konstruktor des polyphonen genetischen Composers

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `private MIDIPartData` | `checkBeats(MIDIPartData mpd)` prueft, ob alle Pitches noch gueltige Werte besitzen und ob Platz fuer die Begleitspuren bleibt
    `private MultiBeat` | `chooseFollower(java.lang.String note, MIDIPartData mpd)` waehlt einen Nachfolgertakt fuer mb aus den Takten in mpd, anhand der Taktuebergangstabelle aus
    `private int` | `chooseInstrumentForMelody()` waehlt aus den zu verwendenden Instrumenten ein passendes fuer die Melodie aus gibt es kein passendes, wird das erste Instrument zugewiesen
    `private MIDIPartData` | `connectBeats(MIDIPartData mpd)` verbindet die Takte mit Hilfe der Taktuebergangstabelle
    `private MultiBeat` | `correctMultiBeat(MultiBeat mb)` ergaenzt den Takt mit Pausen, um die korrekte Taktlaenge zu erreichen
    `private jm.music.data.Part` | `createCounterParts(MIDIPartData almb, int instrument, int channel)` erzeugt eine Begleitspur passend zu den uebergebenen Takten nach Vorgaben gespeichert in mmi (MIDIMelodicInstrument)
    `private jm.music.data.Part` | `createHarmonyPart(java.util.ArrayList<MultiBeat> almb, int instrument, int part)` liefert einen Begleitpart bestehend aus Begleitakkorden
    `private MIDIPartData` | `createNewBeats(MIDIPartData mpd)` waehlt zufaellig eine Art aus, wie neue Takte entstehen sollen
    `private jm.music.data.Part` | `createPercussions(MIDIPartData mpd)` erstellt Percussions als Begleitung
    `private jm.music.data.Part` | `createPercussivs(MIDIPartData mpd, int instrument, int channel)` erstellt Percussions als Begleitung
    `private jm.music.data.Part` | `createPolyphoneMelodyPart(java.util.ArrayList<MultiBeat> almb, int instrument, int part, boolean transpose)` liefert einen polyphonen Part bestehend aus den Noten des uebergebenen Takts
    `private jm.music.data.Part` | `createRandomNoisePart(java.util.ArrayList<MultiBeat> almb, int instrument, int part)` liefert einen Begleitpart bestehend aus zufaelligen Geraeuschen
    `private MultiBeat[]` | `Crossover(MultiBeat mb, MultiBeat mb2, boolean NPoint)` one-point crossover zweier Takte zwei Genome werden jeweils an einer Stelle gebrochen und die entstehenden Teilstücke ausgetauscht (AA, BB => AB, BA) es koennen nur Takte, bei denen beide eine gerade bzw. ungerade Notenanzahl haben, gekreuzt werden
    `private MultiBeat[]` | `CrossoverNPoint(MultiBeat mb, MultiBeat mb2)` n-point crossover zweier Takte zwei Genome werden jeweils an mehreren Stelle gebrochen und die entstehenden Teilstücke ausgetauscht (AAAA, BBBB => AB, BA, ABAB, BABA, ABBB, BAAA, AABA, ...)
    `private MIDIPartData` | `fillUpMotifs(MIDIPartData mpd)` ueberprueft, ob alle Takte genau der Taktlaenge entsprechen und fuellt sie gegebenenefalls mit Pausen auf
    `private java.lang.String` | `FormatKeys(java.lang.String s)` replace key by MIDI-key-name
    `private MIDIPartData` | `generateBeats(MIDIPartData mpd)` generiert neue Takte mit Hilfe eines genetischen Algorithmus erzeugt so lange Takte, bis die benoetigte Anzahl an Takten (beatcount) erreicht wurde danach werden alle Takte nach verschiedenen Fitnessfunctions bewertet und fuer ungenuegend befundene Takte werden verworfen, alle positiven Takte werden zu den bereits vorhandenen Takten hinzugefuegt.
    `private void` | `generateCounterParts(MIDIPartData mpd, int chosenInstrument)` generiert Begleittakte, passen zu den Takten der Grundmelodie
    `private int` | `getAveragePitch(MultiBeat mb)` liefert den Durchschnittspitch des Takts
    `private int` | `getBeatCountForTrack()` liefert die Anzahl der Takte, die der MIDI-Track benoetigt, um die gewuenschte Laenge zu erreichen
    `jm.music.data.Score` | `getComposition()` liefert die neue Komposition
    `private jm.music.data.Note` | `getEmptyBeat()`
    `private MultiBeat` | `getFollower(MultiBeat mb, MIDIPartData mpd)` liefert einen Takt, der auf Grund der Taktuebergangstabelle ein moeglicher Nachfolger des uebergebenen Takts ist
    `private int` | `getHalftoneSteps(java.lang.String From, java.lang.String To)` gibt die Anzahl der Halbtoene zurueck um von der Ursprungstonart in die Zieltonart zu gelangen der geringere Unterschied wird verwendet (man kann auf beide Seiten transponieren, nur die Oktave aendert sich)
    `private int` | `getIDForNote(java.lang.String s)` liefert zur uebergebenen Note die ID i Taktuebergangsarray
    `private int[]` | `getInstrumentGroupBorder(int instrument)` liefert die untere und obere Grenze der Instrumentengruppe des uebergebenen Instruments
    `private int` | `getLowestFirstPitch(MultiBeat mb)` liefert den tiefsten Pitch der ersten (auftretenden) Note
    `private int` | `getMaxPhraseCount(java.util.ArrayList<MultiBeat> almb)` liefert die Anzahl der maximalen Phrasen aller Takte
    `private MultiBeat` | `getMultiBeatInCorrectOctave(MultiBeat mb, int Avg)` liefert einen MultiBeat auf die Oktave transponiert, welche dem Durchschnittspitch (Avg) entspricht
    `private java.lang.String` | `getNoteForInt(int pitch)` liefert zu einem Pitch die Note als String
    `private int` | `getNumerator()` liefert den zufaellig ausgewaehlten Numerator einer Kategorie
    `private jm.music.data.Score` | `getPolyphoneScore(MIDIPartData mpd)` liefert einen polyphonen Score bestehend aus den Phrasen und Noten der uebergebenen Takte
    `private MIDIPartData` | `getStartMotifs(int chosenInstrument)` sucht nach einem Startmotif fuer ein Instrument aus der Kategorie, welches eine Melodie spielt
    `private MIDIPartData` | `gradeBeats(MIDIPartData mpd)` bewertet die Takte, entfernt unpassende/falsche Takte
    `private void` | `initialiseInstruments()` initialisiert die Instrumentengruppen, ob sie Melodie, Akkorde oder zufaellige Toene spielen sollen/duerfen
    `private boolean` | `InstrumentPlaysMelody(int instrument)` gibt an, ob das uebergebene Instrument eine Melodie spielen kann/soll
    `private MultiBeat` | `invertBeat(MultiBeat mb)` invertiert den Tankt (Spiegel)
    `private MultiBeat` | `Mutation(MultiBeat mb)` Mutation eines Takts - transponieren (um -6 bis 6) - vertauschen der Pitches - nach Pitches aufsteigend sortieren - nach Pitches absteigend sortieren - umdrehen (Reversion/Krebs) - Intervallrichtungsaenderung (Inversion/Spiegel)
    `private void` | `printIdentityHashCode(MIDIPartData mpd)` fuer Debuggingzwecke gibt den Speicherbereich jeder Note aus
    `private void` | `printMinMaxPitchOfEachBeat(MIDIPartData mpd)` fuer Debuggingzwecke gibt die hoechste und die tiefste Note aus
    `private void` | `printNoteDataArray(NoteData[][] nd)` fuer Debuggingzwecke gibt einen Takt als String aus
    `private MultiBeat` | `revertBeat(MultiBeat mb)` dreht den Takt um (Krebs)
    `private MIDIPartData` | `setMotifsToSameOctave(MIDIPartData mpd)` transponiert alle Takte auf die gleiche Oktave
    `private MultiBeat` | `shuffleBeat(MultiBeat mb)` vertauscht zufaellig die Reihenfolge der Noten im Takt
    `private MultiBeat` | `sortBeatAscOrDesc(MultiBeat mb, boolean Asc)` sortiert die Noten aufsteigend bzw. absteigend
    `private MultiBeat` | `transposeBeat(MultiBeat mb)` transponiert den Takt zufaellig um -6 bis +6 Halbtonschritte
    `private MultiBeat` | `TransposeBeat(MultiBeat mb, java.lang.String oldKey, java.lang.String newKey, int Steps)` transponiert den polyphonen Takt in eine andere Tonart
    `private MIDIPartData` | `transposeMotifsToBaseTonality(MIDIPartData mpd)` transponiert alle Takte auf die Grundtonart (Tonart ohne Vorzeichen) bei Dur in C-Dur und bei Moll in A-Moll
    `private MIDIPartData` | `transposeMotifsToChosenTonality(MIDIPartData mpd)` transponiert alle Takte auf die gewuenschte Tonart

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### user

          private java.lang.String user

      username

    - #### pw

          private java.lang.String pw

      password

    - #### url

          private java.lang.String url

      DB-Url

    - #### PPQN

          private static int PPQN

      Pulses Per Quarter Note

    - #### instruments

          private int[] instruments

      Array der IDs der zu verwendeten Instrumente (200 entspricht Percussion)

    - #### category

          private int category

      ID der verwendeten/entstehenden Kategorie (Genre)

    - #### tempo

          private int tempo

      BPM (Beats per Minute)

    - #### tracklength

          private int tracklength

      Laenge des MIDI-Tracks in Sekunden

    - #### key

          private java.lang.String key

      Tonart der neuen Komposition

    - #### major

          private boolean major

      Dur (major): true, Moll (minor): false

    - #### STARTSIZE

          private static int STARTSIZE

      Anzahl der Motive pro Instrument, die als Grundpopulation dienen sollen

    - #### numerator

          private int numerator

      Anzahl der Viertelnoten pro Takt

    - #### mmi

          private MIDIMelodicInstrument[] mmi

      gibt an, welche Instrumente Melodie, Akkord oder zufaellig spielt

    - #### score

          private jm.music.data.Score score

      die Komposition

    - #### transposeStep

          private java.lang.String[] transposeStep

      Halbtonschritte beim Transponieren

    - #### alParts

          private java.util.ArrayList<jm.music.data.Part> alParts

      ArrayList mit Begleitungen

    - #### volumes

          private int[] volumes

      Volume of each Part

    - #### fitness

          private double fitness

      >= dieser Grenze werden die Takte behalten

    - #### beatTransitions

          private int[][] beatTransitions

      Array fuer die Taktuebergaenge (Zeilen-/Spaltenreihenfolge 0-11 : C, C#, D, E, Eb, F, F#, G, Ab, A, Bb, B)

    - #### Crossover

          private boolean Crossover

      gibt an, welche Arten der Taktveraenderung verwendet werden sollen

    - #### NPointCrossover

          private boolean NPointCrossover

      gibt an, welche Arten der Taktveraenderung verwendet werden sollen

    - #### Mutation

          private boolean Mutation

      gibt an, welche Arten der Taktveraenderung verwendet werden sollen

  - ### Constructor Detail

    - #### PolyphonGeneticComposer

          public PolyphonGeneticComposer(int category,
                                 int tempo,
                                 int tracklength,
                                 int[] instruments,
                                 int[] volumes,
                                 int startPopulation,
                                 double fitness,
                                 java.lang.String key,
                                 java.lang.String user,
                                 java.lang.String pw,
                                 java.lang.String url,
                                 ComposingStatusDialog csd,
                                 boolean Crossover,
                                 boolean NPointCrossover,
                                 boolean Mutation)

      Konstruktor des polyphonen genetischen Composers
      Parameters:
        `category` - ID der Kategorie (Genre)
        `tempo` - BPM - Tempo des Tracks
        `tracklength` - Laenge des Tracks in Sekunden
        `instruments` - zu verwendende Instrumente
        `volumes` - Lautstaerken der einzelnen Parts
        `startPopulation` - Groesse der Grundpopulation fuer den Algorithmus (Anzahl der verschiedenen zufaellig ausgewaehlten Takte)
        `fitness` - >= diesem Wert werden bewertete Takte behalten
        `user` - DB-User
        `pw` - DB-Passwort
        `url` - DB-Url
        `csd` - Statusdialog (kann auch null sein, wenn keiner angezeigt werden soll)
        `Crossover` - true, wenn OnePointCrossover verwendet werden soll
        `NPointCrossover` - true, wenn NPointCrossover verwendet werden soll
        `Mutation` - true, wenn Mutation verwendet werden soll

  - ### Method Detail

    - #### printMinMaxPitchOfEachBeat

          private void printMinMaxPitchOfEachBeat(MIDIPartData mpd)

      fuer Debuggingzwecke gibt die hoechste und die tiefste Note aus
      Parameters:
        `mpd` - alle Takte

    - #### printIdentityHashCode

          private void printIdentityHashCode(MIDIPartData mpd)

      fuer Debuggingzwecke gibt den Speicherbereich jeder Note aus
      Parameters:
        `mpd` - alle Takte

    - #### printNoteDataArray

          private void printNoteDataArray(NoteData[][] nd)

      fuer Debuggingzwecke gibt einen Takt als String aus
      Parameters:
        `nd` - NoteDataArray

    - #### transposeMotifsToBaseTonality

          private MIDIPartData transposeMotifsToBaseTonality(MIDIPartData mpd)

      transponiert alle Takte auf die Grundtonart (Tonart ohne Vorzeichen) bei Dur in C-Dur und bei Moll in A-Moll
      Parameters:
        `mpd` - alle Takte
      Returns:
        transponierte Takte

    - #### setMotifsToSameOctave

          private MIDIPartData setMotifsToSameOctave(MIDIPartData mpd)

      transponiert alle Takte auf die gleiche Oktave
      Parameters:
        `mpd` - alle Takte
      Returns:
        transponierte Takte

    - #### generateBeats

          private MIDIPartData generateBeats(MIDIPartData mpd)

      generiert neue Takte mit Hilfe eines genetischen Algorithmus erzeugt so lange Takte, bis die benoetigte Anzahl an Takten (beatcount) erreicht wurde danach werden alle Takte nach verschiedenen Fitnessfunctions bewertet und fuer ungenuegend befundene Takte werden verworfen, alle positiven Takte werden zu den bereits vorhandenen Takten hinzugefuegt. neue Takte entstehen mit Hilfe von - OnePointCrossover - NPointCrossover - Mutation
      Parameters:
        `mpd` - alle Takte
      Returns:
        Grundmotive und generierte bewertete Takte

    - #### transposeMotifsToChosenTonality

          private MIDIPartData transposeMotifsToChosenTonality(MIDIPartData mpd)

      transponiert alle Takte auf die gewuenschte Tonart
      Parameters:
        `mpd` - alle Takte
      Returns:
        transponierte Takte

    - #### checkBeats

          private MIDIPartData checkBeats(MIDIPartData mpd)

      prueft, ob alle Pitches noch gueltige Werte besitzen und ob Platz fuer die Begleitspuren bleibt
      Parameters:
        `mpd` - alle Takte
      Returns:
        korrigierte Takte

    - #### connectBeats

          private MIDIPartData connectBeats(MIDIPartData mpd)

      verbindet die Takte mit Hilfe der Taktuebergangstabelle
      Parameters:
        `mpd` - alle Takte
      Returns:
        Takte in korrekter Reihenfolge

    - #### generateCounterParts

          private void generateCounterParts(MIDIPartData mpd,
                                  int chosenInstrument)

      generiert Begleittakte, passen zu den Takten der Grundmelodie
      Parameters:
        `mpd` - alle Takte
        `chosenInstrument` - Instrument, welches die Grundmelodie spielt

    - #### createCounterParts

          private jm.music.data.Part createCounterParts(MIDIPartData almb,
                                              int instrument,
                                              int channel)

      erzeugt eine Begleitspur passend zu den uebergebenen Takten nach Vorgaben gespeichert in mmi (MIDIMelodicInstrument)
      Parameters:
        `almb` - Takte, welche die Grundmelodie darstellen
        `instrument` - Instrument, mit welchem der neue Part gespielt werden soll
        `channel` - der Channel des aktuellen Parts
      Returns:
        begleitender Part

    - #### createPercussions

          private jm.music.data.Part createPercussions(MIDIPartData mpd)

      erstellt Percussions als Begleitung
      Parameters:
        `mpd` - Takte, zu denen die Percussions erzeugt werden
      Returns:
        Part mit Percussions

    - #### createPercussivs

          private jm.music.data.Part createPercussivs(MIDIPartData mpd,
                                            int instrument,
                                            int channel)

      erstellt Percussions als Begleitung
      Parameters:
        `mpd` - Takte, zu denen die Percussions erzeugt werden
        `instrument` - Instrument, das den Part spielt
        `channel` - der Channel des Parts
      Returns:
        Part mit Percussions

    - #### getFollower

          private MultiBeat getFollower(MultiBeat mb,
                              MIDIPartData mpd)

      liefert einen Takt, der auf Grund der Taktuebergangstabelle ein moeglicher Nachfolger des uebergebenen Takts ist
      Parameters:
        `mb` - Takt, fuer den ein Nachfolger gesucht wird
        `mpd` - alle generierten Takte
      Returns:
        nachfolgender Takt

    - #### chooseFollower

          private MultiBeat chooseFollower(java.lang.String note,
                                 MIDIPartData mpd)

      waehlt einen Nachfolgertakt fuer mb aus den Takten in mpd, anhand der Taktuebergangstabelle aus
      Parameters:
        `note` - Note, fuer die ein Nachfolger gesucht wird
        `mpd` - alle generierten Takte
      Returns:
        nachfolgender Takt

    - #### getIDForNote

          private int getIDForNote(java.lang.String s)

      liefert zur uebergebenen Note die ID i Taktuebergangsarray
      Parameters:
        `s` - Note (zB.: C, C#, D, Eb, ...)
      Returns:
        ID im Array

    - #### getAveragePitch

          private int getAveragePitch(MultiBeat mb)

      liefert den Durchschnittspitch des Takts
      Parameters:
        `mb` - der zu analysierende Takt
      Returns:
        Durchschnittspitch

    - #### getMultiBeatInCorrectOctave

          private MultiBeat getMultiBeatInCorrectOctave(MultiBeat mb,
                                              int Avg)

      liefert einen MultiBeat auf die Oktave transponiert, welche dem Durchschnittspitch (Avg) entspricht
      Parameters:
        `mb` - der zu transponierende MultiBeat
        `Avg` - der Referenzdurchschnittspitch
      Returns:
        transponierter MultiBeat

    - #### initialiseInstruments

          private void initialiseInstruments()

      initialisiert die Instrumentengruppen, ob sie Melodie, Akkorde oder zufaellige Toene spielen sollen/duerfen

    - #### getPolyphoneScore

          private jm.music.data.Score getPolyphoneScore(MIDIPartData mpd)

      liefert einen polyphonen Score bestehend aus den Phrasen und Noten der uebergebenen Takte
      Parameters:
        `mpd` - Instrument und Motife
      Returns:
        MIDI-Score

    - #### getComposition

          public jm.music.data.Score getComposition()

      liefert die neue Komposition
      Returns:
        die Komposition

    - #### createPolyphoneMelodyPart

          private jm.music.data.Part createPolyphoneMelodyPart(java.util.ArrayList<MultiBeat> almb,
                                                     int instrument,
                                                     int part,
                                                     boolean transpose)

      liefert einen polyphonen Part bestehend aus den Noten des uebergebenen Takts
      Parameters:
        `almb` - ArrayList mit polyphonen Takten
        `instrument` - das zu verwendende Instrument
        `part` - Nummer des Parts (ist auch Channelnummer)
        `transpose` - true, wenn Pitches um 1 Oktave nach unten transponiert werden sollen
      Returns:
        MIDI-Part

    - #### createHarmonyPart

          private jm.music.data.Part createHarmonyPart(java.util.ArrayList<MultiBeat> almb,
                                             int instrument,
                                             int part)

      liefert einen Begleitpart bestehend aus Begleitakkorden
      Parameters:
        `almb` - ArrayList mit polyphonen Takten
        `instrument` - das zu verwendende Instrument
        `part` - Nummer des Parts (ist auch Channelnummer)
      Returns:
        MIDI-Part

    - #### getEmptyBeat

          private jm.music.data.Note getEmptyBeat()

    - #### getNoteForInt

          private java.lang.String getNoteForInt(int pitch)

      liefert zu einem Pitch die Note als String
      Parameters:
        `pitch` - Pitch als Integer
      Returns:
        die Note als String

    - #### getLowestFirstPitch

          private int getLowestFirstPitch(MultiBeat mb)

      liefert den tiefsten Pitch der ersten (auftretenden) Note
      Parameters:
        `mb` - MultiBeat
      Returns:
        niedrigster Pitch der ersten Note

    - #### createRandomNoisePart

          private jm.music.data.Part createRandomNoisePart(java.util.ArrayList<MultiBeat> almb,
                                                 int instrument,
                                                 int part)

      liefert einen Begleitpart bestehend aus zufaelligen Geraeuschen
      Parameters:
        `almb` - ArrayList mit polyphonen Takten
        `instrument` - das zu verwendende Instrument
        `part` - Nummer des Parts (ist auch Channelnummer)
      Returns:
        MIDI-Part

    - #### getMaxPhraseCount

          private int getMaxPhraseCount(java.util.ArrayList<MultiBeat> almb)

      liefert die Anzahl der maximalen Phrasen aller Takte
      Parameters:
        `almb` - ArrayList mit polyphonen Takten
      Returns:
        maximale Anzahl der Phrasen

    - #### chooseInstrumentForMelody

          private int chooseInstrumentForMelody()

      waehlt aus den zu verwendenden Instrumenten ein passendes fuer die Melodie aus gibt es kein passendes, wird das erste Instrument zugewiesen
      Returns:
        Instrument, welches die Hauptmelodie spielen soll

    - #### InstrumentPlaysMelody

          private boolean InstrumentPlaysMelody(int instrument)

      gibt an, ob das uebergebene Instrument eine Melodie spielen kann/soll
      Parameters:
        `instrument` - ID des Instruments
      Returns:
        true, wenn Instrument Melodie spielen kann

    - #### getNumerator

          private int getNumerator()

      liefert den zufaellig ausgewaehlten Numerator einer Kategorie
      Returns:
        Numerator

    - #### getStartMotifs

          private MIDIPartData getStartMotifs(int chosenInstrument)

      sucht nach einem Startmotif fuer ein Instrument aus der Kategorie, welches eine Melodie spielt
      Parameters:
        `chosenInstrument` - Instrument, welches die Hauptmelodie spielen soll
      Returns:
        Instrument (Part) und dessen Takte

    - #### fillUpMotifs

          private MIDIPartData fillUpMotifs(MIDIPartData mpd)

      ueberprueft, ob alle Takte genau der Taktlaenge entsprechen und fuellt sie gegebenenefalls mit Pausen auf
      Parameters:
        `mpd` - die Takte
      Returns:
        korregierte Takte

    - #### correctMultiBeat

          private MultiBeat correctMultiBeat(MultiBeat mb)

      ergaenzt den Takt mit Pausen, um die korrekte Taktlaenge zu erreichen
      Parameters:
        `mb` - der zu korrigierende Takt
      Returns:
        der korrigierte Takt

    - #### getInstrumentGroupBorder

          private int[] getInstrumentGroupBorder(int instrument)

      liefert die untere und obere Grenze der Instrumentengruppe des uebergebenen Instruments
      Parameters:
        `instrument` - Instrumenten-ID (MIDI-Standard)
      Returns:
        Array mit unterer und oberer Grenze (ID 0: unten, ID 1: oben)

    - #### gradeBeats

          private MIDIPartData gradeBeats(MIDIPartData mpd)

      bewertet die Takte, entfernt unpassende/falsche Takte
      Parameters:
        `mpd` - die bisherigen Takte
      Returns:
        passende Takte

    - #### createNewBeats

          private MIDIPartData createNewBeats(MIDIPartData mpd)

      waehlt zufaellig eine Art aus, wie neue Takte entstehen sollen
      Parameters:
        `mpd` - die bisherigen Takte
      Returns:
        alte und neue Takte

    - #### Crossover

          private MultiBeat[] Crossover(MultiBeat mb,
                              MultiBeat mb2,
                              boolean NPoint)

      one-point crossover zweier Takte zwei Genome werden jeweils an einer Stelle gebrochen und die entstehenden Teilstücke ausgetauscht (AA, BB => AB, BA) es koennen nur Takte, bei denen beide eine gerade bzw. ungerade Notenanzahl haben, gekreuzt werden
      Parameters:
        `mb` - erster urspruenglicher Takt
        `mb2` - zweiter urspruenglicher Takt
        `NPoint` - true wenn NPointCrossover, false wenn OnePointCrossover
      Returns:
        neue Takte

    - #### CrossoverNPoint

          private MultiBeat[] CrossoverNPoint(MultiBeat mb,
                                    MultiBeat mb2)

      n-point crossover zweier Takte zwei Genome werden jeweils an mehreren Stelle gebrochen und die entstehenden Teilstücke ausgetauscht (AAAA, BBBB => AB, BA, ABAB, BABA, ABBB, BAAA, AABA, ...) es koennen nur Takte, bei denen beide eine gerade bzw. ungerade Notenanzahl haben, gekreuzt werden
      Parameters:
        `mb` - erster urspruenglicher Takt
        `mb2` - zweiter urspruenglicher Takt
      Returns:
        neue Takte

    - #### Mutation

          private MultiBeat Mutation(MultiBeat mb)

      Mutation eines Takts - transponieren (um -6 bis 6) - vertauschen der Pitches - nach Pitches aufsteigend sortieren - nach Pitches absteigend sortieren - umdrehen (Reversion/Krebs) - Intervallrichtungsaenderung (Inversion/Spiegel)
      Parameters:
        `mb` - urspruenglicher Takt
      Returns:
        neue Takt

    - #### transposeBeat

          private MultiBeat transposeBeat(MultiBeat mb)

      transponiert den Takt zufaellig um -6 bis +6 Halbtonschritte
      Parameters:
        `mb` - ein Takt
      Returns:
        transponierter Takt

    - #### shuffleBeat

          private MultiBeat shuffleBeat(MultiBeat mb)

      vertauscht zufaellig die Reihenfolge der Noten im Takt
      Parameters:
        `mb` - ein Takt
      Returns:
        Takt mit durchgemischten Noten

    - #### sortBeatAscOrDesc

          private MultiBeat sortBeatAscOrDesc(MultiBeat mb,
                                    boolean Asc)

      sortiert die Noten aufsteigend bzw. absteigend
      Parameters:
        `mb` - ein Takt
        `Asc` - true wenn aufsteigend, false wenn absteigend
      Returns:
        Takt aufsteigend bzw. absteigend sortiert

    - #### revertBeat

          private MultiBeat revertBeat(MultiBeat mb)

      dreht den Takt um (Krebs)
      Parameters:
        `mb` - ein Takt
      Returns:
        umgedrehter Takt

    - #### invertBeat

          private MultiBeat invertBeat(MultiBeat mb)

      invertiert den Tankt (Spiegel)
      Parameters:
        `mb` - ein Takt
      Returns:
        invertierter Takt

    - #### getBeatCountForTrack

          private int getBeatCountForTrack()

      liefert die Anzahl der Takte, die der MIDI-Track benoetigt, um die gewuenschte Laenge zu erreichen
      Returns:
        Anzahl der Takte

    - #### TransposeBeat

          private MultiBeat TransposeBeat(MultiBeat mb,
                                java.lang.String oldKey,
                                java.lang.String newKey,
                                int Steps)

      transponiert den polyphonen Takt in eine andere Tonart
      Parameters:
        `mb` - polyphoner Takt
        `oldKey` - bisherige Tonart (nur Grundton, zB. bei C-Dur nur "C")
        `newKey` - neue Tonart (nur Grundton, zB. bei G-Dur nur "G")
        `Steps` - Anzahl der Halbtonschritte der Aenderung, wenn Steps = 200 => berechne die Halbtonschritte intern
      Returns:
        der transponierte MultiBeat

    - #### getHalftoneSteps

          private int getHalftoneSteps(java.lang.String From,
                             java.lang.String To)

      gibt die Anzahl der Halbtoene zurueck um von der Ursprungstonart in die Zieltonart zu gelangen der geringere Unterschied wird verwendet (man kann auf beide Seiten transponieren, nur die Oktave aendert sich)
      Parameters:
        `From` - Ursprungstonart
        `To` - Zieltonart
      Returns:
        Verschiebung in Halbtoenen

    - #### FormatKeys

          private java.lang.String FormatKeys(java.lang.String s)

      replace key by MIDI-key-name
      Parameters:
        `s` - key to check
      Returns:
        the correspondent key or the key passed through