#pragma STDC FENV_ACCESS ON
#include "math.h"
#include "complex.h"
#include "fenv.h"
#include "xmmLibm_prefix.h"
#define Real(z) (__real__ z)
#define Imag(z) (__imag__ z)
static const double expOverflowThreshold_d = 0x1.62e42fefa39efp+9;
static const double expOverflowValue_d = 0x1.fffffffffff2ap+1023; static const double twiceExpOverflowThresh_d = 0x1.62e42fefa39efp+10;
static const long double expOverflowThreshold_ld = 0xb.17217f7d1cf79abp+10L;
static const long double expOverflowValue_ld = 0xf.fffffffffffcd87p+16380L; static const long double twiceExpOverflowThresh_ld = 0xb.17217f7d1cf79abp+10L;
static const double FPKASINHOM4 = 0x1.633ce8fb9f87ep+7;
static const float FPKASINHOM4f = 0x1.65a9f8p+4f;
static const double FPKTHETA = 0x1.fffffffffffffp+509;
static const float FPKTHETAf = 0x1.fffffep+61f;
static const double FPKRHO = 0x1p-510;
static const float FPKRHOf = 0x1.000002p-62f;
static
double complex xdivc( double x, double complex y )
{
double complex z;
double r, denom;
if ( __builtin_fabs(Real(y)) >= __builtin_fabs(Imag(y)) ) {
if (__builtin_fabs(Real(y)) == INFINITY) {
Real(z) = __builtin_copysign(0.0,Real(y));
Imag(z) = __builtin_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 ( __builtin_fabsf(Real(y)) >= __builtin_fabsf(Imag(y)) ) {
if (__builtin_fabsf(Real(y)) == INFINITY) {
Real(z) = __builtin_copysignf(0.0f,Real(y));
Imag(z) = __builtin_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;
}
static
long double complex xdivcl( long double x, long double complex y )
{
long double complex z;
long double r, denom;
if ( __builtin_fabsl(Real(y)) >= __builtin_fabsl(Imag(y)) ) {
if (__builtin_fabsl(Real(y)) == INFINITY) {
Real(z) = __builtin_copysignl(0.0L,Real(y));
Imag(z) = __builtin_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;
}
double carg ( double complex z ) { return atan2(Imag(z), Real(z)); }
float cargf ( float complex z ) { return atan2f(Imag(z), Real(z)); }
long double cargl ( long double complex z ) { return atan2l(Imag(z), Real(z)); }
double complex csqrt ( double complex z )
{
static const double inf = __builtin_inf();
double u,v;
if (__builtin_fabs(Imag(z)) == inf)
return inf + I*Imag(z);
if (Imag(z) != Imag(z)) {
if (Real(z) != Real(z)) return z;
else if (Real(z) == inf) return z;
else if (Real(z) == -inf) return Imag(z) + I*__builtin_copysign(inf,Imag(z));
else { return Imag(z) + I*Imag(z);
}
}
if (Real(z) != Real(z)) { return Real(z) + I*__builtin_copysign(Real(z),Imag(z));
}
if (Real(z) == 0.0) {
if (Imag(z) == 0.0) return I*Imag(z);
else { u = __builtin_sqrt(0.5*__builtin_fabs(Imag(z)));
return u + I*__builtin_copysign(u, Imag(z) );
}
}
if (Real(z) == inf) return inf + I*__builtin_copysign(0.0,Imag(z));
if (Real(z) == -inf) return I*__builtin_copysign(inf,Imag(z));
else {
long double x = __builtin_fabsl(Real(z));
long double y = Imag(z);
u = (double)__builtin_sqrtl(0.5L*(__builtin_sqrtl(x*x + y*y) + x));
v = 0.5 * (Imag(z) / u);
if (Real(z) < 0.0) {
return __builtin_fabs(v) + I*__builtin_copysign(u,Imag(z));
} else {
return u + I*v;
}
}
}
float complex csqrtf ( float complex z )
{
static const float inf = __builtin_inff();
float u,v;
if (__builtin_fabsf(Imag(z)) == inf)
return inf + I*Imag(z);
if (Imag(z) != Imag(z)) {
if (Real(z) != Real(z)) return z;
else if (Real(z) == inf) return z;
else if (Real(z) == -inf) return Imag(z) + I*__builtin_copysignf(inf,Imag(z));
else { return Imag(z) + I*Imag(z);
}
}
if (Real(z) != Real(z)) { return Real(z) + I*__builtin_copysignf(Real(z),Imag(z));
}
if (Real(z) == 0.0f) {
if (Imag(z) == 0.0f) return I*Imag(z);
else { u = __builtin_sqrtf(0.5f*__builtin_fabsf(Imag(z)));
return u + I*__builtin_copysignf(u, Imag(z) );
}
}
if (Real(z) == inf) return inf + I*__builtin_copysignf(0.0f,Imag(z));
if (Real(z) == -inf) return I*__builtin_copysignf(inf,Imag(z));
else {
double x = __builtin_fabs(Real(z));
double y = Imag(z);
u = (float)__builtin_sqrt(0.5*(__builtin_sqrt(x*x + y*y) + x));
v = 0.5f * (Imag(z) / u);
if (Real(z) < 0.0f) {
return __builtin_fabsf(v) + I*__builtin_copysignf(u,Imag(z));
} else {
return u + I*v;
}
}
}
typedef union
{
long double ld;
struct
{
uint64_t mantissa;
int16_t sexp;
};
}ld_parts;
long double complex csqrtl ( long double complex z ) {
static const long double inf = __builtin_infl();
static const long double zero = 0.0l;
static const long double half = 0.5l;
long double u,v;
if (__builtin_fabsl(Imag(z)) == inf)
return inf + I*Imag(z);
if (Imag(z) != Imag(z)) {
if (Real(z) != Real(z)) return z;
else if (Real(z) == inf) return z;
else if (Real(z) == -inf) return Imag(z) + I*__builtin_copysignl(inf,Imag(z));
else { return Imag(z) + I*Imag(z);
}
}
if (Imag(z) == zero) {
if (Real(z) == zero) return I*Imag(z);
else {
u = __builtin_sqrtl(__builtin_fabsl(Real(z)));
if (Real(z) < zero)
return zero + I*__builtin_copysignl(u,Imag(z));
else
return u + I*__builtin_copysignl(zero,Imag(z));
}
}
if (Real(z) != Real(z)) { return Real(z) + I*__builtin_copysignl(Real(z),Imag(z));
}
if (Real(z) == zero) {
u = __builtin_sqrtl(half*__builtin_fabsl(Imag(z)));
return u + I*__builtin_copysignl(u, Imag(z) );
}
if (Real(z) == inf) return inf + I*__builtin_copysignl(zero,Imag(z));
if (Real(z) == -inf) return I*__builtin_copysignl(inf,Imag(z));
else {
long double x = __builtin_fabsl(Real(z));
long double y = __builtin_fabsl(Imag(z));
ld_parts *large = (ld_parts*) &x;
ld_parts *small = (ld_parts*) &y;
if (large->ld < small->ld) {
ld_parts *p = large;
large = small;
small = p;
}
int lexp = large->sexp;
int sexp = small->sexp;
if( lexp == 0 )
{
large->ld = large->mantissa;
lexp = large->sexp - 16445;
}
if( sexp == 0 )
{
small->ld = small->mantissa;
sexp = small->sexp - 16445;
}
large->sexp = 0x3fff;
int scale = 0x3fff - lexp;
int small_scale = sexp + scale;
if( small_scale < 64 )
small_scale = 64;
small->sexp = small_scale;
u = __builtin_sqrtl( large->ld * large->ld + small->ld * small->ld ) + x;
if (scale%2)
scale = 0x3fff - (scale + 1)/2;
else {
scale = 0x3fff - (scale/2 + 1);
u = u + u;
}
u = __builtin_sqrtl(u);
large->sexp = scale;
large->mantissa = 0x8000000000000000ULL;
u *= large->ld;
v = Imag(z) / (2.0l * u);
if (Real(z) < zero) {
return __builtin_fabsl(v) + I*__builtin_copysignl(u,Imag(z));
} else {
return u + I*v;
}
}
}
double complex clog ( double complex z )
{
static const double inf = __builtin_inf();
double large, small, temp;
double complex w;
long double ratio;
Imag(w) = carg(z);
if ((__builtin_fabs(Real(z)) == inf) || (__builtin_fabs(Imag(z)) == inf)) {
Real(w) = inf;
return w;
}
if (Real(z) != Real(z)) return Real(z) + I*__builtin_copysign(Real(z),Imag(z));
if (Imag(z) != Imag(z)) return Imag(z) + I*Imag(z);
large = __builtin_fabs(Real(z));
small = __builtin_fabs(Imag(z));
if (large < small) {
temp = large;
large = small;
small = temp;
}
Real(w) = log(large);
if (small == 0.0) return w;
if (large == 1.0) {
Real(w) = 0.5*log1p(small*small); return w;
}
ratio = (long double)small / (long double)large;
if (ratio > 0x1.0p-53L) {
Real(w) += 0.5*log1p((double)(ratio*ratio));
}
return w;
}
float complex clogf ( float complex z )
{
static const float inf = __builtin_inff();
float large, small, temp;
float complex w;
double ratio;
Imag(w) = cargf(z);
if ((__builtin_fabsf(Real(z)) == inf) || (__builtin_fabsf(Imag(z)) == inf)) {
Real(w) = inf;
return w;
}
if (Real(z) != Real(z)) return Real(z) + I*__builtin_copysignf(Real(z),Imag(z));
if (Imag(z) != Imag(z)) return Imag(z) + I*Imag(z);
large = __builtin_fabsf(Real(z));
small = __builtin_fabsf(Imag(z));
if (large < small) {
temp = large;
large = small;
small = temp;
}
Real(w) = logf(large);
if (small == 0.0f) return w;
if (large == 1.0f) {
Real(w) = 0.5f*log1pf(small*small); return w;
}
ratio = (double)small / (double)large;
if (ratio > 0x1.0p-24) {
Real(w) += 0.5f*log1pf((float)(ratio*ratio));
}
return w;
}
long double complex clogl ( long double complex z )
{
static const long double inf = __builtin_infl();
long double x,y;
long double complex w;
long double ratio;
Imag(w) = cargl(z);
if ((__builtin_fabsl(Real(z)) == inf) || (__builtin_fabsl(Imag(z)) == inf)) {
Real(w) = inf;
return w;
}
if (Real(z) != Real(z)) return Real(z) + I*__builtin_copysignl(Real(z),Imag(z));
if (Imag(z) != Imag(z)) return Imag(z) + I*Imag(z);
x = __builtin_fabsl(Real(z));
y = __builtin_fabsl(Imag(z));
ld_parts *large = (ld_parts*) &x;
ld_parts *small = (ld_parts*) &y;
if (large->ld < small->ld) {
ld_parts *p = large;
large = small;
small = p;
}
Real(w) = logl(large->ld);
if (small->ld == 0.0L) return w;
if (large->ld == 1.0L) {
Real(w) = 0.5L*log1pl((small->ld)*(small->ld)); return w;
}
if (large->sexp - small->sexp < 64) {
ratio = small->ld / large->ld;
Real(w) += 0.5L*log1pl(ratio*ratio);
}
return w;
}
void cosisin(double x, double complex *z);
void cosisinf(float x, float complex *z);
void cosisinl(long double x, long double complex *z);
double complex csin ( double complex z )
{
double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = csinh(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
float complex csinf ( float complex z )
{
float complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = csinhf(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
long double complex csinl ( long double complex z )
{
long double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = csinhl(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
double complex ccos ( double complex z )
{
double complex iz;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
return ccosh(iz);
}
float complex ccosf ( float complex z )
{
float complex iz;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
return ccoshf(iz);
}
long double complex ccosl ( long double complex z )
{
long double complex iz;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
return ccoshl(iz);
}
double complex csinh ( double complex z )
{
static const double INF = __builtin_inf();
double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysign(Real(z), Imag(z));
return w;
}
double absx = __builtin_fabs(Real(z));
double reducedx = absx;
cosisin(Imag(z), &w); Real(w) *= __builtin_copysign(1.0, Real(z));
if ((absx == INF) && ((Imag(z) == INF) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0))) {
Real(w) = __builtin_copysign(INF, Real(z));
return w;
}
if (absx == 0.0) {
Real(w) = Real(z); return w;
}
if ((reducedx < twiceExpOverflowThresh_d) && (reducedx > expOverflowThreshold_d)) {
reducedx -= expOverflowThreshold_d; Real(w) *= expOverflowValue_d; Imag(w) *= expOverflowValue_d; }
double exm1 = expm1(reducedx);
if (absx < 0x1p-27) { Real(w) *= absx; }
else if (absx > 19.0) { double halfExpX = 0.5 * (exm1 + 1.0); Real(w) *= halfExpX; if (Imag(z) != 0.0) Imag(w) *= halfExpX;
}
else { double twiceExpX = 2.0 * (exm1 + 1.0);
Imag(w) *= 1.0 + (exm1*exm1)/twiceExpX;
Real(w) *= 0.5*exm1 + exm1/twiceExpX;
}
return w;
}
float complex csinhf ( float complex z )
{
static const float INFf = __builtin_inff();
static const double INF = __builtin_inf();
float complex w;
double complex wd;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0f) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignf(Real(z), Imag(z));
return w;
}
double absx = (double)__builtin_fabsf(Real(z));
cosisin((double)Imag(z), &wd); Real(wd) *= __builtin_copysign(1.0, (double)Real(z));
if ((absx == INF) && ((Imag(z) == INFf) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0f))) {
Real(w) = __builtin_copysignf(INFf, Real(z));
Imag(w) = (float)Imag(wd);
return w;
}
if (absx == 0.0) {
Real(w) = Real(z); Imag(w) = (float)Imag(wd);
return w;
}
double exm1 = expm1(absx);
if (absx < 0x1p-27) { Real(wd) *= absx; }
else if (absx > 19.0) { double halfExpX = 0.5 * (exm1 + 1.0); Real(wd) *= halfExpX; if (Imag(z) != 0.0f) Imag(wd) *= halfExpX;
}
else { double twiceExpX = 2.0 * (exm1 + 1.0);
Imag(wd) *= 1.0 + (exm1*exm1)/twiceExpX;
Real(wd) *= 0.5*exm1 + exm1/twiceExpX;
}
Real(w) = (float)Real(wd);
Imag(w) = (float)Imag(wd);
return w;
}
long double complex csinhl ( long double complex z )
{
static const long double INFl = __builtin_infl();
long double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0L) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignl(Real(z), Imag(z));
return w;
}
long double absx = __builtin_fabsl(Real(z));
long double reducedx = absx;
cosisinl(Imag(z), &w); Real(w) *= __builtin_copysignl(1.0L, Real(z));
if ((absx == INFl) && ((Imag(z) == INFl) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0L))) {
Real(w) = __builtin_copysignl(INFl, Real(z));
return w;
}
if (absx == 0.0L) {
Real(w) = Real(z); return w;
}
if ((reducedx < twiceExpOverflowThresh_ld) && (reducedx > expOverflowThreshold_ld)) {
reducedx -= expOverflowThreshold_ld; Real(w) *= expOverflowValue_ld; Imag(w) *= expOverflowValue_ld; }
long double exm1 = expm1l(reducedx);
if (absx < 0x1p-32L) { Real(w) *= absx; }
else if (absx > 23L) { long double halfExpX = 0.5L * (exm1 + 1.0L); Real(w) *= halfExpX; if (Imag(z) != 0.0L) Imag(w) *= halfExpX;
}
else { long double twiceExpX = 2.0L * (exm1 + 1.0L);
Imag(w) *= 1.0L + (exm1*exm1)/twiceExpX;
Real(w) *= 0.5L*exm1 + exm1/twiceExpX;
}
return w;
}
double complex ccosh ( double complex z )
{
static const double INF = __builtin_inf();
double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysign(Real(z), Imag(z));
return w;
}
double absx = __builtin_fabs(Real(z));
double reducedx = absx;
cosisin(Imag(z), &w); Imag(w) *= __builtin_copysign(1.0, Real(z));
if ((absx == INF) && ((Imag(z) == INF) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0))) {
Real(w) = INF;
return w;
}
if (absx == 0.0) {
Imag(w) = Real(z) * __builtin_copysign(1.0, Imag(z)); return w;
}
if ((reducedx < twiceExpOverflowThresh_d) && (reducedx > expOverflowThreshold_d)) {
reducedx -= expOverflowThreshold_d; Real(w) *= expOverflowValue_d; Imag(w) *= expOverflowValue_d; }
double exm1 = expm1(reducedx);
if (absx < 0x1p-27) { Imag(w) *= absx; }
else if (absx > 19.0) { double halfExpX = 0.5 * (exm1 + 1.0); Real(w) *= halfExpX; if (Imag(z) != 0.0) Imag(w) *= halfExpX;
}
else { double twiceExpX = 2.0 * (exm1 + 1.0);
Real(w) *= 1.0 + (exm1*exm1)/twiceExpX;
Imag(w) *= 0.5*exm1 + exm1/twiceExpX;
}
return w;
}
float complex ccoshf ( float complex z )
{
static const float INFf = __builtin_inff();
static const double INF = __builtin_inf();
double complex wd;
float complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0f) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignf(Real(z), Imag(z));
return w;
}
double absx = (double)__builtin_fabsf(Real(z));
cosisin((double)Imag(z), &wd); Imag(wd) *= __builtin_copysign(1.0, (double)Real(z));
if ((absx == INF) && ((Imag(z) == INFf) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0f))) {
Real(w) = INFf;
Imag(w) = (float)Imag(wd);
return w;
}
if (absx == 0.0) {
Imag(w) = Real(z) * __builtin_copysignf(1.0f, Imag(z)); Real(w) = (float)Real(wd);
return w;
}
double exm1 = expm1(absx);
if (absx < 0x1p-27) { Imag(wd) *= absx; }
else if (absx > 19.0) { double halfExpX = 0.5 * (exm1 + 1.0); Real(wd) *= halfExpX; if (Imag(z) != 0.0) Imag(wd) *= halfExpX;
}
else { double twiceExpX = 2.0 * (exm1 + 1.0);
Real(wd) *= 1.0 + (exm1*exm1)/twiceExpX;
Imag(wd) *= 0.5*exm1 + exm1/twiceExpX;
}
Real(w) = (float)Real(wd);
Imag(w) = (float)Imag(wd);
return w;
}
long double complex ccoshl ( long double complex z )
{
static const long double INFl = __builtin_infl();
long double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0L) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignl(Real(z), Imag(z));
return w;
}
long double absx = __builtin_fabsl(Real(z));
long double reducedx = absx;
cosisinl(Imag(z), &w); Imag(w) *= __builtin_copysignl(1.0, Real(z));
if ((absx == INFl) && ((Imag(z) == INFl) || (Imag(z) != Imag(z)) || (Imag(z) == 0.0L))) {
Real(w) = INFl;
return w;
}
if (absx == 0.0L) {
Imag(w) = Real(z) * __builtin_copysignl(1.0, Imag(z)); return w;
}
if ((reducedx < twiceExpOverflowThresh_ld) && (reducedx > expOverflowThreshold_ld)) {
reducedx -= expOverflowThreshold_ld; Real(w) *= expOverflowValue_ld; Imag(w) *= expOverflowValue_ld; }
long double exm1 = expm1l(reducedx);
if (absx < 0x1p-32L) { Imag(w) *= absx; }
else if (absx > 23L) { long double halfExpX = 0.5L * (exm1 + 1.0L); Real(w) *= halfExpX; if (Imag(z) != 0.0L) Imag(w) *= halfExpX;
}
else { long double twiceExpX = 2.0L * (exm1 + 1.0L);
Real(w) *= 1.0L + (exm1*exm1)/twiceExpX;
Imag(w) *= 0.5L*exm1 + exm1/twiceExpX;
}
return w;
}
double complex cexp ( double complex z )
{
static const double INF = __builtin_inf();
double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysign(Real(z), Imag(z));
return w;
}
if ((Real(z) == -INF) && ((__builtin_fabs(Imag(z)) == INF) || (Imag(z) != Imag(z)))) {
Real(w) = 0.0;
Imag(w) = __builtin_copysign(0.0, Imag(z));
return w;
}
if (Imag(z) == 0.0) { Real(w) = exp(Real(z));
Imag(w) = __builtin_copysign(0.0, Imag(z));
return w;
}
cosisin(Imag(z), &w);
if ((Real(z) == INF) && ((Imag(z) == INF) || (Imag(z) != Imag(z)))) {
Real(w) = INF; return w; }
double x = Real(z);
if ((x < twiceExpOverflowThresh_d) && (x > expOverflowThreshold_d)) {
x -= expOverflowThreshold_d; Real(w) *= expOverflowValue_d; Imag(w) *= expOverflowValue_d; }
double scale = exp(x);
Real(w) *= scale;
Imag(w) *= scale;
return w;
}
float complex cexpf ( float complex z )
{
static const float INFf = __builtin_inff();
float complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0f) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignf(Real(z), Imag(z));
return w;
}
if ((Real(z) == -INFf) && ((__builtin_fabsf(Imag(z)) == INFf) || (Imag(z) != Imag(z)))) {
Real(w) = 0.0f;
Imag(w) = __builtin_copysignf(0.0f, Imag(z));
return w;
}
if (Imag(z) == 0.0f) { Real(w) = expf(Real(z));
Imag(w) = __builtin_copysignf(0.0f, Imag(z));
return w;
}
double complex wd;
cosisin((double)Imag(z), &wd);
if ((Real(z) == INFf) && ((Imag(z) == INFf) || (Imag(z) != Imag(z)))) {
Real(w) = INFf; Imag(w) = (float)Imag(wd);
return w; }
double scale = exp((double)Real(z));
Real(w) = (float)(scale*Real(wd));
Imag(w) = (float)(scale*Imag(wd));
return w;
}
long double complex cexpl ( long double complex z )
{
static const long double INFl = __builtin_infl();
long double complex w;
if (Real(z) != Real(z)) {
Real(w) = Real(z);
if (Imag(z) == 0.0L) Imag(w) = Imag(z);
else Imag(w) = __builtin_copysignl(Real(z), Imag(z));
return w;
}
if ((Real(z) == -INFl) && ((__builtin_fabsl(Imag(z)) == INFl) || (Imag(z) != Imag(z)))) {
Real(w) = 0.0L;
Imag(w) = __builtin_copysignl(0.0L, Imag(z));
return w;
}
if (Imag(z) == 0.0L) { Real(w) = expl(Real(z));
Imag(w) = __builtin_copysignl(0.0L, Imag(z));
return w;
}
cosisinl(Imag(z), &w);
if ((Real(z) == INFl) && ((Imag(z) == INFl) || (Imag(z) != Imag(z)))) {
Real(w) = INFl; return w; }
long double x = Real(z);
if ((x < twiceExpOverflowThresh_ld) && (x > expOverflowThreshold_ld)) {
x -= expOverflowThreshold_ld; Real(w) *= expOverflowValue_ld; Imag(w) *= expOverflowValue_ld; }
long double scale = expl(x);
Real(w) *= scale;
Imag(w) *= scale;
return w;
}
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));
}
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));
}
double complex ctanh( double complex z )
{
static const double INF = __builtin_inf();
double x = __builtin_fabs(Real(z));
double y = __builtin_fabs(Imag(z));
double sinhval, coshval, tanval, exm1, cscsq;
double complex w;
if (x == INF) {
w = 1.0 + I*__builtin_copysign(0.0, sin(2.0*y)); }
else if (Imag(z) != Imag(z) || Real(z) != Real(z)) {
if (Imag(z) == 0.0) {
w = Real(z) + I*0.0; } else {
Real(w) = Real(z) + Imag(z); Imag(w) = Real(w);
}
}
else if (y == INF) {
Real(w) = y - y; Imag(w) = Real(w);
}
else if (x > 19.0) {
w = 1.0 + I*__builtin_copysign(0.0, sin(2.0*y)); }
else { tanval = tan(y);
cscsq = 1.0 + tanval*tanval;
if (x < 0x1p-27) {
coshval = 1.0;
sinhval = x;
} else {
exm1 = expm1(x);
coshval = 1.0 + 0.5*(exm1*exm1)/(exm1 + 1.0);
sinhval = 0.5*(exm1 + exm1/(exm1 + 1.0));
}
Real(w) = cscsq * coshval * sinhval / (1.0 + cscsq * sinhval * sinhval);
Imag(w) = tanval / (1.0 + cscsq * sinhval * sinhval);
}
Real(w) = __builtin_copysign(Real(w),Real(z));
Imag(w) *= __builtin_copysign(1.0,Imag(z));
return w;
}
float complex ctanhf( float complex z )
{
static const float INFf = __builtin_inff();
float x = __builtin_fabsf(Real(z));
float y = __builtin_fabsf(Imag(z));
double sinhval, coshval, tanval, exm1, cscsq;
float complex w;
if (x == INFf) {
w = 1.0f + I*__builtin_copysignf(0.0f, sinf(2.0f*y)); }
else if (Imag(z) != Imag(z) || Real(z) != Real(z)) {
if (Imag(z) == 0.0f) {
w = Real(z) + I*0.0f; } else {
Real(w) = Real(z) + Imag(z); Imag(w) = Real(w);
}
}
else if (y == INFf) {
Real(w) = y - y; Imag(w) = Real(w);
}
else if (x > 19.0f) {
w = 1.0f + I*__builtin_copysignf(0.0f, sinf(2.0f*y)); }
else { tanval = (double)tanf(y);
cscsq = 1.0 + tanval*tanval;
if (x < 0x1p-13f) {
coshval = 1.0;
sinhval = x;
} else {
exm1 = (double)expm1f(x);
coshval = 1.0 + 0.5*(exm1*exm1)/(exm1 + 1.0);
sinhval = 0.5*(exm1 + exm1/(exm1 + 1.0));
}
Real(w) = (float)(cscsq * coshval * sinhval / (1.0 + cscsq * sinhval * sinhval));
Imag(w) = (float)(tanval / (1.0 + cscsq * sinhval * sinhval));
}
Real(w) = __builtin_copysignf(Real(w),Real(z));
Imag(w) *= __builtin_copysignf(1.0f,Imag(z));
return w;
}
long double complex ctanhl( long double complex z )
{
static const long double INFl = __builtin_infl();
long double x = __builtin_fabsl(Real(z));
long double y = __builtin_fabsl(Imag(z));
long double sinhval, coshval, tanval, exm1, cscsq;
long double complex w;
if (x == INFl) {
w = 1.0l + I*__builtin_copysignl(0.0l, sinl(2.0l*y)); }
else if (Imag(z) != Imag(z) || Real(z) != Real(z)) {
if (Imag(z) == 0.0l) {
w = Real(z) + I*0.0l; } else {
Real(w) = Real(z) + Imag(z); Imag(w) = Real(w);
}
}
else if (y == INFl) {
Real(w) = y - y; Imag(w) = Real(w);
}
else if (x > 22.0l) {
w = 1.0l + I*__builtin_copysignl(0.0l, sinl(2.0l*y)); }
else { tanval = tanl(y);
cscsq = 1.0l + tanval*tanval;
if (x < 0x1p-32l) {
coshval = 1.0l;
sinhval = x;
} else {
exm1 = expm1l(x);
coshval = 1.0l + 0.5l*(exm1*exm1)/(exm1 + 1.0l);
sinhval = 0.5l*(exm1 + exm1/(exm1 + 1.0l));
}
Real(w) = cscsq * coshval * sinhval / (1.0l + cscsq * sinhval * sinhval);
Imag(w) = tanval / (1.0l + cscsq * sinhval * sinhval);
}
Real(w) = __builtin_copysignl(Real(w),Real(z));
Imag(w) *= __builtin_copysignl(1.0l,Imag(z));
return w;
}
double complex ctan( double complex z )
{
double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = ctanh(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
float complex ctanf( float complex z )
{
float complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = ctanhf(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
long double complex ctanl( long double complex z )
{
long double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = ctanhl(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
double complex casin ( double complex z )
{
double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = casinh(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
float complex casinf ( float complex z )
{
float complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = casinhf(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
long double complex casinl ( long double complex z )
{
long double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = casinhl(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
double complex casinh ( double complex z )
{
static const double INF = __builtin_inf();
static const double ln2 = 0x1.62e42fefa39ef358p-1;
static const double sqrt1_2 = 0x1.6a09e667f3bcc908p-1;
double complex w;
double x = __builtin_fabs(Real(z));
double y = __builtin_fabs(Imag(z));
double u, xSquared, tmp;
double complex sqrt1Plusiz, sqrt1PlusizBar;
if ((x == INF) || (y == INF)) {
Real(w) = INF;
Imag(w) = atan2(y,x);
}
else if ((x != x) || (y != y)) {
if (y == 0.0)
w = z;
else {
Real(w) = x + y;
Imag(w) = x + y;
}
}
else {
if ((x < 0x1p-27) && (y < 0x1p-27)) {
Real(w) = x;
Imag(w) = y;
}
else if ((x > 0x1p27) || (y > 0x1p27)) {
w = clog(x + I*y);
Real(w) += ln2;
}
else {
u = 1.0 - y;
xSquared = (x < 0x1p-106 ? 0.0 : x*x);
if (u == 0.0) {
Real(sqrt1Plusiz) = sqrt1_2 * __builtin_sqrt(x); Imag(sqrt1Plusiz) = Real(sqrt1Plusiz); }
else { Real(sqrt1Plusiz) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + xSquared) + __builtin_fabs(u)));
tmp = 0.5 * (x / Real(sqrt1Plusiz));
if (u < 0.0) {
Imag(sqrt1Plusiz) = Real(sqrt1Plusiz);
Real(sqrt1Plusiz) = tmp;
} else {
Imag(sqrt1Plusiz) = tmp;
}
}
u = 1.0 + y;
Real(sqrt1PlusizBar) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + xSquared) + u));
Imag(sqrt1PlusizBar) = x / (2.0*Real(sqrt1PlusizBar));
Real(w) = asinh(Real(sqrt1Plusiz)*Imag(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Real(sqrt1PlusizBar));
Imag(w) = atan2(y, Real(sqrt1Plusiz)*Real(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Imag(sqrt1PlusizBar));
}
}
Real(w) = __builtin_copysign(Real(w), Real(z));
Imag(w) = __builtin_copysign(Imag(w), Imag(z));
return w;
}
float complex casinhf ( float complex z )
{
static const float INFf = __builtin_inff();
static const float ln2f = 0x1.62e42fefa39ef358p-1f;
static const float sqrt1_2f = 0x1.6a09e667f3bcc908p-1f;
float complex w;
float x = __builtin_fabsf(Real(z));
float y = __builtin_fabsf(Imag(z));
float u, xSquared, tmp;
float complex sqrt1Plusiz, sqrt1PlusizBar;
if ((x == INFf) || (y == INFf)) {
Real(w) = INFf;
Imag(w) = atan2f(y,x);
}
else if ((x != x) || (y != y)) {
if (y == 0.0f)
w = z;
else {
Real(w) = x + y;
Imag(w) = x + y;
}
}
else {
if ((x < 0x1p-13f) && (y < 0x1p-13f)) {
Real(w) = x;
Imag(w) = y;
}
else if ((x > 0x1p13f) || (y > 0x1p13f)) {
w = clogf(x + I*y);
Real(w) += ln2f;
}
else {
u = 1.0f - y;
xSquared = (x < 0x1p-52f ? 0.0f : x*x);
if (u == 0.0f) {
Real(sqrt1Plusiz) = sqrt1_2f * __builtin_sqrtf(x); Imag(sqrt1Plusiz) = Real(sqrt1Plusiz); }
else { Real(sqrt1Plusiz) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + xSquared) + __builtin_fabsf(u)));
tmp = 0.5f * (x / Real(sqrt1Plusiz));
if (u < 0.0f) {
Imag(sqrt1Plusiz) = Real(sqrt1Plusiz);
Real(sqrt1Plusiz) = tmp;
} else {
Imag(sqrt1Plusiz) = tmp;
}
}
u = 1.0f + y;
Real(sqrt1PlusizBar) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + xSquared) + u));
Imag(sqrt1PlusizBar) = x / (2.0f*Real(sqrt1PlusizBar));
Real(w) = asinhf(Real(sqrt1Plusiz)*Imag(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Real(sqrt1PlusizBar));
Imag(w) = atan2f(y, Real(sqrt1Plusiz)*Real(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Imag(sqrt1PlusizBar));
}
}
Real(w) = __builtin_copysignf(Real(w), Real(z));
Imag(w) = __builtin_copysignf(Imag(w), Imag(z));
return w;
}
long double complex casinhl ( long double complex z )
{
static const long double INFl = __builtin_infl();
static const long double ln2l = 0x1.62e42fefa39ef358p-1L;
static const long double sqrt1_2l = 0x1.6a09e667f3bcc908p-1L;
long double complex w;
long double x = __builtin_fabsl(Real(z));
long double y = __builtin_fabsl(Imag(z));
long double u, xSquared, tmp;
long double complex sqrt1Plusiz, sqrt1PlusizBar;
if ((x == INFl) || (y == INFl)) {
Real(w) = INFl;
Imag(w) = atan2l(y,x);
}
else if ((x != x) || (y != y)) {
if (y == 0.0l)
w = z;
else {
Real(w) = x + y;
Imag(w) = x + y;
}
}
else {
if ((x < 0x1p-32l) && (y < 0x1p-32l)) {
Real(w) = x;
Imag(w) = y;
}
else if ((x > 0x1p32l) || (y > 0x1p32l)) {
w = clogl(x + I*y);
Real(w) += ln2l;
}
else {
u = 1.0l - y;
xSquared = (x < 0x1p-128l ? 0.0l : x*x);
if (u == 0.0l) {
Real(sqrt1Plusiz) = sqrt1_2l * __builtin_sqrtl(x); Imag(sqrt1Plusiz) = Real(sqrt1Plusiz); }
else { Real(sqrt1Plusiz) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + xSquared) + __builtin_fabsl(u)));
tmp = 0.5 * (x / Real(sqrt1Plusiz));
if (u < 0.0l) {
Imag(sqrt1Plusiz) = Real(sqrt1Plusiz);
Real(sqrt1Plusiz) = tmp;
} else {
Imag(sqrt1Plusiz) = tmp;
}
}
u = 1.0l + y;
Real(sqrt1PlusizBar) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + xSquared) + u));
Imag(sqrt1PlusizBar) = x / (2.0l*Real(sqrt1PlusizBar));
Real(w) = asinhl(Real(sqrt1Plusiz)*Imag(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Real(sqrt1PlusizBar));
Imag(w) = atan2l(y, Real(sqrt1Plusiz)*Real(sqrt1PlusizBar) + Imag(sqrt1Plusiz)*Imag(sqrt1PlusizBar));
}
}
Real(w) = __builtin_copysignl(Real(w), Real(z));
Imag(w) = __builtin_copysignl(Imag(w), Imag(z));
return w;
}
double complex cacos ( double complex z )
{
static const double INF = __builtin_inf();
static const double ln2 = 0x1.62e42fefa39ef358p-1;
static const double sqrt1_2 = 0x1.6a09e667f3bcc908p-1;
static const double pi2 = 0x1.921fb54442d1846ap0;
double complex w;
double x = __builtin_fabs(Real(z));
double y = __builtin_fabs(Imag(z));
double u, ySquared, tmp;
double complex sqrt1Plusz, sqrt1Minusz;
if ((x == INF) || (y == INF)) {
Imag(w) = -INF;
Real(w) = atan2(y,x);
}
else if ((x != x) || (y != y)) {
if (x == 0.0)
Real(w) = pi2;
else
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-27) && (y < 0x1p-27)) {
Real(w) = pi2 - x;
Imag(w) = -y;
}
else if ((x > 0x1p27) || (y > 0x1p27)) {
w = clog(x + I*y) + ln2;
const double tmp = __real__ w;
__real__ w = __imag__ w;
__imag__ w = -tmp;
}
else {
ySquared = (y < 0x1p-106 ? 0.0 : y*y);
u = 1.0 + x;
Real(sqrt1Plusz) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + ySquared) + u));
Imag(sqrt1Plusz) = 0.5 * (y / Real(sqrt1Plusz));
u = 1.0 - x;
if (u == 0.0) {
Real(sqrt1Minusz) = sqrt1_2 * __builtin_sqrt(y); Imag(sqrt1Minusz) = -Real(sqrt1Minusz); }
else { Real(sqrt1Minusz) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + ySquared) + __builtin_fabs(u)));
tmp = 0.5 * (y / Real(sqrt1Minusz));
if (u < 0.0) {
Imag(sqrt1Minusz) = -Real(sqrt1Minusz);
Real(sqrt1Minusz) = tmp;
} else {
Imag(sqrt1Minusz) = -tmp;
}
}
Real(w) = 2.0 * atan2(Real(sqrt1Minusz), Real(sqrt1Plusz));
Imag(w) = asinh( Real(sqrt1Plusz)*Imag(sqrt1Minusz) - Imag(sqrt1Plusz)*Real(sqrt1Minusz) );
}
}
Imag(w) = __builtin_copysign(Imag(w), -Imag(z));
if (Real(z) < 0.0)
Real(w) = 2.0 * pi2 - Real(w);
return w;
}
float complex cacosf ( float complex z )
{
static const float INFf = __builtin_inff();
static const float ln2f = 0x1.62e42fefa39ef358p-1f;
static const float pi2f = 0x1.921fb54442d1846ap0f;
static const float sqrt1_2f = 0x1.6a09e667f3bcc908p-1f;
float complex w;
float x = __builtin_fabsf(Real(z));
float y = __builtin_fabsf(Imag(z));
float u, ySquared, tmp;
float complex sqrt1Plusz, sqrt1Minusz;
if ((x == INFf) || (y == INFf)) {
Imag(w) = -INFf;
Real(w) = atan2f(y,x);
}
else if ((x != x) || (y != y)) {
if (x == 0.0f)
Real(w) = pi2f;
else
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-13f) && (y < 0x1p-13f)) {
Real(w) = pi2f - x;
Imag(w) = -y;
}
else if ((x > 0x1p13f) || (y > 0x1p13f)) {
w = clogf(x + I*y) + ln2f;
const float tmp = __real__ w;
__real__ w = __imag__ w;
__imag__ w = -tmp;
}
else {
ySquared = (y < 0x1p-52f ? 0.0f : y*y);
u = 1.0f + x;
Real(sqrt1Plusz) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + ySquared) + u));
Imag(sqrt1Plusz) = 0.5f * (y / Real(sqrt1Plusz));
u = 1.0f - x;
if (u == 0.0f) {
Real(sqrt1Minusz) = sqrt1_2f * __builtin_sqrtf(y);
Imag(sqrt1Minusz) = -Real(sqrt1Minusz);
}
else {
Real(sqrt1Minusz) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + ySquared) + __builtin_fabsf(u)));
tmp = 0.5f * (y / Real(sqrt1Minusz));
if (u < 0.0f) {
Imag(sqrt1Minusz) = -Real(sqrt1Minusz);
Real(sqrt1Minusz) = tmp;
} else {
Imag(sqrt1Minusz) = -tmp;
}
}
Real(w) = 2.0f * atan2f(Real(sqrt1Minusz),Real(sqrt1Plusz));
Imag(w) = asinhf( Real(sqrt1Plusz)*Imag(sqrt1Minusz) - Imag(sqrt1Plusz)*Real(sqrt1Minusz) );
}
}
Imag(w) = __builtin_copysignf(Imag(w), -Imag(z));
if (Real(z) < 0.0f)
Real(w) = 2.0f * pi2f - Real(w);
return w;
}
long double complex cacosl ( long double complex z )
{
static const long double INFl = __builtin_infl();
static const long double ln2l = 0x1.62e42fefa39ef358p-1L;
static const long double pi2l = 0x1.921fb54442d1846ap0L;
static const long double sqrt1_2l = 0x1.6a09e667f3bcc908p-1L;
long double complex w;
long double x = __builtin_fabsl(Real(z));
long double y = __builtin_fabsl(Imag(z));
long double u, ySquared, tmp;
long double complex sqrt1Plusz, sqrt1Minusz;
if ((x == INFl) || (y == INFl)) {
Imag(w) = -INFl;
Real(w) = atan2l(y,x);
}
else if ((x != x) || (y != y)) {
if (x == 0.0l)
Real(w) = pi2l;
else
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-32l) && (y < 0x1p-32l)) {
Real(w) = pi2l - x;
Imag(w) = -y;
}
else if ((x > 0x1p32l) || (y > 0x1p32l)) {
w = clogl(x + I*y) + ln2l;
const long double tmp = __real__ w;
__real__ w = __imag__ w;
__imag__ w = -tmp;
}
else {
ySquared = (y < 0x1p-128l ? 0.0l : y*y);
u = 1.0l + x;
Real(sqrt1Plusz) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + ySquared) + u));
Imag(sqrt1Plusz) = 0.5l * (y / Real(sqrt1Plusz));
u = 1.0l - x;
if (u == 0.0l) {
Real(sqrt1Minusz) = sqrt1_2l * __builtin_sqrt(y);
Imag(sqrt1Minusz) = -Real(sqrt1Minusz);
}
else {
Real(sqrt1Minusz) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + ySquared) + __builtin_fabsl(u)));
tmp = 0.5l * (y / Real(sqrt1Minusz));
if (u < 0.0l) {
Imag(sqrt1Minusz) = -Real(sqrt1Minusz);
Real(sqrt1Minusz) = tmp;
} else {
Imag(sqrt1Minusz) = -tmp;
}
}
Real(w) = 2.0l * atan2l(Real(sqrt1Minusz), Real(sqrt1Plusz));
Imag(w) = asinhl( Real(sqrt1Plusz)*Imag(sqrt1Minusz) - Imag(sqrt1Plusz)*Real(sqrt1Minusz) );
}
}
Imag(w) = __builtin_copysignl(Imag(w), -Imag(z));
if (Real(z) < 0.0l)
Real(w) = 2.0l * pi2l - Real(w);
return w;
}
double complex cacosh ( double complex z )
{
static const double INF = __builtin_inf();
static const double ln2 = 0x1.62e42fefa39ef358p-1;
static const double sqrt1_2 = 0x1.6a09e667f3bcc908p-1;
static const double pi2 = 0x1.921fb54442d1846ap0;
double complex w;
double x = __builtin_fabs(Real(z));
double y = __builtin_fabs(Imag(z));
double u, ySquared, tmp;
double complex sqrtzPlus1, sqrtzMinus1;
if ((x == INF) || (y == INF)) {
Imag(w) = atan2(y,x);
Real(w) = INF;
}
else if ((x != x) || (y != y)) {
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-27) && (y < 0x1p-27)) {
Real(w) = y;
Imag(w) = pi2 - x;
}
else if ((x > 0x1p27) || (y > 0x1p27)) {
w = clog(x + I*y) + ln2;
}
else {
ySquared = (y < 0x1p-106 ? 0.0 : y*y);
u = x + 1.0;
Real(sqrtzPlus1) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + ySquared) + u));
Imag(sqrtzPlus1) = 0.5 * (y / Real(sqrtzPlus1));
u = x - 1.0;
if (u == 0.0) {
Real(sqrtzMinus1) = sqrt1_2 * __builtin_sqrt(y); Imag(sqrtzMinus1) = Real(sqrtzMinus1); }
else { Real(sqrtzMinus1) = __builtin_sqrt(0.5*(__builtin_sqrt(u*u + ySquared) + __builtin_fabs(u)));
tmp = 0.5 * (y / Real(sqrtzMinus1));
if (u < 0.0) {
Imag(sqrtzMinus1) = Real(sqrtzMinus1);
Real(sqrtzMinus1) = tmp;
} else {
Imag(sqrtzMinus1) = tmp;
}
}
Real(w) = asinh( Real(sqrtzPlus1)*Real(sqrtzMinus1) + Imag(sqrtzPlus1)*Imag(sqrtzMinus1) );
Imag(w) = 2.0*atan2( Imag(sqrtzMinus1) , Real(sqrtzPlus1) );
}
}
if (Real(z) < 0.0)
Imag(w) = 2.0 * pi2 - Imag(w);
Imag(w) = __builtin_copysign(Imag(w), Imag(z));
return w;
}
float complex cacoshf ( float complex z )
{
static const float INFf = __builtin_inff();
static const float ln2f = 0x1.62e42fefa39ef358p-1f;
static const float sqrt1_2f = 0x1.6a09e667f3bcc908p-1f;
static const float pi2f = 0x1.921fb54442d1846ap0f;
float complex w;
float x = __builtin_fabsf(Real(z));
float y = __builtin_fabsf(Imag(z));
float u, ySquared, tmp;
float complex sqrtzPlus1, sqrtzMinus1;
if ((x == INFf) || (y == INFf)) {
Imag(w) = atan2f(y,x);
Real(w) = INFf;
}
else if ((x != x) || (y != y)) {
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-13f) && (y < 0x1p-13f)) {
Real(w) = y;
Imag(w) = pi2f - x;
}
else if ((x > 0x1p13f) || (y > 0x1p13f)) {
w = clogf(x + I*y) + ln2f;
}
else {
ySquared = (y < 0x1p-52f ? 0.0f : y*y);
u = x + 1.0f;
Real(sqrtzPlus1) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + ySquared) + u));
Imag(sqrtzPlus1) = 0.5f * (y / Real(sqrtzPlus1));
u = x - 1.0f;
if (u == 0.0f) {
Real(sqrtzMinus1) = sqrt1_2f * __builtin_sqrtf(y); Imag(sqrtzMinus1) = Real(sqrtzMinus1); }
else { Real(sqrtzMinus1) = __builtin_sqrtf(0.5f*(__builtin_sqrtf(u*u + ySquared) + __builtin_fabsf(u)));
tmp = 0.5f * (y / Real(sqrtzMinus1));
if (u < 0.0f) {
Imag(sqrtzMinus1) = Real(sqrtzMinus1);
Real(sqrtzMinus1) = tmp;
} else {
Imag(sqrtzMinus1) = tmp;
}
}
Real(w) = asinhf( Real(sqrtzPlus1)*Real(sqrtzMinus1) + Imag(sqrtzPlus1)*Imag(sqrtzMinus1) );
Imag(w) = 2.0f*atan2f( Imag(sqrtzMinus1) , Real(sqrtzPlus1) );
}
}
if (Real(z) < 0.0f)
Imag(w) = 2.0f * pi2f - Imag(w);
Imag(w) = __builtin_copysignf(Imag(w), Imag(z));
return w;
}
long double complex cacoshl ( long double complex z )
{
static const long double INFl = __builtin_infl();
static const long double ln2l = 0x1.62e42fefa39ef358p-1L;
static const long double sqrt1_2l = 0x1.6a09e667f3bcc908p-1L;
static const long double pi2l = 0x1.921fb54442d1846ap0L;
long double complex w;
long double x = __builtin_fabsl(Real(z));
long double y = __builtin_fabsl(Imag(z));
long double u, ySquared, tmp;
long double complex sqrtzPlus1, sqrtzMinus1;
if ((x == INFl) || (y == INFl)) {
Imag(w) = atan2l(y,x);
Real(w) = INFl;
}
else if ((x != x) || (y != y)) {
Real(w) = x + y;
Imag(w) = x + y;
}
else {
if ((x < 0x1p-32l) && (y < 0x1p-32l)) {
Real(w) = y;
Imag(w) = pi2l - x;
}
else if ((x > 0x1p32l) || (y > 0x1p32l)) {
w = clogl(x + I*y) + ln2l;
}
else {
ySquared = (y < 0x1p-128L ? 0.0L : y*y);
u = x + 1.0l;
Real(sqrtzPlus1) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + ySquared) + u));
Imag(sqrtzPlus1) = 0.5l * (y / Real(sqrtzPlus1));
u = x - 1.0l;
if (u == 0.0l) {
Real(sqrtzMinus1) = sqrt1_2l * __builtin_sqrtl(y); Imag(sqrtzMinus1) = Real(sqrtzMinus1); }
else { Real(sqrtzMinus1) = __builtin_sqrtl(0.5l*(__builtin_sqrtl(u*u + ySquared) + __builtin_fabsl(u)));
tmp = 0.5l * (y / Real(sqrtzMinus1));
if (u < 0.0l) {
Imag(sqrtzMinus1) = Real(sqrtzMinus1);
Real(sqrtzMinus1) = tmp;
} else {
Imag(sqrtzMinus1) = tmp;
}
}
Real(w) = asinhl( Real(sqrtzPlus1)*Real(sqrtzMinus1) + Imag(sqrtzPlus1)*Imag(sqrtzMinus1) );
Imag(w) = 2.0l*atan2l( Imag(sqrtzMinus1) , Real(sqrtzPlus1) );
}
}
if (Real(z) < 0.0l)
Imag(w) = 2.0l * pi2l - Imag(w);
Imag(w) = __builtin_copysignl(Imag(w), Imag(z));
return w;
}
double complex catan ( double complex z )
{
double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = catanh(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
float complex catanf ( float complex z )
{
float complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = catanhf(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
long double complex catanl ( long double complex z )
{
long double complex iz, iw, w;
Real(iz) = -Imag(z);
Imag(iz) = Real(z);
iw = catanhl(iz);
Real(w) = Imag(iw);
Imag(w) = -Real(iw);
return w;
}
double complex catanh( double complex z )
{
double complex ctemp, w;
double t1, t2, xi, eta, beta;
beta = __builtin_copysign(1.0,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETA) || (__builtin_fabs(Imag(z)) > FPKTHETA)) {
eta = __builtin_copysign(M_PI_2,Imag(z));
ctemp = xdivc(1.0,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0) {
t1 = __builtin_fabs(Imag(z)) + FPKRHO;
xi = log(__builtin_sqrt(__builtin_sqrt(4.0 + t1*t1))/__builtin_sqrt(__builtin_fabs(Imag(z))));
eta = 0.5*__builtin_copysign(M_PI-atan(2.0/(__builtin_fabs(Imag(z))+FPKRHO)),Imag(z));
}
else {
t2 = __builtin_fabs(Imag(z)) + FPKRHO;
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 = __builtin_copysignf(1.0f,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETAf) || (__builtin_fabsf(Imag(z)) > FPKTHETAf)) {
eta = __builtin_copysignf((float) M_PI_2,Imag(z));
ctemp = xdivcf(1.0f,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0f) {
t1 = __builtin_fabsf(Imag(z)) + FPKRHOf;
xi = logf(__builtin_sqrtf(__builtin_sqrtf(4.0f + t1*t1))/__builtin_sqrtf(__builtin_fabsf(Imag(z))));
eta = 0.5f*__builtin_copysignf((float)( M_PI-atan(2.0f/(__builtin_fabsf(Imag(z))+FPKRHOf))),Imag(z));
}
else {
t2 = __builtin_fabsf(Imag(z)) + FPKRHOf;
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;
}
long double complex catanhl( long double complex z )
{
long double complex ctemp, w;
long double t1, t2, xi, eta, beta;
beta = __builtin_copysignl(1.0L,Real(z));
Imag(z) = -beta*Imag(z);
Real(z) = beta*Real(z);
if ((Real(z) > FPKTHETA) || (__builtin_fabsl(Imag(z)) > FPKTHETA)) {
eta = __builtin_copysignl(M_PI_2,Imag(z));
ctemp = xdivcl(1.0L,z);
xi = Real(ctemp);
}
else if (Real(z) == 1.0L) {
t1 = __builtin_fabsl(Imag(z)) + FPKRHO;
xi = logl(__builtin_sqrtl(__builtin_sqrtl(4.0L + t1*t1))/__builtin_sqrtl(__builtin_fabsl(Imag(z))));
eta = 0.5L*__builtin_copysignl(M_PI-atanl(2.0L/(__builtin_fabsl(Imag(z))+FPKRHO)),Imag(z));
}
else {
t2 = __builtin_fabsl(Imag(z)) + FPKRHO;
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;
}
double creal( double complex z )
{
return __builtin_creal(z);
}
float crealf( float complex z )
{
return __builtin_crealf(z);
}
long double creall( long double complex z )
{
return __builtin_creall(z);
}
double cimag( double complex z )
{
return __builtin_cimag(z);
}
float cimagf( float complex z )
{
return __builtin_cimagf(z);
}
long double cimagl( long double complex z )
{
return __builtin_cimagl(z);
}
double complex conj( double complex z )
{
return __builtin_conj(z);
}
float complex conjf( float complex z )
{
return __builtin_conjf(z);
}
long double complex conjl( long double complex z )
{
return __builtin_conjl(z);
}
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 (EXPECT_FALSE((u == inf) || (v == inf))) {
__real__ z = inf;
__imag__ z = __builtin_copysign(0.0, __imag__ z);
}
return z;
}
float complex cprojf( float complex z )
{
static const float inff = __builtin_inff();
float u = __builtin_fabsf(Real(z));
float v = __builtin_fabsf(Imag(z));
if (EXPECT_FALSE((u == inff) || (v == inff))) {
__real__ z = inff;
__imag__ z = __builtin_copysignf(0.0f, __imag__ z);
}
return z;
}
long double complex cprojl( long double complex z )
{
static const long double infl = __builtin_infl();
long double u = __builtin_fabsl(Real(z));
long double v = __builtin_fabsl(Imag(z));
if (EXPECT_FALSE((u == infl) || (v == infl))) {
__real__ z = infl;
__imag__ z = __builtin_copysignl(0.0L, __imag__ z);
}
return z;
}