Modo conciso per implementare round() in C?

Question

La C incorporata che sto usando non ha una funzione round() è matematica lib, quale sarebbe un modo conciso per implementarlo in C? Stavo pensando di stamparlo su una stringa, cercando la posizione decimale, quindi trovando il primo carattere dopo il periodo, quindi arrotondando se> = 5, altrimenti verso il basso. ecc. Stava chiedendo se c'è qualcosa di più intelligente.

Grazie, Fred

Answer 1

Si potrebbe reinventare la ruota, come suggeriscono molte altre risposte.In alternativa, potresti utilizzare la ruota di un'altra persona: suggerirei Newlib, che è concesso in licenza BSD e destinato all'uso su sistemi embedded. Gestisce correttamente numeri negativi, NaN, infiniti e casi che non sono rappresentabili come numeri interi (perché troppo grandi), così come lo fanno in modo efficiente che utilizza esponenti e mascheramento piuttosto che operazioni a virgola mobile generalmente più costose. Inoltre, è regolarmente collaudato, quindi sai che non ha bug in agguato.

La Newlib sorgente può essere un po 'imbarazzante per navigare, ecco sono i bit che si desidera:

versione galleggiante: https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob;f=newlib/libm/common/sf_round.c;hb=master

Doppia versione: https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob;f=newlib/libm/common/s_round.c;hb=master

macro Word-estrazione definita qui: https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob;f=newlib/libm/common/fdlibm.h;hb=master

Se sono necessari altri file da lì, il genitore di rectory è questa: https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=tree;f=newlib/libm/common;hb=master

Per la registrazione, ecco il codice per la versione flottante. Come puoi vedere, c'è un po 'di complessità necessaria per gestire correttamente tutti i casi possibili.

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; 
} 

Answer 2

Nei giorni antichi, quando arrotondamento non è stato ben definito tra i sistemi, abbiamo scritto una funzione di arrotondamento in scala che prima moltiplicato il numero in modo che l'arrotondamento è stato fatto da troncare il numero.
Per arrotondare a 2 posizioni decimali, moltiplicare per 100, aggiungere 0,5, troncare i risultati e dividere per 100.
Ecco come è stato fatto per le macchine utensili a controllo numerico quando i controlli non potevano eseguire un programma NC a meno che non era azzeccato.

Answer 3

int round(float x) 
{ 
    return (int)(x + 0.5); 
} 

Caveat: Funziona solo su numeri positivi.

Answer 4

Un modo utilizzando un'operazione stringa

float var=1.2345; 
char tmp[12]={0x0}; 
sprintf(tmp, "%.2f", var); 
var=atof(tmp); 

Un altro modo mediante operazioni numeriche

float var=1.2345; 
int i=0; 
var*=100; 
i=var; 
var=i; 
var/=100; 

Answer 5

int round(double x) 
{ 
    if (x < 0.0) 
     return (int)(x - 0.5); 
    else 
     return (int)(x + 0.5); 
} 

Answer 6

IEEE 754 consiglia la "metà intorno a addirittura" approccio: se la parte frazionaria di d è 0,5 quindi arrotondato al numero intero pari più vicino. Il problema è che l'arrotondamento di una parte frazionaria di 0,5 nella stessa direzione introduce bias nei risultati; quindi, devi arrotondare lo 0,5 frazionario per metà tempo e metà del tempo, quindi il bit "arrotondato al più vicino pari", arrotondando alla cifra più vicina funzionerebbe anche come farebbe una moneta equa per determinare quale strada partire.

penso che qualcosa di più simile a questo sarebbe IEEE-corretto:

#include <math.h> 

int is_even(double d) { 
    double int_part; 
    modf(d/2.0, &int_part); 
    return 2.0 * int_part == d; 
} 

double round_ieee_754(double d) { 
    double i = floor(d); 
    d -= i; 
    if(d < 0.5) 
     return i; 
    if(d > 0.5) 
     return i + 1.0; 
    if(is_even(i)) 
     return i; 
    return i + 1.0; 
} 

E questo dovrebbe essere C99-ish (che sembra indicare che i numeri con parti frazionarie di 0.5 devono essere arrotondati per eccesso) :

#include <math.h> 
double round_c99(double x) { 
    return (x >= 0.0) ? floor(x + 0.5) : ceil(x - 0.5); 
} 

e una versione più compatta del mio primo round_c99(), questo gestisce attraversando il confine 56bit mantissa meglio non basandosi su x+0.5 o x-0.5 essendo cose sensibili da fare:

#include <math.h> 
double round_c99(double d) { 
    double int_part, frac_part; 
    frac_part = modf(d, &int_part); 
    if(fabs(frac_part) < 0.5) 
     return int_part; 
    return int_part > 0.0 ? int_part + 1.0 : int_part - 1.0; 
} 

Ciò avrà problemi se |int_part| >> 1 ma arrotonda una doppia con un grande esponente è inutile. Sono sicuro che ci siano anche NaN in tutte e tre le cose, ma il mio masochismo ha dei limiti e la programmazione numerica non è davvero la mia cosa.

Il calcolo a virgola mobile ha un ampio margine per errori impercettibili, pertanto conciso potrebbe non essere il requisito migliore.

Una soluzione ancora migliore sarebbe quella di battere il venditore del compilatore all'incirca sul viso e sul collo finché non forniscono una libreria matematica corretta.

Answer 7

Puoi usare intero? effettuare le seguenti operazioni:

int roundup(int m, int n) 
{ 
return (m + n - 1)/n ; 
} 

int rounddown(int m, int n) 
{ 
return m/n; 
} 

int round(int m, int n) 
{ 
    int mod = m % n; 

    if(mod >= (n + 1)/2) 
     return roundup(m, n); 
    else 
     return rounddown(m, n); 
}