commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r739834 - in /commons/proper/math/trunk/src: java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java site/xdoc/changes.xml test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java
Date Sun, 01 Feb 2009 20:56:12 GMT
Author: luc
Date: Sun Feb  1 20:56:12 2009
New Revision: 739834

URL: http://svn.apache.org/viewvc?rev=739834&view=rev
Log:
Added add, subtract, negate, multiply and toString methods to PolynomialFunction

Modified:
    commons/proper/math/trunk/src/java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java
    commons/proper/math/trunk/src/site/xdoc/changes.xml
    commons/proper/math/trunk/src/test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java?rev=739834&r1=739833&r2=739834&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/analysis/polynomials/PolynomialFunction.java
Sun Feb  1 20:56:12 2009
@@ -32,25 +32,26 @@
 public class PolynomialFunction implements DifferentiableUnivariateRealFunction, Serializable
{
 
     /** Serializable version identifier */
-    private static final long serialVersionUID = 3322454535052136809L;
-    
+    private static final long serialVersionUID = -7726511984200295583L;
+
     /**
      * 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[];
+    private final double 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. 
+     * is the index of the last non-null element of the array, or 0 if all elements
+     * are null. 
      * <p>
      * The constructor makes a copy of the input array and assigns the copy to
      * the coefficients property.</p>
      * 
-     * @param c polynominal coefficients
+     * @param c polynomial coefficients
      * @throws NullPointerException if c is null
      * @throws IllegalArgumentException if c is empty
      */
@@ -59,8 +60,12 @@
         if (c.length < 1) {
             throw new IllegalArgumentException("Polynomial coefficient array must have postive
length.");
         }
-        this.coefficients = new double[c.length];
-        System.arraycopy(c, 0, this.coefficients, 0, c.length);
+        int l = c.length;
+        while ((l > 1) && (c[l - 1] == 0)) {
+            --l;
+        }
+        this.coefficients = new double[l];
+        System.arraycopy(c, 0, this.coefficients, 0, l);
     }
 
     /**
@@ -97,9 +102,7 @@
      * @return  a fresh copy of the coefficients array
      */
     public double[] getCoefficients() {
-        double[] out = new double[coefficients.length];
-        System.arraycopy(coefficients,0, out, 0, coefficients.length);
-        return out;
+        return coefficients.clone();
     }
     
     /**
@@ -123,7 +126,96 @@
         }
         return result;
     }
-    
+
+    /**
+     * Add a polynomial to the instance.
+     * @param p polynomial to add
+     * @return a new polynomial which is the sum of the instance and p
+     */
+    public PolynomialFunction add(final PolynomialFunction p) {
+
+        // identify the lowest degree polynomial
+        final int lowLength  = Math.min(coefficients.length, p.coefficients.length);
+        final int highLength = Math.max(coefficients.length, p.coefficients.length);
+
+        // build the coefficients array
+        double[] newCoefficients = new double[highLength];
+        for (int i = 0; i < lowLength; ++i) {
+            newCoefficients[i] = coefficients[i] + p.coefficients[i];
+        }
+        System.arraycopy((coefficients.length < p.coefficients.length) ?
+                         p.coefficients : coefficients,
+                         lowLength,
+                         newCoefficients, lowLength,
+                         highLength - lowLength);
+
+        return new PolynomialFunction(newCoefficients);
+
+    }
+
+    /**
+     * Subtract a polynomial from the instance.
+     * @param p polynomial to subtract
+     * @return a new polynomial which is the difference the instance minus p
+     */
+    public PolynomialFunction subtract(final PolynomialFunction p) {
+
+        // identify the lowest degree polynomial
+        int lowLength  = Math.min(coefficients.length, p.coefficients.length);
+        int highLength = Math.max(coefficients.length, p.coefficients.length);
+
+        // build the coefficients array
+        double[] newCoefficients = new double[highLength];
+        for (int i = 0; i < lowLength; ++i) {
+            newCoefficients[i] = coefficients[i] - p.coefficients[i];
+        }
+        if (coefficients.length < p.coefficients.length) {
+            for (int i = lowLength; i < highLength; ++i) {
+                newCoefficients[i] = -p.coefficients[i];
+            }
+        } else {
+            System.arraycopy(coefficients, lowLength, newCoefficients, lowLength,
+                             highLength - lowLength);
+        }
+
+        return new PolynomialFunction(newCoefficients);
+
+    }
+
+    /**
+     * Negate the instance.
+     * @return a new polynomial
+     */
+    public PolynomialFunction negate() {
+        double[] newCoefficients = new double[coefficients.length];
+        for (int i = 0; i < coefficients.length; ++i) {
+            newCoefficients[i] = -coefficients[i];
+        }
+        return new PolynomialFunction(newCoefficients);
+    }
+
+    /**
+     * Multiply the instance by a polynomial.
+     * @param p polynomial to multiply by
+     * @return a new polynomial
+     */
+    public PolynomialFunction multiply(final PolynomialFunction p) {
+
+        double[] newCoefficients = new double[coefficients.length + p.coefficients.length
- 1];
+
+        for (int i = 0; i < newCoefficients.length; ++i) {
+            newCoefficients[i] = 0.0;
+            for (int j = Math.max(0, i + 1 - p.coefficients.length);
+                 j < Math.min(coefficients.length, i + 1);
+                 ++j) {
+                newCoefficients[i] += coefficients[j] * p.coefficients[i-j];
+            }
+        }
+
+        return new PolynomialFunction(newCoefficients);
+
+    }
+
     /**
      * Returns the coefficients of the derivative of the polynomial with the given coefficients.
      * 
@@ -164,5 +256,66 @@
     public UnivariateRealFunction derivative() {
         return polynomialDerivative();
     }
-   
+
+    /** Returns a string representation of the polynomial.
+
+     * <p>The representation is user oriented. Terms are displayed lowest
+     * degrees first. The multiplications signs, coefficients equals to
+     * one and null terms are not displayed (except if the polynomial is 0,
+     * in which case the 0 constant term is displayed). Addition of terms
+     * with negative coefficients are replaced by subtraction of terms
+     * with positive coefficients except for the first displayed term
+     * (i.e. we display <code>-3</code> for a constant negative polynomial,
+     * but <code>1 - 3 x + x^2</code> if the negative coefficient is not
+     * the first one displayed).</p>
+
+     * @return a string representation of the polynomial
+
+     */
+     public String toString() {
+
+       StringBuffer s = new StringBuffer();
+       if (coefficients[0] == 0.0) {
+         if (coefficients.length == 1) {
+           return "0";
+         }
+       } else {
+         s.append(Double.toString(coefficients[0]));
+       }
+
+       for (int i = 1; i < coefficients.length; ++i) {
+
+         if (coefficients[i] != 0) {
+
+           if (s.length() > 0) {
+             if (coefficients[i] < 0) {
+               s.append(" - ");
+             } else {
+               s.append(" + ");
+             }
+           } else {
+             if (coefficients[i] < 0) {
+               s.append("-");
+             }
+           }
+
+           double absAi = Math.abs(coefficients[i]);
+           if ((absAi - 1) != 0) {
+             s.append(Double.toString(absAi));
+             s.append(' ');
+           }
+
+           s.append("x");
+           if (i > 1) {
+             s.append('^');
+             s.append(Integer.toString(i));
+           }
+         }
+
+       }
+
+       return s.toString();
+
+     }
+
 }

Modified: commons/proper/math/trunk/src/site/xdoc/changes.xml
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/site/xdoc/changes.xml?rev=739834&r1=739833&r2=739834&view=diff
==============================================================================
--- commons/proper/math/trunk/src/site/xdoc/changes.xml (original)
+++ commons/proper/math/trunk/src/site/xdoc/changes.xml Sun Feb  1 20:56:12 2009
@@ -39,6 +39,9 @@
   </properties>
   <body>
     <release version="2.0" date="TBD" description="TBD">
+      <action dev="luc" type="add" >
+        Added add, subtract, negate, multiply and toString methods to PolynomialFunction.
+      </action> 
       <action dev="psteitz" type="update" issue="MATH-189">
         Changed FractionFormat to extend NumberFormat.
       </action> 

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java?rev=739834&r1=739833&r2=739834&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java
(original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/analysis/polynomials/PolynomialFunctionTest.java
Sun Feb  1 20:56:12 2009
@@ -160,4 +160,80 @@
 
     }
 
+    public void testString() {
+        PolynomialFunction p = new PolynomialFunction(new double[] { -5.0, 3.0, 1.0 });
+        checkPolynomial(p, "-5.0 + 3.0 x + x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 0.0, -2.0, 3.0 }),
+                        "-2.0 x + 3.0 x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 1.0, -2.0, 3.0 }),
+                      "1.0 - 2.0 x + 3.0 x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 0.0,  2.0, 3.0 }),
+                       "2.0 x + 3.0 x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 1.0,  2.0, 3.0 }),
+                     "1.0 + 2.0 x + 3.0 x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 1.0,  0.0, 3.0 }),
+                     "1.0 + 3.0 x^2");
+        checkPolynomial(new PolynomialFunction(new double[] { 0.0 }),
+                     "0");
+    }
+
+    public void testAddition() {
+
+        PolynomialFunction p1 = new PolynomialFunction(new double[] { -2.0, 1.0 });
+        PolynomialFunction p2 = new PolynomialFunction(new double[] { 2.0, -1.0, 0.0 });
+        checkNullPolynomial(p1.add(p2));
+
+        p2 = p1.add(p1);
+        checkPolynomial(p2, "-4.0 + 2.0 x");
+
+        p1 = new PolynomialFunction(new double[] { 1.0, -4.0, 2.0 });
+        p2 = new PolynomialFunction(new double[] { -1.0, 3.0, -2.0 });
+        p1 = p1.add(p2);
+        assertEquals(1, p1.degree());
+        checkPolynomial(p1, "-x");
+
+    }
+
+    public void testSubtraction() {
+
+        PolynomialFunction p1 = new PolynomialFunction(new double[] { -2.0, 1.0 });
+        checkNullPolynomial(p1.subtract(p1));
+
+        PolynomialFunction p2 = new PolynomialFunction(new double[] { -2.0, 6.0 });
+        p2 = p2.subtract(p1);
+        checkPolynomial(p2, "5.0 x");
+
+        p1 = new PolynomialFunction(new double[] { 1.0, -4.0, 2.0 });
+        p2 = new PolynomialFunction(new double[] { -1.0, 3.0, 2.0 });
+        p1 = p1.subtract(p2);
+        assertEquals(1, p1.degree());
+        checkPolynomial(p1, "2.0 - 7.0 x");
+
+    }
+
+    public void testMultiplication() {
+
+        PolynomialFunction p1 = new PolynomialFunction(new double[] { -3.0, 2.0 });
+        PolynomialFunction p2 = new PolynomialFunction(new double[] { 3.0, 2.0, 1.0 });
+        checkPolynomial(p1.multiply(p2), "-9.0 + x^2 + 2.0 x^3");
+
+        p1 = new PolynomialFunction(new double[] { 0.0, 1.0 });
+        p2 = p1;
+        for (int i = 2; i < 10; ++i) {
+            p2 = p2.multiply(p1);
+            checkPolynomial(p2, "x^" + i);
+        }
+
+    }
+
+    public void checkPolynomial(PolynomialFunction p, String reference) {
+        assertEquals(reference, p.toString());
+    }
+
+    private void checkNullPolynomial(PolynomialFunction p) {
+        for (double coefficient : p.getCoefficients()) {
+            assertEquals(0.0, coefficient, 1.0e-15);
+        }
+    }
+
 }



Mime
View raw message