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