Java Training Course/JT06: Difference between revisions

From tehowiki
Jump to navigation Jump to search
imported>Gfis
new
 
imported>Gfis
polish3
 
(7 intermediate revisions by the same user not shown)
Line 1: Line 1:
==Skeleton of Class ''Rational''==
==Preliminary Class ''Ratio''==
As a preparation we implement a Java class which represents fractions and arithmetic operations thereon, but the operations (''methods'' in Java terminology) are all static. They are implemented in a rather straight-forward way, and they are not yet really object-oriented.


/* Rational: exact fractions of integers
Below you will find a skeleton for the code. The task of this session is
  * @(#) $Id$
* Fill in the bodies of the following methods if necessary.
  * 2017-09-23, Georg Fischer
* Thereby make as much use of other methods as possible.
  */
* Insert proper documentation comments.
// package name will later go here
* Arrange the methods of the class in alphabetical order (since there are many).
// imports will later go here
===Desired Methods===
    public Rational abs() { return new Rational((numerator < 0 ? - numerator : numerator), denominator) }
    public Rational add(Rational rat2) { ... }
    public int compareTo(Rational rat2) { /* return -1, 0, +1 iff this < = > rat2 */ ... }
    public Rational divide(Rational rat2) { ... }
    public boolean equals(Rational rat2) { return this.compareTo(rat2) == 0; }
    public boolean isInteger() { return denominator == 1; }
    public int intValue() { return numerator / denominator; }
    public Rational max(Rational rat2) { return this.compareTo(rat2) > 0 ? this : rat2 }
    public Rational min(Rational rat2) { return this.compareTo(rat2) < 0 ? this : rat2 }
    public Rational multiply(Rational rat2) { ... }
    public Rational negate() { return new Rational(- numerator, denominator); }
    public Rational reduce() is already implemented below
    public Rational subtract(Rational rat2) is already implemented below
===Implementation===
<pre>
/* Fractions of integers
* @(#) $Id$
* 2017-11-07: revised in Bekasi
* 2017-09-23, Georg Fischer
*/
// package name will later go here
// imports will later go here
 
/** Class <em>Ratio</em> represents an integer fraction
*  together with the arithmetic operations on such Ratios.
*  The denominator is always &gt; 0. All arithmetic operations
*  return reduced fractions where GCD(numerator, denominator) = 1.
*  The methods have name, parameters and return values analogous to methods
*  of the Java object type BigInteger, see
*  https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html
*/
public class Ratio {
    //----------------
    // Internal Properties
    //----------------
    /** value above the bar, before the slash */
    public int numerator;
    /** value below the bar, after  the slash */
    public int denominator;
 
/*  Implement the following methods, and make use of basic operations.
    All Ratio return values should be reduced.
    Insert proper documentation comments.
    Always arrange the public methods of the class in alphabetical order, since there are many.
*/
    // public static Ratio abs(Ratio rat1) { return new Ratio(); }
    // public static Ratio add(Ratio rat1, Ratio rat2) { return new Ratio(); }
    // public static int compareTo(Ratio rat1, Ratio rat2) { return 0; } // return -1, 0, +1 iff this < = > rat2
    // public static Ratio divide(Ratio rat1, Ratio rat2) { return new Ratio(); }
    // public static boolean equals(Ratio rat1, Ratio rat2) { return rat1.compareTo(rat2) == 0; }
    // public static boolean isInteger(Ratio rat1) { return false; }
    // public static int intValue(Ratio rat1) { return 0; }
    // public static Ratio max(Ratio rat1, Ratio rat2) { return rat1; }
    // public static Ratio min(Ratio rat1, Ratio rat2) { return rat2; }
    // public static Ratio multiply(Ratio rat1, Ratio rat2) is already implemented below
    // public static Ratio negate(Ratio rat1) { return new Ratio(); }
    // public static Ratio reduce(Ratio rat1) is already implemented below
    // public static Ratio subtract(Ratio rat1, Ratio rat2) { return new Ratio(); }
   
    //----------------
    // Constructors
    //----------------
    /** No-args constructor, creates 1/1
    */
    public Ratio() {
        numerator  = 1;
        denominator = 1;
    } // no-args constructor
 
    /** Constructor with numerator, creates a/1
    *  @param a numerator
    */
    public Ratio(int a) {
        numerator  = a;
        denominator = 1;
    } // constructor(int)
 
    /** Constructor with numerator and denominator, creates a/b
    *  @param a numerator
    *  @param b denominator
    */
    public Ratio(int a, int b) {
        numerator  = a;
        denominator = b;
    } // constructor(int, int)
 
    /** Constructor from a String representation, creates a/b
    *  @param str String of the form "a/b"
    */
    public Ratio(String str) {
        int slashPos = str.indexOf("/");
        if (slashPos < 0) {
            str += "/1";
            slashPos = str.length() - 2;
        }
        numerator    = Integer.parseInt(str.substring(0, slashPos));
        denominator = Integer.parseInt(str.substring(slashPos + 1));
    } // constructor(String)
 
    //----------------
    // Internal getters
    //----------------
    /** Gets the numerator
    *  @return the numerator  of this Ratio
    */
    private int getNum() {
        return numerator;
    } // getNum()
 
    /** Gets the denominator
    *  @return the denominator of this Ratio
    */
    private int getDen() {
        return denominator;
    } // getDen()
 
    //----------------
    // Public methods
    //----------------
 
    /** Returns the sum of one Ratio and a second.
    *  @param rat1 1st Ratio
    *  @param rat2 2nd Ratio
    *  @return (rat1 + rat2)
    */
    public static Ratio add(Ratio rat1, Ratio rat2) {
        int denom  = Ratio.lcm(rat1.denominator, rat2.denominator);
        int fact1  = denom / rat1.denominator;
        int fact2  = denom / rat2.denominator;
        int numSum = rat1.numerator * fact1
                    + rat2.numerator * fact2;
        return Ratio.reduce(new Ratio(numSum, denom));
    } // add(Ratio)
 
    /** Returns the quotient of one Ratio and a second.
    *  @param rat1 1st Ratio
    *  @param rat2 2nd Ratio
    *  @return (rat1 / rat2)
    */
    public static Ratio divide(Ratio rat1, Ratio rat2) {
        return Ratio.reduce(new Ratio
                ( rat1.numerator  * rat2.denominator
                , rat1.denominator * rat2.numerator    )
                );
    } // divide(Ratio)
 
    /** Returns the greatest common divisor of 2 integers.
    *  @param a 1st integer
    *  @param b 2nd integer
    *  @return gcd(a,b), which is always positive
    */
    public static int gcd(int a, int b) {
        int result = Math.abs(a);
        if (result != 1) {
            int p = result;
            int q = Math.abs(b);
            while (q != 0) {
                int temp = q;
                q = p % q;
                p = temp;
            }
            result = p;
        } // if > 1
        return Math.abs(result);
    } // gcd(a, b)
   
    /** Returns the least common multiple of 2 integers.
    *  @param a 1st integer
    *  @param b 2nd integer
    *  @return lcm(a,b)
    */
    public static int lcm(int a, int b) {
        int result = a * b;
        if (result < 0) { // absolute, make positive
            result = - result;
        } // abs
        return result / gcd(a, b);
    } // lcm(int,int)
 
    /** Returns the product of one Ratio and a second.
    *  @param rat1 1st Ratio
    *  @param rat2 2nd Ratio
    *  @return (rat1 * rat2)
    */
    public static Ratio multiply(Ratio rat1, Ratio rat2) {
        return Ratio.reduce(new Ratio
                ( rat1.numerator  * rat2.numerator
                , rat1.denominator * rat2.denominator)
                );
    } // multiply(Ratio)
 
    /** Returns the negative of a Ratio.
    *  @param rat1  Ratio to be negated
    *  @return (- rat1)
    */
    public static Ratio negate(Ratio rat1) {
        return Ratio.reduce(new Ratio( - rat1.numerator, rat1.denominator));
    } // negate(Ratio)
 
    /** Reduces and normalizes the fraction, that means:
    *  (1) divides the numerator and the denominator by
    *  their greatest common divisor, if that is &gt; 1,
    *  (2) makes the denominator always positive,
    *  (3) normalizes the denominator to 1 if the numerator is 0.
    *  @param rat1 the Ratio to be reduced
    *  @return the reduced Ratio
    */
    public static Ratio reduce(Ratio rat1) {
        Ratio result = new Ratio(rat1.numerator, rat1.denominator);
        int common = gcd(rat1.numerator, rat1.denominator);
        if (common > 1) {
            result.numerator  /= common;
            result.denominator /= common;
        }
        if (result.numerator == 0) {
            result.denominator = 1;
        } else if (result.denominator < 0) {
            result.numerator  = - result.numerator;
            result.denominator = - result.denominator;
        }
        return result;
    } // reduce(Ratio)
   
   
/** Class <wm>Rational</em> represents an integer fraction
    /** Returns the difference of one Ratio and a second.
  *  together with the arithmetic operations on such Rationals.
     *  @param rat1 1st Ratio
  *  The denominator is always > 0. All arithmetic operations
     *  @param rat2 2nd Ratio
  *  return reduced fractions where GCD(numerator, denominator) = 1.
    *  @return (rat1 - rat2)
  *  The methods have name, parameters and return values analogous to methods
     */
  *  of the Java object type BigInteger, see
    public static Ratio subtract(Ratio rat1, Ratio rat2) {
  *  https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html
        return Ratio.add(rat1, Ratio.negate(rat2));
  */
    } // subtract(Ratio)
public class Rational {
 
    /** value above the bar, before the slash */
    /** Returns this Ratio as a String.
    private int numerator;
    *  @return a String of the form "a/b", or only "a" if b is 1.
    /** value below the bar, after  the slash */
    */
    private int denominator;
    public String toString() {
   
        String result = String.valueOf(numerator);
    /** No-args constructor, creates 1/1
        if (denominator != 1) {
      */
            result += "/" + String.valueOf(denominator);
    public Rational() {
        }
        numerator  = 1;
        return result;
        denominator = 1;
    } // toString()
    } // no-args constructor
 
   
    //================
     /** Constructor with numerator, creates a/1
    /** Test program, shows a series of fixed operations
      *  @param a numerator
     *  @param args String array of commandline arguments
      */
    public Rational(int a) {
        numerator  = a;
        denominator = 1;
    } // constructor(int)
   
     /** Constructor with numerator and denominator, creates a/b
      *  @param a numerator
      *  @param b denominator
      */
    public Rational(int a, int b) {
        numerator  = a;
        denominator = b;
    } // constructor(int, int)
      
    /** Constructor from a String representation, creates a/b
      *  @param str String of the form "a/b"
      */
    public Rational(String str) {
        int slashPos = str.indexOf("/");
        if (slashPos < 0) {
            str += "/1";
            slashPos = str.length() - 2;
        }
        numerator  = Integer.parseInt(str.substr(0, slashPos));
        denominator = Integer.parseInt(str.substr(slashPos + 1));
    } // constructor(String)
   
    /** Gets the numerator
      *  @return the numerator  of <em>this</em> Rational
      */
    private int getNum() {
    return numerator;
    } // getNum()
       
    /** Gets the denominator
      *  @return the denominator of <em>this</em> Rational
      */
    private int getDen() {
    return denominator;
    } // getDen()
       
    /** Returns the <em>Rational</em> as a String.
      *  @return a String of the form "a/b", or only "a" if b is 1.
      */
    public String toString() {
        String result = String.valueOf(numerator);
        if (denominator != 1) {
            result += "/" + String.valueOf(denominator);
        }
        return result;
    } // toString()
   
    /** Returns the greatest common divisor of 2 integers.
      *  @param a 1st integer
      *  @param b 2nd integer
      *  @return gcd(a,b), which is always positive
      */
    public int gcd(int a, int b) {
        int result = 0;
        return result;
    } // gcd(int,int)
   
    /** Returns the least common multiple of 2 integers.
      *  @param a 1st integer
      *  @param b 2nd integer
      *  @return lcm(a,b)
      */
    public int lcm(int a, int b) {
        int result = a * b;
        if (result < 0) { // make absolute
        result = - result;
        } // abs
        return result / gcd(a, b);
    } // lcm(int,int)
     
     /** Returns the difference between <em>this</em> Rational and a second.
      *  @param rat2 2nd Rational
      *  @return (this - rat2)
      */
    public Rational subtract(Rational rat2) {
    return this.add(rat2.negate()).reduce();
    } // subtract(Rational)
   
    /** Returns the product of <em>this</em> Rational and a second.
      *  @param rat2 2nd Rational
      *  @return (this * rat2)
      */
    public Rational multiply(Rational rat2) {
    return (this.getNum() * rat2.getNum() / (this.getDen() * rat2.getDen())).reduce();
    } // multiply(Rational)
    /*  Implement the following methods in the same fashion:
    ... reduce
    ... add
    ... subtract
    ... multiply (c.f. above)
    ... divide
    ... equals
    ... compareTo
    ... abs
    ... max
    ... min
    ... negate
    ... intValue
     */
     */
    public static void main(String[] args) {
    public static void main(String[] args) {
        System.out.println(args[0]);
        int iarg = 0;
    } // main
        String  str0 = "0/1";
} // Rational
        Ratio rat0 = new Ratio(str0);
        while (iarg < args.length) {
            String  str1 = args[iarg];
            Ratio rat1 = new Ratio(str1);
            System.out.println(str0 + " + " + str1 + " = " + Ratio.add    (rat0, rat1).toString());
            System.out.println(str0 + " - " + str1 + " = " + Ratio.subtract(rat0, rat1).toString());
            System.out.println(str0 + " * " + str1 + " = " + Ratio.multiply(rat0, rat1).toString());
            System.out.println(str0 + " / " + str1 + " = " + Ratio.divide  (rat0, rat1).toString());
            System.out.println();
            str0 = str1;
            rat0 = rat1;
            iarg ++;
        } // while iarg
    } // main
} // Ratio
</pre>
[[Java Training Course/JT05|&lt; Previous: JT05]] Control Structures: The Greatest Common Divisor<br />
[[Java Training Course/JT07|&gt; Next: JT07]] Class ''Rational''

Latest revision as of 15:25, 7 November 2017

Preliminary Class Ratio

As a preparation we implement a Java class which represents fractions and arithmetic operations thereon, but the operations (methods in Java terminology) are all static. They are implemented in a rather straight-forward way, and they are not yet really object-oriented.

Below you will find a skeleton for the code. The task of this session is

  • Fill in the bodies of the following methods if necessary.
  • Thereby make as much use of other methods as possible.
  • Insert proper documentation comments.
  • Arrange the methods of the class in alphabetical order (since there are many).

Desired Methods

    public Rational abs() { return new Rational((numerator < 0 ? - numerator : numerator), denominator) }
    public Rational add(Rational rat2) { ... }
    public int compareTo(Rational rat2) { /* return -1, 0, +1 iff this < = > rat2 */ ... }
    public Rational divide(Rational rat2) { ... }
    public boolean equals(Rational rat2) { return this.compareTo(rat2) == 0; }
    public boolean isInteger() { return denominator == 1; }
    public int intValue() { return numerator / denominator; }
    public Rational max(Rational rat2) { return this.compareTo(rat2) > 0 ? this : rat2 }
    public Rational min(Rational rat2) { return this.compareTo(rat2) < 0 ? this : rat2 }
    public Rational multiply(Rational rat2) { ... }
    public Rational negate() { return new Rational(- numerator, denominator); }
    public Rational reduce() is already implemented below
    public Rational subtract(Rational rat2) is already implemented below

Implementation

/* Fractions of integers
 * @(#) $Id$
 * 2017-11-07: revised in Bekasi
 * 2017-09-23, Georg Fischer
 */
// package name will later go here
// imports will later go here

/** Class <em>Ratio</em> represents an integer fraction
 *  together with the arithmetic operations on such Ratios.
 *  The denominator is always > 0. All arithmetic operations
 *  return reduced fractions where GCD(numerator, denominator) = 1.
 *  The methods have name, parameters and return values analogous to methods
 *  of the Java object type BigInteger, see
 *  https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html
 */
public class Ratio {
    //----------------
    // Internal Properties
    //----------------
    /** value above the bar, before the slash */
    public int numerator;
    /** value below the bar, after  the slash */
    public int denominator;

/*  Implement the following methods, and make use of basic operations.
    All Ratio return values should be reduced.
    Insert proper documentation comments.
    Always arrange the public methods of the class in alphabetical order, since there are many.
*/
    // public static Ratio abs(Ratio rat1) { return new Ratio(); }
    // public static Ratio add(Ratio rat1, Ratio rat2) { return new Ratio(); }
    // public static int compareTo(Ratio rat1, Ratio rat2) { return 0; } // return -1, 0, +1 iff this < = > rat2
    // public static Ratio divide(Ratio rat1, Ratio rat2) { return new Ratio(); }
    // public static boolean equals(Ratio rat1, Ratio rat2) { return rat1.compareTo(rat2) == 0; }
    // public static boolean isInteger(Ratio rat1) { return false; }
    // public static int intValue(Ratio rat1) { return 0; }
    // public static Ratio max(Ratio rat1, Ratio rat2) { return rat1; }
    // public static Ratio min(Ratio rat1, Ratio rat2) { return rat2; }
    // public static Ratio multiply(Ratio rat1, Ratio rat2) is already implemented below
    // public static Ratio negate(Ratio rat1) { return new Ratio(); }
    // public static Ratio reduce(Ratio rat1) is already implemented below
    // public static Ratio subtract(Ratio rat1, Ratio rat2) { return new Ratio(); }
    
    //----------------
    // Constructors
    //----------------
    /** No-args constructor, creates 1/1
     */
    public Ratio() {
        numerator   = 1;
        denominator = 1;
    } // no-args constructor

    /** Constructor with numerator, creates a/1
     *  @param a numerator
     */
    public Ratio(int a) {
        numerator   = a;
        denominator = 1;
    } // constructor(int)

    /** Constructor with numerator and denominator, creates a/b
     *  @param a numerator
     *  @param b denominator
     */
    public Ratio(int a, int b) {
        numerator   = a;
        denominator = b;
    } // constructor(int, int)

    /** Constructor from a String representation, creates a/b
     *  @param str String of the form "a/b"
     */
    public Ratio(String str) {
        int slashPos = str.indexOf("/");
        if (slashPos < 0) {
            str += "/1";
            slashPos = str.length() - 2;
        }
        numerator    = Integer.parseInt(str.substring(0, slashPos));
        denominator = Integer.parseInt(str.substring(slashPos + 1));
    } // constructor(String)

    //----------------
    // Internal getters
    //----------------
    /** Gets the numerator
     *  @return the numerator   of this Ratio
     */
    private int getNum() {
        return numerator;
    } // getNum()

    /** Gets the denominator
     *  @return the denominator of this Ratio
     */
    private int getDen() {
        return denominator;
    } // getDen()

    //----------------
    // Public methods
    //----------------

    /** Returns the sum of one Ratio and a second.
     *  @param rat1 1st Ratio
     *  @param rat2 2nd Ratio
     *  @return (rat1 + rat2)
     */
    public static Ratio add(Ratio rat1, Ratio rat2) {
         int denom  = Ratio.lcm(rat1.denominator, rat2.denominator);
         int fact1  = denom / rat1.denominator;
         int fact2  = denom / rat2.denominator;
         int numSum = rat1.numerator * fact1
                    + rat2.numerator * fact2;
         return Ratio.reduce(new Ratio(numSum, denom));
    } // add(Ratio)

    /** Returns the quotient of one Ratio and a second.
     *  @param rat1 1st Ratio
     *  @param rat2 2nd Ratio
     *  @return (rat1 / rat2)
     */
    public static Ratio divide(Ratio rat1, Ratio rat2) {
        return Ratio.reduce(new Ratio
                ( rat1.numerator   * rat2.denominator
                , rat1.denominator * rat2.numerator    )
                );
    } // divide(Ratio)

    /** Returns the greatest common divisor of 2 integers.
     *  @param a 1st integer
     *  @param b 2nd integer
     *  @return gcd(a,b), which is always positive
     */
    public static int gcd(int a, int b) {
        int result = Math.abs(a);
        if (result != 1) {
            int p = result;
            int q = Math.abs(b);
            while (q != 0) {
                int temp = q;
                q = p % q;
                p = temp;
            }
            result = p;
        } // if > 1
        return Math.abs(result);
    } // gcd(a, b)
    
    /** Returns the least common multiple of 2 integers.
     *  @param a 1st integer
     *  @param b 2nd integer
     *  @return lcm(a,b)
     */
    public static int lcm(int a, int b) {
        int result = a * b;
        if (result < 0) { // absolute, make positive
            result = - result;
        } // abs
        return result / gcd(a, b);
    } // lcm(int,int)

    /** Returns the product of one Ratio and a second.
     *  @param rat1 1st Ratio
     *  @param rat2 2nd Ratio
     *  @return (rat1 * rat2)
     */
    public static Ratio multiply(Ratio rat1, Ratio rat2) {
        return Ratio.reduce(new Ratio
                ( rat1.numerator   * rat2.numerator
                , rat1.denominator * rat2.denominator)
                );
    } // multiply(Ratio)

    /** Returns the negative of a Ratio.
     *  @param rat1  Ratio to be negated
     *  @return (- rat1)
     */
    public static Ratio negate(Ratio rat1) {
        return Ratio.reduce(new Ratio( - rat1.numerator, rat1.denominator));
    } // negate(Ratio)

    /** Reduces and normalizes the fraction, that means: 
     *  (1) divides the numerator and the denominator by
     *  their greatest common divisor, if that is > 1,
     *  (2) makes the denominator always positive, 
     *  (3) normalizes the denominator to 1 if the numerator is 0.
     *  @param rat1 the Ratio to be reduced
     *  @return the reduced Ratio
     */
    public static Ratio reduce(Ratio rat1) {
        Ratio result = new Ratio(rat1.numerator, rat1.denominator);
        int common = gcd(rat1.numerator, rat1.denominator);
        if (common > 1) {
            result.numerator   /= common;
            result.denominator /= common;
        }
        if (result.numerator == 0) {
            result.denominator = 1;
        } else if (result.denominator < 0) {
            result.numerator   = - result.numerator;
            result.denominator = - result.denominator;
        }
        return result;
    } // reduce(Ratio)
 
    /** Returns the difference of one Ratio and a second.
     *  @param rat1 1st Ratio
     *  @param rat2 2nd Ratio
     *  @return (rat1 - rat2)
     */
    public static Ratio subtract(Ratio rat1, Ratio rat2) {
        return Ratio.add(rat1, Ratio.negate(rat2));
    } // subtract(Ratio)

    /** Returns this Ratio as a String.
     *  @return a String of the form "a/b", or only "a" if b is 1.
     */
    public String toString() {
        String result = String.valueOf(numerator);
        if (denominator != 1) {
            result += "/" + String.valueOf(denominator);
        }
        return result;
    } // toString()

    //================
    /** Test program, shows a series of fixed operations
     *  @param args String array of commandline arguments
     */
    public static void main(String[] args) {
        int iarg = 0;
        String   str0 = "0/1";
        Ratio rat0 = new Ratio(str0);
        while (iarg < args.length) {
            String   str1 = args[iarg];
            Ratio rat1 = new Ratio(str1);
            System.out.println(str0 + " + " + str1 + " = " + Ratio.add     (rat0, rat1).toString());
            System.out.println(str0 + " - " + str1 + " = " + Ratio.subtract(rat0, rat1).toString());
            System.out.println(str0 + " * " + str1 + " = " + Ratio.multiply(rat0, rat1).toString());
            System.out.println(str0 + " / " + str1 + " = " + Ratio.divide  (rat0, rat1).toString());
            System.out.println();
            str0 = str1;
            rat0 = rat1;
            iarg ++;
        } // while iarg
    } // main
} // Ratio

< Previous: JT05 Control Structures: The Greatest Common Divisor
> Next: JT07 Class Rational