#pragma option nomaf
#pragma STDC FENV_ACCESS ON
#include "math.h"
#include "complex.h"
#include "fenv.h"
#include "fp_private.h"
#define Real(z) (__real__ z)
#define Imag(z) (__imag__ z)
static const
hexdouble FPKLOVERE = HEXDOUBLE(0x03600000,0x00000000);
static const
hexsingle FPKLOVEREf = { 0xc000000 };
static const
hexdouble FPKEXP709 = HEXDOUBLE(0x7fdd422d,0x2be5dc9b);
static const
hexdouble FPKASINHOM4 = HEXDOUBLE(0x406633ce,0x8fb9f87e);
static const
hexsingle FPKASINHOM4f = { 0x41b2d4fc };
static const
hexdouble FPKTHETA = HEXDOUBLE(0x5fcfffff,0xffffffff);
static const
hexsingle FPKTHETAf = { 0x5e7fffff };
static const
hexdouble FPKRHO = HEXDOUBLE(0x20100000,0x00000000);
static const
hexsingle FPKRHOf = { 0x20800001 };
static
double complex xdivc( double x, double complex y )
{
double complex z;
double r, denom;
if ( fabs(Real(y)) >= fabs(Imag(y)) ) {
if (fabs(Real(y)) == INFINITY) {
Real(z) = copysign(0.0,Real(y));
Imag(z) = copysign(0.0,-Imag(y));
}
else {
r = Imag(y)/Real(y);
denom = Real(y) + Imag(y)*r;
Real(z) = x/denom;
Imag(z) = (-x*r)/denom;
}
}
else {
r = Real(y)/Imag(y);
denom = r*Real(y) + Imag(y);
Real(z) = (r*x)/denom;
Imag(z) = -x/denom;
}
return z;
}
static
float complex xdivcf( float x, float complex y )
{
float complex z;
float r, denom;
if ( fabsf(Real(y)) >= fabsf(Imag(y)) ) {
if (fabsf(Real(y)) == INFINITY) {
Real(z) = copysignf(0.0f,Real(y));
Imag(z) = copysignf(0.0f,-Imag(y));
}
else {
r = Imag(y)/Real(y);
denom = Real(y) + Imag(y)*r;
Real(z) = x/denom;
Imag(z) = (-x*r)/denom;
}
}
else {
r = Real(y)/Imag(y);
denom = r*Real(y) + Imag(y);
Real(z) = (r*x)/denom;
Imag(z) = -x/denom;
}
return z;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static
long double complex xdivcl( long double x, long double complex y )
{
long double complex z;
long double r, denom;
if ( fabsl(Real(y)) >= fabsl(Imag(y)) ) {
if (fabsl(Real(y)) == INFINITY) {
Real(z) = copysignl(0.0L,Real(y));
Imag(z) = copysignl(0.0L,-Imag(y));
}
else {
r = Imag(y)/Real(y);
denom = Real(y) + Imag(y)*r;
Real(z) = x/denom;
Imag(z) = (-x*r)/denom;
}
}
else {
r = Real(y)/Imag(y);
denom = r*Real(y) + Imag(y);
Real(z) = (r*x)/denom;
Imag(z) = -x/denom;
}
return z;
}
#endif
extern double cabs( double complex );
float cabsf( float complex z ){ return (float) cabs((double complex) z); }
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static const long double FPKEXP709L = 8.2184074615549721892413723865978e+307L;
#define M_FPKT2P1Q -.0000000000000000000000000000000000014303281246230519268233202620092676L
long double cabsl ( long double complex z )
{
long double a,b,s,t;
fenv_t env;
long double FPR_inf = INFINITY;
a = fabsl(Real(z));
b = fabsl(Imag(z));
if (unlikely( (a == FPR_inf) || (b == FPR_inf) ))
return FPR_inf;
if (unlikely( (a != a) || (b != b) ))
return __FABS ( a + b );
if (unlikely((a == 0.0L) || (b == 0.0L) ))
return __FABS ( a + b );
{
(void)feholdexcept(&env);
(void)fesetround(FE_TONEAREST);
s = 0.0L;
if (a < b)
{
t = a;
a = b;
b = t;
}
t = a - b;
if (t != a)
{
if (t > b)
{
s = a/b;
s += sqrtl(1.0L + s*s);
}
else
{
s = t/b;
t = (2.0L + s)*s;
s = ((M_FPKT2P1Q+t/(M_SQRT2+sqrt(2.0L+t)))+s)+(1.0L + M_SQRT2);
}
s = b/s;
feclearexcept(FE_UNDERFLOW);
}
feupdateenv(&env);
return (a + s);
}
}
#endif
double carg ( double complex z )
{
double a,b,argr;
int clre,clim;
a = Real(z);
b = Imag(z);
clre = fpclassify(a);
clim = fpclassify(b);
if ((clre == FP_ZERO) && (clim == FP_ZERO)) {
a = copysign(1.0, a);
}
if ((clre == FP_INFINITE) && (clim == FP_INFINITE)) {
a = copysign(1.0, a);
b = copysign(1.0, b);
}
if (fabs(b) > fabs(a))
argr = copysign(M_PI_2, b) - atan(a/b);
else {
if (a < 0.0)
argr = copysign(M_PI, b) + atan(b/a);
else
argr = atan(b/a);
}
return argr;
}
float cargf ( float complex z )
{
float a,b,argr;
int clre,clim;
a = Real(z);
b = Imag(z);
clre = fpclassify(a);
clim = fpclassify(b);
if ((clre == FP_ZERO) && (clim == FP_ZERO)) {
a = copysignf(1.0f, a);
}
if ((clre == FP_INFINITE) && (clim == FP_INFINITE)) {
a = copysignf(1.0f, a);
b = copysignf(1.0f, b);
}
if (fabsf(b) > fabsf(a))
argr = copysignf((float) M_PI_2, b) - atanf(a/b);
else {
if (a < 0.0f)
argr = copysignf((float) M_PI, b) + atanf(b/a);
else
argr = atanf(b/a);
}
return argr;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double cargl ( long double complex z )
{
long double a,b,argr;
int clre,clim;
a = Real(z);
b = Imag(z);
clre = fpclassify(a);
clim = fpclassify(b);
if ((clre == FP_ZERO) && (clim == FP_ZERO)) {
a = copysignl(1.0L, a);
}
if ((clre == FP_INFINITE) && (clim == FP_INFINITE)) {
a = copysignl(1.0L, a);
b = copysignl(1.0L, b);
}
if (fabsl(b) > fabsl(a))
argr = copysignl(M_PI_2, b) - atanl(a/b);
else {
if (a < 0.0L)
argr = copysignl(M_PI, b) + atanl(b/a);
else
argr = atanl(b/a);
}
return argr;
}
#endif
static double cssqs ( double complex z, int *k)
{
double a,b,rho;
fenv_t env;
int iscale;
iscale = 0;
a = fabs(Real(z));
b = fabs(Imag(z));
(void)feholdexcept(&env);
rho = a*a + b*b;
if ((a == INFINITY) || (b == INFINITY)) {
rho = INFINITY;
}
else if (fetestexcept(FE_OVERFLOW) || (fetestexcept(FE_UNDERFLOW) && (rho < FPKLOVERE.d))) {
iscale = ilogb(fmax(a,b));
a = scalbn(a,-iscale);
b = scalbn(b,-iscale);
rho = a*a + b*b;
}
feclearexcept(FE_OVERFLOW + FE_UNDERFLOW);
feupdateenv(&env);
*k = iscale;
return (rho);
}
static float cssqsf ( float complex z, int *k)
{
float a,b,rho;
fenv_t env;
int iscale;
iscale = 0;
a = fabsf(Real(z));
b = fabsf(Imag(z));
(void)feholdexcept(&env);
rho = a*a + b*b;
if ((a == INFINITY) || (b == INFINITY)) {
rho = INFINITY;
}
else if (fetestexcept(FE_OVERFLOW) || (fetestexcept(FE_UNDERFLOW) && (rho < FPKLOVEREf.fval))) {
iscale = logbf(fmaxf(a,b));
a = scalbnf(a,-iscale);
b = scalbnf(b,-iscale);
rho = a*a + b*b;
}
feclearexcept(FE_OVERFLOW + FE_UNDERFLOW);
feupdateenv(&env);
*k = iscale;
return (rho);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static long double cssqsl ( long double complex z, int *k)
{
long double a,b,rho;
fenv_t env;
int iscale;
iscale = 0;
a = fabsl(Real(z));
b = fabsl(Imag(z));
(void)feholdexcept(&env);
rho = a*a + b*b;
if ((a == INFINITY) || (b == INFINITY)) {
rho = INFINITY;
}
else if (fetestexcept(FE_OVERFLOW) || (fetestexcept(FE_UNDERFLOW) && (rho < FPKLOVERE.d))) {
iscale = logbl(fmaxl(a,b));
a = scalbnl(a,-iscale);
b = scalbnl(b,-iscale);
rho = a*a + b*b;
}
feclearexcept(FE_OVERFLOW + FE_UNDERFLOW);
feupdateenv(&env);
*k = iscale;
return (rho);
}
#endif
double complex csqrt ( double complex z )
{
double rho,x,y;
double complex w;
int k;
rho = cssqs(z,&k);
if (Real(z) == Real(z))
rho = scalbn(fabs(Real(z)),-k) + sqrt(rho);
if (k%2)
k = (k-1)/2;
else {
k = k/2 - 1;
rho = rho + rho;
}
rho = scalbn(sqrt(rho),k);
x = rho;
y = Imag(z);
if (rho != 0.0) {
if (fabs(y) != INFINITY)
y = (y/rho)*0.5;
if (Real(z) < 0.0) {
x = fabs(y);
y = copysign(rho,Imag(z));
}
}
Real(w) = x;
Imag(w) = y;
return w;
}
float complex csqrtf ( float complex z )
{
float rho,x,y;
float complex w;
int k;
rho = cssqsf(z,&k);
if (Real(z) == Real(z))
rho = scalbnf(fabsf(Real(z)),-k) + sqrtf(rho);
if (k%2)
k = (k-1)/2;
else {
k = k/2 - 1;
rho = rho + rho;
}
rho = scalbnf(sqrtf(rho),k);
x = rho;
y = Imag(z);
if (rho != 0.0f) {
if (fabsf(y) != INFINITY)
y = (y/rho)*0.5f;
if (Real(z) < 0.0f) {
x = fabsf(y);
y = copysignf(rho,Imag(z));
}
}
Real(w) = x;
Imag(w) = y;
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex csqrtl ( long double complex z )
{
long double rho,x,y;
long double complex w;
int k;
rho = cssqsl(z,&k);
if (Real(z) == Real(z))
rho = scalbnl(fabsl(Real(z)),-k) + sqrtl(rho);
if (k%2)
k = (k-1)/2;
else {
k = k/2 - 1;
rho = rho + rho;
}
rho = scalbnl(sqrtl(rho),k);
x = rho;
y = Imag(z);
if (rho != 0.0L) {
if (fabsl(y) != INFINITY)
y = (y/rho)*0.5L;
if (Real(z) < 0.0L) {
x = fabsl(y);
y = copysignl(rho,Imag(z));
}
}
Real(w) = x;
Imag(w) = y;
return w;
}
#endif
double complex clog ( double complex z )
{
double rho,dmax,dmin,temp;
double complex w;
int k;
dmax = fabs(Real(z));
dmin = fabs(Imag(z));
if (dmax < dmin) {
temp = dmax;
dmax = dmin;
dmin = temp;
}
rho = cssqs(z,&k);
if ((k == 0) && (dmax > M_SQRT1_2) && ((dmax <= 1.25) || (rho < 3.0)))
Real(w) = log1p((dmax - 1.0)*(dmax + 1.0) + dmin*dmin)*0.5;
else
Real(w) = log(rho)*0.5 + k*M_LN2;
Imag(w) = carg(z);
return w;
}
float complex clogf ( float complex z )
{
float rho,dmax,dmin,temp;
float complex w;
int k;
dmax = fabsf(Real(z));
dmin = fabsf(Imag(z));
if (dmax < dmin) {
temp = dmax;
dmax = dmin;
dmin = temp;
}
rho = cssqsf(z,&k);
if ((k == 0) && (dmax > M_SQRT1_2) && ((dmax <= 1.25f) || (rho < 3.0f)))
Real(w) = log1pf((dmax - 1.0f)*(dmax + 1.0f) + dmin*dmin)*0.5f;
else
Real(w) = logf(rho)*0.5f + (float)((double)k*M_LN2);
Imag(w) = cargf(z);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex clogl ( long double complex z )
{
long double rho,dmax,dmin,temp;
long double complex w;
int k;
dmax = fabsl(Real(z));
dmin = fabsl(Imag(z));
if (dmax < dmin) {
temp = dmax;
dmax = dmin;
dmin = temp;
}
rho = cssqsl(z,&k);
if ((k == 0) && (dmax > M_SQRT1_2) && ((dmax <= 1.25L) || (rho < 3.0L)))
Real(w) = log1pl((dmax - 1.0L)*(dmax + 1.0L) + dmin*dmin)*0.5L;
else
Real(w) = logl(rho)*0.5L + k*M_LN2;
Imag(w) = cargl(z);
return w;
}
#endif
static double coshmul ( double x, double y )
{
double absx, result;
absx = fabs(x);
if (absx <= 709.0) {
return y*cosh(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*absx);
}
else if (absx > 1460.0) {
return (scalbn(y,2100));
}
else {
result = (0.5 * FPKEXP709.d) * y;
absx -= 709.0;
while (absx > 709.0) {
result *= FPKEXP709.d;
absx -= 709.0;
}
return (result*exp(absx));
}
}
static float coshmulf ( float x, float y )
{
float absx;
absx = fabsf(x);
if (absx <= 89.0f) {
return y*coshf(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*absx);
}
return (float)coshmul((double)x, (double)y);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static long double coshmull ( long double x, long double y )
{
long double absx, result;
absx = fabsl(x);
if (absx <= 709.0L) {
return y*coshl(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*absx);
}
else if (absx > 1460.0L) {
return (scalbnl(y,2100));
}
else {
long double t = FPKEXP709L;
result = (0.5L * t) * y;
absx -= 709.0L;
while (absx > 709.0L) {
result *= t;
absx -= 709.0L;
}
return (result*expl(absx));
}
}
#endif
static double sinhmul ( double x, double y )
{
double absx, result;
absx = fabs(x);
if (absx <= 709.0) {
return y*sinh(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*x);
}
else if (absx > 1460.0) {
return (scalbn(y,2100));
}
else {
result = (0.5*FPKEXP709.d)*y;
absx -= 709.0;
if (signbit(x) != 0) result = -result;
while (absx > 709.0) {
result *= FPKEXP709.d;
absx -= 709.0;
}
return (result*exp(absx));
}
}
static float sinhmulf ( float x, float y )
{
float absx;
absx = fabsf(x);
if (absx <= 709.0f) {
return y*sinhf(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*x);
}
return (float)sinhmul((double)x, (double)y);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static long double sinhmull ( long double x, long double y )
{
long double absx, result;
absx = fabsl(x);
if (absx <= 709.0L) {
return y*sinhl(x);
}
else if (fpclassify(x) < FP_ZERO) {
return (y*x);
}
else if (absx > 1460.0L) {
return (scalbnl(y,2100));
}
else {
long double t = FPKEXP709L;
result = (0.5L*t)*y;
absx -= 709.0L;
if (signbit(x) != 0) result = -result;
while (absx > 709.0L) {
result *= t;
absx -= 709.0L;
}
return (result*expl(absx));
}
}
#endif
double complex csin ( double complex z )
{
fenv_t env;
double sinval, cosval;
double complex w;
(void)feholdexcept(&env);
sinval = sin(Real(z));
cosval = cos(Real(z));
Real(w) = coshmul(Imag(z),sinval);
Imag(w) = sinhmul(Imag(z),cosval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
float complex csinf ( float complex z )
{
fenv_t env;
float sinval, cosval;
float complex w;
(void)feholdexcept(&env);
sinval = sinf(Real(z));
cosval = cosf(Real(z));
Real(w) = coshmulf(Imag(z),sinval);
Imag(w) = sinhmulf(Imag(z),cosval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex csinl ( long double complex z )
{
fenv_t env;
long double sinval, cosval;
long double complex w;
(void)feholdexcept(&env);
sinval = sinl(Real(z));
cosval = cosl(Real(z));
Real(w) = coshmull(Imag(z),sinval);
Imag(w) = sinhmull(Imag(z),cosval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#endif
double complex ccos ( double complex z )
{
fenv_t env;
double sinval, cosval;
double complex w;
(void)feholdexcept(&env);
sinval = sin(Real(z));
cosval = cos(Real(z));
Real(w) = coshmul(Imag(z),cosval);
Imag(w) = sinhmul(Imag(z),-sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
float complex ccosf ( float complex z )
{
fenv_t env;
float sinval, cosval;
float complex w;
(void)feholdexcept(&env);
sinval = sinf(Real(z));
cosval = cosf(Real(z));
Real(w) = coshmulf(Imag(z),cosval);
Imag(w) = sinhmulf(Imag(z),-sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex ccosl ( long double complex z )
{
fenv_t env;
long double sinval, cosval;
long double complex w;
(void)feholdexcept(&env);
sinval = sinl(Real(z));
cosval = cosl(Real(z));
Real(w) = coshmull(Imag(z),cosval);
Imag(w) = sinhmull(Imag(z),-sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#endif
double complex csinh ( double complex z )
{
fenv_t env;
double sinval, cosval;
double complex w;
(void)feholdexcept(&env);
sinval = sin(Imag(z));
cosval = cos(Imag(z));
Real(w) = sinhmul(Real(z),cosval);
Imag(w) = coshmul(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
float complex csinhf ( float complex z )
{
fenv_t env;
float sinval, cosval;
float complex w;
(void)feholdexcept(&env);
sinval = sinf(Imag(z));
cosval = cosf(Imag(z));
Real(w) = sinhmulf(Real(z),cosval);
Imag(w) = coshmulf(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex csinhl ( long double complex z )
{
fenv_t env;
long double sinval, cosval;
long double complex w;
(void)feholdexcept(&env);
sinval = sinl(Imag(z));
cosval = cosl(Imag(z));
Real(w) = sinhmull(Real(z),cosval);
Imag(w) = coshmull(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#endif
double complex ccosh ( double complex z )
{
fenv_t env;
double sinval, cosval;
double complex w;
(void)feholdexcept(&env);
sinval = sin(Imag(z));
cosval = cos(Imag(z));
Real(w) = coshmul(Real(z),cosval);
Imag(w) = sinhmul(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
float complex ccoshf ( float complex z )
{
fenv_t env;
float sinval, cosval;
float complex w;
(void)feholdexcept(&env);
sinval = sinf(Imag(z));
cosval = cosf(Imag(z));
Real(w) = coshmulf(Real(z),cosval);
Imag(w) = sinhmulf(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex ccoshl ( long double complex z )
{
fenv_t env;
long double sinval, cosval;
long double complex w;
(void)feholdexcept(&env);
sinval = sinl(Imag(z));
cosval = cosl(Imag(z));
Real(w) = coshmull(Real(z),cosval);
Imag(w) = sinhmull(Real(z),sinval);
feclearexcept(FE_UNDERFLOW);
feupdateenv(&env);
return w;
}
#endif
double complex cexp ( double complex z )
{
double sinval, cosval, expval, exparg;
double complex w;
sinval = sin(Imag(z));
cosval = cos(Imag(z));
if (Real(z) <= 709.0) {
expval = exp(Real(z));
Real(w) = cosval*expval;
Imag(w) = sinval*expval;
}
else if (fpclassify(Real(z)) < FP_ZERO) {
Real(w) = cosval*Real(z);
Imag(w) = sinval*Real(z);
}
else if (Real(z) > 1460.0) {
Real(w) = scalbn(cosval,2100);
Imag(w) = scalbn(sinval,2100);
}
else {
Real(w) = cosval*FPKEXP709.d;
Imag(w) = sinval*FPKEXP709.d;
exparg = Real(z) - 709.0;
while (exparg > 709.0) {
Real(w) *= FPKEXP709.d;
Imag(w) *= FPKEXP709.d;
exparg -= 709.0;
}
expval = exp(exparg);
Real(w) *= expval;
Imag(w) *= expval;
}
return w;
}
float complex cexpf ( float complex z )
{
float sinval, cosval, expval;
float complex w;
sinval = sinf(Imag(z));
cosval = cosf(Imag(z));
if (Real(z) <= 88.0f) {
expval = expf(Real(z));
Real(w) = cosval*expval;
Imag(w) = sinval*expval;
}
else w = (float complex)cexp((double complex)z);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex cexpl ( long double complex z )
{
long double sinval, cosval, expval, exparg;
long double complex w;
sinval = sinl(Imag(z));
cosval = cosl(Imag(z));
if (Real(z) <= 709.0L) {
expval = expl(Real(z));
Real(w) = cosval*expval;
Imag(w) = sinval*expval;
}
else if (fpclassify(Real(z)) < FP_ZERO) {
Real(w) = cosval*Real(z);
Imag(w) = sinval*Real(z);
}
else if (Real(z) > 1460.0L) {
Real(w) = scalbnl(cosval,2100);
Imag(w) = scalbnl(sinval,2100);
}
else {
long double t = FPKEXP709L;
Real(w) = cosval*t;
Imag(w) = sinval*t;
exparg = Real(z) - 709.0L;
while (exparg > 709.0) {
Real(w) *= t;
Imag(w) *= t;
exparg -= 709.0L;
}
expval = expl(exparg);
Real(w) *= expval;
Imag(w) *= expval;
}
return w;
}
#endif
double complex cpow ( double complex x, double complex y )
{
double complex logval,z;
logval = clog(x);
Real(z) = Real(y)*Real(logval) - Imag(y)*Imag(logval);
Imag(z) = Real(y)*Imag(logval) + Imag(y)*Real(logval);
return (cexp(z));
}
float complex cpowf ( float complex x, float complex y )
{
float complex logval,z;
logval = clogf(x);
Real(z) = Real(y)*Real(logval) - Imag(y)*Imag(logval);
Imag(z) = Real(y)*Imag(logval) + Imag(y)*Real(logval);
return (cexpf(z));
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex cpowl ( long double complex x, long double complex y )
{
long double complex logval,z;
logval = clogl(x);
Real(z) = Real(y)*Real(logval) - Imag(y)*Imag(logval);
Imag(z) = Real(y)*Imag(logval) + Imag(y)*Real(logval);
return (cexpl(z));
}
#endif
double complex ctanh( double complex z )
{
fenv_t env;
double tanval, beta, sinhval, coshval, denom;
double complex w;
(void)feholdexcept(&env);
if (fabs(Real(z)) > FPKASINHOM4.d) {
Real(w) = copysign(1.0,Real(z));
Imag(w) = copysign(0.0,Imag(z));
if (fabs(Real(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tan(Imag(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0 + tanval*tanval;
sinhval = sinh(Real(z));
coshval = sqrt(1.0+sinhval*sinhval);
if (fabs(tanval) == INFINITY) {
Real(w) = coshval/sinhval;
Imag(w) = 1.0/tanval;
}
else {
denom = 1.0 + beta*sinhval*sinhval;
Real(w) = beta*coshval*sinhval/denom;
Imag(w) = tanval/denom;
}
}
return w;
}
float complex ctanhf( float complex z )
{
fenv_t env;
float tanval, beta, sinhval, coshval, denom;
float complex w;
(void)feholdexcept(&env);
if (fabsf(Real(z)) > FPKASINHOM4f.fval) {
Real(w) = copysignf(1.0f,Real(z));
Imag(w) = copysignf(0.0f,Imag(z));
if (fabsf(Real(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tanf(Imag(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0f + tanval*tanval;
sinhval = sinhf(Real(z));
coshval = sqrtf(1.0f+sinhval*sinhval);
if (fabs(tanval) == INFINITY) {
Real(w) = coshval/sinhval;
Imag(w) = 1.0f/tanval;
}
else {
denom = 1.0f + beta*sinhval*sinhval;
Real(w) = beta*coshval*sinhval/denom;
Imag(w) = tanval/denom;
}
}
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex ctanhl( long double complex z )
{
fenv_t env;
long double tanval, beta, sinhval, coshval, denom;
long double complex w;
(void)feholdexcept(&env);
if (fabsl(Real(z)) > FPKASINHOM4.d) {
Real(w) = copysignl(1.0L,Real(z));
Imag(w) = copysignl(0.0L,Imag(z));
if (fabsl(Real(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tanl(Imag(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0L + tanval*tanval;
sinhval = sinhl(Real(z));
coshval = sqrtl(1.0L+sinhval*sinhval);
if (fabsl(tanval) == INFINITY) {
Real(w) = coshval/sinhval;
Imag(w) = 1.0L/tanval;
}
else {
denom = 1.0L + beta*sinhval*sinhval;
Real(w) = beta*coshval*sinhval/denom;
Imag(w) = tanval/denom;
}
}
return w;
}
#endif
double complex ctan( double complex z )
{
fenv_t env;
double tanval, beta, sinhval, coshval, denom;
double complex w;
(void)feholdexcept(&env);
if (fabs(Imag(z)) > FPKASINHOM4.d) {
Real(w) = copysign(0.0,Real(z));
Imag(w) = copysign(1.0,Imag(z));
if (fabs(Imag(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tan(Real(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0 + tanval*tanval;
sinhval = sinh(Imag(z));
coshval = sqrt(1.0+sinhval*sinhval);
if (fabs(tanval) == INFINITY) {
Real(w) = 1.0/tanval;
Imag(w) = coshval/sinhval;
}
else {
denom = 1.0 + beta*sinhval*sinhval;
Real(w) = tanval/denom;
Imag(w) = beta*coshval*sinhval/denom;
}
}
return w;
}
float complex ctanf( float complex z )
{
fenv_t env;
float tanval, beta, sinhval, coshval, denom;
float complex w;
(void)feholdexcept(&env);
if (fabsf(Imag(z)) > FPKASINHOM4f.fval) {
Real(w) = copysignf(0.0f,Real(z));
Imag(w) = copysignf(1.0f,Imag(z));
if (fabsf(Imag(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tanf(Real(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0f + tanval*tanval;
sinhval = sinhf(Imag(z));
coshval = sqrtf(1.0f+sinhval*sinhval);
if (fabsf(tanval) == INFINITY) {
Real(w) = 1.0f/tanval;
Imag(w) = coshval/sinhval;
}
else {
denom = 1.0f + beta*sinhval*sinhval;
Real(w) = tanval/denom;
Imag(w) = beta*coshval*sinhval/denom;
}
}
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex ctanl( long double complex z )
{
fenv_t env;
long double tanval, beta, sinhval, coshval, denom;
long double complex w;
(void)feholdexcept(&env);
if (fabsl(Imag(z)) > FPKASINHOM4.d) {
Real(w) = copysignl(0.0L,Real(z));
Imag(w) = copysignl(1.0L,Imag(z));
if (fabsl(Imag(z)) != INFINITY)
feraiseexcept(FE_INEXACT);
feupdateenv(&env);
}
else {
tanval = tanl(Real(z));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
beta = 1.0L + tanval*tanval;
sinhval = sinhl(Imag(z));
coshval = sqrtl(1.0L+sinhval*sinhval);
if (fabsl(tanval) == INFINITY) {
Real(w) = 1.0L/tanval;
Imag(w) = coshval/sinhval;
}
else {
denom = 1.0L + beta*sinhval*sinhval;
Real(w) = tanval/denom;
Imag(w) = beta*coshval*sinhval/denom;
}
}
return w;
}
#endif
double complex casin ( double complex z )
{
double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0 + Real(z);
Imag(zp1) = Imag(z);
zp1 = csqrt(zp1);
Real(zm) = 1.0 - Real(z);
Imag(zm) = -Imag(z);
zm1 = csqrt(zm);
(void)feholdexcept(&env);
Real(w) = atan(Real(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = Imag(z);
zm1 = csqrt(zm);
Imag(w) = asinh(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
float complex casinf ( float complex z )
{
float complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0f + Real(z);
Imag(zp1) = Imag(z);
zp1 = csqrtf(zp1);
Real(zm) = 1.0f - Real(z);
Imag(zm) = -Imag(z);
zm1 = csqrtf(zm);
(void)feholdexcept(&env);
Real(w) = atanf(Real(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = Imag(z);
zm1 = csqrtf(zm);
Imag(w) = asinhf(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex casinl ( long double complex z )
{
long double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0L + Real(z);
Imag(zp1) = Imag(z);
zp1 = csqrtl(zp1);
Real(zm) = 1.0L - Real(z);
Imag(zm) = -Imag(z);
zm1 = csqrtl(zm);
(void)feholdexcept(&env);
Real(w) = atanl(Real(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = Imag(z);
zm1 = csqrtl(zm);
Imag(w) = asinhl(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
#endif
double complex casinh ( double complex z )
{
double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0 - Imag(z);
Imag(zp1) = Real(z);
zp1 = csqrt(zp1);
Real(zm) = 1.0 + Imag(z);
Imag(zm) = Real(z);
zm1 = csqrt(zm);
Real(w) = asinh(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
Imag(zm) = -Real(z);
zm1 = csqrt(zm);
(void)feholdexcept(&env);
Imag(w) = atan(Imag(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
return w;
}
float complex casinhf ( float complex z )
{
float complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0f - Imag(z);
Imag(zp1) = Real(z);
zp1 = csqrt(zp1);
Real(zm) = 1.0f + Imag(z);
Imag(zm) = Real(z);
zm1 = csqrtf(zm);
Real(w) = asinhf(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
Imag(zm) = -Real(z);
zm1 = csqrtf(zm);
(void)feholdexcept(&env);
Imag(w) = atanf(Imag(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex casinhl ( long double complex z )
{
long double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = 1.0L - Imag(z);
Imag(zp1) = Real(z);
zp1 = csqrtl(zp1);
Real(zm) = 1.0L + Imag(z);
Imag(zm) = Real(z);
zm1 = csqrtl(zm);
Real(w) = asinhl(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
Imag(zm) = -Real(z);
zm1 = csqrtl(zm);
(void)feholdexcept(&env);
Imag(w) = atanl(Imag(z)/(Real(zp1)*Real(zm1) -Imag(zp1)*Imag(zm1)));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
return w;
}
#endif
double complex cacos ( double complex z )
{
double complex zp, zp1, zm1, w;
fenv_t env;
Real(zp) = 1.0 + Real(z);
Imag(zp) = Imag(z);
zp1 = csqrt(zp);
Real(zm1) = 1.0 - Real(z);
Imag(zm1) = -Imag(z);
zm1 = csqrt(zm1);
(void)feholdexcept(&env);
Real(w) = 2.0*atan(Real(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zp) = -Imag(z);
zp1 = csqrt(zp);
Imag(w) = asinh(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
float complex cacosf ( float complex z )
{
float complex zp, zp1, zm1, w;
fenv_t env;
Real(zp) = 1.0f + Real(z);
Imag(zp) = Imag(z);
zp1 = csqrtf(zp);
Real(zm1) = 1.0f - Real(z);
Imag(zm1) = -Imag(z);
zm1 = csqrtf(zm1);
(void)feholdexcept(&env);
Real(w) = 2.0f*atanf(Real(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zp) = -Imag(z);
zp1 = csqrtf(zp);
Imag(w) = asinhf(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex cacosl ( long double complex z )
{
long double complex zp, zp1, zm1, w;
fenv_t env;
Real(zp) = 1.0L + Real(z);
Imag(zp) = Imag(z);
zp1 = csqrtl(zp);
Real(zm1) = 1.0L - Real(z);
Imag(zm1) = -Imag(z);
zm1 = csqrtl(zm1);
(void)feholdexcept(&env);
Real(w) = 2.0L*atanl(Real(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zp) = -Imag(z);
zp1 = csqrtl(zp);
Imag(w) = asinhl(Real(zp1)*Imag(zm1) + Imag(zp1)*Real(zm1));
return w;
}
#endif
double complex cacosh ( double complex z )
{
double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = Real(z) + 1.0;
Imag(zp1) = Imag(z);
zp1 = csqrt(zp1);
Real(zm) = Real(z) - 1.0;
Imag(zm) = Imag(z);
zm1 = csqrt(zm);
(void)feholdexcept(&env);
Imag(w) = 2.0*atan(Imag(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = -Imag(z);
zm1 = csqrt(zm);
Real(w) = asinh(Real(zp1)*Real(zm1) - Imag(zp1)*Imag(zm1));
return w;
}
float complex cacoshf ( float complex z )
{
float complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = Real(z) + 1.0f;
Imag(zp1) = Imag(z);
zp1 = csqrtf(zp1);
Real(zm) = Real(z) - 1.0f;
Imag(zm) = Imag(z);
zm1 = csqrtf(zm);
(void)feholdexcept(&env);
Imag(w) = 2.0f*atanf(Imag(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = -Imag(z);
zm1 = csqrtf(zm);
Real(w) = asinhf(Real(zp1)*Real(zm1) - Imag(zp1)*Imag(zm1));
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex cacoshl ( long double complex z )
{
long double complex zp1, zm, zm1, w;
fenv_t env;
Real(zp1) = Real(z) + 1.0L;
Imag(zp1) = Imag(z);
zp1 = csqrtl(zp1);
Real(zm) = Real(z) - 1.0L;
Imag(zm) = Imag(z);
zm1 = csqrtl(zm);
(void)feholdexcept(&env);
Imag(w) = 2.0L*atanl(Imag(zm1)/Real(zp1));
feclearexcept(FE_DIVBYZERO);
feupdateenv(&env);
Imag(zm) = -Imag(z);
zm1 = csqrtl(zm);
Real(w) = asinhl(Real(zp1)*Real(zm1) - Imag(zp1)*Imag(zm1));
return w;
}
#endif
double complex catan ( double complex z )
{
double complex ctemp, w;
double t1, t2, xi, eta, beta;
xi = -Imag(z);
beta = copysign(1.0,xi);
Imag(z) = -beta*Real(z);
Real(z) = beta*xi;
if ((Real(z) > FPKTHETA.d) || (fabs(Imag(z)) > FPKTHETA.d)) {
xi = copysign(M_PI_2,Imag(z));
ctemp = xdivc(1.0,z);
eta = Real(ctemp);
}
else if (Real(z) == 1.0) {
t1 = fabs(Imag(z)) + FPKRHO.d;
xi = log(sqrt(sqrt(4.0 + t1*t1))/sqrt(fabs(Imag(z))));
eta = 0.5*copysign(M_PI-atan(2.0/(fabs(Imag(z))+FPKRHO.d)),Imag(z));
}
else {
t2 = fabs(Imag(z)) + FPKRHO.d;
t1 = 1.0 - Real(z);
t2 = t2*t2;
xi = 0.25*log1p(4.0*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0 - Real(z))*(1.0 + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5*carg(ctemp);
}
Real(w) = -beta*eta;
Imag(w) = -beta*xi;
return w;
}
float complex catanf ( float complex z )
{
float complex ctemp, w;
float t1, t2, xi, eta, beta;
xi = -Imag(z);
beta = copysignf(1.0f,xi);
Imag(z) = -beta*Real(z);
Real(z) = beta*xi;
if ((Real(z) > FPKTHETAf.fval) || (fabsf(Imag(z)) > FPKTHETAf.fval)) {
xi = copysignf((float) M_PI_2,Imag(z));
ctemp = xdivcf(1.0f,z);
eta = Real(ctemp);
}
else if (Real(z) == 1.0f) {
t1 = fabsf(Imag(z)) + FPKRHOf.fval;
xi = logf(sqrtf(sqrtf(4.0f + t1*t1))/sqrtf(fabsf(Imag(z))));
eta = 0.5f*copysignf((float)( M_PI-atan(2.0/(fabsf(Imag(z))+FPKRHOf.fval))),Imag(z));
}
else {
t2 = fabsf(Imag(z)) + FPKRHOf.fval;
t1 = 1.0f - Real(z);
t2 = t2*t2;
xi = 0.25f*log1pf(4.0f*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0f - Real(z))*(1.0f + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5f*cargf(ctemp);
}
Real(w) = -beta*eta;
Imag(w) = -beta*xi;
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
static const
hexdbldbl FPKRHOl = {{0x20100000, 0x00000001, 0x9cbfffff, 0xffffffff}};
long double complex catanl ( long double complex z )
{
long double complex ctemp, w;
long double t1, t2, xi, eta, beta;
xi = -Imag(z);
beta = copysignl(1.0L,xi);
Imag(z) = -beta*Real(z);
Real(z) = beta*xi;
if ((Real(z) > FPKTHETA.d) || (fabsl(Imag(z)) > FPKTHETA.d)) {
xi = copysignl(M_PI_2,Imag(z));
ctemp = xdivcl(1.0L,z);
eta = Real(ctemp);
}
else if (Real(z) == 1.0L) {
t1 = fabsl(Imag(z)) + FPKRHOl.ld;
xi = logl(sqrtl(sqrtl(4.0L + t1*t1))/sqrtl(fabsl(Imag(z))));
eta = 0.5L*copysignl(M_PI-atanl(2.0L/(fabsl(Imag(z))+FPKRHOl.ld)),Imag(z));
}
else {
t2 = fabsl(Imag(z)) + FPKRHOl.ld;
t1 = 1.0L - Real(z);
t2 = t2*t2;
xi = 0.25L*log1pl(4.0L*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0L - Real(z))*(1.0L + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5L*cargl(ctemp);
}
Real(w) = -beta*eta;
Imag(w) = -beta*xi;
return w;
}
#endif
double complex catanh( double complex z )
{
double complex ctemp, w;
double t1, t2, xi, eta, beta;
beta = copysign(1.0,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETA.d) || (fabs(Imag(z)) > FPKTHETA.d)) {
eta = copysign(M_PI_2,Imag(z));
ctemp = xdivc(1.0,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0) {
t1 = fabs(Imag(z)) + FPKRHO.d;
xi = log(sqrt(sqrt(4.0 + t1*t1))/sqrt(fabs(Imag(z))));
eta = 0.5*copysign(M_PI-atan(2.0/(fabs(Imag(z))+FPKRHO.d)),Imag(z));
}
else {
t2 = fabs(Imag(z)) + FPKRHO.d;
t1 = 1.0 - Real(z);
t2 = t2*t2;
xi = 0.25*log1p(4.0*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0 - Real(z))*(1.0 + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5*carg(ctemp);
}
Real(w) = beta*xi;
Imag(w) = -beta*eta;
return w;
}
float complex catanhf( float complex z )
{
float complex ctemp, w;
float t1, t2, xi, eta, beta;
beta = copysignf(1.0f,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETAf.fval) || (fabsf(Imag(z)) > FPKTHETAf.fval)) {
eta = copysignf((float) M_PI_2,Imag(z));
ctemp = xdivcf(1.0f,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0f) {
t1 = fabsf(Imag(z)) + FPKRHOf.fval;
xi = logf(sqrtf(sqrtf(4.0f + t1*t1))/sqrtf(fabsf(Imag(z))));
eta = 0.5f*copysignf((float)( M_PI-atan(2.0f/(fabsf(Imag(z))+FPKRHOf.fval))),Imag(z));
}
else {
t2 = fabsf(Imag(z)) + FPKRHOf.fval;
t1 = 1.0f - Real(z);
t2 = t2*t2;
xi = 0.25f*log1pf(4.0f*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0f - Real(z))*(1.0f + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5f*cargf(ctemp);
}
Real(w) = beta*xi;
Imag(w) = -beta*eta;
return w;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex catanhl( long double complex z )
{
long double complex ctemp, w;
long double t1, t2, xi, eta, beta;
beta = copysignl(1.0L,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETA.d) || (fabsl(Imag(z)) > FPKTHETA.d)) {
eta = copysignl(M_PI_2,Imag(z));
ctemp = xdivcl(1.0L,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0L) {
t1 = fabsl(Imag(z)) + FPKRHOl.ld;
xi = logl(sqrtl(sqrtl(4.0L + t1*t1))/sqrtl(fabsl(Imag(z))));
eta = 0.5L*copysignl(M_PI-atanl(2.0L/(fabsl(Imag(z))+FPKRHOl.ld)),Imag(z));
}
else {
t2 = fabsl(Imag(z)) + FPKRHOl.ld;
t1 = 1.0L - Real(z);
t2 = t2*t2;
xi = 0.25L*log1pl(4.0L*Real(z)/(t1*t1 + t2));
Real(ctemp) = (1.0L - Real(z))*(1.0L + Real(z)) - t2;
Imag(ctemp) = Imag(z) + Imag(z);
eta = 0.5L*cargl(ctemp);
}
Real(w) = beta*xi;
Imag(w) = -beta*eta;
return w;
}
#endif
double creal( double complex z )
{
return __builtin_creal(z);
}
float crealf( float complex z )
{
return __builtin_crealf(z);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double creall( long double complex z )
{
return __builtin_creall(z);
}
#endif
double cimag( double complex z )
{
return __builtin_cimag(z);
}
float cimagf( float complex z )
{
return __builtin_cimagf(z);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double cimagl( long double complex z )
{
return __builtin_cimagl(z);
}
#endif
double complex conj( double complex z )
{
return __builtin_conj(z);
}
float complex conjf( float complex z )
{
return __builtin_conjf(z);
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex conjl( long double complex z )
{
return __builtin_conjl(z);
}
#endif
double complex cproj( double complex z )
{
static const double inf = __builtin_inf();
double u = __builtin_fabs(Real(z));
double v = __builtin_fabs(Imag(z));
if (unlikely((u == inf) || (v == inf)))
return inf + I*copysign(0.0, Imag(z));
else
return z;
}
float complex cprojf( float complex z )
{
static const double inf = __builtin_inff();
float u = __builtin_fabsf(Real(z));
float v = __builtin_fabsf(Imag(z));
if (unlikely((u == inf) || (v == inf)))
return inf + I*copysignf(0.0f, Imag(z));
else
return z;
}
#if (__WANT_LONG_DOUBLE_FORMAT__ - 0L == 128L)
long double complex cprojl( long double complex z )
{
static const double inf = __builtin_infl();
float u = __builtin_fabsl(Real(z));
float v = __builtin_fabsl(Imag(z));
if (unlikely((u == inf) || (v == inf)))
return inf + I*copysignl(0.0l, Imag(z));
else
return z;
}
#endif