You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by tn...@apache.org on 2015/02/16 23:39:37 UTC
[07/82] [partial] [math] Update for next development iteration:
commons-math4
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java b/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java
deleted file mode 100644
index 0e93a0f..0000000
--- a/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java
+++ /dev/null
@@ -1,1147 +0,0 @@
-/*
- * 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.math3.linear;
-
-import java.io.Serializable;
-import java.util.Arrays;
-
-import org.apache.commons.math3.Field;
-import org.apache.commons.math3.FieldElement;
-import org.apache.commons.math3.exception.DimensionMismatchException;
-import org.apache.commons.math3.exception.MathArithmeticException;
-import org.apache.commons.math3.exception.NotPositiveException;
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.NumberIsTooLargeException;
-import org.apache.commons.math3.exception.NumberIsTooSmallException;
-import org.apache.commons.math3.exception.OutOfRangeException;
-import org.apache.commons.math3.exception.ZeroException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-import org.apache.commons.math3.util.MathArrays;
-import org.apache.commons.math3.util.MathUtils;
-
-/**
- * This class implements the {@link FieldVector} interface with a {@link FieldElement} array.
- * @param <T> the type of the field elements
- * @since 2.0
- */
-public class ArrayFieldVector<T extends FieldElement<T>> implements FieldVector<T>, Serializable {
- /** Serializable version identifier. */
- private static final long serialVersionUID = 7648186910365927050L;
-
- /** Entries of the vector. */
- private T[] data;
-
- /** Field to which the elements belong. */
- private final Field<T> field;
-
- /**
- * Build a 0-length vector.
- * Zero-length vectors may be used to initialize construction of vectors
- * by data gathering. We start with zero-length and use either the {@link
- * #ArrayFieldVector(ArrayFieldVector, ArrayFieldVector)} constructor
- * or one of the {@code append} methods ({@link #add(FieldVector)} or
- * {@link #append(ArrayFieldVector)}) to gather data into this vector.
- *
- * @param field field to which the elements belong
- */
- public ArrayFieldVector(final Field<T> field) {
- this(field, 0);
- }
-
- /**
- * Construct a vector of zeroes.
- *
- * @param field Field to which the elements belong.
- * @param size Size of the vector.
- */
- public ArrayFieldVector(Field<T> field, int size) {
- this.field = field;
- this.data = MathArrays.buildArray(field, size);
- }
-
- /**
- * Construct a vector with preset values.
- *
- * @param size Size of the vector.
- * @param preset All entries will be set with this value.
- */
- public ArrayFieldVector(int size, T preset) {
- this(preset.getField(), size);
- Arrays.fill(data, preset);
- }
-
- /**
- * Construct a vector from an array, copying the input array.
- * This constructor needs a non-empty {@code d} array to retrieve
- * the field from its first element. This implies it cannot build
- * 0 length vectors. To build vectors from any size, one should
- * use the {@link #ArrayFieldVector(Field, FieldElement[])} constructor.
- *
- * @param d Array.
- * @throws NullArgumentException if {@code d} is {@code null}.
- * @throws ZeroException if {@code d} is empty.
- * @see #ArrayFieldVector(Field, FieldElement[])
- */
- public ArrayFieldVector(T[] d)
- throws NullArgumentException, ZeroException {
- MathUtils.checkNotNull(d);
- try {
- field = d[0].getField();
- data = d.clone();
- } catch (ArrayIndexOutOfBoundsException e) {
- throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
- }
- }
-
- /**
- * Construct a vector from an array, copying the input array.
- *
- * @param field Field to which the elements belong.
- * @param d Array.
- * @throws NullArgumentException if {@code d} is {@code null}.
- * @see #ArrayFieldVector(FieldElement[])
- */
- public ArrayFieldVector(Field<T> field, T[] d)
- throws NullArgumentException {
- MathUtils.checkNotNull(d);
- this.field = field;
- data = d.clone();
- }
-
- /**
- * Create a new ArrayFieldVector using the input array as the underlying
- * data array.
- * If an array is built specially in order to be embedded in a
- * ArrayFieldVector 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.
- * This constructor needs a non-empty {@code d} array to retrieve
- * the field from its first element. This implies it cannot build
- * 0 length vectors. To build vectors from any size, one should
- * use the {@link #ArrayFieldVector(Field, FieldElement[], boolean)}
- * constructor.
- *
- * @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}.
- * @throws ZeroException if {@code d} is empty.
- * @see #ArrayFieldVector(FieldElement[])
- * @see #ArrayFieldVector(Field, FieldElement[], boolean)
- */
- public ArrayFieldVector(T[] d, boolean copyArray)
- throws NullArgumentException, ZeroException {
- MathUtils.checkNotNull(d);
- if (d.length == 0) {
- throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
- }
- field = d[0].getField();
- data = copyArray ? d.clone() : d;
- }
-
- /**
- * Create a new ArrayFieldVector using the input array as the underlying
- * data array.
- * If an array is built specially in order to be embedded in a
- * ArrayFieldVector 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 field Field to which the elements belong.
- * @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 #ArrayFieldVector(FieldElement[], boolean)
- */
- public ArrayFieldVector(Field<T> field, T[] d, boolean copyArray)
- throws NullArgumentException {
- MathUtils.checkNotNull(d);
- this.field = field;
- data = copyArray ? d.clone() : d;
- }
-
- /**
- * Construct a vector from part of a array.
- *
- * @param d Array.
- * @param pos Position of the 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 ArrayFieldVector(T[] d, int pos, int size)
- throws NullArgumentException, NumberIsTooLargeException {
- MathUtils.checkNotNull(d);
- if (d.length < pos + size) {
- throw new NumberIsTooLargeException(pos + size, d.length, true);
- }
- field = d[0].getField();
- data = MathArrays.buildArray(field, size);
- System.arraycopy(d, pos, data, 0, size);
- }
-
- /**
- * Construct a vector from part of a array.
- *
- * @param field Field to which the elements belong.
- * @param d Array.
- * @param pos Position of the 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 ArrayFieldVector(Field<T> field, T[] d, int pos, int size)
- throws NullArgumentException, NumberIsTooLargeException {
- MathUtils.checkNotNull(d);
- if (d.length < pos + size) {
- throw new NumberIsTooLargeException(pos + size, d.length, true);
- }
- this.field = field;
- data = MathArrays.buildArray(field, size);
- System.arraycopy(d, pos, data, 0, size);
- }
-
- /**
- * Construct a vector from another vector, using a deep copy.
- *
- * @param v Vector to copy.
- * @throws NullArgumentException if {@code v} is {@code null}.
- */
- public ArrayFieldVector(FieldVector<T> v)
- throws NullArgumentException {
- MathUtils.checkNotNull(v);
- field = v.getField();
- data = MathArrays.buildArray(field, 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 ArrayFieldVector(ArrayFieldVector<T> v)
- throws NullArgumentException {
- MathUtils.checkNotNull(v);
- field = v.getField();
- data = v.data.clone();
- }
-
- /**
- * 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
- * @throws NullArgumentException if {@code v} is {@code null}.
- */
- public ArrayFieldVector(ArrayFieldVector<T> v, boolean deep)
- throws NullArgumentException {
- MathUtils.checkNotNull(v);
- field = v.getField();
- 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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @deprecated as of 3.2, replaced by {@link #ArrayFieldVector(FieldVector, FieldVector)}
- */
- @Deprecated
- public ArrayFieldVector(ArrayFieldVector<T> v1, ArrayFieldVector<T> v2)
- throws NullArgumentException {
- this((FieldVector<T>) v1, (FieldVector<T>) v2);
- }
-
- /**
- * 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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @since 3.2
- */
- public ArrayFieldVector(FieldVector<T> v1, FieldVector<T> v2)
- throws NullArgumentException {
- MathUtils.checkNotNull(v1);
- MathUtils.checkNotNull(v2);
- field = v1.getField();
- final T[] v1Data =
- (v1 instanceof ArrayFieldVector) ? ((ArrayFieldVector<T>) v1).data : v1.toArray();
- final T[] v2Data =
- (v2 instanceof ArrayFieldVector) ? ((ArrayFieldVector<T>) v2).data : v2.toArray();
- data = MathArrays.buildArray(field, v1Data.length + v2Data.length);
- System.arraycopy(v1Data, 0, data, 0, v1Data.length);
- System.arraycopy(v2Data, 0, data, v1Data.length, v2Data.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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @deprecated as of 3.2, replaced by {@link #ArrayFieldVector(FieldVector, FieldElement[])}
- */
- @Deprecated
- public ArrayFieldVector(ArrayFieldVector<T> v1, T[] v2)
- throws NullArgumentException {
- this((FieldVector<T>) v1, v2);
- }
-
- /**
- * 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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @since 3.2
- */
- public ArrayFieldVector(FieldVector<T> v1, T[] v2)
- throws NullArgumentException {
- MathUtils.checkNotNull(v1);
- MathUtils.checkNotNull(v2);
- field = v1.getField();
- final T[] v1Data =
- (v1 instanceof ArrayFieldVector) ? ((ArrayFieldVector<T>) v1).data : v1.toArray();
- data = MathArrays.buildArray(field, v1Data.length + v2.length);
- System.arraycopy(v1Data, 0, data, 0, v1Data.length);
- System.arraycopy(v2, 0, data, v1Data.length, v2.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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @deprecated as of 3.2, replaced by {@link #ArrayFieldVector(FieldElement[], FieldVector)}
- */
- @Deprecated
- public ArrayFieldVector(T[] v1, ArrayFieldVector<T> v2)
- throws NullArgumentException {
- this(v1, (FieldVector<T>) v2);
- }
-
- /**
- * 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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @since 3.2
- */
- public ArrayFieldVector(T[] v1, FieldVector<T> v2)
- throws NullArgumentException {
- MathUtils.checkNotNull(v1);
- MathUtils.checkNotNull(v2);
- field = v2.getField();
- final T[] v2Data =
- (v2 instanceof ArrayFieldVector) ? ((ArrayFieldVector<T>) v2).data : v2.toArray();
- data = MathArrays.buildArray(field, v1.length + v2Data.length);
- System.arraycopy(v1, 0, data, 0, v1.length);
- System.arraycopy(v2Data, 0, data, v1.length, v2Data.length);
- }
-
- /**
- * Construct a vector by appending one vector to another vector.
- * This constructor needs at least one non-empty array to retrieve
- * the field from its first element. This implies it cannot build
- * 0 length vectors. To build vectors from any size, one should
- * use the {@link #ArrayFieldVector(Field, FieldElement[], FieldElement[])}
- * constructor.
- *
- * @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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @throws ZeroException if both arrays are empty.
- * @see #ArrayFieldVector(Field, FieldElement[], FieldElement[])
- */
- public ArrayFieldVector(T[] v1, T[] v2)
- throws NullArgumentException, ZeroException {
- MathUtils.checkNotNull(v1);
- MathUtils.checkNotNull(v2);
- if (v1.length + v2.length == 0) {
- throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
- }
- data = MathArrays.buildArray(v1[0].getField(), v1.length + v2.length);
- System.arraycopy(v1, 0, data, 0, v1.length);
- System.arraycopy(v2, 0, data, v1.length, v2.length);
- field = data[0].getField();
- }
-
- /**
- * Construct a vector by appending one vector to another vector.
- *
- * @param field Field to which the elements belong.
- * @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).
- * @throws NullArgumentException if {@code v1} or {@code v2} is
- * {@code null}.
- * @throws ZeroException if both arrays are empty.
- * @see #ArrayFieldVector(FieldElement[], FieldElement[])
- */
- public ArrayFieldVector(Field<T> field, T[] v1, T[] v2)
- throws NullArgumentException, ZeroException {
- MathUtils.checkNotNull(v1);
- MathUtils.checkNotNull(v2);
- if (v1.length + v2.length == 0) {
- throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
- }
- data = MathArrays.buildArray(field, v1.length + v2.length);
- System.arraycopy(v1, 0, data, 0, v1.length);
- System.arraycopy(v2, 0, data, v1.length, v2.length);
- this.field = field;
- }
-
- /** {@inheritDoc} */
- public Field<T> getField() {
- return field;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> copy() {
- return new ArrayFieldVector<T>(this, true);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> add(FieldVector<T> v)
- throws DimensionMismatchException {
- try {
- return add((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- checkVectorDimensions(v);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].add(v.getEntry(i));
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
- }
-
- /**
- * Compute the sum of {@code this} and {@code v}.
- * @param v vector to be added
- * @return {@code this + v}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- */
- public ArrayFieldVector<T> add(ArrayFieldVector<T> v)
- throws DimensionMismatchException {
- checkVectorDimensions(v.data.length);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].add(v.data[i]);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> subtract(FieldVector<T> v)
- throws DimensionMismatchException {
- try {
- return subtract((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- checkVectorDimensions(v);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].subtract(v.getEntry(i));
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
- }
-
- /**
- * Compute {@code this} minus {@code v}.
- * @param v vector to be subtracted
- * @return {@code this - v}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- */
- public ArrayFieldVector<T> subtract(ArrayFieldVector<T> v)
- throws DimensionMismatchException {
- checkVectorDimensions(v.data.length);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].subtract(v.data[i]);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapAdd(T d) throws NullArgumentException {
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].add(d);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapAddToSelf(T d) throws NullArgumentException {
- for (int i = 0; i < data.length; i++) {
- data[i] = data[i].add(d);
- }
- return this;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapSubtract(T d) throws NullArgumentException {
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].subtract(d);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapSubtractToSelf(T d) throws NullArgumentException {
- for (int i = 0; i < data.length; i++) {
- data[i] = data[i].subtract(d);
- }
- return this;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapMultiply(T d) throws NullArgumentException {
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].multiply(d);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapMultiplyToSelf(T d) throws NullArgumentException {
- for (int i = 0; i < data.length; i++) {
- data[i] = data[i].multiply(d);
- }
- return this;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapDivide(T d)
- throws NullArgumentException, MathArithmeticException {
- MathUtils.checkNotNull(d);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].divide(d);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapDivideToSelf(T d)
- throws NullArgumentException, MathArithmeticException {
- MathUtils.checkNotNull(d);
- for (int i = 0; i < data.length; i++) {
- data[i] = data[i].divide(d);
- }
- return this;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapInv() throws MathArithmeticException {
- T[] out = MathArrays.buildArray(field, data.length);
- final T one = field.getOne();
- for (int i = 0; i < data.length; i++) {
- try {
- out[i] = one.divide(data[i]);
- } catch (final MathArithmeticException e) {
- throw new MathArithmeticException(LocalizedFormats.INDEX, i);
- }
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> mapInvToSelf() throws MathArithmeticException {
- final T one = field.getOne();
- for (int i = 0; i < data.length; i++) {
- try {
- data[i] = one.divide(data[i]);
- } catch (final MathArithmeticException e) {
- throw new MathArithmeticException(LocalizedFormats.INDEX, i);
- }
- }
- return this;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> ebeMultiply(FieldVector<T> v)
- throws DimensionMismatchException {
- try {
- return ebeMultiply((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- checkVectorDimensions(v);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].multiply(v.getEntry(i));
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
- }
-
- /**
- * Element-by-element multiplication.
- * @param v vector by which instance elements must be multiplied
- * @return a vector containing {@code this[i] * v[i]} for all {@code i}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- */
- public ArrayFieldVector<T> ebeMultiply(ArrayFieldVector<T> v)
- throws DimensionMismatchException {
- checkVectorDimensions(v.data.length);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- out[i] = data[i].multiply(v.data[i]);
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> ebeDivide(FieldVector<T> v)
- throws DimensionMismatchException, MathArithmeticException {
- try {
- return ebeDivide((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- checkVectorDimensions(v);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- try {
- out[i] = data[i].divide(v.getEntry(i));
- } catch (final MathArithmeticException e) {
- throw new MathArithmeticException(LocalizedFormats.INDEX, i);
- }
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
- }
-
- /**
- * Element-by-element division.
- * @param v vector by which instance elements must be divided
- * @return a vector containing {@code this[i] / v[i]} for all {@code i}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- * @throws MathArithmeticException if one entry of {@code v} is zero.
- */
- public ArrayFieldVector<T> ebeDivide(ArrayFieldVector<T> v)
- throws DimensionMismatchException, MathArithmeticException {
- checkVectorDimensions(v.data.length);
- T[] out = MathArrays.buildArray(field, data.length);
- for (int i = 0; i < data.length; i++) {
- try {
- out[i] = data[i].divide(v.data[i]);
- } catch (final MathArithmeticException e) {
- throw new MathArithmeticException(LocalizedFormats.INDEX, i);
- }
- }
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public T[] 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 T[] getDataRef() {
- return data;
- }
-
- /** {@inheritDoc} */
- public T dotProduct(FieldVector<T> v)
- throws DimensionMismatchException {
- try {
- return dotProduct((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- checkVectorDimensions(v);
- T dot = field.getZero();
- for (int i = 0; i < data.length; i++) {
- dot = dot.add(data[i].multiply(v.getEntry(i)));
- }
- return dot;
- }
- }
-
- /**
- * Compute the dot product.
- * @param v vector with which dot product should be computed
- * @return the scalar dot product of {@code this} and {@code v}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- */
- public T dotProduct(ArrayFieldVector<T> v)
- throws DimensionMismatchException {
- checkVectorDimensions(v.data.length);
- T dot = field.getZero();
- for (int i = 0; i < data.length; i++) {
- dot = dot.add(data[i].multiply(v.data[i]));
- }
- return dot;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> projection(FieldVector<T> v)
- throws DimensionMismatchException, MathArithmeticException {
- return v.mapMultiply(dotProduct(v).divide(v.dotProduct(v)));
- }
-
- /** Find the orthogonal projection of this vector onto another vector.
- * @param v vector onto which {@code this} must be projected
- * @return projection of {@code this} onto {@code v}
- * @throws DimensionMismatchException if {@code v} is not the same size as
- * {@code this}
- * @throws MathArithmeticException if {@code v} is the null vector.
- */
- public ArrayFieldVector<T> projection(ArrayFieldVector<T> v)
- throws DimensionMismatchException, MathArithmeticException {
- return (ArrayFieldVector<T>) v.mapMultiply(dotProduct(v).divide(v.dotProduct(v)));
- }
-
- /** {@inheritDoc} */
- public FieldMatrix<T> outerProduct(FieldVector<T> v) {
- try {
- return outerProduct((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- final int m = data.length;
- final int n = v.getDimension();
- final FieldMatrix<T> out = new Array2DRowFieldMatrix<T>(field, m, n);
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- out.setEntry(i, j, data[i].multiply(v.getEntry(j)));
- }
- }
- return out;
- }
- }
-
- /**
- * Compute the outer product.
- * @param v vector with which outer product should be computed
- * @return the matrix outer product between instance and v
- */
- public FieldMatrix<T> outerProduct(ArrayFieldVector<T> v) {
- final int m = data.length;
- final int n = v.data.length;
- final FieldMatrix<T> out = new Array2DRowFieldMatrix<T>(field, m, n);
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- out.setEntry(i, j, data[i].multiply(v.data[j]));
- }
- }
- return out;
- }
-
- /** {@inheritDoc} */
- public T getEntry(int index) {
- return data[index];
- }
-
- /** {@inheritDoc} */
- public int getDimension() {
- return data.length;
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> append(FieldVector<T> v) {
- try {
- return append((ArrayFieldVector<T>) v);
- } catch (ClassCastException cce) {
- return new ArrayFieldVector<T>(this,new ArrayFieldVector<T>(v));
- }
- }
-
- /**
- * Construct a vector by appending a vector to this vector.
- * @param v vector to append to this one.
- * @return a new vector
- */
- public ArrayFieldVector<T> append(ArrayFieldVector<T> v) {
- return new ArrayFieldVector<T>(this, v);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> append(T in) {
- final T[] out = MathArrays.buildArray(field, data.length + 1);
- System.arraycopy(data, 0, out, 0, data.length);
- out[data.length] = in;
- return new ArrayFieldVector<T>(field, out, false);
- }
-
- /** {@inheritDoc} */
- public FieldVector<T> getSubVector(int index, int n)
- throws OutOfRangeException, NotPositiveException {
- if (n < 0) {
- throw new NotPositiveException(LocalizedFormats.NUMBER_OF_ELEMENTS_SHOULD_BE_POSITIVE, n);
- }
- ArrayFieldVector<T> out = new ArrayFieldVector<T>(field, 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, T value) {
- try {
- data[index] = value;
- } catch (IndexOutOfBoundsException e) {
- checkIndex(index);
- }
- }
-
- /** {@inheritDoc} */
- public void setSubVector(int index, FieldVector<T> v) throws OutOfRangeException {
- try {
- try {
- set(index, (ArrayFieldVector<T>) 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);
- }
- }
-
- /**
- * 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 invalid.
- */
- public void set(int index, ArrayFieldVector<T> v) throws OutOfRangeException {
- try {
- System.arraycopy(v.data, 0, data, index, v.data.length);
- } catch (IndexOutOfBoundsException e) {
- checkIndex(index);
- checkIndex(index + v.data.length - 1);
- }
- }
-
- /** {@inheritDoc} */
- public void set(T value) {
- Arrays.fill(data, value);
- }
-
- /** {@inheritDoc} */
- public T[] toArray(){
- return data.clone();
- }
-
- /**
- * Check if instance and specified vectors have the same dimension.
- * @param v vector to compare instance with
- * @exception DimensionMismatchException if the vectors do not
- * have the same dimensions
- */
- protected void checkVectorDimensions(FieldVector<T> 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 not equal to the
- * size of {@code this} vector.
- */
- protected void checkVectorDimensions(int n)
- throws DimensionMismatchException {
- if (data.length != n) {
- throw new DimensionMismatchException(data.length, n);
- }
- }
-
- /**
- * Visits (but does not alter) all entries of this vector in default order
- * (increasing index).
- *
- * @param visitor the visitor to be used to process the entries of this
- * vector
- * @return the value returned by {@link FieldVectorPreservingVisitor#end()}
- * at the end of the walk
- * @since 3.3
- */
- public T walkInDefaultOrder(final FieldVectorPreservingVisitor<T> visitor) {
- final int dim = getDimension();
- visitor.start(dim, 0, dim - 1);
- for (int i = 0; i < dim; i++) {
- visitor.visit(i, getEntry(i));
- }
- return visitor.end();
- }
-
- /**
- * Visits (but does not alter) some entries of this vector in default order
- * (increasing index).
- *
- * @param visitor visitor to be used to process the entries of this vector
- * @param start the index of the first entry to be visited
- * @param end the index of the last entry to be visited (inclusive)
- * @return the value returned by {@link FieldVectorPreservingVisitor#end()}
- * at the end of the walk
- * @throws NumberIsTooSmallException if {@code end < start}.
- * @throws OutOfRangeException if the indices are not valid.
- * @since 3.3
- */
- public T walkInDefaultOrder(final FieldVectorPreservingVisitor<T> visitor,
- final int start, final int end)
- throws NumberIsTooSmallException, OutOfRangeException {
- checkIndices(start, end);
- visitor.start(getDimension(), start, end);
- for (int i = start; i <= end; i++) {
- visitor.visit(i, getEntry(i));
- }
- return visitor.end();
- }
-
- /**
- * Visits (but does not alter) all entries of this vector in optimized
- * order. The order in which the entries are visited is selected so as to
- * lead to the most efficient implementation; it might depend on the
- * concrete implementation of this abstract class.
- *
- * @param visitor the visitor to be used to process the entries of this
- * vector
- * @return the value returned by {@link FieldVectorPreservingVisitor#end()}
- * at the end of the walk
- * @since 3.3
- */
- public T walkInOptimizedOrder(final FieldVectorPreservingVisitor<T> visitor) {
- return walkInDefaultOrder(visitor);
- }
-
- /**
- * Visits (but does not alter) some entries of this vector in optimized
- * order. The order in which the entries are visited is selected so as to
- * lead to the most efficient implementation; it might depend on the
- * concrete implementation of this abstract class.
- *
- * @param visitor visitor to be used to process the entries of this vector
- * @param start the index of the first entry to be visited
- * @param end the index of the last entry to be visited (inclusive)
- * @return the value returned by {@link FieldVectorPreservingVisitor#end()}
- * at the end of the walk
- * @throws NumberIsTooSmallException if {@code end < start}.
- * @throws OutOfRangeException if the indices are not valid.
- * @since 3.3
- */
- public T walkInOptimizedOrder(final FieldVectorPreservingVisitor<T> visitor,
- final int start, final int end)
- throws NumberIsTooSmallException, OutOfRangeException {
- return walkInDefaultOrder(visitor, start, end);
- }
-
- /**
- * Visits (and possibly alters) all entries of this vector in default order
- * (increasing index).
- *
- * @param visitor the visitor to be used to process and modify the entries
- * of this vector
- * @return the value returned by {@link FieldVectorChangingVisitor#end()}
- * at the end of the walk
- * @since 3.3
- */
- public T walkInDefaultOrder(final FieldVectorChangingVisitor<T> visitor) {
- final int dim = getDimension();
- visitor.start(dim, 0, dim - 1);
- for (int i = 0; i < dim; i++) {
- setEntry(i, visitor.visit(i, getEntry(i)));
- }
- return visitor.end();
- }
-
- /**
- * Visits (and possibly alters) some entries of this vector in default order
- * (increasing index).
- *
- * @param visitor visitor to be used to process the entries of this vector
- * @param start the index of the first entry to be visited
- * @param end the index of the last entry to be visited (inclusive)
- * @return the value returned by {@link FieldVectorChangingVisitor#end()}
- * at the end of the walk
- * @throws NumberIsTooSmallException if {@code end < start}.
- * @throws OutOfRangeException if the indices are not valid.
- * @since 3.3
- */
- public T walkInDefaultOrder(final FieldVectorChangingVisitor<T> visitor,
- final int start, final int end)
- throws NumberIsTooSmallException, OutOfRangeException {
- checkIndices(start, end);
- visitor.start(getDimension(), start, end);
- for (int i = start; i <= end; i++) {
- setEntry(i, visitor.visit(i, getEntry(i)));
- }
- return visitor.end();
- }
-
- /**
- * Visits (and possibly alters) all entries of this vector in optimized
- * order. The order in which the entries are visited is selected so as to
- * lead to the most efficient implementation; it might depend on the
- * concrete implementation of this abstract class.
- *
- * @param visitor the visitor to be used to process the entries of this
- * vector
- * @return the value returned by {@link FieldVectorChangingVisitor#end()}
- * at the end of the walk
- * @since 3.3
- */
- public T walkInOptimizedOrder(final FieldVectorChangingVisitor<T> visitor) {
- return walkInDefaultOrder(visitor);
- }
-
- /**
- * Visits (and possibly change) some entries of this vector in optimized
- * order. The order in which the entries are visited is selected so as to
- * lead to the most efficient implementation; it might depend on the
- * concrete implementation of this abstract class.
- *
- * @param visitor visitor to be used to process the entries of this vector
- * @param start the index of the first entry to be visited
- * @param end the index of the last entry to be visited (inclusive)
- * @return the value returned by {@link FieldVectorChangingVisitor#end()}
- * at the end of the walk
- * @throws NumberIsTooSmallException if {@code end < start}.
- * @throws OutOfRangeException if the indices are not valid.
- * @since 3.3
- */
- public T walkInOptimizedOrder(final FieldVectorChangingVisitor<T> visitor,
- final int start, final int end)
- throws NumberIsTooSmallException, OutOfRangeException {
- return walkInDefaultOrder(visitor, start, end);
- }
-
- /**
- * Test for the equality of two vectors.
- *
- * @param other Object to test for equality.
- * @return {@code true} if two vector objects are equal, {@code false}
- * otherwise.
- */
- @Override
- public boolean equals(Object other) {
- if (this == other) {
- return true;
- }
- if (other == null) {
- return false;
- }
-
- try {
- @SuppressWarnings("unchecked") // May fail, but we ignore ClassCastException
- FieldVector<T> rhs = (FieldVector<T>) other;
- if (data.length != rhs.getDimension()) {
- return false;
- }
-
- for (int i = 0; i < data.length; ++i) {
- if (!data[i].equals(rhs.getEntry(i))) {
- return false;
- }
- }
- return true;
- } catch (ClassCastException ex) {
- // ignore exception
- return false;
- }
- }
-
- /**
- * 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() {
- int h = 3542;
- for (final T a : data) {
- h ^= a.hashCode();
- }
- return h;
- }
-
- /**
- * Check if an index is valid.
- *
- * @param index Index to check.
- * @exception OutOfRangeException if the index is not valid.
- */
- private void checkIndex(final int index) throws OutOfRangeException {
- if (index < 0 || index >= getDimension()) {
- throw new OutOfRangeException(LocalizedFormats.INDEX,
- index, 0, getDimension() - 1);
- }
- }
-
- /**
- * Checks that the indices of a subvector are valid.
- *
- * @param start the index of the first entry of the subvector
- * @param end the index of the last entry of the subvector (inclusive)
- * @throws OutOfRangeException if {@code start} of {@code end} are not valid
- * @throws NumberIsTooSmallException if {@code end < start}
- * @since 3.3
- */
- private void checkIndices(final int start, final int end)
- throws NumberIsTooSmallException, OutOfRangeException {
- final int dim = getDimension();
- if ((start < 0) || (start >= dim)) {
- throw new OutOfRangeException(LocalizedFormats.INDEX, start, 0,
- dim - 1);
- }
- if ((end < 0) || (end >= dim)) {
- throw new OutOfRangeException(LocalizedFormats.INDEX, end, 0,
- dim - 1);
- }
- if (end < start) {
- throw new NumberIsTooSmallException(LocalizedFormats.INITIAL_ROW_AFTER_FINAL_ROW,
- end, start, false);
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/linear/ArrayRealVector.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/linear/ArrayRealVector.java b/src/main/java/org/apache/commons/math3/linear/ArrayRealVector.java
deleted file mode 100644
index 00b81d0..0000000
--- a/src/main/java/org/apache/commons/math3/linear/ArrayRealVector.java
+++ /dev/null
@@ -1,954 +0,0 @@
-/*
- * 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.math3.linear;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.Iterator;
-
-import org.apache.commons.math3.analysis.UnivariateFunction;
-import org.apache.commons.math3.exception.NotPositiveException;
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.DimensionMismatchException;
-import org.apache.commons.math3.exception.NumberIsTooLargeException;
-import org.apache.commons.math3.exception.NumberIsTooSmallException;
-import org.apache.commons.math3.exception.OutOfRangeException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-import org.apache.commons.math3.util.MathUtils;
-import org.apache.commons.math3.util.FastMath;
-
-/**
- * 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 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 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 FastMath.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 FastMath.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 += FastMath.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 += FastMath.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 = FastMath.max(max, FastMath.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 = FastMath.max(max, FastMath.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) {
- 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} */
- @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 MathUtils.hash(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);
- }
-}