Мені потрібна проста функція округлення з плаваючою комою, таким чином:

double round(double);

round(0.1) = 0
round(-0.1) = 0
round(-0.9) = -1

Я можу знайти ceil()і floor()в math.h - але ні round().

Він присутній у стандартній бібліотеці C ++ під іншою назвою, або він відсутній ??

У стандартній бібліотеці C ++ 98 немає круглого (). Ви можете написати це самостійно. Далі йде реалізація круглої половини :

double round(double d)
{
  return floor(d + 0.5);
}

Ймовірною причиною відсутності круглої функції у стандартній бібліотеці C ++ 98 є те, що вона насправді може бути реалізована різними способами. Вищезазначене є одним із поширених способів, але є й інші, такі як кругла до рівна , яка менш упереджена і, як правило, краще, якщо ви збираєтеся робити багато округлення; це трохи складніше втілити в життя.

Boost пропонує простий набір функцій округлення.

#include <boost/math/special_functions/round.hpp>

double a = boost::math::round(1.5); // Yields 2.0
int b = boost::math::iround(1.5); // Yields 2 as an integer

Для отримання додаткової інформації див документацію Boost .

Edit : Так як C ++ 11, є std::round, std::lroundіstd::llround .

Стандарт C ++ 03 покладається на стандарт C90 для того, що стандарт називає бібліотекою Standard C, яка охоплена в проекті стандарту C ++ 03 ( найближчий загальнодоступний проект стандарту до C ++ 03 - це N1804 ) 1.2 Нормативні посилання :

Бібліотека, описана в пункті 7 ISO / IEC 9899: 1990 та пункт 7 ISO / IEC 9899 / Amd.1: 1995, далі називається "Бібліотека стандарту С". ¹⁾

Якщо ми переходимо до документації на C для круглого, lround, llround на cppreference, ми можемо побачити, що круглі та пов'язані з ними функції є частиною C99, і тому вони не будуть доступні в C ++ 03 або попередньому.

У C ++ 11 це змінюється, оскільки C ++ 11 покладається на стандарт стандарту C99 для бібліотеки стандартних стандартів C, і тому забезпечує std :: round та для інтегральних типів повернення std :: lround, std :: llround :

#include <iostream>
#include <cmath>

int main()
{
    std::cout << std::round( 0.4 ) << " " << std::lround( 0.4 ) << " " << std::llround( 0.4 ) << std::endl ;
    std::cout << std::round( 0.5 ) << " " << std::lround( 0.5 ) << " " << std::llround( 0.5 ) << std::endl ;
    std::cout << std::round( 0.6 ) << " " << std::lround( 0.6 ) << " " << std::llround( 0.6 ) << std::endl ;
}

Іншим варіантом також від C99 буде std :: trunc, який:

Обчислює найближче ціле число не більше, ніж арг.

#include <iostream>
#include <cmath>

int main()
{
    std::cout << std::trunc( 0.4 ) << std::endl ;
    std::cout << std::trunc( 0.9 ) << std::endl ;
    std::cout << std::trunc( 1.1 ) << std::endl ;

}

Якщо вам потрібно підтримувати додатки , які не містять C ++ 11, найкращим варіантом буде використання підсилювального кругового, грунтового, грунтового, обертового або прискореного підключення .

Згорнути власну версію раунду важко

Прокрутка вашого власного, мабуть, не варта зусиль, оскільки важче, ніж здається: округлення поплавця до найближчого цілого числа, частина 1 , округлий поплавок до найближчого цілого числа, частина 2 і округлення поплавця до найближчого цілого числа, частина 3 поясніть:

Наприклад, звичайний ролик вашої реалізації за допомогою std::floorта додавання 0.5працює не для всіх даних:

double myround(double d)
{
  return std::floor(d + 0.5);
}

Один з даних, для якого не вдасться, - це 0.49999999999999994( дивіться його наживо ).

Інша загальна реалізація включає введення типу плаваючої точки до інтегрального типу, що може викликати невизначене поведінку у випадку, коли інтегральна частина не може бути представлена ​​у типі призначення. Це ми бачимо з проекту стандартного розділу C ++ " 4.9 Плаваючо-інтегральні перетворення", який говорить ( моє наголос ):

Первісне значення типу з плаваючою точкою може бути перетворене в первісне значення цілого числа. Скорочення конверсії; тобто дробова частина відкидається. Поведінка не визначена, якщо усічене значення не може бути представлено у типі призначення. [...]

Наприклад:

float myround(float f)
{
  return static_cast<float>( static_cast<unsigned int>( f ) ) ;
}

З огляду на std::numeric_limits<unsigned int>::max()це , 4294967295то наступний виклик:

myround( 4294967296.5f ) 

викличе переповнення, ( дивіться це наживо ).

Ми можемо побачити, наскільки це насправді складно, дивлячись на цю відповідь на стислий спосіб реалізації round () в C? яка посилається на newlibs версію єдиного точного поплавкового кругла. Це дуже довга функція для чогось, що здається простим. Навряд чи хтось без інтимних знань про реалізацію плаваючої крапки може правильно реалізувати цю функцію:

float roundf(x)
{
  int signbit;
  __uint32_t w;
  /* Most significant word, least significant word. */
  int exponent_less_127;

  GET_FLOAT_WORD(w, x);

  /* Extract sign bit. */
  signbit = w & 0x80000000;

  /* Extract exponent field. */
  exponent_less_127 = (int)((w & 0x7f800000) >> 23) - 127;

  if (exponent_less_127 < 23)
    {
      if (exponent_less_127 < 0)
        {
          w &= 0x80000000;
          if (exponent_less_127 == -1)
            /* Result is +1.0 or -1.0. */
            w |= ((__uint32_t)127 << 23);
        }
      else
        {
          unsigned int exponent_mask = 0x007fffff >> exponent_less_127;
          if ((w & exponent_mask) == 0)
            /* x has an integral value. */
            return x;

          w += 0x00400000 >> exponent_less_127;
          w &= ~exponent_mask;
        }
    }
  else
    {
      if (exponent_less_127 == 128)
        /* x is NaN or infinite. */
        return x + x;
      else
        return x;
    }
  SET_FLOAT_WORD(x, w);
  return x;
}

З іншого боку, якщо жодне з інших рішень не застосовується, newlib потенційно може бути варіантом, оскільки це добре перевірена реалізація.

Можливо, варто зауважити, що якщо ви хочете отримати цілий результат від округлення, вам не потрібно буде пропускати його через стелю або підлогу. Тобто,

int round_int( double r ) {
    return (r > 0.0) ? (r + 0.5) : (r - 0.5); 
}

Він доступний з C ++ 11 дюймами (згідно http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf )

#include <cmath>
#include <iostream>

int main(int argc, char** argv) {
  std::cout << "round(0.5):\t" << round(0.5) << std::endl;
  std::cout << "round(-0.5):\t" << round(-0.5) << std::endl;
  std::cout << "round(1.4):\t" << round(1.4) << std::endl;
  std::cout << "round(-1.4):\t" << round(-1.4) << std::endl;
  std::cout << "round(1.6):\t" << round(1.6) << std::endl;
  std::cout << "round(-1.6):\t" << round(-1.6) << std::endl;
  return 0;
}

Вихід:

round(0.5):  1
round(-0.5): -1
round(1.4):  1
round(-1.4): -1
round(1.6):  2
round(-1.6): -2

Зазвичай він реалізується як floor(value + 0.5).

Редагувати: і це, мабуть, не називається круглим, оскільки відомо щонайменше три алгоритми округлення, про які я знаю: круглий нуль, круглий до найближчого цілого числа та округлення банкіра. Ви запитуєте округлення до найближчого цілого числа.

Ми розглядаємо дві проблеми:

1. округлення перетворень
2. перетворення типу.

Перетворення округлення означають округлення ± поплавок / подвійний до найближчого поверху / плавучого плаву / подвійного. Можливо, ваша проблема закінчується тут. Але якщо очікується повернення Int / Long, вам потрібно здійснити перетворення типів, і, таким чином, проблема «Переповнення» може потрапити у ваше рішення. Так, зробіть перевірку на помилку у вашій функції

long round(double x) {
   assert(x >= LONG_MIN-0.5);
   assert(x <= LONG_MAX+0.5);
   if (x >= 0)
      return (long) (x+0.5);
   return (long) (x-0.5);
}

#define round(x) ((x) < LONG_MIN-0.5 || (x) > LONG_MAX+0.5 ?\
      error() : ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))

від: http://www.cs.tut.fi/~jkorpela/round.html

Певний тип округлення також реалізований у Boost:

#include <iostream>

#include <boost/numeric/conversion/converter.hpp>

template<typename T, typename S> T round2(const S& x) {
  typedef boost::numeric::conversion_traits<T, S> Traits;
  typedef boost::numeric::def_overflow_handler OverflowHandler;
  typedef boost::numeric::RoundEven<typename Traits::source_type> Rounder;
  typedef boost::numeric::converter<T, S, Traits, OverflowHandler, Rounder> Converter;
  return Converter::convert(x);
}

int main() {
  std::cout << round2<int, double>(0.1) << ' ' << round2<int, double>(-0.1) << ' ' << round2<int, double>(-0.9) << std::endl;
}

Зауважте, що це працює лише в тому випадку, якщо ви робите перетворення на цілі числа.

Ви можете округлити до n цифр точності за допомогою:

double round( double x )
{
const double sd = 1000; //for accuracy to 3 decimal places
return int(x*sd + (x<0? -0.5 : 0.5))/sd;
}

У ці дні не повинно бути проблемою використовувати компілятор C ++ 11, який включає математичну бібліотеку C99 / C ++ 11. Але тоді стає питання: яку функцію округлення ви обираєте?

C99 / C ++ 11 round()часто насправді не є функцією округлення, яку ви хочете . Він використовує режим фанкі округлення, який заокруглюється від 0, як розрив на половині випадків ( +-xxx.5000). Якщо ви конкретно хочете, щоб цей режим округлення або ви націлили на C ++ реалізацію там, де round()швидше rint(), тоді скористайтеся ним (або емулюйте його поведінку одним із інших відповідей на це питання, який сприйняв його за номіналом та ретельно відтворив цю конкретну поведінка на округлення.)

round()Округлення відрізняється від IEEE754 за замовчуванням до найближчого режиму навіть рівним тай- брейком . Найближчі - навіть уникають статистичного зміщення середньої величини чисел, але робить ухил до парних чисел.

Є дві функції округлення математичної бібліотеки, які використовують поточний режим округлення за замовчуванням: std::nearbyint()і std::rint()обидва додані в C99 / C ++ 11, тому вони доступні в будь-який час std::round(). Єдина відмінність полягає в тому, що nearbyintніколи не підвищується FE_INEXACT.

Віддайте перевагу rint()причин продуктивності : і gcc, і clang обидва вбудовують його легше, але gcc ніколи не вбудовується nearbyint()(навіть із -ffast-math)

gcc / clang для x86-64 та AArch64

Я поклав кілька тестових функцій у Провідник компілятора Метта Годбольта , де ви можете бачити вихідний вихідний вихідний (asm) вихід (для декількох компіляторів). Більше про читання результатів компілятора див. У цьому запитанні та запитаннях та розмові Метта про CppCon2017: «Що зробив мій компілятор останнім часом? Зняття кришки компілятора " ,

У FP-коді, як правило, великий виграш вбудовує невеликі функції. Особливо у не-Windows, де стандартний режим викликів не має збережених викликів регістрів, тому компілятор не може зберігати жодних значень FP в регістрах XMM через a call. Тож навіть якщо ви насправді не знаєте ASM, ви все одно можете легко зрозуміти, чи це лише хвостовий виклик функції бібліотеки чи чи він накреслений однією чи двома математичними інструкціями. Все, що вказує на одну чи дві інструкції, краще, ніж виклик функції (для цієї конкретної задачі на x86 або ARM).

На x86 все, що вказує на SSE4.1, roundsdможе автоматично векторизуватися за допомогою SSE4.1 roundpd(або AVX vroundpd). (FP-> цілочисельні перетворення також доступні в упакованому вигляді SIMD, за винятком FP-> 64-бітного цілого числа, для якого потрібен AVX512.)

• std::nearbyint():

  • x86 clang: вказує на один inn з -msse4.1.
  • x86 GCC: вбудовує в одному insn тільки з -msse4.1 -ffast-math, і тільки на GCC 5.4 і вище . Пізніше gcc ніколи не вказує на нього (можливо, вони не усвідомлювали, що один з негайних бітів може придушити неточний виняток? Ось що використовує clang, але старший gcc використовує те саме, що і rintколи він вбудовує його в рядок )
  • AArch64 gcc6.3: вказує за замовчуванням один інн.

• std::rint:

  • x86 clang: вказує на один inn з -msse4.1
  • x86 gcc7: рядки до одного інсн з -msse4.1. (Без SSE4.1 вказується на кілька інструкцій)
  • x86 gcc6.x та новіші версії: вказується на один inn з -ffast-math -msse4.1.
  • AArch64 gcc: за замовчуванням вказується на один inn

• std::round:

  • x86 clang: не вбудований
  • x86 gcc: вказує на кілька інструкцій з -ffast-math -msse4.1, вимагаючи двох векторних констант.
  • AArch64 gcc: вказує на одну інструкцію (підтримка HW для цього режиму округлення, а також IEEE за замовчуванням та більшість інших.)

• std::floor/ std::ceil/std::trunc

  • x86 clang: вказує на один inn з -msse4.1
  • x86 gcc7.x: вказує на один inn з -msse4.1
  • x86 gcc6.x та новіші версії: вказується на один inn з -ffast-math -msse4.1
  • AArch64 gcc: вводиться за замовчуванням до однієї інструкції

Округлення до int/ long/ long long:

Тут у вас є два варіанти: використовувати lrint(наприклад, rintале повертає longабо long longдля llrint), або використовувати функцію округлення FP-> FP, а потім перетворити на цілий тип звичайним способом (з усіченням). Деякі компілятори оптимізують один спосіб краще за інший.

long l = lrint(x);

int  i = (int)rint(x);

Зверніть увагу, що спочатку int i = lrint(x)перетворює floatабо double-> long, а потім обрізає ціле число int. Це має значення для цілих чисел поза діапазоном: Невизначена поведінка в C ++, але чітко визначена для інструкцій x86 FP -> int (яку компілятор видаватиме, якщо він не бачить UB під час компіляції під час постійного поширення, тоді це дозволяється робити код, який порушується, якщо він коли-небудь виконується).

На x86 ціле число перетворення FP->, яке переповнює ціле число, виробляє INT_MINабо LLONG_MIN(бітовий візерунок 0x8000000або 64-бітовий еквівалент, лише з набором бітів знаків). Intel називає це значення "невизначеним числом". (Див на cvttsd2siручне введення , інструкція SSE2 , який перетворює (з обрізанням) скаляр подвійний знакове ціле число. Це є з 32-бітної або 64-розрядний ціле число призначення (тільки в 64-бітному режимі). Там же cvtsd2si(новонавернений з поточним округленням режим), що ми хотіли б, щоб компілятор випускав, але, на жаль, gcc і clang не обійдуться -ffast-math.

Також майте на увазі, що FP до / з unsignedint / long є менш ефективним на x86 (без AVX512). Перетворення на 32-розрядну непідписану на 64-бітній машині досить дешево; просто перетворити на 64-бітні підписані та усічені. Але в іншому випадку це значно повільніше.

• x86 clang з / без -ffast-math -msse4.1: (int/long)rintinlines to roundsd/ cvttsd2si. (пропущена оптимізація до cvtsd2si). lrintзовсім не в рядку.

• x86 gcc6.x і раніше без -ffast-math: жодного способу в рядках

• x86 gcc7 без -ffast-math: (int/long)rintокругляє та конвертує окремо (з 2 загальними інструкціями SSE4.1 включено, інакше з купою коду, позначеного rintбез roundsd). lrintне в рядку.

• x86 gcc з -ffast-math : всі шляхи вбудовані до cvtsd2si(оптимальні) , немає необхідності в SSE4.1.

• AArch64 gcc6.3 без -ffast-math: (int/long)rintдодає до 2 інструкцій. lrintне в рядку

• AArch64 gcc6.3 з -ffast-math: (int/long)rintкомпілюється у виклик до lrint. lrintне в рядку. Це може бути пропущена оптимізація, якщо дві інструкції, які ми отримуємо, не -ffast-mathдуже повільні.

Остерігайся floor(x+0.5). Ось що може статися з непарними числами в діапазоні [2 ^ 52,2 ^ 53]:

-bash-3.2$ cat >test-round.c <<END

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

int main() {
    double x=5000000000000001.0;
    double y=round(x);
    double z=floor(x+0.5);
    printf("      x     =%f\n",x);
    printf("round(x)    =%f\n",y);
    printf("floor(x+0.5)=%f\n",z);
    return 0;
}
END

-bash-3.2$ gcc test-round.c
-bash-3.2$ ./a.out
      x     =5000000000000001.000000
round(x)    =5000000000000001.000000
floor(x+0.5)=5000000000000002.000000

Це http://bugs.squeak.org/view.php?id=7134 . Використовуйте рішення, подібне до рішення @konik.

Моя власна надійна версія була б приблизно такою:

double round(double x)
{
    double truncated,roundedFraction;
    double fraction = modf(x, &truncated);
    modf(2.0*fraction, &roundedFraction);
    return truncated + roundedFraction;
}

Інша причина уникати підлоги (х + 0,5) наведена тут .

Якщо ви в кінцевому підсумку хочете перетворити doubleвисновок своєї round()функції в int, то прийняті рішення цього питання будуть виглядати приблизно так:

int roundint(double r) {
  return (int)((r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5));
}

Це працює на рівні приблизно 8,88 нс на моїй машині, коли передаються в рівномірно випадкових значеннях.

Наведене нижче є функціонально еквівалентним, наскільки я можу сказати, але працює на 2,48 нс на моїй машині, для значної переваги в роботі:

int roundint (double r) {
  int tmp = static_cast<int> (r);
  tmp += (r-tmp>=.5) - (r-tmp<=-.5);
  return tmp;
}

Серед причин кращих показників - пропущене розгалуження.

Не потрібно нічого реалізовувати, тому я не впевнений, чому так багато відповідей передбачає визначення, функції чи методи.

У C99

У нас є наступне і і заголовок <tgmath.h> для макросів типу "generic".

#include <math.h>
double round (double x);
float roundf (float x);
long double roundl (long double x);

Якщо ви не можете скласти це, ви, мабуть, залишили математичну бібліотеку. Команда, подібна до цієї, працює на кожному компіляторі C, який у мене є (кілька).

gcc -lm -std=c99 ...

В С ++ 11

У нас є наступні та додаткові перевантаження в #include <cmath>, які покладаються на плаваючу точку подвійної точності IEEE.

#include <math.h>
double round (double x);
float round (float x);
long double round (long double x);
double round (T x);

І в просторі імен std є еквіваленти .

Якщо ви не можете скласти це, ви можете використовувати компіляцію C замість C ++. Наступна основна команда не створює ані помилок, ані попереджень із g ++ 6.3.1, x86_64-w64-mingw32-g ++ 6.3.0, clang-x86_64 ++ 3.8.0 та Visual C ++ 2015 Community.

g++ -std=c++11 -Wall

З ординальним відділом

При поділі двох порядкових чисел, де T короткий, int, довгий або інший порядковий, вираз округлення такий.

T roundedQuotient = (2 * integerNumerator + 1)
    / (2 * integerDenominator);

Точність

Немає сумнівів, що незвичайні неточності виявляються в операціях з плаваючою комою, але це лише тоді, коли з’являються числа, і мало спільного з округленням.

Джерело - це не просто кількість значущих цифр у мантісі представлення IEEE числа з плаваючою комою, воно пов'язане з нашим десятковим мисленням як люди.

Десять - це п’ять і два, а 5 і 2 - відносно прості. Отже стандарти IEEE з плаваючою комою неможливо представляти ідеально як десяткові числа для всіх двійкових цифрових зображень.

Це не проблема з алгоритмами округлення. Саме математичну реальність слід враховувати під час вибору типів та проектування обчислень, введення даних та відображення чисел. Якщо програма відображає цифри, які відображають ці десятково-двійкові проблеми перетворення, то програма візуально виражає точність, яка не існує в цифровій реальності і повинна бути змінена.

Функція double round(double)з використанням modfфункції:

double round(double x)
{
    using namespace std;

    if ((numeric_limits<double>::max() - 0.5) <= x)
        return numeric_limits<double>::max();

    if ((-1*std::numeric_limits<double>::max() + 0.5) > x)
        return (-1*std::numeric_limits<double>::max());

    double intpart;
    double fractpart = modf(x, &intpart);

    if (fractpart >= 0.5)
        return (intpart + 1);
    else if (fractpart >= -0.5)
        return intpart;
    else
        return (intpart - 1);
    }

Щоб скласти чисто, потрібно "math.h" та "limit". Функція працює за такою схемою округлення:

• раунд 5,0 - 5,0
• раунд 3,8 - 4,0
• раунд 2,3 - 2,0
• раунд 1,5 - 2,0
• раунд 0,550 - 1,0
• раунд 0,5 - 1,0
• раунд 0,499 - 0,0
• раунд 0,01 - 0,0
• раунд 0,0 - 0,0
• раунд -0,01 становить -0,0
• раунд -0,499 становить -0,0
• раунд -0,5 становить -0,0
• раунд -0,501 є -1,0
• раунд -1,5 становить -1,0
• раунд -2,3 становить -2,0
• раунд -3,8 становить -4,0
• раунд -5,0 становить -5,0

Якщо вам потрібно мати змогу компілювати код у середовищах, які підтримують стандарт C ++ 11, але також потрібно вміти компілювати той самий код у середовищах, які не підтримують його, ви можете використовувати макрос функції для вибору між std :: round () та спеціальна функція для кожної системи. Просто перейдіть -DCPP11або /DCPP11до компілятора, сумісного з C ++ 11 (або використовуйте його вбудовану версію макросів) та зробіть такий заголовок:

// File: rounding.h
#include <cmath>

#ifdef CPP11
    #define ROUND(x) std::round(x)
#else    /* CPP11 */
    inline double myRound(double x) {
        return (x >= 0.0 ? std::floor(x + 0.5) : std::ceil(x - 0.5));
    }

    #define ROUND(x) myRound(x)
#endif   /* CPP11 */

Короткий приклад див. На сайті http://ideone.com/zal709 .

Це приблизний показник std :: round () в середовищах, які не відповідають C ++ 11, включаючи збереження біта знаків для -0.0. Однак це може спричинити незначний удар в продуктивності, і, ймовірно, виникнуть проблеми із округленням певних відомих «проблемних» значень з плаваючою комою, таких як 0,49999999999999994 або подібних значень.

Крім того, якщо у вас є доступ до компілятора, сумісного з C ++ 11, ви можете просто захопити std :: round () зі свого <cmath>заголовка і використовувати його для створення власного заголовка, який визначає функцію, якщо вона ще не визначена. Зауважте, що це може бути не оптимальним рішенням, особливо якщо вам потрібно компілювати для декількох платформ.

На основі відповіді Калаксі подано шаблонне рішення, яке округляє будь-який номер плаваючої точки до найближчого цілого типу на основі природного округлення. Він також видає помилку в режимі налагодження, якщо значення виходить за межі цілого типу, тим самим виконуючи функцію життєздатної бібліотеки.

    // round a floating point number to the nearest integer
    template <typename Arg>
    int Round(Arg arg)
    {
#ifndef NDEBUG
        // check that the argument can be rounded given the return type:
        if (
            (Arg)std::numeric_limits<int>::max() < arg + (Arg) 0.5) ||
            (Arg)std::numeric_limits<int>::lowest() > arg - (Arg) 0.5)
            )
        {
            throw std::overflow_error("out of bounds");
        }
#endif

        return (arg > (Arg) 0.0) ? (int)(r + (Arg) 0.5) : (int)(r - (Arg) 0.5);
    }

Як зазначалося в коментарях та інших відповідях, стандартна бібліотека ISO C ++ не була додана round()до ISO C ++ 11, коли цю функцію було застосовано посиланням на стандартну математичну бібліотеку ISO C99.

Для позитивних операндів у [½, ub ] round(x) == floor (x + 0.5), де ub - 2 ²³ для, floatколи їх відображено в IEEE-754 (2008) binary32, і 2 ⁵² для, doubleколи він відображається в IEEE-754 (2008) binary64. Числа 23 і 52 відповідають кількості збережених бітів мантіси в цих двох форматах з плаваючою комою. Для позитивних операндів у [+0, ½) round(x) == 0, а для позитивних операндів у ( ub , + ∞] round(x) == x. Оскільки функція симетрична щодо осі x, негативні аргументи xможна обробляти відповідно до round(-x) == -round(x).

Це призводить до компактного коду нижче. Він збирає в розумну кількість інструкцій на машинах на різних платформах. Я спостерігав найбільш компактний код на графічних процесорах, де my_roundf()потрібно близько десятка інструкцій. Залежно від архітектури процесора та ланцюжка інструментів, цей підхід з плаваючою комою може бути або швидшим, або повільнішим, ніж реалізація на основі цілої чисельності з newlib, на яку посилається інша відповідь .

Я my_roundf()вичерпно перевірив roundf()реалізацію newlib, використовуючи компілятор Intel версії 13, з обома /fp:strictі /fp:fast. Я також перевірив, чи відповідає версія newlib roundf()у mathimfбібліотеці компілятора Intel. Вичерпне тестування неможливо для подвійної точності round(), однак код структурно ідентичний реалізації з одноточною реалізацією.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <math.h>

float my_roundf (float x)
{
    const float half = 0.5f;
    const float one = 2 * half;
    const float lbound = half;
    const float ubound = 1L << 23;
    float a, f, r, s, t;
    s = (x < 0) ? (-one) : one;
    a = x * s;
    t = (a < lbound) ? x : s;
    f = (a < lbound) ? 0 : floorf (a + half);
    r = (a > ubound) ? x : (t * f);
    return r;
}

double my_round (double x)
{
    const double half = 0.5;
    const double one = 2 * half;
    const double lbound = half;
    const double ubound = 1ULL << 52;
    double a, f, r, s, t;
    s = (x < 0) ? (-one) : one;
    a = x * s;
    t = (a < lbound) ? x : s;
    f = (a < lbound) ? 0 : floor (a + half);
    r = (a > ubound) ? x : (t * f);
    return r;
}

uint32_t float_as_uint (float a)
{
    uint32_t r;
    memcpy (&r, &a, sizeof(r));
    return r;
}

float uint_as_float (uint32_t a)
{
    float r;
    memcpy (&r, &a, sizeof(r));
    return r;
}

float newlib_roundf (float x)
{
    uint32_t w;
    int exponent_less_127;

    w = float_as_uint(x);
    /* Extract exponent field. */
    exponent_less_127 = (int)((w & 0x7f800000) >> 23) - 127;
    if (exponent_less_127 < 23) {
        if (exponent_less_127 < 0) {
            /* Extract sign bit. */
            w &= 0x80000000;
            if (exponent_less_127 == -1) {
                /* Result is +1.0 or -1.0. */
                w |= ((uint32_t)127 << 23);
            }
        } else {
            uint32_t exponent_mask = 0x007fffff >> exponent_less_127;
            if ((w & exponent_mask) == 0) {
                /* x has an integral value. */
                return x;
            }
            w += 0x00400000 >> exponent_less_127;
            w &= ~exponent_mask;
        }
    } else {
        if (exponent_less_127 == 128) {
            /* x is NaN or infinite so raise FE_INVALID by adding */
            return x + x;
        } else {
            return x;
        }
    }
    x = uint_as_float (w);
    return x;
}

int main (void)
{
    uint32_t argi, resi, refi;
    float arg, res, ref;

    argi = 0;
    do {
        arg = uint_as_float (argi);
        ref = newlib_roundf (arg);
        res = my_roundf (arg);
        resi = float_as_uint (res);
        refi = float_as_uint (ref);
        if (resi != refi) { // check for identical bit pattern
            printf ("!!!! arg=%08x  res=%08x  ref=%08x\n", argi, resi, refi);
            return EXIT_FAILURE;
        }
        argi++;
    } while (argi);
    return EXIT_SUCCESS;
}

Я використовую таку реалізацію раунда в ASM для архітектури x86 та специфічного для MS VS C ++:

__forceinline int Round(const double v)
{
    int r;
    __asm
    {
        FLD     v
        FISTP   r
        FWAIT
    };
    return r;
}

UPD: для повернення подвійного значення

__forceinline double dround(const double v)
{
    double r;
    __asm
    {
        FLD     v
        FRNDINT
        FSTP    r
        FWAIT
    };
    return r;
}

Вихід:

dround(0.1): 0.000000000000000
dround(-0.1): -0.000000000000000
dround(0.9): 1.000000000000000
dround(-0.9): -1.000000000000000
dround(1.1): 1.000000000000000
dround(-1.1): -1.000000000000000
dround(0.49999999999999994): 0.000000000000000
dround(-0.49999999999999994): -0.000000000000000
dround(0.5): 0.000000000000000
dround(-0.5): -0.000000000000000

Найкращий спосіб округлення плаваючого значення на "n" десяткових знаків - це такий, як в O (1) час: -

Ми повинні округлювати значення на 3 місця, тобто n = 3. Отже,

float a=47.8732355;
printf("%.3f",a);

// Convert the float to a string
// We might use stringstream, but it looks like it truncates the float to only
//5 decimal points (maybe that's what you want anyway =P)

float MyFloat = 5.11133333311111333;
float NewConvertedFloat = 0.0;
string FirstString = " ";
string SecondString = " ";
stringstream ss (stringstream::in | stringstream::out);
ss << MyFloat;
FirstString = ss.str();

// Take out how ever many decimal places you want
// (this is a string it includes the point)
SecondString = FirstString.substr(0,5);
//whatever precision decimal place you want

// Convert it back to a float
stringstream(SecondString) >> NewConvertedFloat;
cout << NewConvertedFloat;
system("pause");

Це може бути неефективним брудним способом конвертації, але чорт, це працює хаха. І це добре, адже це стосується фактичного поплавця. Не лише візуально впливає на вихід.

Я зробив це:

#include <cmath.h>

using namespace std;

double roundh(double number, int place){

    /* place = decimal point. Putting in 0 will make it round to whole
                              number. putting in 1 will round to the
                              tenths digit.
    */

    number *= 10^place;
    int istack = (int)floor(number);
    int out = number-istack;
    if (out < 0.5){
        floor(number);
        number /= 10^place;
        return number;
    }
    if (out > 0.4) {
        ceil(number);
        number /= 10^place;
        return number;
    }
}