void
Serial(int m, int n)
{
double p_value1, p_value2, psim0, psim1, psim2, del1, del2;
psim0 = psi2(m, n);
psim1 = psi2(m-1, n);
psim2 = psi2(m-2, n);
del1 = psim0 - psim1;
del2 = psim0 - 2.0*psim1 + psim2;
p_value1 = cephes_igamc(pow(2, m-1)/2, del1/2.0);
p_value2 = cephes_igamc(pow(2, m-2)/2, del2/2.0);
fprintf(stats[TEST_SERIAL], "\t\t\t SERIAL TEST\n");
fprintf(stats[TEST_SERIAL], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_SERIAL], "\t\t COMPUTATIONAL INFORMATION: \n");
fprintf(stats[TEST_SERIAL], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_SERIAL], "\t\t(a) Block length (m) = %d\n", m);
fprintf(stats[TEST_SERIAL], "\t\t(b) Sequence length (n) = %d\n", n);
fprintf(stats[TEST_SERIAL], "\t\t(c) Psi_m = %f\n", psim0);
fprintf(stats[TEST_SERIAL], "\t\t(d) Psi_m-1 = %f\n", psim1);
fprintf(stats[TEST_SERIAL], "\t\t(e) Psi_m-2 = %f\n", psim2);
fprintf(stats[TEST_SERIAL], "\t\t(f) Del_1 = %f\n", del1);
fprintf(stats[TEST_SERIAL], "\t\t(g) Del_2 = %f\n", del2);
fprintf(stats[TEST_SERIAL], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_SERIAL], "%s\t\tp_value1 = %f\n", p_value1 < ALPHA ? "FAILURE" : "SUCCESS", p_value1);
fprintf(results[TEST_SERIAL], "%f\n", p_value1);
fprintf(stats[TEST_SERIAL], "%s\t\tp_value2 = %f\n\n", p_value2 < ALPHA ? "FAILURE" : "SUCCESS", p_value2);
fprintf(results[TEST_SERIAL], "%f\n", p_value2);
}
double Cephes::cephes_igam(double a, double x)
{
double ans, ax, c, r;
if ( (x <= 0) || ( a <= 0) )
return 0.0;
if ( (x > 1.0) && (x > a ) )
return 1.e0 - cephes_igamc(a,x);
/* Compute x**a * exp(-x) / gamma(a) */
ax = a * log(x) - x - cephes_lgam(a);
if ( ax < -MAXLOG ) {
printf("igam: UNDERFLOW\n");
return 0.0;
}
ax = exp(ax);
/* power series */
r = a;
c = 1.0;
ans = 1.0;
do {
r += 1.0;
c *= x/r;
ans += c;
} while ( c/ans > MACHEP );
return ans * ax/a;
}
int
computeMetrics(char *s, int test)
{
int j, pos, count, passCount, sampleSize, expCount, proportion_threshold_min, proportion_threshold_max;
int freqPerBin[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
double *A, *T, chi2, proportion, uniformity, p_hat, tmp;
float c;
FILE *fp;
if ( (fp = fopen(s, "r")) == NULL ) {
printf("%s",s);
printf(" -- file not found. Exiting program.\n");
exit(-1);
}
if ( (A = (double *)calloc(tp.numOfBitStreams, sizeof(double))) == NULL ) {
printf("Final Analysis Report aborted due to insufficient workspace\n");
return 0;
}
/* Compute Metric 1: Proportion of Passing Sequences */
count = 0;
sampleSize = tp.numOfBitStreams;
if ( (test == TEST_RND_EXCURSION) || (test == TEST_RND_EXCURSION_VAR) ) { /* Special Case: Random Excursion Tests */
if ( (T = (double *)calloc(tp.numOfBitStreams, sizeof(double))) == NULL ) {
printf("Final Analysis Report aborted due to insufficient workspace\n");
return 0;
}
for ( j=0; j<sampleSize; j++ ) {
fscanf(fp, "%f", &c);
if ( c > 0.000000 )
T[count++] = c;
}
if ( (A = (double *)calloc(count, sizeof(double))) == NULL ) {
printf("Final Analysis Report aborted due to insufficient workspace\n");
return 0;
}
for ( j=0; j<count; j++ )
A[j] = T[j];
sampleSize = count;
count = 0;
for ( j=0; j<sampleSize; j++ )
if ( A[j] < ALPHA )
count++;
free(T);
}
else {
if ( (A = (double *)calloc(sampleSize, sizeof(double))) == NULL ) {
printf("Final Analysis Report aborted due to insufficient workspace\n");
return 0;
}
for ( j=0; j<sampleSize; j++ ) {
fscanf(fp, "%f", &c);
if ( c < ALPHA )
count++;
A[j] = c;
}
}
if ( sampleSize == 0 )
passCount = 0;
else
passCount = sampleSize - count;
p_hat = 1.0 - ALPHA;
proportion_threshold_max = (p_hat + 3.0 * sqrt((p_hat*ALPHA)/sampleSize)) * sampleSize;
proportion_threshold_min = (p_hat - 3.0 * sqrt((p_hat*ALPHA)/sampleSize)) * sampleSize;
/* Compute Metric 2: Histogram */
qsort((void *)A, sampleSize, sizeof(double), (void *)cmp);
for ( j=0; j<sampleSize; j++ ) {
pos = (int)floor(A[j]*10);
if ( pos == 10 )
pos--;
freqPerBin[pos]++;
}
chi2 = 0.0;
expCount = sampleSize/10;
if ( expCount == 0 )
uniformity = 0.0;
else {
for ( j=0; j<10; j++ )
chi2 += pow(freqPerBin[j]-expCount, 2)/expCount;
uniformity = cephes_igamc(9.0/2.0, chi2/2.0);
}
for ( j=0; j<10; j++ ) /* DISPLAY RESULTS */
fprintf(summary, "%3d ", freqPerBin[j]);
if ( expCount == 0 )
fprintf(summary, " ---- ");
else if ( uniformity < 0.0001 )
fprintf(summary, " %8.6f * ", uniformity);
else
fprintf(summary, " %8.6f ", uniformity);
if ( sampleSize == 0 )
fprintf(summary, " ------ %s\n", testNames[test]);
// else if ( proportion < 0.96 )
else if ( (passCount < proportion_threshold_min) || (passCount > proportion_threshold_max))
fprintf(summary, "%4d/%-4d * %s\n", passCount, sampleSize, testNames[test]);
else
fprintf(summary, "%4d/%-4d %s\n", passCount, sampleSize, testNames[test]);
fclose(fp);
free(A);
return sampleSize;
}
void
LongestRunOfOnes(int n)
{
double pval, chi2, pi[7];
int run, v_n_obs, N, i, j, K, M, V[7];
unsigned int nu[7] = { 0, 0, 0, 0, 0, 0, 0 };
if ( n < 128 ) {
fprintf(stats[TEST_LONGEST_RUN], "\t\t\t LONGEST RUNS OF ONES TEST\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t n=%d is too short\n", n);
return;
}
if ( n < 6272 ) {
K = 3;
M = 8;
V[0] = 1; V[1] = 2; V[2] = 3; V[3] = 4;
pi[0] = 0.21484375;
pi[1] = 0.3671875;
pi[2] = 0.23046875;
pi[3] = 0.1875;
}
else if ( n < 750000 ) {
K = 5;
M = 128;
V[0] = 4; V[1] = 5; V[2] = 6; V[3] = 7; V[4] = 8; V[5] = 9;
pi[0] = 0.1174035788;
pi[1] = 0.242955959;
pi[2] = 0.249363483;
pi[3] = 0.17517706;
pi[4] = 0.102701071;
pi[5] = 0.112398847;
}
else {
K = 6;
M = 10000;
V[0] = 10; V[1] = 11; V[2] = 12; V[3] = 13; V[4] = 14; V[5] = 15; V[6] = 16;
pi[0] = 0.0882;
pi[1] = 0.2092;
pi[2] = 0.2483;
pi[3] = 0.1933;
pi[4] = 0.1208;
pi[5] = 0.0675;
pi[6] = 0.0727;
}
N = n/M;
for ( i=0; i<N; i++ ) {
v_n_obs = 0;
run = 0;
for ( j=0; j<M; j++ ) {
if ( epsilon[i*M+j] == 1 ) {
run++;
if ( run > v_n_obs )
v_n_obs = run;
}
else
run = 0;
}
if ( v_n_obs < V[0] )
nu[0]++;
for ( j=0; j<=K; j++ ) {
if ( v_n_obs == V[j] )
nu[j]++;
}
if ( v_n_obs > V[K] )
nu[K]++;
}
chi2 = 0.0;
for ( i=0; i<=K; i++ )
chi2 += ((nu[i] - N * pi[i]) * (nu[i] - N * pi[i])) / (N * pi[i]);
pval = cephes_igamc((double)(K/2.0), chi2 / 2.0);
fprintf(stats[TEST_LONGEST_RUN], "\t\t\t LONGEST RUNS OF ONES TEST\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\tCOMPUTATIONAL INFORMATION:\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t(a) N (# of substrings) = %d\n", N);
fprintf(stats[TEST_LONGEST_RUN], "\t\t(b) M (Substring Length) = %d\n", M);
fprintf(stats[TEST_LONGEST_RUN], "\t\t(c) Chi^2 = %f\n", chi2);
fprintf(stats[TEST_LONGEST_RUN], "\t\t---------------------------------------------\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t F R E Q U E N C Y\n");
fprintf(stats[TEST_LONGEST_RUN], "\t\t---------------------------------------------\n");
if ( K == 3 ) {
fprintf(stats[TEST_LONGEST_RUN], "\t\t <=1 2 3 >=4 P-value Assignment");
fprintf(stats[TEST_LONGEST_RUN], "\n\t\t %3d %3d %3d %3d ", nu[0], nu[1], nu[2], nu[3]);
}
else if ( K == 5 ) {
fprintf(stats[TEST_LONGEST_RUN], "\t\t<=4 5 6 7 8 >=9 P-value Assignment");
fprintf(stats[TEST_LONGEST_RUN], "\n\t\t %3d %3d %3d %3d %3d %3d ", nu[0], nu[1], nu[2],
nu[3], nu[4], nu[5]);
}
else {
fprintf(stats[TEST_LONGEST_RUN],"\t\t<=10 11 12 13 14 15 >=16 P-value Assignment");
fprintf(stats[TEST_LONGEST_RUN],"\n\t\t %3d %3d %3d %3d %3d %3d %3d ", nu[0], nu[1], nu[2],
nu[3], nu[4], nu[5], nu[6]);
}
if ( isNegative(pval) || isGreaterThanOne(pval) )
fprintf(stats[TEST_LONGEST_RUN], "WARNING: P_VALUE IS OUT OF RANGE.\n");
fprintf(stats[TEST_LONGEST_RUN], "%s\t\tp_value = %f\n\n", pval < ALPHA ? "FAILURE" : "SUCCESS", pval); fflush(stats[TEST_LONGEST_RUN]);
fprintf(results[TEST_LONGEST_RUN], "%f\n", pval); fflush(results[TEST_LONGEST_RUN]);
}
void
LinearComplexity(int M, int n)
{
int i, ii, j, d, N, L, m, N_, parity, sign, K = 6;
double p_value, T_, mean, nu[7], chi2;
double pi[7] = { 0.01047, 0.03125, 0.12500, 0.50000, 0.25000, 0.06250, 0.020833 };
BitSequence *T = NULL, *P = NULL, *B_ = NULL, *C = NULL;
N = (int)floor(n/M);
if ( ((B_ = (BitSequence *) calloc(M, sizeof(BitSequence))) == NULL) ||
((C = (BitSequence *) calloc(M, sizeof(BitSequence))) == NULL) ||
((P = (BitSequence *) calloc(M, sizeof(BitSequence))) == NULL) ||
((T = (BitSequence *) calloc(M, sizeof(BitSequence))) == NULL) ) {
printf("Insufficient Memory for Work Space:: Linear Complexity Test\n");
if ( B_ != NULL )
free(B_);
if ( C != NULL )
free(C);
if ( P != NULL )
free(P);
if ( T != NULL )
free(T);
return;
}
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tL I N E A R C O M P L E X I T Y\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tM (substring length) = %d\n", M);
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tN (number of substrings) = %d\n", N);
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " F R E Q U E N C Y \n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " C0 C1 C2 C3 C4 C5 C6 CHI2 P-value\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tNote: %d bits were discarded!\n", n%M);
for ( i=0; i<K+1; i++ )
nu[i] = 0.00;
for ( ii=0; ii<N; ii++ ) {
for ( i=0; i<M; i++ ) {
B_[i] = 0;
C[i] = 0;
T[i] = 0;
P[i] = 0;
}
L = 0;
m = -1;
d = 0;
C[0] = 1;
B_[0] = 1;
/* DETERMINE LINEAR COMPLEXITY */
N_ = 0;
while ( N_ < M ) {
d = (int)epsilon[ii*M+N_];
for ( i=1; i<=L; i++ )
d += C[i] * epsilon[ii*M+N_-i];
d = d%2;
if ( d == 1 ) {
for ( i=0; i<M; i++ ) {
T[i] = C[i];
P[i] = 0;
}
for ( j=0; j<M; j++ )
if ( B_[j] == 1 )
P[j+N_-m] = 1;
for ( i=0; i<M; i++ )
C[i] = (C[i] + P[i])%2;
if ( L <= N_/2 ) {
L = N_ + 1 - L;
m = N_;
for ( i=0; i<M; i++ )
B_[i] = T[i];
}
}
N_++;
}
if ( (parity = (M+1)%2) == 0 )
sign = -1;
else
sign = 1;
mean = M/2.0 + (9.0+sign)/36.0 - 1.0/pow(2, M) * (M/3.0 + 2.0/9.0);
if ( (parity = M%2) == 0 )
sign = 1;
else
sign = -1;
T_ = sign * (L - mean) + 2.0/9.0;
if ( T_ <= -2.5 )
nu[0]++;
else if ( T_ > -2.5 && T_ <= -1.5 )
nu[1]++;
else if ( T_ > -1.5 && T_ <= -0.5 )
nu[2]++;
else if ( T_ > -0.5 && T_ <= 0.5 )
nu[3]++;
else if ( T_ > 0.5 && T_ <= 1.5 )
nu[4]++;
else if ( T_ > 1.5 && T_ <= 2.5 )
nu[5]++;
else
nu[6]++;
}
chi2 = 0.00;
for ( i=0; i<K+1; i++ )
fprintf(stats[TEST_LINEARCOMPLEXITY], "%4d ", (int)nu[i]);
for ( i=0; i<K+1; i++ )
chi2 += pow(nu[i]-N*pi[i], 2) / (N*pi[i]);
p_value = cephes_igamc(K/2.0, chi2/2.0);
fprintf(stats[TEST_LINEARCOMPLEXITY], "%9.6f%9.6f\n", chi2, p_value); fflush(stats[TEST_LINEARCOMPLEXITY]);
fprintf(results[TEST_LINEARCOMPLEXITY], "%f\n", p_value); fflush(results[TEST_LINEARCOMPLEXITY]);
free(B_);
free(P);
free(C);
free(T);
}
void
LinearComplexity3(int M, int n)
{
int i, ii, j, N, L, parity, sign, K = 6, nu[7];
double p_value, T_, mean, chi2;
double pi[7] = { 0.01047, 0.03125, 0.12500, 0.50000, 0.25000, 0.06250, 0.020833 };
int size;
//double low, up;
BMAint *d_b, *d_c, *d_t, *S;
size = (M + sizeof(BMAint)* 8) / (sizeof(BMAint)* 8) + 4 /* pro jistotu: */ + 100;
d_b = (BMAint*)malloc(sizeof(BMAint)*size);
d_c = (BMAint*)malloc(sizeof(BMAint)*size);
d_t = (BMAint*)malloc(sizeof(BMAint)*size);
S = (BMAint*)malloc(sizeof(BMAint)*size);
N = (int)floor(n / M);
#ifdef FILE_OUTPUT
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tL I N E A R C O M P L E X I T Y\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tM (substring length) = %d\n", M);
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tN (number of substrings) = %d\n", N);
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " F R E Q U E N C Y \n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " C0 C1 C2 C3 C4 C5 C6 CHI2 P-value\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tNote: %d bits were discarded!\n", n%M);
#endif
if ((parity = (M + 1) % 2) == 0)
sign = -1;
else
sign = 1;
mean = M / 2.0 + (9.0 + sign) / 36.0 - 1.0 / pow(2, M) * (M / 3.0 + 2.0 / 9.0);
if ((parity = M % 2) == 0)
sign = 1;
else
sign = -1;
//low = (2.5 - 2.0 / 9.0) / sign + mean;
//up = (-2.5 - 2.0 / 9.0) / sign + mean;
for (i = 0; i<K + 1; i++)
nu[i] = 0;
for (ii = 0; ii<N; ii++) {
j = 0;
for (i = M*ii; i < M*(ii + 1); i += 32)
{
S[j] = get_nth_block_effect(array, i);
j++;
}
//if((M % 32) != 0) S[j] &= ((M % 32) << 1);
L = BM_JOURNAL(d_b, d_c, d_t, S, M);
T_ = sign * (L - mean) + 2.0 / 9.0;
if (T_ <= -2.5)
nu[0]++;
else if (T_ > -2.5 && T_ <= -1.5)
nu[1]++;
else if (T_ > -1.5 && T_ <= -0.5)
nu[2]++;
else if (T_ > -0.5 && T_ <= 0.5)
nu[3]++;
else if (T_ > 0.5 && T_ <= 1.5)
nu[4]++;
else if (T_ > 1.5 && T_ <= 2.5)
nu[5]++;
else
nu[6]++;
}
chi2 = 0.00;
#ifdef FILE_OUTPUT
for (i = 0; i<K + 1; i++)
fprintf(stats[TEST_LINEARCOMPLEXITY], "%4d ", (int)nu[i]);
#endif
for (i = 0; i<K + 1; i++)
{
chi2 += pow(nu[i] - N*pi[i], 2) / (N*pi[i]);
//printf("%d ",nu[i]);
#ifdef VERIFY_RESULTS
R_.linear_complexity.nu[i] = nu[i];
#endif
}
p_value = cephes_igamc(K / 2.0, chi2 / 2.0);
#ifdef SPEED
dummy_result = p_value;
#endif
#ifdef VERIFY_RESULTS
R_.linear_complexity.chi2=chi2;
R_.linear_complexity.p_value=p_value;
if(LinearComplexity_v1 == LinearComplexity3) R1 = R_;
else R2 = R_;
#endif
#ifdef FILE_OUTPUT
fprintf(stats[TEST_LINEARCOMPLEXITY], "%9.6f%9.6f\n", chi2, p_value); fflush(stats[TEST_LINEARCOMPLEXITY]);
fprintf(results[TEST_LINEARCOMPLEXITY], "%f\n", p_value); fflush(results[TEST_LINEARCOMPLEXITY]);
#endif
#ifdef KS
pvals.linear_complexity_pvals[pvals.seq_counter] = p_value;
#endif
}
void
LinearComplexity2(int M, int n)
{
int i, ii, j, N, L, parity, sign, K = 6, nu[7];
double p_value, T_, mean, chi2;
double pi[7] = { 0.01047, 0.03125, 0.12500, 0.50000, 0.25000, 0.06250, 0.020833 };
int array_size, type_size_bits,type_size_bytes;
type *type_array,*c,*t,*b;
type_size_bytes = sizeof(type);
type_size_bits = sizeof(type)*8;
array_size = M / type_size_bits + (M % type_size_bits != 0);
type_array = (type*)malloc(array_size*type_size_bytes);
c = (type*)malloc(array_size*type_size_bytes);
t = (type*)malloc(array_size*type_size_bytes);
b = (type*)malloc(array_size*type_size_bytes);
if (type_array==NULL||c==NULL||t==NULL||b==NULL) {
printf("Insufficient Memory for Work Space: Linear Complexity Test\n");
if ( type_array!= NULL )
free(type_array);
if ( c != NULL )
free(c);
if ( t != NULL )
free(t);
if ( b != NULL )
free(b);
return;
}
N = (int)floor(n/M);
#ifdef FILE_OUTPUT
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tL I N E A R C O M P L E X I T Y\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tM (substring length) = %d\n", M);
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tN (number of substrings) = %d\n", N);
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " F R E Q U E N C Y \n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], " C0 C1 C2 C3 C4 C5 C6 CHI2 P-value\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "-----------------------------------------------------\n");
fprintf(stats[TEST_LINEARCOMPLEXITY], "\tNote: %d bits were discarded!\n", n%M);
#endif
for ( i=0; i<K+1; i++ )
nu[i] = 0;
for ( ii=0; ii<N; ii++ ) {
j = 0;
for(i = M*ii; i < M*(ii+1); i+= type_size_bits)
{
type_array[j] = get_nth_block_effect(array,i);
j++;
}
if((M % type_size_bits) != 0) type_array[j] &= ((M % type_size_bits) << 1);
L = BM_c(type_array,M,c,b,t);
if ( (parity = (M+1)%2) == 0 )
sign = -1;
else
sign = 1;
mean = M/2.0 + (9.0+sign)/36.0 - 1.0/pow(2, M) * (M/3.0 + 2.0/9.0);
if ( (parity = M%2) == 0 )
sign = 1;
else
sign = -1;
T_ = sign * (L - mean) + 2.0/9.0;
if ( T_ <= -2.5 )
nu[0]++;
else if ( T_ > -2.5 && T_ <= -1.5 )
nu[1]++;
else if ( T_ > -1.5 && T_ <= -0.5 )
nu[2]++;
else if ( T_ > -0.5 && T_ <= 0.5 )
nu[3]++;
else if ( T_ > 0.5 && T_ <= 1.5 )
nu[4]++;
else if ( T_ > 1.5 && T_ <= 2.5 )
nu[5]++;
else
nu[6]++;
}
chi2 = 0.00;
#ifdef FILE_OUTPUT
for ( i=0; i<K+1; i++ )
fprintf(stats[TEST_LINEARCOMPLEXITY], "%4d ", (int)nu[i]);
#endif
for ( i=0; i<K+1; i++ )
{
chi2 += pow(nu[i]-N*pi[i], 2) / (N*pi[i]);
//printf("%d ",nu[i]);
#ifdef VERIFY_RESULTS
R_.linear_complexity.nu[i]=nu[i];
#endif
}
p_value = cephes_igamc(K/2.0, chi2/2.0);
#ifdef SPEED
dummy_result = p_value;
#endif
#ifdef VERIFY_RESULTS
R_.linear_complexity.chi2=chi2;
R_.linear_complexity.p_value=p_value;
if(LinearComplexity_v1 == LinearComplexity2) R1 = R_;
else R2 = R_;
#endif
#ifdef FILE_OUTPUT
fprintf(stats[TEST_LINEARCOMPLEXITY], "%9.6f%9.6f\n", chi2, p_value); fflush(stats[TEST_LINEARCOMPLEXITY]);
fprintf(results[TEST_LINEARCOMPLEXITY], "%f\n", p_value); fflush(results[TEST_LINEARCOMPLEXITY]);
#endif
#ifdef KS
pvals.linear_complexity_pvals[pvals.seq_counter] = p_value;
#endif
}
void
NonOverlappingTemplateMatchings(int m, int n)
{
int numOfTemplates[100] = {0, 0, 2, 4, 6, 12, 20, 40, 74, 148, 284, 568, 1116,
2232, 4424, 8848, 17622, 35244, 70340, 140680, 281076, 562152};
/*----------------------------------------------------------------------------
NOTE: Should additional templates lengths beyond 21 be desired, they must
first be constructed, saved into files and then the corresponding
number of nonperiodic templates for that file be stored in the m-th
position in the numOfTemplates variable.
----------------------------------------------------------------------------*/
unsigned int bit, W_obs, nu[6], *Wj = NULL;
FILE *fp;
double sum, chi2, p_value, lambda, pi[6], varWj;
int i, j, jj, k, match, SKIP, M, N, K = 5;
char directory[100];
BitSequence *sequence = NULL;
N = 8;
M = n/N;
if ( (Wj = (unsigned int*)calloc(N, sizeof(unsigned int))) == NULL ) {
fprintf(stats[TEST_NONPERIODIC], "\tNONOVERLAPPING TEMPLATES TESTS ABORTED DUE TO ONE OF THE FOLLOWING : \n");
fprintf(stats[TEST_NONPERIODIC], "\tInsufficient memory for required work space.\n");
return;
}
lambda = (M-m+1)/pow(2, m);
varWj = M*(1.0/pow(2.0, m) - (2.0*m-1.0)/pow(2.0, 2.0*m));
sprintf(directory, "templates/template%d", m);
if ( ((isNegative(lambda)) || (isZero(lambda))) ||
((fp = fopen(directory, "r")) == NULL) ||
((sequence = (BitSequence *) calloc(m, sizeof(BitSequence))) == NULL) ) {
fprintf(stats[TEST_NONPERIODIC], "\tNONOVERLAPPING TEMPLATES TESTS ABORTED DUE TO ONE OF THE FOLLOWING : \n");
fprintf(stats[TEST_NONPERIODIC], "\tLambda (%f) not being positive!\n", lambda);
fprintf(stats[TEST_NONPERIODIC], "\tTemplate file <%s> not existing\n", directory);
fprintf(stats[TEST_NONPERIODIC], "\tInsufficient memory for required work space.\n");
if ( sequence != NULL )
free(sequence);
}
else {
fprintf(stats[TEST_NONPERIODIC], "\t\t NONPERIODIC TEMPLATES TEST\n");
fprintf(stats[TEST_NONPERIODIC], "-------------------------------------------------------------------------------------\n");
fprintf(stats[TEST_NONPERIODIC], "\t\t COMPUTATIONAL INFORMATION\n");
fprintf(stats[TEST_NONPERIODIC], "-------------------------------------------------------------------------------------\n");
fprintf(stats[TEST_NONPERIODIC], "\tLAMBDA = %f\tM = %d\tN = %d\tm = %d\tn = %d\n", lambda, M, N, m, n);
fprintf(stats[TEST_NONPERIODIC], "-------------------------------------------------------------------------------------\n");
fprintf(stats[TEST_NONPERIODIC], "\t\tF R E Q U E N C Y\n");
fprintf(stats[TEST_NONPERIODIC], "Template W_1 W_2 W_3 W_4 W_5 W_6 W_7 W_8 Chi^2 P_value Assignment Index\n");
fprintf(stats[TEST_NONPERIODIC], "-------------------------------------------------------------------------------------\n");
if ( numOfTemplates[m] < MAXNUMOFTEMPLATES )
SKIP = 1;
else
SKIP = (int)(numOfTemplates[m]/MAXNUMOFTEMPLATES);
numOfTemplates[m] = (int)numOfTemplates[m]/SKIP;
sum = 0.0;
for ( i=0; i<2; i++ ) { /* Compute Probabilities */
pi[i] = exp(-lambda+i*log(lambda)-cephes_lgam(i+1));
sum += pi[i];
}
pi[0] = sum;
for ( i=2; i<=K; i++ ) { /* Compute Probabilities */
pi[i-1] = exp(-lambda+i*log(lambda)-cephes_lgam(i+1));
sum += pi[i-1];
}
pi[K] = 1 - sum;
for( jj=0; jj<MIN(MAXNUMOFTEMPLATES, numOfTemplates[m]); jj++ ) {
sum = 0;
for ( k=0; k<m; k++ ) {
fscanf(fp, "%d", &bit);
sequence[k] = bit;
fprintf(stats[TEST_NONPERIODIC], "%d", sequence[k]);
}
fprintf(stats[TEST_NONPERIODIC], " ");
for ( k=0; k<=K; k++ )
nu[k] = 0;
for ( i=0; i<N; i++ ) {
W_obs = 0;
for ( j=0; j<M-m+1; j++ ) {
match = 1;
for ( k=0; k<m; k++ ) {
if ( (int)sequence[k] != (int)epsilon[i*M+j+k] ) {
match = 0;
break;
}
}
if ( match == 1 )
W_obs++;
}
Wj[i] = W_obs;
}
sum = 0;
chi2 = 0.0; /* Compute Chi Square */
for ( i=0; i<N; i++ ) {
if ( m == 10 )
fprintf(stats[TEST_NONPERIODIC], "%3d ", Wj[i]);
else
fprintf(stats[TEST_NONPERIODIC], "%4d ", Wj[i]);
chi2 += pow(((double)Wj[i] - lambda)/pow(varWj, 0.5), 2);
}
p_value = cephes_igamc(N/2.0, chi2/2.0);
if ( isNegative(p_value) || isGreaterThanOne(p_value) )
fprintf(stats[TEST_NONPERIODIC], "\t\tWARNING: P_VALUE IS OUT OF RANGE.\n");
fprintf(stats[TEST_NONPERIODIC], "%9.6f %f %s %3d\n", chi2, p_value, p_value < ALPHA ? "FAILURE" : "SUCCESS", jj);
if ( SKIP > 1 )
fseek(fp, (long)(SKIP-1)*2*m, SEEK_CUR);
fprintf(results[TEST_NONPERIODIC], "%f\n", p_value);
}
}
fprintf(stats[TEST_NONPERIODIC], "\n");
if ( sequence != NULL )
free(sequence);
free(Wj);
fclose(fp);
}
