Как округлить числа с плавающей точкой до ближайшего целого числа в C?

Question

Есть ли способ округлить числа в C?

Я не хочу использовать потолок и пол. Есть ли другая альтернатива?

Я наткнулся на этот фрагмент кода, когда я Googled для ответа:

(int)(num < 0 ? (num - 0.5) : (num + 0.5)) 

Эта строка всегда печатает значение как 4, даже если поплавок Num = 4.9.

Answer 1

4.9 + 0.5 - 5.4, который не может быть округленным до 4, если ваш компилятор серьезно не сломан.

Я только что подтвердил, что код Googled дает правильный ответ для 4.9.

marcelo@macbookpro-1:~$ cat round.c 
#include <stdio.h> 

int main() { 
    float num = 4.9; 
    int n = (int)(num < 0 ? (num - 0.5) : (num + 0.5)); 
    printf("%d\n", n); 
} 
marcelo@macbookpro-1:~$ make round && ./round 
cc  round.c -o round 
5 
marcelo@macbookpro-1:~$ 

Answer 2

Общее решение заключается в использовании rint() и установить FLT_ROUNDS режим округления по мере необходимости.

Answer 3

Try двигая скобки на ваше решение выше, так что он читает:

(int)(num < 0) ? (num - 0.5) : (num + 0.5) 

Использование Num в 4,9 она округляет до 5 на моей машине.

Answer 4

Я думаю, что вы ищете это: int n = (d - floor(d) > 0.5) ? ceil(d) : floor(d);

Answer 5

Вы можете быть в состоянии использовать fesetround() в fenv.h (введен в C99). Возможными аргументами являются макросы FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO и FE_UPWARD, но обратите внимание, что не все из них обязательно определены - только те, которые поддерживаются платформой/реализацией. Затем вы можете использовать различные функции round, rint и nearbyint в math.h (также C99). Таким образом, вы можете установить желаемое поведение округления один раз и вызвать ту же функцию независимо от того, является ли это значение положительным или отрицательным.

(С, например, lround обычно нужно даже не установить округление направления для нормального использования, чтобы получить, как правило, то, что вы хотите.)

Answer 6

Я не уверен, что это хорошая идея. Этот код зависит от приведения, и я уверен, что точное усечение не определено.

float result = (num - floor(num) > 0.5) ? ceil(num) : floor(num); 

Я бы сказал, что это гораздо лучше (это в основном то, что писал Широко), так как он не зависит от каких-либо забросов.

Answer 7

работает с ошибкой. Идея этого заключается в том, что вы округлите, когда десятичное число меньше 0,5 и наоборот. (int) преобразует float в тип int, который просто сбрасывает десятичную. Если вы добавите .5 в положительное число, вы получите падение до следующего int. Если вы вычитаете .5 из отрицательного, то он делает то же самое.

Answer 8

int round(double x) 
{ 
return x >= 0.0 ? int(x + 0.5) : int(x - int(x-1) + 0.5) + int(x-1); 
} 

Это будет быстрее, чем версия с потолком и полом.

Answer 9

Круглое значение х до точности p, где 0 < p < бесконечное. (f.ex. 0,25, 0.5, 1, 2, ...)

float RoundTo(float x, float p) 
{ 
    float y = 1/p; 
    return int((x+(1/(y+y)))*y)/y; 
} 

float RoundUp(float x, float p) 
{ 
    float y = 1/p; 
    return int((x+(1/y))*y)/y; 
} 

float RoundDown(float x, float p) 
{ 
    float y = 1/p; 
    return int(x*y)/y; 
} 

Answer 10

Чтобы округлить в С в float, есть 3 <math.h> функции для удовлетворения потребности. Рекомендовать rintf().

float nearbyintf(float x); 

В nearbyint функции вокруг своего аргумента целого значения в формате с плавающей точкой, используя текущее направление округления и без повышения „неточного“ «» исключения с плавающей точкой. C11dr §7.12.9.3 2

или

float rintf(float x); 

В rint функции отличаются от nearbyint функций (7.12.9.3) только в том, что rint функции могут поднимать '' неточное» «исключение с плавающей точкой», если результат отличается от значения аргументом. C11dr §7.12.9.4 2

или

float roundf(float x); 

В round функции круглого аргумента до ближайшего целого значения в формате с плавающей точкой, округление случаи на полпути от нуля, независимо от того, текущее направление округления. C11dr §7.12.9.6 2

---

Пример

#include <fenv.h> 
#include <math.h> 
#include <stdio.h> 

void rtest(const char *fname, double (*f)(double x), double x) { 
    printf("Clear inexact flag  :%s\n", feclearexcept(FE_INEXACT) ? "Fail" : "Success"); 
    printf("Set round to nearest mode:%s\n", fesetround(FE_TONEAREST) ? "Fail" : "Success"); 

    double y = (*f)(x); 
    printf("%s(%f) --> %f\n", fname,x,y); 

    printf("Inexact flag    :%s\n", fetestexcept(FE_INEXACT) ? "Inexact" : "Exact"); 
    puts(""); 
} 

int main(void) { 
    double x = 8.5; 
    rtest("nearbyint", nearbyint, x); 
    rtest("rint", rint, x); 
    rtest("round", round, x); 
    return 0; 
} 

Выход

Clear inexact flag  :Success 
Set round to nearest mode:Success 
nearbyint(8.500000) --> 8.000000 
Inexact flag    :Exact 

Clear inexact flag  :Success 
Set round to nearest mode:Success 
rint(8.500000) --> 8.000000 
Inexact flag    :Inexact 

Clear inexact flag  :Success 
Set round to nearest mode:Success 
round(8.500000) --> 9.000000 
Inexact flag    :Exact 

---

Что слаб о коде OP в?

(int)(num < 0 ? (num - 0.5) : (num + 0.5)) 

1. Должен num иметь значение не вблизи int диапазона, литые (int) результатов в непредсказуемом поведении.

2. Когда num +/- 0.5 приводит к неточному ответу. Здесь маловероятно, что 0.5 является double, в результате чего добавление происходит с большей точностью, чем float. Когда num и 0.5 имеют одинаковую точность, добавление 0.5 к числу может привести к числовое округленное ответ. (Это не целое число округления позиции OP.) Пример: число, равное менее 0,5, должно округляться до 0 на цель OP, но num + 0.5 приводит к точному ответу между 1.0 и наименьшим double всего менее 1.0. Поскольку точный ответ не является представимым, эта сумма округляется, как правило, до 1.0, приводя к неправильному ответу. Аналогичная ситуация имеет место с большими числами.дилемма

---

OP о "Эта строка всегда печатает значение как 4, даже когда float num =4.9." не объяснимо, как указано. Требуется дополнительный код/​​информация. Я подозреваю, что ОП мог использовать int num = 4.9;.

---

// avoid all library calls 
// Relies on UINTMAX_MAX >= FLT_MAX_CONTINUOUS_INTEGER - 1 
float my_roundf(float x) { 
    // Test for large values of x 
    // All of the x values are whole numbers and need no rounding 
    #define FLT_MAX_CONTINUOUS_INTEGER (FLT_RADIX/FLT_EPSILON) 
    if (x >= FLT_MAX_CONTINUOUS_INTEGER) return x; 

    // Positive numbers 
    // Important: _no_ precision lost in the subtraction 
    // This is the key improvement over OP's method 
    if (x > 0) { 
    float floor_x = (float)(uintmax_t) x; 
    if (x - floor_x >= 0.5) floor_x += 1.0f; 
    return floor_x; 
    } 

    if (x < 0) return -my_roundf(-x); 
    return x; // x is 0.0, -0.0 or NaN 
} 

Испытано мало - будет делать это позже, когда у меня есть время.