commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r701883 - in /commons/proper/math/branches/MATH_2_0/src: java/org/apache/commons/math/linear/RealVector.java java/org/apache/commons/math/linear/RealVectorImpl.java test/org/apache/commons/math/linear/RealVectorImplTest.java
Date Sun, 05 Oct 2008 20:37:16 GMT
Author: luc
Date: Sun Oct  5 13:37:15 2008
New Revision: 701883

URL: http://svn.apache.org/viewvc?rev=701883&view=rev
Log:
added methods to operate directly on double arrays

Modified:
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVector.java
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorImplTest.java

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVector.java?rev=701883&r1=701882&r2=701883&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVector.java
(original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVector.java
Sun Oct  5 13:37:15 2008
@@ -57,6 +57,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Compute the sum of this and v.
+     * @param v vector to be added
+     * @return this + v
+     * @throws IllegalArgumentException if v is not the same size as this
+     */
+    RealVector add(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Compute this minus v.
      * @param v vector to be subtracted
      * @return this + v
@@ -66,6 +75,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Compute this minus v.
+     * @param v vector to be subtracted
+     * @return this + v
+     * @throws IllegalArgumentException if v is not the same size as this
+     */
+    RealVector subtract(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Map an addition operation to each entry.
      * @param d value to be added to each entry
      * @return this + d
@@ -449,6 +467,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Element-by-element multiplication.
+     * @param v vector by which instance elements must be multiplied
+     * @return a vector containing this[i] * v[i] for all i
+     * @throws IllegalArgumentException if v is not the same size as this
+     */
+    public RealVector ebeMultiply(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Element-by-element division.
      * @param v vector by which instance elements must be divided
      * @return a vector containing this[i] / v[i] for all i
@@ -458,6 +485,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Element-by-element division.
+     * @param v vector by which instance elements must be divided
+     * @return a vector containing this[i] / v[i] for all i
+     * @throws IllegalArgumentException if v is not the same size as this
+     */
+    public RealVector ebeDivide(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Returns vector entries as a double array.
      * @return double array of entries
      */
@@ -473,6 +509,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Compute the dot product.
+     * @param v vector with which dot product should be computed
+     * @return the scalar dot product between instance and v
+     * @exception IllegalArgumentException if v is not the same size as this
+     */
+    double dotProduct(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Returns the L<sub>2</sub> norm of the vector.
      * <p>The L<sub>2</sub> norm is the root of the sum of
      * the squared elements.</p>
@@ -522,6 +567,21 @@
 
     /**
      * Distance between two vectors.
+     * <p>This method computes the distance consistent with the
+     * L<sub>2</sub> norm, i.e. the square root of the sum of
+     * elements differences, or euclidian distance.</p>
+     * @param v vector to which distance is requested
+     * @return distance between two vectors.
+     * @exception IllegalArgumentException if v is not the same size as this
+     * @see #getL1Distance(double[])
+     * @see #getLInfDistance(double[])
+     * @see #getNorm()
+     */
+    double getDistance(double[] v)
+        throws IllegalArgumentException;
+
+    /**
+     * Distance between two vectors.
      * <p>This method computes the distance consistent with
      * L<sub>1</sub> norm, i.e. the sum of the absolute values of
      * elements differences.</p>
@@ -538,6 +598,21 @@
     /**
      * Distance between two vectors.
      * <p>This method computes the distance consistent with
+     * L<sub>1</sub> norm, i.e. the sum of the absolute values of
+     * elements differences.</p>
+     * @param v vector to which distance is requested
+     * @return distance between two vectors.
+     * @exception IllegalArgumentException if v is not the same size as this
+     * @see #getDistance(double[])
+     * @see #getLInfDistance(double[])
+     * @see #getL1Norm()
+     */
+    double getL1Distance(double[] v)
+        throws IllegalArgumentException;
+
+    /**
+     * Distance between two vectors.
+     * <p>This method computes the distance consistent with
      * L<sub>&infty;</sub> norm, i.e. the max of the absolute values of
      * elements differences.</p>
      * @param v vector to which distance is requested
@@ -550,6 +625,21 @@
     double getLInfDistance(RealVector v)
         throws IllegalArgumentException;
 
+    /**
+     * Distance between two vectors.
+     * <p>This method computes the distance consistent with
+     * L<sub>&infty;</sub> norm, i.e. the max of the absolute values of
+     * elements differences.</p>
+     * @param v vector to which distance is requested
+     * @return distance between two vectors.
+     * @exception IllegalArgumentException if v is not the same size as this
+     * @see #getDistance(double[])
+     * @see #getL1Distance(double[])
+     * @see #getLInfNorm()
+     */
+    double getLInfDistance(double[] v)
+        throws IllegalArgumentException;
+
     /** Creates a unit vector pointing in the direction of this vector.
      * <p>The instance is not changed by this method.</p>
      * @return a unit vector pointing in direction of this vector
@@ -571,6 +661,14 @@
     RealVector projection(RealVector v)
         throws IllegalArgumentException;
 
+    /** Find the orthogonal projection of this vector onto another vector.
+     * @param v vector onto which instance must be projected
+     * @return projection of the instance onto v
+     * @throws IllegalArgumentException if v is not the same size as this
+     */
+    RealVector projection(double[] v)
+        throws IllegalArgumentException;
+
     /**
      * Compute the outer product.
      * @param v vector with which outer product should be computed
@@ -581,6 +679,15 @@
         throws IllegalArgumentException;
 
     /**
+     * Compute the outer product.
+     * @param v vector with which outer product should be computed
+     * @return the square matrix outer product between instance and v
+     * @exception IllegalArgumentException if v is not the same size as this
+     */
+    RealMatrix outerProduct(double[] v)
+        throws IllegalArgumentException;
+
+    /**
      * Returns the entry in the specified index.
      * <p>
      * The index start at 0 and must be lesser than the size,
@@ -652,6 +759,16 @@
         throws MatrixIndexException;
 
     /**
+     * Set a set of consecutive elements.
+     * @param index index of first element to be set.
+     * @param v vector containing the values to set.
+     * @exception MatrixIndexException if the index is
+     * inconsistent with vector size
+     */
+    void set(int index, double[] v)
+        throws MatrixIndexException;
+
+    /**
      * Set all elements to a single value.
      * @param value single value to set for all elements
      */

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java?rev=701883&r1=701882&r2=701883&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java
(original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java
Sun Oct  5 13:37:15 2008
@@ -29,7 +29,7 @@
 public class RealVectorImpl implements RealVector, Serializable {
 
     /** Serializable version identifier. */
-    private static final long serialVersionUID = 7838747548772166404L;
+    private static final long serialVersionUID = -1097961340710804027L;
 
     /** Default format. */
     private static final RealVectorFormat DEFAULT_FORMAT =
@@ -186,6 +186,39 @@
         System.arraycopy(v2.data, 0, data, v1.data.length, v2.data.length);
     }
 
+    /**
+     * Construct a vector by appending one vector to another vector.
+     * @param v1 first vector (will be put in front of the new vector)
+     * @param v2 second vector (will be put at back of the new vector)
+     */
+    public RealVectorImpl(RealVectorImpl v1, double[] v2) {
+        data = new double[v1.data.length + v2.length];
+        System.arraycopy(v1.data, 0, data, 0, v1.data.length);
+        System.arraycopy(v2, 0, data, v1.data.length, v2.length);
+    }
+
+    /**
+     * Construct a vector by appending one vector to another vector.
+     * @param v1 first vector (will be put in front of the new vector)
+     * @param v2 second vector (will be put at back of the new vector)
+     */
+    public RealVectorImpl(double[] v1, RealVectorImpl v2) {
+        data = new double[v1.length + v2.data.length];
+        System.arraycopy(v1, 0, data, 0, v1.length);
+        System.arraycopy(v2.data, 0, data, v1.length, v2.data.length);
+    }
+
+    /**
+     * Construct a vector by appending one vector to another vector.
+     * @param v1 first vector (will be put in front of the new vector)
+     * @param v2 second vector (will be put at back of the new vector)
+     */
+    public RealVectorImpl(double[] v1, double[] v2) {
+        data = new double[v1.length + v2.length];
+        System.arraycopy(v1, 0, data, 0, v1.length);
+        System.arraycopy(v2, 0, data, v1.length, v2.length);
+    }
+
     /** {@inheritDoc} */
     public RealVector copy() {
         return new RealVectorImpl(this, true);
@@ -206,6 +239,17 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public RealVector add(double[] v)
+    throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double[] out = new double[data.length];
+        for (int i = 0; i < data.length; i++) {
+            out[i] = data[i] + v[i];
+        }
+        return new RealVectorImpl(out);
+    }
+
     /**
      * Compute the sum of this and v.
      * @param v vector to be added
@@ -214,12 +258,7 @@
      */
     public RealVectorImpl add(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double[] out = new double[data.length];
-        for (int i = 0; i < data.length; i++) {
-            out[i] = data[i] + v.data[i];
-        }
-        return new RealVectorImpl(out);
+        return (RealVectorImpl) add(v.data);
     }
 
     /** {@inheritDoc} */
@@ -237,6 +276,17 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public RealVector subtract(double[] v)
+    throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double[] out = new double[data.length];
+        for (int i = 0; i < data.length; i++) {
+            out[i] = data[i] - v[i];
+        }
+        return new RealVectorImpl(out);
+    }
+
     /**
      * Compute this minus v.
      * @param v vector to be subtracted
@@ -245,12 +295,7 @@
      */
     public RealVectorImpl subtract(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double[] out = new double[data.length];
-        for (int i = 0; i < data.length; i++) {
-            out[i] = data[i] - v.data[i];
-        }
-        return new RealVectorImpl(out);
+        return (RealVectorImpl) subtract(v.data);
     }
 
     /** {@inheritDoc} */
@@ -744,6 +789,17 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public RealVector ebeMultiply(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double[] out = new double[data.length];
+        for (int i = 0; i < data.length; i++) {
+            out[i] = data[i] * v[i];
+        }
+        return new RealVectorImpl(out);
+    }
+
     /**
      * Element-by-element multiplication.
      * @param v vector by which instance elements must be multiplied
@@ -752,12 +808,7 @@
      */
     public RealVectorImpl ebeMultiply(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double[] out = new double[data.length];
-        for (int i = 0; i < data.length; i++) {
-            out[i] = data[i] * v.data[i];
-        }
-        return new RealVectorImpl(out);
+        return (RealVectorImpl) ebeMultiply(v.data);
     }
 
     /** {@inheritDoc} */
@@ -775,6 +826,17 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public RealVector ebeDivide(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double[] out = new double[data.length];
+        for (int i = 0; i < data.length; i++) {
+                out[i] = data[i] / v[i];
+        }
+        return new RealVectorImpl(out);
+    }
+
     /**
      * Element-by-element division.
      * @param v vector by which instance elements must be divided
@@ -783,12 +845,7 @@
      */
     public RealVectorImpl ebeDivide(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double[] out = new double[data.length];
-        for (int i = 0; i < data.length; i++) {
-                out[i] = data[i] / v.data[i];
-        }
-        return new RealVectorImpl(out);
+        return (RealVectorImpl) ebeDivide(v.data);
     }
 
     /** {@inheritDoc} */
@@ -820,6 +877,17 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public double dotProduct(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double dot = 0;
+        for (int i = 0; i < data.length; i++) {
+            dot += data[i] * v[i];
+        }
+        return dot;
+    }
+
     /**
      * Compute the dot product.
      * @param v vector with which dot product should be computed
@@ -828,12 +896,7 @@
      */
     public double dotProduct(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double dot = 0;
-        for (int i = 0; i < data.length; i++) {
-            dot += data[i] * v.getEntry(i);
-        }
-        return dot;
+        return dotProduct(v.data);
     }
 
     /** {@inheritDoc} */
@@ -879,7 +942,19 @@
         }
     }
 
-    /**
+    /** {@inheritDoc} */
+    public double getDistance(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double sum = 0;
+        for (int i = 0; i < data.length; ++i) {
+            final double delta = data[i] - v[i];
+            sum += delta * delta;
+        }
+        return Math.sqrt(sum);
+    }
+
+   /**
      * Distance between two vectors.
      * <p>This method computes the distance consistent with the
      * L<sub>2</sub> norm, i.e. the square root of the sum of
@@ -894,13 +969,7 @@
      */
     public double getDistance(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double sum = 0;
-        for (int i = 0; i < data.length; ++i) {
-            final double delta = data[i] - v.data[i];
-            sum += delta * delta;
-        }
-        return Math.sqrt(sum);
+        return getDistance(v.data);
     }
 
     /** {@inheritDoc} */
@@ -919,6 +988,18 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public double getL1Distance(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double sum = 0;
+        for (int i = 0; i < data.length; ++i) {
+            final double delta = data[i] - v[i];
+            sum += Math.abs(delta);
+        }
+        return sum;
+    }
+
     /**
      * Distance between two vectors.
      * <p>This method computes the distance consistent with
@@ -934,13 +1015,7 @@
      */
     public double getL1Distance(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double sum = 0;
-        for (int i = 0; i < data.length; ++i) {
-            final double delta = data[i] - v.data[i];
-            sum += Math.abs(delta);
-        }
-        return sum;
+        return getL1Distance(v.data);
     }
 
     /** {@inheritDoc} */
@@ -959,6 +1034,18 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public double getLInfDistance(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double max = 0;
+        for (int i = 0; i < data.length; ++i) {
+            final double delta = data[i] - v[i];
+            max = Math.max(max, Math.abs(delta));
+        }
+        return max;
+    }
+
     /**
      * Distance between two vectors.
      * <p>This method computes the distance consistent with
@@ -974,13 +1061,7 @@
      */
     public double getLInfDistance(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double max = 0;
-        for (int i = 0; i < data.length; ++i) {
-            final double delta = data[i] - v.data[i];
-            max = Math.max(max, Math.abs(delta));
-        }
-        return max;
+        return getLInfDistance(v.data);
     }
 
     /** {@inheritDoc} */
@@ -1008,7 +1089,12 @@
         return v.mapMultiply(dotProduct(v) / v.dotProduct(v));
     }
 
-    /** Find the orthogonal projection of this vector onto another vector.
+    /** {@inheritDoc} */
+    public RealVector projection(double[] v) {
+        return projection(new RealVectorImpl(v, false));
+    }
+
+   /** Find the orthogonal projection of this vector onto another vector.
      * @param v vector onto which instance must be projected
      * @return projection of the instance onto v
      * @throws IllegalArgumentException if v is not the same size as this
@@ -1034,6 +1120,19 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public RealMatrix outerProduct(double[] v)
+        throws IllegalArgumentException {
+        checkVectorDimensions(v.length);
+        double[][] out = new double[data.length][data.length];
+        for (int i = 0; i < data.length; i++) {
+            for (int j = 0; j < data.length; j++) {
+                out[i][j] = data[i] * v[j];
+            }
+        }
+        return new RealMatrixImpl(out);
+    }
+
     /**
      * Compute the outer product.
      * @param v vector with which outer product should be computed
@@ -1042,14 +1141,7 @@
      */
     public RealMatrixImpl outerProduct(RealVectorImpl v)
         throws IllegalArgumentException {
-        checkVectorDimensions(v);
-        double[][] out = new double[data.length][data.length];
-        for (int i = 0; i < data.length; i++) {
-            for (int j = 0; j < data.length; j++) {
-                out[i][j] = data[i] * v.data[j];
-            }
-        }
-        return new RealMatrixImpl(out);
+        return (RealMatrixImpl) outerProduct(v.data);
     }
 
     /** {@inheritDoc} */
@@ -1090,10 +1182,7 @@
 
     /** {@inheritDoc} */
     public RealVector append(double[] in) {
-        final double[] out = new double[data.length + in.length];
-        System.arraycopy(data, 0, out, 0, data.length);
-        System.arraycopy(in, 0, out, data.length, in.length);
-        return new RealVectorImpl(out);
+        return new RealVectorImpl(this, in);
     }
 
     /** {@inheritDoc} */
@@ -1132,6 +1221,15 @@
         }
     }
 
+    /** {@inheritDoc} */
+    public void set(int index, double[] v) {
+        try {
+            System.arraycopy(v, 0, data, index, v.length);
+        } catch (IndexOutOfBoundsException e) {
+            throw new MatrixIndexException(e.getMessage());
+        }
+    }
+
     /**
      * Set a set of consecutive elements.
      * 
@@ -1142,11 +1240,7 @@
      */
     public void set(int index, RealVectorImpl v)
         throws MatrixIndexException {
-        try {
-            System.arraycopy(v.data, 0, data, index, v.data.length);
-        } catch (IndexOutOfBoundsException e) {
-            throw new MatrixIndexException(e.getMessage());
-        }
+        set(index, v.data);
     }
 
     /** {@inheritDoc} */

Modified: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorImplTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorImplTest.java?rev=701883&r1=701882&r2=701883&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorImplTest.java
(original)
+++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorImplTest.java
Sun Oct  5 13:37:15 2008
@@ -47,7 +47,7 @@
     public static class RealVectorTestImpl implements RealVector, Serializable {
 
         /** Serializable version identifier. */
-        private static final long serialVersionUID = 8731816072271374422L;
+        private static final long serialVersionUID = 4715341047369582908L;
 
         /** Entries of the vector. */
         protected double data[];
@@ -68,10 +68,18 @@
             throw unsupported();
         }
 
+        public RealVector add(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public RealVector subtract(RealVector v) throws IllegalArgumentException {
             throw unsupported();
         }
 
+        public RealVector subtract(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public RealVector mapAdd(double d) {
             throw unsupported();
         }
@@ -304,17 +312,23 @@
             throw unsupported();
         }
 
+        public RealVector ebeMultiply(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public RealVector ebeDivide(RealVector v) throws IllegalArgumentException {
             throw unsupported();
         }
 
+        public RealVector ebeDivide(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public double[] getData() {
             return data.clone();
         }
 
         public double dotProduct(RealVector v) throws IllegalArgumentException {
-
-            //	checkVectorDimensions(v);
             double dot = 0;
             for (int i = 0; i < data.length; i++) {
                 dot += data[i] * v.getEntry(i);
@@ -322,6 +336,14 @@
             return dot;
         }
 
+        public double dotProduct(double[] v) throws IllegalArgumentException {
+            double dot = 0;
+            for (int i = 0; i < data.length; i++) {
+                dot += data[i] * v[i];
+            }
+            return dot;
+        }
+
         public double getNorm() {
             throw unsupported();
         }
@@ -338,14 +360,26 @@
             throw unsupported();
         }
 
+        public double getDistance(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public double getL1Distance(RealVector v) throws IllegalArgumentException {
             throw unsupported();
         }
 
+        public double getL1Distance(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public double getLInfDistance(RealVector v) throws IllegalArgumentException {
             throw unsupported();
         }
 
+        public double getLInfDistance(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public RealVector unitVector() {
             throw unsupported();
         }
@@ -358,10 +392,18 @@
             throw unsupported();
         }
 
+        public RealVector projection(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public RealMatrix outerProduct(RealVector v) throws IllegalArgumentException {
             throw unsupported();
         }
 
+        public RealMatrix outerProduct(double[] v) throws IllegalArgumentException {
+            throw unsupported();
+        }
+
         public double getEntry(int index) throws MatrixIndexException {
             return data[index];
         }
@@ -394,6 +436,10 @@
             throw unsupported();
         }
 
+        public void set(int index, double[] v) throws MatrixIndexException {
+            throw unsupported();
+        }
+
         public void set(double value) {
             throw unsupported();
         }



Mime
View raw message