Исходный код для округления числа с плавающей запятой

0

Помимо использования каких-либо встроенных функций, таких как ceil и floor как вы можете объединить число с плавающей запятой?

Я хочу конвертировать 2.10 в 2. 14-> 2.1 и 2.15 до 2.19 → 2.2

Я написал некоторую логику, но застрял в середине

    float a = 2.24;
    int b = a*100;
    int result n, i =0;
    while(i>2)
    {
        n = b%10;
        i++;
    }
    if(n >5)
    {
      c = b%10;
      c = c/10 + 1;
    }

Я пробовал много встроенной функции, но все, что не работает для моего компилятора diab

//  totalDist = roundf(totalDist * 10) / 10.0;      
//  totalDist = floor(totalDist * pow(10., 1) + .5) / pow(10., 1);  
    totalDist = floorf(totalDist * 10 + 0.5) / 10;

планируя написать свою собственную логику

  • 0
    Почему «Кроме использования любой встроенной функции»?
  • 1
    totalDist = floorf(totalDist * 10 + 0.5) / 10; кажется правильным, за исключением того, что вы могли бы использовать литералы типа float: 10.0f и 0.5f .
Теги:
visual-c++

5 ответов

0
Лучший ответ

Поскольку мой старый ответ требует много тщательного программирования, чтобы заставить его работать

Я представляю другой способ реализации круглой функции:

Вы можете легко проверить, будет ли (положительное/отрицательное) число округлено вверх или вниз (добавление/вычитание). 0.5. Затем вы можете усечь результат и принять свой ответ. Кроме того, чтобы поддерживать более глубокий уровень раунда, как вы хотите, вы можете позволить пользователю указать, сколько десятичных знаков вокруг нужно, и вуаля:

long double round_f(long double number, int decimal_places)
{
     assert(decimal_places > 0);

     double power = pow(10, decimal_places-1);
     number *= power;

     return (number >= 0) ? ((long long)(number + 0.5))/power : ((long long)(number - 0.5))/power;
}

И здесь вы можете увидеть рабочий пример.

Старый:

Вы можете использовать спринт:

#include <stdio.h>

int main(void)
{
    float a = 2.24;
    int size;
    char num[8] = {0};
    sprintf(num, "%d", (int) (a * 100));

    for (size=0; num[size]; size++);

    size--;

    if (num[size] < '5') {
        num[size] = '0';
    } else {
        num[size] = '0';
        if (num[size-1] == '9')
            num[size-1] = '0';
        else
            num[size-1]++;
    }

    printf("a = %f\n", a);
    printf("num = %s\n", num);

    return(0);
}

Вы можете видеть логику. Наконец, вы можете вернуть строку в целое число и умножить на 100.

EDIT: Это только логика. См. Комментарии ниже для того, что необходимо для полной работы.

  • 0
    Окончательное число - 220, ожидаемый результат - 2,3.
  • 0
    Этот метод не работает для a > 100000.0 . Это не для чисел, как 3.99 . Не удается a < -10000.0 . Это не удается для a*100 большего int диапазона int .
Показать ещё 5 комментариев
3
float a = 2.24;
float b = roundf(a*10.0f)/10.0f;//roundf in C99
  • 0
    +1 Для решения, которое 1) работает как с положительными, так и с отрицательными числами, 2) не ограничивается диапазоном int и 3) является точным. (Предложите 10.0f вместо 10.0).
  • 0
    @chux Я изменился по твоему предложению.
Показать ещё 2 комментария
1

Попробуйте int((x + 0.05) * 10.0)/10.0.

Вы также можете использовать trunc вместо преобразования в и из int.

Или вы можете использовать round: round(x * 10.0)/10.0

  • 1
    int() потерпит неудачу в целочисленном диапазоне. trunc() потерпит неудачу на отрицательных числах. Вы можете использовать floor() вместо этого.
  • 0
    @Vovanium: за пределами целочисленного диапазона значения с плавающей запятой также не будут иметь точности. ОП не указывал поведение для отрицательных чисел, но это действительно то, что нужно решить
Показать ещё 1 комментарий
0

Ответ BLUEPIXY хорош. Но в основном; умножение с плавающей запятой происходит быстрее, чем деление, поэтому, если скорость актуальна; умножьте на 0,1 вместо деления на 10.

  • 0
    Я попробовал все это // totalDist = roundf (totalDist * 10) / 10.0; // totalDist = floor (totalDist * pow (10. 1) + .5) / pow (10. 1); totalDist = floorf (totalDist * 10 + 0,5) / 10;
0

Если вы просто хотите округлить число для целей вывода, то %.1f формата %.1f действительно является правильным ответом.

printf("%.1f", 2.14);

или Если вы действительно хотите округлить значение, то что-то вроде этой работы

#include <math.h>

float val = 37.777779;

float rounded_down = floorf(val * 100) / 100;   /* Result: 37.77 */
float nearest = floorf(val * 100 + 0.5) / 100;  /* Result: 37.78 */
float rounded_up = ceilf(val * 100) / 100;      /* Result: 37.78 */

Обычно мы используем nearest метод

  • 0
    Примечание: floorf(val * 100 + 0.5) не работает для отрицательных чисел.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню