float complex csinhf(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 (cpackf(sinhf(x), y)); if (ix < 0x41100000) /* small x: normal case */ return (cpackf(sinhf(x) * cosf(y), coshf(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 (cpackf(copysignf(h, x) * cosf(y), h * sinf(y))); } else if (ix < 0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ z = __ldexp_cexpf(cpackf(fabsf(x), y), -1); return (cpackf(crealf(z) * copysignf(1, x), cimagf(z))); } else { /* x >= 192.7: the result always overflows */ h = huge * x; return (cpackf(h * cosf(y), h * h * sinf(y))); } } if (ix == 0 && iy >= 0x7f800000) return (cpackf(copysignf(0, x * (y - y)), y - y)); if (iy == 0 && ix >= 0x7f800000) { if ((hx & 0x7fffff) == 0) return (cpackf(x, y)); return (cpackf(x, copysignf(0, y))); } if (ix < 0x7f800000 && iy >= 0x7f800000) return (cpackf(y - y, x * (y - y))); if (ix >= 0x7f800000 && (hx & 0x7fffff) == 0) { if (iy >= 0x7f800000) return (cpackf(x * x, x * (y - y))); return (cpackf(x * cosf(y), INFINITY * sinf(y))); } return (cpackf((x * x) * (y - y), (x + x) * (y - y))); }
static float kepler(const float ecc, float mean_anom) { float curr, err, thresh; int is_negative = 0, n_iter = 0; if( !mean_anom) { return( 0.); } if( ecc < .3) { /* low-eccentricity formula from Meeus, p. 195 */ curr = atan2f( sinf( mean_anom), cosf( mean_anom) - ecc); /* one correction step, and we're done */ err = curr - ecc * sinf( curr) - mean_anom; curr -= err / (1. - ecc * cosf( curr)); } else { curr = mean_anom; } if( mean_anom < 0.) { mean_anom = -mean_anom; curr = - curr; is_negative = 1; } thresh = THRESH * fabsf( 1. - ecc); if( ecc > .8 && mean_anom < PI / 3. || ecc > 1.) /* up to 60 degrees */ { float trial = mean_anom / fabsf( 1. - ecc); if( trial * trial > 6. * fabsf(1. - ecc)) /* cubic term is dominant */ { if( mean_anom < PI) { trial = CUBE_ROOT( 6. * mean_anom); } else { /* hyperbolic w/ 5th & higher-order terms predominant */ trial = asinhf( mean_anom / ecc); } } curr = trial; } if( ecc < 1.) { err = curr - ecc * sinf( curr) - mean_anom; while( fabsf( err) > thresh) { n_iter++; curr -= err / (1. - ecc * cosf( curr)); err = curr - ecc * sinf( curr) - mean_anom; } } else { err = ecc * sinhf( curr) - curr - mean_anom; while( fabsf( err) > thresh) { n_iter++; curr -= err / (ecc * coshf( curr) - 1.); err = ecc * sinhf( curr) - curr - mean_anom; } } return( is_negative ? -curr : curr); }
ATF_TC_BODY(sinhf_nan, tc) { const float x = 0.0L / 0.0L; ATF_CHECK(isnan(x) != 0); ATF_CHECK(isnan(sinhf(x)) != 0); }
static TACommandVerdict sinhf_cmd(TAThread thread,TAInputStream stream) { float x, res; // Prepare x = readFloat(&stream); errno = 0; START_TARGET_OPERATION(thread); // Execute res = sinhf(x); END_TARGET_OPERATION(thread); // Response writeFloat(thread, res); writeInt(thread, errno); sendResponse(thread); return taDefaultVerdict; }
/** * Performs some maths operation */ static void performMathsOp(struct core_ctrl * core) { if (core->core_command-1000 == RANDOM_MATHS_OP) { core->data[0]=INT_TYPE; int r=rand(); memcpy(&core->data[1], &r, sizeof(int)); } else { float fvalue=0.0, r=0.0; if (core->data[0]==1) { fvalue=*((float*) &core->data[1]); } else if (core->data[0]==0) { fvalue=(float) *((int*) &core->data[1]); } if (core->core_command-1000 == SQRT_MATHS_OP) r=sqrtf(fvalue); if (core->core_command-1000 == SIN_MATHS_OP) r=sinf(fvalue); if (core->core_command-1000 == COS_MATHS_OP) r=cosf(fvalue); if (core->core_command-1000 == TAN_MATHS_OP) r=tanf(fvalue); if (core->core_command-1000 == ASIN_MATHS_OP) r=asinf(fvalue); if (core->core_command-1000 == ACOS_MATHS_OP) r=acosf(fvalue); if (core->core_command-1000 == ATAN_MATHS_OP) r=atanf(fvalue); if (core->core_command-1000 == SINH_MATHS_OP) r=sinhf(fvalue); if (core->core_command-1000 == COSH_MATHS_OP) r=coshf(fvalue); if (core->core_command-1000 == TANH_MATHS_OP) r=tanhf(fvalue); if (core->core_command-1000 == FLOOR_MATHS_OP) r=floorf(fvalue); if (core->core_command-1000 == CEIL_MATHS_OP) r=ceilf(fvalue); if (core->core_command-1000 == LOG_MATHS_OP) r=logf(fvalue); if (core->core_command-1000 == LOG10_MATHS_OP) r=log10f(fvalue); core->data[0]=REAL_TYPE; memcpy(&core->data[1], &r, sizeof(float)); } }
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 csinf (float complex Z) { float complex Res; __real__ Res = sinf (__real__ Z) * coshf ( __imag__ Z); __imag__ Res = cosf (__real__ Z) * sinhf ( __imag__ Z); return Res; }
/* Convert lla to utm (float). * Note this conversion is not very accurate. If high accuracy needed use lla_of_utm_d. * @param[out] utm position in m, alt is copied directly from lla * @param[in] lla position in rad, alt in m */ void utm_of_lla_f(struct UtmCoor_f *utm, struct LlaCoor_f *lla) { // compute zone if not initialised if (utm->zone == 0) { utm->zone = UtmZoneOfLlaLonRad(lla->lon); } float lambda_c = LambdaOfUtmZone(utm->zone); float ll = isometric_latitude_f(lla->lat , E); float dl = lla->lon - lambda_c; float phi_ = asinf(sinf(dl) / coshf(ll)); float ll_ = isometric_latitude_fast_f(phi_); float lambda_ = atanf(sinhf(ll) / cosf(dl)); struct complex z_ = { lambda_, ll_ }; CScal(serie_coeff_proj_mercator[0], z_); int8_t k; for (k = 1; k < 3; k++) { struct complex z = { lambda_, ll_ }; CScal(2.*k, z); CSin(z); CScal(serie_coeff_proj_mercator[k], z); CAdd(z, z_); } CScal(N, z_); utm->east = DELTA_EAST + z_.im; utm->north = DELTA_NORTH + z_.re; // copy alt above reference ellipsoid utm->alt = lla->alt; }
float complex CLANG_PORT_DECL(ccoshf) (float complex Z) { float complex Res; __real__ Res = coshf (__real__ Z) * cosf (__imag__ Z); __imag__ Res = sinhf (__real__ Z) * sinf (__imag__ Z); return Res; }
/* Convert utm to lla (float). * Note this conversion is not very accurate. If high accuracy needed use lla_of_utm_d. * @param[out] lla position in rad, alt is copied directly from utm * @param[in] utm position in m, alt in m */ void lla_of_utm_f(struct LlaCoor_f *lla, struct UtmCoor_f *utm) { float scale = 1 / N / serie_coeff_proj_mercator[0]; float real = (utm->north - DELTA_NORTH) * scale; float img = (utm->east - DELTA_EAST) * scale; struct complex z = { real, img }; int8_t k; for (k = 1; k < 2; k++) { struct complex z_ = { real, img }; CScal(2.*k, z_); CSin(z_); CScal(serie_coeff_proj_mercator_inverse[k], z_); CSub(z_, z); } float lambda_c = LambdaOfUtmZone(utm->zone); lla->lon = lambda_c + atanf(sinhf(z.im) / cosf(z.re)); float phi_ = asinf(sinf(z.re) / coshf(z.im)); float il = isometric_latitude_fast_f(phi_); lla->lat = inverse_isometric_latitude_f(il, E, 1e-8); // copy alt above reference ellipsoid lla->alt = utm->alt; }
void test_sinh() { static_assert((std::is_same<decltype(sinh((double)0)), double>::value), ""); static_assert((std::is_same<decltype(sinhf(0)), float>::value), ""); static_assert((std::is_same<decltype(sinhl(0)), long double>::value), ""); assert(sinh(0) == 0); }
/** * Called when running on the host, this performs some maths operation */ struct value_defn performMathsOp(unsigned short operation, struct value_defn value) { struct value_defn result; result.dtype=SCALAR; if (operation== RANDOM_MATHS_OP) { result.type=INT_TYPE; int r=rand(); cpy(result.data, &r, sizeof(int)); } else { float fvalue, r; if (value.type==REAL_TYPE) { fvalue=*((float*) value.data); } else if (value.type==INT_TYPE) { fvalue=(float) *((int*) value.data); } result.type=REAL_TYPE; if (operation==SQRT_MATHS_OP) r=sqrtf(fvalue); if (operation==SIN_MATHS_OP) r=sinf(fvalue); if (operation==COS_MATHS_OP) r=cosf(fvalue); if (operation==TAN_MATHS_OP) r=tanf(fvalue); if (operation==ASIN_MATHS_OP) r=asinf(fvalue); if (operation==ACOS_MATHS_OP) r=acosf(fvalue); if (operation==ATAN_MATHS_OP) r=atanf(fvalue); if (operation==SINH_MATHS_OP) r=sinhf(fvalue); if (operation==COSH_MATHS_OP) r=coshf(fvalue); if (operation==TANH_MATHS_OP) r=tanhf(fvalue); if (operation==FLOOR_MATHS_OP) r=floorf(fvalue); if (operation==CEIL_MATHS_OP) r=ceilf(fvalue); if (operation==LOG_MATHS_OP) r=logf(fvalue); if (operation==LOG10_MATHS_OP) r=log10f(fvalue); cpy(result.data, &r, sizeof(float)); } return result; }
float complex ctanf (float complex Z) { float complex Res; float two_I = 2.0f * __imag__ Z; float two_R = 2.0f * __real__ Z; float denom = cosf (two_R) + coshf (two_I); if (denom == 0.0f) { errno = ERANGE; __real__ Res = HUGE_VALF; __imag__ Res = HUGE_VALF; } else if (isinf (denom)) { errno = ERANGE; __real__ Res = 0.0; __imag__ Res = two_I > 0 ? 1.0f : -1.0f; } else { __real__ Res = sinf (two_R) / denom; __imag__ Res = sinhf (two_I) / denom; } return Res; }
ATF_TC_BODY(sinhf_zero_pos, tc) { const float x = 0.0L; float y = sinhf(x); if (fabsf(y) > 0.0 || signbit(y) != 0) atf_tc_fail_nonfatal("sinhf(+0.0) != +0.0"); }
ATF_TC_BODY(sinhf_inf_pos, tc) { const float x = 1.0L / 0.0L; float y = sinhf(x); ATF_CHECK(isinf(y) != 0); ATF_CHECK(signbit(y) == 0); }
static void *sinh_new(t_floatarg f) { t_sinh *x = (t_sinh *)pd_new(sinh_class); /* CHECKME large values */ x->x_value = sinhf(f); outlet_new((t_object *)x, &s_float); return (x); }
complex __ccos(float zreal, float zimag) { complex r; r.real = cosf(zreal) * coshf(zimag); r.imag = - sinf(zreal) * sinhf(zimag); return r; }
ATF_TC_BODY(sinhf_zero_neg, tc) { const float x = -0.0L; float y = sinhf(x); if (fabsf(y) > 0.0 || signbit(y) == 0) atf_tc_fail_nonfatal("sinhf(-0.0) != -0.0"); }
float complex csinhf(float complex z) { float complex w; float x, y; x = crealf(z); y = cimagf(z); w = sinhf (x) * cosf (y) + (coshf (x) * sinf (y)) * I; return (w); }
float complex ccoshf (float complex a) { float r, i; float complex v; r = REALPART (a); i = IMAGPART (a); COMPLEX_ASSIGN (v, coshf (r) * cosf (i), - (sinhf (r) * sinf (i))); return v; }
float complex ccoshf(float complex z) { float complex w; float x, y; x = creal(z); y = cimag(z); w = coshf (x) * cosf (y) + (sinhf (x) * sinf (y)) * I; return (w); }
float complex ctanhf(float complex z) { float complex w; float x, y, d; x = crealf(z); y = cimagf(z); d = coshf (2.0f * x) + cosf (2.0f * y); w = sinhf (2.0f * x) / d + (sinf (2.0f * y) / d) * I; return (w); }
/* cosh(z) = cosh(a)cos(b) - isinh(a)sin(b) */ GFC_COMPLEX_4 ccoshf (GFC_COMPLEX_4 a) { GFC_REAL_4 r; GFC_REAL_4 i; GFC_COMPLEX_4 v; r = REALPART (a); i = IMAGPART (a); COMPLEX_ASSIGN (v, coshf (r) * cosf (i), - (sinhf (r) * sinf (i))); return v; }
// substitute STDampedSpringStep's r with ri (i=imaginary unit), // you get over-damping equation. float STOverDampedSpringStep(float value){ const float r=3.3f; // [???] if(value<0.f)value=0.f; if(value>1.f)value=1.f; float theta=r*value; float v=1.f; float tt=(value*(value-2.f)+1.f); v-=tt*coshf(theta); v-=(2.f/r)*(value*(value-2.f)+1.f)*sinhf(theta); return v; }
kiss_fft_cpx sf_ccosf(kiss_fft_cpx z) /*< complex cosine >*/ { float x, y; x = z.r; y = z.i; z.r = coshf(y)*cosf(x); z.i = -sinhf(y)*sinf(x); return z; }
kiss_fft_cpx sf_csinhf(kiss_fft_cpx z) /*< complex hyperbolic sine >*/ { float x, y; x = z.r; y = z.i; z.r = sinhf(x)*cosf(y); z.i = coshf(x)*sinf(y); return z; }
kiss_fft_cpx sf_ctanhf(kiss_fft_cpx z) /*< complex hyperbolic tangent >*/ { float x, y, d; x = z.r; y = z.i; d = coshf(2*x) + cosf(2*y); z.r = sinhf(2*x)/ d; z.i = sinf (2*y)/ d; return z; }
ATF_TC_BODY(sinhf_inrange, tc) { float eps; float x; float y; size_t i; for (i = 0; i < __arraycount(values); i++) { x = values[i].x; y = values[i].y; eps = 1e-6 * values[i].e; if (fabsf(sinhf(x) - y) > eps) atf_tc_fail_nonfatal("sinhf(%g) != %g\n", x, y); } }
static void cchshf(float xx, float *c, float *s) { float x, e, ei; x = xx; if(fabsf(x) <= 0.5f) { *c = coshf(x); *s = sinhf(x); } else { e = expf(x); ei = 0.5f/e; e = 0.5f * e; *s = e - ei; *c = e + ei; } }
float complex ctanf(float complex z) { float complex w; float d; d = cosf( 2.0f * crealf(z) ) + coshf( 2.0f * cimagf(z) ); if(fabsf(d) < 0.25f) d = _ctansf(z); if (d == 0.0f) { /*mtherr( "ctanf", OVERFLOW );*/ w = MAXNUMF + MAXNUMF * I; return (w); } w = sinf (2.0f * crealf(z)) / d + (sinhf (2.0f * cimagf(z)) / d) * I; return (w); }