int is_rectangle_inside (rectangle_t *rect, point_t *pt) { double half_w = rect->width / 2.0; double half_h = rect->height / 2.0; return (islessequal (rect->center.x - half_w, pt->x) && isgreaterequal (rect->center.x + half_w, pt->x) && islessequal (rect->center.y - half_h, pt->y) && isgreaterequal (rect->center.y + half_h, pt->y)); }
int main(void) { __VERIFIER_assert(isgreaterequal(2.0, 1.0)); __VERIFIER_assert(!isgreaterequal(1.0, 2.0)); __VERIFIER_assert(isgreaterequal(1.0, 1.0)); __VERIFIER_assert(isgreaterequal(INFINITY, 1.0)); __VERIFIER_assert(!isgreaterequal(1.0, NAN)); return 0; }
void test_isgreaterequal() { static_assert((std::is_same<decltype(isgreaterequal((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (long double)0)), bool>::value), ""); assert(isgreaterequal(-1.0, 0.F) == false); }
long double __ieee754_exp2l (long double x) { if (__glibc_likely (isless (x, (long double) LDBL_MAX_EXP))) { if (__builtin_expect (isgreaterequal (x, (long double) (LDBL_MIN_EXP - LDBL_MANT_DIG - 1)), 1)) { int intx = (int) x; long double fractx = x - intx; if (fabsl (fractx) < LDBL_EPSILON / 4.0L) return __scalbnl (1.0L + fractx, intx); return __scalbnl (__ieee754_expl (M_LN2l * fractx), intx); } else { /* Underflow or exact zero. */ if (isinf (x)) return 0; else return LDBL_MIN * LDBL_MIN; } } else /* Infinity, NaN or overflow. */ return LDBL_MAX * x; }
static int map_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options) { struct drange_map_data *mdata = data; const struct sol_flow_node_type_float_map_options *opts; SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options, SOL_FLOW_NODE_TYPE_FLOAT_MAP_OPTIONS_API_VERSION, -EINVAL); opts = (const struct sol_flow_node_type_float_map_options *)options; mdata->use_input_range = opts->use_input_range; mdata->input = opts->input_range; if (!mdata->use_input_range && isgreaterequal(mdata->input.min, mdata->input.max)) { SOL_WRN("Invalid range: input max must to be bigger than min"); return -EINVAL; } mdata->output = opts->output_range; if (isless(mdata->output.min, mdata->output.max)) { mdata->output_value.min = mdata->output.min; mdata->output_value.max = mdata->output.max; } else { mdata->output_value.max = mdata->output.min; mdata->output_value.min = mdata->output.max; } mdata->output_value.step = opts->output_range.step; return 0; }
static int map_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct drange_map_data *mdata = data; struct sol_drange in_value; double out_value; int r; r = sol_flow_packet_get_drange(packet, &in_value); SOL_INT_CHECK(r, < 0, r); if (mdata->use_input_range) { if (isgreaterequal(in_value.min, in_value.max)) { SOL_WRN("Invalid range: input max must to be bigger than min"); return -EINVAL; } r = _map(in_value.val, in_value.min, in_value.max, mdata->output.min, mdata->output.max, mdata->output_value.step, &out_value); } else r = _map(in_value.val, mdata->input.min, mdata->input.max, mdata->output.min, mdata->output.max, mdata->output_value.step, &out_value); SOL_INT_CHECK(r, < 0, r); mdata->output_value.val = out_value; return sol_flow_send_drange_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_MAP__OUT__OUT, &mdata->output_value); }
int is_rectangle_covered (rectangle_t *dest, rectangle_t *src) { double d_half_w = dest->width / 2.0; double d_half_h = dest->height / 2.0; double s_half_w = src->width / 2.0; double s_half_h = src->height / 2.0; return (islessequal (src->center.x - s_half_w, dest->center.x - d_half_w) && islessequal (src->center.y - s_half_h, dest->center.y - d_half_h) && isgreaterequal (src->center.x + s_half_w, dest->center.x + d_half_w) && isgreaterequal (src->center.y + s_half_h, dest->center.y + d_half_h)); }
void vtc_expect(struct vtclog *vl, const char *olhs, const char *lhs, const char *cmp, const char *orhs, const char *rhs) { vre_t *vre; const char *error; int erroroffset; int i, j, retval = -1; double fl, fr; j = lhs == NULL || rhs == NULL; if (lhs == NULL) lhs = "<undef>"; if (rhs == NULL) rhs = "<undef>"; if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) { vre = VRE_compile(rhs, 0, &error, &erroroffset); if (vre == NULL) vtc_fatal(vl, "REGEXP error: %s (@%d) (%s)", error, erroroffset, rhs); i = VRE_exec(vre, lhs, strlen(lhs), 0, 0, NULL, 0, 0); retval = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!'); VRE_free(&vre); } else if (!strcmp(cmp, "==")) { retval = strcmp(lhs, rhs) == 0; } else if (!strcmp(cmp, "!=")) { retval = strcmp(lhs, rhs) != 0; } else if (j) { // fail inequality comparisons if either side is undef'ed retval = 0; } else { fl = VNUM(lhs); fr = VNUM(rhs); if (!strcmp(cmp, "<")) retval = isless(fl, fr); else if (!strcmp(cmp, ">")) retval = isgreater(fl, fr); else if (!strcmp(cmp, "<=")) retval = islessequal(fl, fr); else if (!strcmp(cmp, ">=")) retval = isgreaterequal(fl, fr); } if (retval == -1) vtc_fatal(vl, "EXPECT %s (%s) %s %s (%s) test not implemented", olhs, lhs, cmp, orhs, rhs); else if (retval == 0) vtc_fatal(vl, "EXPECT %s (%s) %s \"%s\" failed", olhs, lhs, cmp, rhs); else vtc_log(vl, 4, "EXPECT %s (%s) %s \"%s\" match", olhs, lhs, cmp, rhs); }
static inline char *format_value_with_precision_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision) { if(unlikely(isnan(value) || isinf(value))) value = 0.0; char *separator = ""; if(unlikely(isalnum(*units))) separator = " "; if(precision < 0) { int len, lstop = 0, trim_zeros = 1; calculated_number abs = value; if(isless(value, 0)) { lstop = 1; abs = calculated_number_fabs(value); } if(isgreaterequal(abs, 1000)) { len = snprintfz(value_string, value_string_len, "%0.0" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); trim_zeros = 0; } else if(isgreaterequal(abs, 10)) len = snprintfz(value_string, value_string_len, "%0.1" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else if(isgreaterequal(abs, 1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else if(isgreaterequal(abs, 0.1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else if(isgreaterequal(abs, 0.01)) len = snprintfz(value_string, value_string_len, "%0.4" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else if(isgreaterequal(abs, 0.001)) len = snprintfz(value_string, value_string_len, "%0.5" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else if(isgreaterequal(abs, 0.0001)) len = snprintfz(value_string, value_string_len, "%0.6" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); else len = snprintfz(value_string, value_string_len, "%0.7" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value); if(unlikely(trim_zeros)) { int l; // remove trailing zeros from the decimal part for(l = len - 1; l > lstop; l--) { if(likely(value_string[l] == '0')) { value_string[l] = '\0'; len--; } else if(unlikely(value_string[l] == '.')) { value_string[l] = '\0'; len--; break; } else break; } } if(unlikely(len <= 0)) len = 1; snprintfz(&value_string[len], value_string_len - len, "%s%s", separator, units); } else { if(precision > 50) precision = 50; snprintfz(value_string, value_string_len, "%0.*" LONG_DOUBLE_MODIFIER "%s%s", precision, (LONG_DOUBLE) value, separator, units); } return value_string; }
FLOAT M_DECL_FUNC (__fmax) (FLOAT x, FLOAT y) { if (isgreaterequal (x, y)) return x; else if (isless (x, y)) return y; else if (issignaling (x) || issignaling (y)) return x + y; else return isnan (y) ? x : y; }
/* wrapper atanhl */ long double __atanhl (long double x) { if (__builtin_expect (isgreaterequal (fabsl (x), 1.0L), 0) && _LIB_VERSION != _IEEE_) return __kernel_standard_l (x, x, fabsl (x) > 1.0L ? 230 /* atanh(|x|>1) */ : 231); /* atanh(|x|==1) */ return __ieee754_atanhl (x); }
int libvlc_audio_set_volume( libvlc_media_player_t *mp, int volume ) { float vol = volume / 100.f; if (!isgreaterequal(vol, 0.f)) { libvlc_printerr( "Volume out of range" ); return -1; } int ret = -1; audio_output_t *aout = GetAOut( mp ); if( aout != NULL ) { ret = aout_VolumeSet( aout, vol ); vlc_object_release( aout ); } return ret; }
static int float_filter_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct sol_drange value; int r; struct float_filter_data *mdata = data; r = sol_flow_packet_get_drange(packet, &value); SOL_INT_CHECK(r, < 0, r); if (isgreaterequal(value.val, mdata->min) && islessequal(value.val, mdata->max)) { if (mdata->range_override) { value.min = mdata->min; value.max = mdata->max; value.step = 1; } return sol_flow_send_drange_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_FILTER__OUT__OUT, &value); } return 0; }
static int angle_set(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { double in_value; struct servo_motor_data *mdata = data; int r, pulse_width; r = sol_flow_packet_get_drange_value(packet, &in_value); SOL_INT_CHECK(r, < 0, r); if (isless(in_value, 0) || isgreaterequal(in_value, 180)) { SOL_WRN("Invalid value %f. It must be >= 0 and < 180", in_value); return -EINVAL; } pulse_width = in_value * mdata->duty_cycle_diff / 180 + mdata->duty_cycle_range.min; return set_pulse_width(mdata, pulse_width); }
static bool drange_val_greater_or_equal(double var0, double var1) { return isgreaterequal(var0, var1); }
#ifndef TRANSITIVE #include <math.h> #endif #include "util.h" TYPE_ARITH(float_t); TYPE_ARITH(double_t); IDENT(fpclassify(0.0), int); IDENT(isfinite(0.0), int); IDENT(isgreater(0.0, 0.0), int); IDENT(isgreaterequal(0.0, 0.0), int); IDENT(isinf(0.0), int); IDENT(isless(0.0, 0.0), int); IDENT(islessequal(0.0, 0.0), int); IDENT(islessgreater(0.0, 0.0), int); IDENT(isnan(0.0), int); IDENT(isnormal(0.0), int); IDENT(isunordered(0.0, 0.0), int); IDENT(signbit(0.0), int); IDENT(M_E, double); IDENT(M_LOG2E, double); IDENT(M_LOG10E, double); IDENT(M_LN2, double); IDENT(M_LN10, double); IDENT(M_PI, double); IDENT(M_PI_2, double); IDENT(M_PI_4, double); IDENT(M_1_PI, double);
double fmax (double _x, double _y) { return ( isgreaterequal (_x, _y)|| __isnan (_y) ? _x : _y ); }
Double __ieee754_exp2 (Double x) { static const Double himark = (Double) DBL_MAX_EXP; static const Double lomark = (Double) (DBL_MIN_EXP - DBL_MANT_DIG - 1); /* Check for usual case. */ if (isless (x, himark) && isgreaterequal (x, lomark)) { static const Double THREEp42 = 13194139533312.0; int tval, unsafe; Double rx, x22, result; union ieee754_double ex2_u, scale_u; fenv_t oldenv; feholdexcept (&oldenv); #ifdef FE_TONEAREST /* If we don't have this, it's too bad. */ fesetround (FE_TONEAREST); #endif /* 1. Argument reduction. Choose integers ex, -256 <= t < 256, and some real -1/1024 <= x1 <= 1024 so that x = ex + t/512 + x1. First, calculate rx = ex + t/512. */ rx = x + THREEp42; rx -= THREEp42; x -= rx; /* Compute x=x1. */ /* Compute tval = (ex*512 + t)+256. Now, t = (tval mod 512)-256 and ex=tval/512 [that's mod, NOT %; and /-round-to-nearest not the usual c integer /]. */ tval = (int) (rx * 512.0 + 256.0); /* 2. Adjust for accurate table entry. Find e so that x = ex + t/512 + e + x2 where -1e6 < e < 1e6, and (Double)(2^(t/512+e)) is accurate to one part in 2^-64. */ /* 'tval & 511' is the same as 'tval%512' except that it's always positive. Compute x = x2. */ x -= exp2_deltatable[tval & 511]; /* 3. Compute ex2 = 2^(t/512+e+ex). */ ex2_u.d() = exp2_accuratetable[tval & 511]; tval >>= 9; unsafe = abs(tval) >= -DBL_MIN_EXP - 1; ex2_u.ieee.exponent += tval >> unsafe; scale_u.d() = 1.0; scale_u.ieee.exponent += tval - (tval >> unsafe); /* 4. Approximate 2^x2 - 1, using a fourth-degree polynomial, with maximum error in [-2^-10-2^-30,2^-10+2^-30] less than 10^-19. */ x22 = (((.0096181293647031180 * x + .055504110254308625) * x + .240226506959100583) * x + .69314718055994495) * ex2_u.d(); /* 5. Return (2^x2-1) * 2^(t/512+e+ex) + 2^(t/512+e+ex). */ fesetenv (&oldenv); result = x22 * x + ex2_u.d(); if (!unsafe) return result; else return result * scale_u.d(); } /* Exceptional cases: */ else if (isless (x, himark))
double __fmax (double x, double y) { return (isgreaterequal (x, y) || isnan (y)) ? x : y; }
void domathl (void) { #ifndef NO_LONG_DOUBLE long double f1; long double f2; int i1; f1 = acosl(0.0); fprintf( stdout, "acosl : %Lf\n", f1); f1 = acoshl(0.0); fprintf( stdout, "acoshl : %Lf\n", f1); f1 = asinl(1.0); fprintf( stdout, "asinl : %Lf\n", f1); f1 = asinhl(1.0); fprintf( stdout, "asinhl : %Lf\n", f1); f1 = atanl(M_PI_4); fprintf( stdout, "atanl : %Lf\n", f1); f1 = atan2l(2.3, 2.3); fprintf( stdout, "atan2l : %Lf\n", f1); f1 = atanhl(1.0); fprintf( stdout, "atanhl : %Lf\n", f1); f1 = cbrtl(27.0); fprintf( stdout, "cbrtl : %Lf\n", f1); f1 = ceill(3.5); fprintf( stdout, "ceill : %Lf\n", f1); f1 = copysignl(3.5, -2.5); fprintf( stdout, "copysignl : %Lf\n", f1); f1 = cosl(M_PI_2); fprintf( stdout, "cosl : %Lf\n", f1); f1 = coshl(M_PI_2); fprintf( stdout, "coshl : %Lf\n", f1); f1 = erfl(42.0); fprintf( stdout, "erfl : %Lf\n", f1); f1 = erfcl(42.0); fprintf( stdout, "erfcl : %Lf\n", f1); f1 = expl(0.42); fprintf( stdout, "expl : %Lf\n", f1); f1 = exp2l(0.42); fprintf( stdout, "exp2l : %Lf\n", f1); f1 = expm1l(0.00042); fprintf( stdout, "expm1l : %Lf\n", f1); f1 = fabsl(-1.123); fprintf( stdout, "fabsl : %Lf\n", f1); f1 = fdiml(1.123, 2.123); fprintf( stdout, "fdiml : %Lf\n", f1); f1 = floorl(0.5); fprintf( stdout, "floorl : %Lf\n", f1); f1 = floorl(-0.5); fprintf( stdout, "floorl : %Lf\n", f1); f1 = fmal(2.1, 2.2, 3.01); fprintf( stdout, "fmal : %Lf\n", f1); f1 = fmaxl(-0.42, 0.42); fprintf( stdout, "fmaxl : %Lf\n", f1); f1 = fminl(-0.42, 0.42); fprintf( stdout, "fminl : %Lf\n", f1); f1 = fmodl(42.0, 3.0); fprintf( stdout, "fmodl : %Lf\n", f1); /* no type-specific variant */ i1 = fpclassify(1.0); fprintf( stdout, "fpclassify : %d\n", i1); f1 = frexpl(42.0, &i1); fprintf( stdout, "frexpl : %Lf\n", f1); f1 = hypotl(42.0, 42.0); fprintf( stdout, "hypotl : %Lf\n", f1); i1 = ilogbl(42.0); fprintf( stdout, "ilogbl : %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 = j0l(1.2); fprintf( stdout, "j0l : %Lf\n", f1); f1 = j1l(1.2); fprintf( stdout, "j1l : %Lf\n", f1); f1 = jnl(2,1.2); fprintf( stdout, "jnl : %Lf\n", f1); f1 = ldexpl(1.2,3); fprintf( stdout, "ldexpl : %Lf\n", f1); f1 = lgammal(42.0); fprintf( stdout, "lgammal : %Lf\n", f1); f1 = llrintl(-0.5); fprintf( stdout, "llrintl : %Lf\n", f1); f1 = llrintl(0.5); fprintf( stdout, "llrintl : %Lf\n", f1); f1 = llroundl(-0.5); fprintf( stdout, "lroundl : %Lf\n", f1); f1 = llroundl(0.5); fprintf( stdout, "lroundl : %Lf\n", f1); f1 = logl(42.0); fprintf( stdout, "logl : %Lf\n", f1); f1 = log10l(42.0); fprintf( stdout, "log10l : %Lf\n", f1); f1 = log1pl(42.0); fprintf( stdout, "log1pl : %Lf\n", f1); f1 = log2l(42.0); fprintf( stdout, "log2l : %Lf\n", f1); f1 = logbl(42.0); fprintf( stdout, "logbl : %Lf\n", f1); f1 = lrintl(-0.5); fprintf( stdout, "lrintl : %Lf\n", f1); f1 = lrintl(0.5); fprintf( stdout, "lrintl : %Lf\n", f1); f1 = lroundl(-0.5); fprintf( stdout, "lroundl : %Lf\n", f1); f1 = lroundl(0.5); fprintf( stdout, "lroundl : %Lf\n", f1); f1 = modfl(42.0,&f2); fprintf( stdout, "lmodfl : %Lf\n", f1); f1 = nanl(""); fprintf( stdout, "nanl : %Lf\n", f1); f1 = nearbyintl(1.5); fprintf( stdout, "nearbyintl : %Lf\n", f1); f1 = nextafterl(1.5,2.0); fprintf( stdout, "nextafterl : %Lf\n", f1); f1 = powl(3.01, 2.0); fprintf( stdout, "powl : %Lf\n", f1); f1 = remainderl(3.01,2.0); fprintf( stdout, "remainderl : %Lf\n", f1); f1 = remquol(29.0,3.0,&i1); fprintf( stdout, "remquol : %Lf\n", f1); f1 = rintl(0.5); fprintf( stdout, "rintl : %Lf\n", f1); f1 = rintl(-0.5); fprintf( stdout, "rintl : %Lf\n", f1); f1 = roundl(0.5); fprintf( stdout, "roundl : %Lf\n", f1); f1 = roundl(-0.5); fprintf( stdout, "roundl : %Lf\n", f1); f1 = scalblnl(1.2,3); fprintf( stdout, "scalblnl : %Lf\n", f1); f1 = scalbnl(1.2,3); fprintf( stdout, "scalbnl : %Lf\n", f1); /* no type-specific variant */ i1 = signbit(1.0); fprintf( stdout, "signbit : %i\n", i1); f1 = sinl(M_PI_4); fprintf( stdout, "sinl : %Lf\n", f1); f1 = sinhl(M_PI_4); fprintf( stdout, "sinhl : %Lf\n", f1); f1 = sqrtl(9.0); fprintf( stdout, "sqrtl : %Lf\n", f1); f1 = tanl(M_PI_4); fprintf( stdout, "tanl : %Lf\n", f1); f1 = tanhl(M_PI_4); fprintf( stdout, "tanhl : %Lf\n", f1); f1 = tgammal(2.1); fprintf( stdout, "tgammal : %Lf\n", f1); f1 = truncl(3.5); fprintf( stdout, "truncl : %Lf\n", f1); f1 = y0l(1.2); fprintf( stdout, "y0l : %Lf\n", f1); f1 = y1l(1.2); fprintf( stdout, "y1l : %Lf\n", f1); f1 = ynl(3,1.2); fprintf( stdout, "ynl : %Lf\n", f1); #endif }
void domath (void) { #ifndef NO_DOUBLE double f1; double f2; int i1; f1 = acos (0.0); fprintf( stdout, "acos : %f\n", f1); f1 = acosh (0.0); fprintf( stdout, "acosh : %f\n", f1); f1 = asin (1.0); fprintf( stdout, "asin : %f\n", f1); f1 = asinh (1.0); fprintf( stdout, "asinh : %f\n", f1); f1 = atan (M_PI_4); fprintf( stdout, "atan : %f\n", f1); f1 = atan2 (2.3, 2.3); fprintf( stdout, "atan2 : %f\n", f1); f1 = atanh (1.0); fprintf( stdout, "atanh : %f\n", f1); f1 = cbrt (27.0); fprintf( stdout, "cbrt : %f\n", f1); f1 = ceil (3.5); fprintf( stdout, "ceil : %f\n", f1); f1 = copysign (3.5, -2.5); fprintf( stdout, "copysign : %f\n", f1); f1 = cos (M_PI_2); fprintf( stdout, "cos : %f\n", f1); f1 = cosh (M_PI_2); fprintf( stdout, "cosh : %f\n", f1); f1 = erf (42.0); fprintf( stdout, "erf : %f\n", f1); f1 = erfc (42.0); fprintf( stdout, "erfc : %f\n", f1); f1 = exp (0.42); fprintf( stdout, "exp : %f\n", f1); f1 = exp2 (0.42); fprintf( stdout, "exp2 : %f\n", f1); f1 = expm1 (0.00042); fprintf( stdout, "expm1 : %f\n", f1); f1 = fabs (-1.123); fprintf( stdout, "fabs : %f\n", f1); f1 = fdim (1.123, 2.123); fprintf( stdout, "fdim : %f\n", f1); f1 = floor (0.5); fprintf( stdout, "floor : %f\n", f1); f1 = floor (-0.5); fprintf( stdout, "floor : %f\n", f1); f1 = fma (2.1, 2.2, 3.01); fprintf( stdout, "fma : %f\n", f1); f1 = fmax (-0.42, 0.42); fprintf( stdout, "fmax : %f\n", f1); f1 = fmin (-0.42, 0.42); fprintf( stdout, "fmin : %f\n", f1); f1 = fmod (42.0, 3.0); fprintf( stdout, "fmod : %f\n", f1); /* no type-specific variant */ i1 = fpclassify(1.0); fprintf( stdout, "fpclassify : %d\n", i1); f1 = frexp (42.0, &i1); fprintf( stdout, "frexp : %f\n", f1); f1 = hypot (42.0, 42.0); fprintf( stdout, "hypot : %f\n", f1); i1 = ilogb (42.0); fprintf( stdout, "ilogb : %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 = j0 (1.2); fprintf( stdout, "j0 : %f\n", f1); f1 = j1 (1.2); fprintf( stdout, "j1 : %f\n", f1); f1 = jn (2,1.2); fprintf( stdout, "jn : %f\n", f1); f1 = ldexp (1.2,3); fprintf( stdout, "ldexp : %f\n", f1); f1 = lgamma (42.0); fprintf( stdout, "lgamma : %f\n", f1); f1 = llrint (-0.5); fprintf( stdout, "llrint : %f\n", f1); f1 = llrint (0.5); fprintf( stdout, "llrint : %f\n", f1); f1 = llround (-0.5); fprintf( stdout, "lround : %f\n", f1); f1 = llround (0.5); fprintf( stdout, "lround : %f\n", f1); f1 = log (42.0); fprintf( stdout, "log : %f\n", f1); f1 = log10 (42.0); fprintf( stdout, "log10 : %f\n", f1); f1 = log1p (42.0); fprintf( stdout, "log1p : %f\n", f1); f1 = log2 (42.0); fprintf( stdout, "log2 : %f\n", f1); f1 = logb (42.0); fprintf( stdout, "logb : %f\n", f1); f1 = lrint (-0.5); fprintf( stdout, "lrint : %f\n", f1); f1 = lrint (0.5); fprintf( stdout, "lrint : %f\n", f1); f1 = lround (-0.5); fprintf( stdout, "lround : %f\n", f1); f1 = lround (0.5); fprintf( stdout, "lround : %f\n", f1); f1 = modf (42.0,&f2); fprintf( stdout, "lmodf : %f\n", f1); f1 = nan (""); fprintf( stdout, "nan : %f\n", f1); f1 = nearbyint (1.5); fprintf( stdout, "nearbyint : %f\n", f1); f1 = nextafter (1.5,2.0); fprintf( stdout, "nextafter : %f\n", f1); f1 = pow (3.01, 2.0); fprintf( stdout, "pow : %f\n", f1); f1 = remainder (3.01,2.0); fprintf( stdout, "remainder : %f\n", f1); f1 = remquo (29.0,3.0,&i1); fprintf( stdout, "remquo : %f\n", f1); f1 = rint (0.5); fprintf( stdout, "rint : %f\n", f1); f1 = rint (-0.5); fprintf( stdout, "rint : %f\n", f1); f1 = round (0.5); fprintf( stdout, "round : %f\n", f1); f1 = round (-0.5); fprintf( stdout, "round : %f\n", f1); f1 = scalbln (1.2,3); fprintf( stdout, "scalbln : %f\n", f1); f1 = scalbn (1.2,3); fprintf( stdout, "scalbn : %f\n", f1); /* no type-specific variant */ i1 = signbit(1.0); fprintf( stdout, "signbit : %i\n", i1); f1 = sin (M_PI_4); fprintf( stdout, "sin : %f\n", f1); f1 = sinh (M_PI_4); fprintf( stdout, "sinh : %f\n", f1); f1 = sqrt (9.0); fprintf( stdout, "sqrt : %f\n", f1); f1 = tan (M_PI_4); fprintf( stdout, "tan : %f\n", f1); f1 = tanh (M_PI_4); fprintf( stdout, "tanh : %f\n", f1); f1 = tgamma (2.1); fprintf( stdout, "tgamma : %f\n", f1); f1 = trunc (3.5); fprintf( stdout, "trunc : %f\n", f1); f1 = y0 (1.2); fprintf( stdout, "y0 : %f\n", f1); f1 = y1 (1.2); fprintf( stdout, "y1 : %f\n", f1); f1 = yn (3,1.2); fprintf( stdout, "yn : %f\n", f1); #endif }
float __ieee754_exp2f (float x) { static const float himark = (float) FLT_MAX_EXP; static const float lomark = (float) (FLT_MIN_EXP - FLT_MANT_DIG - 1); /* Check for usual case. */ if (isless (x, himark) && isgreaterequal (x, lomark)) { static const float THREEp14 = 49152.0; int tval, unsafe; float rx, x22, result; union ieee754_float ex2_u, scale_u; if (fabsf (x) < FLT_EPSILON / 4.0f) return 1.0f + x; { SET_RESTORE_ROUND_NOEXF (FE_TONEAREST); /* 1. Argument reduction. Choose integers ex, -128 <= t < 128, and some real -1/512 <= x1 <= 1/512 so that x = ex + t/512 + x1. First, calculate rx = ex + t/256. */ rx = x + THREEp14; rx -= THREEp14; x -= rx; /* Compute x=x1. */ /* Compute tval = (ex*256 + t)+128. Now, t = (tval mod 256)-128 and ex=tval/256 [that's mod, NOT %; and /-round-to-nearest not the usual c integer /]. */ tval = (int) (rx * 256.0f + 128.0f); /* 2. Adjust for accurate table entry. Find e so that x = ex + t/256 + e + x2 where -7e-4 < e < 7e-4, and (float)(2^(t/256+e)) is accurate to one part in 2^-64. */ /* 'tval & 255' is the same as 'tval%256' except that it's always positive. Compute x = x2. */ x -= __exp2f_deltatable[tval & 255]; /* 3. Compute ex2 = 2^(t/255+e+ex). */ ex2_u.f = __exp2f_atable[tval & 255]; tval >>= 8; /* x2 is an integer multiple of 2^-30; avoid intermediate underflow from the calculation of x22 * x. */ unsafe = abs(tval) >= -FLT_MIN_EXP - 32; ex2_u.ieee.exponent += tval >> unsafe; scale_u.f = 1.0; scale_u.ieee.exponent += tval - (tval >> unsafe); /* 4. Approximate 2^x2 - 1, using a second-degree polynomial, with maximum error in [-2^-9 - 2^-14, 2^-9 + 2^-14] less than 1.3e-10. */ x22 = (.24022656679f * x + .69314736128f) * ex2_u.f; } /* 5. Return (2^x2-1) * 2^(t/512+e+ex) + 2^(t/512+e+ex). */ result = x22 * x + ex2_u.f; if (!unsafe) return result; else { result *= scale_u.f; math_check_force_underflow_nonneg (result); return result; } } /* Exceptional cases: */ else if (isless (x, himark))
static void cmd_http_expect(CMD_ARGS) { struct http *hp; const char *lhs, *clhs; char *cmp; const char *rhs, *crhs; vre_t *vre; const char *error; int erroroffset; int i, retval = -1; (void)cmd; (void)vl; CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC); AZ(strcmp(av[0], "expect")); av++; AN(av[0]); AN(av[1]); AN(av[2]); AZ(av[3]); lhs = cmd_var_resolve(hp, av[0]); cmp = av[1]; rhs = cmd_var_resolve(hp, av[2]); clhs = lhs ? lhs : "<undef>"; crhs = rhs ? rhs : "<undef>"; if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) { vre = VRE_compile(crhs, 0, &error, &erroroffset); if (vre == NULL) vtc_log(hp->vl, 0, "REGEXP error: %s (@%d) (%s)", error, erroroffset, crhs); i = VRE_exec(vre, clhs, strlen(clhs), 0, 0, NULL, 0, 0); retval = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!'); VRE_free(&vre); } else if (!strcmp(cmp, "==")) { retval = strcmp(clhs, crhs) == 0; } else if (!strcmp(cmp, "!=")) { retval = strcmp(clhs, crhs) != 0; } else if (lhs == NULL || rhs == NULL) { // fail inequality comparisons if either side is undef'ed retval = 0; } else if (!strcmp(cmp, "<")) { retval = isless(VNUM(lhs), VNUM(rhs)); } else if (!strcmp(cmp, ">")) { retval = isgreater(VNUM(lhs), VNUM(rhs)); } else if (!strcmp(cmp, "<=")) { retval = islessequal(VNUM(lhs), VNUM(rhs)); } else if (!strcmp(cmp, ">=")) { retval = isgreaterequal(VNUM(lhs), VNUM(rhs)); } if (retval == -1) vtc_log(hp->vl, 0, "EXPECT %s (%s) %s %s (%s) test not implemented", av[0], clhs, av[1], av[2], crhs); else vtc_log(hp->vl, retval ? 4 : 0, "EXPECT %s (%s) %s \"%s\" %s", av[0], clhs, cmp, crhs, retval ? "match" : "failed"); }
long double fmaxl (long double _x, long double _y) { return (( isgreaterequal(_x, _y) || __isnanl (_y)) ? _x : _y ); }
long double __fmaxl (long double x, long double y) { return (isgreaterequal (x, y) || isnan (y)) ? x : y; }
static int wave_generator_trapezoidal_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options) { struct drange_wave_generator_trapezoidal_data *mdata = data; const struct sol_flow_node_type_wave_generator_trapezoidal_options *opts = (const struct sol_flow_node_type_wave_generator_trapezoidal_options *)options; uint32_t tick_start; struct t_state *t_state; struct sol_drange *val; SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(opts, SOL_FLOW_NODE_TYPE_WAVE_GENERATOR_TRAPEZOIDAL_OPTIONS_API_VERSION, -EINVAL); if (isgreaterequal(opts->min.val, opts->max.val)) { SOL_ERR("Trapezoidal wave generator's min must be less than its max"); return -EDOM; } if (opts->ticks_inc.val < 1) { SOL_ERR("Trapezoidal wave generator's ticks_inc value (%d) cannot" " be less than 1)", opts->ticks_inc.val); return -EDOM; } if (opts->ticks_dec.val < 1) { SOL_ERR("Trapezoidal wave generator's ticks_dec value (%d) cannot" " be less than 1)", opts->ticks_dec.val); return -EDOM; } if (opts->tick_start.val < 0) { SOL_ERR("Trapezoidal wave generator's tick_start value (%d) cannot" " be less than 0)", opts->tick_start.val); return -EDOM; } if (opts->ticks_at_max.val < 0) { SOL_ERR("Trapezoidal wave generator's ticks_at_max value (%d) cannot" " be less than 0)", opts->ticks_at_max.val); return -EDOM; } if (opts->ticks_at_min.val < 0) { SOL_ERR("Trapezoidal wave generator's ticks_at_min value (%d) cannot" " be less than 0)", opts->ticks_at_min.val); return -EDOM; } mdata->ticks_at_min = opts->ticks_at_min.val; mdata->ticks_at_max = opts->ticks_at_max.val; t_state = &mdata->t_state; val = &t_state->val; t_state->did_first = false; val->min = opts->min.val; val->max = opts->max.val; mdata->ticks_inc = opts->ticks_inc.val; mdata->ticks_dec = opts->ticks_dec.val; mdata->inc_step = (val->max - val->min) / mdata->ticks_inc; mdata->dec_step = (val->min - val->max) / mdata->ticks_dec; /* calculating starting val from tick_start */ t_state->increasing = true; mdata->period_in_ticks = mdata->ticks_at_min + mdata->ticks_inc + mdata->ticks_at_max + mdata->ticks_dec; tick_start = opts->tick_start.val % mdata->period_in_ticks; t_state->max_tick_cnt = 0; t_state->min_tick_cnt = mdata->ticks_at_min; val->val = val->min; val->step = mdata->inc_step; while (t_state->curr_period_tick != tick_start) { trapezoidal_iterate_do(mdata); /* we set min_tick_cnt manually, but max_tick_cnt has be * updated on the run */ direction_check(mdata, false, true); } return 0; }
__kernel void optical_flow ( read_only image2d_t current_image, read_only image2d_t previous_image, write_only image2d_t optical_flow, const float scale, const float offset, const float lambda, const float threshold ) { sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE; int2 coords = (int2)(get_global_id(0), get_global_id(1)); float4 current_pixel = read_imagef(current_image, sampler, coords); float4 previous_pixel = read_imagef(previous_image, sampler, coords); int2 x1 = (int2)(offset, 0.f); int2 y1 = (int2)(0.f, offset); //get the difference float4 curdif = previous_pixel - current_pixel; //calculate the gradient //Image 2 first float4 gradx = read_imagef(previous_image, sampler, coords+x1) - read_imagef(previous_image, sampler, coords-x1); //Image 1 gradx += read_imagef(current_image, sampler, coords+x1) - read_imagef(current_image, sampler, coords-x1); //Image 2 first float4 grady = read_imagef(previous_image, sampler, coords+y1) - read_imagef(previous_image, sampler, coords-y1); //Image 1 grady += read_imagef(current_image, sampler, coords+y1) - read_imagef(current_image, sampler, coords-y1); float4 sqr = (gradx*gradx) + (grady*grady) + (float4)(lambda,lambda, lambda, lambda); float4 gradmag = sqrt(sqr); /////////////////////////////////////////////////// float4 vx = curdif * (gradx / gradmag); float vxd = vx.x;//assumes greyscale //format output for flowrepos, out(-x,+x,-y,+y) float2 xout = (float2)(fmax(vxd,0.f),fabs(fmin(vxd,0.f))); xout *= scale; /////////////////////////////////////////////////// float4 vy = curdif*(grady/gradmag); float vyd = vy.x;//assumes greyscale //format output for flowrepos, out(-x,+x,-y,+y) float2 yout = (float2)(fmax(vyd,0.f),fabs(fmin(vyd,0.f))); yout *= scale; /////////////////////////////////////////////////// float4 out = (float4)(xout, yout); float cond = (float)isgreaterequal(length(out), threshold); out *= cond; write_imagef(optical_flow, coords, out); }
FLOAT M_DECL_FUNC (__fmax) (FLOAT x, FLOAT y) { return (isgreaterequal (x, y) || isnan (y)) ? x : y; }
double __ieee754_exp2 (double x) { static const double himark = (double) DBL_MAX_EXP; static const double lomark = (double) (DBL_MIN_EXP - DBL_MANT_DIG - 1); /* Check for usual case. */ if (__glibc_likely (isless (x, himark))) { /* Exceptional cases: */ if (__glibc_unlikely (!isgreaterequal (x, lomark))) { if (isinf (x)) /* e^-inf == 0, with no error. */ return 0; else /* Underflow */ return TWOM1000 * TWOM1000; } static const double THREEp42 = 13194139533312.0; int tval, unsafe; double rx, x22, result; union ieee754_double ex2_u, scale_u; if (fabs (x) < DBL_EPSILON / 4.0) return 1.0 + x; { SET_RESTORE_ROUND_NOEX (FE_TONEAREST); /* 1. Argument reduction. Choose integers ex, -256 <= t < 256, and some real -1/1024 <= x1 <= 1024 so that x = ex + t/512 + x1. First, calculate rx = ex + t/512. */ rx = x + THREEp42; rx -= THREEp42; x -= rx; /* Compute x=x1. */ /* Compute tval = (ex*512 + t)+256. Now, t = (tval mod 512)-256 and ex=tval/512 [that's mod, NOT %; and /-round-to-nearest not the usual c integer /]. */ tval = (int) (rx * 512.0 + 256.0); /* 2. Adjust for accurate table entry. Find e so that x = ex + t/512 + e + x2 where -1e6 < e < 1e6, and (double)(2^(t/512+e)) is accurate to one part in 2^-64. */ /* 'tval & 511' is the same as 'tval%512' except that it's always positive. Compute x = x2. */ x -= exp2_deltatable[tval & 511]; /* 3. Compute ex2 = 2^(t/512+e+ex). */ ex2_u.d = exp2_accuratetable[tval & 511]; tval >>= 9; /* x2 is an integer multiple of 2^-54; avoid intermediate underflow from the calculation of x22 * x. */ unsafe = abs (tval) >= -DBL_MIN_EXP - 56; ex2_u.ieee.exponent += tval >> unsafe; scale_u.d = 1.0; scale_u.ieee.exponent += tval - (tval >> unsafe); /* 4. Approximate 2^x2 - 1, using a fourth-degree polynomial, with maximum error in [-2^-10-2^-30,2^-10+2^-30] less than 10^-19. */ x22 = (((.0096181293647031180 * x + .055504110254308625) * x + .240226506959100583) * x + .69314718055994495) * ex2_u.d; math_opt_barrier (x22); } /* 5. Return (2^x2-1) * 2^(t/512+e+ex) + 2^(t/512+e+ex). */ result = x22 * x + ex2_u.d; if (!unsafe) return result; else return result * scale_u.d; } else /* Return x, if x is a NaN or Inf; or overflow, otherwise. */ return TWO1023 * x;
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 }