"void main" <no****@nospam.invalidwrote in message
news:61****************@aioe.org...
I'm rather new to complex numbers in C and was wondering, how do I
initialize a complex variable properly if the imaginary part is 0.
I tried
--------
#include <complex.h>
float complex c = 1.0f;
--------
and was told:
Error ctest.c: 3 invalid initialization type; found 'float' expected
'struct long double _Complex'
--------
#include <complex.h>
float complex c = 1.0f + I * 0.0f;
--------
and
--------
#include <complex.h>
float complex c = 1.0f + 0.0f * I;
--------
but both got me
Error c:\tests\clc\ctest.c 3 Compiler error (trap). Stopping compilation
What am I doing wrong?
According to a sample in the C99 standard:
24 EXAMPLE 1 Provided that <complex.hhas been #included, the declarations
int i = 3.5;
complex c = 5 + 3 * I;
define and initialize i with the value 3 and c with the value 5. 0 + i3. 0.
So I think you are doing it right. Show us the actual code you are trying
to compile.
Here are some sample C programs that use complex numbers from the standard.
If your compiler does not compile it, then you do not have a working C99
compiler.
From ISO/IEC 9899:1999 (E) ŠISO/IEC:
#include <math.h>
#include <complex.h>
/* Multiplyz * w... */
double complex _Cmultd(double complex z, double complex w)
{
#pragma STDC FP_CONTRACT OFF
double a,
b,
c,
d,
ac,
bd,
ad,
bc,
x,
y;
a = creal(z);
b = cimag(z)
c = creal(w);
d = cimag(w);
ac = a * c;
bd = b * d;
ad = a * d;
bc = b * c;
x = ac - bd;
y = ad + bc;
if (isnan(x) && isnan(y)) {
/* Recover infinities that computed as NaN+iNaN ... */
int recalc = 0;
if (isinf(a) || isinf(b)) { // z is infinite
/* "Box" the infinity and change NaNs in the other factor to 0
*/
a = copysign(isinf(a) ? 1.0 : 0.0, a);
b = copysign(isinf(b) ? 1.0 : 0.0, b);
if (isnan(c))
c = copysign(0.0, c);
if (isnan(d))
d = copysign(0.0, d);
recalc = 1;
}
if (isinf(c) || isinf(d)) { // w is infinite
/* "Box" the infinity and change NaNs in the other factor to 0
*/
c = copysign(isinf(c) ? 1.0 : 0.0, c);
d = copysign(isinf(d) ? 1.0 : 0.0, d);
if (isnan(a))
a = copysign(0.0, a);
if (isnan(b))
b = copysign(0.0, b);
recalc = 1;
}
if (!recalc && (isinf(ac) || isinf(bd) ||
isinf(ad) || isinf(bc))) {
/* Recover infinities from overflow by changing NaNs to 0 ... */
if (isnan(a))
a = copysign(0.0, a);
if (isnan(b))
b = copysign(0.0, b);
if (isnan(c))
c = copysign(0.0, c);
if (isnan(d))
d = copysign(0.0, d);
recalc = 1;
}
if (recalc) {
x = INFINITY * (a * c - b * d);
y = INFINITY * (a * d + b * c);
}
}
return x + I * y;
}
/*
7 This implementation achieves the required treatment of infinities at
the cost of only one isnan test in ordinary (finite) cases. It is less than
ideal in that undue overflow and underflow may occur.
468 IEC60559-compatible complexarithmetic §G.5.1
ŠISO/IEC ISO/IEC 9899:1999 (E)
8 EXAMPLE 2 Division of two double _Complex operands could be implemented
as follows.
*/
#include <math.h>
#include <complex.h>
/* Dividez / w ... */
double complex _Cdivd(double complex z, double complex w)
{
#pragma STDC FP_CONTRACT OFF
double a,
b,
c,
d,
logbw,
denom,
x,
y;
int ilogbw = 0;
a = creal(z);
b = cimag(z);
c = creal(w);
d = cimag(w);
logbw = logb(fmax(fabs(c), fabs(d)));
if (isfinite(logbw)) {
ilogbw = (int) logbw;
c = scalbn(c, -ilogbw);
d = scalbn(d, -ilogbw);
}
denom = c * c + d * d;
x = scalbn((a * c + b * d) / denom, -ilogbw);
y = scalbn((b * c - a * d) / denom, -ilogbw);
/* Recover infinities and zeros that computed as NaN+iNaN; */
/* the only cases are non-zero/zero, infinite/finite, and finite/infinite,
.... */
if (isnan(x) && isnan(y)) {
if ((denom == 0.0) &&
(!isnan(a) || !isnan(b))) {
x = copysign(INFINITY, c) * a;
y = copysign(INFINITY, c) * b;
} else if ((isinf(a) || isinf(b)) &&
isfinite(c) && isfinite(d)) {
a = copysign(isinf(a) ? 1.0 : 0.0, a);
b = copysign(isinf(b) ? 1.0 : 0.0, b);
x = INFINITY * (a * c + b * d);
y = INFINITY * (b * c - a * d);
} else if (isinf(logbw) &&
isfinite(a) && isfinite(b)) {
c = copysign(isinf(c) ? 1.0 : 0.0, c);
d = copysign(isinf(d) ? 1.0 : 0.0, d);
x = 0.0 * (a * c + b * d);
y = 0.0 * (b * c - a * d);
}
}
return x + I * y;
}
/*
9 Scaling the denominator alleviates the main overflow and underflow
problem, which is more serious than for multiplication. In the spirit of the
multiplication example above, this code does not defend against overflow
and underflow in the calculation of the numerator. Scaling with the scalbn
function, instead of with division, provides better roundoff
characteristics.
§G.5.1 IEC60559-compatible complex arithmetic 469
*/
** Posted from
http://www.teranews.com **
