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 import java.io.Serializable; 020 021 import junit.framework.Test; 022 import junit.framework.TestCase; 023 import junit.framework.TestSuite; 024 025 import org.apache.commons.math.TestUtils; 026 027 /** 028 * Test cases for the {@link OpenMapRealVector} class. 029 * 030 * @version $Revision: 799857 $ $Date: 2009-08-01 09:07:12 -0400 (Sat, 01 Aug 2009) $ 031 */ 032 public class SparseRealVectorTest extends TestCase { 033 034 // 035 protected double[][] ma1 = {{1d, 2d, 3d}, {4d, 5d, 6d}, {7d, 8d, 9d}}; 036 protected double[] vec1 = {1d, 2d, 3d}; 037 protected double[] vec2 = {4d, 5d, 6d}; 038 protected double[] vec3 = {7d, 8d, 9d}; 039 protected double[] vec4 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d}; 040 protected double[] vec_null = {0d, 0d, 0d}; 041 protected Double[] dvec1 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d}; 042 protected double[][] mat1 = {{1d, 2d, 3d}, {4d, 5d, 6d},{ 7d, 8d, 9d}}; 043 044 // tolerances 045 protected double entryTolerance = 10E-16; 046 protected double normTolerance = 10E-14; 047 048 // Testclass to test the RealVector interface 049 // only with enough content to support the test 050 public static class SparseRealVectorTestImpl implements RealVector, Serializable { 051 052 /** Serializable version identifier. */ 053 private static final long serialVersionUID = 4715341047369582908L; 054 055 /** Entries of the vector. */ 056 protected double data[]; 057 058 public SparseRealVectorTestImpl(double[] d) { 059 data = d.clone(); 060 } 061 062 private UnsupportedOperationException unsupported() { 063 return new UnsupportedOperationException("Not supported, unneeded for test purposes"); 064 } 065 066 public RealVector copy() { 067 throw unsupported(); 068 } 069 070 public RealVector add(RealVector v) throws IllegalArgumentException { 071 throw unsupported(); 072 } 073 074 public RealVector add(double[] v) throws IllegalArgumentException { 075 throw unsupported(); 076 } 077 078 public RealVector subtract(RealVector v) throws IllegalArgumentException { 079 throw unsupported(); 080 } 081 082 public RealVector subtract(double[] v) throws IllegalArgumentException { 083 throw unsupported(); 084 } 085 086 public RealVector mapAdd(double d) { 087 throw unsupported(); 088 } 089 090 public RealVector mapAddToSelf(double d) { 091 throw unsupported(); 092 } 093 094 public RealVector mapSubtract(double d) { 095 throw unsupported(); 096 } 097 098 public RealVector mapSubtractToSelf(double d) { 099 throw unsupported(); 100 } 101 102 public RealVector mapMultiply(double d) { 103 double[] out = new double[data.length]; 104 for (int i = 0; i < data.length; i++) { 105 out[i] = data[i] * d; 106 } 107 return new OpenMapRealVector(out); 108 } 109 110 public RealVector mapMultiplyToSelf(double d) { 111 throw unsupported(); 112 } 113 114 public RealVector mapDivide(double d) { 115 throw unsupported(); 116 } 117 118 public RealVector mapDivideToSelf(double d) { 119 throw unsupported(); 120 } 121 122 public RealVector mapPow(double d) { 123 throw unsupported(); 124 } 125 126 public RealVector mapPowToSelf(double d) { 127 throw unsupported(); 128 } 129 130 public RealVector mapExp() { 131 throw unsupported(); 132 } 133 134 public RealVector mapExpToSelf() { 135 throw unsupported(); 136 } 137 138 public RealVector mapExpm1() { 139 throw unsupported(); 140 } 141 142 public RealVector mapExpm1ToSelf() { 143 throw unsupported(); 144 } 145 146 public RealVector mapLog() { 147 throw unsupported(); 148 } 149 150 public RealVector mapLogToSelf() { 151 throw unsupported(); 152 } 153 154 public RealVector mapLog10() { 155 throw unsupported(); 156 } 157 158 public RealVector mapLog10ToSelf() { 159 throw unsupported(); 160 } 161 162 public RealVector mapLog1p() { 163 throw unsupported(); 164 } 165 166 public RealVector mapLog1pToSelf() { 167 throw unsupported(); 168 } 169 170 public RealVector mapCosh() { 171 throw unsupported(); 172 } 173 174 public RealVector mapCoshToSelf() { 175 throw unsupported(); 176 } 177 178 public RealVector mapSinh() { 179 throw unsupported(); 180 } 181 182 public RealVector mapSinhToSelf() { 183 throw unsupported(); 184 } 185 186 public RealVector mapTanh() { 187 throw unsupported(); 188 } 189 190 public RealVector mapTanhToSelf() { 191 throw unsupported(); 192 } 193 194 public RealVector mapCos() { 195 throw unsupported(); 196 } 197 198 public RealVector mapCosToSelf() { 199 throw unsupported(); 200 } 201 202 public RealVector mapSin() { 203 throw unsupported(); 204 } 205 206 public RealVector mapSinToSelf() { 207 throw unsupported(); 208 } 209 210 public RealVector mapTan() { 211 throw unsupported(); 212 } 213 214 public RealVector mapTanToSelf() { 215 throw unsupported(); 216 } 217 218 public RealVector mapAcos() { 219 throw unsupported(); 220 } 221 222 public RealVector mapAcosToSelf() { 223 throw unsupported(); 224 } 225 226 public RealVector mapAsin() { 227 throw unsupported(); 228 } 229 230 public RealVector mapAsinToSelf() { 231 throw unsupported(); 232 } 233 234 public RealVector mapAtan() { 235 throw unsupported(); 236 } 237 238 public RealVector mapAtanToSelf() { 239 throw unsupported(); 240 } 241 242 public RealVector mapInv() { 243 throw unsupported(); 244 } 245 246 public RealVector mapInvToSelf() { 247 throw unsupported(); 248 } 249 250 public RealVector mapAbs() { 251 throw unsupported(); 252 } 253 254 public RealVector mapAbsToSelf() { 255 throw unsupported(); 256 } 257 258 public RealVector mapSqrt() { 259 throw unsupported(); 260 } 261 262 public RealVector mapSqrtToSelf() { 263 throw unsupported(); 264 } 265 266 public RealVector mapCbrt() { 267 throw unsupported(); 268 } 269 270 public RealVector mapCbrtToSelf() { 271 throw unsupported(); 272 } 273 274 public RealVector mapCeil() { 275 throw unsupported(); 276 } 277 278 public RealVector mapCeilToSelf() { 279 throw unsupported(); 280 } 281 282 public RealVector mapFloor() { 283 throw unsupported(); 284 } 285 286 public RealVector mapFloorToSelf() { 287 throw unsupported(); 288 } 289 290 public RealVector mapRint() { 291 throw unsupported(); 292 } 293 294 public RealVector mapRintToSelf() { 295 throw unsupported(); 296 } 297 298 public RealVector mapSignum() { 299 throw unsupported(); 300 } 301 302 public RealVector mapSignumToSelf() { 303 throw unsupported(); 304 } 305 306 public RealVector mapUlp() { 307 throw unsupported(); 308 } 309 310 public RealVector mapUlpToSelf() { 311 throw unsupported(); 312 } 313 314 public RealVector ebeMultiply(RealVector v) throws IllegalArgumentException { 315 throw unsupported(); 316 } 317 318 public RealVector ebeMultiply(double[] v) throws IllegalArgumentException { 319 throw unsupported(); 320 } 321 322 public RealVector ebeDivide(RealVector v) throws IllegalArgumentException { 323 throw unsupported(); 324 } 325 326 public RealVector ebeDivide(double[] v) throws IllegalArgumentException { 327 throw unsupported(); 328 } 329 330 public double[] getData() { 331 return data.clone(); 332 } 333 334 public double dotProduct(RealVector v) throws IllegalArgumentException { 335 double dot = 0; 336 for (int i = 0; i < data.length; i++) { 337 dot += data[i] * v.getEntry(i); 338 } 339 return dot; 340 } 341 342 public double dotProduct(double[] v) throws IllegalArgumentException { 343 double dot = 0; 344 for (int i = 0; i < data.length; i++) { 345 dot += data[i] * v[i]; 346 } 347 return dot; 348 } 349 350 public double getNorm() { 351 throw unsupported(); 352 } 353 354 public double getL1Norm() { 355 throw unsupported(); 356 } 357 358 public double getLInfNorm() { 359 throw unsupported(); 360 } 361 362 public double getDistance(RealVector v) throws IllegalArgumentException { 363 throw unsupported(); 364 } 365 366 public double getDistance(double[] v) throws IllegalArgumentException { 367 throw unsupported(); 368 } 369 370 public double getL1Distance(RealVector v) throws IllegalArgumentException { 371 throw unsupported(); 372 } 373 374 public double getL1Distance(double[] v) throws IllegalArgumentException { 375 throw unsupported(); 376 } 377 378 public double getLInfDistance(RealVector v) throws IllegalArgumentException { 379 throw unsupported(); 380 } 381 382 public double getLInfDistance(double[] v) throws IllegalArgumentException { 383 throw unsupported(); 384 } 385 386 public RealVector unitVector() { 387 throw unsupported(); 388 } 389 390 public void unitize() { 391 throw unsupported(); 392 } 393 394 public RealVector projection(RealVector v) throws IllegalArgumentException { 395 throw unsupported(); 396 } 397 398 public RealVector projection(double[] v) throws IllegalArgumentException { 399 throw unsupported(); 400 } 401 402 public RealMatrix outerProduct(RealVector v) throws IllegalArgumentException { 403 throw unsupported(); 404 } 405 406 public RealMatrix outerProduct(double[] v) throws IllegalArgumentException { 407 throw unsupported(); 408 } 409 410 public double getEntry(int index) throws MatrixIndexException { 411 return data[index]; 412 } 413 414 public int getDimension() { 415 return data.length; 416 } 417 418 public RealVector append(RealVector v) { 419 throw unsupported(); 420 } 421 422 public RealVector append(double d) { 423 throw unsupported(); 424 } 425 426 public RealVector append(double[] a) { 427 throw unsupported(); 428 } 429 430 public RealVector getSubVector(int index, int n) throws MatrixIndexException { 431 throw unsupported(); 432 } 433 434 public void setEntry(int index, double value) throws MatrixIndexException { 435 throw unsupported(); 436 } 437 438 public void setSubVector(int index, RealVector v) throws MatrixIndexException { 439 throw unsupported(); 440 } 441 442 public void setSubVector(int index, double[] v) throws MatrixIndexException { 443 throw unsupported(); 444 } 445 446 public void set(double value) { 447 throw unsupported(); 448 } 449 450 public double[] toArray() { 451 throw unsupported(); 452 } 453 454 public boolean isNaN() { 455 throw unsupported(); 456 } 457 458 public boolean isInfinite() { 459 throw unsupported(); 460 } 461 462 } 463 464 public static Test suite() { 465 TestSuite suite = new TestSuite(SparseRealVectorTest.class); 466 suite.setName("SparseRealVector Tests"); 467 return suite; 468 } 469 470 public void testConstructors() { 471 472 OpenMapRealVector v0 = new OpenMapRealVector(); 473 assertEquals("testData len", 0, v0.getDimension()); 474 475 OpenMapRealVector v1 = new OpenMapRealVector(7); 476 assertEquals("testData len", 7, v1.getDimension()); 477 assertEquals("testData is 0.0 ", 0.0, v1.getEntry(6)); 478 479 OpenMapRealVector v3 = new OpenMapRealVector(vec1); 480 assertEquals("testData len", 3, v3.getDimension()); 481 assertEquals("testData is 2.0 ", 2.0, v3.getEntry(1)); 482 483 //SparseRealVector v4 = new SparseRealVector(vec4, 3, 2); 484 //assertEquals("testData len", 2, v4.getDimension()); 485 //assertEquals("testData is 4.0 ", 4.0, v4.getEntry(0)); 486 //try { 487 // new SparseRealVector(vec4, 8, 3); 488 // fail("IllegalArgumentException expected"); 489 //} catch (IllegalArgumentException ex) { 490 // expected behavior 491 //} catch (Exception e) { 492 // fail("wrong exception caught"); 493 //} 494 495 RealVector v5_i = new OpenMapRealVector(dvec1); 496 assertEquals("testData len", 9, v5_i.getDimension()); 497 assertEquals("testData is 9.0 ", 9.0, v5_i.getEntry(8)); 498 499 OpenMapRealVector v5 = new OpenMapRealVector(dvec1); 500 assertEquals("testData len", 9, v5.getDimension()); 501 assertEquals("testData is 9.0 ", 9.0, v5.getEntry(8)); 502 503 OpenMapRealVector v7 = new OpenMapRealVector(v1); 504 assertEquals("testData len", 7, v7.getDimension()); 505 assertEquals("testData is 0.0 ", 0.0, v7.getEntry(6)); 506 507 SparseRealVectorTestImpl v7_i = new SparseRealVectorTestImpl(vec1); 508 509 OpenMapRealVector v7_2 = new OpenMapRealVector(v7_i); 510 assertEquals("testData len", 3, v7_2.getDimension()); 511 assertEquals("testData is 0.0 ", 2.0d, v7_2.getEntry(1)); 512 513 OpenMapRealVector v8 = new OpenMapRealVector(v1); 514 assertEquals("testData len", 7, v8.getDimension()); 515 assertEquals("testData is 0.0 ", 0.0, v8.getEntry(6)); 516 517 } 518 519 public void testDataInOut() { 520 521 OpenMapRealVector v1 = new OpenMapRealVector(vec1); 522 OpenMapRealVector v2 = new OpenMapRealVector(vec2); 523 OpenMapRealVector v4 = new OpenMapRealVector(vec4); 524 SparseRealVectorTestImpl v2_t = new SparseRealVectorTestImpl(vec2); 525 526 RealVector v_append_1 = v1.append(v2); 527 assertEquals("testData len", 6, v_append_1.getDimension()); 528 assertEquals("testData is 4.0 ", 4.0, v_append_1.getEntry(3)); 529 530 RealVector v_append_2 = v1.append(2.0); 531 assertEquals("testData len", 4, v_append_2.getDimension()); 532 assertEquals("testData is 2.0 ", 2.0, v_append_2.getEntry(3)); 533 534 RealVector v_append_3 = v1.append(vec2); 535 assertEquals("testData len", 6, v_append_3.getDimension()); 536 assertEquals("testData is ", 4.0, v_append_3.getEntry(3)); 537 538 RealVector v_append_4 = v1.append(v2_t); 539 assertEquals("testData len", 6, v_append_4.getDimension()); 540 assertEquals("testData is 4.0 ", 4.0, v_append_4.getEntry(3)); 541 542 RealVector vout5 = v4.getSubVector(3, 3); 543 assertEquals("testData len", 3, vout5.getDimension()); 544 assertEquals("testData is 4.0 ", 5.0, vout5.getEntry(1)); 545 try { 546 v4.getSubVector(3, 7); 547 fail("MatrixIndexException expected"); 548 } catch (MatrixIndexException ex) { 549 // expected behavior 550 } catch (Exception e) { 551 fail("wrong exception caught"); 552 } 553 554 OpenMapRealVector v_set1 = (OpenMapRealVector) v1.copy(); 555 v_set1.setEntry(1, 11.0); 556 assertEquals("testData is 11.0 ", 11.0, v_set1.getEntry(1)); 557 try { 558 v_set1.setEntry(3, 11.0); 559 fail("MatrixIndexException expected"); 560 } catch (MatrixIndexException ex) { 561 // expected behavior 562 } catch (Exception e) { 563 fail("wrong exception caught"); 564 } 565 566 OpenMapRealVector v_set2 = (OpenMapRealVector) v4.copy(); 567 v_set2.setSubVector(3, v1); 568 assertEquals("testData is 1.0 ", 1.0, v_set2.getEntry(3)); 569 assertEquals("testData is 7.0 ", 7.0, v_set2.getEntry(6)); 570 try { 571 v_set2.setSubVector(7, v1); 572 fail("MatrixIndexException expected"); 573 } catch (MatrixIndexException ex) { 574 // expected behavior 575 } catch (Exception e) { 576 fail("wrong exception caught"); 577 } 578 579 OpenMapRealVector v_set3 = (OpenMapRealVector) v1.copy(); 580 v_set3.set(13.0); 581 assertEquals("testData is 13.0 ", 13.0, v_set3.getEntry(2)); 582 583 try { 584 v_set3.getEntry(23); 585 fail("MatrixIndexException expected"); 586 } catch (MatrixIndexException ex) { 587 // expected behavior 588 } catch (Exception e) { 589 fail("wrong exception caught"); 590 } 591 592 OpenMapRealVector v_set4 = (OpenMapRealVector) v4.copy(); 593 v_set4.setSubVector(3, v2_t); 594 assertEquals("testData is 1.0 ", 4.0, v_set4.getEntry(3)); 595 assertEquals("testData is 7.0 ", 7.0, v_set4.getEntry(6)); 596 try { 597 v_set4.setSubVector(7, v2_t); 598 fail("MatrixIndexException expected"); 599 } catch (MatrixIndexException ex) { 600 // expected behavior 601 } catch (Exception e) { 602 fail("wrong exception caught"); 603 } 604 605 606 } 607 608 public void testMapFunctions() { 609 OpenMapRealVector v1 = new OpenMapRealVector(vec1); 610 611 //octave = v1 .+ 2.0 612 RealVector v_mapAdd = v1.mapAdd(2.0d); 613 double[] result_mapAdd = {3d, 4d, 5d}; 614 assertClose("compare vectors" ,result_mapAdd,v_mapAdd.getData(),normTolerance); 615 616 //octave = v1 .+ 2.0 617 RealVector v_mapAddToSelf = v1.copy(); 618 v_mapAddToSelf.mapAddToSelf(2.0d); 619 double[] result_mapAddToSelf = {3d, 4d, 5d}; 620 assertClose("compare vectors" ,result_mapAddToSelf,v_mapAddToSelf.getData(),normTolerance); 621 622 //octave = v1 .- 2.0 623 RealVector v_mapSubtract = v1.mapSubtract(2.0d); 624 double[] result_mapSubtract = {-1d, 0d, 1d}; 625 assertClose("compare vectors" ,result_mapSubtract,v_mapSubtract.getData(),normTolerance); 626 627 //octave = v1 .- 2.0 628 RealVector v_mapSubtractToSelf = v1.copy(); 629 v_mapSubtractToSelf.mapSubtractToSelf(2.0d); 630 double[] result_mapSubtractToSelf = {-1d, 0d, 1d}; 631 assertClose("compare vectors" ,result_mapSubtractToSelf,v_mapSubtractToSelf.getData(),normTolerance); 632 633 //octave = v1 .* 2.0 634 RealVector v_mapMultiply = v1.mapMultiply(2.0d); 635 double[] result_mapMultiply = {2d, 4d, 6d}; 636 assertClose("compare vectors" ,result_mapMultiply,v_mapMultiply.getData(),normTolerance); 637 638 //octave = v1 .* 2.0 639 RealVector v_mapMultiplyToSelf = v1.copy(); 640 v_mapMultiplyToSelf.mapMultiplyToSelf(2.0d); 641 double[] result_mapMultiplyToSelf = {2d, 4d, 6d}; 642 assertClose("compare vectors" ,result_mapMultiplyToSelf,v_mapMultiplyToSelf.getData(),normTolerance); 643 644 //octave = v1 ./ 2.0 645 RealVector v_mapDivide = v1.mapDivide(2.0d); 646 double[] result_mapDivide = {.5d, 1d, 1.5d}; 647 assertClose("compare vectors" ,result_mapDivide,v_mapDivide.getData(),normTolerance); 648 649 //octave = v1 ./ 2.0 650 RealVector v_mapDivideToSelf = v1.copy(); 651 v_mapDivideToSelf.mapDivideToSelf(2.0d); 652 double[] result_mapDivideToSelf = {.5d, 1d, 1.5d}; 653 assertClose("compare vectors" ,result_mapDivideToSelf,v_mapDivideToSelf.getData(),normTolerance); 654 655 //octave = v1 .^ 2.0 656 RealVector v_mapPow = v1.mapPow(2.0d); 657 double[] result_mapPow = {1d, 4d, 9d}; 658 assertClose("compare vectors" ,result_mapPow,v_mapPow.getData(),normTolerance); 659 660 //octave = v1 .^ 2.0 661 RealVector v_mapPowToSelf = v1.copy(); 662 v_mapPowToSelf.mapPowToSelf(2.0d); 663 double[] result_mapPowToSelf = {1d, 4d, 9d}; 664 assertClose("compare vectors" ,result_mapPowToSelf,v_mapPowToSelf.getData(),normTolerance); 665 666 //octave = exp(v1) 667 RealVector v_mapExp = v1.mapExp(); 668 double[] result_mapExp = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d}; 669 assertClose("compare vectors" ,result_mapExp,v_mapExp.getData(),normTolerance); 670 671 //octave = exp(v1) 672 RealVector v_mapExpToSelf = v1.copy(); 673 v_mapExpToSelf.mapExpToSelf(); 674 double[] result_mapExpToSelf = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d}; 675 assertClose("compare vectors" ,result_mapExpToSelf,v_mapExpToSelf.getData(),normTolerance); 676 677 678 //octave = ??? 679 RealVector v_mapExpm1 = v1.mapExpm1(); 680 double[] result_mapExpm1 = {1.718281828459045d,6.38905609893065d, 19.085536923187668d}; 681 assertClose("compare vectors" ,result_mapExpm1,v_mapExpm1.getData(),normTolerance); 682 683 //octave = ??? 684 RealVector v_mapExpm1ToSelf = v1.copy(); 685 v_mapExpm1ToSelf.mapExpm1ToSelf(); 686 double[] result_mapExpm1ToSelf = {1.718281828459045d,6.38905609893065d, 19.085536923187668d}; 687 assertClose("compare vectors" ,result_mapExpm1ToSelf,v_mapExpm1ToSelf.getData(),normTolerance); 688 689 //octave = log(v1) 690 RealVector v_mapLog = v1.mapLog(); 691 double[] result_mapLog = {0d,6.931471805599453e-01d, 1.098612288668110e+00d}; 692 assertClose("compare vectors" ,result_mapLog,v_mapLog.getData(),normTolerance); 693 694 //octave = log(v1) 695 RealVector v_mapLogToSelf = v1.copy(); 696 v_mapLogToSelf.mapLogToSelf(); 697 double[] result_mapLogToSelf = {0d,6.931471805599453e-01d, 1.098612288668110e+00d}; 698 assertClose("compare vectors" ,result_mapLogToSelf,v_mapLogToSelf.getData(),normTolerance); 699 700 //octave = log10(v1) 701 RealVector v_mapLog10 = v1.mapLog10(); 702 double[] result_mapLog10 = {0d,3.010299956639812e-01d, 4.771212547196624e-01d}; 703 assertClose("compare vectors" ,result_mapLog10,v_mapLog10.getData(),normTolerance); 704 705 //octave = log(v1) 706 RealVector v_mapLog10ToSelf = v1.copy(); 707 v_mapLog10ToSelf.mapLog10ToSelf(); 708 double[] result_mapLog10ToSelf = {0d,3.010299956639812e-01d, 4.771212547196624e-01d}; 709 assertClose("compare vectors" ,result_mapLog10ToSelf,v_mapLog10ToSelf.getData(),normTolerance); 710 711 //octave = ??? 712 RealVector v_mapLog1p = v1.mapLog1p(); 713 double[] result_mapLog1p = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d}; 714 assertClose("compare vectors" ,result_mapLog1p,v_mapLog1p.getData(),normTolerance); 715 716 //octave = ??? 717 RealVector v_mapLog1pToSelf = v1.copy(); 718 v_mapLog1pToSelf.mapLog1pToSelf(); 719 double[] result_mapLog1pToSelf = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d}; 720 assertClose("compare vectors" ,result_mapLog1pToSelf,v_mapLog1pToSelf.getData(),normTolerance); 721 722 //octave = cosh(v1) 723 RealVector v_mapCosh = v1.mapCosh(); 724 double[] result_mapCosh = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d}; 725 assertClose("compare vectors" ,result_mapCosh,v_mapCosh.getData(),normTolerance); 726 727 //octave = cosh(v1) 728 RealVector v_mapCoshToSelf = v1.copy(); 729 v_mapCoshToSelf.mapCoshToSelf(); 730 double[] result_mapCoshToSelf = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d}; 731 assertClose("compare vectors" ,result_mapCoshToSelf,v_mapCoshToSelf.getData(),normTolerance); 732 733 //octave = sinh(v1) 734 RealVector v_mapSinh = v1.mapSinh(); 735 double[] result_mapSinh = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d}; 736 assertClose("compare vectors" ,result_mapSinh,v_mapSinh.getData(),normTolerance); 737 738 //octave = sinh(v1) 739 RealVector v_mapSinhToSelf = v1.copy(); 740 v_mapSinhToSelf.mapSinhToSelf(); 741 double[] result_mapSinhToSelf = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d}; 742 assertClose("compare vectors" ,result_mapSinhToSelf,v_mapSinhToSelf.getData(),normTolerance); 743 744 //octave = tanh(v1) 745 RealVector v_mapTanh = v1.mapTanh(); 746 double[] result_mapTanh = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d}; 747 assertClose("compare vectors" ,result_mapTanh,v_mapTanh.getData(),normTolerance); 748 749 //octave = tanh(v1) 750 RealVector v_mapTanhToSelf = v1.copy(); 751 v_mapTanhToSelf.mapTanhToSelf(); 752 double[] result_mapTanhToSelf = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d}; 753 assertClose("compare vectors" ,result_mapTanhToSelf,v_mapTanhToSelf.getData(),normTolerance); 754 755 //octave = cos(v1) 756 RealVector v_mapCos = v1.mapCos(); 757 double[] result_mapCos = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d}; 758 assertClose("compare vectors" ,result_mapCos,v_mapCos.getData(),normTolerance); 759 760 //octave = cos(v1) 761 RealVector v_mapCosToSelf = v1.copy(); 762 v_mapCosToSelf.mapCosToSelf(); 763 double[] result_mapCosToSelf = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d}; 764 assertClose("compare vectors" ,result_mapCosToSelf,v_mapCosToSelf.getData(),normTolerance); 765 766 //octave = sin(v1) 767 RealVector v_mapSin = v1.mapSin(); 768 double[] result_mapSin = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d}; 769 assertClose("compare vectors" ,result_mapSin,v_mapSin.getData(),normTolerance); 770 771 //octave = sin(v1) 772 RealVector v_mapSinToSelf = v1.copy(); 773 v_mapSinToSelf.mapSinToSelf(); 774 double[] result_mapSinToSelf = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d}; 775 assertClose("compare vectors" ,result_mapSinToSelf,v_mapSinToSelf.getData(),normTolerance); 776 777 //octave = tan(v1) 778 RealVector v_mapTan = v1.mapTan(); 779 double[] result_mapTan = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d}; 780 assertClose("compare vectors" ,result_mapTan,v_mapTan.getData(),normTolerance); 781 782 //octave = tan(v1) 783 RealVector v_mapTanToSelf = v1.copy(); 784 v_mapTanToSelf.mapTanToSelf(); 785 double[] result_mapTanToSelf = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d}; 786 assertClose("compare vectors" ,result_mapTanToSelf,v_mapTanToSelf.getData(),normTolerance); 787 788 double[] vat_a = {0d, 0.5d, 1.0d}; 789 OpenMapRealVector vat = new OpenMapRealVector(vat_a); 790 791 //octave = acos(vat) 792 RealVector v_mapAcos = vat.mapAcos(); 793 double[] result_mapAcos = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d}; 794 assertClose("compare vectors" ,result_mapAcos,v_mapAcos.getData(),normTolerance); 795 796 //octave = acos(vat) 797 RealVector v_mapAcosToSelf = vat.copy(); 798 v_mapAcosToSelf.mapAcosToSelf(); 799 double[] result_mapAcosToSelf = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d}; 800 assertClose("compare vectors" ,result_mapAcosToSelf,v_mapAcosToSelf.getData(),normTolerance); 801 802 //octave = asin(vat) 803 RealVector v_mapAsin = vat.mapAsin(); 804 double[] result_mapAsin = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d}; 805 assertClose("compare vectors" ,result_mapAsin,v_mapAsin.getData(),normTolerance); 806 807 //octave = asin(vat) 808 RealVector v_mapAsinToSelf = vat.copy(); 809 v_mapAsinToSelf.mapAsinToSelf(); 810 double[] result_mapAsinToSelf = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d}; 811 assertClose("compare vectors" ,result_mapAsinToSelf,v_mapAsinToSelf.getData(),normTolerance); 812 813 //octave = atan(vat) 814 RealVector v_mapAtan = vat.mapAtan(); 815 double[] result_mapAtan = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d}; 816 assertClose("compare vectors" ,result_mapAtan,v_mapAtan.getData(),normTolerance); 817 818 //octave = atan(vat) 819 RealVector v_mapAtanToSelf = vat.copy(); 820 v_mapAtanToSelf.mapAtanToSelf(); 821 double[] result_mapAtanToSelf = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d}; 822 assertClose("compare vectors" ,result_mapAtanToSelf,v_mapAtanToSelf.getData(),normTolerance); 823 824 //octave = v1 .^-1 825 RealVector v_mapInv = v1.mapInv(); 826 double[] result_mapInv = {1d,0.5d,3.333333333333333e-01d}; 827 assertClose("compare vectors" ,result_mapInv,v_mapInv.getData(),normTolerance); 828 829 //octave = v1 .^-1 830 RealVector v_mapInvToSelf = v1.copy(); 831 v_mapInvToSelf.mapInvToSelf(); 832 double[] result_mapInvToSelf = {1d,0.5d,3.333333333333333e-01d}; 833 assertClose("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData(),normTolerance); 834 835 double[] abs_a = {-1.0d, 0.0d, 1.0d}; 836 OpenMapRealVector abs_v = new OpenMapRealVector(abs_a); 837 838 //octave = abs(abs_v) 839 RealVector v_mapAbs = abs_v.mapAbs(); 840 double[] result_mapAbs = {1d,0d,1d}; 841 assertClose("compare vectors" ,result_mapAbs,v_mapAbs.getData(),normTolerance); 842 843 //octave = abs(abs_v) 844 RealVector v_mapAbsToSelf = abs_v.copy(); 845 v_mapAbsToSelf.mapAbsToSelf(); 846 double[] result_mapAbsToSelf = {1d,0d,1d}; 847 assertClose("compare vectors" ,result_mapAbsToSelf,v_mapAbsToSelf.getData(),normTolerance); 848 849 //octave = sqrt(v1) 850 RealVector v_mapSqrt = v1.mapSqrt(); 851 double[] result_mapSqrt = {1d,1.414213562373095e+00d,1.732050807568877e+00d}; 852 assertClose("compare vectors" ,result_mapSqrt,v_mapSqrt.getData(),normTolerance); 853 854 //octave = sqrt(v1) 855 RealVector v_mapSqrtToSelf = v1.copy(); 856 v_mapSqrtToSelf.mapSqrtToSelf(); 857 double[] result_mapSqrtToSelf = {1d,1.414213562373095e+00d,1.732050807568877e+00d}; 858 assertClose("compare vectors" ,result_mapSqrtToSelf,v_mapSqrtToSelf.getData(),normTolerance); 859 860 double[] cbrt_a = {-2.0d, 0.0d, 2.0d}; 861 OpenMapRealVector cbrt_v = new OpenMapRealVector(cbrt_a); 862 863 //octave = ??? 864 RealVector v_mapCbrt = cbrt_v.mapCbrt(); 865 double[] result_mapCbrt = {-1.2599210498948732d,0d,1.2599210498948732d}; 866 assertClose("compare vectors" ,result_mapCbrt,v_mapCbrt.getData(),normTolerance); 867 868 //octave = ??? 869 RealVector v_mapCbrtToSelf = cbrt_v.copy(); 870 v_mapCbrtToSelf.mapCbrtToSelf(); 871 double[] result_mapCbrtToSelf = {-1.2599210498948732d,0d,1.2599210498948732d}; 872 assertClose("compare vectors" ,result_mapCbrtToSelf,v_mapCbrtToSelf.getData(),normTolerance); 873 874 double[] ceil_a = {-1.1d, 0.9d, 1.1d}; 875 OpenMapRealVector ceil_v = new OpenMapRealVector(ceil_a); 876 877 //octave = ceil(ceil_v) 878 RealVector v_mapCeil = ceil_v.mapCeil(); 879 double[] result_mapCeil = {-1d,1d,2d}; 880 assertClose("compare vectors" ,result_mapCeil,v_mapCeil.getData(),normTolerance); 881 882 //octave = ceil(ceil_v) 883 RealVector v_mapCeilToSelf = ceil_v.copy(); 884 v_mapCeilToSelf.mapCeilToSelf(); 885 double[] result_mapCeilToSelf = {-1d,1d,2d}; 886 assertClose("compare vectors" ,result_mapCeilToSelf,v_mapCeilToSelf.getData(),normTolerance); 887 888 //octave = floor(ceil_v) 889 RealVector v_mapFloor = ceil_v.mapFloor(); 890 double[] result_mapFloor = {-2d,0d,1d}; 891 assertClose("compare vectors" ,result_mapFloor,v_mapFloor.getData(),normTolerance); 892 893 //octave = floor(ceil_v) 894 RealVector v_mapFloorToSelf = ceil_v.copy(); 895 v_mapFloorToSelf.mapFloorToSelf(); 896 double[] result_mapFloorToSelf = {-2d,0d,1d}; 897 assertClose("compare vectors" ,result_mapFloorToSelf,v_mapFloorToSelf.getData(),normTolerance); 898 899 //octave = ??? 900 RealVector v_mapRint = ceil_v.mapRint(); 901 double[] result_mapRint = {-1d,1d,1d}; 902 assertClose("compare vectors" ,result_mapRint,v_mapRint.getData(),normTolerance); 903 904 //octave = ??? 905 RealVector v_mapRintToSelf = ceil_v.copy(); 906 v_mapRintToSelf.mapRintToSelf(); 907 double[] result_mapRintToSelf = {-1d,1d,1d}; 908 assertClose("compare vectors" ,result_mapRintToSelf,v_mapRintToSelf.getData(),normTolerance); 909 910 //octave = ??? 911 RealVector v_mapSignum = ceil_v.mapSignum(); 912 double[] result_mapSignum = {-1d,1d,1d}; 913 assertClose("compare vectors" ,result_mapSignum,v_mapSignum.getData(),normTolerance); 914 915 //octave = ??? 916 RealVector v_mapSignumToSelf = ceil_v.copy(); 917 v_mapSignumToSelf.mapSignumToSelf(); 918 double[] result_mapSignumToSelf = {-1d,1d,1d}; 919 assertClose("compare vectors" ,result_mapSignumToSelf,v_mapSignumToSelf.getData(),normTolerance); 920 921 922 // Is with the used resolutions of limited value as test 923 //octave = ??? 924 RealVector v_mapUlp = ceil_v.mapUlp(); 925 double[] result_mapUlp = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d}; 926 assertClose("compare vectors" ,result_mapUlp,v_mapUlp.getData(),normTolerance); 927 928 //octave = ??? 929 RealVector v_mapUlpToSelf = ceil_v.copy(); 930 v_mapUlpToSelf.mapUlpToSelf(); 931 double[] result_mapUlpToSelf = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d}; 932 assertClose("compare vectors" ,result_mapUlpToSelf,v_mapUlpToSelf.getData(),normTolerance); 933 934 } 935 936 public void testBasicFunctions() { 937 OpenMapRealVector v1 = new OpenMapRealVector(vec1); 938 OpenMapRealVector v2 = new OpenMapRealVector(vec2); 939 OpenMapRealVector v_null = new OpenMapRealVector(vec_null); 940 941 SparseRealVectorTestImpl v2_t = new SparseRealVectorTestImpl(vec2); 942 943 //octave = sqrt(sumsq(v1)) 944 double d_getNorm = v1.getNorm(); 945 assertEquals("compare values ", 3.7416573867739413,d_getNorm); 946 947 double d_getL1Norm = v1.getL1Norm(); 948 assertEquals("compare values ",6.0, d_getL1Norm); 949 950 double d_getLInfNorm = v1.getLInfNorm(); 951 assertEquals("compare values ",6.0, d_getLInfNorm); 952 953 //octave = sqrt(sumsq(v1-v2)) 954 double dist = v1.getDistance(v2); 955 assertEquals("compare values ",v1.subtract(v2).getNorm(), dist ); 956 957 //octave = sqrt(sumsq(v1-v2)) 958 double dist_2 = v1.getDistance(v2_t); 959 assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_2 ); 960 961 //octave = ??? 962 double d_getL1Distance = v1. getL1Distance(v2); 963 assertEquals("compare values ",9d, d_getL1Distance ); 964 965 double d_getL1Distance_2 = v1. getL1Distance(v2_t); 966 assertEquals("compare values ",9d, d_getL1Distance_2 ); 967 968 //octave = ??? 969 double d_getLInfDistance = v1. getLInfDistance(v2); 970 assertEquals("compare values ",3d, d_getLInfDistance ); 971 972 double d_getLInfDistance_2 = v1. getLInfDistance(v2_t); 973 assertEquals("compare values ",3d, d_getLInfDistance_2 ); 974 975 //octave = v1 + v2 976 OpenMapRealVector v_add = v1.add(v2); 977 double[] result_add = {5d, 7d, 9d}; 978 assertClose("compare vect" ,v_add.getData(),result_add,normTolerance); 979 980 SparseRealVectorTestImpl vt2 = new SparseRealVectorTestImpl(vec2); 981 RealVector v_add_i = v1.add(vt2); 982 double[] result_add_i = {5d, 7d, 9d}; 983 assertClose("compare vect" ,v_add_i.getData(),result_add_i,normTolerance); 984 985 //octave = v1 - v2 986 OpenMapRealVector v_subtract = v1.subtract(v2); 987 double[] result_subtract = {-3d, -3d, -3d}; 988 assertClose("compare vect" ,v_subtract.getData(),result_subtract,normTolerance); 989 990 RealVector v_subtract_i = v1.subtract(vt2); 991 double[] result_subtract_i = {-3d, -3d, -3d}; 992 assertClose("compare vect" ,v_subtract_i.getData(),result_subtract_i,normTolerance); 993 994 // octave v1 .* v2 995 RealVector v_ebeMultiply = v1.ebeMultiply(v2); 996 double[] result_ebeMultiply = {4d, 10d, 18d}; 997 assertClose("compare vect" ,v_ebeMultiply.getData(),result_ebeMultiply,normTolerance); 998 999 RealVector v_ebeMultiply_2 = v1.ebeMultiply(v2_t); 1000 double[] result_ebeMultiply_2 = {4d, 10d, 18d}; 1001 assertClose("compare vect" ,v_ebeMultiply_2.getData(),result_ebeMultiply_2,normTolerance); 1002 1003 // octave v1 ./ v2 1004 RealVector v_ebeDivide = v1.ebeDivide(v2); 1005 double[] result_ebeDivide = {0.25d, 0.4d, 0.5d}; 1006 assertClose("compare vect" ,v_ebeDivide.getData(),result_ebeDivide,normTolerance); 1007 1008 RealVector v_ebeDivide_2 = v1.ebeDivide(v2_t); 1009 double[] result_ebeDivide_2 = {0.25d, 0.4d, 0.5d}; 1010 assertClose("compare vect" ,v_ebeDivide_2.getData(),result_ebeDivide_2,normTolerance); 1011 1012 // octave dot(v1,v2) 1013 double dot = v1.dotProduct(v2); 1014 assertEquals("compare val ",32d, dot); 1015 1016 // octave dot(v1,v2_t) 1017 double dot_2 = v1.dotProduct(v2_t); 1018 assertEquals("compare val ",32d, dot_2); 1019 1020 RealMatrix m_outerProduct = v1.outerProduct(v2); 1021 assertEquals("compare val ",4d, m_outerProduct.getEntry(0,0)); 1022 1023 RealMatrix m_outerProduct_2 = v1.outerProduct(v2_t); 1024 assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0)); 1025 1026 RealVector v_unitVector = v1.unitVector(); 1027 RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm()); 1028 assertClose("compare vect" ,v_unitVector.getData(),v_unitVector_2.getData(),normTolerance); 1029 1030 try { 1031 v_null.unitVector(); 1032 fail("Expecting ArithmeticException"); 1033 } catch (ArithmeticException ex) { 1034 // expected behavior 1035 } catch (Exception e) { 1036 fail("wrong exception caught"); 1037 } 1038 1039 OpenMapRealVector v_unitize = (OpenMapRealVector)v1.copy(); 1040 v_unitize.unitize(); 1041 assertClose("compare vect" ,v_unitVector_2.getData(),v_unitize.getData(),normTolerance); 1042 try { 1043 v_null.unitize(); 1044 fail("Expecting ArithmeticException"); 1045 } catch (ArithmeticException ex) { 1046 // expected behavior 1047 } catch (Exception e) { 1048 fail("wrong exception caught"); 1049 } 1050 1051 RealVector v_projection = v1.projection(v2); 1052 double[] result_projection = {1.662337662337662, 2.0779220779220777, 2.493506493506493}; 1053 assertClose("compare vect", v_projection.getData(), result_projection, normTolerance); 1054 1055 RealVector v_projection_2 = v1.projection(v2_t); 1056 double[] result_projection_2 = {1.662337662337662, 2.0779220779220777, 2.493506493506493}; 1057 assertClose("compare vect", v_projection_2.getData(), result_projection_2, normTolerance); 1058 1059 } 1060 1061 public void testMisc() { 1062 OpenMapRealVector v1 = new OpenMapRealVector(vec1); 1063 1064 String out1 = v1.toString(); 1065 assertTrue("some output ", out1.length()!=0); 1066 try { 1067 v1.checkVectorDimensions(2); 1068 fail("IllegalArgumentException expected"); 1069 } catch (IllegalArgumentException ex) { 1070 // expected behavior 1071 } catch (Exception e) { 1072 fail("wrong exception caught"); 1073 } 1074 1075 1076 } 1077 1078 public void testPredicates() { 1079 1080 OpenMapRealVector v = new OpenMapRealVector(new double[] { 0, 1, 2 }); 1081 1082 assertFalse(v.isNaN()); 1083 v.setEntry(1, Double.NaN); 1084 assertTrue(v.isNaN()); 1085 1086 assertFalse(v.isInfinite()); 1087 v.setEntry(0, Double.POSITIVE_INFINITY); 1088 assertFalse(v.isInfinite()); // NaN has higher priority than infinity 1089 v.setEntry(1, 1); 1090 assertTrue(v.isInfinite()); 1091 1092 v.setEntry(0, 0); 1093 assertEquals(v, new OpenMapRealVector(new double[] { 0, 1, 2 })); 1094 assertNotSame(v, new OpenMapRealVector(new double[] { 0, 1, 2 + Math.ulp(2)})); 1095 assertNotSame(v, new OpenMapRealVector(new double[] { 0, 1, 2, 3 })); 1096 1097 } 1098 1099 public void testSerial() { 1100 OpenMapRealVector v = new OpenMapRealVector(new double[] { 0, 1, 2 }); 1101 assertEquals(v,TestUtils.serializeAndRecover(v)); 1102 } 1103 1104 /** verifies that two vectors are close (sup norm) */ 1105 protected void assertClose(String msg, double[] m, double[] n, 1106 double tolerance) { 1107 if (m.length != n.length) { 1108 fail("vectors have different lengths"); 1109 } 1110 for (int i = 0; i < m.length; i++) { 1111 assertEquals(msg + " " + i + " elements differ", m[i],n[i],tolerance); 1112 } 1113 } 1114 1115 }