Fraction issues on calculating less than % gcd on negative numbers

[Tate Hsumsor]

Hi guys

I've been writing a fraction class code below that does a number of arithmetic calcs and when I run it these are the results I get. My gcd doesn't work when it comes to negative fractions and I'm not quite sure how to print.out the boolean methods ((greaterthan)), ((equals))and ((negative)). I'm also not sure if I have implemented those 3 methods properly. I'm still learning how to do unit testing. . Thanks in advance.

Enter numerator; then denominator.
-5
10
-5/10
Enter numerator; then denominator.
3
9
1/3
Sum:
-5/30
-0.16666666666666666
Product:
-5/30
-0.16666666666666666
Devide:
-15/30
-0.5
subtract:
-45/90
-0.5
negative:
1/6
0.16666666666666666
Lessthan:
1/6
0.16666666666666666
greaterthan:
1/6
0.16666666666666666

FRACTION CLASS

****************/

import java.util.Scanner;




public class Fraction
 {
   private int numerator;  //numerator
   private int denominator;  //denominator


//*********************************************************************************

public Fraction ()
  {
  this(1,1);
  }

 //*********************************************************************************
//00000000000000000000000000000000000000000000000000000000000000000000000000

public Fraction(int n, int d) {
    numerator = (d < 0 ? -n : n);
    if (d == 0) {
        denominator = 1;
    }
    denominator = (d < 0 ? -d : d);
    normalize();
}
 
// 000000000000000000000000000000000000000000000000000000
 public static void main(String[] args)

 {
	Scanner stdIn = new Scanner(System.in);
	Fraction c, d, x; // Fraction objects

	System.out.println("Enter numerator; then denominator.");
	c = new Fraction(stdIn.nextInt(), stdIn.nextInt());
	c.print();

	System.out.println("Enter numerator; then denominator.");
	d = new Fraction(stdIn.nextInt(), stdIn.nextInt());
	d.print();

	x = new Fraction(); // create a fraction for number 0

	System.out.println("Sum:");
	x = c.add(d);
	x.print();
	x.printAsDouble();

	x = new Fraction(1,1); // create a fraction for number 1

	System.out.println("Product:");
	x = c.multiply(d);
	x.print();
	x.printAsDouble();
	
	System.out.println("Devide:");
	x = c.devide(d);
	x.print();
	x.printAsDouble();
	
	System.out.println("subtract:");
	x = c.subtract(d);
	x.print();
	x.printAsDouble();
	
	System.out.println("negative:");
	x = c.negative();
	x.print();
	x.printAsDouble();
	
	System.out.println("Lessthan:");
	//x = c.lessThan();
	x.print();
	x.printAsDouble();
	
	System.out.println("greaterthan:");
	//x = c.greaterThan();
	x.print();
	x.printAsDouble();
	stdIn.close();

} // end main
 
 
  
 //mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
 public void setNumerator(int num) {
     numerator = num;
     normalize();
 }


 //mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
  public void setDenominator(int d) {
      if (d > 0) {
          this.denominator = d;
          normalize();
      }
      else if (d < 0) {
          numerator = -numerator;
          this.denominator = -d;
         normalize();
          }
  }

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

  ///''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
 //*********************************************************************************

  public Fraction add(Fraction d)
   {
	int newNumerator = ((numerator * d.denominator) + (d.numerator * denominator));
	int newDenominator = (d.denominator * denominator);
	Fraction x = new Fraction (newNumerator, newDenominator);
	x.normalize();
	//print();
	return x;
	}

 //*********************************************************************************
  public Fraction subtract(Fraction d)
  {
	int newNumerator = ((numerator * d.denominator) - (d.numerator * denominator));
	int newDenominator = (d.denominator * denominator);
	Fraction x = new Fraction (newNumerator, newDenominator);
	x.normalize();
	//print();
	return x;
	}
  //'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
//method6
		public Fraction negative() {
		Fraction x = new Fraction(-numerator, denominator );
		x.normalize();
			return x ;
		}
  /*-----------------------------------------------------------------
   * equals
   * compare the parameter Fraction to the current object Fraction
   */

  public boolean equals(Fraction d) {
      return (numerator == d.numerator) && (denominator == d.denominator);
  }

  //0000000000000000000000000000000000000000000000000000000
  public boolean lessThan(Fraction d)
  {  
      if (numerator * d.denominator <=   
              denominator * d.denominator){  
   
     
	return true ;  
      }  
      else {  
      return false;  
      }   
  }  
 
//00000000000000000000000000000000000000000000000000000000000000000000000
  public boolean greaterThan(Fraction d)
  {  
      if (numerator * d.denominator >   
              denominator * d.numerator){  
   
     
	return true ;  
      }  
      else {  
      return false;  
      }   
  }  
  
  //''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
  
  private void normalize() {
	  int nume = numerator; 
     boolean gcd = false; 
     while ( (!gcd) && (nume > 1) ) 
     { 
       // check that the numerator can be divided exactly by nume 
       if (numerator%nume == 0) 
       { 
         // see if the denominator can be divided exactly by the same number 
         if (denominator%nume == 0) 
         { 
           // got a result 
           numerator = numerator / nume; 
           denominator = denominator / nume; 
           gcd = true; 
         } 
       } 
       nume = nume - 1; 
     } 
   } 

   
  
   public Fraction multiply(Fraction e)
	{
	 this.numerator = (numerator * e.numerator);
	 this.denominator = (denominator * e.denominator);
	 Fraction x = new Fraction (this.numerator, this.denominator);
	 x.normalize();
	 //print();
	 return x;
	}
   
   //mmmmmmmmmmmmmmmmmmmmmm
 //method4
 public Fraction devide(Fraction f) {
 	int newDenominator= (denominator * f.numerator); 
 	int newNumerator = (numerator * f.denominator);		  
 		    
 	// return a new (normalised) fraction instance 
  Fraction x = new Fraction (newNumerator, newDenominator); 
 		     x.normalize(); 
 		     return x; 
 		   } 


  //*********************************************************************************

   public void print()
	{
	  System.out.println(this.numerator + "/" + this.denominator);
	}

  //*********************************************************************************

	public void printAsDouble()
	{
	  System.out.println((double) numerator / (double) denominator);

   } //end printAsDouble

 } //end class Fraction

[Campbell Ritchie]

You have fallen into the trap of writing lots of code and then wondering why it doesn't work.
Start by removing most of the //0000000000 comments which make the code harder to read. Then turn your computer off.
Write down an algorithm for GCD. Convert that to pseudocode, then consider turning your computer back on.
Then create a class with a gcd method (probably static) using Euclid's algorithm or something else. Get that to work.

Then you can consider the other methods.

[Tate Hsumsor]

Thankd I'll try that and see.

[Winston Gutkowski]

Tate Hsumsor wrote:I've been writing a fraction class...

Oddly enough, I did exactly the same thing a few years back, except with BigInteger's, so here's a few suggestions for you:

1. Consider implementing Comparable<Fraction>, rather than separate lessThan() and greaterThan() methods.
2. Your lessThan() method doesn't look right (haven't checked the other one).
3. Normalizing (also called 'reducing') can be done "in arrears" - ie, when the Fraction is used, rather than every time you get a result. You may also find it useful to have normalize() return a Fraction - ie, this, after you've reduced it.
4. Consider adding an invert() method.
5. You never check for overflow, despite the fact that pretty much any arithmetic on a Fraction will tend to increase the sizes of the numerator and/or divisor.
6. Fractions have a lot in common with floating-point numbers, so you might want to consider whether you want to support "infinites" (n/0) and/or "NaN" (0/0).
7. You keep the sign in the numerator, which is fine (and probably simplest); but an alternative arrangement is to store the sign separately and make your numerator and divisor positive (sometimes called "sign-magnitude"). One thing this does is allow you to store ±0 as distinct values if you want to; but it's not wildly important.
8. Consider making the class immutable and have your arithmetic methods return new Fractions, rather than updating this one. I think you'll find the API becomes a lot simpler.

and a few "efficiency" things for you:
1. When adding or subtracting, you don't need to normalize if the divisors are equal.
2. When muliplying or dividing, you don't have to normalize if either operand is 1 or -1.
3. When comparing, check the signs first, and then whether one operand is "vulgar" and the other isn't. You only need to compare products if both of the those cases are false.

HIH

Winston

[Tate Hsumsor]

Winston thank you so much that was seriously helpful. Much appreciated, I had initially made my class immutable but then ended up having errors on methods, but now I know why, I was not returning the newFraction. Thanks again

[Winston Gutkowski]

Tate Hsumsor wrote:Winston thank you so much that was seriously helpful. Much appreciated...

You're most welcome. Glad to see someone else ploughing the same furrow. I always thought it might be kinda useful.

Winston