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();
}
