Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Support for one dimensional vectors has been added to the linear algebra 

package with a RealVector interface, a RealVectorImpl default implementation
using a single double array to store elements and a RealVectorFormat class for
input/output.


git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/branches/MATH_2_0@680166 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe 2008-07-27 19:15:22 +00:00
parent 6ef68ad4a9
commit b47b287663
13 changed files with 4199 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
findbugs-exclude-filter.xml
View File

@ -82,6 +82,11 @@
<Method name="getValues" params="" returns="double[]" /> <Method name="getValues" params="" returns="double[]" />
<Bug pattern="EI_EXPOSE_REP" /> <Bug pattern="EI_EXPOSE_REP" />
</Match> </Match>
<Match>
<Class name="org.apache.commons.math.linear.RealVectorImpl"/>
<Method name="getDataRef" params="" returns="double[]" />
<Bug pattern="EI_EXPOSE_REP" />
</Match>
<!-- The following cases are intentional unit tests for null parameters --> <!-- The following cases are intentional unit tests for null parameters -->
<Match> <Match>

3
pom.xml
View File

@ -126,6 +126,9 @@
<contributor> <contributor>
<name>Todd C. Parnell</name> <name>Todd C. Parnell</name>
</contributor> </contributor>
<contributor>
<name>Andreas Rieger</name>
</contributor>
<contributor> <contributor>
<name>Joni Salonen</name> <name>Joni Salonen</name>
</contributor> </contributor>

51
src/java/org/apache/commons/math/linear/RealMatrix.java
View File

@ -148,6 +148,26 @@ public interface RealMatrix {
* @throws MatrixIndexException if the specified column index is invalid * @throws MatrixIndexException if the specified column index is invalid
*/ */
RealMatrix getColumnMatrix(int column) throws MatrixIndexException; RealMatrix getColumnMatrix(int column) throws MatrixIndexException;
/**
* Returns the entries in row number <code>row</code>
* as a vector. Row indices start at 0.
*
* @param row the row to be fetched
* @return row vector
* @throws MatrixIndexException if the specified row index is invalid
*/
RealVector getRowVector(int row) throws MatrixIndexException;
/**
* Returns the entries in column number <code>column</code>
* as a column vector. Column indices start at 0.
*
* @param column the column to be fetched
* @return column vector
* @throws MatrixIndexException if the specified column index is invalid
*/
RealVector getColumnVector(int column) throws MatrixIndexException;
/** /**
* Returns the entries in row number <code>row</code> as an array. * Returns the entries in row number <code>row</code> as an array.
@ -255,6 +275,15 @@ public interface RealMatrix {
*/ */
double[] operate(double[] v) throws IllegalArgumentException; double[] operate(double[] v) throws IllegalArgumentException;
/**
* Returns the result of multiplying this by the vector <code>v</code>.
*
* @param v the vector to operate on
* @return this*v
* @throws IllegalArgumentException if columnDimension != v.size()
*/
RealVector operate(RealVector v) throws IllegalArgumentException;
/** /**
* Returns the (row) vector result of premultiplying this by the vector <code>v</code>. * Returns the (row) vector result of premultiplying this by the vector <code>v</code>.
* *
@ -264,6 +293,15 @@ public interface RealMatrix {
*/ */
double[] preMultiply(double[] v) throws IllegalArgumentException; double[] preMultiply(double[] v) throws IllegalArgumentException;
/**
* Returns the (row) vector result of premultiplying this by the vector <code>v</code>.
*
* @param v the row vector to premultiply by
* @return v*this
* @throws IllegalArgumentException if rowDimension != v.size()
*/
RealVector preMultiply(RealVector v) throws IllegalArgumentException;
/** /**
* Returns the solution vector for a linear system with coefficient * Returns the solution vector for a linear system with coefficient
* matrix = this and constant vector = <code>b</code>. * matrix = this and constant vector = <code>b</code>.
@ -275,6 +313,17 @@ public interface RealMatrix {
*/ */
double[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException; double[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException;
/**
* Returns the solution vector for a linear system with coefficient
* matrix = this and constant vector = <code>b</code>.
*
* @param b constant vector
* @return vector of solution values to AX = b, where A is *this
* @throws IllegalArgumentException if this.rowDimension != b.length
* @throws InvalidMatrixException if this matrix is not square or is singular
*/
RealVector solve(RealVector b) throws IllegalArgumentException, InvalidMatrixException;
/** /**
* Returns a matrix of (column) solution vectors for linear systems with * Returns a matrix of (column) solution vectors for linear systems with
* coefficient matrix = this and constant vectors = columns of * coefficient matrix = this and constant vectors = columns of
@ -287,5 +336,5 @@ public interface RealMatrix {
* @throws InvalidMatrixException if this matrix is not square or is singular * @throws InvalidMatrixException if this matrix is not square or is singular
*/ */
RealMatrix solve(RealMatrix b) throws IllegalArgumentException, InvalidMatrixException; RealMatrix solve(RealMatrix b) throws IllegalArgumentException, InvalidMatrixException;
}
}

193
src/java/org/apache/commons/math/linear/RealMatrixImpl.java
View File

@ -52,7 +52,7 @@ import org.apache.commons.math.util.MathUtils;
public class RealMatrixImpl implements RealMatrix, Serializable { public class RealMatrixImpl implements RealMatrix, Serializable {
/** Serializable version identifier */ /** Serializable version identifier */
private static final long serialVersionUID = -4828886979278117018L; private static final long serialVersionUID = 4970229902484487012L;
/** Entries of the matrix */ /** Entries of the matrix */
protected double data[][] = null; protected double data[][] = null;
@ -600,7 +600,17 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
return new RealMatrixImpl(out, false); return new RealMatrixImpl(out, false);
} }
/** /** {@inheritDoc} */
public RealVector getColumnVector(int column) throws MatrixIndexException {
return new RealVectorImpl(getColumn(column), false);
}
/** {@inheritDoc} */
public RealVector getRowVector(int row) throws MatrixIndexException {
return new RealVectorImpl(getRow(row), false);
}
/**
* Returns the entries in row number <code>row</code> as an array. * Returns the entries in row number <code>row</code> as an array.
* <p> * <p>
* Row indices start at 0. A <code>MatrixIndexException</code> is thrown * Row indices start at 0. A <code>MatrixIndexException</code> is thrown
@ -788,6 +798,40 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
return out; return out;
} }
/** {@inheritDoc} */
public RealVector operate(RealVector v) throws IllegalArgumentException {
try {
return operate((RealVectorImpl) v);
} catch (ClassCastException cce) {
final int nRows = this.getRowDimension();
final int nCols = this.getColumnDimension();
if (v.getDimension() != nCols) {
throw new IllegalArgumentException("vector has wrong length");
}
final double[] out = new double[nRows];
for (int row = 0; row < nRows; row++) {
final double[] dataRow = data[row];
double sum = 0;
for (int i = 0; i < nCols; i++) {
sum += dataRow[i] * v.getEntry(i);
}
out[row] = sum;
}
return new RealVectorImpl(out, false);
}
}
/**
* Returns the result of multiplying this by the vector <code>v</code>.
*
* @param v the vector to operate on
* @return this*v
* @throws IllegalArgumentException if columnDimension != v.size()
*/
public RealVectorImpl operate(RealVectorImpl v) throws IllegalArgumentException {
return new RealVectorImpl(operate(v.getDataRef()), false);
}
/** /**
* @param v vector to premultiply by * @param v vector to premultiply by
* @throws IllegalArgumentException if rowDimension != v.length * @throws IllegalArgumentException if rowDimension != v.length
@ -810,6 +854,39 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
return out; return out;
} }
/** {@inheritDoc} */
public RealVector preMultiply(RealVector v) throws IllegalArgumentException {
try {
return preMultiply((RealVectorImpl) v);
} catch (ClassCastException cce) {
final int nRows = this.getRowDimension();
if (v.getDimension() != nRows) {
throw new IllegalArgumentException("vector has wrong length");
}
final int nCols = this.getColumnDimension();
final double[] out = new double[nCols];
for (int col = 0; col < nCols; col++) {
double sum = 0;
for (int i = 0; i < nRows; i++) {
sum += data[i][col] * v.getEntry(i);
}
out[col] = sum;
}
return new RealVectorImpl(out, false);
}
}
/**
* Returns the (row) vector result of premultiplying this by the vector <code>v</code>.
*
* @param v the row vector to premultiply by
* @return v*this
* @throws IllegalArgumentException if rowDimension != v.size()
*/
RealVectorImpl preMultiply(RealVectorImpl v) throws IllegalArgumentException {
return new RealVectorImpl(preMultiply(v.getDataRef()), false);
}
/** /**
* Returns a matrix of (column) solution vectors for linear systems with * Returns a matrix of (column) solution vectors for linear systems with
* coefficient matrix = this and constant vectors = columns of * coefficient matrix = this and constant vectors = columns of
@ -822,17 +899,105 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
* @throws InvalidMatrixException if this matrix is not square or is singular * @throws InvalidMatrixException if this matrix is not square or is singular
*/ */
public double[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException { public double[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException {
final int nRows = this.getRowDimension(); final int nRows = this.getRowDimension();
final int nCol = this.getColumnDimension();
if (b.length != nRows) { if (b.length != nRows) {
throw new IllegalArgumentException("constant vector has wrong length"); throw new IllegalArgumentException("constant vector has wrong length");
} }
final RealMatrix bMatrix = new RealMatrixImpl(b); if (!isSquare()) {
final double[][] solution = ((RealMatrixImpl) (solve(bMatrix))).getDataRef(); throw new InvalidMatrixException("coefficient matrix is not square");
final double[] out = new double[nRows];
for (int row = 0; row < nRows; row++) {
out[row] = solution[row][0];
} }
return out; if (isSingular()) { // side effect: compute LU decomp
throw new InvalidMatrixException("Matrix is singular.");
}
final double[] bp = new double[nRows];
// Apply permutations to b
for (int row = 0; row < nRows; row++) {
bp[row] = b[permutation[row]];
}
// Solve LY = b
for (int col = 0; col < nCol; col++) {
for (int i = col + 1; i < nCol; i++) {
bp[i] -= bp[col] * lu[i][col];
}
}
// Solve UX = Y
for (int col = nCol - 1; col >= 0; col--) {
bp[col] /= lu[col][col];
for (int i = 0; i < col; i++) {
bp[i] -= bp[col] * lu[i][col];
}
}
return bp;
}
/** {@inheritDoc} */
public RealVector solve(RealVector b)
throws IllegalArgumentException, InvalidMatrixException {
try {
return solve((RealVectorImpl) b);
} catch (ClassCastException cce) {
final int nRows = this.getRowDimension();
final int nCol = this.getColumnDimension();
if (b.getDimension() != nRows) {
throw new IllegalArgumentException("constant vector has wrong length");
}
if (!isSquare()) {
throw new InvalidMatrixException("coefficient matrix is not square");
}
if (isSingular()) { // side effect: compute LU decomp
throw new InvalidMatrixException("Matrix is singular.");
}
final double[] bp = new double[nRows];
// Apply permutations to b
for (int row = 0; row < nRows; row++) {
bp[row] = b.getEntry(permutation[row]);
}
// Solve LY = b
for (int col = 0; col < nCol; col++) {
for (int i = col + 1; i < nCol; i++) {
bp[i] -= bp[col] * lu[i][col];
}
}
// Solve UX = Y
for (int col = nCol - 1; col >= 0; col--) {
bp[col] /= lu[col][col];
for (int i = 0; i < col; i++) {
bp[i] -= bp[col] * lu[i][col];
}
}
return new RealVectorImpl(bp, false);
}
}
/**
* Returns the solution vector for a linear system with coefficient
* matrix = this and constant vector = <code>b</code>.
*
* @param b constant vector
* @return vector of solution values to AX = b, where A is *this
* @throws IllegalArgumentException if this.rowDimension != b.length
* @throws InvalidMatrixException if this matrix is not square or is singular
*/
RealVectorImpl solve(RealVectorImpl b)
throws IllegalArgumentException, InvalidMatrixException {
return new RealVectorImpl(solve(b.getDataRef()), false);
} }
/** /**
@ -865,18 +1030,20 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
final double[][] bp = new double[nRowB][nColB]; final double[][] bp = new double[nRowB][nColB];
for (int row = 0; row < nRowB; row++) { for (int row = 0; row < nRowB; row++) {
final double[] bpRow = bp[row]; final double[] bpRow = bp[row];
final int pRow = permutation[row];
for (int col = 0; col < nColB; col++) { for (int col = 0; col < nColB; col++) {
bpRow[col] = b.getEntry(permutation[row], col); bpRow[col] = b.getEntry(pRow, col);
} }
} }
// Solve LY = b // Solve LY = b
for (int col = 0; col < nCol; col++) { for (int col = 0; col < nCol; col++) {
final double[] bpCol = bp[col];
for (int i = col + 1; i < nCol; i++) { for (int i = col + 1; i < nCol; i++) {
final double[] bpI = bp[i]; final double[] bpI = bp[i];
final double[] luI = lu[i]; final double luICol = lu[i][col];
for (int j = 0; j < nColB; j++) { for (int j = 0; j < nColB; j++) {
bpI[j] -= bp[col][j] * luI[col]; bpI[j] -= bpCol[j] * luICol;
} }
} }
} }
@ -890,9 +1057,9 @@ public class RealMatrixImpl implements RealMatrix, Serializable {
} }
for (int i = 0; i < col; i++) { for (int i = 0; i < col; i++) {
final double[] bpI = bp[i]; final double[] bpI = bp[i];
final double[] luI = lu[i]; final double luICol = lu[i][col];
for (int j = 0; j < nColB; j++) { for (int j = 0; j < nColB; j++) {
bpI[j] -= bp[col][j] * luI[col]; bpI[j] -= bpCol[j] * luICol;
} }
} }
} }

682
src/java/org/apache/commons/math/linear/RealVector.java Normal file
View File

@ -0,0 +1,682 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.linear;
/**
* Interface defining a real-valued vector with basic algebraic operations.
* <p>
* vector element indexing is 0-based -- e.g., <code>getEntry(0)</code>
* returns the first element of the vector.
* </p>
* <p>
* The various <code>mapXxx</code> and <code>mapXxxToSelf</code> methods operate
* on vectors element-wise, i.e. they perform the same operation (adding a scalar,
* applying a function ...) on each element in turn. The <code>mapXxx</code>
* versions create a new vector to hold the result and do not change the instance.
* The <code>mapXxxToSelf</code> versions use the instance itself to store the
* results, so the instance is changed by these methods. In both cases, the result
* vector is returned by the methods, this allows to use the <i>fluent API</i>
* style, like this:
* </p>
* <pre>
* RealVector result = v.mapAddToSelf(3.0).mapTanToSelf().mapSquareToSelf();
* </pre>
*
* @version $Revision$ $Date$
* @since 2.0
*/
public interface RealVector {
/**
* Returns a (deep) copy of this.
* @return vector copy
*/
RealVector copy();
/**
* 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(RealVector v)
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(RealVector v)
throws IllegalArgumentException;
/**
* Map an addition operation to each entry.
* @param d value to be added to each entry
* @return this + d
*/
RealVector mapAdd(double d);
/**
* Map an addition operation to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @param d value to be added to each entry
* @return for convenience, return this
*/
RealVector mapAddToSelf(double d);
/**
* Map a subtraction operation to each entry.
* @param d value to be subtracted to each entry
* @return this - d
*/
RealVector mapSubtract(double d);
/**
* Map a subtraction operation to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @param d value to be subtracted to each entry
* @return for convenience, return this
*/
RealVector mapSubtractToSelf(double d);
/**
* Map a multiplication operation to each entry.
* @param d value to multiply all entries by
* @return this * d
*/
RealVector mapMultiply(double d);
/**
* Map a multiplication operation to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @param d value to multiply all entries by
* @return for convenience, return this
*/
RealVector mapMultiplyToSelf(double d);
/**
* Map a division operation to each entry.
* @param d value to divide all entries by
* @return this / d
*/
RealVector mapDivide(double d);
/**
* Map a division operation to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @param d value to divide all entries by
* @return for convenience, return this
*/
RealVector mapDivideToSelf(double d);
/**
* Map a power operation to each entry.
* @param d value to raise all entries to
* @return this ^ d
*/
RealVector mapPow(double d);
/**
* Map a power operation to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @param d value to raise all entries to
* @return for convenience, return this
*/
RealVector mapPowToSelf(double d);
/**
* Map the {@link Math#exp(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapExp();
/**
* Map the {@link Math#exp(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapExpToSelf();
/**
* Map the {@link Math#expm1(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapExpm1();
/**
* Map the {@link Math#expm1(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapExpm1ToSelf();
/**
* Map the {@link Math#log(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapLog();
/**
* Map the {@link Math#log(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapLogToSelf();
/**
* Map the {@link Math#log10(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapLog10();
/**
* Map the {@link Math#log10(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapLog10ToSelf();
/**
* Map the {@link Math#log1p(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapLog1p();
/**
* Map the {@link Math#log1p(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapLog1pToSelf();
/**
* Map the {@link Math#cosh(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapCosh();
/**
* Map the {@link Math#cosh(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapCoshToSelf();
/**
* Map the {@link Math#sinh(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapSinh();
/**
* Map the {@link Math#sinh(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapSinhToSelf();
/**
* Map the {@link Math#tanh(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapTanh();
/**
* Map the {@link Math#tanh(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapTanhToSelf();
/**
* Map the {@link Math#cos(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapCos();
/**
* Map the {@link Math#cos(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapCosToSelf();
/**
* Map the {@link Math#sin(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapSin();
/**
* Map the {@link Math#sin(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapSinToSelf();
/**
* Map the {@link Math#tan(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapTan();
/**
* Map the {@link Math#tan(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapTanToSelf();
/**
* Map the {@link Math#acos(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapAcos();
/**
* Map the {@link Math#acos(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapAcosToSelf();
/**
* Map the {@link Math#asin(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapAsin();
/**
* Map the {@link Math#asin(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapAsinToSelf();
/**
* Map the {@link Math#atan(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapAtan();
/**
* Map the {@link Math#atan(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapAtanToSelf();
/**
* Map the 1/x function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapInv();
/**
* Map the 1/x function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapInvToSelf();
/**
* Map the {@link Math#abs(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapAbs();
/**
* Map the {@link Math#abs(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapAbsToSelf();
/**
* Map the {@link Math#sqrt(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapSqrt();
/**
* Map the {@link Math#sqrt(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapSqrtToSelf();
/**
* Map the {@link Math#cbrt(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapCbrt();
/**
* Map the {@link Math#cbrt(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapCbrtToSelf();
/**
* Map the {@link Math#ceil(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapCeil();
/**
* Map the {@link Math#ceil(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapCeilToSelf();
/**
* Map the {@link Math#floor(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapFloor();
/**
* Map the {@link Math#floor(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapFloorToSelf();
/**
* Map the {@link Math#rint(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapRint();
/**
* Map the {@link Math#rint(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapRintToSelf();
/**
* Map the {@link Math#signum(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapSignum();
/**
* Map the {@link Math#signum(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapSignumToSelf();
/**
* Map the {@link Math#ulp(double)} function to each entry.
* @return a vector containing the result of applying the function to each entry
*/
RealVector mapUlp();
/**
* Map the {@link Math#ulp(double)} function to each entry.
* <p>The instance <strong>is</strong> changed by this method.</p>
* @return for convenience, return this
*/
RealVector mapUlpToSelf();
/**
* 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(RealVector 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
* @throws IllegalArgumentException if v is not the same size as this
*/
public RealVector ebeDivide(RealVector v)
throws IllegalArgumentException;
/**
* Returns vector entries as a double array.
* @return double array of entries
*/
double[] getData();
/**
* 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(RealVector 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>
* @return norm
* @see #getL1Norm()
* @see #getLInfNorm()
* @see #getDistance(RealVector)
*/
double getNorm();
/**
* Returns the L<sub>1</sub> norm of the vector.
* <p>The L<sub>1</sub> norm is the sum of the absolute
* values of elements.</p>
* @return norm
* @see #getNorm()
* @see #getLInfNorm()
* @see #getL1Distance(RealVector)
*/
double getL1Norm();
/**
* Returns the L<sub>&infty;</sub> norm of the vector.
* <p>The L<sub>&infty;</sub> norm is the max of the absolute
* values of elements.</p>
* @return norm
* @see #getNorm()
* @see #getL1Norm()
* @see #getLInfDistance(RealVector)
*/
double getLInfNorm();
/**
* 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(RealVector)
* @see #getLInfDistance(RealVector)
* @see #getNorm()
*/
double getDistance(RealVector 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>
* @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(RealVector)
* @see #getLInfDistance(RealVector)
* @see #getL1Norm()
*/
double getL1Distance(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(RealVector)
* @see #getL1Distance(RealVector)
* @see #getLInfNorm()
*/
double getLInfDistance(RealVector 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
* @exception ArithmeticException if the norm is null
*/
RealVector unitVector();
/** Converts this vector into a unit vector.
* <p>The instance itself is changed by this method.</p>
* @exception ArithmeticException if the norm is null
*/
void unitize();
/** 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(RealVector v)
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(RealVector v)
throws IllegalArgumentException;
/**
* Returns the entry in the specified index.
* <p>
* The index start at 0 and must be lesser than the size,
* otherwise a {@link MatrixIndexException} is thrown.
* </p>
* @param index index location of entry to be fetched
* @return vector entry at index
* @throws MatrixIndexException if the index is not valid
*/
double getEntry(int index)
throws MatrixIndexException;
/**
* Returns the size of the vector.
* @return size
*/
int getDimension();
/**
* Construct a vector by appending a vector to this vector.
* @param v vector to append to this one.
* @return a new vector
*/
RealVector append(RealVector v);
/**
* Construct a vector by appending a double to this vector.
* @param d double to append.
* @return a new vector
*/
RealVector append(double d);
/**
* Construct a vector by appending a double array to this vector.
* @param a double array to append.
* @return a new vector
*/
RealVector append(double[] a);
/**
* Get a subvector from consecutive elements.
* @param index index of first element.
* @param n number of elements to be retrieved.
* @return a vector containing n elements.
* @exception MatrixIndexException if the index is
* inconsistent with vector size
*/
RealVector get(int index, int n)
throws MatrixIndexException;
/**
* Set a single element.
* @param index element index.
* @param value new value for the element.
* @exception MatrixIndexException if the index is
* inconsistent with vector size
*/
void set(int index, double value)
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, RealVector v)
throws MatrixIndexException;
/**
* Set all elements to a single value.
* @param value single value to set for all elements
*/
void set(double value);
/**
* Convert the vector to a double array.
* <p>The array is independent from vector data, it's elements
* are copied.</p>
* @return array containing a copy of vector elements
*/
double[] toArray();
/**
* Returns true if any coordinate of this vector is NaN; false otherwise
* @return true if any coordinate of this vector is NaN; false otherwise
*/
public boolean isNaN();
/**
* Returns true if any coordinate of this vector is infinite and none are NaN;
* false otherwise
* @return true if any coordinate of this vector is infinite and none are NaN;
* false otherwise
*/
public boolean isInfinite();
}

334
src/java/org/apache/commons/math/linear/RealVectorFormat.java Normal file
View File

@ -0,0 +1,334 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.linear;
import java.text.FieldPosition;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.apache.commons.math.util.CompositeFormat;
/**
* Formats a vector in components list format "{v0; v1; ...; vk-1}".
* <p>The prefix and suffix "{" and "}" and the separator "; " can be replaced by
* any user-defined strings. The number format for components can be configured.</p>
* <p>White space is ignored at parse time, even if it is in the prefix, suffix
* or separator specifications. So even if the default separator does include a space
* character that is used at format time, both input string "{1;1;1}" and
* " { 1 ; 1 ; 1 } " will be parsed without error and the same vector will be
* returned. In the second case, however, the parse position after parsing will be
* just after the closing curly brace, i.e. just before the trailing space.</p>
*
* @version $Revision$ $Date$
* @since 2.0
*/
public class RealVectorFormat extends CompositeFormat {
/** Serializable version identifier */
private static final long serialVersionUID = -708767813036157690L;
/** The default prefix: "{". */
private static final String DEFAULT_PREFIX = "{";
/** The default suffix: "}". */
private static final String DEFAULT_SUFFIX = "}";
/** The default separator: ", ". */
private static final String DEFAULT_SEPARATOR = "; ";
/** Prefix. */
private final String prefix;
/** Suffix. */
private final String suffix;
/** Separator. */
private final String separator;
/** Trimmed prefix. */
private final String trimmedPrefix;
/** Trimmed suffix. */
private final String trimmedSuffix;
/** Trimmed separator. */
private final String trimmedSeparator;
/** The format used for components. */
private NumberFormat format;
/**
* Create an instance with default settings.
* <p>The instance uses the default prefix, suffix and separator:
* "{", "}", and "; " and the default number format for components.</p>
*/
public RealVectorFormat() {
this(DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_SEPARATOR, getDefaultNumberFormat());
}
/**
* Create an instance with a custom number format for components.
* @param format the custom format for components.
*/
public RealVectorFormat(final NumberFormat format) {
this(DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_SEPARATOR, format);
}
/**
* Create an instance with custom prefix, suffix and separator.
* @param prefix prefix to use instead of the default "{"
* @param suffix suffix to use instead of the default "}"
* @param separator separator to use instead of the default "; "
*/
public RealVectorFormat(final String prefix, final String suffix,
final String separator) {
this(prefix, suffix, separator, getDefaultNumberFormat());
}
/**
* Create an instance with custom prefix, suffix, separator and format
* for components.
* @param prefix prefix to use instead of the default "{"
* @param suffix suffix to use instead of the default "}"
* @param separator separator to use instead of the default "; "
* @param format the custom format for components.
*/
public RealVectorFormat(final String prefix, final String suffix,
final String separator, final NumberFormat format) {
this.prefix = prefix;
this.suffix = suffix;
this.separator = separator;
trimmedPrefix = prefix.trim();
trimmedSuffix = suffix.trim();
trimmedSeparator = separator.trim();
this.format = format;
}
/**
* Get the set of locales for which real vectors formats are available.
* <p>This is the same set as the {@link NumberFormat} set.</p>
* @return available real vector format locales.
*/
public static Locale[] getAvailableLocales() {
return NumberFormat.getAvailableLocales();
}
/**
* Get the format prefix.
* @return format prefix.
*/
public String getPrefix() {
return prefix;
}
/**
* Get the format suffix.
* @return format suffix.
*/
public String getSuffix() {
return suffix;
}
/**
* Get the format separator between components.
* @return format separator.
*/
public String getSeparator() {
return separator;
}
/**
* Get the components format.
* @return components format.
*/
public NumberFormat getFormat() {
return format;
}
/**
* Returns the default real vector format for the current locale.
* @return the default real vector format.
*/
public static RealVectorFormat getInstance() {
return getInstance(Locale.getDefault());
}
/**
* Returns the default real vector format for the given locale.
* @param locale the specific locale used by the format.
* @return the real vector format specific to the given locale.
*/
public static RealVectorFormat getInstance(final Locale locale) {
return new RealVectorFormat(getDefaultNumberFormat(locale));
}
/**
* This static method calls {@link #format(Object)} on a default instance of
* RealVectorFormat.
*
* @param v RealVector object to format
* @return A formatted vector
*/
public static String formatRealVector(RealVector v) {
return getInstance().format(v);
}
/**
* Formats a {@link RealVector} object to produce a string.
* @param vector the object to format.
* @param toAppendTo where the text is to be appended
* @param pos On input: an alignment field, if desired. On output: the
* offsets of the alignment field
* @return the value passed in as toAppendTo.
*/
public StringBuffer format(RealVector vector, StringBuffer toAppendTo,
FieldPosition pos) {
pos.setBeginIndex(0);
pos.setEndIndex(0);
// format prefix
toAppendTo.append(prefix);
// format components
for (int i = 0; i < vector.getDimension(); ++i) {
if (i > 0) {
toAppendTo.append(separator);
}
formatDouble(vector.getEntry(i), format, toAppendTo, pos);
}
// format suffix
toAppendTo.append(suffix);
return toAppendTo;
}
/**
* Formats a object to produce a string.
* <p><code>obj</code> must be a {@link RealVector} object. Any other type of
* object will result in an {@link IllegalArgumentException} being thrown.</p>
* @param obj the object to format.
* @param toAppendTo where the text is to be appended
* @param pos On input: an alignment field, if desired. On output: the
* offsets of the alignment field
* @return the value passed in as toAppendTo.
* @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
* @throws IllegalArgumentException is <code>obj</code> is not a valid type.
*/
public StringBuffer format(Object obj, StringBuffer toAppendTo,
FieldPosition pos) {
if (obj instanceof RealVector) {
return format( (RealVector)obj, toAppendTo, pos);
}
throw new IllegalArgumentException("Cannot format given Object as a RealVector");
}
/**
* Parses a string to produce a {@link RealVector} object.
* @param source the string to parse
* @return the parsed {@link RealVector} object.
* @exception ParseException if the beginning of the specified string
* cannot be parsed.
*/
public RealVectorImpl parse(String source) throws ParseException {
ParsePosition parsePosition = new ParsePosition(0);
RealVectorImpl result = parse(source, parsePosition);
if (parsePosition.getIndex() == 0) {
throw new ParseException("Unparseable real vector: \"" + source +
"\"", parsePosition.getErrorIndex());
}
return result;
}
/**
* Parses a string to produce a {@link RealVector} object.
* @param source the string to parse
* @param pos input/ouput parsing parameter.
* @return the parsed {@link RealVector} object.
*/
public RealVectorImpl parse(String source, ParsePosition pos) {
int initialIndex = pos.getIndex();
// parse prefix
parseAndIgnoreWhitespace(source, pos);
if (!parseFixedstring(source, trimmedPrefix, pos)) {
return null;
}
// parse components
List<Number> components = new ArrayList<Number>();
for (boolean loop = true; loop;){
if (!components.isEmpty()) {
parseAndIgnoreWhitespace(source, pos);
if (!parseFixedstring(source, trimmedSeparator, pos)) {
loop = false;
}
}
if (loop) {
parseAndIgnoreWhitespace(source, pos);
Number component = parseNumber(source, format, pos);
if (component != null) {
components.add(component);
} else {
// invalid component
// set index back to initial, error index should already be set
pos.setIndex(initialIndex);
return null;
}
}
}
// parse suffix
parseAndIgnoreWhitespace(source, pos);
if (!parseFixedstring(source, trimmedSuffix, pos)) {
return null;
}
// build vector
double[] data = new double[components.size()];
for (int i = 0; i < data.length; ++i) {
data[i] = components.get(i).doubleValue();
}
return new RealVectorImpl(data, false);
}
/**
* Parses a string to produce a object.
* @param source the string to parse
* @param pos input/ouput parsing parameter.
* @return the parsed object.
* @see java.text.Format#parseObject(java.lang.String, java.text.ParsePosition)
*/
public Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);
}
}

1295
src/java/org/apache/commons/math/linear/RealVectorImpl.java Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/site/xdoc/changes.xml
View File

@ -39,6 +39,12 @@ The <action> type attribute can be add,update,fix,remove.
</properties> </properties>
<body> <body>
<release version="2.0" date="TBD" description="TBD"> <release version="2.0" date="TBD" description="TBD">
<action dev="luc" type="add" due-to="Andreas Rieger">
Support for one dimensional vectors has been added to the linear algebra
package with a RealVector interface, a RealVectorImpl default implementation
using a single double array to store elements and a RealVectorFormat for
input/output.
</action>
<action dev="psteitz" type="update" issue="MATH-217"> <action dev="psteitz" type="update" issue="MATH-217">
Changed OLS regression implementation added in MATH-203 to use Changed OLS regression implementation added in MATH-203 to use
QR decomposition to solve the normal equations. QR decomposition to solve the normal equations.

32
src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java Normal file
View File

@ -0,0 +1,32 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.linear;
import java.util.Locale;
public class FrenchRealVectorFormatTest extends RealVectorFormatAbstractTest {
protected char getDecimalCharacter() {
return ',';
}
protected Locale getLocale() {
return Locale.FRENCH;
}
}

65
src/test/org/apache/commons/math/linear/RealMatrixImplTest.java
View File

@ -253,8 +253,10 @@ public final class RealMatrixImplTest extends TestCase {
RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m = new RealMatrixImpl(testData);
RealMatrix mInv = new RealMatrixImpl(testDataInv); RealMatrix mInv = new RealMatrixImpl(testDataInv);
// being a bit slothful here -- actually testing that X = A^-1 * B // being a bit slothful here -- actually testing that X = A^-1 * B
assertClose("inverse-operate",mInv.operate(testVector), assertClose("inverse-operate", mInv.operate(testVector),
m.solve(testVector),normTolerance); m.solve(testVector), normTolerance);
assertClose("inverse-operate", mInv.operate(testVector),
m.solve(new RealVectorImpl(testVector)).getData(), normTolerance);
try { try {
m.solve(testVector2); m.solve(testVector2);
fail("expecting IllegalArgumentException"); fail("expecting IllegalArgumentException");
@ -332,8 +334,10 @@ public final class RealMatrixImplTest extends TestCase {
/** test operate */ /** test operate */
public void testOperate() { public void testOperate() {
RealMatrix m = new RealMatrixImpl(id); RealMatrix m = new RealMatrixImpl(id);
double[] x = m.operate(testVector); assertClose("identity operate", testVector,
assertClose("identity operate",testVector,x,entryTolerance); m.operate(testVector), entryTolerance);
assertClose("identity operate", testVector,
m.operate(new RealVectorImpl(testVector)).getData(), entryTolerance);
m = new RealMatrixImpl(bigSingular); m = new RealMatrixImpl(bigSingular);
try { try {
m.operate(testVector); m.operate(testVector);
@ -368,7 +372,10 @@ public final class RealMatrixImplTest extends TestCase {
/** test preMultiply by vector */ /** test preMultiply by vector */
public void testPremultiplyVector() { public void testPremultiplyVector() {
RealMatrix m = new RealMatrixImpl(testData); RealMatrix m = new RealMatrixImpl(testData);
assertClose("premultiply",m.preMultiply(testVector),preMultTest,normTolerance); assertClose("premultiply", m.preMultiply(testVector),
preMultTest, normTolerance);
assertClose("premultiply", m.preMultiply(new RealVectorImpl(testVector).getData()),
preMultTest, normTolerance);
m = new RealMatrixImpl(bigSingular); m = new RealMatrixImpl(bigSingular);
try { try {
m.preMultiply(testVector); m.preMultiply(testVector);
@ -607,6 +614,54 @@ public final class RealMatrixImplTest extends TestCase {
// expected // expected
} }
} }
public void testGetRowVector() {
RealMatrix m = new RealMatrixImpl(subTestData);
RealVector mRow0 = new RealVectorImpl(subRow0[0]);
RealVector mRow3 = new RealVectorImpl(subRow3[0]);
assertEquals("Row0", mRow0, m.getRowVector(0));
assertEquals("Row3", mRow3, m.getRowVector(3));
try {
m.getRowVector(-1);
fail("Expecting MatrixIndexException");
} catch (MatrixIndexException ex) {
// expected
}
try {
m.getRowVector(4);
fail("Expecting MatrixIndexException");
} catch (MatrixIndexException ex) {
// expected
}
}
public void testGetColumnVector() {
RealMatrix m = new RealMatrixImpl(subTestData);
RealVector mColumn1 = columnToVector(subColumn1);
RealVector mColumn3 = columnToVector(subColumn3);
assertEquals("Column1", mColumn1, m.getColumnVector(1));
assertEquals("Column3", mColumn3, m.getColumnVector(3));
try {
m.getColumnVector(-1);
fail("Expecting MatrixIndexException");
} catch (MatrixIndexException ex) {
// expected
}
try {
m.getColumnVector(4);
fail("Expecting MatrixIndexException");
} catch (MatrixIndexException ex) {
// expected
}
}
private RealVector columnToVector(double[][] column) {
double[] data = new double[column.length];
for (int i = 0; i < data.length; ++i) {
data[i] = column[i][0];
}
return new RealVectorImpl(data, false);
}
public void testEqualsAndHashCode() { public void testEqualsAndHashCode() {
RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m = new RealMatrixImpl(testData);

384
src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java Normal file
View File

@ -0,0 +1,384 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.linear;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.util.Locale;
import junit.framework.TestCase;
import org.apache.commons.math.util.CompositeFormat;
public abstract class RealVectorFormatAbstractTest extends TestCase {
RealVectorFormat realVectorFormat = null;
RealVectorFormat realVectorFormatSquare = null;
protected abstract Locale getLocale();
protected abstract char getDecimalCharacter();
protected void setUp() throws Exception {
realVectorFormat = RealVectorFormat.getInstance(getLocale());
final NumberFormat nf = NumberFormat.getInstance(getLocale());
nf.setMaximumFractionDigits(2);
realVectorFormatSquare = new RealVectorFormat("[", "]", " : ", nf);
}
public void testSimpleNoDecimals() {
RealVectorImpl c = new RealVectorImpl(new double[] {1, 1, 1});
String expected = "{1; 1; 1}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testSimpleWithDecimals() {
RealVectorImpl c = new RealVectorImpl(new double[] {1.23, 1.43, 1.63});
String expected =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43; 1" + getDecimalCharacter() +
"63}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testSimpleWithDecimalsTrunc() {
RealVectorImpl c = new RealVectorImpl(new double[] {1.2323, 1.4343, 1.6333});
String expected =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43; 1" + getDecimalCharacter() +
"63}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testNegativeX() {
RealVectorImpl c = new RealVectorImpl(new double[] {-1.2323, 1.4343, 1.6333});
String expected =
"{-1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43; 1" + getDecimalCharacter() +
"63}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testNegativeY() {
RealVectorImpl c = new RealVectorImpl(new double[] {1.2323, -1.4343, 1.6333});
String expected =
"{1" + getDecimalCharacter() +
"23; -1" + getDecimalCharacter() +
"43; 1" + getDecimalCharacter() +
"63}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testNegativeZ() {
RealVectorImpl c = new RealVectorImpl(new double[] {1.2323, 1.4343, -1.6333});
String expected =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43; -1" + getDecimalCharacter() +
"63}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testNonDefaultSetting() {
RealVectorImpl c = new RealVectorImpl(new double[] {1, 1, 1});
String expected = "[1 : 1 : 1]";
String actual = realVectorFormatSquare.format(c);
assertEquals(expected, actual);
}
public void testStaticFormatRealVectorImpl() {
Locale defaultLocal = Locale.getDefault();
Locale.setDefault(getLocale());
RealVectorImpl c = new RealVectorImpl(new double[] {232.222, -342.33, 432.444});
String expected =
"{232" + getDecimalCharacter() +
"22; -342" + getDecimalCharacter() +
"33; 432" + getDecimalCharacter() +
"44}";
String actual = RealVectorFormat.formatRealVector(c);
assertEquals(expected, actual);
Locale.setDefault(defaultLocal);
}
public void testNan() {
RealVectorImpl c = new RealVectorImpl(new double[] {Double.NaN, Double.NaN, Double.NaN});
String expected = "{(NaN); (NaN); (NaN)}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testPositiveInfinity() {
RealVectorImpl c = new RealVectorImpl(new double[] {
Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY
});
String expected = "{(Infinity); (Infinity); (Infinity)}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void tesNegativeInfinity() {
RealVectorImpl c = new RealVectorImpl(new double[] {
Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY
});
String expected = "{(-Infinity); (-Infinity); (-Infinity)}";
String actual = realVectorFormat.format(c);
assertEquals(expected, actual);
}
public void testParseSimpleNoDecimals() {
String source = "{1; 1; 1}";
RealVectorImpl expected = new RealVectorImpl(new double[] {1, 1, 1});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseIgnoredWhitespace() {
RealVectorImpl expected = new RealVectorImpl(new double[] {1, 1, 1});
ParsePosition pos1 = new ParsePosition(0);
String source1 = "{1;1;1}";
assertEquals(expected, realVectorFormat.parseObject(source1, pos1));
assertEquals(source1.length(), pos1.getIndex());
ParsePosition pos2 = new ParsePosition(0);
String source2 = " { 1 ; 1 ; 1 } ";
assertEquals(expected, realVectorFormat.parseObject(source2, pos2));
assertEquals(source2.length() - 1, pos2.getIndex());
}
public void testParseSimpleWithDecimals() {
String source =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43; 1" + getDecimalCharacter() +
"63}";
RealVectorImpl expected = new RealVectorImpl(new double[] {1.23, 1.43, 1.63});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseSimpleWithDecimalsTrunc() {
String source =
"{1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343; 1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {1.2323, 1.4343, 1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNegativeX() {
String source =
"{-1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343; 1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {-1.2323, 1.4343, 1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNegativeY() {
String source =
"{1" + getDecimalCharacter() +
"2323; -1" + getDecimalCharacter() +
"4343; 1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {1.2323, -1.4343, 1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNegativeZ() {
String source =
"{1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343; -1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {1.2323, 1.4343, -1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNegativeAll() {
String source =
"{-1" + getDecimalCharacter() +
"2323; -1" + getDecimalCharacter() +
"4343; -1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {-1.2323, -1.4343, -1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseZeroX() {
String source =
"{0" + getDecimalCharacter() +
"0; -1" + getDecimalCharacter() +
"4343; 1" + getDecimalCharacter() +
"6333}";
RealVectorImpl expected = new RealVectorImpl(new double[] {0.0, -1.4343, 1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNonDefaultSetting() {
String source =
"[1" + getDecimalCharacter() +
"2323 : 1" + getDecimalCharacter() +
"4343 : 1" + getDecimalCharacter() +
"6333]";
RealVectorImpl expected = new RealVectorImpl(new double[] {1.2323, 1.4343, 1.6333});
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormatSquare.parseObject(source);
assertEquals(expected, actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNan() {
String source = "{(NaN); (NaN); (NaN)}";
try {
RealVectorImpl actual = (RealVectorImpl) realVectorFormat.parseObject(source);
assertEquals(new RealVectorImpl(new double[] {Double.NaN, Double.NaN, Double.NaN}), actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParsePositiveInfinity() {
String source = "{(Infinity); (Infinity); (Infinity)}";
try {
RealVectorImpl actual = (RealVectorImpl)realVectorFormat.parseObject(source);
assertEquals(new RealVectorImpl(new double[] {
Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY
}), actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNegativeInfinity() {
String source = "{(-Infinity); (-Infinity); (-Infinity)}";
try {
RealVectorImpl actual = (RealVectorImpl)realVectorFormat.parseObject(source);
assertEquals(new RealVectorImpl(new double[] {
Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY
}), actual);
} catch (ParseException ex) {
fail(ex.getMessage());
}
}
public void testParseNoComponents() {
try {
realVectorFormat.parseObject("{ }");
} catch (ParseException pe) {
// expected behavior
} catch (Exception e) {
fail("wrong exception caught");
}
}
public void testParseManyComponents() throws ParseException {
RealVectorImpl parsed =
(RealVectorImpl) realVectorFormat.parseObject("{0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0}");
assertEquals(24, parsed.getDimension());
}
public void testConstructorSingleFormat() {
NumberFormat nf = NumberFormat.getInstance();
RealVectorFormat cf = new RealVectorFormat(nf);
assertNotNull(cf);
assertEquals(nf, cf.getFormat());
}
public void testFormatObject() {
try {
CompositeFormat cf = new RealVectorFormat();
Object object = new Object();
cf.format(object);
fail();
} catch (IllegalArgumentException ex) {
// success
}
}
public void testForgottenPrefix() {
ParsePosition pos = new ParsePosition(0);
assertNull(new RealVectorFormat().parse("1; 1; 1}", pos));
assertEquals(0, pos.getErrorIndex());
}
public void testForgottenSeparator() {
ParsePosition pos = new ParsePosition(0);
assertNull(new RealVectorFormat().parse("{1; 1 1}", pos));
assertEquals(6, pos.getErrorIndex());
}
public void testForgottenSuffix() {
ParsePosition pos = new ParsePosition(0);
assertNull(new RealVectorFormat().parse("{1; 1; 1 ", pos));
assertEquals(8, pos.getErrorIndex());
}
}

31
src/test/org/apache/commons/math/linear/RealVectorFormatTest.java Normal file
View File

@ -0,0 +1,31 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.linear;
import java.util.Locale;
public class RealVectorFormatTest extends RealVectorFormatAbstractTest {
protected char getDecimalCharacter() {
return '.';
}
protected Locale getLocale() {
return Locale.US;
}
}

1137
src/test/org/apache/commons/math/linear/RealVectorImplTest.java Normal file
View File

File diff suppressed because it is too large Load Diff