static void ceyeaTest ( void ) { int i = 0 ; floatComplex result = FloatComplex ( 0 , 0 ) ; floatComplex in[LEADDIM*LEADDIM] ; ceyea ( in , LEADDIM , LEADDIM ) ; for ( i = 0 ; i < LEADDIM*LEADDIM ; i++) { if ( i%(LEADDIM+1) == 0 ) result = FloatComplex ( 1.0f , 0 ) ; else result = FloatComplex ( 0 , 0 ) ; printf ( "\t\t %d in : %e\tresult : %e \n" , i, creals( in[i]) , creals ( result ) ) ; if ( creals( in[i]) < 1e-6 && creals( result) < 1e-6 ) assert(1); else assert ( fabs ( creals(in[i]) - creals(result)) / fabs( creals(in[i])) < 1e-6 ) ; if ( cimags ( in[i]) < 1e-6 ) assert (1); else assert (0); } }
floatComplex ctanhs(floatComplex z) { float real = creals(z); float imag = cimags(z); floatComplex result = ctans(FloatComplex(-imag, real)); return (FloatComplex(cimags(result), -creals(result))); }
static void ceyesTest ( void ) { floatComplex result = FloatComplex ( 1.0f , 0 ) ; floatComplex in = FloatComplex ( LEADDIM, LEADDIM ) ; in = ceyes ( in ) ; assert ( (creals(in) - creals(result)) / fabs( creals(in)) < 1e-6 ) ; assert ( cimags (in) == 0) ; }
float sdista(float* in1,float* in2, int lines, int columns) { int i=0; float out=0; float *a, *at, *mul; floatComplex *eigenvalues,*mulCpx; /* FIXME : malloc here*/ a=(float*)malloc((unsigned int)(lines*columns)*sizeof(float)); at=(float*)malloc((unsigned int)(lines*columns)*sizeof(float)); mul=(float*)malloc((unsigned int)(lines*lines)*sizeof(float)); eigenvalues=(floatComplex*)malloc((unsigned int)(lines)*sizeof(floatComplex)); mulCpx=(floatComplex*)malloc((unsigned int)(lines*lines)*sizeof(floatComplex)); for (i=0; i<lines*columns; i++) a[i]=in1[i]-in2[i]; stransposea(a,lines, columns,at); smulma(a,lines,columns,at,columns,lines,mul); for (i=0; i<lines*lines; i++) mulCpx[i]=FloatComplex(mul[i],0); cspeca(mulCpx,lines,eigenvalues); csqrta(eigenvalues,lines,eigenvalues); /* Research of the higher value of eigenvalues*/ for (i=0; i<lines; i++) { if (creals(eigenvalues[i])>out) out = creals(eigenvalues[i]); } free(a); free(at); free(mul); free(eigenvalues); free(mulCpx); return out; }
floatComplex ccoss(floatComplex z) { float real = creals(z); float imag = cimags(z); return FloatComplex(scoss(real) * scoshs(imag), -ssins(real) * ssinhs(imag)); }
floatComplex ccoths(floatComplex z) { floatComplex out; out = crdivs(FloatComplex(1,0), ctanhs(z)); return out; }
static void ccholsTest(void){ floatComplex in; floatComplex out; in=FloatComplex(3,1); printf("\n >>> CCholS <<<\n"); out=cchols(in); printf("result : %f\n",creals(out)); }
void conesa ( floatComplex* in , int rows ,int cols ) { int i = 0 ; for ( i = 0 ; i < rows*cols ; i++) { in[i] = FloatComplex ( 1.0f , 0); } }
void crowmeanfa(floatComplex *in1, int lines, int columns, floatComplex *in2, floatComplex *out) { int i = 0; int j = 0; floatComplex tempCoefSum = FloatComplex(0.0f,0.0f); floatComplex tempMul = FloatComplex(0.0f,0.0f); /*we first multiply each cell of the input matrix by its coefficient*/ for (j = 0; j < columns; ++j) { tempCoefSum = FloatComplex(0.0f,0.0f); out[j]= FloatComplex(0.0f,0.0f); for ( i = 0 ; i < lines; ++i ) { tempMul = cmuls ( in1[lines*j + i] , in2[lines*j + i]); /* we times by the coefficient*/ tempCoefSum = cadds ( in2[lines*j + i] ,tempCoefSum ) ; out[j] = cadds (tempMul, out[j]) ; } out[j] = crdivs(out[j] ,tempCoefSum); } }
floatComplex cvariancea(floatComplex *in, int size) { int i = 0 ; floatComplex sum = FloatComplex ( 0 , 0 ) ; floatComplex temp = FloatComplex ( 0 , 0 ) ; floatComplex variance = FloatComplex ( 0 , 0 ); floatComplex mean = cmeana ( in , size ) ; for ( i = 0 ; i < size ; i++) { temp = cdiffs( in[i] , mean ) ; sum = cadds ( sum , cpows ( temp , FloatComplex ( 2, 0) ) ); } variance = crdivs (sum , FloatComplex ( (float)(size - 1),0 )); return variance ; }
/* ** \float complexes displaying test */ static void cdispaTest (void) { int i = 0 ; floatComplex tabF[SIZE] ; for ( i = 0 ; i < SIZE ; ++i) { tabF[i] = FloatComplex ((float) rand (), (float) rand()); } cdispa ( tabF, 1, SIZE ) ; }
int clengthaTest() { floatComplex goodArray[5]; floatComplex badArray[5]; /* Good values in goodArray */ goodArray[0] = FloatComplex(0., 0.); goodArray[1] = FloatComplex(0., 2.); goodArray[2] = FloatComplex(3., 50.); goodArray[3] = FloatComplex(5., 10.); goodArray[4] = FloatComplex(10., -10.); /* Bad values in badArray */ badArray[5] = FloatComplex(0., 0.); badArray[5] = FloatComplex(0., 0.); badArray[5] = FloatComplex(0., 0.); badArray[5] = FloatComplex(0., 0.); badArray[5] = FloatComplex(0., 0.); printf(">> Float Complex \n"); assert(clengtha(goodArray, 5) == 5); assert(clengtha(badArray, 5) == 5); return 0; }
void spowma(float* in, int rows, float power, float* out){ int i=0, j=0; int symmetric=0; floatComplex *eigenvalues,*eigenvectors,*tmp; float* ZEROS; /* Data initialization */ eigenvalues = (floatComplex*)malloc((unsigned int)(rows*rows)*sizeof(floatComplex)); eigenvectors = (floatComplex*)malloc((unsigned int)(rows*rows)*sizeof(floatComplex)); tmp = (floatComplex*)malloc((unsigned int)(rows*rows)*sizeof(floatComplex)); ZEROS = (float*)malloc((unsigned int)(rows*rows)*sizeof(float)); /* symmetric test*/ for(i=0;i<rows;i++) { for (j=0;j<rows;j++) if (in[i*rows+j]!=in[j*rows+i]) break; if (j!=rows) break; } if ((i==rows)&&(j==rows)) symmetric=1; szerosa(ZEROS,rows,rows); tmp = FloatComplexMatrix(in,ZEROS,rows*rows); /* find eigenvalues and eigenvectors */ cspec2a(tmp, rows, eigenvalues,eigenvectors); /* make operation on eigenvalues and eigenvectors */ for (i=0;i<rows;i++) eigenvalues[i+i*rows]=cpows(eigenvalues[i+i*rows],FloatComplex(power,0)); cmulma(eigenvectors, rows, rows, eigenvalues, rows, rows, tmp); if (symmetric){ ctransposea(eigenvectors, rows,rows, eigenvalues); cconja(eigenvalues, rows*rows, eigenvalues); } else cinverma(eigenvectors, eigenvalues, rows); cmulma(tmp, rows, rows, eigenvalues, rows, rows, eigenvectors); for (i=0;i<rows*rows;i++) out[i]=creals(eigenvectors[i]); free(eigenvalues); free(eigenvectors); free(tmp); }
void cconva(floatComplex *in1, int size1, floatComplex *in2,int size2, floatComplex *out){ int m1,i; floatComplex *in1b, *in2b, *result; m1=(int)floor( log(size1+size2-1.0) / log(2.0) + 1 ); m1=(int)pow(2.0, m1); in1b=(floatComplex *)malloc((unsigned int)(2*m1)*sizeof(float)); for(i=0;i<m1;i++){ if (i<size1) in1b[i]=in1[i]; else in1b[i]=FloatComplex(0,0); } in2b=(floatComplex *)malloc((unsigned int)(2*m1)*sizeof(float)); for(i=0;i<m1;i++){ if (i<size2) in2b[i]=in2[i]; else in2b[i]=FloatComplex(0,0); } cfftma(in1b,m1,1,in1b); cfftma(in2b,m1,1,in2b); result=(floatComplex *)malloc((unsigned int)(2*m1)*sizeof(float)); cmula(in1b,in2b,m1,result); cifftma(result,m1,1,result); for (i=0;i<size1+size2-1;i++){ out[i]=result[i]; } free(in1b); free(in2b); free(result); }
void ccoshsTest(void) { float inR[]=CSOURCER; float inI[]=CSOURCEI; float resR[]=CRESULTR; float resI[]=CRESULTI; floatComplex in,out; int i; for (i=0;i<200;i++){ in=FloatComplex(inR[i],inI[i]); out=ccoshs(in); assert( fabs(creals(out) - resR[i]) < 3e-6); assert( fabs(cimags(out) - resI[i]) < 3e-6); } }
void catansTest(void) { float inR[]=CSOURCER; float inI[]=CSOURCEI; float resR[]=CRESULTR; float resI[]=CRESULTI; floatComplex in, out; int i=0; for (i=0;i<200;i++){ in=FloatComplex(inR[i],inI[i]); out=catans(in); assert( ( (fabs(creals(out)-resR[i])) / (fabs(creals(out))) ) <1e-6); assert( ( (fabs(cimags(out)-resI[i])) / (fabs(cimags(out))) ) <1e-6); } }
void cpowsTest(void) { float in1R[]=CSOURCER; float in1I[]=CSOURCEI; floatComplex in2=CEXPAND; float resR[]=CRESULTR; float resI[]=CRESULTI; floatComplex in1,out; int i; for (i=0;i<200;i++){ in1=FloatComplex(in1R[i],in1I[i]); out=cpows(in1,in2); assert(( (fabs(creals(out)-resR[i]))/(fabs(creals(out))) )<1e-5); assert(( (fabs(cimags(out)-resI[i]))/(fabs(cimags(out))) )<1e-5); } }
void crdivma ( floatComplex* in1, int lines1, int columns1 , floatComplex* in2, int lines2, int columns2 , floatComplex* out ){ int i = 0 ; /* these 3 variable are created to permit to use the value in the fortran functions because they need doubleComplex matrix as arguments and we can't cast directly the pointers without having problems , i know that's ugly */ doubleComplex *dblin1 = NULL; doubleComplex *dblin2 = NULL; doubleComplex *dblout = NULL; /* Array allocations*/ dblin1 = (doubleComplex*)malloc(sizeof(doubleComplex) * (unsigned int)columns1 * (unsigned int)lines1); dblin2 = (doubleComplex*)malloc(sizeof(doubleComplex) * (unsigned int)columns2 * (unsigned int)lines2); dblout = (doubleComplex*)malloc(sizeof(doubleComplex) * (unsigned int)lines1 * (unsigned int)lines2); /*copy and cast all the floatComplex value into doubleComplex value */ for ( i = 0 ; i < lines1 * columns1 ; i ++ ) { dblin1[i] = DoubleComplex ( (double) creals( in1[i]) , (double) cimags ( in1[i])) ; } for ( i = 0 ; i < lines2 * columns2 ; i ++ ) { dblin2[i] = DoubleComplex ( (double) creals( in2[i]) , (double) cimags ( in2[i])) ; } zrdivma( dblin1 , lines1 , columns1 , dblin2 , lines2 , columns2 , dblout ); for ( i = 0 ; i < min(lines2,columns2) * lines1 ; i++ ) { out[i] = FloatComplex ((float) zreals ( dblout[i]) , (float) zimags ( dblout[i])) ; } free ( dblin1); free ( dblin2); free ( dblout); }
floatComplex clogs(floatComplex in) { static float sR2 = 1.41421356237309504f; float _RealIn = creals(in); float _ImgIn = cimags(in); float _RealOut = 0; float _ImgOut = 0; float RMax = (float) getOverflowThreshold(); float LInf = sqrtf((float) getUnderflowThreshold()); float LSup = sqrtf(0.5f * RMax); float AbsReal = fabsf(_RealIn); float AbsImg = fabsf(_ImgIn); _ImgOut = atan2f(_ImgIn, _RealIn); if(_ImgIn > _RealIn) {/* switch Real part and Imaginary part */ float Temp = AbsReal; AbsReal = AbsImg; AbsImg = Temp; } if((0.5 <= AbsReal) && (AbsReal <= sR2)) _RealOut = 0.5f * slog1ps((AbsReal - 1.0f) * (AbsReal + 1.0f) + AbsImg * AbsImg); else if(LInf < AbsImg && AbsReal < LSup) _RealOut = 0.5f * slogs(AbsReal * AbsReal + AbsImg * AbsImg); else if(AbsReal > RMax) _RealOut = AbsReal; else { float Temp = spythags(AbsReal, AbsImg); if(Temp <= RMax) { _RealOut = slogs(Temp); } else /* handle rare spurious overflow with : */ { float Temp2 = AbsImg/AbsReal; _RealOut = slogs(AbsReal) + 0.5f * slog1ps(Temp2 * Temp2); } } return FloatComplex(_RealOut, _ImgOut); }
void ccoshaTest(void) { float inR[]=CSOURCER; float inI[]=CSOURCEI; float resR[]=CRESULTR; float resI[]=CRESULTI; floatComplex in[200],out[200]; int i; for (i=0;i<200;i++){ in[i]=FloatComplex(inR[i],inI[i]); } ccosha(in,200,out); for (i=0;i<200;i++){ assert( fabs(creals(out[i]) - resR[i]) < 3e-6); assert( fabs(cimags(out[i]) - resI[i]) < 3e-6); } }
void slpc2cepa(float *in, int size, float*out){ int i; floatComplex* inCpx; /* Copy in in a FloatComplex*/ inCpx=(floatComplex*)malloc((unsigned int)(size*size)*sizeof(floatComplex)); for (i=0;i<size*size;i++) { inCpx[i]=FloatComplex(in[i],0); } cfftma(inCpx,size,size,inCpx); clogma(inCpx,size,inCpx); cifftma(inCpx,size,size,inCpx); creala(inCpx,size*size,out); free(inCpx); }
void cinverma ( floatComplex* in, floatComplex* out, int leadDimIn ) { int i = 0 ; /* these 3 variable are created to permit to use the value in the fortran functions because they need doubleComplex matrix as arguments and we can't cast directly the pointers without having problems , i know that's ugly */ doubleComplex *dblin = NULL; doubleComplex *dblout = NULL; /* Array allocations*/ dblin = (doubleComplex*)malloc(sizeof(doubleComplex) * (unsigned int)(leadDimIn * leadDimIn)); dblout = (doubleComplex*)malloc(sizeof(doubleComplex) * (unsigned int)(leadDimIn * leadDimIn)); /*copy and cast all the floatComplex value into doubleComplex value */ for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i ++ ) { dblin[i] = DoubleComplex ( (double) creals( in[i]) , (double) cimags ( in[i])) ; } zinverma ( dblin, dblout, leadDimIn ); for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i++ ) { out[i] = FloatComplex ((float) zreals ( dblout[i]) , (float) zimags ( dblout[i])) ; } free ( dblin); free ( dblout); }
assert( ( fabs(rowMeanmedTable2_2_5[1] ) - ( 95.0f / 27.0f ) ) / fabs ( rowMeanmedTable2_2_5[1] ) < 1e-6 ); assert( ( fabs(rowMeanmedTable2_2_5[2] ) - ( 171.0f / 31.0f ) ) / fabs ( rowMeanmedTable2_2_5[2] ) < 1e-6 ); assert( ( fabs(rowMeanmedTable2_2_5[3] ) - ( 263.0f / 35.0f ) ) / fabs ( rowMeanmedTable2_2_5[3] ) < 1e-6 ); assert( ( fabs(rowMeanmedTable2_2_5[4] ) - ( 371.0f / 39.0f ) ) / fabs ( rowMeanmedTable2_2_5[4] ) < 1e-6 ); return 0; } */ static int cvariancefsTest(void) { printf("\n>>>> Mean Float Complex Scalar Test\n"); assert( creals(cvariancefs(FloatComplex(3.0f, 3.0f),FloatComplex(3.0f, 0.0f);)) == 0.0f ); assert( cimags(cvariancefs(FloatComplex(3.0f, 3.0f),FloatComplex(3.0f, 0.0f);)) == 0.0f ); assert( creals(cvariancefs(FloatComplex(1.123456789f, 1.123456789f),FloatComplex(1.123456789f, 1.123456789f))) == 0.0f ); assert( cimags(cvariancefs(FloatComplex(1.123456789f, 1.123456789f),FloatComplex(1.123456789f, 1.123456789f))) == 0.0f ); return 0; } static int cvariancefaTest(void) { float tableR1[9] = {1.0f, 4.0f, 7.0f, 2.0f , 5.0f, 8.0f, 3.0f, 6.0f, 9.0f}; float tableI1[9] = {1.0f, 2.0f, 3.0f, 4.0f , 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; float coefR1[9] = {10.0f, 1.0f, 5.0f,11.0f , 2.0f, 6.0f,12.0f, 3.0f, 7.0f}; float coefI1[9] = { 0.0f, 0.0f, 0.0f, 0.0f , 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
void ccolumnstdevfa(floatComplex *in1, int lines, int columns, floatComplex*in2, floatComplex* out){ int i = 0; int j = 0; floatComplex temp = FloatComplex(0.0f,0.0f); floatComplex accumulate = FloatComplex(0.0f,0.0f); floatComplex accumulateFre = FloatComplex(0.0f,0.0f); ccolumnmeanfa(in1, lines, columns, in2, out ); /*we first multiply each cell of the input matrix by its coefficient*/ for (j = 0; j < lines; ++j) { accumulate = FloatComplex(0.0f,0.0f); accumulateFre = FloatComplex(0.0f,0.0f); temp = FloatComplex(0.0f,0.0f); for ( i = 0 ; i < columns; ++i ) { temp = cpows ( cdiffs (in1[lines*i + j] ,out[j] ) ,FloatComplex (2.0f, 0.0f ) ); temp = cmuls( in2[lines*i + j] , temp); accumulate = cadds( temp , accumulate); accumulateFre = cadds (in2[lines*i + j] ,accumulateFre ); } if (lines <= 1) { out[j] = cmuls (FloatComplex(0.0f,0.0f) , accumulate ) ; } else { if( sabss (creals(accumulate)) <= 3e-6 ) accumulate = FloatComplex(sabss(creals(accumulate)) ,cimags(accumulate)); if( sabss (cimags(accumulate)) <= 3e-6 ) accumulate = FloatComplex(creals(accumulate) ,sabss(cimags(accumulate))); accumulate = crdivs (accumulate , cdiffs (accumulateFre ,FloatComplex(1.0f,0.0f)) ); out[j] =csqrts(accumulate); } } }
static void cfixsTest(void) { floatComplex in, out; /* tests allant de -2 + i a -1 + 2*i, les reels décroissants de 0.1, les imaginaires croissant de 0.1 + 1 test supplementaire : -0.9 + 0.9*i*/ in=FloatComplex(-2,1); out = cfixs(in); assert ((fabs( creals(out) - (-2))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.9f,1.1f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.8f,1.2f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.7f,1.3f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.6f,1.4f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.5f,1.5f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.4f,1.6f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.3f,1.7f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.2f,1.8f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.1f,1.9f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (1))/fabs(cimags(out)))<1e-16); in=FloatComplex(-1.0f,2.0f); out = cfixs(in); assert ((fabs( creals(out) - (-1))/fabs(creals(out)))<1e-16); assert ((fabs( cimags(out) - (2))/fabs(cimags(out)))<1e-16); in=FloatComplex(-.9f,.9f); out = cfixs(in); assert (fabs( creals(out))<1e-16); assert (fabs( cimags(out))<1e-16); }
floatComplex catans(floatComplex z) { static float sSlim = 0.2f; /* . ** / \ WARNING : this algorithm was based on double precision ** / ! \ using float truncate the value to 0. ** `----' ** ** static float sAlim = 1E-150f; */ static float sAlim = 0.0f; static float sTol = 0.3f; static float sLn2 = 0.6931471805599453094172321f; float RMax = (float) getOverflowThreshold(); float Pi_2 = 2.0f * satans(1); float _inReal = creals(z); float _inImg = cimags(z); float _outReal = 0; float _outImg = 0; /* Temporary variables */ float R2 = 0; float S = 0; if(_inImg == 0) { _outReal = satans(_inReal); _outImg = 0; } else { R2 = _inReal * _inReal + _inImg * _inImg; /* Oo */ if(R2 > RMax) { if( dabss(_inImg) > RMax) S = 0; else S = 1.0f / (((0.5f * _inReal) / _inImg) * _inReal + 0.5f * _inImg ); } else S = (2 * _inImg) / (1+R2); if(dabss(S) < sSlim) { /* s is small: |s| < SLIM <=> |z| outside the following disks: D+ = D(center = [0; 1/slim], radius = sqrt(1/slim**2 - 1)) if b > 0 D- = D(center = [0; -1/slim], radius = sqrt(1/slim**2 - 1)) if b < 0 use the special evaluation of log((1+s)/(1-s)) (5) */ _outImg = slnp1m1s(S) * 0.25f; } else { if(sabss(S) == 1 && sabss(_inReal) <= sAlim) { /* |s| >= SLIM => |z| is inside D+ or D- */ _outImg = _sign(0.5f,_inImg) * ( sLn2 - logf(sabss(_inReal))); } else { _outImg = 0.25f * logf((powf(_inReal,2) + powf((_inImg + 1.0f),2)) / (powf(_inReal,2) + powf((_inImg - 1.0f),2))); } } if(_inReal == 0) {/* z is purely imaginary */ if( dabss(_inImg) > 1) {/* got sign(b) * pi/2 */ _outReal = _sign(1, _inImg) * Pi_2; } else if( dabss(_inImg) == 1) {/* got a Nan with 0/0 */ _outReal = (_inReal - _inReal) / (_inReal - _inReal); /* Oo */ } else _outReal = 0; } else if(R2 > RMax) {/* _outImg is necessarily very near sign(a)* pi/2 */ _outReal = _sign(1, _inReal) * Pi_2; } else if(sabss(1 - R2) + sabss(_inReal) <= sTol) {/* |b| is very near 1 (and a is near 0) some cancellation occur in the (next) generic formula */ _outReal = 0.5f * atan2f(2.0f * _inReal, (1.0f - _inImg) * (1.0f + _inImg) - powf(_inReal,2.0f)); } else _outReal = 0.5f * atan2f(2.0f * _inReal, 1.0f - R2); } return FloatComplex(_outReal, _outImg); }
floatComplex cacoshs(floatComplex z) { floatComplex acos_z = cacoss(z); float sign = localSign(-cimags(acos_z)); return FloatComplex(-sign * cimags(acos_z), sign * creals(acos_z)); }
static int cvariancefsTest(void) { printf("\n>>>> Mean Float Complex Scalar Test\n"); assert( creals(cvariancefs(FloatComplex(3.0f, 3.0f),FloatComplex(3.0f, 0.0f);)) == 0.0f );
floatComplex csigns(floatComplex in) { if ( (creals(in)==0) && (cimags(in)==0) ) return FloatComplex(0,0); return FloatComplex(creals(in) / cabss(in), cimags(in) / cabss(in)); }
static void cpowmaTest(void){ { float inR[9]={1,2,3,4,5,6,7,8,9}; float inI[9]={1,2,3,4,5,6,7,8,9}; float resultR[9]={- 4.7115011361608578610571f,- 2.0782061409646632732517f,0.5550888542315330909105f, - 2.3202132490900626571317f,- 2.4412168031527574640904f,- 2.5622203572154611528333f, 0.0710746379807356554181f,- 2.80422746534086453352f,- 5.6795295686624518438634f}; float resultI[9]={- 12.188702380084603049681f,- 4.0827818504168584823333f,4.0231386792508754268738f, - 3.0919079733956360556135f,- 2.5964710348850239540752f,- 2.1010340963744131848046f, 6.0048864332933264975622f,- 1.1101602193531934226201f,- 8.2252068719997026846613f}; floatComplex *in,out[9]; int i; in=FloatComplexMatrix(inR,inI,9); cpowma(in, 3, FloatComplex(1,1), out); for (i=0;i<9;i++) printf("out[%d] = %f+%f*i\n",i,creals(out[i]),cimags(out[i])); for (i=0;i<9;i++){ assert( (fabs(creals(out[i])-resultR[i])/ fabs(creals(out[i])) ) <3e-5); assert( (fabs(cimags(out[i])-resultI[i])/ fabs(cimags(out[i])) ) <1e-6); } } { float in1R[4]={1,5,4,2}; float in1I[4]={0}; float expand1=2.2f; float result1R[4]={ 27.93459280052221771484f , 23.580294119266994812278f , 18.864235295413593007652f , 32.650651624375619519469f }; float result1I[4]={ 3.6611113731522362257920f , - 3.6611113731522362257920f , - 2.9288890985217883589087f , 2.9288890985217883589087f }; floatComplex out1[4]; int i; float in2R[16]={ 2.5358983855694532394409f , 9.0725262500345706939697f, 0.0026536155492067337036f, 3.9639251008629798889160f , 7.9845732506364583969116f, 7.5407014600932598114014f, 10.196942830458283424377f , 8.2287722378969192504883f , 10.538597775623202323914f, 0.8204884417355060577393f, 6.7301832754164934158325f, 7.9482832476496696472168f, 8.7162081208080053329468f , 2.3821726106107234954834f , 6.5310877952724695205688f, 2.784897476434707641602f }; float in2I[16]={0}; float expand2 = 3.4683557949028909206390f; float result2R[16]={13801.893971410685480805f , 9622.6108799100766191259f , 10325.586569611912636901f, 10694.791005280343597406f , 24728.411825244897045195f , 18392.823733925368287601f , 18631.05868385956637212f , 19357.84707477861229563f , 16169.682243927050876664f , 12258.542785024719705689f , 12630.164466338968850323f , 12827.915677254180991440f , 13742.841851328515986097f , 10198.0420642120679986f , 10658.784670951883526868f , 10839.51135004585739807f }; float result2I[16]={ - 7.1981835972120027378196f , 1.9386514637886893552832f, - 17.692616672339234185074f , 24.561537532538231687340f , - 2.2418859631076406557781f , 0.6037961445855435371755f, - 5.5103941755046683681485f, 7.649730724813480264857f , - 4.865855522250573272913f , 1.310496989059492634056f , - 11.95992230200565309417f , 16.603201547139228466676f , 16.00935601900000193609f , - 4.3117212921047043394651f , 39.34984366402868971591f , - 54.626892107189902958453f }; floatComplex out2[16]; floatComplex *in1,*in2; in1=FloatComplexMatrix(in1R,in1I,4); in2=FloatComplexMatrix(in2R,in2I,16); cpowma(in1, 2, FloatComplex(expand1,0), out1); cpowma(in2, 4, FloatComplex(expand2,0), out2); for (i=0;i<4;i++) { assert( fabs(creals(out1[i])-result1R[i]) / fabs(creals(out1[i])) <1e-6); assert( fabs(cimags(out1[i])-result1I[i]) / fabs(cimags(out1[i])) <1e-6); } for (i=0;i<16;i++) { assert( fabs(creals(out2[i])-result2R[i]) / fabs(creals(out2[i])) <1e-6); assert( fabs(cimags(out2[i])-result2I[i]) / fabs(cimags(out2[i])) <1e-6); } } }