Zero-length vectors may be used to initialized construction of vectors + * by data gathering. We start with zero-length and use either the {@link + * #RealVectorImpl(RealVectorImpl, RealVectorImpl)} constructor + * or one of the `append` method ({@link #append(double)}, {@link + * #append(double[])}, {@link #append(RealVectorImpl)}) to gather data + * into this vector.

+ */ + public RealVectorImpl() { + data = new double[0]; + } + + /** + * Construct a (size)-length vector of zeros. + * @param size size of the vector + */ + public RealVectorImpl(int size) { + data = new double[size]; + } + + /** + * Construct an (size)-length vector with preset values. + * @param size size of the vector + * @param preset fill the vector with this scalar value + */ + public RealVectorImpl(int size, double preset) { + data = new double[size]; + Arrays.fill(data, preset); + } + + /** + * Construct a vector from an array, copying the input array. + * @param d array of doubles. + */ + public RealVectorImpl(double[] d) { + data = d.clone(); + } + + /** + * Create a new RealVectorImpl using the input array as the underlying + * data array. + *

If an array is built specially in order to be embedded in a + * RealVectorImpl and not used directly, the `copyArray` may be + * set to ```false + * @param d data for new vector + * @param copyArray if true, the input array will be copied, otherwise + * it will be referenced + * @throws IllegalArgumentException if d is empty + * @throws NullPointerException if d is null + * @see #RealVectorImpl(double[]) + */ + public RealVectorImpl(double[] d, boolean copyArray) + throws NullPointerException, IllegalArgumentException { + if (d == null) { + throw new NullPointerException(); + } + if (d.length == 0) { + throw new IllegalArgumentException("Vector must have at least one element."); + } + data = copyArray ? d.clone() : d; + } + + /** + * Construct a vector from part of a array. + * @param d array of doubles. + * @param pos position of first entry + * @param size number of entries to copy + */ + public RealVectorImpl(double[] d, int pos, int size) { + if (d.length < pos + size) { + throw new IllegalArgumentException("Position " + pos + " and size " + size + + " don't fit to the size of the input array " + + d.length); + } + data = new double[size]; + System.arraycopy(d, pos, data, 0, size); + } + + /** + * Construct a vector from an array. + * @param d array of Doubles. + */ + public RealVectorImpl(Double[] d) { + data = new double[d.length]; + for (int i = 0; i < d.length; i++) { + data[i] = d[i].doubleValue(); + } + } + + /** + * Construct a vector from part of a Double array + * @param d array of Doubles. + * @param pos position of first entry + * @param size number of entries to copy + */ + public RealVectorImpl(Double[] d, int pos, int size) { + if (d.length < pos + size) { + throw new IllegalArgumentException("Position " + pos + " and size " + size + + " don't fit to the size of the input array " + + d.length); + } + data = new double[size]; + for (int i = pos; i < pos + size; i++) { + data[i-pos] = d[i].doubleValue(); + } + } + + /** + * Construct a vector from another vector, using a deep copy. + * @param v vector to copy + */ + public RealVectorImpl(RealVector v) { + data = new double[v.getDimension()]; + for (int i = 0; i < data.length; ++i) { + data[i] = v.getEntry(i); + } + } + + /** + * Construct a vector from another vector, using a deep copy. + * @param v vector to copy + */ + public RealVectorImpl(RealVectorImpl v) { + data = v.data.clone(); + } + + /** + * Construct a vector from another vector. + * @param v vector to copy + * @param deep if true perform a deep copy otherwise perform a shallow copy + */ + public RealVectorImpl(RealVectorImpl v, boolean deep) { + data = deep ? v.data.clone() : v.data; + } + + /** + * 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, RealVectorImpl v2) { + data = new double[v1.data.length + v2.data.length]; + System.arraycopy(v1.data, 0, data, 0, v1.data.length); + System.arraycopy(v2.data, 0, data, v1.data.length, v2.data.length); + } + + /** {@inheritDoc} */ + public RealVector copy() { + return new RealVectorImpl(this, true); + } + + /** {@inheritDoc} */ + public RealVector add(RealVector v) + throws IllegalArgumentException { + try { + return add((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] + v.getEntry(i); + } + return new RealVectorImpl(out); + } + } + + /** + * 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 + */ + 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); + } + + /** {@inheritDoc} */ + public RealVector subtract(RealVector v) + throws IllegalArgumentException { + try { + return subtract((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] - v.getEntry(i); + } + return new RealVectorImpl(out); + } + } + + /** + * Compute this minus v. + * @param v vector to be subtracted + * @return this + v + * @throws IllegalArgumentException if v is not the same size as this + */ + 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); + } + + /** {@inheritDoc} */ + public RealVector mapAdd(double d) { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] + d; + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapAddToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] + d; + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapSubtract(double d) { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] - d; + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapSubtractToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] - d; + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapMultiply(double d) { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] * d; + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapMultiplyToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] * d; + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapDivide(double d) { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] / d; + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapDivideToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] / d; + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapPow(double d) { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.pow(data[i], d); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapPowToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = Math.pow(data[i], d); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapExp() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.exp(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapExpToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.exp(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapExpm1() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.expm1(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapExpm1ToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.expm1(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapLog() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.log(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapLogToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.log(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapLog10() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.log10(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapLog10ToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.log10(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapLog1p() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.log1p(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapLog1pToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.log1p(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapCosh() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.cosh(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapCoshToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.cosh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapSinh() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.sinh(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapSinhToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.sinh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapTanh() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.tanh(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapTanhToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.tanh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapCos() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.cos(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapCosToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.cos(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapSin() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.sin(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapSinToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.sin(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapTan() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.tan(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapTanToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.tan(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapAcos() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.acos(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapAcosToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.acos(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapAsin() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.asin(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapAsinToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.asin(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapAtan() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.atan(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapAtanToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.atan(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapInv() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = 1.0 / data[i]; + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapInvToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = 1.0 / data[i]; + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapAbs() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.abs(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapAbsToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.abs(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapSqrt() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.sqrt(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapSqrtToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.sqrt(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapCbrt() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.cbrt(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapCbrtToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.cbrt(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapCeil() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.ceil(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapCeilToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.ceil(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapFloor() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.floor(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapFloorToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.floor(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapRint() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.rint(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapRintToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.rint(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapSignum() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.signum(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapSignumToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.signum(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector mapUlp() { + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = Math.ulp(data[i]); + } + return new RealVectorImpl(out); + } + + /** {@inheritDoc} */ + public RealVector mapUlpToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = Math.ulp(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector ebeMultiply(RealVector v) + throws IllegalArgumentException { + try { + return ebeMultiply((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] * v.getEntry(i); + } + return new RealVectorImpl(out); + } + } + + /** + * 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 + * @exception IllegalArgumentException if v is not the same size as this + */ + 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); + } + + /** {@inheritDoc} */ + public RealVector ebeDivide(RealVector v) + throws IllegalArgumentException { + try { + return ebeDivide((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double[] out = new double[data.length]; + for (int i = 0; i < data.length; i++) { + out[i] = data[i] / v.getEntry(i); + } + return new RealVectorImpl(out); + } + } + + /** + * 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 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); + } + + /** {@inheritDoc} */ + public double[] getData() { + return data.clone(); + } + + /** + * Returns a reference to the underlying data array. + * ```

`Does not make a fresh copy of the underlying data.`

``` + * @return array of entries + */ + public double[] getDataRef() { + return data; + } + + /** {@inheritDoc} */ + public double dotProduct(RealVector v) + throws IllegalArgumentException { + try { + return dotProduct((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double dot = 0; + for (int i = 0; i < data.length; i++) { + dot += data[i] * v.getEntry(i); + } + return dot; + } + } + + /** + * 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 + */ + 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; + } + + /** {@inheritDoc} */ + public double getNorm() { + double sum = 0; + for (double a : data) { + sum += a * a; + } + return Math.sqrt(sum); + } + + /** {@inheritDoc} */ + public double getL1Norm() { + double sum = 0; + for (double a : data) { + sum += Math.abs(a); + } + return sum; + } + + /** {@inheritDoc} */ + public double getLInfNorm() { + double max = 0; + for (double a : data) { + max += Math.max(max, Math.abs(a)); + } + return max; + } + + /** {@inheritDoc} */ + public double getDistance(RealVector v) + throws IllegalArgumentException { + try { + return getDistance((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double sum = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v.getEntry(i); + sum += delta * delta; + } + return Math.sqrt(sum); + } + } + + /** + * Distance between two vectors. + * This method computes the distance consistent with the + * L2 norm, i.e. the square root of the sum of + * elements differences, or euclidian distance. + * @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(RealVectorImpl) + * @see #getLInfDistance(RealVectorImpl) + * @see #getNorm() + */ + 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); + } + + /** {@inheritDoc} */ + public double getL1Distance(RealVector v) + throws IllegalArgumentException { + try { + return getL1Distance((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double sum = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v.getEntry(i); + sum += Math.abs(delta); + } + return sum; + } + } + + /** + * Distance between two vectors. + * This method computes the distance consistent with + * L1 norm, i.e. the sum of the absolute values of + * elements differences. + * @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(RealVectorImpl) + * @see #getLInfDistance(RealVectorImpl) + * @see #getNorm() + */ + 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; + } + + /** {@inheritDoc} */ + public double getLInfDistance(RealVector v) + throws IllegalArgumentException { + try { + return getLInfDistance((RealVectorImpl) v); + } catch (ClassCastException cce) { + checkVectorDimensions(v); + double max = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v.getEntry(i); + max = Math.max(max, Math.abs(delta)); + } + return max; + } + } + + /** + * Distance between two vectors. + * This method computes the distance consistent with + * L&infty; norm, i.e. the max of the absolute values of + * elements differences. + * @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(RealVectorImpl) + * @see #getLInfDistance(RealVectorImpl) + * @see #getNorm() + */ + 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; + } + + /** {@inheritDoc} */ + public RealVector unitVector() throws ArithmeticException { + final double norm = getNorm(); + if (norm == 0) { + throw new ArithmeticException("null norm"); + } + return mapDivide(getNorm()); + } + + /** {@inheritDoc} */ + public void unitize() throws ArithmeticException { + final double norm = getNorm(); + if (norm == 0) { + throw new ArithmeticException("null norm"); + } + for (int i = 0; i < data.length; i++) { + data[i] /= norm; + } + } + + /** {@inheritDoc} */ + public RealVector projection(RealVector v) { + return v.mapMultiply(dotProduct(v) / v.dotProduct(v)); + } + + /** 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 + */ + public RealVectorImpl projection(RealVectorImpl v) { + return (RealVectorImpl) v.mapMultiply(dotProduct(v) / v.dotProduct(v)); + } + + /** {@inheritDoc} */ + public RealMatrix outerProduct(RealVector v) + throws IllegalArgumentException { + try { + return outerProduct((RealVectorImpl) v); + } catch (ClassCastException cce) { + 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.getEntry(j); + } + } + return new RealMatrixImpl(out); + } + } + + /** + * 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 + */ + 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); + } + + /** {@inheritDoc} */ + public double getEntry(int index) throws MatrixIndexException { + return data[index]; + } + + /** {@inheritDoc} */ + public int getDimension() { + return data.length; + } + + /** {@inheritDoc} */ + public RealVector append(RealVector v) { + try { + return append((RealVectorImpl) v); + } catch (ClassCastException cce) { + return new RealVectorImpl(this,new RealVectorImpl(v)); + } + } + + /** + * Construct a vector by appending a vector to this vector. + * @param v vector to append to this one. + * @return a new vector + */ + public RealVectorImpl append(RealVectorImpl v) { + return new RealVectorImpl(this, v); + } + + /** {@inheritDoc} */ + public RealVector append(double in) { + final double[] out = new double[data.length + 1]; + System.arraycopy(data, 0, out, 0, data.length); + out[data.length] = in; + return new RealVectorImpl(out); + } + + /** {@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); + } + + /** {@inheritDoc} */ + public RealVector get(int index, int n) { + try { + RealVectorImpl out = new RealVectorImpl(n); + System.arraycopy(data, index, out.data, 0, n); + + return out; + } catch (IndexOutOfBoundsException e) { + throw new MatrixIndexException(e.getMessage()); + } + } + + /** {@inheritDoc} */ + public void set(int index, double value) { + try { + data[index] = value; + } catch (IndexOutOfBoundsException e) { + throw new MatrixIndexException(e.getMessage()); + } + } + + /** {@inheritDoc} */ + public void set(int index, RealVector v) { + try { + try { + set(index, (RealVectorImpl) v); + } catch (ClassCastException cce) { + for (int i = index; i < index + v.getDimension(); ++i) { + data[i] = v.getEntry(i-index); + } + } + } catch (IndexOutOfBoundsException e) { + throw new MatrixIndexException(e.getMessage()); + } + } + + /** + * 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 + */ + 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()); + } + } + + /** {@inheritDoc} */ + public void set(double value) { + Arrays.fill(data, value); + } + + /** {@inheritDoc} */ + public double[] toArray(){ + return data.clone(); + } + + /** {@inheritDoc} */ + public String toString(){ + return DEFAULT_FORMAT.format(this); + } + + /** + * Check if instance and specified vectors have the same dimension. + * @param v vector to compare instance with + * @exception IllegalArgumentException if the vectors do not + * have the same dimension + */ + public void checkVectorDimensions(RealVector v) + throws IllegalArgumentException { + checkVectorDimensions(v.getDimension()); + } + + /** + * Check if instance dimension is equal to some expected value. + * + * @param n expected dimension. + * @exception IllegalArgumentException if the dimension is + * inconsistent with vector size + */ + public void checkVectorDimensions(int n) + throws IllegalArgumentException { + if (data.length != n) { + throw new IllegalArgumentException("vector dimension is " + data.length + + ", not " + n + " as expected"); + } + } + + /** + * 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() { + for (double v : data) { + if (Double.isNaN(v)) { + return true; + } + } + return false; + } + + /** + * 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() { + + if (isNaN()) { + return false; + } + + for (double v : data) { + if (Double.isInfinite(v)) { + return true; + } + } + + return false; + + } + + /** + * Test for the equality of two real vectors. + * + * If all coordinates of two real vectors are exactly the same, and none are + * Double.NaN, the two real vectors are considered to be equal. + * + * + * NaN coordinates are considered to affect globally the vector + * and be equals to each other - i.e, if either (or all) coordinates of the + * real vector are equal to Double.NaN, the real vector is equal to + * a vector with all Double.NaN coordinates. + * + * + * @param other Object to test for equality to this + * @return true if two 3D vector objects are equal, false if + * object is null, not an instance of Vector3D, or + * not equal to this Vector3D instance + * + */ + public boolean equals(Object other) { + + if (this == other) { + return true; + } + + if (other == null) { + return false; + } + + try { + + RealVector rhs = (RealVector) other; + if (data.length != rhs.getDimension()) { + return false; + } + + if (rhs.isNaN()) { + return this.isNaN(); + } + + for (int i = 0; i < data.length; ++i) { + if (Double.doubleToRawLongBits(data[i]) != + Double.doubleToRawLongBits(rhs.getEntry(i))) { + return false; + } + } + return true; + + } catch (ClassCastException ex) { + // ignore exception + return false; + } + + } + + /** + * Get a hashCode for the real vector. + * All NaN values have the same hash code. + * @return a hash code value for this object + */ + public int hashCode() { + if (isNaN()) { + return 9; + } + return MathUtils.hash(data); + } + +} Propchange: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java ------------------------------------------------------------------------------ svn:eol-style = native Propchange: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealVectorImpl.java ------------------------------------------------------------------------------ svn:keywords = Author Date Id Revision Modified: commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml?rev=680166&r1=680165&r2=680166&view=diff ============================================================================== --- commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml (original) +++ commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml Sun Jul 27 12:15:22 2008 @@ -39,6 +39,12 @@ + + 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. + Changed OLS regression implementation added in MATH-203 to use QR decomposition to solve the normal equations. Added: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java?rev=680166&view=auto ============================================================================== --- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java (added) +++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java Sun Jul 27 12:15:22 2008 @@ -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; + } +} Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java ------------------------------------------------------------------------------ svn:eol-style = native Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/FrenchRealVectorFormatTest.java ------------------------------------------------------------------------------ svn:keywords = Author Date Id Revision Modified: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealMatrixImplTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealMatrixImplTest.java?rev=680166&r1=680165&r2=680166&view=diff ============================================================================== --- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealMatrixImplTest.java (original) +++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealMatrixImplTest.java Sun Jul 27 12:15:22 2008 @@ -253,8 +253,10 @@ RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrix mInv = new RealMatrixImpl(testDataInv); // being a bit slothful here -- actually testing that X = A^-1 * B - assertClose("inverse-operate",mInv.operate(testVector), - m.solve(testVector),normTolerance); + assertClose("inverse-operate", mInv.operate(testVector), + m.solve(testVector), normTolerance); + assertClose("inverse-operate", mInv.operate(testVector), + m.solve(new RealVectorImpl(testVector)).getData(), normTolerance); try { m.solve(testVector2); fail("expecting IllegalArgumentException"); @@ -332,8 +334,10 @@ /** test operate */ public void testOperate() { RealMatrix m = new RealMatrixImpl(id); - double[] x = m.operate(testVector); - assertClose("identity operate",testVector,x,entryTolerance); + assertClose("identity operate", testVector, + m.operate(testVector), entryTolerance); + assertClose("identity operate", testVector, + m.operate(new RealVectorImpl(testVector)).getData(), entryTolerance); m = new RealMatrixImpl(bigSingular); try { m.operate(testVector); @@ -368,7 +372,10 @@ /** test preMultiply by vector */ public void testPremultiplyVector() { 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); try { m.preMultiply(testVector); @@ -607,6 +614,54 @@ // 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() { RealMatrixImpl m = new RealMatrixImpl(testData); Added: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java?rev=680166&view=auto ============================================================================== --- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java (added) +++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java Sun Jul 27 12:15:22 2008 @@ -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()); + } + +} Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java ------------------------------------------------------------------------------ svn:eol-style = native Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatAbstractTest.java ------------------------------------------------------------------------------ svn:keywords = Author Date Id Revision Added: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java?rev=680166&view=auto ============================================================================== --- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java (added) +++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java Sun Jul 27 12:15:22 2008 @@ -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; + } +} Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java ------------------------------------------------------------------------------ svn:eol-style = native Propchange: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealVectorFormatTest.java ------------------------------------------------------------------------------ svn:keywords = Author Date Id Revision ```