diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/linear/RealVector.java')
| -rw-r--r-- | src/main/java/org/apache/commons/math/linear/RealVector.java | 1005 |
1 files changed, 1005 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/linear/RealVector.java b/src/main/java/org/apache/commons/math/linear/RealVector.java new file mode 100644 index 0000000..0d7982b --- /dev/null +++ b/src/main/java/org/apache/commons/math/linear/RealVector.java @@ -0,0 +1,1005 @@ +/* + * 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.Iterator; + +import org.apache.commons.math.FunctionEvaluationException; +import org.apache.commons.math.analysis.UnivariateRealFunction; + + +/** + * 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> + * <p> + * Remark on the deprecated {@code mapXxx} and {@code mapXxxToSelf} methods: In + * Commons-Math v3.0, the same functionality will be achieved by directly using the + * {@link #map(UnivariateRealFunction)} and {@link #mapToSelf(UnivariateRealFunction)} + * together with new function objects (not available in v2.2). + * </p> + * + * @version $Revision: 1070725 $ $Date: 2011-02-15 02:31:12 +0100 (mar. 15 févr. 2011) $ + * @since 2.0 + */ +public interface RealVector { + /** + * Acts as if it is implemented as: + * <pre> + * Entry e = null; + * for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) { + * e.setValue(function.value(e.getValue())); + * } + * </pre> + * + * @param function Function to apply to each entry. + * @return this vector. + * @throws FunctionEvaluationException if the function throws it. + */ + RealVector mapToSelf(UnivariateRealFunction function) throws FunctionEvaluationException; + + /** + * Acts as if implemented as: + * <pre> + * return copy().map(function); + * </pre> + * + * @param function Function to apply to each entry. + * @return a new vector. + * @throws FunctionEvaluationException if the function throws it. + */ + RealVector map(UnivariateRealFunction function) throws FunctionEvaluationException; + + /** Class representing a modifiable entry in the vector. */ + public abstract class Entry { + /** Index of the entry. */ + private int index; + + /** + * Get the value of the entry. + * + * @return the value of the entry. + */ + public abstract double getValue(); + /** + * Set the value of the entry. + * + * @param value New value for the entry. + */ + public abstract void setValue(double value); + /** + * Get the index of the entry. + * + * @return the index of the entry. + */ + public int getIndex() { + return index; + } + /** + * Set the index of the entry. + * + * @param index New index for the entry. + */ + public void setIndex(int index) { + this.index = index; + } + } + + /** + * Generic dense iterator. + * It iterates in increasing order of the vector index. + * + * @return a dense iterator + */ + Iterator<Entry> iterator(); + + /** + * Specialized implementations may choose to not iterate over all + * dimensions, either because those values are unset, or are equal + * to defaultValue(), or are small enough to be ignored for the + * purposes of iteration. + * No guarantees are made about order of iteration. + * In dense implementations, this method will often delegate to + * {@link #iterator()}. + * + * @return a sparse iterator + */ + Iterator<Entry> sparseIterator(); + + /** + * Returns a (deep) copy of this vector. + * + * @return a vector copy. + */ + RealVector copy(); + + /** + * Compute the sum of this vector and {@code v}. + * + * @param v Vector to be added. + * @return {@code this} + {@code v}. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector add(RealVector v); + + /** + * Compute the sum of this vector and {@code v}. + * + * @param v Vector to be added. + * @return {@code this} + {@code v}. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector add(double[] v); + + + /** + * Subtract {@code v} from this vector. + * + * @param v Vector to be subtracted. + * @return {@code this} - {@code v}. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector subtract(RealVector v); + + /** + * Subtract {@code v} from this vector. + * + * @param v Vector to be subtracted. + * @return {@code this} - {@code v}. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector subtract(double[] v); + + /** + * Add a value to each entry. + * + * @param d Value to be added to each entry. + * @return {@code this} + {@code d}. + */ + RealVector mapAdd(double d); + + /** + * Add a value to each entry. + * The instance is changed in-place. + * + * @param d Value to be added to each entry. + * @return {@code this}. + */ + RealVector mapAddToSelf(double d); + + /** + * Subtract a value from each entry. + * + * @param d Value to be subtracted. + * @return {@code this} - {@code d}. + */ + RealVector mapSubtract(double d); + + /** + * Subtract a value from each entry. + * The instance is changed in-place. + * + * @param d Value to be subtracted. + * @return {@code this}. + */ + RealVector mapSubtractToSelf(double d); + + /** + * Multiply each entry. + * + * @param d Multiplication factor. + * @return {@code this} * {@code d}. + */ + RealVector mapMultiply(double d); + + /** + * Multiply each entry. + * The instance is changed in-place. + * + * @param d Multiplication factor. + * @return {@code this}. + */ + RealVector mapMultiplyToSelf(double d); + + /** + * Divide each entry. + * + * @param d Value to divide by. + * @return {@code this} / {@code d}. + */ + RealVector mapDivide(double d); + + /** + * Divide each entry. + * The instance is changed in-place. + * + * @param d Value to divide by. + * @return {@code this}. + */ + RealVector mapDivideToSelf(double d); + + /** + * Map a power operation to each entry. + * + * @param d Operator value. + * @return a mapped copy of the vector. + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + RealVector mapPow(double d); + + /** + * Map a power operation to each entry. + * The instance is changed in-place. + * + * @param d Operator value. + * @return the mapped vector. + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + RealVector mapPowToSelf(double d); + + /** + * Map the {@link Math#exp(double)} function to each entry. + * + * @return a mapped copy of the vector. + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + RealVector mapExp(); + + /** + * Map {@link Math#exp(double)} operation to each entry. + * The instance is changed in-place. + * + * @return the mapped vector. + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + RealVector mapAtanToSelf(); + + /** + * Map the 1/x function to each entry. + * @return a vector containing the result of applying the function to each entry + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 + * @deprecated in 2.2 (to be removed in 3.0). + */ + @Deprecated + 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector ebeMultiply(RealVector v); + + /** + * 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector ebeMultiply(double[] v); + + /** + * 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector ebeDivide(RealVector v); + + /** + * 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector ebeDivide(double[] v); + + /** + * 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 + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + double dotProduct(RealVector v); + + /** + * Compute the dot product. + * @param v vector with which dot product should be computed + * @return the scalar dot product between instance and v + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + double dotProduct(double[] v); + + /** + * 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>∞</sub> norm of the vector. + * <p>The L<sub>∞</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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getL1Distance(RealVector) + * @see #getLInfDistance(RealVector) + * @see #getNorm() + */ + double getDistance(RealVector v); + + /** + * 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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getL1Distance(double[]) + * @see #getLInfDistance(double[]) + * @see #getNorm() + */ + double getDistance(double[] v); + + /** + * 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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getDistance(RealVector) + * @see #getLInfDistance(RealVector) + * @see #getL1Norm() + */ + double getL1Distance(RealVector v); + + /** + * 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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getDistance(double[]) + * @see #getLInfDistance(double[]) + * @see #getL1Norm() + */ + double getL1Distance(double[] v); + + /** + * 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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getDistance(RealVector) + * @see #getL1Distance(RealVector) + * @see #getLInfNorm() + */ + double getLInfDistance(RealVector v); + + /** + * 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. + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + * @see #getDistance(double[]) + * @see #getL1Distance(double[]) + * @see #getLInfNorm() + */ + double getLInfDistance(double[] v); + + /** 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> + * @throws ArithmeticException + * if the norm is zero. + */ + 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector projection(RealVector 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 org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealVector projection(double[] v); + + /** + * Compute the outer product. + * @param v vector with which outer product should be computed + * @return the square matrix outer product between instance and v + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealMatrix outerProduct(RealVector v); + + /** + * Compute the outer product. + * @param v vector with which outer product should be computed + * @return the square matrix outer product between instance and v + * @throws org.apache.commons.math.exception.DimensionMismatchException + * if {@code v} is not the same size as this vector. + */ + RealMatrix outerProduct(double[] v); + + /** + * Returns the entry in the specified index. + * + * @param index Index location of entry to be fetched. + * @return the vector entry at {@code index}. + * @throws org.apache.commons.math.exception.OutOfRangeException + * if the index is not valid. + * @see #setEntry(int, double) + */ + double getEntry(int index); + + /** + * Set a single element. + * @param index element index. + * @param value new value for the element. + * @throws org.apache.commons.math.exception.OutOfRangeException + * if the index is not valid. + * @see #getEntry(int) + */ + void setEntry(int index, double value); + + /** + * 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. + * @throws org.apache.commons.math.exception.OutOfRangeException + * if the index is not valid. + */ + RealVector getSubVector(int index, int n); + + /** + * Set a set of consecutive elements. + * @param index index of first element to be set. + * @param v vector containing the values to set. + * @throws org.apache.commons.math.exception.OutOfRangeException + * if the index is not valid. + * @see #setSubVector(int, double[]) + */ + void setSubVector(int index, RealVector v); + + /** + * Set a set of consecutive elements. + * @param index index of first element to be set. + * @param v vector containing the values to set. + * @throws org.apache.commons.math.exception.OutOfRangeException + * if the index is not valid. + * @see #setSubVector(int, RealVector) + */ + void setSubVector(int index, double[] v); + + /** + * 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(); + + /** + * Check whether any coordinate of this vector is {@code NaN}. + * @return {@code true} if any coordinate of this vector is {@code NaN}, + * {@code false} otherwise. + */ + boolean isNaN(); + + /** + * Check whether any coordinate of this vector is infinite and none are {@code NaN}. + * + * @return {@code true} if any coordinate of this vector is infinite and + * none are {@code NaN}, {@code false} otherwise. + */ + boolean isInfinite(); +} |