Java tutorial
/* * 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 fvr. 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(); }