Pourquoi diviser un flottant par un entier renvoie 0.0? - java, math, division, division en nombres entiers

Donc, si j'ai une gamme de chiffres "0 - 1024" et jeveulent les amener dans "0 - 255", les calculs dicteraient pour diviser l'entrée par le maximum que l'entrée sera (1024 dans ce cas) qui me donnera un nombre entre 0.0 - 1.0. puis multipliez cela par la plage de destination, (255).

C'est ce que je veux faire!

Mais pour une raison quelconque en Java (en utilisant Processing), il retournera toujours une valeur de 0.

Le code serait aussi simple que cela

float scale;
scale = (n/1024) * 255;

Mais j'ai juste 0.0. J'ai "essayé le double et l'intégralité en vain. POURQUOI !?

Réponses:

69 pour la réponse № 1

C'est parce que vous faites la division entière.

Diviser par un double ou un float, et cela fonctionnera:

double scale = ( n / 1024.0 ) * 255 ;

Ou, si vous le voulez comme un flotteur,

float scale = ( n / 1024.0f ) * 255 ;

19 pour la réponse № 2

n / 1024 est division entière, ce qui donne un entier (c'est-à-dire 0 dans ce cas).

Utilisation n / 1024.0 au lieu.


7 pour la réponse № 3

je suppose n est un int. Parce que les constantes 1024 et 255 sont les deux ints tous les calculs de droite sont effectués avec l'arithmétique entière. Ce qui signifie le résultat de n/1024 est tronqué à une valeur intégrale avant d'être multiplié par 255.

N'importe laquelle de ces modifications fera que les calculs fonctionnent correctement:

scale = n / 1024.0 * 255.0;       // Use double constants.
scale = (double) n / 1024 * 255;  // Convert n to a double.
scale = n * 255 / 1024;           // Multiply before dividing.

Le dernier utilise des mathématiques entières maisSi vous changez l'ordre des opérations, vous n'obtiendrez pas la troncature non désirée à 0. Cependant, vous n'obtiendrez toujours que des réponses entières, vous perdrez donc tout point décimal dans les réponses.


2 pour la réponse № 4

Vous devez n auto-cast flotter au moyen d'une multiplication FIRST, sinon vous "faisons une opération entière, puis la coulée du résultat, au lieu de faire l'opération entre les flotteurs.

float scale;
scale = n * 1.0 / 1024 * 255;

2 pour la réponse № 5

Dans ton cas n/1024 donne 0 comme division entière. Pour surmonter cela, vous pouvez lancer n à float. Cela vous donnera un résultat entre 0.0 et 1.0 ensuite vous multipliez avec 255 et renvoyer le résultat en entier. Aussi, vous devez déclarer scale comme int

int scale;
int n = 80;
scale = (int)(((float)n/1024) * 255);

2 pour la réponse № 6

d'autres ont déjà donné de grandes réponses. Si vous voulez que votre balance soit un entier (ce qui est logique si votre n est déjà un entier), vous pouvez le faire

int scale = ((255 * n)/1024);

Notez que vous ne rencontrerez aucun problème tant que ce sont les nombres, puisque n * 255 tiendra toujours dans un int lorsque le maximum n = 1024.

plus flexible serait

int scale(int value, int old_max, int new_max){
java.math.BigInteger big_value = java.math.BigInteger.valueOf(value);
java.math.BigInteger big_old_max = java.math.BigInteger.valueOf(old_max);
java.math.BigInteger big_new_max = java.math.BigInteger.valueOf(new_max);
java.math.BigInteger mult = big_value.multiply(big_old_max);
return (int) mult.devide(big_new_max).doubleValue();
}

Vous n'aurez pas à déborder de cette façon, même si j'avoue que c'est un peu verbeux

Modifier:

Basiquement les mêmes, mais moins encombrants (bien que pour des nombres très élevés, vous pourriez rencontrer des erreurs de précision)

int scale(int value, int old_max, int new_max){
double factor = (double) new_max / (double) old_max;
return factor * value;
}

Le plus populaire