506 lines
14 KiB
C++
506 lines
14 KiB
C++
#include <iostream>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
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("file.txt", ARRAY_SIZE2);
|
|
|
|
//t1.T0();
|
|
t1.T1();
|
|
//t1.T2();
|
|
return 0;
|
|
}
|