static float complex clog_for_large_values(float complex z) { float x, y; float ax, ay, t; x = crealf(z); y = cimagf(z); ax = fabsf(x); ay = fabsf(y); if (ax < ay) { t = ax; ax = ay; ay = t; } if (ax > FLT_MAX / 2) return (CMPLXF(logf(hypotf(x / m_e, y / m_e)) + 1, atan2f(y, x))); if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN) return (CMPLXF(logf(hypotf(x, y)), atan2f(y, x))); return (CMPLXF(logf(ax * ax + ay * ay) / 2, atan2f(y, x))); }
float complex catanf(float complex z) { float complex w = catanhf(CMPLXF(cimagf(z), crealf(z))); return (CMPLXF(cimagf(w), crealf(w))); }
float complex ctanf(float complex z) { z = ctanhf(CMPLXF(cimagf(z), crealf(z))); return (CMPLXF(cimagf(z), crealf(z))); }
float complex ctanhf(float complex z) { float x, y; float t, beta, s, rho, denom; uint32_t hx, ix; x = crealf(z); y = cimagf(z); GET_FLOAT_WORD(hx, x); ix = hx & 0x7fffffff; if (ix >= 0x7f800000) { if (ix & 0x7fffff) return CMPLXF(x, (y == 0 ? y : x * y)); SET_FLOAT_WORD(x, hx - 0x40000000); return CMPLXF(x, copysignf(0, isinf(y) ? y : sinf(y) * cosf(y))); } if (!isfinite(y)) return CMPLXF(y - y, y - y); if (ix >= 0x41300000) { /* x >= 11 */ float exp_mx = expf(-fabsf(x)); return CMPLXF(copysignf(1, x), 4 * sinf(y) * cosf(y) * exp_mx * exp_mx); } t = tanf(y); beta = 1.0 + t * t; s = sinhf(x); rho = sqrtf(1 + s * s); denom = 1 + beta * s * s; return CMPLXF((beta * rho * s) / denom, t / denom); }
float complex casinf(float complex z) { float complex w; float x, y; x = crealf(z); y = cimagf(z); w = CMPLXF(1.0 - (x - y)*(x + y), -2.0*x*y); return clogf(CMPLXF(-y, x) + csqrtf(w)); }
float complex cacosf(float complex z) { float x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x; int sx, sy; int B_is_usable; float complex w; x = crealf(z); y = cimagf(z); sx = signbit(x); sy = signbit(y); ax = fabsf(x); ay = fabsf(y); if (isnan(x) || isnan(y)) { if (isinf(x)) return (CMPLXF(y + y, -INFINITY)); if (isinf(y)) return (CMPLXF(x + x, -y)); if (x == 0) return (CMPLXF(pio2_hi + pio2_lo, y + y)); return (CMPLXF(x + 0.0L + (y + 0), x + 0.0L + (y + 0))); } if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) { w = clog_for_large_values(z); rx = fabsf(cimagf(w)); ry = crealf(w) + m_ln2; if (sy == 0) ry = -ry; return (CMPLXF(rx, ry)); } if (x == 1 && y == 0) return (CMPLXF(0, -y)); raise_inexact(); if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4) return (CMPLXF(pio2_hi - (x - pio2_lo), -y)); do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x); if (B_is_usable) { if (sx == 0) rx = acosf(B); else rx = acosf(-B); } else { if (sx == 0) rx = atan2f(sqrt_A2mx2, new_x); else rx = atan2f(sqrt_A2mx2, -new_x); } if (sy == 0) ry = -ry; return (CMPLXF(rx, ry)); }
float complex clogf(float complex z) { float r, phi; r = cabsf(z); phi = cargf(z); return CMPLXF(logf(r), phi); }
float complex cacoshf(float complex z) { float complex w; float rx, ry; w = cacosf(z); rx = crealf(w); ry = cimagf(w); if (isnan(rx) && isnan(ry)) return (CMPLXF(ry, rx)); if (isnan(rx)) return (CMPLXF(fabsf(ry), rx)); if (isnan(ry)) return (CMPLXF(ry, ry)); return (CMPLXF(fabsf(ry), copysignf(rx, cimagf(z)))); }
DLLEXPORT float complex cprojf(float complex z) { if (!isinf(crealf(z)) && !isinf(cimagf(z))) return (z); else return (CMPLXF(INFINITY, copysignf(0.0, cimagf(z)))); }
float complex cpowf(float complex a, float complex z) { float complex w; float x, y, r, theta, absa, arga; x = crealf(z); y = cimagf(z); absa = cabsf (a); if (absa == 0.0f) { return (CMPLXF(0.0f, 0.0f)); } arga = cargf (a); r = powf (absa, x); theta = x * arga; if (y != 0.0f) { r = r * expf (-y * arga); theta = theta + y * logf (absa); } w = CMPLXF(r * cosf (theta), r * sinf (theta)); return (w); }
float complex csqrtf(float complex z) { double t; float a, b; a = creal(z); b = cimag(z); /* Handle special cases. */ if (z == 0) return (CMPLXF(0, b)); if (isinf(b)) return (CMPLXF(INFINITY, b)); if (isnan(a)) { t = (b - b) / (b - b); /* raise invalid if b is not a NaN */ return (CMPLXF(a + 0.0L + t, a + 0.0L + t)); /* NaN + NaN i */ } if (isinf(a)) { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i * csqrtf(-inf + NaN i) = NaN +- inf i * csqrtf(-inf + y i) = 0 + inf i */ if (signbit(a)) return (CMPLXF(fabsf(b - b), copysignf(a, b))); else return (CMPLXF(a, copysignf(b - b, b))); } if (isnan(b)) { t = (a - a) / (a - a); /* raise invalid */ return (CMPLXF(b + 0.0L + t, b + 0.0L + t)); /* NaN + NaN i */ } /* * We compute t in double precision to avoid overflow and to * provide correct rounding in nearly all cases. * This is Algorithm 312, CACM vol 10, Oct 1967. */ if (a >= 0) { t = sqrt((a + hypot(a, b)) * 0.5); return (CMPLXF(t, b / (2 * t))); } else { t = sqrt((-a + hypot(a, b)) * 0.5); return (CMPLXF(fabsf(b) / (2 * t), copysignf(t, b))); } }
float complex catanhf(float complex z) { float x, y, ax, ay, rx, ry; x = crealf(z); y = cimagf(z); ax = fabsf(x); ay = fabsf(y); if (y == 0 && ax <= 1) return (CMPLXF(atanhf(x), y)); if (x == 0) return (CMPLXF(x, atanf(y))); if (isnan(x) || isnan(y)) { if (isinf(x)) return (CMPLXF(copysignf(0, x), y + y)); if (isinf(y)) return (CMPLXF(copysignf(0, x), copysignf(pio2_hi + pio2_lo, y))); return (CMPLXF(x + 0.0L + (y + 0), x + 0.0L + (y + 0))); } if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) return (CMPLXF(real_part_reciprocal(x, y), copysignf(pio2_hi + pio2_lo, y))); if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) { raise_inexact(); return (z); } if (ax == 1 && ay < FLT_EPSILON) rx = (m_ln2 - logf(ay)) / 2; else rx = log1pf(4 * ax / sum_squares(ax - 1, ay)) / 4; if (ax == 1) ry = atan2f(2, -ay) / 2; else if (ay < FLT_EPSILON) ry = atan2f(2 * ay, (1 - ax) * (1 + ax)) / 2; else ry = atan2f(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2; return (CMPLXF(copysignf(rx, x), copysignf(ry, y))); }
float complex cexpf(float complex z) { float x, y, exp_x; uint32_t hx, hy; x = crealf(z); y = cimagf(z); GET_FLOAT_WORD(hy, y); hy &= 0x7fffffff; /* cexp(x + I 0) = exp(x) + I 0 */ if (hy == 0) return (CMPLXF(expf(x), y)); GET_FLOAT_WORD(hx, x); /* cexp(0 + I y) = cos(y) + I sin(y) */ if ((hx & 0x7fffffff) == 0) return (CMPLXF(cosf(y), sinf(y))); if (hy >= 0x7f800000) { if ((hx & 0x7fffffff) != 0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ return (CMPLXF(y - y, y - y)); } else if (hx & 0x80000000) { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ return (CMPLXF(0.0, 0.0)); } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ return (CMPLXF(x, y - y)); } } if (hx >= exp_ovfl && hx <= cexp_ovfl) { /* * x is between 88.7 and 192, so we must scale to avoid * overflow in expf(x). */ return (__ldexp_cexpf(z, 0)); } else { /* * Cases covered here: * - x < exp_ovfl and exp(x) won't overflow (common case) * - x > cexp_ovfl, so exp(x) * s overflows for all s > 0 * - x = +-Inf (generated by exp()) * - x = NaN (spurious inexact exception from y) */ exp_x = expf(x); return (CMPLXF(exp_x * cosf(y), exp_x * sinf(y))); } }
float complex casinhf(float complex z) { float x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y; int B_is_usable; float complex w; x = crealf(z); y = cimagf(z); ax = fabsf(x); ay = fabsf(y); if (isnan(x) || isnan(y)) { if (isinf(x)) return (CMPLXF(x, y + y)); if (isinf(y)) return (CMPLXF(y, x + x)); if (y == 0) return (CMPLXF(x + x, y)); return (CMPLXF(x + 0.0L + (y + 0), x + 0.0L + (y + 0))); } if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) { if (signbit(x) == 0) w = clog_for_large_values(z) + m_ln2; else w = clog_for_large_values(-z) + m_ln2; return (CMPLXF(copysignf(crealf(w), x), copysignf(cimagf(w), y))); } if (x == 0 && y == 0) return (z); raise_inexact(); if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4) return (z); do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y); if (B_is_usable) ry = asinf(B); else ry = atan2f(new_y, sqrt_A2my2); return (CMPLXF(copysignf(rx, x), copysignf(ry, y))); }
float complex cprojf(float complex z) { if (isinf(crealf(z)) || isinf(cimagf(z))) return CMPLXF(INFINITY, copysignf(0.0, crealf(z))); return z; }
float complex conjf(float complex z) { return (CMPLXF(crealf(z), -cimagf(z))); }
float complex cacosf(float complex z) { z = casinf(z); return CMPLXF((float)M_PI_2 - crealf(z), -cimagf(z)); }
float complex catanhf(float complex z) { z = catanf(CMPLXF(-cimagf(z), crealf(z))); return CMPLXF(cimagf(z), -crealf(z)); }
#include <stdint.h> #include <stddef.h> #include <complex.h> #include <assert.h> #include <nnpack/fft-defs.h> #include <fft/complex.h> void nnp_fft2_aos__ref( const float t[restrict static 4], size_t t_stride, float f[restrict static 4], size_t f_stride) { /* Load inputs */ float _Complex w0 = CMPLXF(t[0 * t_stride], t[1 * t_stride]); float _Complex w1 = CMPLXF(t[2 * t_stride], t[3 * t_stride]); fft2fc(&w0, &w1); /* Store outputs */ f[0 * f_stride] = crealf(w0); f[1 * f_stride] = cimagf(w0); f[2 * f_stride] = crealf(w1); f[3 * f_stride] = cimagf(w1); } void nnp_fft4_aos__ref( const float t[restrict static 8], size_t t_stride, float f[restrict static 8], size_t f_stride) { /* Load inputs */ float _Complex w0 = CMPLXF(t[0 * t_stride], t[1 * t_stride]);
float complex ccosf(float complex z) { return (ccoshf(CMPLXF(-cimagf(z), crealf(z)))); }
float complex ccoshf(float complex z) { float x, y, h; int32_t hx, hy, ix, iy; x = crealf(z); y = cimagf(z); GET_FLOAT_WORD(hx, x); GET_FLOAT_WORD(hy, y); ix = 0x7fffffff & hx; iy = 0x7fffffff & hy; if (ix < 0x7f800000 && iy < 0x7f800000) { if (iy == 0) return (CMPLXF(coshf(x), x * y)); if (ix < 0x41100000) /* |x| < 9: normal case */ return (CMPLXF(coshf(x) * cosf(y), sinhf(x) * sinf(y))); /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if (ix < 0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = expf(fabsf(x)) * 0.5F; return (CMPLXF(h * cosf(y), copysignf(h, x) * sinf(y))); } else if (ix < 0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ z = __ldexp_cexpf(CMPLXF(fabsf(x), y), -1); return (CMPLXF(crealf(z), cimagf(z) * copysignf(1, x))); } else { /* x >= 192.7: the result always overflows */ h = huge * x; return (CMPLXF(h * h * cosf(y), h * sinf(y))); } } if (ix == 0) /* && iy >= 0x7f800000 */ return (CMPLXF(y - y, x * copysignf(0, y))); if (iy == 0) /* && ix >= 0x7f800000 */ return (CMPLXF(x * x, copysignf(0, x) * y)); if (ix < 0x7f800000) /* && iy >= 0x7f800000 */ return (CMPLXF(y - y, x * (y - y))); if (ix == 0x7f800000) { if (iy >= 0x7f800000) return (CMPLXF(INFINITY, x * (y - y))); return (CMPLXF(INFINITY * cosf(y), x * sinf(y))); } return (CMPLXF((x * x) * (y - y), (x + x) * (y - y))); }