Lines Matching refs:fs
1560 int32_t& rounded_int, double fs) {
1576 rounded = std::floor(fs + 0.5);
1578 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1585 rounded = trunc(fs);
1589 rounded = std::ceil(fs);
1593 rounded = std::floor(fs);
1601 int32_t& rounded_int, float fs) {
1617 rounded = std::floor(fs + 0.5);
1619 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1626 rounded = trunc(fs);
1630 rounded = std::ceil(fs);
1634 rounded = std::floor(fs);
1642 int64_t& rounded_int, double fs) {
1658 rounded = std::floor(fs + 0.5);
1660 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1667 rounded = trunc(fs);
1671 rounded = std::ceil(fs);
1675 rounded = std::floor(fs);
1683 int64_t& rounded_int, float fs) {
1699 rounded = std::floor(fs + 0.5);
1701 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1708 rounded = trunc(fs);
1712 rounded = std::ceil(fs);
1716 rounded = std::floor(fs);
2325 double ft, fs, fd;
2328 fs = get_fpu_register_double(fs_reg());
2341 double upper = std::ceil(fs);
2342 double lower = std::floor(fs);
2345 if (upper - fs < fs - lower) {
2347 } else if (upper - fs > fs - lower) {
2360 result = (fs > 0 ? lower : upper);
2370 if (result != fs) {
2377 set_fpu_register_double(fd_reg(), (fd_int & 0x1) == 0 ? fs : ft);
2381 set_fpu_register_double(fd_reg(), (ft_int & 0x1) == 0 ? fs : 0.0);
2385 set_fpu_register_double(fd_reg(), (ft_int & 0x1) != 0 ? fs : 0.0);
2390 set_fpu_register_double(fd_reg(), fs);
2399 set_fpu_register_double(fd_reg(), fs);
2409 if (test_fcsr_bit(ft_cc)) set_fpu_register_double(fd_reg(), fs);
2412 if (!test_fcsr_bit(ft_cc)) set_fpu_register_double(fd_reg(), fs);
2418 fs = get_fpu_register_double(fs_reg());
2419 if (std::isnan(fs) && std::isnan(ft)) {
2420 set_fpu_register_double(fd_reg(), fs);
2421 } else if (std::isnan(fs) && !std::isnan(ft)) {
2423 } else if (!std::isnan(fs) && std::isnan(ft)) {
2424 fs);
2426 set_fpu_register_double(fd_reg(), (fs >= ft) ? ft : fs);
2431 fs = get_fpu_register_double(fs_reg());
2432 if (std::isnan(fs) && std::isnan(ft)) {
2433 set_fpu_register_double(fd_reg(), fs);
2434 } else if (std::isnan(fs) && !std::isnan(ft)) {
2436 } else if (!std::isnan(fs) && std::isnan(ft)) {
2437 set_fpu_register_double(fd_reg(), fs);
2440 if (fabs(fs) > fabs(ft)) {
2442 } else if (fabs(fs) < fabs(ft)) {
2443 result = fs;
2445 result = (fs < ft ? fs : ft);
2452 fs = get_fpu_register_double(fs_reg());
2453 if (std::isnan(fs) && std::isnan(ft)) {
2454 set_fpu_register_double(fd_reg(), fs);
2455 } else if (std::isnan(fs) && !std::isnan(ft)) {
2457 } else if (!std::isnan(fs) && std::isnan(ft)) {
2458 set_fpu_register_double(fd_reg(), fs);
2461 if (fabs(fs) < fabs(ft)) {
2463 } else if (fabs(fs) > fabs(ft)) {
2464 result = fs;
2466 result = (fs > ft ? fs : ft);
2473 fs = get_fpu_register_double(fs_reg());
2474 if (std::isnan(fs) && std::isnan(ft)) {
2475 set_fpu_register_double(fd_reg(), fs);
2476 } else if (std::isnan(fs) && !std::isnan(ft)) {
2478 } else if (!std::isnan(fs) && std::isnan(ft)) {
2479 set_fpu_register_double(fd_reg(), fs);
2481 set_fpu_register_double(fd_reg(), (fs <= ft) ? ft : fs);
2486 set_fpu_register_double(fd_reg(), fs + ft);
2489 set_fpu_register_double(fd_reg(), fs - ft);
2492 set_fpu_register_double(fd_reg(), fs * ft);
2495 set_fpu_register_double(fd_reg(), fs / ft);
2498 set_fpu_register_double(fd_reg(), fabs(fs));
2501 set_fpu_register_double(fd_reg(), fs);
2504 set_fpu_register_double(fd_reg(), -fs);
2508 set_fpu_register_double(fd_reg(), fast_sqrt(fs, isolate_));
2513 double result = 1.0 / fast_sqrt(fs, isolate_);
2519 double result = 1.0 / fs;
2524 set_fcsr_bit(fcsr_cc, std::isnan(fs) || std::isnan(ft));
2527 set_fcsr_bit(fcsr_cc, (fs == ft));
2530 set_fcsr_bit(fcsr_cc, (fs == ft) || (std::isnan(fs) || std::isnan(ft)));
2533 set_fcsr_bit(fcsr_cc, (fs < ft));
2536 set_fcsr_bit(fcsr_cc, (fs < ft) || (std::isnan(fs) || std::isnan(ft)));
2539 set_fcsr_bit(fcsr_cc, (fs <= ft));
2542 set_fcsr_bit(fcsr_cc, (fs <= ft) || (std::isnan(fs) || std::isnan(ft)));
2547 round_according_to_fcsr(fs, rounded, result, fs);
2549 if (set_fcsr_round_error(fs, rounded)) {
2550 set_fpu_register_word_invalid_result(fs, rounded);
2555 double rounded = std::floor(fs + 0.5);
2557 if ((result & 1) != 0 && result - fs == 0.5) {
2563 if (set_fcsr_round_error(fs, rounded)) {
2564 set_fpu_register_word_invalid_result(fs, rounded);
2569 double rounded = trunc(fs);
2572 if (set_fcsr_round_error(fs, rounded)) {
2573 set_fpu_register_word_invalid_result(fs, rounded);
2578 double rounded = std::floor(fs);
2581 if (set_fcsr_round_error(fs, rounded)) {
2582 set_fpu_register_word_invalid_result(fs, rounded);
2587 double rounded = std::ceil(fs);
2590 if (set_fcsr_round_error(fs, rounded)) {
2591 set_fpu_register_word_invalid_result(fs, rounded);
2595 set_fpu_register_float(fd_reg(), static_cast<float>(fs));
2601 round64_according_to_fcsr(fs, rounded, result, fs);
2603 if (set_fcsr_round64_error(fs, rounded)) {
2604 set_fpu_register_invalid_result64(fs, rounded);
2614 double rounded = trunc(fs);
2618 if (set_fcsr_round64_error(fs, rounded)) {
2619 set_fpu_register_invalid_result64(fs, rounded);
2628 double rounded = std::floor(fs + 0.5);
2630 if ((result & 1) != 0 && result - fs == 0.5) {
2638 if (set_fcsr_round64_error(fs, rounded)) {
2639 set_fpu_register_invalid_result64(fs, rounded);
2648 double rounded = std::floor(fs);
2652 if (set_fcsr_round64_error(fs, rounded)) {
2653 set_fpu_register_invalid_result64(fs, rounded);
2662 double rounded = std::ceil(fs);
2666 if (set_fcsr_round64_error(fs, rounded)) {
2667 set_fpu_register_invalid_result64(fs, rounded);
2676 uint64_t classed = bit_cast<uint64_t>(fs);
2750 float fs = get_fpu_register_float(fs_reg());
2766 if (std::isnan(fs) || std::isnan(ft)) {
2773 if (fs == ft) {
2780 if ((fs == ft) || (std::isnan(fs) || std::isnan(ft))) {
2787 if (fs < ft) {
2794 if ((fs < ft) || (std::isnan(fs) || std::isnan(ft))) {
2801 if (fs <= ft) {
2808 if ((fs <= ft) || (std::isnan(fs) || std::isnan(ft))) {
2815 if (!std::isnan(fs) && !std::isnan(ft)) {
2822 if ((fs != ft) || (std::isnan(fs) || std::isnan(ft))) {
2829 if (fs != ft) {
2842 float fs, ft, fd;
2843 fs = get_fpu_register_float(fs_reg());
2856 float upper = std::ceil(fs);
2857 float lower = std::floor(fs);
2860 if (upper - fs < fs - lower) {
2862 } else if (upper - fs > fs - lower) {
2875 result = (fs > 0 ? lower : upper);
2885 if (result != fs) {
2891 set_fpu_register_float(fd_reg(), fs + ft);
2894 set_fpu_register_float(fd_reg(), fs - ft);
2897 set_fpu_register_float(fd_reg(), fs * ft);
2900 set_fpu_register_float(fd_reg(), fs / ft);
2903 set_fpu_register_float(fd_reg(), fabs(fs));
2906 set_fpu_register_float(fd_reg(), fs);
2909 set_fpu_register_float(fd_reg(), -fs);
2913 set_fpu_register_float(fd_reg(), fast_sqrt(fs, isolate_));
2918 float result = 1.0 / fast_sqrt(fs, isolate_);
2924 float result = 1.0 / fs;
2932 set_fcsr_bit(fcsr_cc, std::isnan(fs) || std::isnan(ft));
2935 set_fcsr_bit(fcsr_cc, (fs == ft));
2938 set_fcsr_bit(fcsr_cc, (fs == ft) || (std::isnan(fs) || std::isnan(ft)));
2941 set_fcsr_bit(fcsr_cc, (fs < ft));
2944 set_fcsr_bit(fcsr_cc, (fs < ft) || (std::isnan(fs
2947 set_fcsr_bit(fcsr_cc, (fs <= ft));
2950 set_fcsr_bit(fcsr_cc, (fs <= ft) || (std::isnan(fs) || std::isnan(ft)));
2953 set_fpu_register_double(fd_reg(), static_cast<double>(fs));
2957 set_fpu_register_float(fd_reg(), (fd_int & 0x1) == 0 ? fs : ft);
2961 float fs = get_fpu_register_float(fs_reg());
2962 uint32_t classed = bit_cast<uint32_t>(fs);
3040 set_fpu_register_float(fd_reg(), fs);
3047 set_fpu_register_float(fd_reg(), fs);
3058 if (test_fcsr_bit(ft_cc)) set_fpu_register_float(fd_reg(), fs);
3061 if (!test_fcsr_bit(ft_cc)) set_fpu_register_float(fd_reg(), fs);
3066 float rounded = trunc(fs);
3069 if (set_fcsr_round_error(fs, rounded)) {
3070 set_fpu_register_word_invalid_result(fs, rounded);
3075 float rounded = trunc(fs);
3079 if (set_fcsr_round64_error(fs, rounded)) {
3080 set_fpu_register_invalid_result64(fs, rounded);
3089 float rounded = std::floor(fs);
3092 if (set_fcsr_round_error(fs, rounded)) {
3093 set_fpu_register_word_invalid_result(fs, rounded);
3098 float rounded = std::floor(fs);
3102 if (set_fcsr_round64_error(fs, rounded)) {
3103 set_fpu_register_invalid_result64(fs, rounded);
3111 float rounded = std::floor(fs + 0.5);
3113 if ((result & 1) != 0 && result - fs == 0.5) {
3119 if (set_fcsr_round_error(fs, rounded)) {
3120 set_fpu_register_word_invalid_result(fs, rounded);
3126 float rounded = std::floor(fs + 0.5);
3128 if ((result & 1) != 0 && result - fs == 0.5) {
3136 if (set_fcsr_round64_error(fs, rounded)) {
3137 set_fpu_register_invalid_result64(fs, rounded);
3146 float rounded = std::ceil(fs);
3149 if (set_fcsr_round_error(fs, rounded)) {
3150 set_fpu_register_word_invalid_result(fs, rounded);
3155 float rounded = std::ceil(fs);
3159 if (set_fcsr_round64_error(fs, rounded)) {
3160 set_fpu_register_invalid_result64(fs, rounded);
3169 fs = get_fpu_register_float(fs_reg());
3170 if (std::isnan(fs) && std::isnan(ft)) {
3171 set_fpu_register_float(fd_reg(), fs);
3172 } else if (std::isnan(fs) && !std::isnan(ft)) {
3174 } else if (!std::isnan(fs) && std::isnan(ft)) {
3175 set_fpu_register_float(fd_reg(), fs);
3177 set_fpu_register_float(fd_reg(), (fs >= ft) ? ft : fs);
3182 fs = get_fpu_register_float(fs_reg());
3183 if (std::isnan(fs) && std::isnan(ft)) {
3184 set_fpu_register_float(fd_reg(), fs);
3185 } else if (std::isnan(fs) && !std::isnan(ft)) {
3187 } else if (!std::isnan(fs) && std::isnan(ft)) {
3188 set_fpu_register_float(fd_reg(), fs);
3190 set_fpu_register_float(fd_reg(), (fs <= ft) ? ft : fs);
3195 fs = get_fpu_register_float(fs_reg());
3196 if (std::isnan(fs) && std::isnan(ft)) {
3197 set_fpu_register_float(fd_reg(), fs);
3198 } else if (std::isnan(fs) && !std::isnan(ft)) {
3200 } else if (!std::isnan(fs) && std::isnan(ft)) {
3201 set_fpu_register_float(fd_reg(), fs);
3204 if (fabs(fs) > fabs(ft)) {
3206 } else if (fabs(fs) < fabs(ft)) {
3207 result = fs;
3209 result = (fs < ft ? fs : ft);
3216 fs = get_fpu_register_float(fs_reg());
3217 if (std::isnan(fs) && std::isnan(ft)) {
3218 set_fpu_register_float(fd_reg(), fs);
3219 } else if (std::isnan(fs) && !std::isnan(ft)) {
3221 } else if (!std::isnan(fs) && std::isnan(ft)) {
3222 set_fpu_register_float(fd_reg(), fs);
3225 if (fabs(fs) < fabs(ft)) {
3227 } else if (fabs(fs) > fabs(ft)) {
3228 result = fs;
3230 result = (fs > ft ? fs : ft);
3239 round64_according_to_fcsr(fs, rounded, result, fs);
3241 if (set_fcsr_round64_error(fs, rounded)) {
3242 set_fpu_register_invalid_result64(fs, rounded);
3252 round_according_to_fcsr(fs, rounded, result, fs);
3254 if (set_fcsr_round_error(fs, rounded)) {
3255 set_fpu_register_word_invalid_result(fs, rounded);
3268 double fs = get_fpu_register_double(fs_reg());
3296 if (std::isnan(fs) || std::isnan(ft)) {
3303 if (fs == ft) {
3310 if ((fs == ft) || (std::isnan(fs) || std::isnan(ft))) {
3317 if (fs < ft) {
3324 if ((fs < ft) || (std::isnan(fs) || std::isnan(ft))) {
3331 if (fs <= ft) {
3338 if ((fs <= ft) || (std::isnan(fs) || std::isnan(ft))) {
3345 if (!std::isnan(fs) && !std::isnan(ft)) {
3352 if ((fs != ft) || (std::isnan(fs) || std::isnan(ft))) {
3359 if (fs != ft && (!std::isnan(fs) && !std::isnan(ft))) {
3429 double fr, ft, fs;
3431 fs = get_fpu_register_double(fs_reg());
3433 set_fpu_register_double(fd_reg(), fs * ft + fr);
