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