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);
}
