public static Fraction multiply(Fraction a, Fraction b, Fraction... fractions) { Fraction result = Fraction.multiply(a, b); for (Fraction c : fractions) { result = Fraction.multiply(result, c); } return result; }
Fraction divide(Fraction y) { Fraction z = new Fraction(); z.numerator = numerator.multiply(y.denominator); z.denominator = denominator.multiply(y.numerator); z.simplify(); return z; }
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int numerator, denominator; try { System.out.print("Numerator: "); numerator = sc.nextInt(); System.out.print("Denominator: "); denominator = sc.nextInt(); } catch (InputMismatchException e) { System.out.println("That's not an integer!"); sc.close(); return; } sc.close(); if (denominator == 0) { System.out.println("You can't have a denominator of 0!"); return; } Fraction frac = new Fraction(numerator, denominator); System.out.println("Fraction is " + frac); System.out.println("Value is " + frac.getValue()); System.out.println("Reducing..."); frac.reduce(); System.out.println("Reduced fraction is " + frac); System.out.println("Reduced value is still " + frac.getValue()); }
@Test public void testSimplify() { Fraction a = new Fraction(2, 4); a = a.simplify(); assertEquals(a, (new Fraction(1, 2))); assertTrue(a.toValue() == 0.5); }
public static Fraction subtract(Fraction a, Fraction b, Fraction... fractions) { Fraction result = Fraction.subtract(a, b); for (Fraction c : fractions) { result = Fraction.subtract(result, c); } return result; }
public Fraction multiplication(Fraction f) { Fraction mul = new Fraction(); int num = numerator * f.getNumerator(); mul.setNumerator(num); int den = denominator * f.getDenominator(); mul.setDenominator(den); return mul; }
public Fraction division(Fraction f) { Fraction div = new Fraction(); int num = numerator * f.getDenominator(); div.setNumerator(num); int den = denominator * f.getNumerator(); div.setDenominator(den); return div; }
/** Return the sum of the elements in the array. Return 0/1 if the length of the array is 0. */ public static final Fraction sum(Fraction[] array) { Fraction sum = new Fraction(0, 1); for (Fraction element : array) { sum = sum.add(element); } return sum; }
Fraction subtract(Fraction y) { Fraction z = new Fraction(); gcd = denominator.gcd(y.denominator); z.denominator = denominator.multiply(y.denominator).divide(gcd); z.numerator = numerator.multiply(z.denominator.divide(denominator)) .subtract(y.numerator.multiply(z.denominator.divide(y.denominator))); z.simplify(); return z; }
public static void main(String[] args) throws Exception { PrintWriter pen = new PrintWriter(System.out, true); Fraction f1; f1 = new Fraction(3, 10); Fraction f2; f2 = new Fraction(2, 5); pen.println("First fraction: " + f1); pen.println("Second fraction: " + f2); pen.println("Sum: " + (f1.add(f2))); } // main(String[])
/** * Subtrahiert 2 Br�che miteinander. * * @param subtrahend Der Subtrahend (2. Zahl, mit der der Bruch Subtrahiert wird). * @return Ein neuen Bruch, wo beide Br�che Addiert werden. * @throws FractionException Wird geworfen, wenn der neue Bruch eine 0 enth�lt. * @throws MathException Wird geworfen, wenn nenner und z�hler ungleich sind. */ public Fraction subtract(Fraction subtrahend) throws FractionException, MathException { if (subtrahend.getDenominator() == this.getDenominator()) { numerator = this.getNumerator() - subtrahend.getNumerator(); denominator = this.getDenominator(); return new Fraction(numerator, denominator); } throw new MathException("Die beiden Nenner m�ssen gleich sein!"); }
public boolean equals(Fraction F) { int newNumerator = numeratorV; int newDenominator = denominatorV; int newNumerator1 = F.getNumerator(); int newDenominator1 = F.getDenominator(); if (newNumerator != newNumerator1 || newDenominator != newDenominator1) { return false; } else { return true; } }
/** * Return the dot product of the two arrays. If the lengths of the array are both 0, return 0/1. * If the two arrays do not have the same length, throw an IllegalArgumentException. */ public static final Fraction dotProduct(final Fraction[] array1, final Fraction[] array2) { int length = _commonLength(array1, array2, "FractionArrayMath.dotProduct"); Fraction sum = new Fraction(0, 1); for (int i = 0; i < length; i++) { sum = sum.add(array1[i].multiply(array2[i])); } return sum; }
/** * Addiert 2 Br�che miteinander Es k�nnen nur Br�che miteinander Multipliziert werden, wenn die * Z�hler gleich sein! * * @param summand2 Den Wert, mit dem der Bruch Addiert werden soll. * @return Ein neuen Bruch, wo beide Br�che Addiert werden. * @throws FractionException Wird geworfen, wenn der neue Bruch eine 0 enth�lt. * @throws MathException Wird geworfen, wenn nenner und z�hler ungleich sind. */ public Fraction addition(Fraction summand2) throws FractionException, MathException { int numerator; int denominator; if (summand2.getDenominator() == this.getDenominator()) { numerator = summand2.getNumerator() + this.getNumerator(); denominator = this.getDenominator(); return new Fraction(numerator, denominator).trim(); } throw new MathException("Die beiden Nenner m�ssen gleich sein!"); }
static ArrayList<Integer> continuedFraction(int num) { ArrayList<Integer> continuedFraction = new ArrayList<Integer>(); HashSet<Fraction> previousStates = new HashSet<Fraction>(); int maxRoot = (int) (Math.sqrt(num)); Fraction fraction = new Fraction(1, 0, 1, maxRoot * (-1), num); while (true) { previousStates.add(fraction); continuedFraction.add(fraction.nextInt()); if (previousStates.contains(fraction)) break; } return continuedFraction; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Fraction fraction = (Fraction) o; if (getDenominator() != fraction.getDenominator()) return false; if (getNumerator() != fraction.getNumerator()) return false; return true; }
/** * (Subtracts the two fractions) * * @param (fraction the operation is being applied to) * @return (output fraction) */ public Fraction minus(Fraction f) { // subtracts 2 fractions and returns reduce fraction result if (f.den != den) { f.num *= den; num *= f.den; f.den *= den; den = f.den; } f.num -= num; f.reduce(); return f; }
/** * (Adds the two fractions) * * @param (fraction the operation is being applied to) * @return (output fraction) */ public Fraction plus(Fraction f) { // adds 2 fractions and returns reduce fraction result if (f.den != den) { f.num *= den; num *= f.den; f.den *= den; den = f.den; } f.num += num; f.reduce(); return f; }
Fraction abs() { Fraction z = new Fraction(); if (numerator.compareTo(BigInteger.ZERO) < 0) { z.numerator = numerator.negate(); } else { z.numerator = numerator; } if (denominator.compareTo(BigInteger.ZERO) < 0) { z.denominator = denominator.negate(); } else { z.denominator = denominator; } return z; }
public Fraction subtract(Fraction other) { // int newNum = num * other.denom - denom * other.num; // int newDenom = denom * other.denom; // return new Fraction(newNum, newDenom); return add(other.negate()); }
public static void main(String[] args) { /* Define Numerator and Denominators */ // Fraction 1 int fraction1num = 3; int fraction1den = 5; // Fraction 2 int fraction2num = 1; int fraction2den = 2; /* Define Fractions */ // Fraction 1 Fraction fraction1 = new Fraction(fraction1num, fraction1den); // Fraction 2 Fraction fraction2 = new Fraction(fraction2num, fraction2den); /* Print Arithmetic Tests */ // Fraction 1 + Fraction 2 Fraction addedFraction = new Fraction(fraction1.addFrac(fraction2)); System.out.print("Addition:\n " + fraction1 + " + " + fraction2 + " = " + addedFraction + "\n"); // Fraction 1 - Fraction 2 Fraction subtractedFraction = new Fraction(fraction1.subFrac(fraction2)); System.out.print( "Subtraction:\n " + fraction1 + " - " + fraction2 + " = " + subtractedFraction + "\n"); // Fraction 1 * Fraction 2 Fraction multipliedFraction = new Fraction(fraction1.multFrac(fraction2)); System.out.print( "Multiplication:\n " + fraction1 + " * " + fraction2 + " = " + multipliedFraction + "\n"); // Fraction 1 / Fraction 2 Fraction dividedFraction = new Fraction(fraction1.divFrac(fraction2)); System.out.print( "Division:\n " + fraction1 + " / " + fraction2 + " = " + dividedFraction + "\n"); }
public static void main(String args[]){ Scanner in=new Scanner(System.in); String op=null; while(in.hasNext()){ String line=in.nextLine(); StringTokenizer token=new StringTokenizer(line,"/+-",true); int i=0; String data[]=new String[token.countTokens()]; while(token.hasMoreTokens()) { data[i]=token.nextToken(); i++; } Fraction a=new Fraction(); Fraction b=new Fraction(); Fraction c=new Fraction(); Fraction d=new Fraction(); a.set(data[0],data[2]); b.set(data[4],data[6]); if(data[3].equals("+")) a.add(b).print(); else a.subtract(b).print(); } }
public Fraction subtraction(Fraction f) { Fraction sub = new Fraction(); int num = numerator * f.getDenominator() - f.getNumerator() * denominator; sub.setNumerator(num); int den = denominator * f.getDenominator(); sub.setDenominator(den); return sub; }
// <MATH Section> public Fraction addition(Fraction f) { Fraction add = new Fraction(); int num = numerator * f.getDenominator() + f.getNumerator() * denominator; add.setNumerator(num); int den = denominator * f.getDenominator(); add.setDenominator(den); return add; }
public static void main(String[] args) { Fraction f1 = new Fraction(); Fraction f2 = new Fraction(); for (int i = 1; i <= 4; i++) { f1.numerator = 1; f1.denominator = 2; f2.numerator = 3; f2.denominator = 4; switch (i) { case 1: System.out.println("f1=" + f1.numerator + "/" + f1.denominator); System.out.println("f2=" + f2.numerator + "/" + f2.denominator); f1.add(f2); System.out.println("f1+f2=" + f1.numerator + "/" + f1.denominator); break; case 2: f1.add(3); System.out.println("f1+3=" + f1.numerator + "/" + f1.denominator); break; case 3: f2.sub(f1); System.out.println("f2-f1=" + f2.numerator + "/" + f2.denominator); break; case 4: f2.sub(1); System.out.println("f2-1=" + f2.numerator + "/" + f2.denominator); break; } } }
// f : 分数 // k : 分解個数 // prev : 直前に選択した単位分数の分母 // pow : それまでの単位分数の分母の積 int search(Fraction f, int k, int prev, int pow) { if (pow > a) return 0; // System.out.println(f.p + "/" + f.q + ", k = " + k + ", prev = " + prev + ", pow = " + pow); if (k > n) { return 0; } if (f.p == 0) { // System.out.println("find"); return 1; } int count = 0; for (int i = prev; pow * i <= a; i++) { Fraction _f = f.sub(new Fraction(1, i)); if (_f.p < 0) continue; count += search(_f, k + 1, i, pow * i); } return count; }
@Override public void Run(String[] args) throws Exception { int finalNum = 1; int finalDenom = 1; for (int denom = 10; denom < 100; denom++) { for (int num = 10; num < denom; num++) { if (isDigitCancelling(num, denom)) { Fraction frac = new Fraction(num, denom); frac = frac.getReducedFraction(); finalNum *= frac.getNumerator(); finalDenom *= frac.getDenominator(); } } } Fraction finalFrac = new Fraction(finalNum, finalDenom); finalFrac = finalFrac.getReducedFraction(); int result = finalFrac.getDenominator(); System.out.println(Integer.toString(result)); }
/** * Dividiert die beiden Br�che miteinander. * * @param divisor Der Divisor (2. Zahl, mit der der Bruch Division wird.) * @return Ein neuer Bruch, wo beide Br�che Multipliziert werden. * @throws FractionException Wird geworfen, wenn ein neuer Bruch eine 0 enth�lt. */ public Fraction division(Fraction divisor) throws FractionException { Fraction reciprocalValue = new Fraction(divisor.getDenominator(), divisor.getNumerator()); return multiplicat(reciprocalValue).trim(); }
@Test public void testDivide() { assertEquals(myFraction1.divide(myFraction2).toString(), "4 / 3"); assertEquals(myFraction3.divide(myFraction4).toString(), "5 / 2"); myFraction1 = myFraction1.add(myFraction1); }
/** * Multipliziert die beiden Br�che miteinander. * * @param multiplier Der Multiplikator (2. Zahl, mit der der Bruch Multipliziert wird.) * @return Ein neuer Burch, wo beide Br�che Multipliziert werden. * @throws FractionException Wird geworfen, wenn der neue Bruch eine 0 enth�lt. */ public Fraction multiplicat(Fraction multiplier) throws FractionException { int numerator = multiplier.getNumerator() * this.getNumerator(); int denominator = multiplier.getDenominator() * this.getDenominator(); return new Fraction(numerator, denominator).trim(); }