La meilleure façon de représenter une fraction en Java?

100

J'essaye de travailler avec des fractions en Java.

Je souhaite implémenter des fonctions arithmétiques. Pour cela, je vais d'abord demander un moyen de normaliser les fonctions. Je sais que je ne peux pas ajouter 1/6 et 1/2 avant d'avoir un dénominateur commun. Je devrai ajouter 1/6 et 3/6. Une approche naïve me ferait ajouter 2/12 et 6/12 puis réduire. Comment puis-je obtenir un dénominateur commun avec la moindre pénalité de performance? Quel algorithme est le meilleur pour cela?


Version 8 (merci à hstoerr ):

Les améliorations comprennent:

  • la méthode equals () est désormais cohérente avec la méthode compareTo ()
final class Fraction extends Number {
    private int numerator;
    private int denominator;

    public Fraction(int numerator, int denominator) {
        if(denominator == 0) {
            throw new IllegalArgumentException("denominator is zero");
        }
        if(denominator < 0) {
            numerator *= -1;
            denominator *= -1;
        }
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public Fraction(int numerator) {
        this.numerator = numerator;
        this.denominator = 1;
    }

    public int getNumerator() {
        return this.numerator;
    }

    public int getDenominator() {
        return this.denominator;
    }

    public byte byteValue() {
        return (byte) this.doubleValue();
    }

    public double doubleValue() {
        return ((double) numerator)/((double) denominator);
    }

    public float floatValue() {
        return (float) this.doubleValue();
    }

    public int intValue() {
        return (int) this.doubleValue();
    }

    public long longValue() {
        return (long) this.doubleValue();
    }

    public short shortValue() {
        return (short) this.doubleValue();
    }

    public boolean equals(Fraction frac) {
        return this.compareTo(frac) == 0;
    }

    public int compareTo(Fraction frac) {
        long t = this.getNumerator() * frac.getDenominator();
        long f = frac.getNumerator() * this.getDenominator();
        int result = 0;
        if(t>f) {
            result = 1;
        }
        else if(f>t) {
            result = -1;
        }
        return result;
    }
}

J'ai supprimé toutes les versions précédentes. Mes remerciements à:

onze81
la source
33
Jetez le code, utilisez Apache Commons :) commons.apache.org/math/userguide/fraction.html
Patrick
3
Le commentaire de Patrick mériterait +1, s'il avait été publié comme réponse. Dans la plupart des cas, c'est la bonne réponse; «connaître et utiliser les bibliothèques», comme le dit Effective Java. La question initiale est également claire et utile.
Jonik
Vous avez remarqué que vous avez accepté ma réponse ... si vous utilisez réellement ce code et que vous trouvez des problèmes avec celui-ci ou quoi que ce soit qui manque, faites-le moi savoir! Envoyez-
Kip
Je vous suggère de modifier votre méthode "compareTo" et de lancer "this.getNumerator ()" bien avant la multiplication. Sinon, le code risque toujours de déborder. Je pense également que ce serait bien d'implémenter <Fraction> Comparable, puisque vous avez déjà implémenté la méthode compareTo.
Hosam Aly
Et puisque vous êtes allé si loin, il peut être utile d'implémenter également equals et hashCode.
Hosam Aly

Réponses:

65

Il se trouve que j'ai écrit une classe BigFraction il n'y a pas si longtemps, pour des problèmes de Project Euler . Il garde un numérateur et un dénominateur BigInteger, donc il ne débordera jamais. Mais ce sera un peu lent pour beaucoup d'opérations dont vous savez qu'elles ne déborderont jamais ... de toute façon, utilisez-la si vous le voulez. Je meurs d'envie de montrer ça d'une manière ou d'une autre. :)

Edit : La dernière et la meilleure version de ce code, y compris les tests unitaires, est désormais hébergée sur GitHub et également disponible via Maven Central . Je laisse mon code d'origine ici pour que cette réponse ne soit pas qu'un lien ...


import java.math.*;

/**
 * Arbitrary-precision fractions, utilizing BigIntegers for numerator and
 * denominator.  Fraction is always kept in lowest terms.  Fraction is
 * immutable, and guaranteed not to have a null numerator or denominator.
 * Denominator will always be positive (so sign is carried by numerator,
 * and a zero-denominator is impossible).
 */
public final class BigFraction extends Number implements Comparable<BigFraction>
{
  private static final long serialVersionUID = 1L; //because Number is Serializable
  private final BigInteger numerator;
  private final BigInteger denominator;

  public final static BigFraction ZERO = new BigFraction(BigInteger.ZERO, BigInteger.ONE, true);
  public final static BigFraction ONE = new BigFraction(BigInteger.ONE, BigInteger.ONE, true);

  /**
   * Constructs a BigFraction with given numerator and denominator.  Fraction
   * will be reduced to lowest terms.  If fraction is negative, negative sign will
   * be carried on numerator, regardless of how the values were passed in.
   */
  public BigFraction(BigInteger numerator, BigInteger denominator)
  {
    if(numerator == null)
      throw new IllegalArgumentException("Numerator is null");
    if(denominator == null)
      throw new IllegalArgumentException("Denominator is null");
    if(denominator.equals(BigInteger.ZERO))
      throw new ArithmeticException("Divide by zero.");

    //only numerator should be negative.
    if(denominator.signum() < 0)
    {
      numerator = numerator.negate();
      denominator = denominator.negate();
    }

    //create a reduced fraction
    BigInteger gcd = numerator.gcd(denominator);
    this.numerator = numerator.divide(gcd);
    this.denominator = denominator.divide(gcd);
  }

  /**
   * Constructs a BigFraction from a whole number.
   */
  public BigFraction(BigInteger numerator)
  {
    this(numerator, BigInteger.ONE, true);
  }

  public BigFraction(long numerator, long denominator)
  {
    this(BigInteger.valueOf(numerator), BigInteger.valueOf(denominator));
  }

  public BigFraction(long numerator)
  {
    this(BigInteger.valueOf(numerator), BigInteger.ONE, true);
  }

  /**
   * Constructs a BigFraction from a floating-point number.
   * 
   * Warning: round-off error in IEEE floating point numbers can result
   * in answers that are unexpected.  For example, 
   *     System.out.println(new BigFraction(1.1))
   * will print:
   *     2476979795053773/2251799813685248
   * 
   * This is because 1.1 cannot be expressed exactly in binary form.  The
   * given fraction is exactly equal to the internal representation of
   * the double-precision floating-point number.  (Which, for 1.1, is:
   * (-1)^0 * 2^0 * (1 + 0x199999999999aL / 0x10000000000000L).)
   * 
   * NOTE: In many cases, BigFraction(Double.toString(d)) may give a result
   * closer to what the user expects.
   */
  public BigFraction(double d)
  {
    if(Double.isInfinite(d))
      throw new IllegalArgumentException("double val is infinite");
    if(Double.isNaN(d))
      throw new IllegalArgumentException("double val is NaN");

    //special case - math below won't work right for 0.0 or -0.0
    if(d == 0)
    {
      numerator = BigInteger.ZERO;
      denominator = BigInteger.ONE;
      return;
    }

    final long bits = Double.doubleToLongBits(d);
    final int sign = (int)(bits >> 63) & 0x1;
    final int exponent = ((int)(bits >> 52) & 0x7ff) - 0x3ff;
    final long mantissa = bits & 0xfffffffffffffL;

    //number is (-1)^sign * 2^(exponent) * 1.mantissa
    BigInteger tmpNumerator = BigInteger.valueOf(sign==0 ? 1 : -1);
    BigInteger tmpDenominator = BigInteger.ONE;

    //use shortcut: 2^x == 1 << x.  if x is negative, shift the denominator
    if(exponent >= 0)
      tmpNumerator = tmpNumerator.multiply(BigInteger.ONE.shiftLeft(exponent));
    else
      tmpDenominator = tmpDenominator.multiply(BigInteger.ONE.shiftLeft(-exponent));

    //1.mantissa == 1 + mantissa/2^52 == (2^52 + mantissa)/2^52
    tmpDenominator = tmpDenominator.multiply(BigInteger.valueOf(0x10000000000000L));
    tmpNumerator = tmpNumerator.multiply(BigInteger.valueOf(0x10000000000000L + mantissa));

    BigInteger gcd = tmpNumerator.gcd(tmpDenominator);
    numerator = tmpNumerator.divide(gcd);
    denominator = tmpDenominator.divide(gcd);
  }

  /**
   * Constructs a BigFraction from two floating-point numbers.
   * 
   * Warning: round-off error in IEEE floating point numbers can result
   * in answers that are unexpected.  See BigFraction(double) for more
   * information.
   * 
   * NOTE: In many cases, BigFraction(Double.toString(numerator) + "/" + Double.toString(denominator))
   * may give a result closer to what the user expects.
   */
  public BigFraction(double numerator, double denominator)
  {
    if(denominator == 0)
      throw new ArithmeticException("Divide by zero.");

    BigFraction tmp = new BigFraction(numerator).divide(new BigFraction(denominator));
    this.numerator = tmp.numerator;
    this.denominator = tmp.denominator;
  }

  /**
   * Constructs a new BigFraction from the given BigDecimal object.
   */
  public BigFraction(BigDecimal d)
  {
    this(d.scale() < 0 ? d.unscaledValue().multiply(BigInteger.TEN.pow(-d.scale())) : d.unscaledValue(),
         d.scale() < 0 ? BigInteger.ONE                                             : BigInteger.TEN.pow(d.scale()));
  }

  public BigFraction(BigDecimal numerator, BigDecimal denominator)
  {
    if(denominator.equals(BigDecimal.ZERO))
      throw new ArithmeticException("Divide by zero.");

    BigFraction tmp = new BigFraction(numerator).divide(new BigFraction(denominator));
    this.numerator = tmp.numerator;
    this.denominator = tmp.denominator;
  }

  /**
   * Constructs a BigFraction from a String.  Expected format is numerator/denominator,
   * but /denominator part is optional.  Either numerator or denominator may be a floating-
   * point decimal number, which in the same format as a parameter to the
   * <code>BigDecimal(String)</code> constructor.
   * 
   * @throws NumberFormatException  if the string cannot be properly parsed.
   */
  public BigFraction(String s)
  {
    int slashPos = s.indexOf('/');
    if(slashPos < 0)
    {
      BigFraction res = new BigFraction(new BigDecimal(s));
      this.numerator = res.numerator;
      this.denominator = res.denominator;
    }
    else
    {
      BigDecimal num = new BigDecimal(s.substring(0, slashPos));
      BigDecimal den = new BigDecimal(s.substring(slashPos+1, s.length()));
      BigFraction res = new BigFraction(num, den);
      this.numerator = res.numerator;
      this.denominator = res.denominator;
    }
  }

  /**
   * Returns this + f.
   */
  public BigFraction add(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    //n1/d1 + n2/d2 = (n1*d2 + d1*n2)/(d1*d2) 
    return new BigFraction(numerator.multiply(f.denominator).add(denominator.multiply(f.numerator)),
                           denominator.multiply(f.denominator));
  }

  /**
   * Returns this + b.
   */
  public BigFraction add(BigInteger b)
  {
    if(b == null)
      throw new IllegalArgumentException("Null argument");

    //n1/d1 + n2 = (n1 + d1*n2)/d1
    return new BigFraction(numerator.add(denominator.multiply(b)),
                           denominator, true);
  }

  /**
   * Returns this + n.
   */
  public BigFraction add(long n)
  {
    return add(BigInteger.valueOf(n));
  }

  /**
   * Returns this - f.
   */
  public BigFraction subtract(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    return new BigFraction(numerator.multiply(f.denominator).subtract(denominator.multiply(f.numerator)),
                           denominator.multiply(f.denominator));
  }

  /**
   * Returns this - b.
   */
  public BigFraction subtract(BigInteger b)
  {
    if(b == null)
      throw new IllegalArgumentException("Null argument");

    return new BigFraction(numerator.subtract(denominator.multiply(b)),
                           denominator, true);
  }

  /**
   * Returns this - n.
   */
  public BigFraction subtract(long n)
  {
    return subtract(BigInteger.valueOf(n));
  }

  /**
   * Returns this * f.
   */
  public BigFraction multiply(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    return new BigFraction(numerator.multiply(f.numerator), denominator.multiply(f.denominator));
  }

  /**
   * Returns this * b.
   */
  public BigFraction multiply(BigInteger b)
  {
    if(b == null)
      throw new IllegalArgumentException("Null argument");

    return new BigFraction(numerator.multiply(b), denominator);
  }

  /**
   * Returns this * n.
   */
  public BigFraction multiply(long n)
  {
    return multiply(BigInteger.valueOf(n));
  }

  /**
   * Returns this / f.
   */
  public BigFraction divide(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    if(f.numerator.equals(BigInteger.ZERO))
      throw new ArithmeticException("Divide by zero");

    return new BigFraction(numerator.multiply(f.denominator), denominator.multiply(f.numerator));
  }

  /**
   * Returns this / b.
   */
  public BigFraction divide(BigInteger b)
  {
    if(b == null)
      throw new IllegalArgumentException("Null argument");

    if(b.equals(BigInteger.ZERO))
      throw new ArithmeticException("Divide by zero");

    return new BigFraction(numerator, denominator.multiply(b));
  }

  /**
   * Returns this / n.
   */
  public BigFraction divide(long n)
  {
    return divide(BigInteger.valueOf(n));
  }

  /**
   * Returns this^exponent.
   */
  public BigFraction pow(int exponent)
  {
    if(exponent == 0)
      return BigFraction.ONE;
    else if (exponent == 1)
      return this;
    else if (exponent < 0)
      return new BigFraction(denominator.pow(-exponent), numerator.pow(-exponent), true);
    else
      return new BigFraction(numerator.pow(exponent), denominator.pow(exponent), true);
  }

  /**
   * Returns 1/this.
   */
  public BigFraction reciprocal()
  {
    if(this.numerator.equals(BigInteger.ZERO))
      throw new ArithmeticException("Divide by zero");

    return new BigFraction(denominator, numerator, true);
  }

  /**
   * Returns the complement of this fraction, which is equal to 1 - this.
   * Useful for probabilities/statistics.

   */
  public BigFraction complement()
  {
    return new BigFraction(denominator.subtract(numerator), denominator, true);
  }

  /**
   * Returns -this.
   */
  public BigFraction negate()
  {
    return new BigFraction(numerator.negate(), denominator, true);
  }

  /**
   * Returns -1, 0, or 1, representing the sign of this fraction.
   */
  public int signum()
  {
    return numerator.signum();
  }

  /**
   * Returns the absolute value of this.
   */
  public BigFraction abs()
  {
    return (signum() < 0 ? negate() : this);
  }

  /**
   * Returns a string representation of this, in the form
   * numerator/denominator.
   */
  public String toString()
  {
    return numerator.toString() + "/" + denominator.toString();
  }

  /**
   * Returns if this object is equal to another object.
   */
  public boolean equals(Object o)
  {
    if(!(o instanceof BigFraction))
      return false;

    BigFraction f = (BigFraction)o;
    return numerator.equals(f.numerator) && denominator.equals(f.denominator);
  }

  /**
   * Returns a hash code for this object.
   */
  public int hashCode()
  {
    //using the method generated by Eclipse, but streamlined a bit..
    return (31 + numerator.hashCode())*31 + denominator.hashCode();
  }

  /**
   * Returns a negative, zero, or positive number, indicating if this object
   * is less than, equal to, or greater than f, respectively.
   */
  public int compareTo(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    //easy case: this and f have different signs
    if(signum() != f.signum())
      return signum() - f.signum();

    //next easy case: this and f have the same denominator
    if(denominator.equals(f.denominator))
      return numerator.compareTo(f.numerator);

    //not an easy case, so first make the denominators equal then compare the numerators 
    return numerator.multiply(f.denominator).compareTo(denominator.multiply(f.numerator));
  }

  /**
   * Returns the smaller of this and f.
   */
  public BigFraction min(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    return (this.compareTo(f) <= 0 ? this : f);
  }

  /**
   * Returns the maximum of this and f.
   */
  public BigFraction max(BigFraction f)
  {
    if(f == null)
      throw new IllegalArgumentException("Null argument");

    return (this.compareTo(f) >= 0 ? this : f);
  }

  /**
   * Returns a positive BigFraction, greater than or equal to zero, and less than one.
   */
  public static BigFraction random()
  {
    return new BigFraction(Math.random());
  }

  public final BigInteger getNumerator() { return numerator; }
  public final BigInteger getDenominator() { return denominator; }

  //implementation of Number class.  may cause overflow.
  public byte   byteValue()   { return (byte) Math.max(Byte.MIN_VALUE,    Math.min(Byte.MAX_VALUE,    longValue())); }
  public short  shortValue()  { return (short)Math.max(Short.MIN_VALUE,   Math.min(Short.MAX_VALUE,   longValue())); }
  public int    intValue()    { return (int)  Math.max(Integer.MIN_VALUE, Math.min(Integer.MAX_VALUE, longValue())); }
  public long   longValue()   { return Math.round(doubleValue()); }
  public float  floatValue()  { return (float)doubleValue(); }
  public double doubleValue() { return toBigDecimal(18).doubleValue(); }

  /**
   * Returns a BigDecimal representation of this fraction.  If possible, the
   * returned value will be exactly equal to the fraction.  If not, the BigDecimal
   * will have a scale large enough to hold the same number of significant figures
   * as both numerator and denominator, or the equivalent of a double-precision
   * number, whichever is more.
   */
  public BigDecimal toBigDecimal()
  {
    //Implementation note:  A fraction can be represented exactly in base-10 iff its
    //denominator is of the form 2^a * 5^b, where a and b are nonnegative integers.
    //(In other words, if there are no prime factors of the denominator except for
    //2 and 5, or if the denominator is 1).  So to determine if this denominator is
    //of this form, continually divide by 2 to get the number of 2's, and then
    //continually divide by 5 to get the number of 5's.  Afterward, if the denominator
    //is 1 then there are no other prime factors.

    //Note: number of 2's is given by the number of trailing 0 bits in the number
    int twos = denominator.getLowestSetBit();
    BigInteger tmpDen = denominator.shiftRight(twos); // x / 2^n === x >> n

    final BigInteger FIVE = BigInteger.valueOf(5);
    int fives = 0;
    BigInteger[] divMod = null;

    //while(tmpDen % 5 == 0) { fives++; tmpDen /= 5; }
    while(BigInteger.ZERO.equals((divMod = tmpDen.divideAndRemainder(FIVE))[1]))
    {
      fives++;
      tmpDen = divMod[0];
    }

    if(BigInteger.ONE.equals(tmpDen))
    {
      //This fraction will terminate in base 10, so it can be represented exactly as
      //a BigDecimal.  We would now like to make the fraction of the form
      //unscaled / 10^scale.  We know that 2^x * 5^x = 10^x, and our denominator is
      //in the form 2^twos * 5^fives.  So use max(twos, fives) as the scale, and
      //multiply the numerator and deminator by the appropriate number of 2's or 5's
      //such that the denominator is of the form 2^scale * 5^scale.  (Of course, we
      //only have to actually multiply the numerator, since all we need for the
      //BigDecimal constructor is the scale.
      BigInteger unscaled = numerator;
      int scale = Math.max(twos, fives);

      if(twos < fives)
        unscaled = unscaled.shiftLeft(fives - twos); //x * 2^n === x << n
      else if (fives < twos)
        unscaled = unscaled.multiply(FIVE.pow(twos - fives));

      return new BigDecimal(unscaled, scale);
    }

    //else: this number will repeat infinitely in base-10.  So try to figure out
    //a good number of significant digits.  Start with the number of digits required
    //to represent the numerator and denominator in base-10, which is given by
    //bitLength / log[2](10).  (bitLenth is the number of digits in base-2).
    final double LG10 = 3.321928094887362; //Precomputed ln(10)/ln(2), a.k.a. log[2](10)
    int precision = Math.max(numerator.bitLength(), denominator.bitLength());
    precision = (int)Math.ceil(precision / LG10);

    //If the precision is less than 18 digits, use 18 digits so that the number
    //will be at least as accurate as a cast to a double.  For example, with
    //the fraction 1/3, precision will be 1, giving a result of 0.3.  This is
    //quite a bit different from what a user would expect.
    if(precision < 18)
      precision = 18;

    return toBigDecimal(precision);
  }

  /**
   * Returns a BigDecimal representation of this fraction, with a given precision.
   * @param precision  the number of significant figures to be used in the result.
   */
  public BigDecimal toBigDecimal(int precision)
  {
    return new BigDecimal(numerator).divide(new BigDecimal(denominator), new MathContext(precision, RoundingMode.HALF_EVEN));
  }

  //--------------------------------------------------------------------------
  //  PRIVATE FUNCTIONS
  //--------------------------------------------------------------------------

  /**
   * Private constructor, used when you can be certain that the fraction is already in
   * lowest terms.  No check is done to reduce numerator/denominator.  A check is still
   * done to maintain a positive denominator.
   * 
   * @param throwaway  unused variable, only here to signal to the compiler that this
   *                   constructor should be used.
   */
  private BigFraction(BigInteger numerator, BigInteger denominator, boolean throwaway)
  {
    if(denominator.signum() < 0)
    {
      this.numerator = numerator.negate();
      this.denominator = denominator.negate();
    }
    else
    {
      this.numerator = numerator;
      this.denominator = denominator;
    }
  }

}
Kip
la source
Si un argument est nul, lancez une NullPointerException. En fait, le code le fera de toute façon, donc votre chèque (et le remplacement par IllegalArgumentException (est un gonflement du code inutile.
cletus
24
Je ne suis pas d'accord; si un autre utilisateur utilisait cette classe sans regarder ma source, et obtenait une NullPointerException, il penserait qu'il y avait un bogue dans mon code. Mais une IllegalArgumentException montre qu'il a rompu le contrat impliqué par le javadoc (même si je n'ai pas réussi à le déclarer explicitement).
Kip
1
juste une question, quel est le problème avec la Fraction et la BigFraction dans Commons Math?
Mortimer
@Mortimer: pas sûr, je ne l'ai jamais regardé
Kip
61
  • Rendez-le immuable ;
  • Rendez-le canonique , ce qui signifie que 6/4 devient 3/2 (le plus grand algorithme de diviseur commun est utile pour cela);
  • Appelez cela rationnel, car ce que vous représentez est un nombre rationnel ;
  • Vous pouvez utiliser BigIntegerpour stocker des valeurs arbitrairement précises. Sinon long, alors , qui a une mise en œuvre plus facile;
  • Rendez le dénominateur toujours positif. Le signe doit être porté par le numérateur;
  • Prolonger Number;
  • Mettre en place Comparable<T> ;
  • Mettre en place equals() et hashCode();
  • Ajoutez une méthode de fabrique pour un nombre représenté par un String;
  • Ajoutez quelques méthodes d'usine pratiques;
  • Ajouter un toString() ; et
  • Faites-le Serializable.

En fait, essayez ceci pour la taille. Il fonctionne mais peut avoir quelques problèmes:

public class BigRational extends Number implements Comparable<BigRational>, Serializable {
    public final static BigRational ZERO = new BigRational(BigInteger.ZERO, BigInteger.ONE);
    private final static long serialVersionUID = 1099377265582986378L;

    private final BigInteger numerator, denominator;

    private BigRational(BigInteger numerator, BigInteger denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    private static BigRational canonical(BigInteger numerator, BigInteger denominator, boolean checkGcd) {
        if (denominator.signum() == 0) {
            throw new IllegalArgumentException("denominator is zero");
        }
        if (numerator.signum() == 0) {
            return ZERO;
        }
        if (denominator.signum() < 0) {
            numerator = numerator.negate();
            denominator = denominator.negate();
        }
        if (checkGcd) {
            BigInteger gcd = numerator.gcd(denominator);
            if (!gcd.equals(BigInteger.ONE)) {
                numerator = numerator.divide(gcd);
                denominator = denominator.divide(gcd);
            }
        }
        return new BigRational(numerator, denominator);
    }

    public static BigRational getInstance(BigInteger numerator, BigInteger denominator) {
        return canonical(numerator, denominator, true);
    }

    public static BigRational getInstance(long numerator, long denominator) {
        return canonical(new BigInteger("" + numerator), new BigInteger("" + denominator), true);
    }

    public static BigRational getInstance(String numerator, String denominator) {
        return canonical(new BigInteger(numerator), new BigInteger(denominator), true);
    }

    public static BigRational valueOf(String s) {
        Pattern p = Pattern.compile("(-?\\d+)(?:.(\\d+)?)?0*(?:e(-?\\d+))?");
        Matcher m = p.matcher(s);
        if (!m.matches()) {
            throw new IllegalArgumentException("Unknown format '" + s + "'");
        }

        // this translates 23.123e5 to 25,123 / 1000 * 10^5 = 2,512,300 / 1 (GCD)
        String whole = m.group(1);
        String decimal = m.group(2);
        String exponent = m.group(3);
        String n = whole;

        // 23.123 => 23123
        if (decimal != null) {
            n += decimal;
        }
        BigInteger numerator = new BigInteger(n);

        // exponent is an int because BigInteger.pow() takes an int argument
        // it gets more difficult if exponent needs to be outside {-2 billion,2 billion}
        int exp = exponent == null ? 0 : Integer.valueOf(exponent);
        int decimalPlaces = decimal == null ? 0 : decimal.length();
        exp -= decimalPlaces;
        BigInteger denominator;
        if (exp < 0) {
            denominator = BigInteger.TEN.pow(-exp);
        } else {
            numerator = numerator.multiply(BigInteger.TEN.pow(exp));
            denominator = BigInteger.ONE;
        }

        // done
        return canonical(numerator, denominator, true);
    }

    // Comparable
    public int compareTo(BigRational o) {
        // note: this is a bit of cheat, relying on BigInteger.compareTo() returning
        // -1, 0 or 1.  For the more general contract of compareTo(), you'd need to do
        // more checking
        if (numerator.signum() != o.numerator.signum()) {
            return numerator.signum() - o.numerator.signum();
        } else {
            // oddly BigInteger has gcd() but no lcm()
            BigInteger i1 = numerator.multiply(o.denominator);
            BigInteger i2 = o.numerator.multiply(denominator);
            return i1.compareTo(i2); // expensive!
        }
    }

    public BigRational add(BigRational o) {
        if (o.numerator.signum() == 0) {
            return this;
        } else if (numerator.signum() == 0) {
            return o;
        } else if (denominator.equals(o.denominator)) {
            return new BigRational(numerator.add(o.numerator), denominator);
        } else {
            return canonical(numerator.multiply(o.denominator).add(o.numerator.multiply(denominator)), denominator.multiply(o.denominator), true);
        }
    }


    public BigRational multiply(BigRational o) {
        if (numerator.signum() == 0 || o.numerator.signum( )== 0) {
            return ZERO;
        } else if (numerator.equals(o.denominator)) {
            return canonical(o.numerator, denominator, true);
        } else if (o.numerator.equals(denominator)) {
            return canonical(numerator, o.denominator, true);
        } else if (numerator.negate().equals(o.denominator)) {
            return canonical(o.numerator.negate(), denominator, true);
        } else if (o.numerator.negate().equals(denominator)) {
            return canonical(numerator.negate(), o.denominator, true);
        } else {
            return canonical(numerator.multiply(o.numerator), denominator.multiply(o.denominator), true);
        }
    }

    public BigInteger getNumerator() { return numerator; }
    public BigInteger getDenominator() { return denominator; }
    public boolean isInteger() { return numerator.signum() == 0 || denominator.equals(BigInteger.ONE); }
    public BigRational negate() { return new BigRational(numerator.negate(), denominator); }
    public BigRational invert() { return canonical(denominator, numerator, false); }
    public BigRational abs() { return numerator.signum() < 0 ? negate() : this; }
    public BigRational pow(int exp) { return canonical(numerator.pow(exp), denominator.pow(exp), true); }
    public BigRational subtract(BigRational o) { return add(o.negate()); }
    public BigRational divide(BigRational o) { return multiply(o.invert()); }
    public BigRational min(BigRational o) { return compareTo(o) <= 0 ? this : o; }
    public BigRational max(BigRational o) { return compareTo(o) >= 0 ? this : o; }

    public BigDecimal toBigDecimal(int scale, RoundingMode roundingMode) {
        return isInteger() ? new BigDecimal(numerator) : new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
    }

    // Number
    public int intValue() { return isInteger() ? numerator.intValue() : numerator.divide(denominator).intValue(); }
    public long longValue() { return isInteger() ? numerator.longValue() : numerator.divide(denominator).longValue(); }
    public float floatValue() { return (float)doubleValue(); }
    public double doubleValue() { return isInteger() ? numerator.doubleValue() : numerator.doubleValue() / denominator.doubleValue(); }

    @Override
    public String toString() { return isInteger() ? String.format("%,d", numerator) : String.format("%,d / %,d", numerator, denominator); }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        BigRational that = (BigRational) o;

        if (denominator != null ? !denominator.equals(that.denominator) : that.denominator != null) return false;
        if (numerator != null ? !numerator.equals(that.numerator) : that.numerator != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = numerator != null ? numerator.hashCode() : 0;
        result = 31 * result + (denominator != null ? denominator.hashCode() : 0);
        return result;
    }

    public static void main(String args[]) {
        BigRational r1 = BigRational.valueOf("3.14e4");
        BigRational r2 = BigRational.getInstance(111, 7);
        dump("r1", r1);
        dump("r2", r2);
        dump("r1 + r2", r1.add(r2));
        dump("r1 - r2", r1.subtract(r2));
        dump("r1 * r2", r1.multiply(r2));
        dump("r1 / r2", r1.divide(r2));
        dump("r2 ^ 2", r2.pow(2));
    }

    public static void dump(String name, BigRational r) {
        System.out.printf("%s = %s%n", name, r);
        System.out.printf("%s.negate() = %s%n", name, r.negate());
        System.out.printf("%s.invert() = %s%n", name, r.invert());
        System.out.printf("%s.intValue() = %,d%n", name, r.intValue());
        System.out.printf("%s.longValue() = %,d%n", name, r.longValue());
        System.out.printf("%s.floatValue() = %,f%n", name, r.floatValue());
        System.out.printf("%s.doubleValue() = %,f%n", name, r.doubleValue());
        System.out.println();
    }
}

La sortie est:

r1 = 31,400
r1.negate() = -31,400
r1.invert() = 1 / 31,400
r1.intValue() = 31,400
r1.longValue() = 31,400
r1.floatValue() = 31,400.000000
r1.doubleValue() = 31,400.000000

r2 = 111 / 7
r2.negate() = -111 / 7
r2.invert() = 7 / 111
r2.intValue() = 15
r2.longValue() = 15
r2.floatValue() = 15.857142
r2.doubleValue() = 15.857143

r1 + r2 = 219,911 / 7
r1 + r2.negate() = -219,911 / 7
r1 + r2.invert() = 7 / 219,911
r1 + r2.intValue() = 31,415
r1 + r2.longValue() = 31,415
r1 + r2.floatValue() = 31,415.857422
r1 + r2.doubleValue() = 31,415.857143

r1 - r2 = 219,689 / 7
r1 - r2.negate() = -219,689 / 7
r1 - r2.invert() = 7 / 219,689
r1 - r2.intValue() = 31,384
r1 - r2.longValue() = 31,384
r1 - r2.floatValue() = 31,384.142578
r1 - r2.doubleValue() = 31,384.142857

r1 * r2 = 3,485,400 / 7
r1 * r2.negate() = -3,485,400 / 7
r1 * r2.invert() = 7 / 3,485,400
r1 * r2.intValue() = 497,914
r1 * r2.longValue() = 497,914
r1 * r2.floatValue() = 497,914.281250
r1 * r2.doubleValue() = 497,914.285714

r1 / r2 = 219,800 / 111
r1 / r2.negate() = -219,800 / 111
r1 / r2.invert() = 111 / 219,800
r1 / r2.intValue() = 1,980
r1 / r2.longValue() = 1,980
r1 / r2.floatValue() = 1,980.180176
r1 / r2.doubleValue() = 1,980.180180

r2 ^ 2 = 12,321 / 49
r2 ^ 2.negate() = -12,321 / 49
r2 ^ 2.invert() = 49 / 12,321
r2 ^ 2.intValue() = 251
r2 ^ 2.longValue() = 251
r2 ^ 2.floatValue() = 251.448975
r2 ^ 2.doubleValue() = 251.448980
cletus
la source
30

J'essaye de travailler avec des fractions appropriées en Java.

Apache Commons Math a une classe Fraction depuis un certain temps. La plupart du temps, la réponse à "Boy, je souhaite que Java ait quelque chose comme X dans la bibliothèque principale!" peut être trouvé sous l'égide de la bibliothèque Apache Commons .

lacet
la source
2
Je vais vous dire pourquoi c'est si bas, la bibliothèque Apache Commons n'est pas conviviale pour les débutants. Premièrement, il n'y a pas de lien direct à télécharger sur cette page (il est caché dans le menu de la barre latérale), deuxièmement, il n'y a pas d'instructions sur la façon de l'utiliser (ajouter un pot à votre chemin de construction), troisièmement, j'ai eu une erreur classDefNotFound après avoir tout ajouté de toute façon . Vous n'obtenez donc pas de votes positifs de la part de nous, qui ne savons que copier et coller.
Noumenon
@Noumenon que diriez-vous d'utiliser n'importe quel gestionnaire de build (par exemple maven) et d'ajouter simplement une dépendance dans POM?
eugene.polschikov
1
J'aimerais voir un petit texte de présentation "Comment utiliser ceci dans votre projet" pour les noobs. Cette suggestion pourrait aller là-dedans. Cela dit, j'ai compris comment le faire et je l'ai utilisé dans mon application d'usine qui nécessitait d'afficher des fractions de pouces, et je ne suis jamais revenu pour vous donner votre vote positif. Alors merci, ici c'est tardivement.
Noumenon le
C'est une bonne rétroaction. Voici également mes remerciements tardifs! :)
yawmark le
Celui-ci est assez facile à utiliser.
Eric Wang
24

Veuillez en faire un type immuable! La valeur d'une fraction ne change pas - une moitié ne devient pas un tiers, par exemple. Au lieu de setDenominator, vous pourriez avoir withDenominator qui renvoie une nouvelle fraction qui a le même numérateur mais le dénominateur spécifié.

La vie est beaucoup plus facile avec les types immuables.

Remplacer equals et hashcode serait également judicieux, il peut donc être utilisé dans les cartes et les ensembles. Les points d'Outlaw Programmer concernant les opérateurs arithmétiques et le formatage des chaînes sont également bons.

En règle générale, jetez un œil à BigInteger et BigDecimal. Ils ne font pas la même chose, mais ils sont assez similaires pour vous donner de bonnes idées.

Jon Skeet
la source
5
"Veuillez en faire un type immuable! La valeur d'une fraction ne change pas - une moitié ne devient pas un tiers, par exemple." La liste / tuple / vecteur (1, 2, 3, 4) ne devient pas non plus la valeur (4, 3, 2, 1), mais cela ne semble pas déranger la plupart des personnes qui listent le changement d'état. Non pas que je ne sois pas d'accord avec l'immuabilité des fractions, mais cela mérite un meilleur argument. Cela ressemble plus à une valeur qu’à un ensemble d’états. Les attentes des programmeurs sont-elles la bonne raison d'être guidé? Je ne suis pas sûr à 100%, mais cela semble être une bonne idée.
Jonas Kölker
2
Eh bien, dans la vraie vie des listes font le changement: comment écrivez-vous une liste de courses? Vous commencez avec une feuille de papier vierge et écrivez dessus. À mi-chemin, vous l'appelez toujours "la liste de courses". Cela dit, la programmation fonctionnelle s'efforce de rendre même les listes immuables ...
Jon Skeet
7

Eh bien, d'une part, je me débarrasserais des setters et rendrais Fractions immuables.

Vous voudrez probablement aussi des méthodes pour ajouter, soustraire, etc., et peut-être un moyen d'obtenir la représentation dans divers formats de chaîne.

EDIT: Je marquerais probablement les champs comme `` finaux '' pour signaler mon intention mais je suppose que ce n'est pas un gros problème ...

Programmeur hors-la-loi
la source
2
Je me demande combien de réponses "rendent immuable" nous finirons avec :)
Jon Skeet
5
  • C'est un peu inutile sans les méthodes arithmétiques comme add () et multiplier (), etc.
  • Vous devez absolument remplacer equals () et hashCode ().
  • Vous devez soit ajouter une méthode pour normaliser la fraction, soit le faire automatiquement. Demandez-vous si vous voulez que 1/2 et 2/4 soient considérés comme identiques ou non - cela a des implications pour les méthodes equals (), hashCode () et compareTo ().
Michael Borgwardt
la source
5

J'aurai besoin de les commander du plus petit au plus grand, donc j'aurai finalement besoin de les représenter comme un double aussi

Pas strictement nécessaire. (En fait, si vous voulez gérer l'égalité correctement, ne comptez pas sur double pour fonctionner correctement.) Si b * d est positif, a / b <c / d si ad <bc. S'il y a des entiers négatifs impliqués, cela peut être géré de manière appropriée ...

Je pourrais réécrire comme:

public int compareTo(Fraction frac)
{
    // we are comparing this=a/b with frac=c/d 
    // by multiplying both sides by bd.
    // If bd is positive, then a/b < c/d <=> ad < bc.
    // If bd is negative, then a/b < c/d <=> ad > bc.
    // If bd is 0, then you've got other problems (either b=0 or d=0)
    int d = frac.getDenominator();
    long ad = (long)this.numerator * d;
    long bc = (long)this.denominator * frac.getNumerator();
    long diff = ((long)d*this.denominator > 0) ? (ad-bc) : (bc-ad);
    return (diff > 0 ? 1 : (diff < 0 ? -1 : 0));
}

L'utilisation de longici est de s'assurer qu'il n'y a pas de débordement si vous multipliez deux grandesint s. handle Si vous pouvez garantir que le dénominateur est toujours non négatif (s'il est négatif, niez simplement le numérateur et le dénominateur), alors vous pouvez vous débarrasser de la nécessité de vérifier si b * d est positif et économiser quelques étapes. Je ne sais pas quel comportement vous recherchez avec un dénominateur nul.

Je ne sais pas comment les performances se comparent à l'utilisation de doubles pour comparer. (Autrement dit, si vous vous souciez autant des performances) Voici une méthode de test que j'ai utilisée pour vérifier. (Semble fonctionner correctement.)

public static void main(String[] args)
{
    int a = Integer.parseInt(args[0]);
    int b = Integer.parseInt(args[1]);
    int c = Integer.parseInt(args[2]);
    int d = Integer.parseInt(args[3]);
    Fraction f1 = new Fraction(a,b); 
    Fraction f2 = new Fraction(c,d);
    int rel = f1.compareTo(f2);
    String relstr = "<=>";
    System.out.println(a+"/"+b+" "+relstr.charAt(rel+1)+" "+c+"/"+d);
}

(ps vous pourriez envisager de restructurer pour implémenter Comparableou Comparatorpour votre classe.)

Jason S
la source
Ce n'est pas vrai si, par exemple, a = 1, b = 3, c = -2, d = -3. Si b et d sont positifs, alors il est vrai que a / b <c / d si et seulement si ad <bc.
Luke Woodward
Argh, je me suis trompé de qualification. (merci!) La condition devrait être si bd> 0.
Jason S
Vrai. Plus précisément, a / b <c / d <=> ac <bd est vrai à condition que bd> 0. Si bd <0, l'inverse est vrai. (Si bd = 0, alors vous avez une fraction de fesses. :-))
Paul Brinkley
Fermer. vous voulez dire a / b <c / d <=> ad <bc pour bd> 0. (Je l'ai bien compris la première fois dans mes commentaires de code!)
Jason S
4

Une amélioration très mineure pourrait potentiellement être de sauvegarder la double valeur que vous calculez afin de ne la calculer qu'au premier accès. Ce ne sera pas une grande victoire à moins que vous n'accédiez beaucoup à ce numéro, mais ce n'est pas trop difficile à faire non plus.

Un point supplémentaire pourrait être la vérification d'erreur que vous faites dans le dénominateur ... vous changez automatiquement 0 en 1. Je ne sais pas si cela est correct pour votre application particulière, mais en général, si quelqu'un essaie de diviser par 0, quelque chose ne va pas. . Je laisserais cela lancer une exception (une exception spécialisée si vous pensez que c'est nécessaire) plutôt que de changer la valeur d'une manière apparemment arbitraire qui n'est pas connue de l'utilisateur.

Contrairement à d'autres commentaires, sur l'ajout de méthodes pour ajouter une soustraction, etc ... puisque vous n'avez pas mentionné le besoin, je suppose que vous ne le faites pas. Et à moins que vous ne construisiez une bibliothèque qui sera vraiment utilisée dans de nombreux endroits ou par d'autres personnes, optez pour YAGNI (vous n'en aurez pas besoin, donc elle ne devrait pas être là.)

Beska
la source
Le fait qu'il ait getNumerator () et getDenominator () m'a amené à croire qu'il créait de nouvelles fractions EN DEHORS de cette classe. Cette logique appartient probablement ici si elle existe.
Programmeur hors
+1 Changer silencieusement de 0 à 1 dans le dénominateur est une recette pour le désastre.
maaartinus
4

Il existe plusieurs façons d'améliorer ce type de valeur ou tout autre type de valeur:

  • Rendez votre classe immuable , y compris en définissant le numérateur et le dénominateur
  • Convertir automatiquement les fractions en une forme canonique , par exemple 2/4 -> 1/2
  • Implémenter toString ()
  • Implémentez "Public static Fraction valueOf (String s)" pour convertir des chaînes en fractions. Implémentez des méthodes d'usine similaires pour la conversion de int, double, etc.
  • Mettre en œuvre l'addition, la multiplication, etc.
  • Ajouter un constructeur à partir de nombres entiers
  • Remplacer equals / hashCode
  • Envisagez de faire de Fraction une interface avec une implémentation qui bascule vers BigInteger si nécessaire
  • Envisagez de sous-classer le nombre
  • Envisagez d'inclure des constantes nommées pour les valeurs courantes telles que 0 et 1
  • Pensez à le rendre sérialisable
  • Test de division par zéro
  • Documentez votre API

En gros, jetez un œil à l'API pour d'autres classes de valeur comme Double , Integer et faites ce qu'elles font :)

Dave Ray
la source
3

Si vous multipliez le numérateur et le dénominateur d'une fraction par le dénominateur de l'autre et vice versa, vous vous retrouvez avec deux fractions (qui sont toujours les mêmes valeurs) avec le même dénominateur et vous pouvez comparer les numérateurs directement. Par conséquent, vous n'avez pas besoin de calculer la valeur double:

public int compareTo(Fraction frac) {
    int t = this.numerator * frac.getDenominator();
    int f = frac.getNumerator() * this.denominator;
    if(t>f) return 1;
    if(f>t) return -1;
    return 0;
}
Francisco Canedo
la source
Cela échoue si frac.getDenominator () et this.denominator ont des signes opposés. (Voir mon post.) Il faut aussi faire attention au fait que la multiplication peut déborder.
Jason S
Ah oui, c'est vrai. Mais dans ce cas, je préfère l'implémentation de Kip, que je peux au moins comprendre. ;)
Francisco Canedo
Je précise que dans ma mise en œuvre, seul le numérateur peut être négatif. J'utilise aussi BigIntegers donc il n'y aura jamais de débordement (au détriment de certaines performances, bien sûr).
Kip
2

comment j'améliorerais ce code:

  1. un constructeur basé sur String Fraction (String s) // attendez "nombre / nombre"
  2. un constructeur de copie Fraction (copie de fraction)
  3. remplacer la méthode de clonage
  4. implémente les méthodes equals, toString et hashcode
  5. implémente l'interface java.io.Serializable, Comparable
  6. une méthode "double getDoubleValue ()"
  7. une méthode add / divide / etc ...
  8. Je rendrais cette classe immuable (pas de setters)
Pierre
la source
Une jolie liste. Il n'y a probablement pas besoin de cloner / sérialisable mais tout le reste est raisonnable.
Programmeur hors
@OutlawProgrammer: Oui, 8 ou 3. Un immuable clonable est un non-sens.
maaartinus
2

Vous avez déjà une fonction compareTo ... J'implémenterais l'interface Comparable.

Cependant, peu importe ce que vous allez en faire.

Dave Costa
la source
2

Si vous vous sentez aventureux, jetez un œil à JScience . Il a une Rationalclasse qui représente des fractions.

Zach Scrivena
la source
2

Plus précisément : existe-t-il une meilleure façon de gérer le fait de passer un dénominateur nul? Définir le dénominateur à 1 est très arbitraire. Comment puis-je faire ça correctement?

Je dirais de lancer une ArithmeticException pour diviser par zéro, car c'est vraiment ce qui se passe:

public Fraction(int numerator, int denominator) {
    if(denominator == 0)
        throw new ArithmeticException("Divide by zero.");
    this.numerator = numerator;
    this.denominator = denominator;
}

Au lieu de «Diviser par zéro», vous pouvez faire en sorte que le message dise «Diviser par zéro: le dénominateur de la fraction est zéro».

Kip
la source
1

Une fois que vous avez créé un objet fraction, pourquoi voudriez-vous autoriser d'autres objets à définir le numérateur ou le dénominateur? Je pense que ceux-ci devraient être en lecture seule. Cela rend l'objet immuable ...

Aussi ... définir le dénominateur à zéro devrait lancer une exception d'argument non valide (je ne sais pas ce que c'est en Java)

Jason Punyon
la source
Ou lancez une nouvelle ArithmeticException ("Divide by zero.")
Kip le
1

Timothy Budd a une belle implémentation d'une classe Rational dans ses "Structures de données en C ++". Langage différent, bien sûr, mais il porte très bien sur Java.

Je recommanderais plus de constructeurs. Un constructeur par défaut aurait numérateur 0, dénominateur 1. Un seul constructeur arg supposerait un dénominateur de 1. Pensez à la manière dont vos utilisateurs pourraient utiliser cette classe.

Pas de chèque pour le dénominateur zéro? La programmation par contrat vous obligerait à l'ajouter.

duffymo
la source
1

Je vais troisième ou cinquième ou quelle que soit la recommandation pour rendre votre fraction immuable. Je vous recommande également d'étendre la classe Number . Je regarderais probablement la classe Double , car vous allez probablement vouloir implémenter plusieurs des mêmes méthodes.

Vous devriez probablement également implémenter Comparable et Serializable puisque ce comportement sera probablement attendu. Ainsi, vous devrez implémenter compareTo (). Vous devrez également surcharger equals () et je ne saurais trop insister sur le fait que vous surchargez également hashCode (). C'est peut-être l'un des rares cas où vous ne voulez pas que compareTo () et equals () soient cohérents car les fractions réductibles l'une à l'autre ne sont pas nécessairement égales.

James
la source
1

Une pratique de nettoyage que j'aime est de n'avoir qu'un seul retour.

 public int compareTo(Fraction frac) {
        int result = 0
        double t = this.doubleValue();
        double f = frac.doubleValue();
        if(t>f) 
           result = 1;
        else if(f>t) 
           result -1;
        return result;
    }
Milhous
la source
1

Utilisez la classe Rational de la bibliothèque JScience . C'est la meilleure chose que j'ai vue pour l'arithmétique fractionnaire en Java.

Alexandre Temerev
la source
1

J'ai nettoyé la réponse de Cletus :

  • Ajout de Javadoc pour toutes les méthodes.
  • Ajout de vérifications pour les conditions préalables de la méthode.
  • Remplacement de l'analyse personnalisée valueOf(String)par le BigInteger(String)qui est à la fois plus flexible et plus rapide.
import com.google.common.base.Splitter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.List;
import java.util.Objects;
import org.bitbucket.cowwoc.preconditions.Preconditions;

/**
 * A rational fraction, represented by {@code numerator / denominator}.
 * <p>
 * This implementation is based on <a
 * href="https://stackoverflow.com/a/474577/14731">https://stackoverflow.com/a/474577/14731</a>
 * <p>
 * @author Gili Tzabari
 */
public final class BigRational extends Number implements Comparable<BigRational>
{
    private static final long serialVersionUID = 0L;
    public static final BigRational ZERO = new BigRational(BigInteger.ZERO, BigInteger.ONE);
    public static final BigRational ONE = new BigRational(BigInteger.ONE, BigInteger.ONE);

    /**
     * Ensures the fraction the denominator is positive and optionally divides the numerator and
     * denominator by the greatest common factor.
     * <p>
     * @param numerator   a numerator
     * @param denominator a denominator
     * @param checkGcd    true if the numerator and denominator should be divided by the greatest
     *                    common factor
     * @return the canonical representation of the rational fraction
     */
    private static BigRational canonical(BigInteger numerator, BigInteger denominator,
        boolean checkGcd)
    {
        assert (numerator != null);
        assert (denominator != null);
        if (denominator.signum() == 0)
            throw new IllegalArgumentException("denominator is zero");
        if (numerator.signum() == 0)
            return ZERO;
        BigInteger newNumerator = numerator;
        BigInteger newDenominator = denominator;
        if (newDenominator.signum() < 0)
        {
            newNumerator = newNumerator.negate();
            newDenominator = newDenominator.negate();
        }
        if (checkGcd)
        {
            BigInteger gcd = newNumerator.gcd(newDenominator);
            if (!gcd.equals(BigInteger.ONE))
            {
                newNumerator = newNumerator.divide(gcd);
                newDenominator = newDenominator.divide(gcd);
            }
        }
        return new BigRational(newNumerator, newDenominator);
    }

    /**
     * @param numerator   a numerator
     * @param denominator a denominator
     * @return a BigRational having value {@code numerator / denominator}
     * @throws NullPointerException if numerator or denominator are null
     */
    public static BigRational valueOf(BigInteger numerator, BigInteger denominator)
    {
        Preconditions.requireThat(numerator, "numerator").isNotNull();
        Preconditions.requireThat(denominator, "denominator").isNotNull();
        return canonical(numerator, denominator, true);
    }

    /**
     * @param numerator   a numerator
     * @param denominator a denominator
     * @return a BigRational having value {@code numerator / denominator}
     */
    public static BigRational valueOf(long numerator, long denominator)
    {
        BigInteger bigNumerator = BigInteger.valueOf(numerator);
        BigInteger bigDenominator = BigInteger.valueOf(denominator);
        return canonical(bigNumerator, bigDenominator, true);
    }

    /**
     * @param value the parameter value
     * @param name  the parameter name
     * @return the BigInteger representation of the parameter
     * @throws NumberFormatException if value is not a valid representation of BigInteger
     */
    private static BigInteger requireBigInteger(String value, String name)
        throws NumberFormatException
    {
        try
        {
            return new BigInteger(value);
        }
        catch (NumberFormatException e)
        {
            throw (NumberFormatException) new NumberFormatException("Invalid " + name + ": " + value).
                initCause(e);
        }
    }

    /**
     * @param numerator   a numerator
     * @param denominator a denominator
     * @return a BigRational having value {@code numerator / denominator}
     * @throws NullPointerException     if numerator or denominator are null
     * @throws IllegalArgumentException if numerator or denominator are empty
     * @throws NumberFormatException    if numerator or denominator are not a valid representation of
     *                                  BigDecimal
     */
    public static BigRational valueOf(String numerator, String denominator)
        throws NullPointerException, IllegalArgumentException, NumberFormatException
    {
        Preconditions.requireThat(numerator, "numerator").isNotNull().isNotEmpty();
        Preconditions.requireThat(denominator, "denominator").isNotNull().isNotEmpty();
        BigInteger bigNumerator = requireBigInteger(numerator, "numerator");
        BigInteger bigDenominator = requireBigInteger(denominator, "denominator");
        return canonical(bigNumerator, bigDenominator, true);
    }

    /**
     * @param value a string representation of a rational fraction (e.g. "12.34e5" or "3/4")
     * @return a BigRational representation of the String
     * @throws NullPointerException     if value is null
     * @throws IllegalArgumentException if value is empty
     * @throws NumberFormatException    if numerator or denominator are not a valid representation of
     *                                  BigDecimal
     */
    public static BigRational valueOf(String value)
        throws NullPointerException, IllegalArgumentException, NumberFormatException
    {
        Preconditions.requireThat(value, "value").isNotNull().isNotEmpty();
        List<String> fractionParts = Splitter.on('/').splitToList(value);
        if (fractionParts.size() == 1)
            return valueOfRational(value);
        if (fractionParts.size() == 2)
            return BigRational.valueOf(fractionParts.get(0), fractionParts.get(1));
        throw new IllegalArgumentException("Too many slashes: " + value);
    }

    /**
     * @param value a string representation of a rational fraction (e.g. "12.34e5")
     * @return a BigRational representation of the String
     * @throws NullPointerException     if value is null
     * @throws IllegalArgumentException if value is empty
     * @throws NumberFormatException    if numerator or denominator are not a valid representation of
     *                                  BigDecimal
     */
    private static BigRational valueOfRational(String value)
        throws NullPointerException, IllegalArgumentException, NumberFormatException
    {
        Preconditions.requireThat(value, "value").isNotNull().isNotEmpty();
        BigDecimal bigDecimal = new BigDecimal(value);
        int scale = bigDecimal.scale();
        BigInteger numerator = bigDecimal.unscaledValue();
        BigInteger denominator;
        if (scale > 0)
            denominator = BigInteger.TEN.pow(scale);
        else
        {
            numerator = numerator.multiply(BigInteger.TEN.pow(-scale));
            denominator = BigInteger.ONE;
        }

        return canonical(numerator, denominator, true);
    }

    private final BigInteger numerator;
    private final BigInteger denominator;

    /**
     * @param numerator   the numerator
     * @param denominator the denominator
     * @throws NullPointerException if numerator or denominator are null
     */
    private BigRational(BigInteger numerator, BigInteger denominator)
    {
        Preconditions.requireThat(numerator, "numerator").isNotNull();
        Preconditions.requireThat(denominator, "denominator").isNotNull();
        this.numerator = numerator;
        this.denominator = denominator;
    }

    /**
     * @return the numerator
     */
    public BigInteger getNumerator()
    {
        return numerator;
    }

    /**
     * @return the denominator
     */
    public BigInteger getDenominator()
    {
        return denominator;
    }

    @Override
    @SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
    public int compareTo(BigRational other)
    {
        Preconditions.requireThat(other, "other").isNotNull();

        // canonical() ensures denominator is positive
        if (numerator.signum() != other.numerator.signum())
            return numerator.signum() - other.numerator.signum();

        // Set the denominator to a common multiple before comparing the numerators
        BigInteger first = numerator.multiply(other.denominator);
        BigInteger second = other.numerator.multiply(denominator);
        return first.compareTo(second);
    }

    /**
     * @param other another rational fraction
     * @return the result of adding this object to {@code other}
     * @throws NullPointerException if other is null
     */
    @SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
    public BigRational add(BigRational other)
    {
        Preconditions.requireThat(other, "other").isNotNull();
        if (other.numerator.signum() == 0)
            return this;
        if (numerator.signum() == 0)
            return other;
        if (denominator.equals(other.denominator))
            return new BigRational(numerator.add(other.numerator), denominator);
        return canonical(numerator.multiply(other.denominator).
            add(other.numerator.multiply(denominator)),
            denominator.multiply(other.denominator), true);
    }

    /**
     * @param other another rational fraction
     * @return the result of subtracting {@code other} from this object
     * @throws NullPointerException if other is null
     */
    @SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
    public BigRational subtract(BigRational other)
    {
        return add(other.negate());
    }

    /**
     * @param other another rational fraction
     * @return the result of multiplying this object by {@code other}
     * @throws NullPointerException if other is null
     */
    @SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
    public BigRational multiply(BigRational other)
    {
        Preconditions.requireThat(other, "other").isNotNull();
        if (numerator.signum() == 0 || other.numerator.signum() == 0)
            return ZERO;
        if (numerator.equals(other.denominator))
            return canonical(other.numerator, denominator, true);
        if (other.numerator.equals(denominator))
            return canonical(numerator, other.denominator, true);
        if (numerator.negate().equals(other.denominator))
            return canonical(other.numerator.negate(), denominator, true);
        if (other.numerator.negate().equals(denominator))
            return canonical(numerator.negate(), other.denominator, true);
        return canonical(numerator.multiply(other.numerator), denominator.multiply(other.denominator),
            true);
    }

    /**
     * @param other another rational fraction
     * @return the result of dividing this object by {@code other}
     * @throws NullPointerException if other is null
     */
    public BigRational divide(BigRational other)
    {
        return multiply(other.invert());
    }

    /**
     * @return true if the object is a whole number
     */
    public boolean isInteger()
    {
        return numerator.signum() == 0 || denominator.equals(BigInteger.ONE);
    }

    /**
     * Returns a BigRational whose value is (-this).
     * <p>
     * @return -this
     */
    public BigRational negate()
    {
        return new BigRational(numerator.negate(), denominator);
    }

    /**
     * @return a rational fraction with the numerator and denominator swapped
     */
    public BigRational invert()
    {
        return canonical(denominator, numerator, false);
    }

    /**
     * @return the absolute value of this {@code BigRational}
     */
    public BigRational abs()
    {
        if (numerator.signum() < 0)
            return negate();
        return this;
    }

    /**
     * @param exponent exponent to which both numerator and denominator is to be raised.
     * @return a BigRational whose value is (this<sup>exponent</sup>).
     */
    public BigRational pow(int exponent)
    {
        return canonical(numerator.pow(exponent), denominator.pow(exponent), true);
    }

    /**
     * @param other another rational fraction
     * @return the minimum of this object and the other fraction
     */
    public BigRational min(BigRational other)
    {
        if (compareTo(other) <= 0)
            return this;
        return other;
    }

    /**
     * @param other another rational fraction
     * @return the maximum of this object and the other fraction
     */
    public BigRational max(BigRational other)
    {
        if (compareTo(other) >= 0)
            return this;
        return other;
    }

    /**
     * @param scale        scale of the BigDecimal quotient to be returned
     * @param roundingMode the rounding mode to apply
     * @return a BigDecimal representation of this object
     * @throws NullPointerException if roundingMode is null
     */
    public BigDecimal toBigDecimal(int scale, RoundingMode roundingMode)
    {
        Preconditions.requireThat(roundingMode, "roundingMode").isNotNull();
        if (isInteger())
            return new BigDecimal(numerator);
        return new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
    }

    @Override
    public int intValue()
    {
        return (int) longValue();
    }

    @Override
    public long longValue()
    {
        if (isInteger())
            return numerator.longValue();
        return numerator.divide(denominator).longValue();
    }

    @Override
    public float floatValue()
    {
        return (float) doubleValue();
    }

    @Override
    public double doubleValue()
    {
        if (isInteger())
            return numerator.doubleValue();
        return numerator.doubleValue() / denominator.doubleValue();
    }

    @Override
    @SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
    public boolean equals(Object o)
    {
        if (this == o)
            return true;
        if (!(o instanceof BigRational))
            return false;
        BigRational other = (BigRational) o;

        return numerator.equals(other.denominator) && Objects.equals(denominator, other.denominator);
    }

    @Override
    public int hashCode()
    {
        return Objects.hash(numerator, denominator);
    }

    /**
     * Returns the String representation: {@code numerator / denominator}.
     */
    @Override
    public String toString()
    {
        if (isInteger())
            return String.format("%,d", numerator);
        return String.format("%,d / %,d", numerator, denominator);
    }
}
Gili
la source
0

Remarque initiale:

N'écrivez jamais ceci:

if ( condition ) statement;

Ceci est vraiment mieux

if ( condition ) { statement };

Créez simplement pour créer une bonne habitude.

En rendant la classe immuable comme suggéré, vous pouvez également profiter du double pour effectuer les opérations equals et hashCode et compareTo

Voici ma version rapide et sale:

public final class Fraction implements Comparable {

    private final int numerator;
    private final int denominator;
    private final Double internal;

    public static Fraction createFraction( int numerator, int denominator ) { 
        return new Fraction( numerator, denominator );
    }

    private Fraction(int numerator, int denominator) {
        this.numerator   = numerator;
        this.denominator = denominator;
        this.internal = ((double) numerator)/((double) denominator);
    }


    public int getNumerator() {
        return this.numerator;
    }

    public int getDenominator() {
        return this.denominator;
    }


    private double doubleValue() {
        return internal;
    }

    public int compareTo( Object o ) {
        if ( o instanceof Fraction ) { 
            return internal.compareTo( ((Fraction)o).internal );
        }
        return 1;
    }

    public boolean equals( Object o ) {
          if ( o instanceof Fraction ) {  
             return this.internal.equals( ((Fraction)o).internal );
          } 
          return false;
    }

    public int hashCode() { 
        return internal.hashCode();
    }



    public String toString() { 
        return String.format("%d/%d", numerator, denominator );
    }

    public static void main( String [] args ) { 
        System.out.println( Fraction.createFraction( 1 , 2 ) ) ;
        System.out.println( Fraction.createFraction( 1 , 2 ).hashCode() ) ;
        System.out.println( Fraction.createFraction( 1 , 2 ).compareTo( Fraction.createFraction(2,4) ) ) ;
        System.out.println( Fraction.createFraction( 1 , 2 ).equals( Fraction.createFraction(4,8) ) ) ;
        System.out.println( Fraction.createFraction( 3 , 9 ).equals( Fraction.createFraction(1,3) ) ) ;
    }       

}

À propos de la méthode de fabrique statique, cela peut être utile plus tard, si vous sous-classez la Fraction pour gérer des choses plus complexes, ou si vous décidez d'utiliser un pool pour les objets les plus fréquemment utilisés.

Ce n'est peut-être pas le cas, je voulais juste le souligner. :)

Voir le premier élément Java efficace .

OscarRyz
la source
0

Cela pourrait être utile pour ajouter des choses simples comme rendre la pareille, obtenir du reste et se guérir.

Dark Joshua
la source
cette réponse convient comme commentaire.
Jasonw
Terrible désolé pour la réponse tardive mais je pense qu'il y a un minimum de représentants (50?) Nécessaire pour commenter une réponse que je n'ai pas ...
Darth Joshua
0

Même si vous disposez des méthodes compareTo (), si vous souhaitez utiliser des utilitaires comme Collections.sort (), vous devez également implémenter Comparable.

public class Fraction extends Number implements Comparable<Fraction> {
 ...
}

Aussi, pour un joli affichage, je recommande de remplacer toString ()

public String toString() {
    return this.getNumerator() + "/" + this.getDenominator();
}

Et enfin, je rendrais la classe publique afin que vous puissiez l'utiliser à partir de différents packages.

Kenny Cason
la source
0

Cette fonction simplifier l'utilisation de l'algorithme euclédien est assez utile lors de la définition des fractions

 public Fraction simplify(){


     int safe;
     int h= Math.max(numerator, denominator);
     int h2 = Math.min(denominator, numerator);

     if (h == 0){

         return new Fraction(1,1);
     }

     while (h>h2 && h2>0){

          h = h - h2;
          if (h>h2){

              safe = h;
              h = h2;
              h2 = safe;

          }  

     }

  return new Fraction(numerator/h,denominator/h);

 }
Brennan
la source
0

Pour une implémentation Fraction / Rational de niveau industriel, je l'implémenterais afin qu'elle puisse représenter NaN, l'infini positif, l'infini négatif et éventuellement le zéro négatif avec une sémantique opérationnelle exactement la même que les états standard IEEE 754 pour l'arithmétique en virgule flottante (cela facilite également la conversion vers / à partir de valeurs à virgule flottante). De plus, comme la comparaison avec zéro, un et les valeurs spéciales ci-dessus ne nécessite qu'une comparaison simple, mais combinée du numérateur et du dénominateur par rapport à 0 et 1 - j'ajouterais plusieurs méthodes isXXX et compareToXXX pour faciliter l'utilisation (par exemple, eq0 () utilisez numérateur == 0 && dénominateur! = 0 dans les coulisses au lieu de laisser le client comparer avec une instance de valeur zéro). Certaines valeurs prédéfinies statiquement (ZERO, ONE, TWO, TEN, ONE_TENTH, NAN, etc.) sont également utiles, puisqu'ils apparaissent à plusieurs endroits comme des valeurs constantes. C'est la meilleure façon IMHO.

Tiamin
la source
0

Fraction de classe:

     public class Fraction {
        private int num;            // numerator 
        private int denom;          // denominator 
        // default constructor
        public Fraction() {}
        // constructor
        public Fraction( int a, int b ) {
            num = a;
            if ( b == 0 )
                throw new ZeroDenomException();
            else
                denom = b;
        }
        // return string representation of ComplexNumber
        @Override
        public String toString() {
            return "( " + num + " / " + denom + " )";
        }
        // the addition operation
        public Fraction add(Fraction x){
            return new Fraction(
                    x.num * denom + x.denom * num, x.denom * denom );
        }
        // the multiplication operation
        public Fraction multiply(Fraction x) {
            return new Fraction(x.num * num, x.denom * denom);
        } 
}

Le programme principal:

    static void main(String[] args){
    Scanner input = new Scanner(System.in);
    System.out.println("Enter numerator and denominator of first fraction");
    int num1 =input.nextInt();
    int denom1 =input.nextInt();
    Fraction x = new Fraction(num1, denom1);
    System.out.println("Enter numerator and denominator of second fraction");
    int num2 =input.nextInt();
    int denom2 =input.nextInt();
    Fraction y = new Fraction(num2, denom2);
    Fraction result = new Fraction();
    System.out.println("Enter required operation: A (Add), M (Multiply)");
    char op = input.next().charAt(0);
    if(op == 'A') {
        result = x.add(y);
        System.out.println(x + " + " + y + " = " + result);
    }
BasmaSH
la source