001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.commons.math3.linear;
019
020 import java.util.Iterator;
021 import java.util.NoSuchElementException;
022
023 import org.apache.commons.math3.exception.MathUnsupportedOperationException;
024 import org.apache.commons.math3.exception.DimensionMismatchException;
025 import org.apache.commons.math3.exception.NotPositiveException;
026 import org.apache.commons.math3.exception.NumberIsTooSmallException;
027 import org.apache.commons.math3.exception.OutOfRangeException;
028 import org.apache.commons.math3.exception.MathArithmeticException;
029 import org.apache.commons.math3.analysis.FunctionUtils;
030 import org.apache.commons.math3.analysis.function.Add;
031 import org.apache.commons.math3.analysis.function.Multiply;
032 import org.apache.commons.math3.analysis.function.Divide;
033 import org.apache.commons.math3.analysis.UnivariateFunction;
034 import org.apache.commons.math3.exception.util.LocalizedFormats;
035 import org.apache.commons.math3.util.FastMath;
036
037 /**
038 * Class defining a real-valued vector with basic algebraic operations.
039 * <p>
040 * vector element indexing is 0-based -- e.g., {@code getEntry(0)}
041 * returns the first element of the vector.
042 * </p>
043 * <p>
044 * The {@code code map} and {@code mapToSelf} methods operate
045 * on vectors element-wise, i.e. they perform the same operation (adding a scalar,
046 * applying a function ...) on each element in turn. The {@code map}
047 * versions create a new vector to hold the result and do not change the instance.
048 * The {@code mapToSelf} version uses the instance itself to store the
049 * results, so the instance is changed by this method. In all cases, the result
050 * vector is returned by the methods, allowing the <i>fluent API</i>
051 * style, like this:
052 * </p>
053 * <pre>
054 * RealVector result = v.mapAddToSelf(3.4).mapToSelf(new Tan()).mapToSelf(new Power(2.3));
055 * </pre>
056 *
057 * @version $Id: RealVector.java 1422313 2012-12-15 18:53:41Z psteitz $
058 * @since 2.1
059 */
060 public abstract class RealVector {
061 /**
062 * Returns the size of the vector.
063 *
064 * @return the size of this vector.
065 */
066 public abstract int getDimension();
067
068 /**
069 * Return the entry at the specified index.
070 *
071 * @param index Index location of entry to be fetched.
072 * @return the vector entry at {@code index}.
073 * @throws OutOfRangeException if the index is not valid.
074 * @see #setEntry(int, double)
075 */
076 public abstract double getEntry(int index) throws OutOfRangeException;
077
078 /**
079 * Set a single element.
080 *
081 * @param index element index.
082 * @param value new value for the element.
083 * @throws OutOfRangeException if the index is not valid.
084 * @see #getEntry(int)
085 */
086 public abstract void setEntry(int index, double value)
087 throws OutOfRangeException;
088
089 /**
090 * Change an entry at the specified index.
091 *
092 * @param index Index location of entry to be set.
093 * @param increment Value to add to the vector entry.
094 * @throws OutOfRangeException if the index is not valid.
095 * @since 3.0
096 */
097 public void addToEntry(int index, double increment)
098 throws OutOfRangeException {
099 setEntry(index, getEntry(index) + increment);
100 }
101
102 /**
103 * Construct a new vector by appending a vector to this vector.
104 *
105 * @param v vector to append to this one.
106 * @return a new vector.
107 */
108 public abstract RealVector append(RealVector v);
109
110 /**
111 * Construct a new vector by appending a double to this vector.
112 *
113 * @param d double to append.
114 * @return a new vector.
115 */
116 public abstract RealVector append(double d);
117
118 /**
119 * Get a subvector from consecutive elements.
120 *
121 * @param index index of first element.
122 * @param n number of elements to be retrieved.
123 * @return a vector containing n elements.
124 * @throws OutOfRangeException if the index is not valid.
125 * @throws NotPositiveException if the number of elements is not positive.
126 */
127 public abstract RealVector getSubVector(int index, int n)
128 throws NotPositiveException, OutOfRangeException;
129
130 /**
131 * Set a sequence of consecutive elements.
132 *
133 * @param index index of first element to be set.
134 * @param v vector containing the values to set.
135 * @throws OutOfRangeException if the index is not valid.
136 */
137 public abstract void setSubVector(int index, RealVector v)
138 throws OutOfRangeException;
139
140 /**
141 * Check whether any coordinate of this vector is {@code NaN}.
142 *
143 * @return {@code true} if any coordinate of this vector is {@code NaN},
144 * {@code false} otherwise.
145 */
146 public abstract boolean isNaN();
147
148 /**
149 * Check whether any coordinate of this vector is infinite and none are {@code NaN}.
150 *
151 * @return {@code true} if any coordinate of this vector is infinite and
152 * none are {@code NaN}, {@code false} otherwise.
153 */
154 public abstract boolean isInfinite();
155
156 /**
157 * Check if instance and specified vectors have the same dimension.
158 *
159 * @param v Vector to compare instance with.
160 * @throws DimensionMismatchException if the vectors do not
161 * have the same dimension.
162 */
163 protected void checkVectorDimensions(RealVector v)
164 throws DimensionMismatchException {
165 checkVectorDimensions(v.getDimension());
166 }
167
168 /**
169 * Check if instance dimension is equal to some expected value.
170 *
171 * @param n Expected dimension.
172 * @throws DimensionMismatchException if the dimension is
173 * inconsistent with the vector size.
174 */
175 protected void checkVectorDimensions(int n)
176 throws DimensionMismatchException {
177 int d = getDimension();
178 if (d != n) {
179 throw new DimensionMismatchException(d, n);
180 }
181 }
182
183 /**
184 * Check if an index is valid.
185 *
186 * @param index Index to check.
187 * @exception OutOfRangeException if {@code index} is not valid.
188 */
189 protected void checkIndex(final int index) throws OutOfRangeException {
190 if (index < 0 ||
191 index >= getDimension()) {
192 throw new OutOfRangeException(LocalizedFormats.INDEX,
193 index, 0, getDimension() - 1);
194 }
195 }
196
197 /**
198 * Checks that the indices of a subvector are valid.
199 *
200 * @param start the index of the first entry of the subvector
201 * @param end the index of the last entry of the subvector (inclusive)
202 * @throws OutOfRangeException if {@code start} of {@code end} are not valid
203 * @throws NumberIsTooSmallException if {@code end < start}
204 * @since 3.1
205 */
206 protected void checkIndices(final int start, final int end)
207 throws NumberIsTooSmallException, OutOfRangeException {
208 final int dim = getDimension();
209 if ((start < 0) || (start >= dim)) {
210 throw new OutOfRangeException(LocalizedFormats.INDEX, start, 0,
211 dim - 1);
212 }
213 if ((end < 0) || (end >= dim)) {
214 throw new OutOfRangeException(LocalizedFormats.INDEX, end, 0,
215 dim - 1);
216 }
217 if (end < start) {
218 // TODO Use more specific error message
219 throw new NumberIsTooSmallException(LocalizedFormats.INITIAL_ROW_AFTER_FINAL_ROW,
220 end, start, false);
221 }
222 }
223
224 /**
225 * Compute the sum of this vector and {@code v}.
226 * Returns a new vector. Does not change instance data.
227 *
228 * @param v Vector to be added.
229 * @return {@code this} + {@code v}.
230 * @throws DimensionMismatchException if {@code v} is not the same size as
231 * {@code this} vector.
232 */
233 public RealVector add(RealVector v) throws DimensionMismatchException {
234 checkVectorDimensions(v);
235 RealVector result = v.copy();
236 Iterator<Entry> it = iterator();
237 while (it.hasNext()) {
238 final Entry e = it.next();
239 final int index = e.getIndex();
240 result.setEntry(index, e.getValue() + result.getEntry(index));
241 }
242 return result;
243 }
244
245 /**
246 * Subtract {@code v} from this vector.
247 * Returns a new vector. Does not change instance data.
248 *
249 * @param v Vector to be subtracted.
250 * @return {@code this} - {@code v}.
251 * @throws DimensionMismatchException if {@code v} is not the same size as
252 * {@code this} vector.
253 */
254 public RealVector subtract(RealVector v) throws DimensionMismatchException {
255 checkVectorDimensions(v);
256 RealVector result = v.mapMultiply(-1d);
257 Iterator<Entry> it = iterator();
258 while (it.hasNext()) {
259 final Entry e = it.next();
260 final int index = e.getIndex();
261 result.setEntry(index, e.getValue() + result.getEntry(index));
262 }
263 return result;
264 }
265
266 /**
267 * Add a value to each entry.
268 * Returns a new vector. Does not change instance data.
269 *
270 * @param d Value to be added to each entry.
271 * @return {@code this} + {@code d}.
272 */
273 public RealVector mapAdd(double d) {
274 return copy().mapAddToSelf(d);
275 }
276
277 /**
278 * Add a value to each entry.
279 * The instance is changed in-place.
280 *
281 * @param d Value to be added to each entry.
282 * @return {@code this}.
283 */
284 public RealVector mapAddToSelf(double d) {
285 if (d != 0) {
286 return mapToSelf(FunctionUtils.fix2ndArgument(new Add(), d));
287 }
288 return this;
289 }
290
291 /**
292 * Returns a (deep) copy of this vector.
293 *
294 * @return a vector copy.
295 */
296 public abstract RealVector copy();
297
298 /**
299 * Compute the dot product of this vector with {@code v}.
300 *
301 * @param v Vector with which dot product should be computed
302 * @return the scalar dot product between this instance and {@code v}.
303 * @throws DimensionMismatchException if {@code v} is not the same size as
304 * {@code this} vector.
305 */
306 public double dotProduct(RealVector v) throws DimensionMismatchException {
307 checkVectorDimensions(v);
308 double d = 0;
309 final int n = getDimension();
310 for (int i = 0; i < n; i++) {
311 d += getEntry(i) * v.getEntry(i);
312 }
313 return d;
314 }
315
316 /**
317 * Computes the cosine of the angle between this vector and the
318 * argument.
319 *
320 * @param v Vector.
321 * @return the cosine of the angle between this vector and {@code v}.
322 * @throws MathArithmeticException if {@code this} or {@code v} is the null
323 * vector
324 * @throws DimensionMismatchException if the dimensions of {@code this} and
325 * {@code v} do not match
326 */
327 public double cosine(RealVector v) throws DimensionMismatchException,
328 MathArithmeticException {
329 final double norm = getNorm();
330 final double vNorm = v.getNorm();
331
332 if (norm == 0 ||
333 vNorm == 0) {
334 throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
335 }
336 return dotProduct(v) / (norm * vNorm);
337 }
338
339 /**
340 * Element-by-element division.
341 *
342 * @param v Vector by which instance elements must be divided.
343 * @return a vector containing this[i] / v[i] for all i.
344 * @throws DimensionMismatchException if {@code v} is not the same size as
345 * {@code this} vector.
346 * @deprecated As of version 3.1, this method is deprecated, and will be
347 * removed in version 4.0. This decision follows the discussion reported in
348 * <a href="https://issues.apache.org/jira/browse/MATH-803?focusedCommentId=13399150#comment-13399150">MATH-803</a>.
349 * Uses of this method involving sparse implementations of
350 * {@link RealVector} might lead to wrong results. Since there is no
351 * satisfactory correction to this bug, this method is deprecated. Users who
352 * want to preserve this feature are advised to implement
353 * {@link RealVectorPreservingVisitor} (possibly ignoring corner cases for
354 * the sake of efficiency).
355 */
356 @Deprecated
357 public abstract RealVector ebeDivide(RealVector v)
358 throws DimensionMismatchException;
359
360 /**
361 * Element-by-element multiplication.
362 *
363 * @param v Vector by which instance elements must be multiplied
364 * @return a vector containing this[i] * v[i] for all i.
365 * @throws DimensionMismatchException if {@code v} is not the same size as
366 * {@code this} vector.
367 * @deprecated As of version 3.1, this method is deprecated, and will be
368 * removed in version 4.0. This decision follows the discussion reported in
369 * <a href="https://issues.apache.org/jira/browse/MATH-803?focusedCommentId=13399150#comment-13399150">MATH-803</a>.
370 * Uses of this method involving sparse implementations of
371 * {@link RealVector} might lead to wrong results. Since there is no
372 * satisfactory correction to this bug, this method is deprecated. Users who
373 * want to preserve this feature are advised to implement
374 * {@link RealVectorPreservingVisitor} (possibly ignoring corner cases for
375 * the sake of efficiency).
376 */
377 @Deprecated
378 public abstract RealVector ebeMultiply(RealVector v)
379 throws DimensionMismatchException;
380
381 /**
382 * Distance between two vectors.
383 * <p>This method computes the distance consistent with the
384 * L<sub>2</sub> norm, i.e. the square root of the sum of
385 * element differences, or Euclidean distance.</p>
386 *
387 * @param v Vector to which distance is requested.
388 * @return the distance between two vectors.
389 * @throws DimensionMismatchException if {@code v} is not the same size as
390 * {@code this} vector.
391 * @see #getL1Distance(RealVector)
392 * @see #getLInfDistance(RealVector)
393 * @see #getNorm()
394 */
395 public double getDistance(RealVector v) throws DimensionMismatchException {
396 checkVectorDimensions(v);
397 double d = 0;
398 Iterator<Entry> it = iterator();
399 while (it.hasNext()) {
400 final Entry e = it.next();
401 final double diff = e.getValue() - v.getEntry(e.getIndex());
402 d += diff * diff;
403 }
404 return FastMath.sqrt(d);
405 }
406
407 /**
408 * Returns the L<sub>2</sub> norm of the vector.
409 * <p>The L<sub>2</sub> norm is the root of the sum of
410 * the squared elements.</p>
411 *
412 * @return the norm.
413 * @see #getL1Norm()
414 * @see #getLInfNorm()
415 * @see #getDistance(RealVector)
416 */
417 public double getNorm() {
418 double sum = 0;
419 Iterator<Entry> it = iterator();
420 while (it.hasNext()) {
421 final Entry e = it.next();
422 final double value = e.getValue();
423 sum += value * value;
424 }
425 return FastMath.sqrt(sum);
426 }
427
428 /**
429 * Returns the L<sub>1</sub> norm of the vector.
430 * <p>The L<sub>1</sub> norm is the sum of the absolute
431 * values of the elements.</p>
432 *
433 * @return the norm.
434 * @see #getNorm()
435 * @see #getLInfNorm()
436 * @see #getL1Distance(RealVector)
437 */
438 public double getL1Norm() {
439 double norm = 0;
440 Iterator<Entry> it = iterator();
441 while (it.hasNext()) {
442 final Entry e = it.next();
443 norm += FastMath.abs(e.getValue());
444 }
445 return norm;
446 }
447
448 /**
449 * Returns the L<sub>∞</sub> norm of the vector.
450 * <p>The L<sub>∞</sub> norm is the max of the absolute
451 * values of the elements.</p>
452 *
453 * @return the norm.
454 * @see #getNorm()
455 * @see #getL1Norm()
456 * @see #getLInfDistance(RealVector)
457 */
458 public double getLInfNorm() {
459 double norm = 0;
460 Iterator<Entry> it = iterator();
461 while (it.hasNext()) {
462 final Entry e = it.next();
463 norm = FastMath.max(norm, FastMath.abs(e.getValue()));
464 }
465 return norm;
466 }
467
468 /**
469 * Distance between two vectors.
470 * <p>This method computes the distance consistent with
471 * L<sub>1</sub> norm, i.e. the sum of the absolute values of
472 * the elements differences.</p>
473 *
474 * @param v Vector to which distance is requested.
475 * @return the distance between two vectors.
476 * @throws DimensionMismatchException if {@code v} is not the same size as
477 * {@code this} vector.
478 */
479 public double getL1Distance(RealVector v)
480 throws DimensionMismatchException {
481 checkVectorDimensions(v);
482 double d = 0;
483 Iterator<Entry> it = iterator();
484 while (it.hasNext()) {
485 final Entry e = it.next();
486 d += FastMath.abs(e.getValue() - v.getEntry(e.getIndex()));
487 }
488 return d;
489 }
490
491 /**
492 * Distance between two vectors.
493 * <p>This method computes the distance consistent with
494 * L<sub>∞</sub> norm, i.e. the max of the absolute values of
495 * element differences.</p>
496 *
497 * @param v Vector to which distance is requested.
498 * @return the distance between two vectors.
499 * @throws DimensionMismatchException if {@code v} is not the same size as
500 * {@code this} vector.
501 * @see #getDistance(RealVector)
502 * @see #getL1Distance(RealVector)
503 * @see #getLInfNorm()
504 */
505 public double getLInfDistance(RealVector v)
506 throws DimensionMismatchException {
507 checkVectorDimensions(v);
508 double d = 0;
509 Iterator<Entry> it = iterator();
510 while (it.hasNext()) {
511 final Entry e = it.next();
512 d = FastMath.max(FastMath.abs(e.getValue() - v.getEntry(e.getIndex())), d);
513 }
514 return d;
515 }
516
517 /**
518 * Get the index of the minimum entry.
519 *
520 * @return the index of the minimum entry or -1 if vector length is 0
521 * or all entries are {@code NaN}.
522 */
523 public int getMinIndex() {
524 int minIndex = -1;
525 double minValue = Double.POSITIVE_INFINITY;
526 Iterator<Entry> iterator = iterator();
527 while (iterator.hasNext()) {
528 final Entry entry = iterator.next();
529 if (entry.getValue() <= minValue) {
530 minIndex = entry.getIndex();
531 minValue = entry.getValue();
532 }
533 }
534 return minIndex;
535 }
536
537 /**
538 * Get the value of the minimum entry.
539 *
540 * @return the value of the minimum entry or {@code NaN} if all
541 * entries are {@code NaN}.
542 */
543 public double getMinValue() {
544 final int minIndex = getMinIndex();
545 return minIndex < 0 ? Double.NaN : getEntry(minIndex);
546 }
547
548 /**
549 * Get the index of the maximum entry.
550 *
551 * @return the index of the maximum entry or -1 if vector length is 0
552 * or all entries are {@code NaN}
553 */
554 public int getMaxIndex() {
555 int maxIndex = -1;
556 double maxValue = Double.NEGATIVE_INFINITY;
557 Iterator<Entry> iterator = iterator();
558 while (iterator.hasNext()) {
559 final Entry entry = iterator.next();
560 if (entry.getValue() >= maxValue) {
561 maxIndex = entry.getIndex();
562 maxValue = entry.getValue();
563 }
564 }
565 return maxIndex;
566 }
567
568 /**
569 * Get the value of the maximum entry.
570 *
571 * @return the value of the maximum entry or {@code NaN} if all
572 * entries are {@code NaN}.
573 */
574 public double getMaxValue() {
575 final int maxIndex = getMaxIndex();
576 return maxIndex < 0 ? Double.NaN : getEntry(maxIndex);
577 }
578
579
580 /**
581 * Multiply each entry by the argument. Returns a new vector.
582 * Does not change instance data.
583 *
584 * @param d Multiplication factor.
585 * @return {@code this} * {@code d}.
586 */
587 public RealVector mapMultiply(double d) {
588 return copy().mapMultiplyToSelf(d);
589 }
590
591 /**
592 * Multiply each entry.
593 * The instance is changed in-place.
594 *
595 * @param d Multiplication factor.
596 * @return {@code this}.
597 */
598 public RealVector mapMultiplyToSelf(double d){
599 return mapToSelf(FunctionUtils.fix2ndArgument(new Multiply(), d));
600 }
601
602 /**
603 * Subtract a value from each entry. Returns a new vector.
604 * Does not change instance data.
605 *
606 * @param d Value to be subtracted.
607 * @return {@code this} - {@code d}.
608 */
609 public RealVector mapSubtract(double d) {
610 return copy().mapSubtractToSelf(d);
611 }
612
613 /**
614 * Subtract a value from each entry.
615 * The instance is changed in-place.
616 *
617 * @param d Value to be subtracted.
618 * @return {@code this}.
619 */
620 public RealVector mapSubtractToSelf(double d){
621 return mapAddToSelf(-d);
622 }
623
624 /**
625 * Divide each entry by the argument. Returns a new vector.
626 * Does not change instance data.
627 *
628 * @param d Value to divide by.
629 * @return {@code this} / {@code d}.
630 */
631 public RealVector mapDivide(double d) {
632 return copy().mapDivideToSelf(d);
633 }
634
635 /**
636 * Divide each entry by the argument.
637 * The instance is changed in-place.
638 *
639 * @param d Value to divide by.
640 * @return {@code this}.
641 */
642 public RealVector mapDivideToSelf(double d){
643 return mapToSelf(FunctionUtils.fix2ndArgument(new Divide(), d));
644 }
645
646 /**
647 * Compute the outer product.
648 *
649 * @param v Vector with which outer product should be computed.
650 * @return the matrix outer product between this instance and {@code v}.
651 */
652 public RealMatrix outerProduct(RealVector v) {
653 final int m = this.getDimension();
654 final int n = v.getDimension();
655 final RealMatrix product;
656 if (v instanceof SparseRealVector || this instanceof SparseRealVector) {
657 product = new OpenMapRealMatrix(m, n);
658 } else {
659 product = new Array2DRowRealMatrix(m, n);
660 }
661 for (int i = 0; i < m; i++) {
662 for (int j = 0; j < n; j++) {
663 product.setEntry(i, j, this.getEntry(i) * v.getEntry(j));
664 }
665 }
666 return product;
667 }
668
669 /**
670 * Find the orthogonal projection of this vector onto another vector.
671 *
672 * @param v vector onto which instance must be projected.
673 * @return projection of the instance onto {@code v}.
674 * @throws DimensionMismatchException if {@code v} is not the same size as
675 * {@code this} vector.
676 * @throws MathArithmeticException if {@code this} or {@code v} is the null
677 * vector
678 */
679 public RealVector projection(final RealVector v)
680 throws DimensionMismatchException, MathArithmeticException {
681 final double norm2 = v.dotProduct(v);
682 if (norm2 == 0.0) {
683 throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
684 }
685 return v.mapMultiply(dotProduct(v) / v.dotProduct(v));
686 }
687
688 /**
689 * Set all elements to a single value.
690 *
691 * @param value Single value to set for all elements.
692 */
693 public void set(double value) {
694 Iterator<Entry> it = iterator();
695 while (it.hasNext()) {
696 final Entry e = it.next();
697 e.setValue(value);
698 }
699 }
700
701 /**
702 * Convert the vector to an array of {@code double}s.
703 * The array is independent from this vector data: the elements
704 * are copied.
705 *
706 * @return an array containing a copy of the vector elements.
707 */
708 public double[] toArray() {
709 int dim = getDimension();
710 double[] values = new double[dim];
711 for (int i = 0; i < dim; i++) {
712 values[i] = getEntry(i);
713 }
714 return values;
715 }
716
717 /**
718 * Creates a unit vector pointing in the direction of this vector.
719 * The instance is not changed by this method.
720 *
721 * @return a unit vector pointing in direction of this vector.
722 * @throws MathArithmeticException if the norm is zero.
723 */
724 public RealVector unitVector() throws MathArithmeticException {
725 final double norm = getNorm();
726 if (norm == 0) {
727 throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
728 }
729 return mapDivide(norm);
730 }
731
732 /**
733 * Converts this vector into a unit vector.
734 * The instance itself is changed by this method.
735 *
736 * @throws MathArithmeticException if the norm is zero.
737 */
738 public void unitize() throws MathArithmeticException {
739 final double norm = getNorm();
740 if (norm == 0) {
741 throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
742 }
743 mapDivideToSelf(getNorm());
744 }
745
746 /**
747 * Create a sparse iterator over the vector, which may omit some entries.
748 * Specialized implementations may choose to not iterate over all
749 * dimensions, either because those values are unset, or are equal
750 * to defaultValue(), or are small enough to be ignored for the
751 * purposes of iteration. No guarantees are made about order of iteration.
752 * In dense implementations, this method will often delegate to
753 * {@link #iterator()}.
754 *
755 * <p>Note: derived classes are required to return an {@link Iterator} that
756 * returns non-null {@link Entry} objects as long as {@link Iterator#hasNext()}
757 * returns {@code true}.</p>
758 *
759 * @return a sparse iterator.
760 * @deprecated As of 3.1, this method is deprecated, because its interface
761 * is too confusing (see
762 * <a href="https://issues.apache.org/jira/browse/MATH-875">JIRA MATH-875</a>).
763 * This method will be completely removed in 4.0.
764 */
765 @Deprecated
766 public Iterator<Entry> sparseIterator() {
767 return new SparseEntryIterator();
768 }
769
770 /**
771 * Generic dense iterator. Iteration is in increasing order
772 * of the vector index.
773 *
774 * <p>Note: derived classes are required to return an {@link Iterator} that
775 * returns non-null {@link Entry} objects as long as {@link Iterator#hasNext()}
776 * returns {@code true}.</p>
777 *
778 * @return a dense iterator.
779 */
780 public Iterator<Entry> iterator() {
781 final int dim = getDimension();
782 return new Iterator<Entry>() {
783
784 /** Current index. */
785 private int i = 0;
786
787 /** Current entry. */
788 private Entry e = new Entry();
789
790 /** {@inheritDoc} */
791 public boolean hasNext() {
792 return i < dim;
793 }
794
795 /** {@inheritDoc} */
796 public Entry next() {
797 if (i < dim) {
798 e.setIndex(i++);
799 return e;
800 } else {
801 throw new NoSuchElementException();
802 }
803 }
804
805 /**
806 * {@inheritDoc}
807 *
808 * @throws MathUnsupportedOperationException in all circumstances.
809 */
810 public void remove() throws MathUnsupportedOperationException {
811 throw new MathUnsupportedOperationException();
812 }
813 };
814 }
815
816 /**
817 * Acts as if implemented as:
818 * <pre>
819 * return copy().mapToSelf(function);
820 * </pre>
821 * Returns a new vector. Does not change instance data.
822 *
823 * @param function Function to apply to each entry.
824 * @return a new vector.
825 */
826 public RealVector map(UnivariateFunction function) {
827 return copy().mapToSelf(function);
828 }
829
830 /**
831 * Acts as if it is implemented as:
832 * <pre>
833 * Entry e = null;
834 * for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) {
835 * e.setValue(function.value(e.getValue()));
836 * }
837 * </pre>
838 * Entries of this vector are modified in-place by this method.
839 *
840 * @param function Function to apply to each entry.
841 * @return a reference to this vector.
842 */
843 public RealVector mapToSelf(UnivariateFunction function) {
844 Iterator<Entry> it = iterator();
845 while (it.hasNext()) {
846 final Entry e = it.next();
847 e.setValue(function.value(e.getValue()));
848 }
849 return this;
850 }
851
852 /**
853 * Returns a new vector representing {@code a * this + b * y}, the linear
854 * combination of {@code this} and {@code y}.
855 * Returns a new vector. Does not change instance data.
856 *
857 * @param a Coefficient of {@code this}.
858 * @param b Coefficient of {@code y}.
859 * @param y Vector with which {@code this} is linearly combined.
860 * @return a vector containing {@code a * this[i] + b * y[i]} for all
861 * {@code i}.
862 * @throws DimensionMismatchException if {@code y} is not the same size as
863 * {@code this} vector.
864 */
865 public RealVector combine(double a, double b, RealVector y)
866 throws DimensionMismatchException {
867 return copy().combineToSelf(a, b, y);
868 }
869
870 /**
871 * Updates {@code this} with the linear combination of {@code this} and
872 * {@code y}.
873 *
874 * @param a Weight of {@code this}.
875 * @param b Weight of {@code y}.
876 * @param y Vector with which {@code this} is linearly combined.
877 * @return {@code this}, with components equal to
878 * {@code a * this[i] + b * y[i]} for all {@code i}.
879 * @throws DimensionMismatchException if {@code y} is not the same size as
880 * {@code this} vector.
881 */
882 public RealVector combineToSelf(double a, double b, RealVector y)
883 throws DimensionMismatchException {
884 checkVectorDimensions(y);
885 for (int i = 0; i < getDimension(); i++) {
886 final double xi = getEntry(i);
887 final double yi = y.getEntry(i);
888 setEntry(i, a * xi + b * yi);
889 }
890 return this;
891 }
892
893 /**
894 * Visits (but does not alter) all entries of this vector in default order
895 * (increasing index).
896 *
897 * @param visitor the visitor to be used to process the entries of this
898 * vector
899 * @return the value returned by {@link RealVectorPreservingVisitor#end()}
900 * at the end of the walk
901 * @since 3.1
902 */
903 public double walkInDefaultOrder(final RealVectorPreservingVisitor visitor) {
904 final int dim = getDimension();
905 visitor.start(dim, 0, dim - 1);
906 for (int i = 0; i < dim; i++) {
907 visitor.visit(i, getEntry(i));
908 }
909 return visitor.end();
910 }
911
912 /**
913 * Visits (but does not alter) some entries of this vector in default order
914 * (increasing index).
915 *
916 * @param visitor visitor to be used to process the entries of this vector
917 * @param start the index of the first entry to be visited
918 * @param end the index of the last entry to be visited (inclusive)
919 * @return the value returned by {@link RealVectorPreservingVisitor#end()}
920 * at the end of the walk
921 * @throws NumberIsTooSmallException if {@code end < start}.
922 * @throws OutOfRangeException if the indices are not valid.
923 * @since 3.1
924 */
925 public double walkInDefaultOrder(final RealVectorPreservingVisitor visitor,
926 final int start, final int end)
927 throws NumberIsTooSmallException, OutOfRangeException {
928 checkIndices(start, end);
929 visitor.start(getDimension(), start, end);
930 for (int i = start; i <= end; i++) {
931 visitor.visit(i, getEntry(i));
932 }
933 return visitor.end();
934 }
935
936 /**
937 * Visits (but does not alter) all entries of this vector in optimized
938 * order. The order in which the entries are visited is selected so as to
939 * lead to the most efficient implementation; it might depend on the
940 * concrete implementation of this abstract class.
941 *
942 * @param visitor the visitor to be used to process the entries of this
943 * vector
944 * @return the value returned by {@link RealVectorPreservingVisitor#end()}
945 * at the end of the walk
946 * @since 3.1
947 */
948 public double walkInOptimizedOrder(final RealVectorPreservingVisitor visitor) {
949 return walkInDefaultOrder(visitor);
950 }
951
952 /**
953 * Visits (but does not alter) some entries of this vector in optimized
954 * order. The order in which the entries are visited is selected so as to
955 * lead to the most efficient implementation; it might depend on the
956 * concrete implementation of this abstract class.
957 *
958 * @param visitor visitor to be used to process the entries of this vector
959 * @param start the index of the first entry to be visited
960 * @param end the index of the last entry to be visited (inclusive)
961 * @return the value returned by {@link RealVectorPreservingVisitor#end()}
962 * at the end of the walk
963 * @throws NumberIsTooSmallException if {@code end < start}.
964 * @throws OutOfRangeException if the indices are not valid.
965 * @since 3.1
966 */
967 public double walkInOptimizedOrder(final RealVectorPreservingVisitor visitor,
968 final int start, final int end)
969 throws NumberIsTooSmallException, OutOfRangeException {
970 return walkInDefaultOrder(visitor, start, end);
971 }
972
973 /**
974 * Visits (and possibly alters) all entries of this vector in default order
975 * (increasing index).
976 *
977 * @param visitor the visitor to be used to process and modify the entries
978 * of this vector
979 * @return the value returned by {@link RealVectorChangingVisitor#end()}
980 * at the end of the walk
981 * @since 3.1
982 */
983 public double walkInDefaultOrder(final RealVectorChangingVisitor visitor) {
984 final int dim = getDimension();
985 visitor.start(dim, 0, dim - 1);
986 for (int i = 0; i < dim; i++) {
987 setEntry(i, visitor.visit(i, getEntry(i)));
988 }
989 return visitor.end();
990 }
991
992 /**
993 * Visits (and possibly alters) some entries of this vector in default order
994 * (increasing index).
995 *
996 * @param visitor visitor to be used to process the entries of this vector
997 * @param start the index of the first entry to be visited
998 * @param end the index of the last entry to be visited (inclusive)
999 * @return the value returned by {@link RealVectorChangingVisitor#end()}
1000 * at the end of the walk
1001 * @throws NumberIsTooSmallException if {@code end < start}.
1002 * @throws OutOfRangeException if the indices are not valid.
1003 * @since 3.1
1004 */
1005 public double walkInDefaultOrder(final RealVectorChangingVisitor visitor,
1006 final int start, final int end)
1007 throws NumberIsTooSmallException, OutOfRangeException {
1008 checkIndices(start, end);
1009 visitor.start(getDimension(), start, end);
1010 for (int i = start; i <= end; i++) {
1011 setEntry(i, visitor.visit(i, getEntry(i)));
1012 }
1013 return visitor.end();
1014 }
1015
1016 /**
1017 * Visits (and possibly alters) all entries of this vector in optimized
1018 * order. The order in which the entries are visited is selected so as to
1019 * lead to the most efficient implementation; it might depend on the
1020 * concrete implementation of this abstract class.
1021 *
1022 * @param visitor the visitor to be used to process the entries of this
1023 * vector
1024 * @return the value returned by {@link RealVectorChangingVisitor#end()}
1025 * at the end of the walk
1026 * @since 3.1
1027 */
1028 public double walkInOptimizedOrder(final RealVectorChangingVisitor visitor) {
1029 return walkInDefaultOrder(visitor);
1030 }
1031
1032 /**
1033 * Visits (and possibly change) some entries of this vector in optimized
1034 * order. The order in which the entries are visited is selected so as to
1035 * lead to the most efficient implementation; it might depend on the
1036 * concrete implementation of this abstract class.
1037 *
1038 * @param visitor visitor to be used to process the entries of this vector
1039 * @param start the index of the first entry to be visited
1040 * @param end the index of the last entry to be visited (inclusive)
1041 * @return the value returned by {@link RealVectorChangingVisitor#end()}
1042 * at the end of the walk
1043 * @throws NumberIsTooSmallException if {@code end < start}.
1044 * @throws OutOfRangeException if the indices are not valid.
1045 * @since 3.1
1046 */
1047 public double walkInOptimizedOrder(final RealVectorChangingVisitor visitor,
1048 final int start, final int end)
1049 throws NumberIsTooSmallException, OutOfRangeException {
1050 return walkInDefaultOrder(visitor, start, end);
1051 }
1052
1053 /** An entry in the vector. */
1054 protected class Entry {
1055 /** Index of this entry. */
1056 private int index;
1057
1058 /** Simple constructor. */
1059 public Entry() {
1060 setIndex(0);
1061 }
1062
1063 /**
1064 * Get the value of the entry.
1065 *
1066 * @return the value of the entry.
1067 */
1068 public double getValue() {
1069 return getEntry(getIndex());
1070 }
1071
1072 /**
1073 * Set the value of the entry.
1074 *
1075 * @param value New value for the entry.
1076 */
1077 public void setValue(double value) {
1078 setEntry(getIndex(), value);
1079 }
1080
1081 /**
1082 * Get the index of the entry.
1083 *
1084 * @return the index of the entry.
1085 */
1086 public int getIndex() {
1087 return index;
1088 }
1089
1090 /**
1091 * Set the index of the entry.
1092 *
1093 * @param index New index for the entry.
1094 */
1095 public void setIndex(int index) {
1096 this.index = index;
1097 }
1098 }
1099
1100 /**
1101 * <p>
1102 * Test for the equality of two real vectors. If all coordinates of two real
1103 * vectors are exactly the same, and none are {@code NaN}, the two real
1104 * vectors are considered to be equal. {@code NaN} coordinates are
1105 * considered to affect globally the vector and be equals to each other -
1106 * i.e, if either (or all) coordinates of the real vector are equal to
1107 * {@code NaN}, the real vector is equal to a vector with all {@code NaN}
1108 * coordinates.
1109 * </p>
1110 * <p>
1111 * This method <em>must</em> be overriden by concrete subclasses of
1112 * {@link RealVector} (the current implementation throws an exception).
1113 * </p>
1114 *
1115 * @param other Object to test for equality.
1116 * @return {@code true} if two vector objects are equal, {@code false} if
1117 * {@code other} is null, not an instance of {@code RealVector}, or
1118 * not equal to this {@code RealVector} instance.
1119 * @throws MathUnsupportedOperationException if this method is not
1120 * overridden.
1121 */
1122 @Override
1123 public boolean equals(Object other)
1124 throws MathUnsupportedOperationException {
1125 throw new MathUnsupportedOperationException();
1126 }
1127
1128 /**
1129 * {@inheritDoc}. This method <em>must</em> be overriden by concrete
1130 * subclasses of {@link RealVector} (current implementation throws an
1131 * exception).
1132 *
1133 * @throws MathUnsupportedOperationException if this method is not
1134 * overridden.
1135 */
1136 @Override
1137 public int hashCode() throws MathUnsupportedOperationException {
1138 throw new MathUnsupportedOperationException();
1139 }
1140
1141 /**
1142 * This class should rarely be used, but is here to provide
1143 * a default implementation of sparseIterator(), which is implemented
1144 * by walking over the entries, skipping those whose values are the default one.
1145 *
1146 * Concrete subclasses which are SparseVector implementations should
1147 * make their own sparse iterator, rather than using this one.
1148 *
1149 * This implementation might be useful for ArrayRealVector, when expensive
1150 * operations which preserve the default value are to be done on the entries,
1151 * and the fraction of non-default values is small (i.e. someone took a
1152 * SparseVector, and passed it into the copy-constructor of ArrayRealVector)
1153 *
1154 * @deprecated As of 3.1, this class is deprecated, see
1155 * <a href="https://issues.apache.org/jira/browse/MATH-875">JIRA MATH-875</a>.
1156 * This class will be completely removed in 4.0.
1157
1158 */
1159 @Deprecated
1160 protected class SparseEntryIterator implements Iterator<Entry> {
1161 /** Dimension of the vector. */
1162 private final int dim;
1163 /** Last entry returned by {@link #next()}. */
1164 private Entry current;
1165 /** Next entry for {@link #next()} to return. */
1166 private Entry next;
1167
1168 /** Simple constructor. */
1169 protected SparseEntryIterator() {
1170 dim = getDimension();
1171 current = new Entry();
1172 next = new Entry();
1173 if (next.getValue() == 0) {
1174 advance(next);
1175 }
1176 }
1177
1178 /**
1179 * Advance an entry up to the next nonzero one.
1180 *
1181 * @param e entry to advance.
1182 */
1183 protected void advance(Entry e) {
1184 if (e == null) {
1185 return;
1186 }
1187 do {
1188 e.setIndex(e.getIndex() + 1);
1189 } while (e.getIndex() < dim && e.getValue() == 0);
1190 if (e.getIndex() >= dim) {
1191 e.setIndex(-1);
1192 }
1193 }
1194
1195 /** {@inheritDoc} */
1196 public boolean hasNext() {
1197 return next.getIndex() >= 0;
1198 }
1199
1200 /** {@inheritDoc} */
1201 public Entry next() {
1202 int index = next.getIndex();
1203 if (index < 0) {
1204 throw new NoSuchElementException();
1205 }
1206 current.setIndex(index);
1207 advance(next);
1208 return current;
1209 }
1210
1211 /**
1212 * {@inheritDoc}
1213 *
1214 * @throws MathUnsupportedOperationException in all circumstances.
1215 */
1216 public void remove() throws MathUnsupportedOperationException {
1217 throw new MathUnsupportedOperationException();
1218 }
1219 }
1220
1221 /**
1222 * Returns an unmodifiable view of the specified vector.
1223 * The returned vector has read-only access. An attempt to modify it will
1224 * result in a {@link MathUnsupportedOperationException}. However, the
1225 * returned vector is <em>not</em> immutable, since any modification of
1226 * {@code v} will also change the returned view.
1227 * For example, in the following piece of code
1228 * <pre>
1229 * RealVector v = new ArrayRealVector(2);
1230 * RealVector w = RealVector.unmodifiableRealVector(v);
1231 * v.setEntry(0, 1.2);
1232 * v.setEntry(1, -3.4);
1233 * </pre>
1234 * the changes will be seen in the {@code w} view of {@code v}.
1235 *
1236 * @param v Vector for which an unmodifiable view is to be returned.
1237 * @return an unmodifiable view of {@code v}.
1238 */
1239 public static RealVector unmodifiableRealVector(final RealVector v) {
1240 /**
1241 * This anonymous class is an implementation of {@link RealVector}
1242 * with read-only access.
1243 * It wraps any {@link RealVector}, and exposes all methods which
1244 * do not modify it. Invoking methods which should normally result
1245 * in the modification of the calling {@link RealVector} results in
1246 * a {@link MathUnsupportedOperationException}. It should be noted
1247 * that {@link UnmodifiableVector} is <em>not</em> immutable.
1248 */
1249 return new RealVector() {
1250 /**
1251 * {@inheritDoc}
1252 *
1253 * @throws MathUnsupportedOperationException in all circumstances.
1254 */
1255 @Override
1256 public RealVector mapToSelf(UnivariateFunction function)
1257 throws MathUnsupportedOperationException {
1258 throw new MathUnsupportedOperationException();
1259 }
1260
1261 /** {@inheritDoc} */
1262 @Override
1263 public RealVector map(UnivariateFunction function) {
1264 return v.map(function);
1265 }
1266
1267 /** {@inheritDoc} */
1268 @Override
1269 public Iterator<Entry> iterator() {
1270 final Iterator<Entry> i = v.iterator();
1271 return new Iterator<Entry>() {
1272 /** The current entry. */
1273 private final UnmodifiableEntry e = new UnmodifiableEntry();
1274
1275 /** {@inheritDoc} */
1276 public boolean hasNext() {
1277 return i.hasNext();
1278 }
1279
1280 /** {@inheritDoc} */
1281 public Entry next() {
1282 e.setIndex(i.next().getIndex());
1283 return e;
1284 }
1285
1286 /**
1287 * {@inheritDoc}
1288 *
1289 * @throws MathUnsupportedOperationException in all
1290 * circumstances.
1291 */
1292 public void remove() throws MathUnsupportedOperationException {
1293 throw new MathUnsupportedOperationException();
1294 }
1295 };
1296 }
1297
1298 /** {@inheritDoc} */
1299 @Override
1300 public Iterator<Entry> sparseIterator() {
1301 final Iterator<Entry> i = v.sparseIterator();
1302
1303 return new Iterator<Entry>() {
1304 /** The current entry. */
1305 private final UnmodifiableEntry e = new UnmodifiableEntry();
1306
1307 /** {@inheritDoc} */
1308 public boolean hasNext() {
1309 return i.hasNext();
1310 }
1311
1312 /** {@inheritDoc} */
1313 public Entry next() {
1314 e.setIndex(i.next().getIndex());
1315 return e;
1316 }
1317
1318 /**
1319 * {@inheritDoc}
1320 *
1321 * @throws MathUnsupportedOperationException in all
1322 * circumstances.
1323 */
1324 public void remove()
1325 throws MathUnsupportedOperationException {
1326 throw new MathUnsupportedOperationException();
1327 }
1328 };
1329 }
1330
1331 /** {@inheritDoc} */
1332 @Override
1333 public RealVector copy() {
1334 return v.copy();
1335 }
1336
1337 /** {@inheritDoc} */
1338 @Override
1339 public RealVector add(RealVector w)
1340 throws DimensionMismatchException {
1341 return v.add(w);
1342 }
1343
1344 /** {@inheritDoc} */
1345 @Override
1346 public RealVector subtract(RealVector w)
1347 throws DimensionMismatchException {
1348 return v.subtract(w);
1349 }
1350
1351 /** {@inheritDoc} */
1352 @Override
1353 public RealVector mapAdd(double d) {
1354 return v.mapAdd(d);
1355 }
1356
1357 /**
1358 * {@inheritDoc}
1359 *
1360 * @throws MathUnsupportedOperationException in all
1361 * circumstances.
1362 */
1363 @Override
1364 public RealVector mapAddToSelf(double d)
1365 throws MathUnsupportedOperationException {
1366 throw new MathUnsupportedOperationException();
1367 }
1368
1369 /** {@inheritDoc} */
1370 @Override
1371 public RealVector mapSubtract(double d) {
1372 return v.mapSubtract(d);
1373 }
1374
1375 /**
1376 * {@inheritDoc}
1377 *
1378 * @throws MathUnsupportedOperationException in all
1379 * circumstances.
1380 */
1381 @Override
1382 public RealVector mapSubtractToSelf(double d)
1383 throws MathUnsupportedOperationException {
1384 throw new MathUnsupportedOperationException();
1385 }
1386
1387 /** {@inheritDoc} */
1388 @Override
1389 public RealVector mapMultiply(double d) {
1390 return v.mapMultiply(d);
1391 }
1392
1393 /**
1394 * {@inheritDoc}
1395 *
1396 * @throws MathUnsupportedOperationException in all
1397 * circumstances.
1398 */
1399 @Override
1400 public RealVector mapMultiplyToSelf(double d)
1401 throws MathUnsupportedOperationException {
1402 throw new MathUnsupportedOperationException();
1403 }
1404
1405 /** {@inheritDoc} */
1406 @Override
1407 public RealVector mapDivide(double d) {
1408 return v.mapDivide(d);
1409 }
1410
1411 /**
1412 * {@inheritDoc}
1413 *
1414 * @throws MathUnsupportedOperationException in all
1415 * circumstances.
1416 */
1417 @Override
1418 public RealVector mapDivideToSelf(double d)
1419 throws MathUnsupportedOperationException {
1420 throw new MathUnsupportedOperationException();
1421 }
1422
1423 /** {@inheritDoc} */
1424 @Override
1425 public RealVector ebeMultiply(RealVector w)
1426 throws DimensionMismatchException {
1427 return v.ebeMultiply(w);
1428 }
1429
1430 /** {@inheritDoc} */
1431 @Override
1432 public RealVector ebeDivide(RealVector w)
1433 throws DimensionMismatchException {
1434 return v.ebeDivide(w);
1435 }
1436
1437 /** {@inheritDoc} */
1438 @Override
1439 public double dotProduct(RealVector w)
1440 throws DimensionMismatchException {
1441 return v.dotProduct(w);
1442 }
1443
1444 /** {@inheritDoc} */
1445 @Override
1446 public double cosine(RealVector w)
1447 throws DimensionMismatchException, MathArithmeticException {
1448 return v.cosine(w);
1449 }
1450
1451 /** {@inheritDoc} */
1452 @Override
1453 public double getNorm() {
1454 return v.getNorm();
1455 }
1456
1457 /** {@inheritDoc} */
1458 @Override
1459 public double getL1Norm() {
1460 return v.getL1Norm();
1461 }
1462
1463 /** {@inheritDoc} */
1464 @Override
1465 public double getLInfNorm() {
1466 return v.getLInfNorm();
1467 }
1468
1469 /** {@inheritDoc} */
1470 @Override
1471 public double getDistance(RealVector w)
1472 throws DimensionMismatchException {
1473 return v.getDistance(w);
1474 }
1475
1476 /** {@inheritDoc} */
1477 @Override
1478 public double getL1Distance(RealVector w)
1479 throws DimensionMismatchException {
1480 return v.getL1Distance(w);
1481 }
1482
1483 /** {@inheritDoc} */
1484 @Override
1485 public double getLInfDistance(RealVector w)
1486 throws DimensionMismatchException {
1487 return v.getLInfDistance(w);
1488 }
1489
1490 /** {@inheritDoc} */
1491 @Override
1492 public RealVector unitVector() throws MathArithmeticException {
1493 return v.unitVector();
1494 }
1495
1496 /**
1497 * {@inheritDoc}
1498 *
1499 * @throws MathUnsupportedOperationException in all
1500 * circumstances.
1501 */
1502 @Override
1503 public void unitize() throws MathUnsupportedOperationException {
1504 throw new MathUnsupportedOperationException();
1505 }
1506
1507 /** {@inheritDoc} */
1508 @Override
1509 public RealMatrix outerProduct(RealVector w) {
1510 return v.outerProduct(w);
1511 }
1512
1513 /** {@inheritDoc} */
1514 @Override
1515 public double getEntry(int index) throws OutOfRangeException {
1516 return v.getEntry(index);
1517 }
1518
1519 /**
1520 * {@inheritDoc}
1521 *
1522 * @throws MathUnsupportedOperationException in all
1523 * circumstances.
1524 */
1525 @Override
1526 public void setEntry(int index, double value)
1527 throws MathUnsupportedOperationException {
1528 throw new MathUnsupportedOperationException();
1529 }
1530
1531 /**
1532 * {@inheritDoc}
1533 *
1534 * @throws MathUnsupportedOperationException in all
1535 * circumstances.
1536 */
1537 @Override
1538 public void addToEntry(int index, double value)
1539 throws MathUnsupportedOperationException {
1540 throw new MathUnsupportedOperationException();
1541 }
1542
1543 /** {@inheritDoc} */
1544 @Override
1545 public int getDimension() {
1546 return v.getDimension();
1547 }
1548
1549 /** {@inheritDoc} */
1550 @Override
1551 public RealVector append(RealVector w) {
1552 return v.append(w);
1553 }
1554
1555 /** {@inheritDoc} */
1556 @Override
1557 public RealVector append(double d) {
1558 return v.append(d);
1559 }
1560
1561 /** {@inheritDoc} */
1562 @Override
1563 public RealVector getSubVector(int index, int n)
1564 throws OutOfRangeException, NotPositiveException {
1565 return v.getSubVector(index, n);
1566 }
1567
1568 /**
1569 * {@inheritDoc}
1570 *
1571 * @throws MathUnsupportedOperationException in all
1572 * circumstances.
1573 */
1574 @Override
1575 public void setSubVector(int index, RealVector w)
1576 throws MathUnsupportedOperationException {
1577 throw new MathUnsupportedOperationException();
1578 }
1579
1580 /**
1581 * {@inheritDoc}
1582 *
1583 * @throws MathUnsupportedOperationException in all
1584 * circumstances.
1585 */
1586 @Override
1587 public void set(double value)
1588 throws MathUnsupportedOperationException {
1589 throw new MathUnsupportedOperationException();
1590 }
1591
1592 /** {@inheritDoc} */
1593 @Override
1594 public double[] toArray() {
1595 return v.toArray();
1596 }
1597
1598 /** {@inheritDoc} */
1599 @Override
1600 public boolean isNaN() {
1601 return v.isNaN();
1602 }
1603
1604 /** {@inheritDoc} */
1605 @Override
1606 public boolean isInfinite() {
1607 return v.isInfinite();
1608 }
1609
1610 /** {@inheritDoc} */
1611 @Override
1612 public RealVector combine(double a, double b, RealVector y)
1613 throws DimensionMismatchException {
1614 return v.combine(a, b, y);
1615 }
1616
1617 /**
1618 * {@inheritDoc}
1619 *
1620 * @throws MathUnsupportedOperationException in all
1621 * circumstances.
1622 */
1623 @Override
1624 public RealVector combineToSelf(double a, double b, RealVector y)
1625 throws MathUnsupportedOperationException {
1626 throw new MathUnsupportedOperationException();
1627 }
1628
1629 /** An entry in the vector. */
1630 class UnmodifiableEntry extends Entry {
1631 /** {@inheritDoc} */
1632 @Override
1633 public double getValue() {
1634 return v.getEntry(getIndex());
1635 }
1636
1637 /**
1638 * {@inheritDoc}
1639 *
1640 * @throws MathUnsupportedOperationException in all
1641 * circumstances.
1642 */
1643 @Override
1644 public void setValue(double value)
1645 throws MathUnsupportedOperationException {
1646 throw new MathUnsupportedOperationException();
1647 }
1648 }
1649 };
1650 }
1651 }