Polynomials/Inheritance - Revision history

Admin at 21:49, 9 April 2017

2017-04-09T21:49:26Z

← Older revision		Revision as of 21:49, 9 April 2017
Line 101:		Line 101:
	=Flags/Categories=		=Flags/Categories=

	{{~~PolynomialFlag~~}}		{{PolynomialsFlag}}

	[[Category:CS]]		[[Category:CS]]
	~~[[Category:Polynomials]]~~
	~~[[Category:Math]]~~
	[[Category:Java]]		[[Category:Java]]

Admin at 21:38, 9 April 2017

2017-04-09T21:38:25Z

← Older revision		Revision as of 21:38, 9 April 2017
Line 98:		Line 98:

	The code implements one new constructor taking three arguments, a, b, and c, and populates an array with these coefficients and passes it to the super class constructor. It also implements one new method to compute the two roots of the polynomial. It checks to make sure the discriminant is non-negative. If the discriminant is negative, it will return an empty array. Note that it would be better to raise an exception, and catch the exception where we actually call the getRoots() method, but again, we don't want to clutter our code with exception-handling.		The code implements one new constructor taking three arguments, a, b, and c, and populates an array with these coefficients and passes it to the super class constructor. It also implements one new method to compute the two roots of the polynomial. It checks to make sure the discriminant is non-negative. If the discriminant is negative, it will return an empty array. Note that it would be better to raise an exception, and catch the exception where we actually call the getRoots() method, but again, we don't want to clutter our code with exception-handling.

			=Flags/Categories=

			{{PolynomialFlag}}

	[[Category:CS]]		[[Category:CS]]

Admin: /* Superclass: Polynomial Class */

2017-04-09T21:24:17Z

Superclass: Polynomial Class

← Older revision		Revision as of 21:24, 9 April 2017
Line 45:		Line 45:
	}		}
	</pre>		</pre>

			A few things to note. First, the coefficients array is protected. This is because any child class, or class that derives from the Polynomial class, will need to be able to access the coefficients of the polynomial to do useful things. Another thing to note is that the evaluation method for this polynomial is an efficient and fast implementation of polynomial evaluation that uses a nested representation of a polynomial and a cumulative algorithm to calculate the result.

	==Subclass: Quadratic Class==		==Subclass: Quadratic Class==

Admin: /* Superclass: Polynomial Class */

2017-04-09T21:22:02Z

Superclass: Polynomial Class

← Older revision		Revision as of 21:22, 9 April 2017
Line 21:		Line 21:

	public class SimplePolynomial {		public class SimplePolynomial {
	~~private~~ double[] coeffs;		protected double[] coeffs;

	public SimplePolynomial(double[] coeffs) {		public SimplePolynomial(double[] coeffs) {

Admin: /* Subclass: Quadratic Class */

2017-04-09T21:21:26Z

Subclass: Quadratic Class

← Older revision		Revision as of 21:21, 9 April 2017
Line 77:		Line 77:
	double c = this.coeffs[0];		double c = this.coeffs[0];

	x1 = (-b + Math.sqrt(~~bb-4ac~~))/(2a);		double discriminant = bb - 4a*c;
	x2 = (-b - Math.sqrt(~~bb-4ac~~))/(2a);
			if(discriminant>=0) {
			x1 = (-b + Math.sqrt(discriminant))/(2*a);
			x2 = (-b - Math.sqrt(discriminant))/(2*a);
			return new double[] {x1,x2};
			} else {
			// Raising an exception would be better,
			// but will make code more cluttered.
			return new double[2];
			}

	~~return new double[] {x1,x2};~~
	}		}
	}		}
	</pre>		</pre>

			There are a few things to note about this solution. The first is that the SimpleQuadratic class defines a new constructor that takes 3 arguments. Note that we should probably do a better job of making sure the user doesn't do something crazy like creating a new Quadratic from an existing 8th-degree polynomial, but that would require us to introduce some exceptions and litter our code with exception handling, so let's ignore that distraction for now.

			The code implements one new constructor taking three arguments, a, b, and c, and populates an array with these coefficients and passes it to the super class constructor. It also implements one new method to compute the two roots of the polynomial. It checks to make sure the discriminant is non-negative. If the discriminant is negative, it will return an empty array. Note that it would be better to raise an exception, and catch the exception where we actually call the getRoots() method, but again, we don't want to clutter our code with exception-handling.

	[[Category:CS]]		[[Category:CS]]

Admin: /* Subclass: Quadratic Class */

2017-04-09T21:14:48Z

Subclass: Quadratic Class

← Older revision		Revision as of 21:14, 9 April 2017
Line 48:		Line 48:
	==Subclass: Quadratic Class==		==Subclass: Quadratic Class==

			To create a quadratic class that implements the same methods (degree and evaluate) and constructors, we first specify that the SimpleQuadratic class extends the SimplePolynomial class:

			<pre>
			public class SimpleQuadratic extends SimplePolynomial {
			</pre>

			There are a few other things that the Quadratic class needs to do that the Polynomial class does not:
			* Modify the constructor to check to make sure there are 3 coefficients, and that the leading coefficient is nonzero
			* Implement a method to compute the roots of the quadratic using the quadratic formula

			Here is a class that will do that:

			<pre>
			import java.util.Arrays;

			public class SimpleQuadratic extends SimplePolynomial {

			public SimpleQuadratic(double a, double b, double c) {
			super(new double[] {a,b,c});
			}

			public double[] getRoots() {
			// Use the quadratic formula
			double x1, x2;

			double a = this.coeffs[2];
			double b = this.coeffs[1];
			double c = this.coeffs[0];

			x1 = (-b + Math.sqrt(bb-4ac))/(2a);
			x2 = (-b - Math.sqrt(bb-4ac))/(2a);

			return new double[] {x1,x2};
			}
			}
			</pre>

Admin at 20:54, 9 April 2017

2017-04-09T20:54:46Z

← Older revision		Revision as of 20:54, 9 April 2017
Line 9:		Line 9:
	This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).		This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).

	=Superclass: Polynomial Class=		=The Java Classes=

			We can define a simple polynomial class that implements

			==Superclass: Polynomial Class==

	To begin, we can define a Polynomial class that implements a few behaviors that we want all polynomials to have: the ability to evaluate the polynomial at a particular value of x, and the ability to get the degree of the polynomial.		To begin, we can define a Polynomial class that implements a few behaviors that we want all polynomials to have: the ability to evaluate the polynomial at a particular value of x, and the ability to get the degree of the polynomial.
Line 19:		Line 23:
	private double[] coeffs;		private double[] coeffs;

	~~/** Constructor: assemble a polynomial from its coefficients. */~~
	public SimplePolynomial(double[] coeffs) {		public SimplePolynomial(double[] coeffs) {
	this.coeffs = Arrays.copyOf(coeffs,coeffs.length);		this.coeffs = Arrays.copyOf(coeffs,coeffs.length);
	}		}

	~~/** Constructor: assemble a polynomial from another polynomial. */~~
	public SimplePolynomial(SimplePolynomial p) {		public SimplePolynomial(SimplePolynomial p) {
	this(p.coeffs);		this(p.coeffs);
	}		}

	~~/** Eval the polynomial using an efficient method:~~
	* p(x) = c[0] + x(c[1] + x(c[2] + x*(...
	*/
	public double eval(double x) {		public double eval(double x) {
	int n = coeffs.length-1;		int n = coeffs.length-1;
Line 41:		Line 40:
	}		}

			public double degree() {
			return this.coeffs.length;
			}
	}		}
	</pre>		</pre>

	=Subclass: Quadratic Class=		==Subclass: Quadratic Class==

Admin at 20:53, 9 April 2017

2017-04-09T20:53:17Z

← Older revision		Revision as of 20:53, 9 April 2017
Line 8:		Line 8:

	This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).		This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).

			=Superclass: Polynomial Class=

			To begin, we can define a Polynomial class that implements a few behaviors that we want all polynomials to have: the ability to evaluate the polynomial at a particular value of x, and the ability to get the degree of the polynomial.

			<pre>
			import java.util.Arrays;

			public class SimplePolynomial {
			private double[] coeffs;

			/** Constructor: assemble a polynomial from its coefficients. */
			public SimplePolynomial(double[] coeffs) {
			this.coeffs = Arrays.copyOf(coeffs,coeffs.length);
			}

			/** Constructor: assemble a polynomial from another polynomial. */
			public SimplePolynomial(SimplePolynomial p) {
			this(p.coeffs);
			}

			/** Eval the polynomial using an efficient method:
			* p(x) = c[0] + x(c[1] + x(c[2] + x*(...
			*/
			public double eval(double x) {
			int n = coeffs.length-1;
			double result = coeffs[n];
			for(int j=n-1; j>=0; j--) {
			result = result*x + coeffs[j];
			}
			return result;
			}

			}
			</pre>

			=Subclass: Quadratic Class=




			[[Category:CS]]
			[[Category:Polynomials]]
			[[Category:Math]]
			[[Category:Java]]

Admin: Created page with "=Inheritance= First, let's talk about what inheritance is. In Java, all code is contained in a class or multiple classes. These classes are essentially collections of relat..."

2017-04-09T20:46:53Z

Created page with "=Inheritance= First, let's talk about what inheritance is. In Java, all code is contained in a class or multiple classes. These classes are essentially collections of relat..."

New page

=Inheritance=

First, let's talk about what inheritance is.

In Java, all code is contained in a class or multiple classes. These classes are essentially collections of related data (fields), and behaviors that utilize that data (methods). Classes can encapsulate and abstract away complexity, so they're very useful. But managing complexity and eliminating redundancy also requires the ability to share code between classes. This is the idea behind inheritance - defining an object that implements the same fields and the same methods as another class, but with a few modifications.

The inheritance relationship is an "is-a" relationship. To ask if B should inherit from A, ask if B is-an A. For example, suppose we have implemented a class representing Polynomials, and we want to implement a new class that represents quadratics. In deciding whether the Quadratic class should inherit from the Polynomial class, we ask if a Quadratic is a Polynomial, and the answer is yes. So the Quadratic class should inherit from the Polynomial class.

This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).