web-dev-qa-db-fra.com

Toujours arrondir un double

Comment pourrais-je toujours arrondir une double à une int, et ne jamais l'arrondir vers le bas ... je sais Math.round(double), mais je veux qu'il soit toujours arrondi .. Donc si c'était 3.2, il est arrondi à 4.

javarounding
24
sparklyllama

Vous pouvez utiliser la méthode Math.ceil().

Voir le lien JavaDoc: https://docs.Oracle.com/javase/10/docs/api/Java/lang/Math.html#ceil(double)

De la docs:

ceil

public static double ceil(double a)

Renvoie la plus petite valeur double (la plus proche de l'infini négatif) supérieure ou égale à l'argument et égale à un entier mathématique. Cas spéciaux:

  • Si la valeur de l'argument est déjà égale à un entier mathématique, le résultat est identique à l'argument.
  • Si l'argument est NaN ou un infini ou un zéro positif ou un zéro négatif, le résultat est identique à l'argument.
  • Si la valeur de l'argument est inférieure à zéro mais supérieure à -1.0, le résultat est négatif.

Notez que la valeur de Math.ceil (x) est exactement la valeur de -Math.floor (-x).

Paramètres:

  • a - une valeur.

Résultats:

La plus petite valeur en virgule flottante (la plus proche de l'infini négatif) supérieure ou égale à l'argument et égale à un entier mathématique.

35
tabz100

En des mots simples, 

  • Math.ceil sera toujours arrondi UP ou comme indiqué ci-dessus, en excès. 
  • Math.round arrondira de haut en bas en fonction des décimales .
    • Si la décimale est égale ou supérieure à 5, il s'agit de arrondi.
      • décimal => 5. (1,5 = 2)
    • Si la décimale est moins de 5, alors arrondi.
      • décimal <5. (1,45 = 1)

Exemples de Math.ceil et Math.round: 

Le code ci-dessous renverrait:
Coût, sans Ceil 2.2 et avec Ceil 3 (int), 3.0 (double). Si on l'arrondit: 2

    int m2 = 2200;
    double rate = 1000.0;

    int costceil = (int)Math.ceil(m2/rate);
    double costdouble = m2/rate;
    double costdoubleceil = Math.ceil(m2/rate);
    int costrounded = (int)Math.round(m2/rate);
    System.out.println("Cost, without Ceil "+costdouble+" and with Ceil "+
            costceil+"(int), "+costdoubleceil+"(double). If we round it: "+costrounded);

Si nous modifions la valeur de m2 par exemple 2499, le résultat serait: Coût, sans Ceil 2,499 et avec Ceil 3 (int), 3,0 (double). Si on l'arrondit: 2
Si nous remplaçons m2 par exemple par 2550, le résultat serait:
Coût, sans Ceil 2,55 et avec Ceil 3 (int), 3,0 (double). Si on l'arrondit: 3

J'espère que ça aide. (Informations extraites des réponses précédentes, je voulais juste que ce soit plus clair).

8
maral04

Ma méthode est relativement simple, espérons que cela fonctionne pour vous.

Dans mon cas, j'ai une rangée d'objets qui ne peuvent contenir que 3 éléments et je dois ajuster le nombre de lignes dont je dispose pour accueillir les éléments.

Donc, j'ai un certain nombre numberOfRows, j'utilise ensuite numberOfRows.intValue () pour obtenir une valeur int pour numberOfRows.

si la valeur int que je reçois est inférieure à numberOfRows, j'ajoute 1 à numberOfRows pour l'arrondir, sinon la valeur que je récupère de numberOfRows.intValue () est la réponse que je veux.

J'ai écrit cette simple boucle pour le tester:

    for(int numberOfItems = 0; numberOfItems < 16; numberOfItems++) {
        Double numberOfRows = numberOfItems / 3.0;

        System.out.println("Number of rows are: " + numberOfRows);
        System.out.println("Number of items are: " + numberOfItems);
        if(numberOfRows.intValue() < numberOfRows) {
            System.out.println("int number of rows are: " + (numberOfRows.intValue() + 1));
        }
        else {
            System.out.println("int value of rows are: " + numberOfRows.intValue());
        }
        System.out.println();
        System.out.println();
    }
0
Tunji_D
private int roundUP(double d){
    double dAbs = Math.abs(d);
    int i = (int) dAbs;
    double result = dAbs - (double) i;
    if(result==0.0){ 
        return (int) d;
    }else{
        return (int) d<0 ? -(i+1) : i+1;          
    }
}

Bon travail ! ;)

0
Lostkiefer

tl; dr

BigDecimal( "3.2" ).setScale( 0 , RoundingMode.CEILING )

4

BigDecimal

Si vous voulez précision plutôt que performance , évitez virgule flottante technologie. Cela signifie éviter float, Float, double, Double. Pour plus de précision, utilisez BigDecimal class.

Sur BigDecimal, définissez l'échelle , le nombre de chiffres à droite de la décimale. Si vous ne voulez pas de fraction décimale, définissez l'échelle sur zéro. Et spécifiez un mode d'arrondi . Pour toujours arrondir une fraction vers le haut, utilisez RoundingMode.CEILING , documenté comme suit:

Mode d'arrondi pour arrondir vers l'infini positif. Si le résultat est positif, se comporte comme pour RoundingMode.UP; si négatif, se comporte comme pour RoundingMode.DOWN. Notez que ce mode d'arrondi ne diminue jamais la valeur calculée. Ainsi, par exemple, 1.1 devient 2 et votre 3.2 devient 4. 

BigDecimal bd = new BigDecimal( "3.2" ) ;
BigDecimal bdRounded = bd.setScale( 0 , RoundingMode.CEILING ) ;
String output = bdRounded.toString() ; 
System.out.println( "bdRounded.toString(): " + bdRounded ) ;  // 4

4

Voir ce code exécuté en direct sur IdeOne.com .

0
Basil Bourque

Petit exemple sans utiliser Math.ceil ().

public double roundUp(double d){
    return d > (int)d ? (int)d + 1 : d;
}

Exaplanation: Comparez l'opérande arrondi à l'opérande arrondi à l'aide de la conversion de type, si le retour est plus grand, argument arrondi à la baisse + 1 (signifie arrondi supérieur), sinon opérande inchangé.

Exemple en pseudocode 

double x = 3.01
int roundDown = (int)x   // roundDown = 3
if(x > roundDown)        // 3.01 > 3
    return roundDown + 1 // return 3.0 + 1.0 = 4.0
else
    return x             // x equals roundDown

Quoi qu'il en soit, vous devriez utiliser Math.ceil(). Ceci est seulement censé être un exemple simple de la façon dont vous pourriez le faire vous-même.

0
trinity420