Double à la fraction en Java

Donc ce que je suis en train de faire est de convertir le double de nombre rationnel. J'ai vérifier le nombre de chiffres il y a après le point décimal et je veux enregistrer le numéro 123.456 comme 123456 /1000, par exemple.

public Rational(double d){      
    String s = String.valueOf(d);
    int digitsDec = s.length() - 1 - s.indexOf('.');        

    for(int i = 0; i < digitsDec; i++){
        d *= 10;
    }

    System.out.println((int)d); //checking purposes
}

Cependant, pour le nombre 123.456-je obtenir un arrondi erreur et le résultat est 123455. Je suppose qu'il serait possible de corriger cela avec BigDecimal, mais je ne peux pas le faire fonctionner. Aussi, après avoir calculé ce nombre rationnel, il serait, je voudrais appeler un autre constructeur avec paramètres (int numérateur, int dénominateur) mais je ne peux bien évidemment faire appel au constructeur de la ligne où println est maintenant. Comment dois-je faire cela?

ne serait-il pas plus simple de juste compter l'emplacement de la dot et ensuite supprimer (chaîne de caractères) pour remplacer le dot de la chaîne?
Tu ne peux pas mettre toutes les décimales derrière la dot en face d'elle tout en comptant le nombre de chiffres que vous avez pris? Supprimer la dot, d'analyser tout d'int et de créer un 2ème int à l'aide de 10 fois la quantité de nombres que vous avez pris?
Légèrement hors-sujet, mais vous savez que tout nombre rationnel est un nombre infini de fractions de représentations? Une option pourrait être à la recherche pour le canonique fraction, mais c'est un peu plus compliqué de ce que vous essayez de faire.
Aussi hors sujet, mais vous souhaitez peut-être envisager quelques erreurs d'algorithme. Par exemple, un double ne peut pas représenter 1/10 exactement, mais je ne suis pas sûr si vous voulez représenter le nombre rationnel 0.1000000000000000055511151231257827021181583404541015625. Sinon, comme vous le mentionnez, vous pouvez simplement utiliser BigDecimal.

OriginalL'auteur Neutrino | 2012-12-23

5

Pour la première partie de la question, Java est de stocker des .6 comme .5999999 (répéter). Voir cette sortie:
```
(after first multiply): d=1234.56
(after second multiply): d=12345.599999999999
(after third multiply): d=123455.99999999999
```
Une des solutions est d'utiliser d = Math.round(d) immédiatement après votre boucle se termine.
```
public class Rational {

     private int num, denom;

     public Rational(double d) {
          String s = String.valueOf(d);
          int digitsDec = s.length() - 1 - s.indexOf('.');        

          int denom = 1;
          for(int i = 0; i < digitsDec; i++){
             d *= 10;
             denom *= 10;
          }
          int num = (int) Math.round(d);

          this.num = num; this.denom = denom;
     }

     public Rational(int num, int denom) {
          this.num = num; this.denom = denom;
     }

     public String toString() {
          return String.valueOf(num) + "/" + String.valueOf(denom);
     }

     public static void main(String[] args) {
          System.out.println(new Rational(123.456));
     }
}
```
Cela fonctionne - essayer.

Pour la deuxième partie de votre question...

Afin d'appeler le deuxième constructeur à partir de la première, vous pouvez utiliser le mot clé "this"
```
this(num, denom)
```
Mais elle doit être la première ligne dans le constructeur... qui n'a pas de sens ici (que nous avons à faire quelques calculs en premier). Je ne voudrais pas la peine d'essayer de le faire.

En multipliant par 10.0 n'a pas changé le résultat.
Quant à la deuxième partie: probablement, je n'ai pas l'état de mon problème avec suffisamment de précision. J'en ai deux constructeurs: d'abord avec le paramètre (double d), l'autre avec (int num, int denom). Dans la première, je veux convertir doubler le nombre de fraction et de l'appel de la deuxième constructeur.
Java est le stockage de votre double 123.456 comme 123455.999999 fois que vous avez fini de multiplier par 10. Une façon d'obtenir la bonne valeur est au tour ici.
Voir mon révisé après je l'ai testé et obtenu 123456/1000 que ma sortie standard.
Merci beaucoup, c'est bien maintenant.

OriginalL'auteur ktm5124

Ce code peut-être exagéré, mais elle vous traite de l'erreur d'arrondi que vous êtes en train de vivre, et elle prend également soin de répéter décimales (4.99999999999999 se transforme en 5, et 0.33333333333333333333 se transforme en 1/3).

public static Rational toRational(double number){
return toRational(number, 8);
}
public static Rational toRational(double number, int largestRightOfDecimal){
long sign = 1;
if(number < 0){
number = -number;
sign = -1;
}
final long SECOND_MULTIPLIER_MAX = (long)Math.pow(10, largestRightOfDecimal - 1);
final long FIRST_MULTIPLIER_MAX = SECOND_MULTIPLIER_MAX * 10L;
final double ERROR = Math.pow(10, -largestRightOfDecimal - 1);
long firstMultiplier = 1;
long secondMultiplier = 1;
boolean notIntOrIrrational = false;
long truncatedNumber = (long)number;
Rational rationalNumber = new Rational((long)(sign * number * FIRST_MULTIPLIER_MAX), FIRST_MULTIPLIER_MAX);
double error = number - truncatedNumber;
while( (error >= ERROR) && (firstMultiplier <= FIRST_MULTIPLIER_MAX)){
secondMultiplier = 1;
firstMultiplier *= 10;
while( (secondMultiplier <= SECOND_MULTIPLIER_MAX) && (secondMultiplier < firstMultiplier) ){
double difference = (number * firstMultiplier) - (number * secondMultiplier);
truncatedNumber = (long)difference;
error = difference - truncatedNumber;
if(error < ERROR){
notIntOrIrrational = true;
break;
}
secondMultiplier *= 10;
}
}
if(notIntOrIrrational){
rationalNumber = new Rational(sign * truncatedNumber, firstMultiplier - secondMultiplier);
}
return rationalNumber;
}

Cela fournit les résultats suivants (les résultats de cas de test sont présentés comme des commentaires):

Rational.toRational(110.0/3.0); //110/3
Rational.toRational(11.0/1000.0); //11/1000
Rational.toRational(17357.0/33300.0); //17357/33300
Rational.toRational(215.0/21.0); //215/21
Rational.toRational(0.123123123123123123123123); //41/333
Rational.toRational(145731.0/27100.0); //145731/27100
Rational.toRational(Math.PI); //62831853/20000000
Rational.toRational(62.0/63.0); //62/63
Rational.toRational(24.0/25.0); //24/25
Rational.toRational(-24.0/25.0); //-24/25
Rational.toRational(-0.25333333333333333333333); //-19/75
Rational.toRational(-4.9999999999999999999999); //-5
Rational.toRational(4.9999999999999999999999);  //5
Rational.toRational(123.456); //15432/125

OriginalL'auteur Scott Canady

Ce n'est pas élégant, cependant, je crois que cela ne ce que vous demandez.

double a = 123.456;
String aString = Double.toString(a);        
String[] fraction = aString.split("\\.");
int denominator = (int)Math.pow(10, fraction[1].length());
int numerator = Integer.parseInt(fraction[0] + "" + fraction[1]);
System.out.println(numerator + "/" + denominator);

Maintenant simplifier 😀

OriginalL'auteur Alex Musk

Ici, d=123.456 puis num=123456, j=1000

public Rational(double d){      
double temp =d;
int j=1, num;
do{
j=j*10;
}while((temp*j)%10==0);        
j=j/10;
num=(int)(d*j);
System.out.println(num);
System.out.println(j);
}

OriginalL'auteur OnePunchMan

0

Essayer
```
for(int i = 0; i <= digitsDec; i++){
}
```
Je veux convertir du nombre 123.456 à 123456. Lorsque je change de i <= digitsDec-je obtenir un numéro de 1234559.

OriginalL'auteur Thato Molahlwe Shebe

Vous devez vous connecter pour publier un commentaire.