Een getal tot een macht verheffen in Java

Hier is mijn code. Om de een of andere reden wordt mijn BMI niet correct berekend.
Als ik de uitvoer op een rekenmachine hiervoor controleer: (10/((10/100)^2)))krijg ik 1000, maar in mijn programma krijg ik 5. Ik weet het niet zeker wat ik fout doe. Hier is mijn code:

import javax.swing.*;
public class BMI {
    public static void main(String args[]) {
        int height;
        int weight;
        String getweight;
        getweight = JOptionPane.showInputDialog(null, "Please enter your weight in Kilograms");
        String getheight;
        getheight = JOptionPane.showInputDialog(null, "Please enter your height in Centimeters");
        weight = Integer.parseInt(getweight);
        height = Integer.parseInt(getheight);
        double bmi;
        bmi = (weight/((height/100)^2));
        JOptionPane.showMessageDialog(null, "Your BMI is: " + bmi);
    }
}

Antwoord 1, autoriteit 100%

^in java betekent niet verheffen tot een macht. Het betekent XOR.

U kunt Java’s Math.pow()

. gebruiken

En je zou kunnen overwegen om doublete gebruiken in plaats van intdat wil zeggen:

double height;
double weight;

Merk op dat 199/100resulteert in 1.

Antwoord 2, autoriteit 24%

we kunnen

. gebruiken

Math.pow(2, 4);

dit gemiddelde 2 tot de macht 4 (2^4)

antwoord = 16

Antwoord 3, autoriteit 5%

Uw berekening is waarschijnlijk de boosdoener. Probeer het gebruik van:

bmi = weight / Math.pow(height / 100.0, 2.0);

Omdat zowel heightals 100gehele getallen zijn, kreeg je waarschijnlijk het verkeerde antwoord bij het delen. 100.0is echter een dubbel. Ik stel voor dat je weightook dubbel maakt. De operator ^is ook niet voor bevoegdheden. Gebruik in plaats daarvan de methode Math.pow().

Antwoord 4, autoriteit 3%

^is niet de gewenste operator. U zoekt de powfunctie van java.lang.Math.

U kunt Math.pow(value, power)gebruiken.

Voorbeeld:

Math.pow(23, 5); // 23 to the fifth power

Antwoord 5, autoriteit 3%

Te laat voor de OP natuurlijk, maar toch…
De uitdrukking herschikken als:

int bmi = (10000 * weight) / (height * height)

Elimineert alle drijvende komma’s en converteert een deling door een constante naar een vermenigvuldiging, die sneller zou moeten worden uitgevoerd. Gehele precisie is waarschijnlijk voldoende voor deze toepassing, maar als dat niet het geval is:

double bmi = (10000.0 * weight) / (height * height)

zou nog steeds een verbetering zijn.

Antwoord 6, autoriteit 2%

U moet onderstaande methode gebruiken-

Math.pow(dubbele a, dubbele b)

Van (https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#pow-double-double-)

Retourneert de waarde van het eerste argument verheven tot de macht van het tweede argument.

Antwoord 7

int weight=10;
int height=10;
double bmi;
bmi = weight / Math.pow(height / 100.0, 2.0);
System.out.println("bmi"+(bmi));
double result = bmi * 100;
result = Math.round(result);
result = result / 100;
System.out.println("result"+result);

Antwoord 8

1) We gebruiken gewoonlijk geen intgegevenstypen voor lengte, gewicht, afstand,
temperatuur enz. (variabelen die decimalen kunnen hebben)
Daarom moet lengte, gewicht dubbel zijn of zweven.
maar double is nauwkeuriger dan float wanneer je meer decimalen hebt

2) En in plaats van ^, kunt u die berekening zoals hieronder wijzigen met Math.pow()

bmi = (weight/(Math.pow(height/100, 2)));

3) Math.pow()methode heeft onderstaande definitie

Math.pow(double var_1, double var_2);

Voorbeeld:

i) Math.pow(8, 2)wordt geproduceerd 64 (8 tot de macht 2)

ii) Math.pow(8.2, 2.1)wordt geproduceerd 82.986813689753 (8,2 tot de macht 2.1)

Antwoord 9

Ik deed de benchmarking met Math.pow(x,2) en x*x,
het resultaat is dat Math.pow() gemakkelijk veertig keer langzamer is dan het handmatig vermenigvuldigen met zichzelf, dus ik raad het niet aan voor iets waar een beetje prestatie vereist is.

Dit zijn de resultaten:

proof_of_work: 19.284756867003345
time for Math.pow(x,2) in ns: 35143
proof_of_work: 19.284756867003345
time for x*x in ns: 884
manual calculation is 39 times faster

en hier is de testcode

double r1 = 4.391441320;
long multiply_d1 = System.nanoTime();
double multiply_dr = Math.pow(r1,2);
long multiply_d2 = System.nanoTime();
System.out.println(("proof_of_work: ") + (multiply_dr));
System.out.println(("time for Math.pow(x,2) in ns: ") + (multiply_d2 - multiply_d1));
long multiply_t1 = System.nanoTime();
double multiply_tr = r1*r1;
long multiply_t2 = System.nanoTime();
System.out.println(("proof_of_work: ") + (multiply_tr));
System.out.println(("time for x*x in ns: ") + (multiply_t2 - multiply_t1));
System.out.println(("manual calculation is ") + ((multiply_d2 - multiply_d1) / (multiply_t2 - multiply_t1)) + (" times faster"));