psteitz 2004/07/20 05:55:01
Modified: math/src/java/org/apache/commons/math/analysis
PolynomialFunction.java
PolynomialSplineFunction.java
Log:
javadoc.
Revision Changes Path
1.12 +8 4 jakartacommons/math/src/java/org/apache/commons/math/analysis/PolynomialFunction.java
Index: PolynomialFunction.java
===================================================================
RCS file: /home/cvs/jakartacommons/math/src/java/org/apache/commons/math/analysis/PolynomialFunction.java,v
retrieving revision 1.11
retrieving revision 1.12
diff u r1.11 r1.12
 PolynomialFunction.java 23 Jun 2004 16:26:14 0000 1.11
+++ PolynomialFunction.java 20 Jul 2004 12:55:01 0000 1.12
@@ 31,13 +31,17 @@
static final long serialVersionUID = 3322454535052136809L;
/**
 * The coefficients of the polynomial, ordered by degree  i.e., coefficients[0]
is the constant term
 * and coefficients[n] is the coefficient of x^n where n is the degree of the polynomial.
+ * The coefficients of the polynomial, ordered by degree  i.e.,
+ * coefficients[0] is the constant term and coefficients[n] is the
+ * coefficient of x^n where n is the degree of the polynomial.
*/
private double coefficients[];
/**
 * Construct a polynomial with the given coefficients.
+ * Construct a polynomial with the given coefficients. The first element
+ * of the coefficients array is the constant term. Higher degree
+ * coefficients follow in sequence. The degree of the resulting polynomial
+ * is the length of the array minus 1.
* <p>
* The constructor makes a copy of the input array and assigns the copy to
* the coefficients property.
1.8 +50 29 jakartacommons/math/src/java/org/apache/commons/math/analysis/PolynomialSplineFunction.java
Index: PolynomialSplineFunction.java
===================================================================
RCS file: /home/cvs/jakartacommons/math/src/java/org/apache/commons/math/analysis/PolynomialSplineFunction.java,v
retrieving revision 1.7
retrieving revision 1.8
diff u r1.7 r1.8
 PolynomialSplineFunction.java 17 Jul 2004 21:19:39 0000 1.7
+++ PolynomialSplineFunction.java 20 Jul 2004 12:55:01 0000 1.8
@@ 23,23 +23,32 @@
/**
* Represents a polynomial spline function.
* <p>
 * A <strong>polynomial spline function</strong> consists of a set of <i>interpolating
polynomials</i>
 * and an ascending array of domain <i>knot points</i>, determining the intervals
over which the
 * spline function is defined by the constituent polynomials. The polynomials are assumed
to have
 * been computed to match the values of another function at the knot points. The value
 * consistency constraints are not currently enforced by <code>PolynomialSplineFunction</code>
itself,
 * but are assumed to hold among the polynomials and knot points passed to the constructor.
+ * A <strong>polynomial spline function</strong> consists of a set of
+ * <i>interpolating polynomials</i> and an ascending array of domain
+ * <i>knot points</i>, determining the intervals over which the spline function
+ * is defined by the constituent polynomials. The polynomials are assumed to
+ * have been computed to match the values of another function at the knot
+ * points. The value consistency constraints are not currently enforced by
+ * <code>PolynomialSplineFunction</code> itself, but are assumed to hold among
+ * the polynomials and knot points passed to the constructor.
* <p>
 * N.B.: The polynomials in the <code>polynomials</code> property must be
centered on the knot points
 * to compute the spline function values. See below.
+ * N.B.: The polynomials in the <code>polynomials</code> property must be
+ * centered on the knot points to compute the spline function values. See below.
* <p>
 * The value of the polynomial spline function for an argument <code>x</code>
is computed as follows:
+ * The domain of the polynomial spline function is
+ * <code>[smallest knot, largest knot)</code>. Attempts to evaluate the
+ * function at values outside of this range generate IllegalArgumentExceptions.
+ * <p>
+ * The value of the polynomial spline function for an argument <code>x</code>
+ * is computed as follows:
* <ol>
 * <li>The knot array is searched to find the segment to which <code>x</code>
belongs.
 * If <code>x</code> is less than the smallest knot point or greater than
or equal to the largest one, an
 * <code>IllegalArgumentException</code> is thrown.</li>
 * <li> Let <code>j</code> be the index of the largest knot point that
is less than or equal to <code>x</code>.
 * The value returned is <br> <code>polynomials[j](x  knot[j])</code></li></ol>
+ * <li>The knot array is searched to find the segment to which <code>x</code>
+ * belongs. If <code>x</code> is less than the smallest knot point or greater
+ * than or equal to the largest one, an <code>IllegalArgumentException</code>
+ * is thrown.</li>
+ * <li> Let <code>j</code> be the index of the largest knot point that
is less
+ * than or equal to <code>x</code>. The value returned is <br>
+ * <code>polynomials[j](x  knot[j])</code></li></ol>
*
* @version $Revision$ $Date$
*/
@@ 52,33 +61,37 @@
private double knots[];
/**
 * The polynomial functions that make up the spline. The first element determines
the value of the spline
 * over the first subinterval, the second over the second, etc. Spline function values
are determined by
 * evaluating these functions at <code>(x  knot[i])</code> where i is
the knot segment to which x belongs.
+ * The polynomial functions that make up the spline. The first element
+ * determines the value of the spline over the first subinterval, the
+ * second over the second, etc. Spline function values are determined by
+ * evaluating these functions at <code>(x  knot[i])</code> where i is
the
+ * knot segment to which x belongs.
*/
private PolynomialFunction polynomials[] = null;
 /** Number of spline segments = number of polynomials = number of partition points
 1 */
+ /**
+ * Number of spline segments = number of polynomials
+ * = number of partition points  1
+ */
private int n = 0;
/**
 * Construct a polynomial spline function with the given segment delimiters and interpolating
 * polynomials.
+ * Construct a polynomial spline function with the given segment delimiters
+ * and interpolating polynomials.
* <p>
 * The constructor copies both arrays and assigns the copies to the knots and polynomials
properties,
 * respectively.
+ * The constructor copies both arrays and assigns the copies to the knots
+ * and polynomials properties, respectively.
*
* @param knots spline segment interval delimiters
* @param polynomials polynomial functions that make up the spline
* @throws NullPointerException if either of the input arrays is null
* @throws IllegalArgumentException if knots has length less than 2,
 * <code>polynomials.length != knots.length  1 </code>, or the knots
array
 * is not strictly increasing.
+ * <code>polynomials.length != knots.length  1 </code>, or the knots array
+ * is not strictly increasing.
*
*/
public PolynomialSplineFunction(double knots[], PolynomialFunction polynomials[]) {
 super();
if (knots.length < 2) {
throw new IllegalArgumentException
("Not enough knot values  spline partition must have at least 2 points.");
@@ 101,12 +114,18 @@
/**
* Compute the value for the function.
+ * <p>
+ * Throws FunctionEvaluationException if v is outside of the domain of the
+ * function. The domain is [smallest knot, largest knot).
+ * <p>
+ * See {@link PolynomialSplineFunction} for details on the algorithm for
+ * computing the value of the function.
*
* @param v the point for which the function value should be computed
* @return the value
* @throws FunctionEvaluationException if v is outside of the domain of
* of the spline function (less than the smallest knot point or greater
 * than the largest knot point)
+ * than or equal to the largest knot point)
*/
public double value(double v) throws FunctionEvaluationException {
if (v < knots[0]  v >= knots[n]) {
@@ 141,7 +160,8 @@
}
/**
 * Returns the number of spline segments = the number of polynomials = the number of
knot points  1.
+ * Returns the number of spline segments = the number of polynomials
+ * = the number of knot points  1.
*
* @return the number of spline segments
*/
@@ 180,9 +200,10 @@
/**
* Determines if the given array is ordered in a strictly increasing
* fashion.
+ *
* @param x the array to examine.
* @return <code>true</code> if the elements in <code>x</code>
are ordered
 * in a stricly increasing manner. <code>false</code>, otherwise.
+ * in a stricly increasing manner. <code>false</code>, otherwise.
*/
private static boolean isStrictlyIncreasing(double[] x) {
for (int i = 1; i < x.length; ++i) {

To unsubscribe, email: commonsdevunsubscribe@jakarta.apache.org
For additional commands, email: commonsdevhelp@jakarta.apache.org
