void pc_init(unsigned buffer_chunks, unsigned int buffered_before_play) { pc.buffer_chunks = buffer_chunks; pc.buffered_before_play = buffered_before_play; pc.mutex = g_mutex_new(); pc.cond = g_cond_new(); pc.command = PLAYER_COMMAND_NONE; pc.error = PLAYER_ERROR_NOERROR; pc.state = PLAYER_STATE_STOP; pc.cross_fade_seconds = 0; pc.mixramp_db = 0; pc.mixramp_delay_seconds = nanf(""); }
float acosf(float x) /* wrapper acosf */ { #ifdef _IEEE_LIBM return __ieee754_acosf(x); #else float z; z = __ieee754_acosf(x); if(_LIB_VERSION == _IEEE_ || isnan(x)) return z; if(fabsf(x)>1.0f) { /* acosf(|x|>1) */ errno = EDOM; return nanf(""); } else return z; #endif }
TEST(math, fpclassify) { ASSERT_EQ(FP_INFINITE, fpclassify(INFINITY)); ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALF)); ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VAL)); ASSERT_EQ(FP_NAN, fpclassify(nanf(""))); ASSERT_EQ(FP_NAN, fpclassify(nan(""))); ASSERT_EQ(FP_NORMAL, fpclassify(1.0f)); ASSERT_EQ(FP_NORMAL, fpclassify(1.0)); ASSERT_EQ(FP_SUBNORMAL, fpclassify(float_subnormal())); ASSERT_EQ(FP_SUBNORMAL, fpclassify(double_subnormal())); ASSERT_EQ(FP_ZERO, fpclassify(0.0f)); ASSERT_EQ(FP_ZERO, fpclassify(0.0)); }
struct player_control * pc_new(unsigned buffer_chunks, unsigned int buffered_before_play) { struct player_control *pc = g_new0(struct player_control, 1); pc->buffer_chunks = buffer_chunks; pc->buffered_before_play = buffered_before_play; pc->mutex = g_mutex_new(); pc->cond = g_cond_new(); pc->command = PLAYER_COMMAND_NONE; pc->error_type = PLAYER_ERROR_NONE; pc->state = PLAYER_STATE_STOP; pc->cross_fade_seconds = 0; pc->mixramp_db = 0; pc->mixramp_delay_seconds = nanf(""); return pc; }
sl_def(do_test, void) { #define x values[p].d #define xf values[p].f #define y values[p+1].d #define yf values[p+1].f #define n values[p+2].i #define nl values[p+2].l #define call1(F) \ values[p].desc = #F; \ values[p].d = F(x); \ ++p; \ values[p].desc = #F "f"; \ values[p].f = F ## f (xf); \ ++p #define call1i(F) \ values[p].desc = #F; \ values[p].i = F(x); \ ++p #define call2(F) \ values[p].desc = #F; \ values[p].d = F(x, y); \ p += 2; \ values[p].desc = #F "f"; \ values[p].f = F ## f (xf, yf); \ p += 2 #define call2i(F) \ values[p].desc = #F; \ values[p].i = F(x, y); \ p += 2; \ values[p].desc = #F "f"; \ values[p].i = F(xf, yf); \ p += 2 /* classify */ call1i(fpclassify); call1i(signbit); call1i(isfinite); call1i(isnormal); call1i(isnan); call1i(isinf); /* trig */ call1(acos); call1(asin); call1(atan); call2(atan2); call1(cos); call1(sin); call1(tan); /* hyperbolic */ call1(acosh); call1(asinh); call1(atanh); call1(cosh); call1(sinh); call1(tanh); /* exp/log */ call1(exp); call1(exp2); call1(expm1); values[p].desc = "frexp"; values[p].d = frexp(x, &values[p+1].i); p += 2; values[p].desc = "frexpf"; values[p].f = frexpf(xf, &values[p+1].i); p += 2; values[p].desc = "ilogb"; values[p].i = ilogb(x); p++; values[p].desc = "ilogbf"; values[p].i = ilogbf(xf); p++; values[p].desc = "ldexp"; values[p].d = ldexp(x, n); p+=3; values[p].desc = "ldexpf"; values[p].f = ldexpf(xf, n); p+=3; call1(log); call1(log10); call1(log1p); call1(log2); call1(logb); values[p].desc = "modf"; values[p].d = modf(x, &y); p += 2; values[p].desc = "modff"; values[p].f = modff(xf, &yf); p += 2; values[p].desc = "scalbn"; values[p].d = scalbn(x, n); p+=3; values[p].desc = "scalbnf"; values[p].f = scalbnf(xf, n); p+=3; values[p].desc = "scalbln"; values[p].d = scalbln(x, nl); p+=3; values[p].desc = "scalblnf"; values[p].f = scalblnf(xf, nl); p+=3; /* power/abs */ call1(cbrt); call1(fabs); call2(hypot); call2(pow); call1(sqrt); /* error/gamma */ call1(erf); call1(erfc); call1(lgamma); call1(tgamma); call1(ceil); call1(floor); call1(nearbyint); call1(rint); call1(lrint); values[p].desc = "lrint"; values[p].l = lrint(x); p++; values[p].desc = "lrintf"; values[p].l = lrintf(xf); p++; values[p].desc = "llrint"; values[p].ll = llrint(x); p++; values[p].desc = "llrintf"; values[p].ll = llrintf(xf); p++; call1(round); values[p].desc = "lround"; values[p].l = lround(x); p++; values[p].desc = "lroundf"; values[p].l = lroundf(xf); p++; values[p].desc = "llround"; values[p].ll = llround(x); p++; values[p].desc = "llroundf"; values[p].ll = llroundf(xf); p++; call1(trunc); /* rem/mod */ call2(fmod); call2(remainder); values[p].desc = "remquo"; values[p].d = remquo(x, y, &values[p+1].i); p+=2; values[p].desc = "remquof"; values[p].f = remquof(xf, yf, &values[p+1].i); p+=2; call2(copysign); /* nan */ values[p].desc = "nan"; values[p].d = nan(""); ++p; values[p].desc = "nanf"; values[p].f = nanf(""); ++p; call2(nextafter); /* min/max/dim */ call2(fdim); call2(fmax); call2(fmin); values[p].desc = "fma"; values[p].d = fma(x, y, values[p+2].d); p+=3; values[p].desc = "fmaf"; values[p].d = fmaf(xf, yf, values[p+2].f); p+=3; /* comp */ call2i(isgreater); call2i(isgreaterequal); call2i(isless); call2i(islessequal); call2i(islessgreater); call2i(isunordered); #undef x #undef xf #undef y #undef n }
void domathf (void) { #ifndef NO_FLOAT float f1; float f2; int i1; f1 = acosf(0.0); fprintf( stdout, "acosf : %f\n", f1); f1 = acoshf(0.0); fprintf( stdout, "acoshf : %f\n", f1); f1 = asinf(1.0); fprintf( stdout, "asinf : %f\n", f1); f1 = asinhf(1.0); fprintf( stdout, "asinhf : %f\n", f1); f1 = atanf(M_PI_4); fprintf( stdout, "atanf : %f\n", f1); f1 = atan2f(2.3, 2.3); fprintf( stdout, "atan2f : %f\n", f1); f1 = atanhf(1.0); fprintf( stdout, "atanhf : %f\n", f1); f1 = cbrtf(27.0); fprintf( stdout, "cbrtf : %f\n", f1); f1 = ceilf(3.5); fprintf( stdout, "ceilf : %f\n", f1); f1 = copysignf(3.5, -2.5); fprintf( stdout, "copysignf : %f\n", f1); f1 = cosf(M_PI_2); fprintf( stdout, "cosf : %f\n", f1); f1 = coshf(M_PI_2); fprintf( stdout, "coshf : %f\n", f1); f1 = erff(42.0); fprintf( stdout, "erff : %f\n", f1); f1 = erfcf(42.0); fprintf( stdout, "erfcf : %f\n", f1); f1 = expf(0.42); fprintf( stdout, "expf : %f\n", f1); f1 = exp2f(0.42); fprintf( stdout, "exp2f : %f\n", f1); f1 = expm1f(0.00042); fprintf( stdout, "expm1f : %f\n", f1); f1 = fabsf(-1.123); fprintf( stdout, "fabsf : %f\n", f1); f1 = fdimf(1.123, 2.123); fprintf( stdout, "fdimf : %f\n", f1); f1 = floorf(0.5); fprintf( stdout, "floorf : %f\n", f1); f1 = floorf(-0.5); fprintf( stdout, "floorf : %f\n", f1); f1 = fmaf(2.1, 2.2, 3.01); fprintf( stdout, "fmaf : %f\n", f1); f1 = fmaxf(-0.42, 0.42); fprintf( stdout, "fmaxf : %f\n", f1); f1 = fminf(-0.42, 0.42); fprintf( stdout, "fminf : %f\n", f1); f1 = fmodf(42.0, 3.0); fprintf( stdout, "fmodf : %f\n", f1); /* no type-specific variant */ i1 = fpclassify(1.0); fprintf( stdout, "fpclassify : %d\n", i1); f1 = frexpf(42.0, &i1); fprintf( stdout, "frexpf : %f\n", f1); f1 = hypotf(42.0, 42.0); fprintf( stdout, "hypotf : %f\n", f1); i1 = ilogbf(42.0); fprintf( stdout, "ilogbf : %d\n", i1); /* no type-specific variant */ i1 = isfinite(3.0); fprintf( stdout, "isfinite : %d\n", i1); /* no type-specific variant */ i1 = isgreater(3.0, 3.1); fprintf( stdout, "isgreater : %d\n", i1); /* no type-specific variant */ i1 = isgreaterequal(3.0, 3.1); fprintf( stdout, "isgreaterequal : %d\n", i1); /* no type-specific variant */ i1 = isinf(3.0); fprintf( stdout, "isinf : %d\n", i1); /* no type-specific variant */ i1 = isless(3.0, 3.1); fprintf( stdout, "isless : %d\n", i1); /* no type-specific variant */ i1 = islessequal(3.0, 3.1); fprintf( stdout, "islessequal : %d\n", i1); /* no type-specific variant */ i1 = islessgreater(3.0, 3.1); fprintf( stdout, "islessgreater : %d\n", i1); /* no type-specific variant */ i1 = isnan(0.0); fprintf( stdout, "isnan : %d\n", i1); /* no type-specific variant */ i1 = isnormal(3.0); fprintf( stdout, "isnormal : %d\n", i1); /* no type-specific variant */ f1 = isunordered(1.0, 2.0); fprintf( stdout, "isunordered : %d\n", i1); f1 = j0f(1.2); fprintf( stdout, "j0f : %f\n", f1); f1 = j1f(1.2); fprintf( stdout, "j1f : %f\n", f1); f1 = jnf(2,1.2); fprintf( stdout, "jnf : %f\n", f1); f1 = ldexpf(1.2,3); fprintf( stdout, "ldexpf : %f\n", f1); f1 = lgammaf(42.0); fprintf( stdout, "lgammaf : %f\n", f1); f1 = llrintf(-0.5); fprintf( stdout, "llrintf : %f\n", f1); f1 = llrintf(0.5); fprintf( stdout, "llrintf : %f\n", f1); f1 = llroundf(-0.5); fprintf( stdout, "lroundf : %f\n", f1); f1 = llroundf(0.5); fprintf( stdout, "lroundf : %f\n", f1); f1 = logf(42.0); fprintf( stdout, "logf : %f\n", f1); f1 = log10f(42.0); fprintf( stdout, "log10f : %f\n", f1); f1 = log1pf(42.0); fprintf( stdout, "log1pf : %f\n", f1); f1 = log2f(42.0); fprintf( stdout, "log2f : %f\n", f1); f1 = logbf(42.0); fprintf( stdout, "logbf : %f\n", f1); f1 = lrintf(-0.5); fprintf( stdout, "lrintf : %f\n", f1); f1 = lrintf(0.5); fprintf( stdout, "lrintf : %f\n", f1); f1 = lroundf(-0.5); fprintf( stdout, "lroundf : %f\n", f1); f1 = lroundf(0.5); fprintf( stdout, "lroundf : %f\n", f1); f1 = modff(42.0,&f2); fprintf( stdout, "lmodff : %f\n", f1); f1 = nanf(""); fprintf( stdout, "nanf : %f\n", f1); f1 = nearbyintf(1.5); fprintf( stdout, "nearbyintf : %f\n", f1); f1 = nextafterf(1.5,2.0); fprintf( stdout, "nextafterf : %f\n", f1); f1 = powf(3.01, 2.0); fprintf( stdout, "powf : %f\n", f1); f1 = remainderf(3.01,2.0); fprintf( stdout, "remainderf : %f\n", f1); f1 = remquof(29.0,3.0,&i1); fprintf( stdout, "remquof : %f\n", f1); f1 = rintf(0.5); fprintf( stdout, "rintf : %f\n", f1); f1 = rintf(-0.5); fprintf( stdout, "rintf : %f\n", f1); f1 = roundf(0.5); fprintf( stdout, "roundf : %f\n", f1); f1 = roundf(-0.5); fprintf( stdout, "roundf : %f\n", f1); f1 = scalblnf(1.2,3); fprintf( stdout, "scalblnf : %f\n", f1); f1 = scalbnf(1.2,3); fprintf( stdout, "scalbnf : %f\n", f1); /* no type-specific variant */ i1 = signbit(1.0); fprintf( stdout, "signbit : %i\n", i1); f1 = sinf(M_PI_4); fprintf( stdout, "sinf : %f\n", f1); f1 = sinhf(M_PI_4); fprintf( stdout, "sinhf : %f\n", f1); f1 = sqrtf(9.0); fprintf( stdout, "sqrtf : %f\n", f1); f1 = tanf(M_PI_4); fprintf( stdout, "tanf : %f\n", f1); f1 = tanhf(M_PI_4); fprintf( stdout, "tanhf : %f\n", f1); f1 = tgammaf(2.1); fprintf( stdout, "tgammaf : %f\n", f1); f1 = truncf(3.5); fprintf( stdout, "truncf : %f\n", f1); f1 = y0f(1.2); fprintf( stdout, "y0f : %f\n", f1); f1 = y1f(1.2); fprintf( stdout, "y1f : %f\n", f1); f1 = ynf(3,1.2); fprintf( stdout, "ynf : %f\n", f1); #endif }
double nan(const char *arg) { return (double) nanf(arg); }
void test_nan() { static_assert((std::is_same<decltype(nan("")), double>::value), ""); static_assert((std::is_same<decltype(nanf("")), float>::value), ""); static_assert((std::is_same<decltype(nanl("")), long double>::value), ""); }
float __builtin_nanf(const char *tagp) { return nanf(tagp); }
// Here is where the real job is done static PyObject* ZBufferTo3D_recover(PyZBufferTo3D* self, PyObject* args) { Py_buffer img_buffer; int i, pixel, npixels; double z_b; float z_n, z_e; float x, y; int u, v; float * fbuffer; // Read the incomming data as a buffer. It is originally a bgl.Buffer object if (!PyArg_ParseTuple(args, "w*", &img_buffer)) return NULL; // check that there is no division by 0 if (self->width == 0) return NULL; fbuffer = (float *) img_buffer.buf; npixels = img_buffer.len / 4; // rgba (sizeof float = 4B) for (i = 0, pixel = 0; pixel < npixels; pixel++) { z_b = fbuffer[pixel]; if (z_b >= 1.0) { self->points[i] = nanf(""); self->points[i+1] = nanf(""); self->points[i+2] = nanf(""); i += 3; continue; // nothing seen within the far clipping } z_n = 2.0 * z_b - 1.0; z_e = 2.0 * self->near * self->far / (self->far + self->near - z_n * (self->far - self->near)); // The image we receive is stored as a single array of floats. // Pixel 0, 0 in the data is located at the bottom left, according to // the OpenGL conventions. // We need to convert this frame of reference to (u, v), starting at the // top left u = pixel % self->width; v = self->height - (pixel / self->width); // Use the intrinsic matrix of the camera view to get the 3D coordinates // corresponding to each pixel, with respect to the camera x = z_e * (u - self->u_0) / self->alpha_u; y = z_e * (v - self->v_0) / self->alpha_v; // Store the x, y, z coordinates in the buffer self->points[i] = x; self->points[i+1] = y; self->points[i+2] = z_e; i += 3; } // release the Python buffers PyBuffer_Release(&img_buffer); return PyMemoryView_FromMemory((char *)self->points, i*sizeof(float), PyBUF_READ); }
TEST(math, powf) { ASSERT_TRUE(isnanf(powf(nanf(""), 3.0f))); ASSERT_FLOAT_EQ(1.0f, (powf(1.0f, nanf("")))); ASSERT_TRUE(isnanf(powf(2.0f, nanf("")))); ASSERT_FLOAT_EQ(8.0f, powf(2.0f, 3.0f)); }
TEST(math, isnanf) { ASSERT_FALSE(isnanf(123.0f)); ASSERT_TRUE(isnanf(nanf(""))); }
TEST(math, isnan) { ASSERT_FALSE(test_capture_isnan(123.0f)); ASSERT_FALSE(test_capture_isnan(123.0)); ASSERT_TRUE(test_capture_isnan(nanf(""))); ASSERT_TRUE(test_capture_isnan(nan(""))); }
float remquof ( float x, float y, int *quo) { int iclx,icly; /* classify results of x,y */ int32_t iquo; /* low 32 bits of integral quotient */ int32_t iscx, iscy, idiff; /* logb values and difference */ int i; /* loop variable */ float absy,x1,y1,z; /* local floating-point variables */ float rslt; fenv_t OldEnv; hexdouble OldEnvironment; int newexc; FEGETENVD ( OldEnvironment.d ); FESETENVD ( 0.0 ); __NOOP; __NOOP; OldEnv = OldEnvironment.i.lo; *quo = 0; /* initialize quotient result */ iclx = __fpclassifyf(x); icly = __fpclassifyf(y); if (likely((iclx & icly) >= FP_NORMAL)) { /* x,y both nonzero finite case */ x1 = __FABSF(x); /* work with absolute values */ absy = __FABSF(y); iquo = 0; /* zero local quotient */ iscx = (int32_t) logbf(x1); /* get binary exponents */ iscy = (int32_t) logbf(absy); idiff = iscx - iscy; /* exponent difference */ if (idiff >= 0) { /* exponent of x1 >= exponent of y1 */ if (idiff != 0) { /* exponent of x1 > exponent of y1 */ y1 = scalbnf(absy,-iscy); /* scale |y| to unit binade */ x1 = scalbnf(x1,-iscx); /* ditto for |x| */ for (i = idiff; i != 0; i--) { /* begin remainder loop */ if ((z = x1 - y1) >= 0) { /* nonzero remainder step result */ x1 = z; /* update remainder (x1) */ iquo += 1; /* increment quotient */ } iquo += iquo; /* shift quotient left one bit */ x1 += x1; /* shift (double) remainder */ } /* end of remainder loop */ x1 = scalbnf(x1,iscy); /* scale remainder to binade of |y| */ } /* remainder has exponent <= exponent of y */ if (x1 >= absy) { /* last remainder step */ x1 -= absy; iquo +=1; } /* end of last remainder step */ } /* remainder (x1) has smaller exponent than y */ if (likely( x1 < HugeFHalved.fval )) z = x1 + x1; /* double remainder, without overflow */ else z = HugeF.fval; if ((z > absy) || ((z == absy) && ((iquo & 1) != 0))) { x1 -= absy; /* final remainder correction */ iquo += 1; } if (x < 0.0) x1 = -x1; /* remainder if x is negative */ iquo &= 0x0000007f; /* retain low 7 bits of integer quotient */ if ((signbit(x) ^ signbit(y)) != 0) /* take care of sign of quotient */ iquo = -iquo; *quo = iquo; /* deliver quotient result */ rslt = x1; goto ret; } /* end of x,y both nonzero finite case */ else if ((iclx <= FP_QNAN) || (icly <= FP_QNAN)) { rslt = x+y; /* at least one NaN operand */ goto ret; } else if ((iclx == FP_INFINITE)||(icly == FP_ZERO)) { /* invalid result */ rslt = nanf(REM_NAN); OldEnvironment.i.lo |= SET_INVALID; FESETENVD_GRP( OldEnvironment.d ); goto ret; } else /* trivial cases (finite REM infinite */ rslt = x; /* or zero REM nonzero) with *quo = 0 */ ret: FEGETENVD_GRP( OldEnvironment.d ); newexc = OldEnvironment.i.lo & FE_ALL_EXCEPT; OldEnvironment.i.lo = OldEnv; if ((newexc & FE_INVALID) != 0) OldEnvironment.i.lo |= SET_INVALID; OldEnvironment.i.lo |= newexc & ( FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW ); FESETENVD_GRP( OldEnvironment.d ); return rslt; }
TEST(math, fminf) { ASSERT_FLOAT_EQ(10.0f, fminf(12.0f, 10.0f)); ASSERT_FLOAT_EQ(12.0f, fminf(12.0f, nanf(""))); ASSERT_FLOAT_EQ(12.0f, fminf(nanf(""), 12.0f)); }
float fmodf ( float x, float y ) { int iclx,icly; /* classify results of x,y */ int32_t iscx,iscy,idiff; /* logb values and difference */ int i; /* loop variable */ float absy,x1,y1,z; /* local floating-point variables */ float rslt; fenv_t OldEnv; hexdouble OldEnvironment; int newexc; FEGETENVD( OldEnvironment.d ); FESETENVD( 0.0 ); __NOOP; __NOOP; OldEnv = OldEnvironment.i.lo; iclx = __fpclassifyf(x); icly = __fpclassifyf(y); if (likely((iclx & icly) >= FP_NORMAL)) { /* x,y both nonzero finite case */ x1 = __FABSF(x); /* work with absolute values */ absy = __FABSF(y); if (absy > x1) { rslt = x; /* trivial case */ goto ret; } else { /* nontrivial case requires reduction */ iscx = (int32_t) logbf(x1); /* get binary exponents of |x| and |y| */ iscy = (int32_t) logbf(absy); idiff = iscx - iscy; /* exponent difference */ if (idiff != 0) { /* exponent of x1 > exponent of y1 */ y1 = scalbnf(absy,-iscy); /* scale |y| to unit binade */ x1 = scalbnf(x1,-iscx); /* ditto for |x| */ for (i = idiff; i != 0; i--) { /* begin remainder loop */ if ((z = x1 - y1) >= 0) { /* nonzero remainder step result */ x1 = z; /* update remainder (x1) */ } x1 += x1; /* shift (by doubling) remainder */ } /* end of remainder loop */ x1 = scalbnf(x1,iscy); /* scale result to binade of |y| */ } /* remainder exponent >= exponent of y */ if (x1 >= absy) { /* last step to obtain modulus */ x1 -= absy; } } /* x1 is |result| */ if (x < 0.0) x1 = -x1; /* modulus if x is negative */ rslt = x1; goto ret; } /* end of x,y both nonzero finite case */ else if ((iclx <= FP_QNAN) || (icly <= FP_QNAN)) { rslt = x+y; /* at least one NaN operand */ goto ret; } else if ((iclx == FP_INFINITE)||(icly == FP_ZERO)) { /* invalid result */ rslt = nanf(REM_NAN); OldEnvironment.i.lo |= SET_INVALID; FESETENVD_GRP ( OldEnvironment.d ); goto ret; } else /* trivial cases (finite MOD infinite */ rslt = x; /* or zero REM nonzero) with *quo = 0 */ ret: FEGETENVD_GRP (OldEnvironment.d ); newexc = OldEnvironment.i.lo & FE_ALL_EXCEPT; OldEnvironment.i.lo = OldEnv; if ((newexc & FE_INVALID) != 0) OldEnvironment.i.lo |= SET_INVALID; OldEnvironment.i.lo |= newexc & ( FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW ); FESETENVD_GRP (OldEnvironment.d ); return rslt; }
TEST(math, log1pf) { ASSERT_EQ(-HUGE_VALF, log1pf(-1.0f)); ASSERT_TRUE(isnanf(log1pf(nanf("")))); ASSERT_TRUE(__isinff(log1pf(HUGE_VALF))); ASSERT_FLOAT_EQ(1.0f, log1pf(static_cast<float>(M_E) - 1.0f)); }
void testnan(const char *nan_format) { char nan_str[128]; char *end; long double ald[4]; double ad[4]; float af[4]; int i; snprintf(nan_str, sizeof(nan_str), "nan(%s)", nan_format); for (i = 0; i < 4; i++) { /* * x86 has an 80-bit long double stored in 96 bits, * so we need to initialize the memory for the memcmp() * checks below to work. */ bzero(&af[i], sizeof(float)); bzero(&ad[i], sizeof(double)); bzero(&ald[i], sizeof(long double)); } af[0] = nanf(nan_format); assert(isnan(af[0])); af[1] = strtof(nan_str, &end); assert(end == nan_str + strlen(nan_str)); assert(sscanf(nan_str, "%e", &af[2]) == 1); assert(memcmp(&af[0], &af[1], sizeof(float)) == 0); #if !__gnu_linux__ assert(memcmp(&af[1], &af[2], sizeof(float)) == 0); #endif /* !__gnu_linux__ */ if (*nan_format == '\0') { /* nanf("") == strtof("nan") */ af[3] = strtof("nan", NULL); assert(memcmp(&af[2], &af[3], sizeof(float)) == 0); } ad[0] = nan(nan_format); assert(isnan(ad[0])); ad[1] = strtod(nan_str, &end); assert(end == nan_str + strlen(nan_str)); assert(sscanf(nan_str, "%le", &ad[2]) == 1); assert(memcmp(&ad[0], &ad[1], sizeof(double)) == 0); #if !__gnu_linux__ assert(memcmp(&ad[1], &ad[2], sizeof(double)) == 0); #endif /* !__gnu_linux__ */ if (*nan_format == '\0') { /* nan("") == strtod("nan") */ ad[3] = strtod("nan", NULL); assert(memcmp(&ad[2], &ad[3], sizeof(double)) == 0); } ald[0] = nanl(nan_format); assert(isnan(ald[0])); ald[1] = strtold(nan_str, &end); assert(end == nan_str + strlen(nan_str)); assert(sscanf(nan_str, "%Le", &ald[2]) == 1); assert(memcmp(&ald[0], &ald[1], sizeof(long double)) == 0); #if 0 assert(memcmp(&ald[1], &ald[2], sizeof(long double)) == 0); if (*nan_format == '\0') { /* nanl("") == strtold("nan") */ ald[3] = strtold("nan", NULL); assert(memcmp(&ald[2], &ald[3], sizeof(long double)) == 0); } #endif }
__global__ void FloatMathPrecise() { int iX; float fX, fY; acosf(1.0f); acoshf(1.0f); asinf(0.0f); asinhf(0.0f); atan2f(0.0f, 1.0f); atanf(0.0f); atanhf(0.0f); cbrtf(0.0f); fX = ceilf(0.0f); fX = copysignf(1.0f, -2.0f); cosf(0.0f); coshf(0.0f); cospif(0.0f); cyl_bessel_i0f(0.0f); cyl_bessel_i1f(0.0f); erfcf(0.0f); erfcinvf(2.0f); erfcxf(0.0f); erff(0.0f); erfinvf(1.0f); exp10f(0.0f); exp2f(0.0f); expf(0.0f); expm1f(0.0f); fX = fabsf(1.0f); fdimf(1.0f, 0.0f); fdividef(0.0f, 1.0f); fX = floorf(0.0f); fmaf(1.0f, 2.0f, 3.0f); fX = fmaxf(0.0f, 0.0f); fX = fminf(0.0f, 0.0f); fmodf(0.0f, 1.0f); frexpf(0.0f, &iX); hypotf(1.0f, 0.0f); ilogbf(1.0f); isfinite(0.0f); fX = isinf(0.0f); fX = isnan(0.0f); j0f(0.0f); j1f(0.0f); jnf(-1.0f, 1.0f); ldexpf(0.0f, 0); lgammaf(1.0f); llrintf(0.0f); llroundf(0.0f); log10f(1.0f); log1pf(-1.0f); log2f(1.0f); logbf(1.0f); logf(1.0f); lrintf(0.0f); lroundf(0.0f); modff(0.0f, &fX); fX = nanf("1"); fX = nearbyintf(0.0f); nextafterf(0.0f, 0.0f); norm3df(1.0f, 0.0f, 0.0f); norm4df(1.0f, 0.0f, 0.0f, 0.0f); normcdff(0.0f); normcdfinvf(1.0f); fX = 1.0f; normf(1, &fX); powf(1.0f, 0.0f); rcbrtf(1.0f); remainderf(2.0f, 1.0f); remquof(1.0f, 2.0f, &iX); rhypotf(0.0f, 1.0f); fY = rintf(1.0f); rnorm3df(0.0f, 0.0f, 1.0f); rnorm4df(0.0f, 0.0f, 0.0f, 1.0f); fX = 1.0f; rnormf(1, &fX); fY = roundf(0.0f); rsqrtf(1.0f); scalblnf(0.0f, 1); scalbnf(0.0f, 1); signbit(1.0f); sincosf(0.0f, &fX, &fY); sincospif(0.0f, &fX, &fY); sinf(0.0f); sinhf(0.0f); sinpif(0.0f); sqrtf(0.0f); tanf(0.0f); tanhf(0.0f); tgammaf(2.0f); fY = truncf(0.0f); y0f(1.0f); y1f(1.0f); ynf(1, 1.0f); }