/// <summary>
/// Angelehnt an die SequenzUpDown werden hier die Wechsel der Größen geprüft und dann im Anschluss durch die Anzahl der möglichen Wechsel dividiert.
/// Soll Aufschluss über die mittleren Wechsel geben. Wenn die Werte um die 0,5 oder höher liegen, liegt eine gute Güte vor! Ansonsten eine schlechte, da die Folgen sehr lang sind.
/// </summary>
/// <param name="k">Sequenzlänge</param>
/// <returns>Den Mittelwert aller Kettenwechsel.</returns>
public double Berechne(int k, int anz)
{
double[] zahlen = new double[anz]; //Zufallszahlen erstellen
for (int i = 0; i < anz; i++)
{
zahlen[i] = Bibliothek.GeneriereZufallszahl();
}
int[] bitmaske = new int[zahlen.Length - 1]; //Bitmaske erstellen
for (int i = 0; i < zahlen.Length - 1; i++)
{
if (zahlen[i] < zahlen[i + 1])
{
bitmaske[i] = 1;
}
else
{
bitmaske[i] = 0;
}
}
long summe = 0;
for (int i = 0; i < bitmaske.Length - 1; i++) //Bildet Summe der Wechsel
{
if (bitmaske[i] != bitmaske[i + 1])
{
summe++;
}
}
return((double)summe / bitmaske.Length); //Mittelwert der Wechsel
}
/// <summary>
/// Errechnet den Korrelationswert für das Zufallsgenerierte Array
/// </summary>
/// <param name="k">Abstand der verglichenen Zufallszahlen</param>
/// <returns>Korrelationswert des Zufallszahlengenerators</returns>
public double Berechne(int k, int anz)
{
double[] zahlen = new double[anz];
for (int i = 0; i < anz; i++)
{
zahlen[i] = Bibliothek.GeneriereZufallszahl();
}
if (k == 0)//wenn kein spezifisches k gewählt wurde, wird ein zufälliger Abstand zweier Zahlen ausgerechnet
{
int punkt1 = (int)(Bibliothek.GeneriereGleichverteilteZufallszahl01() * anz);
int punkt2 = (int)(Bibliothek.GeneriereGleichverteilteZufallszahl01() * anz);
k = Math.Abs(punkt1 - punkt2);
}
double mittelwert = Bibliothek.Verteilung.Mittelwert; // Berechnet Mittelwert aus allen Zufallszahlen
double zaehler = 0;
double nenner = 0;
int j = 0;
while (j < zahlen.Length - k) // Führt die Serielle Autokorrelation durch
{
zaehler += (zahlen[j] - mittelwert) * (zahlen[j + k] - mittelwert);
nenner += Math.Pow(zahlen[j] - mittelwert, 2);
j++;
}
return((double)zaehler / nenner);
}
/// <summary>
/// Berechnet die Anzahl der Bitfolgen mit der Länge K.
/// </summary>
/// <param name="k">Wenn 0 dann werden alle möglichen k überprüft, ansonsten nur das angegebene k.</param>
/// <param name="anz">Bestimmt die Sequenzlänge des Tests. Also die Anzahl der untersuchten Zufallszahlen</param>
/// <returns></returns>
public double Berechne(int k, int anz)
{
double[] zahlen = new double[anz];
for (int i = 0; i < anz; i++) //Erstelle Zahlenarray
{
zahlen[i] = Bibliothek.GeneriereZufallszahl();
}
int[] bitmaske = new int[zahlen.Length - 1];
for (int i = 0; i < zahlen.Length - 1; i++) //Erstelle Bitmaske
{
if (zahlen[i] < zahlen[i + 1])
{
bitmaske[i] = 1;
}
else
{
bitmaske[i] = 0;
}
}
Dictionary <int, int> kettenlaengen = new Dictionary <int, int>();
int kettenlaenge = 1; //Speichert die Anzahl der jetzigen Folge
int vorherigesBit = bitmaske[0];
for (int i = 1; i < bitmaske.Length; i++)
{
if (vorherigesBit == bitmaske[i])
{
kettenlaenge++;
}
else //Prüft, ob ein Wechsel stattfindet um den Counter zurückzusetzen und ggfls. eine gefundene Bitfolge mit k Elementen zu speichern
{
if (kettenlaengen.ContainsKey(kettenlaenge))
{
kettenlaengen[kettenlaenge]++;
}
else
{
kettenlaengen[kettenlaenge] = 1;
}
kettenlaenge = 1;
vorherigesBit = bitmaske[i];
}
}
if (k == 0)
{
double differenz = 0;
foreach (var eintrag in kettenlaengen)
{
differenz += Math.Abs(BerechneNopt(eintrag.Key, anz) - eintrag.Value); //Errechnet die Differenz der gefundenen Zahlenketten mit dem des optimalen Wertes
}
return(differenz);
}
else
{
return(Math.Abs(BerechneNopt(k, anz) - kettenlaengen[k]));
}
}
