From 3041fc4f70885c9b07ca82f52484ed6f0784b129 Mon Sep 17 00:00:00 2001 From: Gideon Regehr <2023558@stud.hs-mannheim.de> Date: Sun, 23 Apr 2023 14:45:40 +0200 Subject: [PATCH] =?UTF-8?q?Dateien=20hochladen=20nach=20=E2=80=9E=E2=80=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit C++ macht super viel Spaß. (Ist noch nicht vollständig Funktionsfähig) --- BSI_Tests.cxx | 505 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 505 insertions(+) create mode 100644 BSI_Tests.cxx diff --git a/BSI_Tests.cxx b/BSI_Tests.cxx new file mode 100644 index 0000000..bc5a932 --- /dev/null +++ b/BSI_Tests.cxx @@ -0,0 +1,505 @@ +#include +#include +#include +#include +using namespace std; + + +const int ARRAY_SIZE = 20000; +const int ARRAY_SIZE2 = 256 * 65536; +int bitzahl = 0; +char BitFeldA[ARRAY_SIZE2]; +const int bitbreite = 256; + +class BSI_Tests{ +public: + char BitFeldB[ARRAY_SIZE]; + + int letzterwert = 0; + int letzteselement = -1; + +public: + void readBinaryFile(string fileName, int bufferSize) { + ifstream input(fileName, ios::binary); + if (input) { + input.read(BitFeldA, bufferSize); + input.close(); + } + } + //In Bearbeitung + void neuesfeldb(char* BitFeldA, char* BitFeldB, int durchlauf) { + int grundelement = 0; + + if (durchlauf % (bitbreite + 1) == 0) { + std::cout << ("Teste im Block.", false, 1); + for (int i = 0; i < 20000; i++) { + BitFeldB[i] = BitFeldA[i + letzteselement + 1]; + } + letzteselement += teilenaufrunden(20000, bitbreite) * bitbreite; + } + else { + grundelement = (durchlauf % (bitbreite + 1)) + letzteselement; + for (int i = 0; i < 20000; i++) { + BitFeldB[i] = BitFeldA[grundelement + (i * bitbreite)]; + } + if (durchlauf % (bitbreite + 1) == bitbreite) { + letzteselement += 20000 * bitbreite; + } + + } + } + int teilenaufrunden(int a, int b) { + if ((a % b) == 0) { + return (int)(a / b); + } + else { + return (((int)(a / b)) + 1); + } + } + +public: + bool test0(int c, int bitbreite) { + int i, j; + bool ok; + long u0 = (long)0; + long u1 = (long)1; + long WFeld[65536]; + for (i = 0; i < 65536; i++) { + WFeld[i] = u0; + for (j = 0; j < 48; j++) { + WFeld[i] += (u1 << j) * BitFeldA[(c * bitbreite) * i + j]; + } + } + std::sort(WFeld, WFeld + 65536); + ok = true; + for (i = 1; i < 65536; i++) { + if (WFeld[i - 1] == WFeld[i]) { + ok = false; + } + } + return ok; + } + +public: + bool test1() { + int i, einsen, mg = ARRAY_SIZE; + bool ok; + einsen = 0; + for (i = 0; i < mg; i++) { + einsen += BitFeldB[i]; + } + if ((einsen > 9654) && (einsen < 10346)) { + ok = true; + } else { + ok = false; + } + std::cout << "Anzahl Einsen: " << einsen << std::endl; + std::cout << "Zulässiger Bereich: [9655; 10345]" << std::endl; + return ok; + } +public: + bool test2() { + int i, j, index; + int Hfg[16]; + bool ok; + double testgroesse; + + for (i = 0; i < 16; i++) { + Hfg[i] = 0; + } + + for (i = 0; i < 5000; i++) { + index = 0; + for (j = 0; j < 4; j++) { + index += (1 << j) * BitFeldB[4 * i + j]; + } + Hfg[index]++; + } + + testgroesse = 0.0; + + for (i = 0; i < 16; i++) { + testgroesse += Hfg[i] * Hfg[i]; + } + + testgroesse = testgroesse * (16.0 / 5000.0) - 5000.0; + + if ((testgroesse > 1.03) && (testgroesse < 57.4)) { + ok = true; + } else { + ok = false; + } + + return ok; +} + + +bool test3() { + int i, run; + int Run0Feld[7]; + int Run1Feld[7]; + bool ok; + int UGrenze[] = {0, 2267, 1079, 502, 223, 90, 90}; + int OGrenze[] = {0, 2733, 1421, 748, 402, 223, 223}; + + for (i = 0; i < 7; i++) { + Run0Feld[i] = Run1Feld[i] = 0; + } + + run = 1; + + for (i = 1; i < 20000; i++) { + if (BitFeldB[i - 1] == BitFeldB[i]) { + run++; + } else { + if (run > 6) { + run = 6; + } + + if (BitFeldB[i - 1] == 1) { + Run1Feld[run]++; + } else { + Run0Feld[run]++; + } + + run = 1; + } + } + + if (run > 6) { + run = 6; + } + + if (BitFeldB[i - 1] == 1) { + Run1Feld[run]++; + } else { + Run0Feld[run]++; + } + + ok = true; + + for (i = 1; i <= 6; i++) { + if ((Run0Feld[i] >= UGrenze[i]) && (Run0Feld[i] <= OGrenze[i])) { + cout << "0-Runs[" << i << "] = " << Run0Feld[i] << "; zulässiges Intervall: [" << UGrenze[i] << "; " << OGrenze[i] << "]" << endl; + } else { + ok = false; + cout << "FEHLER: 0-Runs[" << i << "] = " << Run0Feld[i] << "; zulässiges Intervall: [" << UGrenze[i] << "; " << OGrenze[i] << "]" << endl; + } + + if ((Run1Feld[i] >= UGrenze[i]) && (Run1Feld[i] <= OGrenze[i])) { + cout << "1-Runs[" << i << "] = " << Run1Feld[i] << "; zulässiges Intervall: [" << UGrenze[i] << "; " << OGrenze[i] << "]" << endl; + } else { + ok = false; + cout << "FEHLER: 1-Runs[" << i << "] = " << Run1Feld[i] << "; zulässiges Intervall: [" << UGrenze[i] << "; " << OGrenze[i] << "]" << endl; + } + } + + return ok; +} + +bool test4() { + int i, run; + bool ok; + + run = 1; + ok = true; + + for (i = 1; i < 20000; i++) { + if (BitFeldB[i - 1] == BitFeldB[i]) { + run++; + if (run >= 34) { + ok = false; + cout << "Long Run aufgetreten (Wert: " << BitFeldB[i] << "). Erste Bitposition: " << (i - 33) << "." << endl; + } + } + else { + run = 1; + } + } + return ok; +} + + +bool test5() { + int i, j, k, tau, Z_tau, max; + bool ok; + int ShiftFeld[5000]; + int MaxKorrFeld[5000]; + + for (tau = 1; tau <= 5000; tau++) { + Z_tau = 0; + for (i = 0; i < 5000; i++) { + Z_tau += (BitFeldB[i] ^ BitFeldB[i + tau]); + } + ShiftFeld[tau - 1] = Z_tau; + } + + max = 0; + + for (tau = 0; tau < 5000; tau++) { + if (abs(ShiftFeld[tau] - 2500) > max) { + max = abs(ShiftFeld[tau] - 2500); + } + } + + j = 0; + for (tau = 0; tau < 5000; tau++) { + if (abs(ShiftFeld[tau] - 2500) == max) { + MaxKorrFeld[j] = tau; + j++; + } + } + + cout << "Maximale Z_tau-Abweichung von 2500: " << max << endl; + cout << "Aufgetreten für Shifts: " << endl; + for (k = 0; k < j; k++) { + cout << "Shift: " << (MaxKorrFeld[k] + 1) << endl; + } + tau = MaxKorrFeld[0]; + Z_tau = 0; + for (i = 10000; i < 15000; i++) { + Z_tau += (BitFeldB[i] ^ BitFeldB[i + tau + 1]); + } + tau++; + cout << "Nochmaliger Autokorrelationstest mit Shift: " << tau << " auf Bits 10.000 bis 14.999" << endl; + cout << "Z_" << tau << " = " << Z_tau << endl; + if ((Z_tau > 2326) && (Z_tau < 2674)) + ok = true; + else + ok = false; + return ok; +} + +bool test6a() { + bool ok; + double* prob = new double[1]; + double absdiff = 0.0; + int groesse = 100000; + int einsen = 0; + for (int i = 0; i < groesse; i++) einsen += BitFeldA[i]; + prob[0] = (double)einsen / (double)groesse; + absdiff = fabs(prob[0] - 0.5); + if (absdiff < 0.025) { + ok = true; + } + else { + ok = false; + } + letzterwert = groesse; + cout << ("|P(1) - 0.5| = " + std::to_string(absdiff), false, 2); + cout << ("Letztes Element: " + std::to_string(letzterwert), false, 2); + delete[] prob; + return ok; +} + +bool test6b() { + int groesse = 100000; + int counter[2] = { 0, 0 }; + int einsen[2] = { 0, 0 }; + int voll[2] = { 0, 0 }; + int i = 0; + double prob[2]; + double absdiff = 0.0; + while ((voll[0] + voll[1] < 2) && ((letzterwert + 2 * i + 1) < bitzahl)) { + if (voll[BitFeldA[letzterwert + 2 * i]] == 1); + else { + counter[BitFeldA[letzterwert + 2 * i]] += 1; + if (counter[BitFeldA[letzterwert + 2 * i]] == groesse) voll[BitFeldA[letzterwert + 2 * i]] = 1; + einsen[BitFeldA[letzterwert + 2 * i]] += BitFeldA[letzterwert + 2 * i + 1]; + } + i++; + } + letzterwert += 2 * i; + if (voll[0] + voll[1] < 2) { + cout << ("Inputdatei zu klein....Kriterium P2.i)(vii.b) konnte nicht geprueft werden.", true, 2); + return false; + } + else { + for (i = 0; i < 2; i++) prob[i] = (double)einsen[i] / groesse; + absdiff = abs(prob[0] - prob[1]); + cout << ("p(01) = " + to_string(prob[0]), false, 2); + cout << ("p(11) = " + to_string(prob[1]), false, 2); + cout << ("|p_(01) - p_(11)| = " + to_string(absdiff), false, 2); + cout << ("Letztes Element: " + to_string(letzterwert), false, 2); + if (absdiff < 0.02) return true; + else return false; + } +} + +bool test7a() { + int groesse = 100000; + int hilf; + int voll[4] = { 0, 0, 0, 0 }; + int counter[4] = { 0, 0, 0, 0 }; + int einsen[4] = { 0, 0, 0, 0 }; + int nullen[4] = { 0, 0, 0, 0 }; + double sum = 0; + int i = 0; + while ((voll[0] + voll[1] + voll[2] + voll[3] < 4) && ((letzterwert + 3 * i) < bitzahl)) { + hilf = 2 * BitFeldA[letzterwert + 3 * i + 1] + BitFeldA[letzterwert + 3 * i]; + if (voll[hilf] == 1); + else { + counter[hilf] += 1; + if (counter[hilf] == groesse) voll[hilf] = 1; + einsen[hilf] += BitFeldA[letzterwert + 3 * i + 2]; + } + i++; + } + letzterwert += 3 * i; + if (voll[0] + voll[1] + voll[2] + voll[3] < 4) { + cout << ("Inputdatei zu klein....Kriterium P2.i)(vii.c) konnte nicht geprueft werden", true, 2); + return false; + } + else { + for (i = 0; i < 4; i++) nullen[i] = groesse - einsen[i]; + bool ok = true; + for (i = 0; i < 2; i++) { + sum = ((double)((nullen[2 * i] - nullen[2 * i + 1]) * (nullen[2 * i] - nullen[2 * i + 1])) / (nullen[2 * i] + nullen[2 * i + 1]) + + (double)((einsen[2 * i] - einsen[2 * i + 1]) * (einsen[2 * i] - einsen[2 * i + 1])) / (einsen[2 * i] + einsen[2 * i + 1])); + if (sum > 15.13) ok = false; + cout << ("Testgröße[" + to_string(i) + "] = " + to_string(sum), false, 2); + } + cout << ("Letztes Element: " + to_string(letzterwert), false, 2); + return ok; + } +} + +bool test7b() { + bool ok; + int hilf; + int voll[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + int counter[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + int einsen[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + int nullen[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + double sum = 0; + int groesse = 100000; + int i = 0; + while ((voll[0] + voll[1] + voll[2] + voll[3] + voll[4] + voll[5] + voll[6] + voll[7] < 8) && ((letzterwert + 4 * i) < bitzahl)) { + hilf = 4 * BitFeldA[letzterwert + 4 * i + 2] + 2 * BitFeldA[letzterwert + 4 * i + 1] + BitFeldA[letzterwert + 4 * i]; + if (voll[hilf] == 1); + else { + counter[hilf] += 1; + if (counter[hilf] == groesse) voll[hilf] = 1; + einsen[hilf] += BitFeldA[letzterwert + 4 * i + 3]; + } + i++; + } + letzterwert += 4 * i; + if (voll[0] + voll[1] + voll[2] + voll[3] + voll[4] + voll[5] + voll[6] + voll[7] < 8) { + cout << ("Inputdatei zu klein....Kriterium P2.i)(vii.d) konnte nicht geprueft werden", true, 2); + ok = false; + } + else { + for (i = 0; i < 8; i++) nullen[i] = groesse - einsen[i]; + ok = true; + for (i = 0; i < 4; i++) { + sum = (double)((nullen[2 * i] - nullen[2 * i + 1]) * (nullen[2 * i] - nullen[2 * i + 1])) / (nullen[2 * i] + nullen[2 * i + 1]) + + (double)((einsen[2 * i] - einsen[2 * i + 1]) * (einsen[2 * i] - einsen[2 * i + 1])) / (einsen[2 * i] + einsen[2 * i + 1]); + if (sum > 15.13) ok = false; + cout << ("Testgröße[" + to_string(i) + "] = " + to_string(sum), false, 2); + } + } + cout << ("Letztes Element: " + to_string(letzterwert), false, 2); + return ok; +} + +bool test8() { + const int L = 8; + const int Q = 2560; + const int K = 256000; + int hilf = 0; + int counter = 0; + int letzteposition[256]; + for (int i = 0; i < 256; i++) { + letzteposition[i] = -1; + } + int W[Q + K]; + double TG; + double G[K + Q + 1]; + int abstand; + + G[1] = 0.0; + for (int i = 1; i <= K + Q - 1; i++) G[i + 1] = G[i] + 1.0 / (i); + for (int i = 1; i <= K + Q; i++) G[i] /= log(2.0); + for (int i = 0; i < Q; i++) { + hilf = 0; + for (int j = 0; j < 8; j++) { + hilf += BitFeldA[letzterwert + 8 * i + j] << j; + } + letzteposition[hilf] = i; + } + TG = 0.0; + for (int i = Q; i < K + Q; i++) { + hilf = 0; + for (int j = 0; j < 8; j++) { + hilf += BitFeldA[letzterwert + 8 * i + j] << j; + } + abstand = i - letzteposition[hilf]; + letzteposition[hilf] = i; + TG += G[abstand]; + } + TG /= (double)K; + cout << ("Testgröße = " + 1, false, 2); + cout << TG; + letzterwert += 8 * (2560 + 256000); + cout << ("Letztes Element: " + letzterwert, false, 2); + if (TG > 7.976) return true; + else return false; +} + +public: + void T1() { + bool result; + bitzahl = teilenaufrunden(257, (bitbreite + 1)) * ((teilenaufrunden(20000, bitbreite)) * bitbreite + (bitbreite * 20000)); + + for (int durchlauf = 0; durchlauf < 257; durchlauf++) { + neuesfeldb(BitFeldA, BitFeldB, durchlauf); + + result = test1(); + std::cout << "Test1 result: " << result << std::endl; + result = test2(); + std::cout << "Test2 result: " << result << std::endl; + result = test3(); + std::cout << "Test3 result: " << result << std::endl; + result = test4(); + std::cout << "Test4 result: " << result << std::endl; + result = test5(); + std::cout << "Test5 result: " << result << std::endl; + } + } +public: + void T0() { + bitzahl = bitbreite * teilenaufrunden(48, bitbreite) * 65536; + bool result = test0(teilenaufrunden(48, bitbreite), bitbreite); + std::cout << "Test0 result: " << result << std::endl; + } +public: + void T2() { + bool result; + + bitzahl = 7200000; + result = test6a(); + std::cout << "Test6a result: " << result << std::endl; + result = test6b(); + std::cout << "Test6b result: " << result << std::endl; + result = test7a(); + std::cout << "Test7a result: " << result << std::endl; + result = test7b(); + std::cout << "Test7b result: " << result << std::endl; + result = test8(); + std::cout << "Test8 result: " << result << std::endl; + + } +}; + +int main() { + + BSI_Tests t1; + + t1.readBinaryFile("TRN_testsBestanden.txt", ARRAY_SIZE2); + + //t1.T0(); + t1.T1(); + //t1.T2(); + return 0; +}