float scalbf(float x, float fn)
{
if (isnan(x) || isnan(fn)) return x*fn;
if (!isfinite(fn)) {
if (fn > 0.0f)
return x*fn;
else
return x/(-fn);
}
if (rintf(fn) != fn) return (fn-fn)/(fn-fn);
if ( fn > 65000.0f) return scalbnf(x, 65000);
if (-fn > 65000.0f) return scalbnf(x,-65000);
return scalbnf(x,(int)fn);
}
void testValues() {
f = 2;
float result;
result = scalbnf(5.0f, 3);
// assert result = 5.0 * \pow(FLT_RADIX, 3.0);
result = scalbnf(1.2f, 8);
// assert result = 1.2 * \pow(FLT_RADIX, 8.3);
result = scalbnf(FLT_MAX, INT_MAX);
// assert result == HUGE_VALF;
// assert (math_errhandling & MATH_ERRNO) ==> (errno == ERANGE);
//@ assert f == 2;
//@ assert vacuous: \false;
}
float ldexpf(float value, int exp)
{
if(!finitef(value)||value==(float)0.0) return value;
value = scalbnf(value,exp);
if(!finitef(value)||value==(float)0.0) errno = ERANGE;
return value;
}
void test_scalbn()
{
static_assert((std::is_same<decltype(scalbn((double)0, (int)0)), double>::value), "");
static_assert((std::is_same<decltype(scalbnf(0, (int)0)), float>::value), "");
static_assert((std::is_same<decltype(scalbnl(0, (int)0)), long double>::value), "");
assert(scalbn(1, 1) == 2);
}
_M_INL float __ieee754_scalbf(float x, float fn)
#endif
{
#ifdef _SCALB_INT
return scalbnf(x,fn);
#else
if (isnanf(x)||isnanf(fn)) return x*fn;
if (!finitef(fn)) {
if(fn>(float)0.0) return x*fn;
else return x/(-fn);
}
if (rintf(fn)!=fn) return (fn-fn)/(fn-fn);
if ( fn > (float)65000.0) return scalbnf(x, 65000);
if (-fn > (float)65000.0) return scalbnf(x,-65000);
return scalbnf(x,(int)fn);
#endif
}
float scalblnf(float x, long n)
{
if (n > INT_MAX)
n = INT_MAX;
else if (n < INT_MIN)
n = INT_MIN;
return scalbnf(x, n);
}
/* This is a portable implementation of nextafterf that is intended to be
independent of the floating point format or its in memory representation.
This implementation works correctly with denormalized values. */
float
nextafterf(float x, float y)
{
/* This variable is marked volatile to avoid excess precision problems
on some platforms, including IA-32. */
volatile float delta;
float absx, denorm_min;
if (isnan(x) || isnan(y))
return x + y;
if (x == y)
return x;
if (!isfinite (x))
return x > 0 ? __FLT_MAX__ : - __FLT_MAX__;
/* absx = fabsf (x); */
absx = (x < 0.0) ? -x : x;
/* __FLT_DENORM_MIN__ is non-zero iff the target supports denormals. */
if (__FLT_DENORM_MIN__ == 0.0f)
denorm_min = __FLT_MIN__;
else
denorm_min = __FLT_DENORM_MIN__;
if (absx < __FLT_MIN__)
delta = denorm_min;
else
{
float frac;
int exp;
/* Discard the fraction from x. */
frac = frexpf (absx, &exp);
delta = scalbnf (0.5f, exp);
/* Scale x by the epsilon of the representation. By rights we should
have been able to combine this with scalbnf, but some targets don't
get that correct with denormals. */
delta *= __FLT_EPSILON__;
/* If we're going to be reducing the absolute value of X, and doing so
would reduce the exponent of X, then the delta to be applied is
one exponent smaller. */
if (frac == 0.5f && (y < x) == (x > 0))
delta *= 0.5f;
/* If that underflows to zero, then we're back to the minimum. */
if (delta == 0.0f)
delta = denorm_min;
}
if (y < x)
delta = -delta;
return x + delta;
}
/*++
Function:
scalbnf
See MSDN.
--*/
PALIMPORT float __cdecl PAL_scalbnf(float x, int n)
{
float ret;
PERF_ENTRY(scalbnf);
ENTRY("scalbnf (x=%f, n=%d)\n", x, n);
ret = scalbnf(x, n);
LOGEXIT("scalbnf returns double %f\n", ret);
PERF_EXIT(scalbnf);
return ret;
}
float expf(float x)
{
float_t hi, lo, c, xx, y;
int k, sign;
uint32_t hx;
GET_FLOAT_WORD(hx, x);
sign = hx >> 31; /* sign bit of x */
hx &= 0x7fffffff; /* high word of |x| */
/* special cases */
if (hx >= 0x42aeac50) { /* if |x| >= -87.33655f or NaN */
if (hx >= 0x42b17218 && !sign) { /* x >= 88.722839f */
/* overflow */
x *= 0x1p127f;
return x;
}
if (sign) {
/* underflow */
FORCE_EVAL(-0x1p-149f/x);
if (hx >= 0x42cff1b5) /* x <= -103.972084f */
return 0;
}
}
/* argument reduction */
if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */
if (hx > 0x3f851592) /* if |x| > 1.5 ln2 */
k = invln2*x + half[sign];
else
k = 1 - sign - sign;
hi = x - k*ln2hi; /* k*ln2hi is exact here */
lo = k*ln2lo;
x = hi - lo;
} else if (hx > 0x39000000) { /* |x| > 2**-14 */
k = 0;
hi = x;
lo = 0;
} else {
/* raise inexact */
FORCE_EVAL(0x1p127f + x);
return 1 + x;
}
/* x is now in primary range */
xx = x*x;
c = x - xx*(P1+xx*P2);
y = 1 + (x*c/(2-c) - lo + hi);
if (k == 0)
return y;
return scalbnf(y, k);
}
float
scalblnf (float x, long n)
{
int in;
in = (int)n;
if (in != n) {
if (n > 0)
in = INT_MAX;
else
in = INT_MIN;
}
return (scalbnf(x, in));
}
int __kernel_rem_pio2f(float *x, float *y, int e0, int nx, int prec,
const s32_t *ipio2)
{
s32_t jz, jx, jv, jp, jk, carry, n, iq[20], i, j, k, m, q0, ih;
float z, fw, f[20], fq[20], q[20];
jk = init_jk[prec];
jp = jk;
jx = nx - 1;
jv = (e0 - 3) / 8;
if (jv < 0)
jv = 0;
q0 = e0 - 8 * (jv + 1);
j = jv - jx;
m = jx + jk;
for (i = 0; i <= m; i++, j++)
f[i] = (j < 0) ? zero : (float) ipio2[j];
for (i = 0; i <= jk; i++)
{
for (j = 0, fw = 0.0; j <= jx; j++)
fw += x[j] * f[jx + i - j];
q[i] = fw;
}
jz = jk;
recompute:
for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--)
{
fw = (float) ((s32_t)(twon8 * z));
iq[i] = (s32_t)(z - two8 * fw);
z = q[j - 1] + fw;
}
z = scalbnf(z, q0);
z -= (float) 8.0 * floorf(z * (float) 0.125);
n = (s32_t) z;
z -= (float) n;
ih = 0;
if (q0 > 0)
{
i = (iq[jz - 1] >> (8 - q0));
n += i;
iq[jz - 1] -= i << (8 - q0);
ih = iq[jz - 1] >> (7 - q0);
}
int __kernel_rem_pio2f(float *x, float *y, int e0, int nx, int prec, const __int32_t *ipio2)
{
__int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
float z,fw,f[20],fq[20],q[20];
/* initialize jk*/
jk = init_jk[prec];
jp = jk;
/* determine jx,jv,q0, note that 3>q0 */
jx = nx-1;
jv = (e0-3)/8;
if(jv<0) jv=0;
q0 = e0-8*(jv+1);
/* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
j = jv-jx;
m = jx+jk;
for(i=0; i<=m; i++,j++) f[i] = (j<0)? zero : (float) ipio2[j];
/* compute q[0],q[1],...q[jk] */
for (i=0; i<=jk; i++) {
for(j=0,fw=0.0; j<=jx; j++) fw += x[j]*f[jx+i-j];
q[i] = fw;
}
jz = jk;
recompute:
/* distill q[] into iq[] reversingly */
for(i=0,j=jz,z=q[jz]; j>0; i++,j--) {
fw = (float)((__int32_t)(twon8* z));
iq[i] = (__int32_t)(z-two8*fw);
z = q[j-1]+fw;
}
/* compute n */
z = scalbnf(z,(int)q0); /* actual value of z */
z -= (float)8.0*floorf(z*(float)0.125); /* trim off integer >= 8 */
n = (__int32_t) z;
z -= (float)n;
ih = 0;
if(q0>0) { /* need iq[jz-1] to determine n */
i = (iq[jz-1]>>(8-q0));
n += i;
iq[jz-1] -= i<<(8-q0);
ih = iq[jz-1]>>(7-q0);
}
float nextafterf(const float x, const float y)
{
int origexp, newexp;
#ifdef isnan
if (isnan(x) || isnan(y))
return x + y;
#endif
if (x == y)
return x;
if (x == 0.0f)
return y > 0.0 ? FLT_MIN : -FLT_MIN;
frexpf(x, &origexp);
if (x >= 0.0f) {
if (y > x) {
if (x < FLT_MIN)
return FLT_MIN;
return x + scalbnf(FLT_EPSILON, origexp - 1);
} else if (x > FLT_MIN) {
float temp = x - scalbnf(FLT_EPSILON, origexp - 1);
frexpf(temp, &newexp);
if (newexp == origexp)
return temp;
return x - scalbnf(FLT_EPSILON, origexp - 2);
} else
return 0.0f;
} else {
if (y < x) {
if (x > -FLT_MIN)
return -FLT_MIN;
return x - scalbnf(FLT_EPSILON, origexp - 1);
} else if (x < -FLT_MIN) {
float temp = x + scalbnf(FLT_EPSILON, origexp - 1);
frexpf(temp, &newexp);
if (newexp == origexp)
return temp;
return x + scalbnf(FLT_EPSILON, origexp - 2);
} else
return 0.0f;
}
}
float
scalblnf (float x, long n)
{
return (scalbnf(x, (int)n));
}
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;
}
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;
}
/*
=============
R_SetupGL
=============
*/
void R_SetupGL (void)
{
float screenaspect;
float yfov;
int i;
extern int glwidth, glheight;
int x, x2, y2, y, w, h;
//
// set up viewpoint
//
glMatrixMode(GL_PROJECTION);
glLoadIdentity ();
x = r_refdef.vrect.x * glwidth/vid.width;
x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth/vid.width;
y = (vid.height-r_refdef.vrect.y) * glheight/vid.height;
y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight/vid.height;
// fudge around because of frac screen scale
if (x > 0)
x--;
if (x2 < glwidth)
x2++;
if (y2 < 0)
y2--;
if (y < glheight)
y++;
w = x2 - x;
h = y - y2;
if (envmap)
{
x = y2 = 0;
w = h = 256;
}
glViewport (glx + x, gly + y2, w, h);
screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI;
MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096);
if (mirror)
{
if (mirror_plane->normal[2])
glScalef (1, -1, 1);
else
glScalef (-1, 1, 1);
glCullFace(GL_BACK);
}
else
glCullFace(GL_FRONT);
glMatrixMode(GL_MODELVIEW);
#ifdef DO_OWN_MATRIX_MATH
float mv[16];
setIdentityM(mv, 0);
rotateM(mv, -90, 1, 0, 0); // put Z going up
rotateM(mv, 90, 0, 0, 1); // put Z going up
rotateM(mv, -r_refdef.viewangles[2], 1, 0, 0);
rotateM(mv, -r_refdef.viewangles[0], 0, 1, 0);
rotateM(mv, -r_refdef.viewangles[1], 0, 0, 1);
translateM(mv, 0, -r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
glLoadMatrixf(mv);
memcpy(r_world_matrix, mv, sizeof(r_world_matrix));
#else
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glRotatef (-r_refdef.viewangles[2], 1, 0, 0);
glRotatef (-r_refdef.viewangles[0], 0, 1, 0);
glRotatef (-r_refdef.viewangles[1], 0, 0, 1);
glTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
#ifdef USE_OPENGLES
static qboolean initialized;
static qboolean haveGL_OES_matrix_get;
static qboolean haveGL_OES_query_matrix;
#if 0
if (! initialized) {
const char* extensions = (const char*) glGetString(GL_EXTENSIONS);
haveGL_OES_matrix_get =
strstr(extensions, "GL_OES_matrix_get") != NULL;
haveGL_OES_query_matrix =
strstr(extensions, "GL_OES_query_matrix") != NULL;
initialized = true;
}
if (haveGL_OES_query_matrix) {
GLfixed mantissa[16];
GLint exponent[16];
glQueryMatrixxOES( mantissa, exponent );
for(int i = 0; i < 16; i++) {
r_world_matrix[i] = scalbnf(mantissa[i], exponent[i]-16);
}
}
else if (haveGL_OES_matrix_get) {
glGetIntegerv (MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES,
(GLint*) r_world_matrix);
}
else
#endif
{
// No way to get the world matix, set to identity
memset(r_world_matrix, 0, sizeof(r_world_matrix));
for(i = 0; i < 16; i += 5) {
r_world_matrix[i] = 1.0f;
}
}
#else
glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix);
#endif
#endif // DO_OWN_MATRIX_MATH
//
// set drawing parms
//
if (gl_cull.value)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
}
float
ldexpf(float x, int n) {
return (scalbnf(x, n));
}
float _EWL_MATH_CDECL
scalblnf(float x, long int y)
{
return scalbnf(x, y);
}
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
}
static int testf(float float_x, long double long_double_x, /*float complex float_complex_x,*/ int int_x, long long_x)
{
int r = 0;
r += acosf(float_x);
r += acoshf(float_x);
r += asinf(float_x);
r += asinhf(float_x);
r += atan2f(float_x, float_x);
r += atanf(float_x);
r += atanhf(float_x);
/*r += cargf(float_complex_x); - will fight with complex numbers later */
r += cbrtf(float_x);
r += ceilf(float_x);
r += copysignf(float_x, float_x);
r += cosf(float_x);
r += coshf(float_x);
r += erfcf(float_x);
r += erff(float_x);
r += exp2f(float_x);
r += expf(float_x);
r += expm1f(float_x);
r += fabsf(float_x);
r += fdimf(float_x, float_x);
r += floorf(float_x);
r += fmaf(float_x, float_x, float_x);
r += fmaxf(float_x, float_x);
r += fminf(float_x, float_x);
r += fmodf(float_x, float_x);
r += frexpf(float_x, &int_x);
r += gammaf(float_x);
r += hypotf(float_x, float_x);
r += ilogbf(float_x);
r += ldexpf(float_x, int_x);
r += lgammaf(float_x);
r += llrintf(float_x);
r += llroundf(float_x);
r += log10f(float_x);
r += log1pf(float_x);
r += log2f(float_x);
r += logbf(float_x);
r += logf(float_x);
r += lrintf(float_x);
r += lroundf(float_x);
r += modff(float_x, &float_x);
r += nearbyintf(float_x);
r += nexttowardf(float_x, long_double_x);
r += powf(float_x, float_x);
r += remainderf(float_x, float_x);
r += remquof(float_x, float_x, &int_x);
r += rintf(float_x);
r += roundf(float_x);
#ifdef __UCLIBC_SUSV3_LEGACY__
r += scalbf(float_x, float_x);
#endif
r += scalblnf(float_x, long_x);
r += scalbnf(float_x, int_x);
r += significandf(float_x);
r += sinf(float_x);
r += sinhf(float_x);
r += sqrtf(float_x);
r += tanf(float_x);
r += tanhf(float_x);
r += tgammaf(float_x);
r += truncf(float_x);
return r;
}
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
}
__host__ void single_precision_math_functions()
{
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);
ceilf(0.0f);
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);
fabsf(1.0f);
fdimf(1.0f, 0.0f);
//fdividef(0.0f, 1.0f);
floorf(0.0f);
fmaf(1.0f, 2.0f, 3.0f);
fmaxf(0.0f, 0.0f);
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);
isinf(0.0f);
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);
///nanf("1");
nearbyintf(0.0f);
//nextafterf(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);
///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);
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);
truncf(0.0f);
///y0f(1.0f);
///y1f(1.0f);
///ynf(1, 1.0f);
}
TEST(math, scalbnf) {
ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2));
}
TEST(math, frexpf) {
int exp;
float fr = frexpf(1024.0f, &exp);
ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp));
}
// https://code.google.com/p/android/issues/detail?id=6697
TEST(math, frexpf_public_bug_6697) {
int exp;
float fr = frexpf(14.1f, &exp);
ASSERT_FLOAT_EQ(14.1f, scalbnf(fr, exp));
}
void runSuccess() {
scalbnf(1.0f, 1);
scalbnf(0.0f, 0);
scalbnf(-1.0f, -1);
scalbnf(anyfloat(), anyint());
}
int main(int argc, char *argv[])
{
float x;
x = scalbnf((float) argc, 1);
return 0;
}
float significandf(float x)
{
return scalbnf(x, -ilogbf(x));
}
__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);
}