diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/linear/ArrayRealVector.java')
-rw-r--r-- | src/main/java/org/apache/commons/math/linear/ArrayRealVector.java | 1228 |
1 files changed, 1228 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/linear/ArrayRealVector.java b/src/main/java/org/apache/commons/math/linear/ArrayRealVector.java new file mode 100644 index 0000000..9f15a6e --- /dev/null +++ b/src/main/java/org/apache/commons/math/linear/ArrayRealVector.java @@ -0,0 +1,1228 @@ +/* + * 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.io.Serializable; +import java.util.Arrays; +import java.util.Iterator; + +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.exception.util.LocalizedFormats; +import org.apache.commons.math.util.MathUtils; +import org.apache.commons.math.util.FastMath; + +/** + * This class implements the {@link RealVector} interface with a double array. + * @version $Revision: 1003993 $ $Date: 2010-10-03 18:39:16 +0200 (dim. 03 oct. 2010) $ + * @since 2.0 + */ +public class ArrayRealVector extends AbstractRealVector implements Serializable { + + /** Serializable version identifier. */ + private static final long serialVersionUID = -1097961340710804027L; + + /** Default format. */ + private static final RealVectorFormat DEFAULT_FORMAT = + RealVectorFormat.getInstance(); + + /** Entries of the vector. */ + protected double data[]; + + /** + * Build a 0-length vector. + * <p>Zero-length vectors may be used to initialized construction of vectors + * by data gathering. We start with zero-length and use either the {@link + * #ArrayRealVector(ArrayRealVector, ArrayRealVector)} constructor + * or one of the <code>append</code> method ({@link #append(double)}, {@link + * #append(double[])}, {@link #append(ArrayRealVector)}) to gather data + * into this vector.</p> + */ + public ArrayRealVector() { + data = new double[0]; + } + + /** + * Construct a (size)-length vector of zeros. + * @param size size of the vector + */ + public ArrayRealVector(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 ArrayRealVector(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 ArrayRealVector(double[] d) { + data = d.clone(); + } + + /** + * Create a new ArrayRealVector using the input array as the underlying + * data array. + * <p>If an array is built specially in order to be embedded in a + * ArrayRealVector and not used directly, the <code>copyArray</code> may be + * set to <code>false</code. This will prevent the copying and improve + * performance as no new array will be built and no data will be copied.</p> + * @param d data for new vector + * @param copyArray if true, the input array will be copied, otherwise + * it will be referenced + * @see #ArrayRealVector(double[]) + */ + public ArrayRealVector(double[] d, boolean copyArray) { + 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 ArrayRealVector(double[] d, int pos, int size) { + if (d.length < pos + size) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.POSITION_SIZE_MISMATCH_INPUT_ARRAY, pos, size, 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 ArrayRealVector(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 ArrayRealVector(Double[] d, int pos, int size) { + if (d.length < pos + size) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.POSITION_SIZE_MISMATCH_INPUT_ARRAY, pos, size, 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 ArrayRealVector(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 ArrayRealVector(ArrayRealVector v) { + this(v, true); + } + + /** + * 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 ArrayRealVector(ArrayRealVector 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 ArrayRealVector(ArrayRealVector v1, ArrayRealVector 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); + } + + /** + * 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 ArrayRealVector(ArrayRealVector v1, RealVector v2) { + final int l1 = v1.data.length; + final int l2 = v2.getDimension(); + data = new double[l1 + l2]; + System.arraycopy(v1.data, 0, data, 0, l1); + for (int i = 0; i < l2; ++i) { + data[l1 + i] = v2.getEntry(i); + } + } + + /** + * 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 ArrayRealVector(RealVector v1, ArrayRealVector v2) { + final int l1 = v1.getDimension(); + final int l2 = v2.data.length; + data = new double[l1 + l2]; + for (int i = 0; i < l1; ++i) { + data[i] = v1.getEntry(i); + } + System.arraycopy(v2.data, 0, data, l1, l2); + } + + /** + * 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 ArrayRealVector(ArrayRealVector v1, double[] v2) { + final int l1 = v1.getDimension(); + final int l2 = v2.length; + data = new double[l1 + l2]; + System.arraycopy(v1.data, 0, data, 0, l1); + System.arraycopy(v2, 0, data, l1, l2); + } + + /** + * 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 ArrayRealVector(double[] v1, ArrayRealVector v2) { + final int l1 = v1.length; + final int l2 = v2.getDimension(); + data = new double[l1 + l2]; + System.arraycopy(v1, 0, data, 0, l1); + System.arraycopy(v2.data, 0, data, l1, l2); + } + + /** + * 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 ArrayRealVector(double[] v1, double[] v2) { + final int l1 = v1.length; + final int l2 = v2.length; + data = new double[l1 + l2]; + System.arraycopy(v1, 0, data, 0, l1); + System.arraycopy(v2, 0, data, l1, l2); + } + + /** {@inheritDoc} */ + @Override + public AbstractRealVector copy() { + return new ArrayRealVector(this, true); + } + + /** {@inheritDoc} */ + @Override + public RealVector add(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return add((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double[] out = data.clone(); + Iterator<Entry> it = v.sparseIterator(); + Entry e; + while (it.hasNext() && (e = it.next()) != null) { + out[e.getIndex()] += e.getValue(); + } + return new ArrayRealVector(out, false); + } + } + + /** {@inheritDoc} */ + @Override + public RealVector add(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] += v[i]; + } + return new ArrayRealVector(out, false); + } + + /** + * 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 ArrayRealVector add(ArrayRealVector v) + throws IllegalArgumentException { + return (ArrayRealVector) add(v.data); + } + + /** {@inheritDoc} */ + @Override + public RealVector subtract(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return subtract((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double[] out = data.clone(); + Iterator<Entry> it = v.sparseIterator(); + Entry e; + while(it.hasNext() && (e = it.next()) != null) { + out[e.getIndex()] -= e.getValue(); + } + return new ArrayRealVector(out, false); + } + } + + /** {@inheritDoc} */ + @Override + public RealVector subtract(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] -= v[i]; + } + return new ArrayRealVector(out, false); + } + + /** + * 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 ArrayRealVector subtract(ArrayRealVector v) + throws IllegalArgumentException { + return (ArrayRealVector) subtract(v.data); + } + + /** {@inheritDoc} */ + @Override + public RealVector mapAddToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] + d; + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapSubtractToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] - d; + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapMultiplyToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] * d; + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapDivideToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = data[i] / d; + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapPowToSelf(double d) { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.pow(data[i], d); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapExpToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.exp(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapExpm1ToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.expm1(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapLogToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.log(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapLog10ToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.log10(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapLog1pToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.log1p(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapCoshToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.cosh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapSinhToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.sinh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapTanhToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.tanh(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapCosToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.cos(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapSinToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.sin(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapTanToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.tan(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapAcosToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.acos(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapAsinToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.asin(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapAtanToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.atan(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapInvToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = 1.0 / data[i]; + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapAbsToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.abs(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapSqrtToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.sqrt(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapCbrtToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.cbrt(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapCeilToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.ceil(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapFloorToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.floor(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapRintToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.rint(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapSignumToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.signum(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + @Override + public RealVector mapUlpToSelf() { + for (int i = 0; i < data.length; i++) { + data[i] = FastMath.ulp(data[i]); + } + return this; + } + + /** {@inheritDoc} */ + public RealVector ebeMultiply(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return ebeMultiply((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] *= v.getEntry(i); + } + return new ArrayRealVector(out, false); + } + } + + /** {@inheritDoc} */ + @Override + public RealVector ebeMultiply(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] *= v[i]; + } + return new ArrayRealVector(out, false); + } + + /** + * 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 ArrayRealVector ebeMultiply(ArrayRealVector v) + throws IllegalArgumentException { + return (ArrayRealVector) ebeMultiply(v.data); + } + + /** {@inheritDoc} */ + public RealVector ebeDivide(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return ebeDivide((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] /= v.getEntry(i); + } + return new ArrayRealVector(out, false); + } + } + + /** {@inheritDoc} */ + @Override + public RealVector ebeDivide(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double[] out = data.clone(); + for (int i = 0; i < data.length; i++) { + out[i] /= v[i]; + } + return new ArrayRealVector(out, false); + } + + /** + * 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 ArrayRealVector ebeDivide(ArrayRealVector v) + throws IllegalArgumentException { + return (ArrayRealVector) ebeDivide(v.data); + } + + /** {@inheritDoc} */ + @Override + public double[] getData() { + return data.clone(); + } + + /** + * Returns a reference to the underlying data array. + * <p>Does not make a fresh copy of the underlying data.</p> + * @return array of entries + */ + public double[] getDataRef() { + return data; + } + + /** {@inheritDoc} */ + @Override + public double dotProduct(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return dotProduct((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double dot = 0; + Iterator<Entry> it = v.sparseIterator(); + Entry e; + while(it.hasNext() && (e = it.next()) != null) { + dot += data[e.getIndex()] * e.getValue(); + } + return dot; + } + } + + /** {@inheritDoc} */ + @Override + public double dotProduct(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double dot = 0; + for (int i = 0; i < data.length; i++) { + dot += data[i] * v[i]; + } + return dot; + } + + /** + * Compute the dot product. + * @param v vector with which dot product should be computed + * @return the scalar dot product between instance and v + * @exception IllegalArgumentException if v is not the same size as this + */ + public double dotProduct(ArrayRealVector v) + throws IllegalArgumentException { + return dotProduct(v.data); + } + + /** {@inheritDoc} */ + @Override + public double getNorm() { + double sum = 0; + for (double a : data) { + sum += a * a; + } + return FastMath.sqrt(sum); + } + + /** {@inheritDoc} */ + @Override + public double getL1Norm() { + double sum = 0; + for (double a : data) { + sum += FastMath.abs(a); + } + return sum; + } + + /** {@inheritDoc} */ + @Override + public double getLInfNorm() { + double max = 0; + for (double a : data) { + max = FastMath.max(max, FastMath.abs(a)); + } + return max; + } + + /** {@inheritDoc} */ + @Override + public double getDistance(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return getDistance((ArrayRealVector) v); + } else { + 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 FastMath.sqrt(sum); + } + } + + /** {@inheritDoc} */ + @Override + public double getDistance(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double sum = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v[i]; + sum += delta * delta; + } + return FastMath.sqrt(sum); + } + + /** + * Distance between two vectors. + * <p>This method computes the distance consistent with the + * L<sub>2</sub> norm, i.e. the square root of the sum of + * 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 #getDistance(RealVector) + * @see #getL1Distance(ArrayRealVector) + * @see #getLInfDistance(ArrayRealVector) + * @see #getNorm() + */ + public double getDistance(ArrayRealVector v) + throws IllegalArgumentException { + return getDistance(v.data); + } + + /** {@inheritDoc} */ + @Override + public double getL1Distance(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return getL1Distance((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double sum = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v.getEntry(i); + sum += FastMath.abs(delta); + } + return sum; + } + } + + /** {@inheritDoc} */ + @Override + public double getL1Distance(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double sum = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v[i]; + sum += FastMath.abs(delta); + } + return sum; + } + + /** + * 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 #getL1Distance(ArrayRealVector) + * @see #getLInfDistance(ArrayRealVector) + * @see #getNorm() + */ + public double getL1Distance(ArrayRealVector v) + throws IllegalArgumentException { + return getL1Distance(v.data); + } + + /** {@inheritDoc} */ + @Override + public double getLInfDistance(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return getLInfDistance((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + double max = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v.getEntry(i); + max = FastMath.max(max, FastMath.abs(delta)); + } + return max; + } + } + + /** {@inheritDoc} */ + @Override + public double getLInfDistance(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + double max = 0; + for (int i = 0; i < data.length; ++i) { + final double delta = data[i] - v[i]; + max = FastMath.max(max, FastMath.abs(delta)); + } + return max; + } + + /** + * Distance between two vectors. + * <p>This method computes the distance consistent with + * L<sub>∞</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(ArrayRealVector) + * @see #getLInfDistance(ArrayRealVector) + * @see #getNorm() + */ + public double getLInfDistance(ArrayRealVector v) + throws IllegalArgumentException { + return getLInfDistance(v.data); + } + + /** {@inheritDoc} */ + @Override + public RealVector unitVector() throws ArithmeticException { + final double norm = getNorm(); + if (norm == 0) { + throw MathRuntimeException.createArithmeticException(LocalizedFormats.ZERO_NORM); + } + return mapDivide(norm); + } + + /** {@inheritDoc} */ + @Override + public void unitize() throws ArithmeticException { + final double norm = getNorm(); + if (norm == 0) { + throw MathRuntimeException.createArithmeticException(LocalizedFormats.CANNOT_NORMALIZE_A_ZERO_NORM_VECTOR); + } + mapDivideToSelf(norm); + } + + /** {@inheritDoc} */ + public RealVector projection(RealVector v) { + return v.mapMultiply(dotProduct(v) / v.dotProduct(v)); + } + + /** {@inheritDoc} */ + @Override + public RealVector projection(double[] v) { + return projection(new ArrayRealVector(v, false)); + } + + /** Find the orthogonal projection of this vector onto another vector. + * @param v vector onto which instance must be projected + * @return projection of the instance onto v + * @throws IllegalArgumentException if v is not the same size as this + */ + public ArrayRealVector projection(ArrayRealVector v) { + return (ArrayRealVector) v.mapMultiply(dotProduct(v) / v.dotProduct(v)); + } + + /** {@inheritDoc} */ + @Override + public RealMatrix outerProduct(RealVector v) + throws IllegalArgumentException { + if (v instanceof ArrayRealVector) { + return outerProduct((ArrayRealVector) v); + } else { + checkVectorDimensions(v); + final int m = data.length; + final RealMatrix out = MatrixUtils.createRealMatrix(m, m); + for (int i = 0; i < data.length; i++) { + for (int j = 0; j < data.length; j++) { + out.setEntry(i, j, data[i] * v.getEntry(j)); + } + } + return 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 RealMatrix outerProduct(ArrayRealVector v) + throws IllegalArgumentException { + return outerProduct(v.data); + } + + /** {@inheritDoc} */ + @Override + public RealMatrix outerProduct(double[] v) + throws IllegalArgumentException { + checkVectorDimensions(v.length); + final int m = data.length; + final RealMatrix out = MatrixUtils.createRealMatrix(m, m); + for (int i = 0; i < data.length; i++) { + for (int j = 0; j < data.length; j++) { + out.setEntry(i, j, data[i] * v[j]); + } + } + return 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 new ArrayRealVector(this, (ArrayRealVector) v); + } catch (ClassCastException cce) { + return new ArrayRealVector(this, v); + } + } + + /** + * Construct a vector by appending a vector to this vector. + * @param v vector to append to this one. + * @return a new vector + */ + public ArrayRealVector append(ArrayRealVector v) { + return new ArrayRealVector(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 ArrayRealVector(out, false); + } + + /** {@inheritDoc} */ + public RealVector append(double[] in) { + return new ArrayRealVector(this, in); + } + + /** {@inheritDoc} */ + public RealVector getSubVector(int index, int n) { + ArrayRealVector out = new ArrayRealVector(n); + try { + System.arraycopy(data, index, out.data, 0, n); + } catch (IndexOutOfBoundsException e) { + checkIndex(index); + checkIndex(index + n - 1); + } + return out; + } + + /** {@inheritDoc} */ + public void setEntry(int index, double value) { + try { + data[index] = value; + } catch (IndexOutOfBoundsException e) { + checkIndex(index); + } + } + + /** {@inheritDoc} */ + @Override + public void setSubVector(int index, RealVector v) { + try { + try { + set(index, (ArrayRealVector) v); + } catch (ClassCastException cce) { + for (int i = index; i < index + v.getDimension(); ++i) { + data[i] = v.getEntry(i-index); + } + } + } catch (IndexOutOfBoundsException e) { + checkIndex(index); + checkIndex(index + v.getDimension() - 1); + } + } + + /** {@inheritDoc} */ + @Override + public void setSubVector(int index, double[] v) { + try { + System.arraycopy(v, 0, data, index, v.length); + } catch (IndexOutOfBoundsException e) { + checkIndex(index); + checkIndex(index + v.length - 1); + } + } + + /** + * 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, ArrayRealVector v) + throws MatrixIndexException { + setSubVector(index, v.data); + } + + /** {@inheritDoc} */ + @Override + public void set(double value) { + Arrays.fill(data, value); + } + + /** {@inheritDoc} */ + @Override + public double[] toArray(){ + return data.clone(); + } + + /** {@inheritDoc} */ + @Override + 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 + */ + @Override + protected 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 + */ + @Override + protected void checkVectorDimensions(int n) + throws IllegalArgumentException { + if (data.length != n) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.VECTOR_LENGTH_MISMATCH, + data.length, n); + } + } + + /** + * 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. + * <p> + * If all coordinates of two real vectors are exactly the same, and none are + * <code>Double.NaN</code>, the two real vectors are considered to be equal. + * </p> + * <p> + * <code>NaN</code> 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 <code>Double.NaN</code>, the real vector is equal to + * a vector with all <code>Double.NaN</code> coordinates. + * </p> + * + * @param other Object to test for equality to this + * @return true if two vector objects are equal, false if + * object is null, not an instance of RealVector, or + * not equal to this RealVector instance + * + */ + @Override + public boolean equals(Object other) { + + if (this == other) { + return true; + } + + if (other == null || !(other instanceof RealVector)) { + return false; + } + + + 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 (data[i] != rhs.getEntry(i)) { + return false; + } + } + return true; + } + + /** + * Get a hashCode for the real vector. + * <p>All NaN values have the same hash code.</p> + * @return a hash code value for this object + */ + @Override + public int hashCode() { + if (isNaN()) { + return 9; + } + return MathUtils.hash(data); + } + +} |