Java Training Course/JT06 - Revision history

imported>Gfis: polish3

2017-11-07T15:25:37Z

polish3

← Older revision		Revision as of 15:25, 7 November 2017
Line 262:		Line 262:
	String str1 = args[iarg];		String str1 = args[iarg];
	Ratio rat1 = new Ratio(str1);		Ratio rat1 = new Ratio(str1);
	System.out.println(str0 + " + " + str1 + " = " + Ratio.add (rat0, rat1).toString());		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.subtract(rat0, rat1).toString());
	System.out.println(str0 + " * " + str1 + " = " + Ratio.multiply(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 + " = " + Ratio.divide (rat0, rat1).toString());
	System.out.println();		System.out.println();
	str0 = str1;		str0 = str1;
Line 273:		Line 273:
	} // main		} // main
	} // Ratio		} // Ratio
	</~~ore~~>		</pre>
	[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />		[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />
	[[Java Training Course/JT07\|> Next: JT07]] Class ''Rational''		[[Java Training Course/JT07\|> Next: JT07]] Class ''Rational''

imported>Gfis: polishing

2017-11-07T15:15:11Z

polishing

Show changes

imported>Gfis: Ratio

2017-11-07T06:35:20Z

Ratio

← Older revision		Revision as of 06:35, 7 November 2017
Line 30:		Line 30:
	// package name will later go here		// package name will later go here
	// imports will later go here		// imports will later go here

	/** Class <wm>Ratio</em> represents an integer fraction		/** Class <wm>Ratio</em> represents an integer fraction
	* together with the arithmetic operations on such Ratios.		* together with the arithmetic operations on such Ratios.
Line 47:		Line 47:
	/** value below the bar, after the slash */		/** value below the bar, after the slash */
	public int denominator;		public int denominator;

	/* Implement the following methods, and make use of basic operations.		/* Implement the following methods, and make use of basic operations.
	All Ratio return values should be reduced.		All Ratio return values should be reduced.
Line 66:		Line 66:
	// public static Ratio reduce(Ratio rat1) is already implemented below		// public static Ratio reduce(Ratio rat1) is already implemented below
	public static Ratio subtract(Ratio rat1, Ratio rat2) { return new Ratio(); }		public static Ratio subtract(Ratio rat1, Ratio rat2) { return new Ratio(); }

	//----------------		//----------------
	// Constructors		// Constructors
Line 76:		Line 76:
	denominator = 1;		denominator = 1;
	} // no-args constructor		} // no-args constructor

	/** Constructor with numerator, creates a/1		/** Constructor with numerator, creates a/1
	* @param a numerator		* @param a numerator
Line 84:		Line 84:
	denominator = 1;		denominator = 1;
	} // constructor(int)		} // constructor(int)

	/** Constructor with numerator and denominator, creates a/b		/** Constructor with numerator and denominator, creates a/b
	* @param a numerator		* @param a numerator
Line 93:		Line 93:
	denominator = b;		denominator = b;
	} // constructor(int, int)		} // constructor(int, int)

	/** Constructor from a String representation, creates a/b		/** Constructor from a String representation, creates a/b
	* @param str String of the form "a/b"		* @param str String of the form "a/b"
Line 103:		Line 103:
	slashPos = str.length() - 2;		slashPos = str.length() - 2;
	}		}
	numerator = Integer.parseInt(str.substring(0, slashPos));		numerator = Integer.parseInt(str.substring(0, slashPos));
	denominator = Integer.parseInt(str.substring(slashPos + 1));		denominator = Integer.parseInt(str.substring(slashPos + 1));
	} // constructor(String)		} // constructor(String)

	//----------------		//----------------
	// Internal getters		// Internal getters
Line 116:		Line 116:
	return numerator;		return numerator;
	} // getNum()		} // getNum()

	/** Gets the denominator		/** Gets the denominator
	* @return the denominator of this Ratio		* @return the denominator of this Ratio
Line 123:		Line 123:
	return denominator;		return denominator;
	} // getDen()		} // getDen()

	//----------------		//----------------
	// Public methods		// Public methods
Line 137:		Line 137:
	return result;		return result;
	} // gcd(int,int)		} // gcd(int,int)

	/** Returns the least common multiple of 2 integers.		/** Returns the least common multiple of 2 integers.
	* @param a 1st integer		* @param a 1st integer
Line 150:		Line 150:
	return result / gcd(a, b);		return result / gcd(a, b);
	} // lcm(int,int)		} // lcm(int,int)

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

	/** Reduces and normalizes the fraction, that means:		/** Reduces and normalizes the fraction, that means:
	* <ul>		* <ul>
	* <li>divides the numerator and the denominator by		* <li>divides the numerator and the denominator by
	* their greatest common divisor, if that is > 1,</li>		* their greatest common divisor, if that is > 1,</li>
	* <li>makes the denominator always positive,</li>		* <li>makes the denominator always positive,</li>
	* <li>normalizes the denominator to 1 if the numerator is 0.</li>		* <li>normalizes the denominator to 1 if the numerator is 0.</li>
Line 175:		Line 175:
	int common = gcd(rat1.numerator, rat1.denominator);		int common = gcd(rat1.numerator, rat1.denominator);
	if (common > 1) {		if (common > 1) {
	result.numerator /= common;		result.numerator /= common;
	result.denominator /= common;		result.denominator /= common;
	}		}
Line 181:		Line 181:
	result.denominator = 1;		result.denominator = 1;
	} else if (result.denominator < 0) {		} else if (result.denominator < 0) {
	result.numerator = - result.numerator;		result.numerator = - result.numerator;
	result.denominator = - result.denominator;		result.denominator = - result.denominator;
	}		}
	return result;		return result;
	} // reduce(Ratio)		} // reduce(Ratio)

	/** Returns this Ratio as a String.		/** Returns this Ratio as a String.
	* @return a String of the form "a/b", or only "a" if b is 1.		* @return a String of the form "a/b", or only "a" if b is 1.
Line 197:		Line 197:
	return result;		return result;
	} // toString()		} // toString()

	//================		//================
	/** Test program, shows a series of fixed operations		/** Test program, shows a series of fixed operations
Line 220:		Line 220:
	} // main		} // main
	} // Ratio		} // Ratio

	</ore>		</ore>
	[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />		[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />
	[[Java Training Course/JT07\|> Next: JT07]] Class ''Rational''		[[Java Training Course/JT07\|> Next: JT07]] Class ''Rational''

imported>Gfis at 06:29, 7 November 2017

2017-11-07T06:29:38Z

Show changes

imported>Gfis: not yet object-oriented

2017-09-26T19:34:45Z

not yet object-oriented

← Older revision		Revision as of 19:34, 26 September 2017
Line 1:		Line 1:
	==~~Skeleton of~~ Class ''~~Rational~~''==		==Preliminary Class ''Ratio''==
	As ~~announced in [[Java Training Course/JT05\|JT05]],~~ we ~~now~~ implement a ~~useful type of objects with~~ operations as a ~~Java class~~. Below you will find a skeleton for the code. The task of this session is		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.		* Fill in the bodies of the following methods if necessary.
	* Thereby make as much use of other methods as possible.		* Thereby make as much use of other methods as possible.
	* All Rational return values should be <em>reduce</em>d.
	* Insert proper documentation comments.		* Insert proper documentation comments.
	* Arrange the methods of the class in alphabetical order (since there are many).		* Arrange the methods of the class in alphabetical order (since there are many).
Line 213:		Line 214:
	} // Rational		} // Rational
	[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />		[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />
	[[Java Training Course/JT07\|> Next: JT07]] ~~Diskussion of~~ Class ''Rational''		[[Java Training Course/JT07\|> Next: JT07]] Class ''Rational''

imported>Gfis at 07:16, 25 September 2017

2017-09-25T07:16:27Z

← Older revision		Revision as of 07:16, 25 September 2017
Line 212:		Line 212:

	} // Rational		} // Rational
			[[Java Training Course/JT05\|< Previous: JT05]] Control Structures: The Greatest Common Divisor<br />
			[[Java Training Course/JT07\|> Next: JT07]] Diskussion of Class ''Rational''

imported>Gfis at 19:30, 24 September 2017

2017-09-24T19:30:15Z

← Older revision		Revision as of 19:30, 24 September 2017
Line 1:		Line 1:
	==Skeleton of Class ''Rational''==		==Skeleton of Class ''Rational''==
	As announced in [[Java Training Course/JT05\|JT05]], we now implement a useful type of objects with operations as a Java class. Below you will find a skeleton for the code. The task of this session is		As announced in [[Java Training Course/JT05\|JT05]], we now implement a useful type of objects with operations as a Java class. Below you will find a skeleton for the code. The task of this session is
	* Fill in the bodies of the following methods.		* Fill in the bodies of the following methods if necessary.
	* Thereby make as much use of other methods as possible.		* Thereby make as much use of other methods as possible.
	* All Rational return values should be <em>reduce</em>d.		* All Rational return values should be <em>reduce</em>d.
Line 7:		Line 7:
	* Arrange the methods of the class in alphabetical order (since there are many).		* Arrange the methods of the class in alphabetical order (since there are many).
	===Desired Methods===		===Desired Methods===
	public Rational abs() { return ~~this;~~ }		public Rational abs() { return new Rational((numerator < 0 ? - numerator : numerator), denominator) }
	public Rational add(Rational rat2) { ~~return this;~~ }		public Rational add(Rational rat2) { ... }
	public int compareTo(Rational rat2) { ~~return 0; } /~~/ return -1, 0, +1 iff this < = > rat2		public int compareTo(Rational rat2) { /* return -1, 0, +1 iff this < = > rat2 */ ... }
	public Rational divide(Rational rat2) { ~~return this;~~ }		public Rational divide(Rational rat2) { ... }
	public boolean equals(Rational rat2) { return this.compareTo(rat2) == 0; }		public boolean equals(Rational rat2) { return this.compareTo(rat2) == 0; }
	public boolean isInteger() { return denominator == 1; }		public boolean isInteger() { return denominator == 1; }
	public int intValue() { return numerator / denominator; }		public int intValue() { return numerator / denominator; }
	public Rational max(Rational rat2) { return this; }		public Rational max(Rational rat2) { return this.compareTo(rat2) > 0 ? this : rat2 }
	public Rational min(Rational rat2) { return this; }		public Rational min(Rational rat2) { return this.compareTo(rat2) < 0 ? this : rat2 }
	public Rational multiply(Rational rat2) { ~~return this;~~ }		public Rational multiply(Rational rat2) { ... }
	public Rational negate() { return ~~this~~; }		public Rational negate() { return new Rational(- numerator, denominator); }
	// public Rational reduce() is already implemented below		// public Rational reduce() is already implemented below
	// public Rational subtract(Rational rat2) is already implemented below		// public Rational subtract(Rational rat2) is already implemented below
Line 129:		Line 129:
	* @return gcd(a,b), which is always positive		* @return gcd(a,b), which is always positive
	*/		*/
	public int gcd(int a, int b) {		public static int gcd(int a, int b) {
	int result = 0;		int result = 0;
	// not yet implemented		// not yet implemented
Line 140:		Line 140:
	* @return lcm(a,b)		* @return lcm(a,b)
	*/		*/
	public int lcm(int a, int b) {		public static int lcm(int a, int b) {
	int result = a * b;		int result = a * b;
	if (result < 0) { // absolute, make positive		if (result < 0) { // absolute, make positive
Line 148:		Line 148:
	} // lcm(int,int)		} // lcm(int,int)

	/** Reduces the fraction, that means:		/** Reduces and normalizes the fraction, that means:
	* divides the numerator and the denominator by		* <ul>
	* their greatest common divisor, if that is > 1,		* <li>divides the numerator and the denominator by
	* ~~and~~ makes the denominator always positive.		* their greatest common divisor, if that is > 1,</li>
			* <li>makes the denominator always positive,</li>
			* <li>normalizes the denominator to 1 if the numerator is 0.</li>
			* </ul>
	*/		*/
	public Rational reduce() {		public Rational reduce() {
Line 159:		Line 162:
	denominator /= common;		denominator /= common;
	}		}
	if (denominator < 0) {		if (numerator == 0) {
			denominator = 1;
			} else if (denominator < 0) {
	numerator = - numerator;		numerator = - numerator;
	denominator = - denominator;		denominator = - denominator;
Line 165:		Line 170:
	return this;		return this;
	} // reduce()		} // reduce()

	/** Returns the difference between <em>this</em> Rational and a second.		/** Returns the difference between <em>this</em> Rational and a second.
	* @param rat2 2nd Rational		* @param rat2 2nd Rational

imported>Gfis: Version 2

2017-09-24T18:20:13Z

Version 2

Show changes

imported>Gfis: new

2017-09-24T10:49:36Z

new

New page

==Skeleton of Class ''Rational''==

/* Rational: exact fractions of integers
* @(#) $Id$
* 2017-09-23, Georg Fischer
*/
// package name will later go here
// imports will later go here

/** Class <wm>Rational represents an integer fraction
* together with the arithmetic operations on such Rationals.
* 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 Rational {
/** value above the bar, before the slash */
private int numerator;
/** value below the bar, after the slash */
private int denominator;

/** No-args constructor, creates 1/1
*/
public Rational() {
numerator = 1;
denominator = 1;
} // no-args constructor

/** Constructor with numerator, creates a/1
* @param a numerator
*/
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 this Rational
*/
private int getNum() {
return numerator;
} // getNum()

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

/** Returns the Rational 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 this 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 this 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) {
System.out.println(args[0]);
} // main
} // Rational