Lines Matching refs:fs
1484 int32_t& rounded_int, double fs) {
1500 rounded = std::floor(fs + 0.5);
1502 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1509 rounded = trunc(fs);
1513 rounded = std::ceil(fs);
1517 rounded = std::floor(fs);
1525 int64_t& rounded_int, double fs) {
1541 rounded = std::floor(fs + 0.5);
1543 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1550 rounded = trunc(fs);
1554 rounded = std::ceil(fs);
1558 rounded = std::floor(fs);
1567 int32_t& rounded_int, float fs) {
1583 rounded = std::floor(fs + 0.5);
1585 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1592 rounded = trunc(fs);
1596 rounded = std::ceil(fs);
1600 rounded = std::floor(fs);
1608 int64_t& rounded_int, float fs) {
1624 rounded = std::floor(fs + 0.5);
1626 if ((rounded_int & 1) != 0 && rounded_int - fs == 0.5) {
1633 rounded = trunc(fs);
1637 rounded = std::ceil(fs);
1641 rounded = std::floor(fs);
2323 float fs, ft, fd;
2324 fs = get_fpu_register_float(fs_reg());
2337 float upper = std::ceil(fs);
2338 float lower = std::floor(fs);
2341 if (upper - fs < fs - lower) {
2343 } else if (upper - fs > fs - lower) {
2356 result = (fs > 0 ? lower : upper);
2366 if (result != fs) {
2372 set_fpu_register_float(fd_reg(), fs + ft);
2375 set_fpu_register_float(fd_reg(), fs - ft);
2378 set_fpu_register_float(fd_reg(), fs * ft);
2381 set_fpu_register_float(fd_reg(), fs / ft);
2384 set_fpu_register_float(fd_reg(), fabs(fs));
2387 set_fpu_register_float(fd_reg(), fs);
2390 set_fpu_register_float(fd_reg(), -fs);
2394 set_fpu_register_float(fd_reg(), fast_sqrt(fs, isolate_));
2398 float result = 1.0 / fast_sqrt(fs, isolate_);
2403 float result = 1.0 / fs;
2411 set_fcsr_bit(fcsr_cc, std::isnan(fs) || std::isnan(ft));
2414 set_fcsr_bit(fcsr_cc, (fs == ft));
2417 set_fcsr_bit(fcsr_cc, (fs == ft) || (std::isnan(fs) || std::isnan(ft)));
2420 set_fcsr_bit(fcsr_cc, (fs < ft));
2423 set_fcsr_bit(fcsr_cc, (fs < ft) || (std::isnan(fs) || std::isnan(ft)));
2426 set_fcsr_bit(fcsr_cc, (fs <= ft));
2429 set_fcsr_bit(fcsr_cc, (fs <= ft) || (std::isnan(fs) || std::isnan(ft)));
2432 set_fpu_register_double(fd_reg(), static_cast<double>(fs));
2436 uint32_t classed = bit_cast<uint32_t>(fs);
2502 round64_according_to_fcsr(fs, rounded, result, fs);
2504 if (set_fcsr_round64_error(fs, rounded)) {
2505 set_fpu_register_invalid_result64(fs, rounded);
2512 round_according_to_fcsr(fs, rounded, result, fs);
2514 if (set_fcsr_round_error(fs, rounded)) {
2515 set_fpu_register_word_invalid_result(fs, rounded);
2520 float rounded = trunc(fs);
2523 if (set_fcsr_round_error(fs, rounded)) {
2524 set_fpu_register_word_invalid_result(fs, rounded);
2528 float rounded = trunc(fs);
2531 if (set_fcsr_round64_error(fs, rounded)) {
2532 set_fpu_register_invalid_result64(fs, rounded);
2537 float rounded = std::floor(fs + 0.5);
2539 if ((result & 1) != 0 && result - fs == 0.5) {
2545 if (set_fcsr_round_error(fs, rounded)) {
2546 set_fpu_register_word_invalid_result(fs, rounded);
2551 float rounded = std::floor(fs + 0.5);
2553 if ((result & 1) != 0 && result - fs == 0.5) {
2560 if (set_fcsr_round64_error(fs, rounded)) {
2561 set_fpu_register_invalid_result64(fs, rounded);
2566 float rounded = floor(fs);
2569 if (set_fcsr_round64_error(fs, rounded)) {
2570 set_fpu_register_invalid_result64(fs, rounded);
2576 float rounded = std::floor(fs);
2579 if (set_fcsr_round_error(fs, rounded)) {
2580 set_fpu_register_word_invalid_result(fs, rounded);
2585 float rounded = std::ceil(fs);
2588 if (set_fcsr_round_error(fs, rounded)) {
2589 set_fpu_register_invalid_result(fs, rounded);
2593 float rounded = ceil(fs);
2596 if (set_fcsr_round64_error(fs, rounded)) {
2597 set_fpu_register_invalid_result64(fs, rounded);
2603 fs = get_fpu_register_float(fs_reg());
2604 if (std::isnan(fs) && std::isnan(ft)) {
2605 set_fpu_register_float(fd_reg(), fs);
2606 } else if (std::isnan(fs) && !std::isnan(ft)) {
2608 } else if (!std::isnan(fs) && std::isnan(ft)) {
2609 set_fpu_register_float(fd_reg(), fs);
2612 if (fabs(fs) > fabs(ft)) {
2614 } else if (fabs(fs) < fabs(ft)) {
2615 result = fs;
2617 result = (fs < ft ? fs : ft);
2624 fs = get_fpu_register_float(fs_reg());
2625 if (std::isnan(fs) && std::isnan(ft)) {
2626 set_fpu_register_float(fd_reg(), fs);
2627 } else if (std::isnan(fs) && !std::isnan(ft)) {
2629 } else if (!std::isnan(fs) && std::isnan(ft)) {
2630 set_fpu_register_float(fd_reg(), fs);
2633 if (fabs(fs) < fabs(ft)) {
2635 } else if (fabs(fs) > fabs(ft)) {
2636 result = fs;
2638 result = (fs > ft ? fs : ft);
2645 fs = get_fpu_register_float(fs_reg());
2646 if (std::isnan(fs) && std::isnan(ft)) {
2647 set_fpu_register_float(fd_reg(), fs);
2648 } else if (std::isnan(fs) && !std::isnan(ft)) {
2650 } else if (!std::isnan(fs) && std::isnan(ft)) {
2651 set_fpu_register_float(fd_reg(), fs);
2653 set_fpu_register_float(fd_reg(), (fs >= ft) ? ft : fs);
2658 fs = get_fpu_register_float(fs_reg());
2659 if (std::isnan(fs) && std::isnan(ft)) {
2660 set_fpu_register_float(fd_reg(), fs);
2661 } else if (std::isnan(fs) && !std::isnan(ft)) {
2663 } else if (!std::isnan(fs) && std::isnan(ft)) {
2664 set_fpu_register_float(fd_reg(), fs);
2666 set_fpu_register_float(fd_reg(), (fs <= ft) ? ft : fs);
2671 set_fpu_register_float(fd_reg(), (fd_int & 0x1) == 0 ? fs : ft);
2688 set_fpu_register_float(fd_reg(), fs);
2695 set_fpu_register_float(fd_reg(), fs);
2706 if (test_fcsr_bit(ft_cc)) set_fpu_register_float(fd_reg(), fs);
2709 if (!test_fcsr_bit(ft_cc)) set_fpu_register_float(fd_reg(), fs);
2722 double ft, fs, fd;
2724 fs = get_fpu_register_double(fs_reg());
2737 double upper = std::ceil(fs);
2738 double lower = std::floor(fs);
2741 if (upper - fs < fs - lower) {
2743 } else if (upper - fs > fs - lower) {
2756 result = (fs > 0 ? lower : upper);
2766 if (result != fs) {
2773 set_fpu_register_double(fd_reg(), (fd_int & 0x1) == 0 ? fs : ft);
2777 set_fpu_register_double(fd_reg(), (ft_int & 0x1) == 0 ? fs : 0.0);
2781 set_fpu_register_double(fd_reg(), (ft_int & 0x1) != 0 ? fs : 0.0);
2786 set_fpu_register_double(fd_reg(), fs);
2793 set_fpu_register_double(fd_reg(), fs);
2803 if (test_fcsr_bit(ft_cc)) set_fpu_register_double(fd_reg(), fs);
2806 if (!test_fcsr_bit(ft_cc)) set_fpu_register_double(fd_reg(), fs);
2812 fs = get_fpu_register_double(fs_reg());
2813 if (std::isnan(fs) && std::isnan(ft)) {
2814 set_fpu_register_double(fd_reg(), fs);
2815 } else if (std::isnan(fs) && !std::isnan(ft)) {
2817 } else if (!std::isnan(fs) && std::isnan(ft)) {
2818 set_fpu_register_double(fd_reg(), fs);
2821 if (fabs(fs) > fabs(ft)) {
2823 } else if (fabs(fs) < fabs(ft)) {
2824 result = fs;
2826 result = (fs < ft ? fs : ft);
2833 fs = get_fpu_register_double(fs_reg());
2834 if (std::isnan(fs) && std::isnan(ft)) {
2835 set_fpu_register_double(fd_reg(), fs);
2836 } else if (std::isnan(fs) && !std::isnan(ft)) {
2838 } else if (!std::isnan(fs) && std::isnan(ft)) {
2839 set_fpu_register_double(fd_reg(), fs);
2842 if (fabs(fs) < fabs(ft)) {
2844 } else if (fabs(fs) > fabs(ft)) {
2845 result = fs;
2847 result = (fs > ft ? fs : ft);
2854 fs = get_fpu_register_double(fs_reg());
2855 if (std::isnan(fs) && std::isnan(ft)) {
2856 set_fpu_register_double(fd_reg(), fs);
2857 } else if (std::isnan(fs) && !std::isnan(ft)) {
2859 } else if (!std::isnan(fs) && std::isnan(ft)) {
2860 set_fpu_register_double(fd_reg(), fs);
2862 set_fpu_register_double(fd_reg(), (fs >= ft) ? ft : fs);
2867 fs = get_fpu_register_double(fs_reg());
2868 if (std::isnan(fs) && std::isnan(ft)) {
2869 set_fpu_register_double(fd_reg(), fs);
2870 } else if (std::isnan(fs) && !std::isnan(ft)) {
2872 } else if (!std::isnan(fs) && std::isnan(ft)) {
2873 set_fpu_register_double(fd_reg(), fs);
2875 set_fpu_register_double(fd_reg(), (fs <= ft) ? ft : fs);
2879 set_fpu_register_double(fd_reg(), fs + ft);
2882 set_fpu_register_double(fd_reg(), fs - ft);
2885 set_fpu_register_double(fd_reg(), fs * ft);
2888 set_fpu_register_double(fd_reg(), fs / ft);
2891 set_fpu_register_double(fd_reg(), fabs(fs));
2894 set_fpu_register_double(fd_reg(), fs);
2897 set_fpu_register_double(fd_reg(), -fs);
2901 set_fpu_register_double(fd_reg(), fast_sqrt(fs, isolate_));
2905 double result = 1.0 / fast_sqrt(fs, isolate_);
2910 double result = 1.0 / fs;
2915 set_fcsr_bit(fcsr_cc, std::isnan(fs) || std::isnan(ft));
2918 set_fcsr_bit(fcsr_cc, (fs == ft));
2921 set_fcsr_bit(fcsr_cc, (fs == ft) || (std::isnan(fs) || std::isnan(ft)));
2924 set_fcsr_bit(fcsr_cc, (fs < ft));
2927 set_fcsr_bit(fcsr_cc, (fs < ft) || (std::isnan(fs) || std::isnan(ft)));
2930 set_fcsr_bit(fcsr_cc, (fs <= ft));
2933 set_fcsr_bit(fcsr_cc, (fs <= ft) || (std::isnan(fs) || std::isnan(ft)));
2938 round_according_to_fcsr(fs, rounded, result, fs);
2940 if (set_fcsr_round_error(fs, rounded)) {
2941 set_fpu_register_word_invalid_result(fs, rounded);
2947 double rounded = std::floor(fs + 0.5);
2949 if ((result & 1) != 0 && result - fs == 0.5) {
2955 if (set_fcsr_round_error(fs, rounded)) {
2956 set_fpu_register_invalid_result(fs, rounded);
2961 double rounded = trunc(fs);
2964 if (set_fcsr_round_error(fs, rounded)) {
2965 set_fpu_register_invalid_result(fs, rounded);
2970 fs);
2973 if (set_fcsr_round_error(fs, rounded)) {
2974 set_fpu_register_invalid_result(fs, rounded);
2979 double rounded = std::ceil(fs);
2982 if (set_fcsr_round_error(fs, rounded)) {
2983 set_fpu_register_invalid_result(fs, rounded);
2987 set_fpu_register_float(fd_reg(), static_cast<float>(fs));
2992 round64_according_to_fcsr(fs, rounded, result, fs);
2994 if (set_fcsr_round64_error(fs, rounded)) {
2995 set_fpu_register_invalid_result64(fs, rounded);
3000 double rounded = std::floor(fs + 0.5);
3002 if ((result & 1) != 0 && result - fs == 0.5) {
3009 if (set_fcsr_round64_error(fs, rounded)) {
3010 set_fpu_register_invalid_result64(fs, rounded);
3015 double rounded = trunc(fs);
3018 if (set_fcsr_round64_error(fs, rounded)) {
3019 set_fpu_register_invalid_result64(fs, rounded);
3024 double rounded = floor(fs);
3027 if (set_fcsr_round64_error(fs, rounded)) {
3028 set_fpu_register_invalid_result64(fs, rounded);
3033 double rounded = ceil(fs);
3036 if (set_fcsr_round64_error(fs, rounded)) {
3037 set_fpu_register_invalid_result64(fs, rounded);
3043 uint64_t classed = bit_cast<uint64_t>(fs);
3117 float fs = get_fpu_register_float(fs_reg());
3133 if (std::isnan(fs) || std::isnan(ft)) {
3140 if (fs == ft) {
3147 if ((fs == ft) || (std::isnan(fs) || std::isnan(ft))) {
3154 if (fs < ft) {
3161 if ((fs < ft) || (std::isnan(fs) || std::isnan(ft))) {
3168 if (fs <= ft) {
3175 if ((fs <= ft) || (std::isnan(fs) || std::isnan(ft))) {
3182 if (!std::isnan(fs) && !std::isnan(ft)) {
3189 if ((fs != ft) || (std::isnan(fs) || std::isnan(ft))) {
3196 if (fs != ft) {
3209 double fs = get_fpu_register_double(fs_reg());
3225 if (std::isnan(fs) || std::isnan(ft)) {
3232 if (fs == ft) {
3239 if ((fs == ft) || (std::isnan(fs) || std::isnan(ft))) {
3246 if (fs < ft) {
3253 if ((fs < ft) || (std::isnan(fs) || std::isnan(ft))) {
3260 if (fs <= ft) {
3267 if ((fs <= ft) || (std::isnan(fs) || std::isnan(ft))) {
3274 if (!std::isnan(fs) && !std::isnan(ft)) {
3281 if ((fs != ft) || (std::isnan(fs) || std::isnan(ft))) {
3288 if (fs != ft && (!std::isnan(fs) && !std::isnan(ft))) {
3366 double fr, ft, fs;
3368 fs = get_fpu_register_double(fs_reg());
3370 set_fpu_register_double(fd_reg(), fs * ft + fr);
