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 package org.apache.commons.math.linear;
018
019 /**
020 * Interface defining a real-valued vector with basic algebraic operations.
021 * <p>
022 * vector element indexing is 0-based -- e.g., <code>getEntry(0)</code>
023 * returns the first element of the vector.
024 * </p>
025 * <p>
026 * The various <code>mapXxx</code> and <code>mapXxxToSelf</code> methods operate
027 * on vectors element-wise, i.e. they perform the same operation (adding a scalar,
028 * applying a function ...) on each element in turn. The <code>mapXxx</code>
029 * versions create a new vector to hold the result and do not change the instance.
030 * The <code>mapXxxToSelf</code> versions use the instance itself to store the
031 * results, so the instance is changed by these methods. In both cases, the result
032 * vector is returned by the methods, this allows to use the <i>fluent API</i>
033 * style, like this:
034 * </p>
035 * <pre>
036 * RealVector result = v.mapAddToSelf(3.0).mapTanToSelf().mapSquareToSelf();
037 * </pre>
038 *
039 * @version $Revision: 778058 $ $Date: 2009-05-23 18:57:26 -0400 (Sat, 23 May 2009) $
040 * @since 2.0
041 */
042 public interface RealVector {
043
044 /**
045 * Returns a (deep) copy of this.
046 * @return vector copy
047 */
048 RealVector copy();
049
050 /**
051 * Compute the sum of this and v.
052 * @param v vector to be added
053 * @return this + v
054 * @throws IllegalArgumentException if v is not the same size as this
055 */
056 RealVector add(RealVector v)
057 throws IllegalArgumentException;
058
059 /**
060 * Compute the sum of this and v.
061 * @param v vector to be added
062 * @return this + v
063 * @throws IllegalArgumentException if v is not the same size as this
064 */
065 RealVector add(double[] v)
066 throws IllegalArgumentException;
067
068 /**
069 * Compute this minus v.
070 * @param v vector to be subtracted
071 * @return this + v
072 * @throws IllegalArgumentException if v is not the same size as this
073 */
074 RealVector subtract(RealVector v)
075 throws IllegalArgumentException;
076
077 /**
078 * Compute this minus v.
079 * @param v vector to be subtracted
080 * @return this + v
081 * @throws IllegalArgumentException if v is not the same size as this
082 */
083 RealVector subtract(double[] v)
084 throws IllegalArgumentException;
085
086 /**
087 * Map an addition operation to each entry.
088 * @param d value to be added to each entry
089 * @return this + d
090 */
091 RealVector mapAdd(double d);
092
093 /**
094 * Map an addition operation to each entry.
095 * <p>The instance <strong>is</strong> changed by this method.</p>
096 * @param d value to be added to each entry
097 * @return for convenience, return this
098 */
099 RealVector mapAddToSelf(double d);
100
101 /**
102 * Map a subtraction operation to each entry.
103 * @param d value to be subtracted to each entry
104 * @return this - d
105 */
106 RealVector mapSubtract(double d);
107
108 /**
109 * Map a subtraction operation to each entry.
110 * <p>The instance <strong>is</strong> changed by this method.</p>
111 * @param d value to be subtracted to each entry
112 * @return for convenience, return this
113 */
114 RealVector mapSubtractToSelf(double d);
115
116 /**
117 * Map a multiplication operation to each entry.
118 * @param d value to multiply all entries by
119 * @return this * d
120 */
121 RealVector mapMultiply(double d);
122
123 /**
124 * Map a multiplication operation to each entry.
125 * <p>The instance <strong>is</strong> changed by this method.</p>
126 * @param d value to multiply all entries by
127 * @return for convenience, return this
128 */
129 RealVector mapMultiplyToSelf(double d);
130
131 /**
132 * Map a division operation to each entry.
133 * @param d value to divide all entries by
134 * @return this / d
135 */
136 RealVector mapDivide(double d);
137
138 /**
139 * Map a division operation to each entry.
140 * <p>The instance <strong>is</strong> changed by this method.</p>
141 * @param d value to divide all entries by
142 * @return for convenience, return this
143 */
144 RealVector mapDivideToSelf(double d);
145
146 /**
147 * Map a power operation to each entry.
148 * @param d value to raise all entries to
149 * @return this ^ d
150 */
151 RealVector mapPow(double d);
152
153 /**
154 * Map a power operation to each entry.
155 * <p>The instance <strong>is</strong> changed by this method.</p>
156 * @param d value to raise all entries to
157 * @return for convenience, return this
158 */
159 RealVector mapPowToSelf(double d);
160
161 /**
162 * Map the {@link Math#exp(double)} function to each entry.
163 * @return a vector containing the result of applying the function to each entry
164 */
165 RealVector mapExp();
166
167 /**
168 * Map the {@link Math#exp(double)} function to each entry.
169 * <p>The instance <strong>is</strong> changed by this method.</p>
170 * @return for convenience, return this
171 */
172 RealVector mapExpToSelf();
173
174 /**
175 * Map the {@link Math#expm1(double)} function to each entry.
176 * @return a vector containing the result of applying the function to each entry
177 */
178 RealVector mapExpm1();
179
180 /**
181 * Map the {@link Math#expm1(double)} function to each entry.
182 * <p>The instance <strong>is</strong> changed by this method.</p>
183 * @return for convenience, return this
184 */
185 RealVector mapExpm1ToSelf();
186
187 /**
188 * Map the {@link Math#log(double)} function to each entry.
189 * @return a vector containing the result of applying the function to each entry
190 */
191 RealVector mapLog();
192
193 /**
194 * Map the {@link Math#log(double)} function to each entry.
195 * <p>The instance <strong>is</strong> changed by this method.</p>
196 * @return for convenience, return this
197 */
198 RealVector mapLogToSelf();
199
200 /**
201 * Map the {@link Math#log10(double)} function to each entry.
202 * @return a vector containing the result of applying the function to each entry
203 */
204 RealVector mapLog10();
205
206 /**
207 * Map the {@link Math#log10(double)} function to each entry.
208 * <p>The instance <strong>is</strong> changed by this method.</p>
209 * @return for convenience, return this
210 */
211 RealVector mapLog10ToSelf();
212
213 /**
214 * Map the {@link Math#log1p(double)} function to each entry.
215 * @return a vector containing the result of applying the function to each entry
216 */
217 RealVector mapLog1p();
218
219 /**
220 * Map the {@link Math#log1p(double)} function to each entry.
221 * <p>The instance <strong>is</strong> changed by this method.</p>
222 * @return for convenience, return this
223 */
224 RealVector mapLog1pToSelf();
225
226 /**
227 * Map the {@link Math#cosh(double)} function to each entry.
228 * @return a vector containing the result of applying the function to each entry
229 */
230 RealVector mapCosh();
231
232 /**
233 * Map the {@link Math#cosh(double)} function to each entry.
234 * <p>The instance <strong>is</strong> changed by this method.</p>
235 * @return for convenience, return this
236 */
237 RealVector mapCoshToSelf();
238
239 /**
240 * Map the {@link Math#sinh(double)} function to each entry.
241 * @return a vector containing the result of applying the function to each entry
242 */
243 RealVector mapSinh();
244
245 /**
246 * Map the {@link Math#sinh(double)} function to each entry.
247 * <p>The instance <strong>is</strong> changed by this method.</p>
248 * @return for convenience, return this
249 */
250 RealVector mapSinhToSelf();
251
252 /**
253 * Map the {@link Math#tanh(double)} function to each entry.
254 * @return a vector containing the result of applying the function to each entry
255 */
256 RealVector mapTanh();
257
258 /**
259 * Map the {@link Math#tanh(double)} function to each entry.
260 * <p>The instance <strong>is</strong> changed by this method.</p>
261 * @return for convenience, return this
262 */
263 RealVector mapTanhToSelf();
264
265 /**
266 * Map the {@link Math#cos(double)} function to each entry.
267 * @return a vector containing the result of applying the function to each entry
268 */
269 RealVector mapCos();
270
271 /**
272 * Map the {@link Math#cos(double)} function to each entry.
273 * <p>The instance <strong>is</strong> changed by this method.</p>
274 * @return for convenience, return this
275 */
276 RealVector mapCosToSelf();
277
278 /**
279 * Map the {@link Math#sin(double)} function to each entry.
280 * @return a vector containing the result of applying the function to each entry
281 */
282 RealVector mapSin();
283
284 /**
285 * Map the {@link Math#sin(double)} function to each entry.
286 * <p>The instance <strong>is</strong> changed by this method.</p>
287 * @return for convenience, return this
288 */
289 RealVector mapSinToSelf();
290
291 /**
292 * Map the {@link Math#tan(double)} function to each entry.
293 * @return a vector containing the result of applying the function to each entry
294 */
295 RealVector mapTan();
296
297 /**
298 * Map the {@link Math#tan(double)} function to each entry.
299 * <p>The instance <strong>is</strong> changed by this method.</p>
300 * @return for convenience, return this
301 */
302 RealVector mapTanToSelf();
303
304 /**
305 * Map the {@link Math#acos(double)} function to each entry.
306 * @return a vector containing the result of applying the function to each entry
307 */
308 RealVector mapAcos();
309
310 /**
311 * Map the {@link Math#acos(double)} function to each entry.
312 * <p>The instance <strong>is</strong> changed by this method.</p>
313 * @return for convenience, return this
314 */
315 RealVector mapAcosToSelf();
316
317 /**
318 * Map the {@link Math#asin(double)} function to each entry.
319 * @return a vector containing the result of applying the function to each entry
320 */
321 RealVector mapAsin();
322
323 /**
324 * Map the {@link Math#asin(double)} function to each entry.
325 * <p>The instance <strong>is</strong> changed by this method.</p>
326 * @return for convenience, return this
327 */
328 RealVector mapAsinToSelf();
329
330 /**
331 * Map the {@link Math#atan(double)} function to each entry.
332 * @return a vector containing the result of applying the function to each entry
333 */
334 RealVector mapAtan();
335
336 /**
337 * Map the {@link Math#atan(double)} function to each entry.
338 * <p>The instance <strong>is</strong> changed by this method.</p>
339 * @return for convenience, return this
340 */
341 RealVector mapAtanToSelf();
342
343 /**
344 * Map the 1/x function to each entry.
345 * @return a vector containing the result of applying the function to each entry
346 */
347 RealVector mapInv();
348
349 /**
350 * Map the 1/x function to each entry.
351 * <p>The instance <strong>is</strong> changed by this method.</p>
352 * @return for convenience, return this
353 */
354 RealVector mapInvToSelf();
355
356 /**
357 * Map the {@link Math#abs(double)} function to each entry.
358 * @return a vector containing the result of applying the function to each entry
359 */
360 RealVector mapAbs();
361
362 /**
363 * Map the {@link Math#abs(double)} function to each entry.
364 * <p>The instance <strong>is</strong> changed by this method.</p>
365 * @return for convenience, return this
366 */
367 RealVector mapAbsToSelf();
368
369 /**
370 * Map the {@link Math#sqrt(double)} function to each entry.
371 * @return a vector containing the result of applying the function to each entry
372 */
373 RealVector mapSqrt();
374
375 /**
376 * Map the {@link Math#sqrt(double)} function to each entry.
377 * <p>The instance <strong>is</strong> changed by this method.</p>
378 * @return for convenience, return this
379 */
380 RealVector mapSqrtToSelf();
381
382 /**
383 * Map the {@link Math#cbrt(double)} function to each entry.
384 * @return a vector containing the result of applying the function to each entry
385 */
386 RealVector mapCbrt();
387
388 /**
389 * Map the {@link Math#cbrt(double)} function to each entry.
390 * <p>The instance <strong>is</strong> changed by this method.</p>
391 * @return for convenience, return this
392 */
393 RealVector mapCbrtToSelf();
394
395 /**
396 * Map the {@link Math#ceil(double)} function to each entry.
397 * @return a vector containing the result of applying the function to each entry
398 */
399 RealVector mapCeil();
400
401 /**
402 * Map the {@link Math#ceil(double)} function to each entry.
403 * <p>The instance <strong>is</strong> changed by this method.</p>
404 * @return for convenience, return this
405 */
406 RealVector mapCeilToSelf();
407
408 /**
409 * Map the {@link Math#floor(double)} function to each entry.
410 * @return a vector containing the result of applying the function to each entry
411 */
412 RealVector mapFloor();
413
414 /**
415 * Map the {@link Math#floor(double)} function to each entry.
416 * <p>The instance <strong>is</strong> changed by this method.</p>
417 * @return for convenience, return this
418 */
419 RealVector mapFloorToSelf();
420
421 /**
422 * Map the {@link Math#rint(double)} function to each entry.
423 * @return a vector containing the result of applying the function to each entry
424 */
425 RealVector mapRint();
426
427 /**
428 * Map the {@link Math#rint(double)} function to each entry.
429 * <p>The instance <strong>is</strong> changed by this method.</p>
430 * @return for convenience, return this
431 */
432 RealVector mapRintToSelf();
433
434 /**
435 * Map the {@link Math#signum(double)} function to each entry.
436 * @return a vector containing the result of applying the function to each entry
437 */
438 RealVector mapSignum();
439
440 /**
441 * Map the {@link Math#signum(double)} function to each entry.
442 * <p>The instance <strong>is</strong> changed by this method.</p>
443 * @return for convenience, return this
444 */
445 RealVector mapSignumToSelf();
446
447 /**
448 * Map the {@link Math#ulp(double)} function to each entry.
449 * @return a vector containing the result of applying the function to each entry
450 */
451 RealVector mapUlp();
452
453 /**
454 * Map the {@link Math#ulp(double)} function to each entry.
455 * <p>The instance <strong>is</strong> changed by this method.</p>
456 * @return for convenience, return this
457 */
458 RealVector mapUlpToSelf();
459
460 /**
461 * Element-by-element multiplication.
462 * @param v vector by which instance elements must be multiplied
463 * @return a vector containing this[i] * v[i] for all i
464 * @throws IllegalArgumentException if v is not the same size as this
465 */
466 public RealVector ebeMultiply(RealVector v)
467 throws IllegalArgumentException;
468
469 /**
470 * Element-by-element multiplication.
471 * @param v vector by which instance elements must be multiplied
472 * @return a vector containing this[i] * v[i] for all i
473 * @throws IllegalArgumentException if v is not the same size as this
474 */
475 public RealVector ebeMultiply(double[] v)
476 throws IllegalArgumentException;
477
478 /**
479 * Element-by-element division.
480 * @param v vector by which instance elements must be divided
481 * @return a vector containing this[i] / v[i] for all i
482 * @throws IllegalArgumentException if v is not the same size as this
483 */
484 public RealVector ebeDivide(RealVector v)
485 throws IllegalArgumentException;
486
487 /**
488 * Element-by-element division.
489 * @param v vector by which instance elements must be divided
490 * @return a vector containing this[i] / v[i] for all i
491 * @throws IllegalArgumentException if v is not the same size as this
492 */
493 public RealVector ebeDivide(double[] v)
494 throws IllegalArgumentException;
495
496 /**
497 * Returns vector entries as a double array.
498 * @return double array of entries
499 */
500 double[] getData();
501
502 /**
503 * Compute the dot product.
504 * @param v vector with which dot product should be computed
505 * @return the scalar dot product between instance and v
506 * @exception IllegalArgumentException if v is not the same size as this
507 */
508 double dotProduct(RealVector v)
509 throws IllegalArgumentException;
510
511 /**
512 * Compute the dot product.
513 * @param v vector with which dot product should be computed
514 * @return the scalar dot product between instance and v
515 * @exception IllegalArgumentException if v is not the same size as this
516 */
517 double dotProduct(double[] v)
518 throws IllegalArgumentException;
519
520 /**
521 * Returns the L<sub>2</sub> norm of the vector.
522 * <p>The L<sub>2</sub> norm is the root of the sum of
523 * the squared elements.</p>
524 * @return norm
525 * @see #getL1Norm()
526 * @see #getLInfNorm()
527 * @see #getDistance(RealVector)
528 */
529 double getNorm();
530
531 /**
532 * Returns the L<sub>1</sub> norm of the vector.
533 * <p>The L<sub>1</sub> norm is the sum of the absolute
534 * values of elements.</p>
535 * @return norm
536 * @see #getNorm()
537 * @see #getLInfNorm()
538 * @see #getL1Distance(RealVector)
539 */
540 double getL1Norm();
541
542 /**
543 * Returns the L<sub>∞</sub> norm of the vector.
544 * <p>The L<sub>∞</sub> norm is the max of the absolute
545 * values of elements.</p>
546 * @return norm
547 * @see #getNorm()
548 * @see #getL1Norm()
549 * @see #getLInfDistance(RealVector)
550 */
551 double getLInfNorm();
552
553 /**
554 * Distance between two vectors.
555 * <p>This method computes the distance consistent with the
556 * L<sub>2</sub> norm, i.e. the square root of the sum of
557 * elements differences, or euclidian distance.</p>
558 * @param v vector to which distance is requested
559 * @return distance between two vectors.
560 * @exception IllegalArgumentException if v is not the same size as this
561 * @see #getL1Distance(RealVector)
562 * @see #getLInfDistance(RealVector)
563 * @see #getNorm()
564 */
565 double getDistance(RealVector v)
566 throws IllegalArgumentException;
567
568 /**
569 * Distance between two vectors.
570 * <p>This method computes the distance consistent with the
571 * L<sub>2</sub> norm, i.e. the square root of the sum of
572 * elements differences, or euclidian distance.</p>
573 * @param v vector to which distance is requested
574 * @return distance between two vectors.
575 * @exception IllegalArgumentException if v is not the same size as this
576 * @see #getL1Distance(double[])
577 * @see #getLInfDistance(double[])
578 * @see #getNorm()
579 */
580 double getDistance(double[] v)
581 throws IllegalArgumentException;
582
583 /**
584 * Distance between two vectors.
585 * <p>This method computes the distance consistent with
586 * L<sub>1</sub> norm, i.e. the sum of the absolute values of
587 * elements differences.</p>
588 * @param v vector to which distance is requested
589 * @return distance between two vectors.
590 * @exception IllegalArgumentException if v is not the same size as this
591 * @see #getDistance(RealVector)
592 * @see #getLInfDistance(RealVector)
593 * @see #getL1Norm()
594 */
595 double getL1Distance(RealVector v)
596 throws IllegalArgumentException;
597
598 /**
599 * Distance between two vectors.
600 * <p>This method computes the distance consistent with
601 * L<sub>1</sub> norm, i.e. the sum of the absolute values of
602 * elements differences.</p>
603 * @param v vector to which distance is requested
604 * @return distance between two vectors.
605 * @exception IllegalArgumentException if v is not the same size as this
606 * @see #getDistance(double[])
607 * @see #getLInfDistance(double[])
608 * @see #getL1Norm()
609 */
610 double getL1Distance(double[] v)
611 throws IllegalArgumentException;
612
613 /**
614 * Distance between two vectors.
615 * <p>This method computes the distance consistent with
616 * L<sub>∞</sub> norm, i.e. the max of the absolute values of
617 * elements differences.</p>
618 * @param v vector to which distance is requested
619 * @return distance between two vectors.
620 * @exception IllegalArgumentException if v is not the same size as this
621 * @see #getDistance(RealVector)
622 * @see #getL1Distance(RealVector)
623 * @see #getLInfNorm()
624 */
625 double getLInfDistance(RealVector v)
626 throws IllegalArgumentException;
627
628 /**
629 * Distance between two vectors.
630 * <p>This method computes the distance consistent with
631 * L<sub>∞</sub> norm, i.e. the max of the absolute values of
632 * elements differences.</p>
633 * @param v vector to which distance is requested
634 * @return distance between two vectors.
635 * @exception IllegalArgumentException if v is not the same size as this
636 * @see #getDistance(double[])
637 * @see #getL1Distance(double[])
638 * @see #getLInfNorm()
639 */
640 double getLInfDistance(double[] v)
641 throws IllegalArgumentException;
642
643 /** Creates a unit vector pointing in the direction of this vector.
644 * <p>The instance is not changed by this method.</p>
645 * @return a unit vector pointing in direction of this vector
646 * @exception ArithmeticException if the norm is null
647 */
648 RealVector unitVector();
649
650 /** Converts this vector into a unit vector.
651 * <p>The instance itself is changed by this method.</p>
652 * @exception ArithmeticException if the norm is null
653 */
654 void unitize();
655
656 /** Find the orthogonal projection of this vector onto another vector.
657 * @param v vector onto which instance must be projected
658 * @return projection of the instance onto v
659 * @throws IllegalArgumentException if v is not the same size as this
660 */
661 RealVector projection(RealVector v)
662 throws IllegalArgumentException;
663
664 /** Find the orthogonal projection of this vector onto another vector.
665 * @param v vector onto which instance must be projected
666 * @return projection of the instance onto v
667 * @throws IllegalArgumentException if v is not the same size as this
668 */
669 RealVector projection(double[] v)
670 throws IllegalArgumentException;
671
672 /**
673 * Compute the outer product.
674 * @param v vector with which outer product should be computed
675 * @return the square matrix outer product between instance and v
676 * @exception IllegalArgumentException if v is not the same size as this
677 */
678 RealMatrix outerProduct(RealVector v)
679 throws IllegalArgumentException;
680
681 /**
682 * Compute the outer product.
683 * @param v vector with which outer product should be computed
684 * @return the square matrix outer product between instance and v
685 * @exception IllegalArgumentException if v is not the same size as this
686 */
687 RealMatrix outerProduct(double[] v)
688 throws IllegalArgumentException;
689
690 /**
691 * Returns the entry in the specified index.
692 * <p>
693 * The index start at 0 and must be lesser than the size,
694 * otherwise a {@link MatrixIndexException} is thrown.
695 * </p>
696 * @param index index location of entry to be fetched
697 * @return vector entry at index
698 * @throws MatrixIndexException if the index is not valid
699 * @see #setEntry(int, double)
700 */
701 double getEntry(int index)
702 throws MatrixIndexException;
703
704 /**
705 * Set a single element.
706 * @param index element index.
707 * @param value new value for the element.
708 * @exception MatrixIndexException if the index is
709 * inconsistent with vector size
710 * @see #getEntry(int)
711 */
712 void setEntry(int index, double value)
713 throws MatrixIndexException;
714
715 /**
716 * Returns the size of the vector.
717 * @return size
718 */
719 int getDimension();
720
721 /**
722 * Construct a vector by appending a vector to this vector.
723 * @param v vector to append to this one.
724 * @return a new vector
725 */
726 RealVector append(RealVector v);
727
728 /**
729 * Construct a vector by appending a double to this vector.
730 * @param d double to append.
731 * @return a new vector
732 */
733 RealVector append(double d);
734
735 /**
736 * Construct a vector by appending a double array to this vector.
737 * @param a double array to append.
738 * @return a new vector
739 */
740 RealVector append(double[] a);
741
742 /**
743 * Get a subvector from consecutive elements.
744 * @param index index of first element.
745 * @param n number of elements to be retrieved.
746 * @return a vector containing n elements.
747 * @exception MatrixIndexException if the index is
748 * inconsistent with vector size
749 */
750 RealVector getSubVector(int index, int n)
751 throws MatrixIndexException;
752
753 /**
754 * Set a set of consecutive elements.
755 * @param index index of first element to be set.
756 * @param v vector containing the values to set.
757 * @exception MatrixIndexException if the index is
758 * inconsistent with vector size
759 * @see #setSubVector(int, double[])
760 */
761 void setSubVector(int index, RealVector v)
762 throws MatrixIndexException;
763
764 /**
765 * Set a set of consecutive elements.
766 * @param index index of first element to be set.
767 * @param v vector containing the values to set.
768 * @exception MatrixIndexException if the index is
769 * inconsistent with vector size
770 * @see #setSubVector(int, RealVector)
771 */
772 void setSubVector(int index, double[] v)
773 throws MatrixIndexException;
774
775 /**
776 * Set all elements to a single value.
777 * @param value single value to set for all elements
778 */
779 void set(double value);
780
781 /**
782 * Convert the vector to a double array.
783 * <p>The array is independent from vector data, it's elements
784 * are copied.</p>
785 * @return array containing a copy of vector elements
786 */
787 double[] toArray();
788
789 /**
790 * Returns true if any coordinate of this vector is NaN; false otherwise
791 * @return true if any coordinate of this vector is NaN; false otherwise
792 */
793 public boolean isNaN();
794
795 /**
796 * Returns true if any coordinate of this vector is infinite and none are NaN;
797 * false otherwise
798 * @return true if any coordinate of this vector is infinite and none are NaN;
799 * false otherwise
800 */
801 public boolean isInfinite();
802
803 }