أفضل طريقة لتمثيل جزء في جافا ؟
https://stackoverflow.com/questions/474535
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
أنا أحاول أن أعمل مع الكسور في جافا.
أريد أن تنفذ وظائف حسابية.لهذا سوف تحتاج أولا إلى طريقة تطبيع وظائف.أعرف أني لا أستطيع إضافة 1/6 1/2 حتى يكون هناك قاسم مشترك.وسوف تضطر إلى إضافة 1/6 و 3/6.ساذجة النهج قد أضيف 2/12 و 6/12 ثم الحد.كيف يمكنني تحقيق قاسم مشترك مع أقل أداء عقوبة ؟ ما الخوارزمية هو أفضل من هذا ؟
الإصدار 8 (بفضل hstoerr):
وتشمل التحسينات:
- يساوي() الأسلوب هو الآن يتفق مع 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;
}
}
يجب إزالة كافة الإصدارات السابقة.شكري:
المحلول
انها مجرد أن ذلك يحدث أن كتبت BigFraction الدرجة منذ وقت ليس ببعيد ، المشروع يولر مشاكل.فإنه يحتفظ BigInteger البسط والمقام ، لذلك لن تجاوز.ولكن سيكون صبي بطيئة عن الكثير من العمليات التي تعرف أبدا تجاوز..على كل حال استخدامه إذا كنت تريد ذلك.كنت أتوق إلى إظهار هذا بطريقة أو بأخرى.:)
تحرير:أحدث إصدار من هذا القانون ، بما في ذلك وحدة الاختبارات الآن استضافتها على جيثب و أيضا متاحة عبر مخضرم المركزي.وأنا أغادر بلدي الأصلي رمز هنا حيث أن هذا الجواب ليس مجرد ارتباط...
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;
}
}
}
نصائح أخرى
- تجعل غير قابل للتغيير;
- تجعل الكنسي, بمعنى 6/4 يصبح 3/2 (القاسم المشترك الأكبر الخوارزمية هي مفيدة في هذا) ؛
- نسميها عقلانية ، منذ ما أنت تمثل هي عقلانية عدد;
- هل يمكن استخدام
BigIntegerلتخزين arbitrarilyy-قيم دقة.إذا لم يكن ثمlong, الذي لديه أسهل من التنفيذ ؛ - جعل القاسم إيجابية دائما.التوقيع يجب أن يتم من خلال البسط;
- تمديد
Number; - تنفيذ
Comparable<T>; - تنفيذ
equals()وhashCode(); - إضافة طريقة مصنع لعدد يمثله
String; - إضافة بعض الراحة مصنع الأساليب ؛
- إضافة
toString();و - تجعل
Serializable.
في الواقع, جرب هذا على حجم.فإنه يعمل ولكن قد يكون لها بعض القضايا:
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();
}
}
الناتج هو:
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
أنا أحاول أن أعمل مع السليم الكسور في جاوة.
أباتشي العموم الرياضيات وقد كان جزء الطبقة لبعض الوقت.معظم أوقات إجابة "الصبي أتمنى جافا كان شيئا مثل X في مكتبة الأساسية!" يمكن العثور عليها تحت مظلة أباتشي العموم المكتبة.
يرجى التأكد أنه غير قابل للتغيير نوع!قيمة جزء لا تغيير - نصف لا تصبح ثالث ، على سبيل المثال.بدلا من setDenominator, هل يمكن أن يكون withDenominator والتي ترجع جديد الكسر الذي له نفس البسط ولكن المحدد القاسم.
الحياة كثيرا أسهل مع ثابتة أنواع.
تجاوز يساوي hashcode المعقول أيضا ، لذلك يمكن أن تستخدم في الخرائط مجموعات.تحريم مبرمج نقاط عن العوامل الحسابية و سلسلة التنسيق جيدة جدا.
كدليل عام ، إلقاء نظرة على BigInteger و BigDecimal.انهم لا يفعلون الشيء نفسه لكنهم مماثلة بما فيه الكفاية لتعطيك الأفكار الجيدة.
أولا, أود التخلص من واضعي وجعل الكسور غير قابل للتغيير.
عليك ربما تريد أيضا طرق الجمع والطرح وغيرها ، وربما بعض طريقة للحصول على تمثيل في مختلف سلسلة من الأشكال.
تحرير:كنت على الأرجح علامة على الحقول 'النهائي' للإشارة إلى هدفي ولكن اعتقد انها ليست صفقة كبيرة...
- انها نوع من العبث دون الحساب أساليب مثل إضافة() ومضاعفة () ، الخ.
- يجب عليك بالتأكيد تجاوز يساوي() و hashCode().
- يجب عليك إما إضافة وسيلة لتطبيع الكسر ، أو أن تفعل ذلك تلقائيا.التفكير في ما إذا كنت تريد 1/2 و2 / 4 أن يعتبر نفسه أم لا - وهذا له آثار يساوي(), hashCode() و compareTo() الأساليب.
سوف تحتاج إلى ترتيبها من الأصغر إلى الأكبر ، حتى في نهاية المطاف سوف تحتاج إلى تمثل لهم مزدوجة أيضا
لم يكن ضروريا.(في الواقع إذا كنت ترغب في التعامل مع المساواة بشكل صحيح, لا تعتمد على مضاعفة العمل بشكل صحيح.) إذا ب*د إيجابية ، a/b < ج/د إذا الإعلانية < قبل الميلاد.إذا كان هناك سلبي الاعداد الصحيحه المعنية ، التي يمكن التعامل معها بشكل مناسب...
قد كتابة:
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));
}
استخدام long هنا هو التأكد من أن هناك لا تجاوز إذا ضرب اثنين كبيرة ints.مقبض إذا كنت يمكن أن تضمن أن القاسم هو دائما سالب (إذا كان سلبيا فقط ينفي كل من البسط والمقام), ثم يمكنك الحصول على التخلص من الحاجة إلى التحقق من ما إذا كان ب*د إيجابية وحفظ بضع خطوات.لست متأكدا ما هو السلوك تبحث عنه مع صفر القاسم.
غير متأكد من كيفية أداء يقارن باستخدام الزوجي مقارنة.(هذا إذا كنت الرعاية حول الأداء كثيرا) وهنا طريقة الاختبار استخدمت للتحقق.(يبدو أن تعمل بشكل صحيح.)
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);
}
(p.s.قد تفكر في إعادة هيكلة لتنفيذ Comparable أو Comparator للفئة الخاصة بك.)
واحد طفيفة جدا تحسين يحتمل أن يكون حفظ ضعف القيمة التي كنت الحوسبة بحيث يمكنك فقط حساب على الوصول الأول.هذا لن يكون فوزا كبيرا إلا إذا كنت في الوصول إلى هذا العدد الكثير ، ولكن ليس بشكل مفرط من الصعب القيام به أيضا.
نقطة إضافية واحدة قد يكون خطأ التحقق يمكنك القيام به في المقام...هل تتغير تلقائيا 0 إلى 1.لست متأكدا إذا كان هذا هو الصحيح للتطبيق الخاص بك معين ، ولكن بشكل عام إذا كان شخص ما يحاول القسمة على 0 ، شيء خاطئ جدا.سأترك هذه رمي استثناء (المتخصصة استثناء إذا كنت تشعر أنه مطلوب) بدلا من تغيير القيمة في ما يبدو التعسفي الطريقة ليست معروفة للمستخدم.
في constrast مع بعض التعليقات حول إضافة طرق لإضافة أو طرح الخ...بما أنك لم تذكر الحاجة لهم, أنا على افتراض أنك لا.و إلا إذا كنت بناء مكتبة حقا هو الذهاب إلى استخدامها في العديد من الأماكن أو من قبل أشخاص آخرين ، انتقل مع YAGNI (أنك لن تحتاج إليها ، لذلك ينبغي أن لا يكون هناك....)
هناك عدة طرق لتحسين هذا أو أي نوع القيمة:
- جعل الطبقة غير قابل للتغيير, ، بما في ذلك صنع البسط والمقام النهائي
- تلقائيا تحويل الكسور إلى النموذج المتعارف عليه, مثلا2/4 -> 1/2
- تنفيذ toString()
- تنفيذ "الجمهور ساكنة جزء valueOf(String s)" لتحويل من السلاسل إلى الكسور.تنفيذ مصنع مماثل طرق تحويل من int, double, الخ.
- تنفيذ ذلك الضرب, الخ
- إضافة منشئ من أرقام كاملة
- تجاوز يساوي/hashCode
- النظر في تقديم جزء واجهة مع التنفيذ التي تتحول إلى BigInteger عند الضرورة
- تنظر فرعية تصنف عدد
- بما في ذلك النظر في اسمه الثوابت من أجل القيم المشتركة مثل 0 و 1
- النظر في جعلها serializable
- اختبار القسمة على صفر
- الوثيقة API
في الأساس, نلقي نظرة على API قيمة أخرى مثل الطبقات مزدوج, عدد صحيح و يفعلون ما :)
إذا ضرب البسط والمقام من جزء واحد مع القاسم من الآخر والعكس صحيح ، كنت في نهاية المطاف مع اثنين من الكسور (التي لا تزال نفس القيم) مع نفس المقام و يمكنك مقارنة بسط مباشرة.لذلك أنت لا تحتاج إلى حساب قيمة مزدوجة:
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;
}
كيف يمكنني تحسين هذا الرمز:
- منشئ على أساس سلسلة الكسر(String s) //نتوقع "عدد/عدد"
- نسخة منشئ الكسر(كسر نسخ)
- تجاوز استنساخ طريقة
- تنفذ يساوي ، toString و hashcode
- تنفذ واجهة جافا.io.Serializable ، للمقارنة
- طريقة "مزدوجة getDoubleValue()"
- طريقة إضافة/تقسيم/الخ...
- وأود أن جعل هذا الفصل ثابتة (لا واضعي)
لديك compareTo وظيفة بالفعل ...أود أن تنفيذ واجهة مماثلة.
قد لا يهم حقا على ما أنت ذاهب إلى القيام به مع ذلك.
على وجه التحديد:هل هناك طريقة أفضل للتعامل مع مرت صفر المقام ؟ إعداد القاسم إلى 1 هو شعور عظيم التعسفي.كيف يمكن أن أفعل هذا صحيح ؟
أود أن أقول رمي ArithmeticException عن القسمة على الصفر ، لأن هذا حقا ما يحدث:
public Fraction(int numerator, int denominator) {
if(denominator == 0)
throw new ArithmeticException("Divide by zero.");
this.numerator = numerator;
this.denominator = denominator;
}
بدلا من "القسمة على صفر.", قد ترغب في جعل الرسالة أقول "القسمة على صفر:مقام الكسر هو صفر".
بمجرد إنشاء جزء وجوه لماذا تريد أن تسمح الكائنات الأخرى إلى مجموعة البسط أو المقام ؟ أعتقد أن هذه يجب أن يكون للقراءة فقط.يجعل الكائن غير قابل للتغيير...
أيضا...الإعداد القاسم إلى الصفر يجب رمي وسيطة غير صالحة استثناء (أنا لا أعرف ما هو عليه في جافا)
تيموثي بود يرام تنفيذ الرشيد الدرجة في كتابه "هياكل البيانات في C++".لغة مختلفة ، بالطبع ، ولكن من الموانئ إلى جافا بشكل جيد جدا.
أنصح أكثر المنشئات.منشئ افتراضي قد البسط 0, قاسم 1.واحد arg المنشئ أن نفترض قاسم 1.التفكير في كيف يمكن استخدام هذه الفئة.
لا التحقق من الصفر المقام ؟ البرمجة قبل العقد إضافته.
سوف الثالثة أو الخامسة أو أي توصية لجعل الخاصة بك جزء غير قابل للتغيير.أود أن أوصى أيضا أن لديك تمديد عدد فئة.ربما تبدو في مزدوج فئة ، بما أنك ربما تريد الذهاب إلى تنفيذ العديد من الأساليب نفسها.
ربما يجب عليك أيضا تنفيذ للمقارنة و Serializable لأن هذا السلوك ربما يكون من المتوقع.وبالتالي, سوف تحتاج إلى تنفيذ compareTo().سوف تحتاج أيضا إلى تجاوز يساوي() وأنا لا أستطيع أن أؤكد بما فيه الكفاية بشدة أن يمكنك أيضا تجاوز hashCode().وهذا قد يكون واحدا من عدد قليل من الحالات على الرغم حيث كنت لا تريد compareTo() و يساوي() أن تكون متسقة منذ الكسور reducable بعضها البعض ليست بالضرورة متساوية.
تنظيف الممارسة التي أحب أن يكون واحد فقط العودة.
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;
}
الاستخدام الرشيد فئة من JScience المكتبة.إنه أفضل شيء بالنسبة كسور الحسابية رأيت في جاوة.
أنا تنظيف كليتوس' الجواب:
- وأضاف جافادوك لجميع الطرق.
- وأضاف يتحقق الأسلوب شروط مسبقة.
- محل مخصص في تحليل
valueOf(String)معBigInteger(String)والتي هي على حد سواء أكثر مرونة وأسرع.
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);
}
}
الأولي ملاحظة:
لم أكتب هذا:
if ( condition ) statement;
هذا هو أفضل بكثير
if ( condition ) { statement };
مجرد إنشاء لإنشاء عادة جيدة.
من خلال جعل فئة ثابتة كما اقترح يمكنك أيضا الاستفادة من ضعف أداء يساوي hashCode و compareTo العمليات
هنا هو بلدي سريعة القذرة الإصدار:
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) ) ) ;
}
}
عن طريقة مصنع ثابت ، قد يكون من المفيد في وقت لاحق, إذا كنت فرعية جزء للتعامل مع أشياء أكثر تعقيدا ، أو إذا كنت ترغب في استخدام المسبح الأكثر استخداما الكائنات.
قد لا يكون هذا هو الحال, أنا فقط أردت أن أشير إليه.:)
انظر فعالة جافا البند الأول.
قد يكون من المفيد إضافة أشياء بسيطة مثل بالمثل ، والحصول على الباقي على العموم.
على الرغم من أن لديك طرق compareTo () ، إذا كنت ترغب في الاستفادة من المرافق مثل مجموعات.النوع(), ثم يجب عليك أيضا تنفيذ للمقارنة.
public class Fraction extends Number implements Comparable<Fraction> {
...
}
أيضا ، على حد عرض أوصي تجاوز toString()
public String toString() {
return this.getNumerator() + "/" + this.getDenominator();
}
وأخيرا ، أود أن جعل الطبقة العامة بحيث يمكنك استخدامه من حزم مختلفة.
هذه الوظيفة تبسيط استخدام eucledian خوارزمية مفيد جدا عند تحديد الكسور
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);
}
الصناعة-الصف جزء/الرشيد التنفيذ ، أود أن تنفيذ ذلك حتى أنها يمكن أن تمثل نان ما لا نهاية الإيجابية السلبية ما لا نهاية ، واختياريا السلبي صفر التنفيذية دلالات بالضبط نفس IEEE 754 مستوى الدول النقطة العائمة الحساب (كما يخفف التحويل إلى/من قيم النقطة العائمة).بالإضافة منذ المقارنة إلى صفر, واحد, و خاصة القيم أعلاه يحتاج فقط بسيطة ، ولكن جنبا إلى جنب مقارنة بين البسط والمقام ضد 0 و 1 - أود أن أضيف عدة isXXX و compareToXXX طرق لسهولة الاستخدام (على سبيل المثال.eq0() استخدام البسط == 0 && القاسم != 0 خلف الكواليس بدلا من السماح للعميل مقارنة مقابل صفر الكرام سبيل المثال).بعض بشكل ثابت القيم المعرفة مسبقا (صفر, واحد, اثنين, عشرة, ONE_TENTH نان..... الخ) مفيدة أيضا, لأنها تظهر في أماكن عدة من القيم الثابتة.هذا هو أفضل وسيلة IMHO.
فئة الكسر:
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);
}
}
البرنامج الرئيسي:
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);
}
لا تنتمي إلى StackOverflow
