Comment faire pour arrondir des nombres à virgule flottante à l'entier le plus proche en C?

Est-il un moyen pour arrondir des nombres à C?

Je ne veux pas utiliser plafond et le plancher. Est-il une autre alternative?

Je suis tombé sur cet extrait de code lorsque j'ai Googlé pour la réponse:

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

La ligne ci-dessus permet d'imprimer la valeur 4, même lorsque le flotteur num =4.9.

Il ya beaucoup de différents types de l'arrondissement dont l'une(s) voulez-vous utiliser? S'il vous plaît poster des exemples de comportement souhaité.
Je pense que le problème est ailleurs, il conviendrait sans doute d'impression 5 pour l'entrée de 4.9.
Oui, la conversion d'un type à virgule flottante d'un type entier, qui peut représenter un nombre nécessaires de ce paramètre et de l'ampleur devrait fonctionner simplement en tronquant les décimales, ce code ne l' ±0,5 à cause de cette troncature à tour la valeur d'origine à l'écart à partir de zéro.
Besoins homework tag ?
Quel est le problème avec ceil et floor? Aussi, voir stackoverflow.com/questions/485525/round-for-float-in-c.
voir stackoverflow.com/questions/2205211/... sauf pour remplacer static_cast<int> avec (int)
La ligne ci-dessus n'a pas d'imprimer quoi que ce soit. Il n'y a rien dans cette ligne que peut faire aucune impression. Montrez-nous comment vous imprimer des choses. Le problème est sans doute là.
Sous-ensemble: spécifique pour la division entière: stackoverflow.com/questions/2422712/... | C++ stackoverflow.com/questions/485525/round-for-float-in-c

InformationsquelleAutor webgenius | 2010-04-03

c rounding

9

De 4,9 + 0,5 est 5.4, qui ne peut pas rond à 4, sauf si votre compilateur est brisé.

Je vient de confirmer que le Googlé code donne la bonne réponse pour 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:~$
```
- Hmmm....Vous avez raison....La déclaration peut encore être simplifiée comme suit: int n = (num < 0) ? (num - 0.5) : (num + 0.5); j'ai vérifié et ça marche impeccable. Pouvez-vous expliquer comment l' (num<0) comparaison fonctionne? J'ai inséré un point d'arrêt dans mon IDE et vu que la condition de vérifier (num<0) renvoie toujours FALSE, ce qui doit s'exécuter (num + 0.5) toujours
- Pas sûr de ce que vous demandez, mais une expression a ? b : c évalue à b si a est vrai et à c autrement. Dans ce cas, l'idée est de déplacer la valeur de num à l'écart à partir de zéro par 0.5 avant la conversion de int en tronquant les décimales. De cette façon, la troncature rond le plus proche int (par exemple 0.5 + 0.5 = 1.0 et 0,99 + 0.5 = 1.49 deux tronquée à 1).
- Mais pourquoi est - (num<0) comparaison fait? num sera toujours 4.9
- La comparaison est faite parce que l'instruction est pour un cas d'utilisation (où num pourrait être positif ou négatif), pas pour le cas spécifique de son programme d'exemple. Si le but de la question était: "comment faites-vous faire un tour de 4,9 à 5?" alors qu'on pourrait juste mettre float num = 5.0 et être fait avec elle.
- Ce produit 4 avec ./gcc-frip-tissu de l'espace-temps. Il y a un plugin pour emacs qui transforme ce sur par défaut.
- Cette méthode échoue lorsque num est en dehors de la plage de int 2), Il allait échouer pour de nombreuses autres float sauf qu'il utilise double mathématiques. par exemple, (int)(num < 0 ? (num - 0.5f) : (num + 0.5f)) a beaucoup de défaut des valeurs lors de l' num + 0.5f tours pour une float résultat.
- quand il est à l'extérieur de int gamme, float ne peut pas distinguer entre les nombres entiers et les fractions de toute façon. Avec double, vous pouvez lancer à int64_t.
- Vous comment peut s'appliquer sur certaines plates-formes, mais pas en C en général. Considérer les 16 bits int. Assez commun dans incorporé prédécesseurs en 2016.
- bien sûr, mais je suppose que les personnes travaillant sur bizarre matériel sont déjà assez conscient pour comprendre cela pour eux-mêmes.
- Processeurs embarqués déploiement en 2016 dépassent de loin les autres plates-formes - des Milliards par ans. D'être si commun est peu bizarre. C est très populaire là-bas et beaucoup dans ce domaine ont de la difficulté en raison des hypothèses comme l' int 32-bits.
- ensuite, utilisez int32_t.
- Oui code pourrait utiliser int32_t. OP code est bien sur int, pas int32_t et amis. D'où mes commentaires concernant int et une limitation (int)(num < 0 ? (num - 0.5) : (num + 0.5));.
- uhuh.
InformationsquelleAutor Marcelo Cantos
3

Une solution générale est d'utiliser rint() et définir la FLT_ROUNDS mode d'arrondi selon le cas.

InformationsquelleAutor Dan Story
3

Je ne suis pas sûr que ce soit une bonne idée. Ce code dépend de jette, et je suis assez sûr que la troncature n'est pas défini.
```
float result = (num - floor(num) > 0.5) ? ceil(num) : floor(num);
```
Je dirais que c'est beaucoup mieux (ce qui est essentiellement ce Shiroko posté), car il ne dépend pas de les plâtres.

InformationsquelleAutor Puppy
3

Pour arrondir un float en C, il y a 3 <math.h> fonctions pour répondre à ce besoin. Recommander rintf().
```
float nearbyintf(float x);
```
La nearbyint fonctions arrondissent leurs argument un entier de valeur en virgule flottante au format, à l'aide de l'actuelle direction de l'arrondissement et sans élever la ‘inexact’ floating point exception. C11dr §7.12.9.3 2

ou
```
float rintf(float x);
```
La rint fonctions diffèrent de la nearbyint fonctions (7.12.9.3) en ce que les rint fonctions peuvent augmenter le ‘inexact’ exception de virgule flottante si le résultat diffère de la valeur de l'argument. C11dr §7.12.9.4 2

ou
```
float roundf(float x);
```
La round fonctions ronde leur argument à l'entier le plus proche de la valeur en virgule flottante format, arrondi à mi-chemin des cas, loin de zéro, quelle que soit la direction de l'arrondissement. C11dr §7.12.9.6 2

Exemple
```
#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;
}
```
Sortie
```
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
```
Ce qui est faible sur les OP de code?
```
(int)(num < 0 ? (num - 0.5) : (num + 0.5))
```
1. Devrait num ont pas une valeur proche de la int gamme, le casting (int) résultats dans un comportement indéfini.
2. Quand num +/- 0.5 résultats dans une réponse inexacte. Il est peu probable ici que 0.5 est un double causant le plus de se produire à un degré de précision plus élevé que float. Lorsque num et 0.5 ont la même précision, ajoutant 0.5 à un nombre peut entraîner numérique arrondie réponse. (Ce n'est pas le nombre entier arrondi de l'OP post.) Exemple: le nombre juste moins de 0,5 doit arrondir à 0 par l'OP de l'objectif, encore num + 0.5 résultats dans une réponse exacte entre la 1.0 et la plus petite double un peu moins de 1,0. Depuis la réponse exacte n'est pas représentable, que la somme des tours, généralement à 1,0 conduisant à une réponse incorrecte. Une situation similaire se produit avec les grands nombres.
OP dilemme qui se pose à propos de "La ligne ci-dessus permet d'imprimer la valeur 4, même lorsque float num =4.9." n'est pas explicable comme indiqué. Code supplémentaire/information est nécessaire. Je soupçonne OP peut-être utilisé 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
}
```
Testé peu le faire plus tard quand j'ai le temps.
- Serait aussi cool d'avoir des exemples de définition de l'actuel arrondissement de direction et les imprécisions de drapeau.
- Exemple ajouté.
InformationsquelleAutor chux
1

Je pense que ce que vous cherchez est:
int n = (d - floor(d) > 0.5) ? ceil(d) : floor(d);
- "Je ne veux pas utiliser de plafond et de plancher" ...
- Si l'interlocuteur réellement ne voulez pas utiliser de plafond et le plancher, mais il est vraiment heureux de l'appel à la conversion en int, alors la question peut être déposée en vertu de l' "bizarre interview de style de questions qui impliquent une restriction artificielle pour illustrer un certain point pleinement compris que par l'enquêteur". Malheureusement, cela ne correspond pas à une balise.
- Steve, vous avez raison. C'est une question souvent posée dans les entretiens.
InformationsquelleAutor Shiroko
1

la googlé code fonctionne correctement. L'idée derrière cela est que vous arrondissez vers le bas lorsque la décimale est inférieure à 5 et arrondir le contraire. (int) jette le float en int type qui tombe de la virgule. Si vous ajoutez .5 positif num, vous obtenez la baisse de la prochaine int. Si vous soustrayez .5 partir d'un négatif, il fait la même chose.

InformationsquelleAutor datdo
0

Vous pouvez être en mesure d'utiliser fesetround() dans fenv.h (introduit en C99). Les arguments possibles sont les macros FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO, et FE_UPWARD mais notez que tous ne sont pas nécessairement définies uniquement ceux pris en charge par la plate-forme/mise en œuvre sont. Ensuite, vous pouvez utiliser les différents round, rint et nearbyint fonctions dans math.h (également C99). De cette façon, vous pouvez définir l'arrondissement de comportement une fois et d'appeler la même fonction, indépendamment de savoir si ou non la valeur est positive ou négative.

(Avec, par exemple, lround d'habitude vous n'avez même pas besoin de définir la direction de l'arrondissement pour l'utilisation normale de l'habitude d'obtenir ce que vous voulez.)

InformationsquelleAutor Arkku
0
```
int round(double x)
{
return x >= 0.0 ? int(x + 0.5) : int(x - int(x-1) + 0.5) + int(x-1);
}
```
Il sera plus rapide qu'une version avec plafond et plancher.
- Pas une C une solution. int(x + 0.5) est invalide C. Algorithme échoue pour x just less than 0.5, x` est pas près de int gamme.
InformationsquelleAutor Ekimov Alexander
0

Ronde de la valeur x à la précision p, avec 0 < p < infini. (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;
}
```
- Ce que vous avez posté n'est pas compilé en C - le langage de ce post est balisé. Peut-être vous êtes le codage par une autre langue?
- De plus, en C++, en utilisant int(...) échoue devrait x*(...) dépasser la gamme de int.
- C'est Arduino C/C++, désolé si ce n'est pas "réel" C. Il que int(float x) renvoie juste entier (décapage décimales loin). Quelle est la "bonne" façon de bande de seulement décimales loin?
- La "bonne" façon de bande de décimales à l'écart à partir d'un float est tuncf(x).
- tuncf(x)?!? Tu veux sans doute dire trunc(x)...
- double trunc(double x) est pour double. Utilisation float truncf(float x); pour float(). Il peut être mathématiquement gaspillage d'utiliser le retour d'un float() à l'aide de float x; return double trunc(x).
InformationsquelleAutor JJussi
0

juste ajouter 0,5 pour le nombre et le transtypage il..
et de l'imprimer par type de moulage en entier..
sinon, vous pouvez aller avec round() à l'intérieur qui vient de passer l'argument que le nombre respectif.

InformationsquelleAutor ravi kumar sharma
-4

Essayez de déplacer les crochets sur votre solution ci-dessus, afin qu'il se lise:
```
(int)(num < 0) ? (num - 0.5) : (num + 0.5)
```
À l'aide de num comme 4.9 elle arrondit à 5 sur ma machine.
- Cela n'a aucun effet autre que peut-être soulever un avertissement lorsque vous affectez cette expression de type int. Aussi, le (int) cast est redondant, car num < 0 déjà a type int.
- Que voulez-vous dire c'est ne peut pas travailler. C'est la même que la réponse qui a 4 voix.
- Je n'ai pas dit qu'il ne peut pas possible, j'ai dit qu'il n'a pas d'effet, par lequel je voulais dire que la suppression des parenthèses, comme vous l'avez fait ne change rien.
- Pire que ça, en enlevant les crochets vous avez changé le type. L'expression d'origine avaient de type int, le vôtre est de type float.
InformationsquelleAutor Ali Lown

Vous devez vous connecter pour publier un commentaire.