Coverage Report - org.apache.commons.math.analysis.PolynomialFunction

Classes in this File	Line Coverage	Branch Coverage	Complexity
PolynomialFunction	90%	100%	2.25;2.25

1		/*
2		* Copyright 2003-2004 The Apache Software Foundation.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.apache.commons.math.analysis;
17
18		import java.io.Serializable;
19
20		/**
21		* Immutable representation of a real polynomial function with real coefficients.
22		* <p>
23		* <a href="http://mathworld.wolfram.com/HornersMethod.html">Horner's Method</a>
24		* is used to evaluate the function.
25		*
26		* @version $Revision$ $Date: 2005-02-26 05:11:52 -0800 (Sat, 26 Feb 2005) $
27		*/
28		public class PolynomialFunction implements DifferentiableUnivariateRealFunction, Serializable {
29
30		/** Serializable version identifier */
31		static final long serialVersionUID = 3322454535052136809L;
32
33		/**
34		* The coefficients of the polynomial, ordered by degree -- i.e.,
35		* coefficients[0] is the constant term and coefficients[n] is the
36		* coefficient of x^n where n is the degree of the polynomial.
37		*/
38		private double coefficients[];
39
40		/**
41		* Construct a polynomial with the given coefficients. The first element
42		* of the coefficients array is the constant term. Higher degree
43		* coefficients follow in sequence. The degree of the resulting polynomial
44		* is the length of the array minus 1.
45		* <p>
46		* The constructor makes a copy of the input array and assigns the copy to
47		* the coefficients property.
48		*
49		* @param c polynominal coefficients
50		* @throws NullPointerException if c is null
51		* @throws IllegalArgumentException if c is empty
52		*/
53		public PolynomialFunction(double c[]) {
54	168	super();
55	168	if (c.length < 1) {
56	0	throw new IllegalArgumentException("Polynomial coefficient array must have postive length.");
57		}
58	168	this.coefficients = new double[c.length];
59	168	System.arraycopy(c, 0, this.coefficients, 0, c.length);
60	168	}
61
62		/**
63		* Compute the value of the function for the given argument.
64		* <p>
65		* The value returned is <br>
66		* <code>coefficients[n] * x^n + ... + coefficients[1] * x + coefficients[0]</code>
67		*
68		* @param x the argument for which the function value should be computed
69		* @return the value of the polynomial at the given point
70		* @see UnivariateRealFunction#value(double)
71		*/
72		public double value(double x) {
73	366	return evaluate(coefficients, x);
74		}
75
76
77		/**
78		* Returns the degree of the polynomial
79		*
80		* @return the degree of the polynomial
81		*/
82		public int degree() {
83	6	return coefficients.length - 1;
84		}
85
86		/**
87		* Returns a copy of the coefficients array.
88		* <p>
89		* Changes made to the returned copy will not affect the coefficients of
90		* the polynomial.
91		*
92		* @return a fresh copy of the coefficients array
93		*/
94		public double[] getCoefficients() {
95	44	double[] out = new double[coefficients.length];
96	44	System.arraycopy(coefficients,0, out, 0, coefficients.length);
97	44	return out;
98		}
99
100		/**
101		* Uses Horner's Method to evaluate the polynomial with the given coefficients at
102		* the argument.
103		*
104		* @param coefficients the coefficients of the polynomial to evaluate
105		* @param argument the input value
106		* @return the value of the polynomial
107		* @throws IllegalArgumentException if coefficients is empty
108		* @throws NullPointerException if coefficients is null
109		*/
110		protected static double evaluate(double[] coefficients, double argument) {
111	366	int n = coefficients.length;
112	366	if (n < 1) {
113	0	throw new IllegalArgumentException("Coefficient array must have positive length for evaluation");
114		}
115	366	double result = coefficients[n - 1];
116	1156	for (int j = n -2; j >=0; j--) {
117	790	result = argument * result + coefficients[j];
118		}
119	366	return result;
120		}
121
122		/**
123		* Returns the coefficients of the derivative of the polynomial with the given coefficients.
124		*
125		* @param coefficients the coefficients of the polynomial to differentiate
126		* @return the coefficients of the derivative or null if coefficients has length 1.
127		* @throws IllegalArgumentException if coefficients is empty
128		* @throws NullPointerException if coefficients is null
129		*/
130		protected static double[] differentiate(double[] coefficients) {
131	98	int n = coefficients.length;
132	98	if (n < 1) {
133	0	throw new IllegalArgumentException("Coefficient array must have positive length for differentiation");
134		}
135	98	if (n == 1) {
136	8	return new double[]{0};
137		}
138	90	double[] result = new double[n - 1];
139	326	for (int i = n - 1; i > 0; i--) {
140	236	result[i - 1] = (double) i * coefficients[i];
141		}
142	90	return result;
143		}
144
145		/**
146		* Returns the derivative as a PolynomialRealFunction
147		*
148		* @return the derivative polynomial
149		*/
150		public PolynomialFunction polynomialDerivative() {
151	98	return new PolynomialFunction(differentiate(coefficients));
152		}
153
154		/**
155		* Returns the derivative as a UnivariateRealFunction
156		*
157		* @return the derivative function
158		*/
159		public UnivariateRealFunction derivative() {
160	64	return polynomialDerivative();
161		}
162
163		}