/*
    * 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.math4.legacy.linear;
  
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.Iterator;
  
  import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
  import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
  import org.apache.commons.math4.legacy.exception.NotPositiveException;
  import org.apache.commons.math4.legacy.exception.NullArgumentException;
  import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
  import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
  import org.apache.commons.math4.legacy.exception.OutOfRangeException;
  import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
  import org.apache.commons.math4.core.jdkmath.JdkMath;
  
  /**
   * This class implements the {@link RealVector} interface with a double array.
   * @since 2.0
   */
  public class ArrayRealVector extends RealVector 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. */
      private double[] data;
  
      /**
       * Build a 0-length vector.
       * 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} method ({@link #append(double)},
       * {@link #append(ArrayRealVector)}) to gather data into this vector.
       */
      public ArrayRealVector() {
          data = new double[0];
      }
  
      /**
       * Construct a vector of zeroes.
       *
       * @param size Size of the vector.
       */
      public ArrayRealVector(int size) {
          data = new double[size];
      }
  
      /**
       * Construct a vector with preset values.
       *
       * @param size Size of the vector
       * @param preset All entries will be set with this 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.
       */
      public ArrayRealVector(double[] d) {
          data = d.clone();
      }
  
      /**
       * Create a new ArrayRealVector using the input array as the underlying
       * data array.
       * If an array is built specially in order to be embedded in a
       * ArrayRealVector and not used directly, the {@code copyArray} may be
       * set to {@code false}. This will prevent the copying and improve
       * performance as no new array will be built and no data will be copied.
       *
       * @param d Data for the new vector.
       * @param copyArray if {@code true}, the input array will be copied,
       * otherwise it will be referenced.
       * @throws NullArgumentException if {@code d} is {@code null}.
       * @see #ArrayRealVector(double[])
      */
     public ArrayRealVector(double[] d, boolean copyArray)
         throws NullArgumentException {
         if (d == null) {
             throw new NullArgumentException();
         }
         data = copyArray ? d.clone() :  d;
     }
 
     /**
      * Construct a vector from part of a array.
      *
      * @param d Array.
      * @param pos Position of first entry.
      * @param size Number of entries to copy.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @throws NumberIsTooLargeException if the size of {@code d} is less
      * than {@code pos + size}.
      */
     public ArrayRealVector(double[] d, int pos, int size)
         throws NullArgumentException, NumberIsTooLargeException {
         if (d == null) {
             throw new NullArgumentException();
         }
         if (d.length < pos + size) {
             throw new NumberIsTooLargeException(pos + size, d.length, true);
         }
         data = new double[size];
         System.arraycopy(d, pos, data, 0, size);
     }
 
     /**
      * Construct a vector from an array.
      *
      * @param d Array of {@code Double}s.
      */
     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 an array.
      *
      * @param d Array.
      * @param pos Position of first entry.
      * @param size Number of entries to copy.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @throws NumberIsTooLargeException if the size of {@code d} is less
      * than {@code pos + size}.
      */
     public ArrayRealVector(Double[] d, int pos, int size)
         throws NullArgumentException, NumberIsTooLargeException {
         if (d == null) {
             throw new NullArgumentException();
         }
         if (d.length < pos + size) {
             throw new NumberIsTooLargeException(pos + size, d.length, true);
         }
         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.
      * @throws NullArgumentException if {@code v} is {@code null}.
      */
     public ArrayRealVector(RealVector v) throws NullArgumentException {
         if (v == null) {
             throw new NullArgumentException();
         }
         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.
      * @throws NullArgumentException if {@code v} is {@code null}.
      */
     public ArrayRealVector(ArrayRealVector v) throws NullArgumentException {
         this(v, true);
     }
 
     /**
      * Construct a vector from another vector.
      *
      * @param v Vector to copy.
      * @param deep If {@code 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 ArrayRealVector copy() {
         return new ArrayRealVector(this, true);
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector add(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             final int dim = vData.length;
             checkVectorDimensions(dim);
             ArrayRealVector result = new ArrayRealVector(dim);
             double[] resultData = result.data;
             for (int i = 0; i < dim; i++) {
                 resultData[i] = data[i] + vData[i];
             }
             return result;
         } else {
             checkVectorDimensions(v);
             double[] out = data.clone();
             Iterator<Entry> it = v.iterator();
             while (it.hasNext()) {
                 final Entry e = it.next();
                 out[e.getIndex()] += e.getValue();
             }
             return new ArrayRealVector(out, false);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector subtract(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             final int dim = vData.length;
             checkVectorDimensions(dim);
             ArrayRealVector result = new ArrayRealVector(dim);
             double[] resultData = result.data;
             for (int i = 0; i < dim; i++) {
                 resultData[i] = data[i] - vData[i];
             }
             return result;
         } else {
             checkVectorDimensions(v);
             double[] out = data.clone();
             Iterator<Entry> it = v.iterator();
             while (it.hasNext()) {
                 final Entry e = it.next();
                 out[e.getIndex()] -= e.getValue();
             }
             return new ArrayRealVector(out, false);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector map(UnivariateFunction function) {
         return copy().mapToSelf(function);
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector mapToSelf(UnivariateFunction function) {
         for (int i = 0; i < data.length; i++) {
             data[i] = function.value(data[i]);
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public RealVector mapAddToSelf(double d) {
         for (int i = 0; i < data.length; i++) {
             data[i] += d;
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public RealVector mapSubtractToSelf(double d) {
         for (int i = 0; i < data.length; i++) {
             data[i] -= d;
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public RealVector mapMultiplyToSelf(double d) {
         for (int i = 0; i < data.length; i++) {
             data[i] *= d;
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public RealVector mapDivideToSelf(double d) {
         for (int i = 0; i < data.length; i++) {
             data[i] /= d;
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector ebeMultiply(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             final int dim = vData.length;
             checkVectorDimensions(dim);
             ArrayRealVector result = new ArrayRealVector(dim);
             double[] resultData = result.data;
             for (int i = 0; i < dim; i++) {
                 resultData[i] = data[i] * vData[i];
             }
             return result;
         } 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 ArrayRealVector ebeDivide(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             final int dim = vData.length;
             checkVectorDimensions(dim);
             ArrayRealVector result = new ArrayRealVector(dim);
             double[] resultData = result.data;
             for (int i = 0; i < dim; i++) {
                 resultData[i] = data[i] / vData[i];
             }
             return result;
         } 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);
         }
     }
 
     /**
      * Get a reference to the underlying data array.
      * This method does not make a fresh copy of the underlying data.
      *
      * @return the array of entries.
      */
     public double[] getDataRef() {
         return data;
     }
 
     /** {@inheritDoc} */
     @Override
     public double dotProduct(RealVector v) throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             checkVectorDimensions(vData.length);
             double dot = 0;
             for (int i = 0; i < data.length; i++) {
                 dot += data[i] * vData[i];
             }
             return dot;
         }
         return super.dotProduct(v);
     }
 
     /** {@inheritDoc} */
     @Override
     public double getNorm() {
         double sum = 0;
         for (double a : data) {
             sum += a * a;
         }
         return JdkMath.sqrt(sum);
     }
 
     /** {@inheritDoc} */
     @Override
     public double getL1Norm() {
         double sum = 0;
         for (double a : data) {
             sum += JdkMath.abs(a);
         }
         return sum;
     }
 
     /** {@inheritDoc} */
     @Override
     public double getLInfNorm() {
         double max = 0;
         for (double a : data) {
             max = JdkMath.max(max, JdkMath.abs(a));
         }
         return max;
     }
 
     /** {@inheritDoc} */
     @Override
     public double getDistance(RealVector v) throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             checkVectorDimensions(vData.length);
             double sum = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - vData[i];
                 sum += delta * delta;
             }
             return JdkMath.sqrt(sum);
         } 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 JdkMath.sqrt(sum);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public double getL1Distance(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             checkVectorDimensions(vData.length);
             double sum = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - vData[i];
                 sum += JdkMath.abs(delta);
             }
             return sum;
         } else {
             checkVectorDimensions(v);
             double sum = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - v.getEntry(i);
                 sum += JdkMath.abs(delta);
             }
             return sum;
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public double getLInfDistance(RealVector v)
         throws DimensionMismatchException {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             checkVectorDimensions(vData.length);
             double max = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - vData[i];
                 max = JdkMath.max(max, JdkMath.abs(delta));
             }
             return max;
         } else {
             checkVectorDimensions(v);
             double max = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - v.getEntry(i);
                 max = JdkMath.max(max, JdkMath.abs(delta));
             }
             return max;
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public RealMatrix outerProduct(RealVector v) {
         if (v instanceof ArrayRealVector) {
             final double[] vData = ((ArrayRealVector) v).data;
             final int m = data.length;
             final int n = vData.length;
             final RealMatrix out = MatrixUtils.createRealMatrix(m, n);
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {
                     out.setEntry(i, j, data[i] * vData[j]);
                 }
             }
             return out;
         } else {
             final int m = data.length;
             final int n = v.getDimension();
             final RealMatrix out = MatrixUtils.createRealMatrix(m, n);
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {
                     out.setEntry(i, j, data[i] * v.getEntry(j));
                 }
             }
             return out;
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public double getEntry(int index) throws OutOfRangeException {
         try {
             return data[index];
         } catch (IndexOutOfBoundsException e) {
             throw new OutOfRangeException(LocalizedFormats.INDEX, index, 0,
                 getDimension() - 1);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public int getDimension() {
         return data.length;
     }
 
     /** {@inheritDoc} */
     @Override
     public RealVector append(RealVector v) {
         if (v instanceof ArrayRealVector) {
             return new ArrayRealVector(this, (ArrayRealVector) v);
         }
         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} */
     @Override
     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} */
     @Override
     public RealVector getSubVector(int index, int n)
         throws OutOfRangeException, NotPositiveException {
         if (n < 0) {
             throw new NotPositiveException(LocalizedFormats.NUMBER_OF_ELEMENTS_SHOULD_BE_POSITIVE, 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} */
     @Override
     public void setEntry(int index, double value) throws OutOfRangeException {
         try {
             data[index] = value;
         } catch (IndexOutOfBoundsException e) {
             checkIndex(index);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void addToEntry(int index, double increment)
         throws OutOfRangeException {
         try {
         data[index] += increment;
         } catch(IndexOutOfBoundsException e){
             throw new OutOfRangeException(LocalizedFormats.INDEX,
                                           index, 0, data.length - 1);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void setSubVector(int index, RealVector v)
         throws OutOfRangeException {
         if (v instanceof ArrayRealVector) {
             setSubVector(index, ((ArrayRealVector) v).data);
         } else {
             try {
                 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);
             }
         }
     }
 
     /**
      * Set a set of consecutive elements.
      *
      * @param index Index of first element to be set.
      * @param v Vector containing the values to set.
      * @throws OutOfRangeException if the index is inconsistent with the vector
      * size.
      */
     public void setSubVector(int index, double[] v)
         throws OutOfRangeException {
         try {
             System.arraycopy(v, 0, data, index, v.length);
         } catch (IndexOutOfBoundsException e) {
             checkIndex(index);
             checkIndex(index + v.length - 1);
         }
     }
 
     /** {@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.
      * @throws DimensionMismatchException if the vectors do not
      * have the same dimension.
      */
     @Override
     protected void checkVectorDimensions(RealVector v)
         throws DimensionMismatchException {
         checkVectorDimensions(v.getDimension());
     }
 
     /**
      * Check if instance dimension is equal to some expected value.
      *
      * @param n Expected dimension.
      * @throws DimensionMismatchException if the dimension is
      * inconsistent with vector size.
      */
     @Override
     protected void checkVectorDimensions(int n)
         throws DimensionMismatchException {
         if (data.length != n) {
             throw new DimensionMismatchException(data.length, n);
         }
     }
 
     /**
      * Check if any coordinate of this vector is {@code NaN}.
      *
      * @return {@code true} if any coordinate of this vector is {@code NaN},
      * {@code false} otherwise.
      */
     @Override
     public boolean isNaN() {
         for (double v : data) {
             if (Double.isNaN(v)) {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * 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.
      */
     @Override
     public boolean isInfinite() {
         if (isNaN()) {
             return false;
         }
 
         for (double v : data) {
             if (Double.isInfinite(v)) {
                 return true;
             }
         }
 
         return false;
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean equals(Object other) {
         if (this == other) {
             return true;
         }
 
         if (!(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;
     }
 
     /**
      * {@inheritDoc} All {@code NaN} values have the same hash code.
      */
     @Override
     public int hashCode() {
         if (isNaN()) {
             return 9;
         }
         return Arrays.hashCode(data);
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector combine(double a, double b, RealVector y)
         throws DimensionMismatchException {
         return copy().combineToSelf(a, b, y);
     }
 
     /** {@inheritDoc} */
     @Override
     public ArrayRealVector combineToSelf(double a, double b, RealVector y)
         throws DimensionMismatchException {
         if (y instanceof ArrayRealVector) {
             final double[] yData = ((ArrayRealVector) y).data;
             checkVectorDimensions(yData.length);
             for (int i = 0; i < this.data.length; i++) {
                 data[i] = a * data[i] + b * yData[i];
             }
         } else {
             checkVectorDimensions(y);
             for (int i = 0; i < this.data.length; i++) {
                 data[i] = a * data[i] + b * y.getEntry(i);
             }
         }
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public double walkInDefaultOrder(final RealVectorPreservingVisitor visitor) {
         visitor.start(data.length, 0, data.length - 1);
         for (int i = 0; i < data.length; i++) {
             visitor.visit(i, data[i]);
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public double walkInDefaultOrder(final RealVectorPreservingVisitor visitor,
         final int start, final int end) throws NumberIsTooSmallException,
         OutOfRangeException {
         checkIndices(start, end);
         visitor.start(data.length, start, end);
         for (int i = start; i <= end; i++) {
             visitor.visit(i, data[i]);
         }
         return visitor.end();
     }
 
     /**
      * {@inheritDoc}
      *
      * In this implementation, the optimized order is the default order.
      */
     @Override
     public double walkInOptimizedOrder(final RealVectorPreservingVisitor visitor) {
         return walkInDefaultOrder(visitor);
     }
 
     /**
      * {@inheritDoc}
      *
      * In this implementation, the optimized order is the default order.
      */
     @Override
     public double walkInOptimizedOrder(final RealVectorPreservingVisitor visitor,
         final int start, final int end) throws NumberIsTooSmallException,
         OutOfRangeException {
         return walkInDefaultOrder(visitor, start, end);
     }
 
     /** {@inheritDoc} */
     @Override
     public double walkInDefaultOrder(final RealVectorChangingVisitor visitor) {
         visitor.start(data.length, 0, data.length - 1);
         for (int i = 0; i < data.length; i++) {
             data[i] = visitor.visit(i, data[i]);
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public double walkInDefaultOrder(final RealVectorChangingVisitor visitor,
         final int start, final int end) throws NumberIsTooSmallException,
         OutOfRangeException {
         checkIndices(start, end);
         visitor.start(data.length, start, end);
         for (int i = start; i <= end; i++) {
             data[i] = visitor.visit(i, data[i]);
         }
         return visitor.end();
     }
 
     /**
      * {@inheritDoc}
      *
      * In this implementation, the optimized order is the default order.
      */
     @Override
     public double walkInOptimizedOrder(final RealVectorChangingVisitor visitor) {
         return walkInDefaultOrder(visitor);
     }
 
     /**
      * {@inheritDoc}
      *
      * In this implementation, the optimized order is the default order.
      */
     @Override
     public double walkInOptimizedOrder(final RealVectorChangingVisitor visitor,
         final int start, final int end) throws NumberIsTooSmallException,
         OutOfRangeException {
         return walkInDefaultOrder(visitor, start, end);
     }
 }