/// <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])); } }