java - ¿Por qué dividir un flotante por un entero devuelve 0.0?

math division

Question

Entonces, si tengo un rango de números ''0 - 1024'' y quiero ponerlos en ''0 - 255'', las matemáticas dictarían dividir la entrada por el máximo que la entrada será (1024 en este caso) que dará yo un número entre 0.0 - 1.0. luego multiplique eso por el rango de destino, (255).

¡Que es lo que quiero hacer!

Pero por alguna razón en Java (usando Procesamiento) Siempre devolverá un valor de 0.

El código sería tan simple como esto

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

Pero acabo de obtener 0.0. He intentado doble e int. todo fue en vano. ¿¡POR QUÉ!?

Answer 1

Debería autoevaluar n para flotar por medio de una multiplicación PRIMERO, de lo contrario, se está haciendo una operación entera y luego se arroja el resultado, en lugar de hacer la operación entre flotantes.

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

Answer 2

En su caso, n/1024 da como resultado 0 a medida que realiza la división de enteros. Para superar esto, puedes lanzar n para float . Esto le dará un resultado entre 0.0 y 1.0 luego usted multiplicará con 255 y arrojará el resultado nuevamente al número entero. También necesita declarar la scale como int

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

Answer 3

Es porque estás haciendo una división entera.

Divida por un doble o un flotador, y funcionará:

double scale = ( n / 1024.0 ) * 255 ;

O, si lo quieres como un flotador,

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

Answer 4

Supongo que n es un int . Como las constantes 1024 y 255 son ambas int s, todos los cálculos del lado derecho se realizan con aritmética de enteros. Lo que significa que el resultado de n/1024 se trunca a un valor integral antes de multiplicarse por 255 .

Cualquiera de estas modificaciones hará que los cálculos funcionen correctamente:

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.

El último usa matemáticas enteras todavía, pero cambiar el orden de las operaciones significa que no obtendrás el truncamiento no deseado en 0. Sin embargo, solo obtendrás respuestas enteras, por lo que perderás puntos decimales en las respuestas.

Answer 5

n / 1024 es una división entera , que da un entero (es decir, 0 en este caso).

Use n / 1024.0 lugar.

Answer 6

otros ya han dado grandes respuestas. En caso de que quiera que su escala sea un número entero (lo cual tiene sentido si su n ya es un número entero), podría hacer

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

Tenga en cuenta que no tendrá ningún problema con esto, siempre que estos sean los números, ya que n * 255 siempre encajará en un int cuando el máximo n = 1024.

más flexible sería

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

No se desbordará ninguna entrada de esta manera, aunque admito que esto es un poco detallado

Editar:

Básicamente lo mismo, pero menos torpe (aunque para números muy altos es posible que se encuentre con algunos errores de precisión)

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