Warum gibt das Teilen eines Floats durch eine Ganzzahl 0.0 zurück? - Java, Mathe, Division, Integer-Division

Also wenn ich einen Zahlenbereich von "0 - 1024" und I habeWill man sie in "0 - 255" bringen, würde die Mathematik vorschreiben, die Eingabe durch das Maximum zu dividieren, das die Eingabe sein wird (1024 in diesem Fall), was mir eine Zahl zwischen 0,0 - 1,0 geben wird. dann multipliziere das mit dem Zielbereich (255).

Was ich machen möchte!

Aber aus irgendeinem Grund in Java (mit der Verarbeitung) wird immer der Wert 0 zurückgegeben.

Der Code wäre so einfach

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

Aber ich bekomme nur 0.0. Ich habe versucht, double und int. Alles vergebens. WARUM !?

Antworten:

69 für die Antwort № 1

Es ist, weil Sie Integer-Division machen.

Teile durch ein Double oder Float, und es wird funktionieren:

double scale = ( n / 1024.0 ) * 255 ;

Oder, wenn Sie es als Schwimmer wollen,

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

19 für die Antwort № 2

n / 1024 ist ganzzahlige Division, was eine ganze Zahl ergibt (dh in diesem Fall 0).

Benutzen n / 1024.0 stattdessen.


7 für die Antwort № 3

Ich nehme an n ist ein int. Weil die Konstanten 1024 und 255 beide sind ints Alle Berechnungen auf der rechten Seite werden mit Ganzzahlarithmetik durchgeführt. Bedeutung das Ergebnis von n/1024 wird auf einen ganzzahligen Wert gekürzt, bevor es mit multipliziert wird 255.

Jede dieser Änderungen wird die Berechnungen richtig funktionieren lassen:

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.

Die letzte verwendet noch Ganzzahlmathematik aberWenn Sie die Reihenfolge der Operationen ändern, bedeutet das, dass Sie die unerwünschte Trunkierung nicht auf 0 setzen. Sie erhalten nur noch ganzzahlige Antworten, sodass Sie alle Dezimalstellen in den Antworten verlieren.


2 für die Antwort № 4

Sie sollten n automatisch floaten, indem Sie die Multiplikation mit FIRST ausführen. Andernfalls führen Sie eine Integer-Operation aus und geben dann das Ergebnis aus, statt die Operation zwischen den Floats auszuführen.

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

2 für die Antwort № 5

In Ihrem Fall n/1024 ergibt 0, da Sie eine Ganzzahldivision durchführen. Um dies zu überwinden, können Sie casten n zu float. Dadurch erhalten Sie ein Ergebnis zwischen 0.0 und 1.0 Als nächstes multiplizieren Sie mit 255 und wirf das Ergebnis zurück auf Integer. Auch Sie müssen deklarieren scale wie int

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

2 für die Antwort № 6

Andere haben bereits gute Antworten gegeben. Wenn Sie möchten, dass Ihre Skala eine ganze Zahl ist (was sinnvoll ist, wenn Ihr n bereits eine ganze Zahl ist), könnten Sie das tun

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

Beachten Sie, dass Sie keine Probleme damit lösen werden, solange dies die Zahlen sind, da n * 255 immer in ein int passt, wenn das Maximum n = 1024 ist.

flexibler wäre

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

Sie werden keine Ints auf diese Weise überlaufen, obwohl ich zugeben, das ist ein bisschen ausführlich

Bearbeiten:

Grundsätzlich gleich, aber weniger klobig (obwohl bei sehr hohen Zahlen einige Präzessionsfehler auftreten können)

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