001/*- 002 ******************************************************************************* 003 * Copyright (c) 2011, 2016 Diamond Light Source Ltd. 004 * All rights reserved. This program and the accompanying materials 005 * are made available under the terms of the Eclipse Public License v1.0 006 * which accompanies this distribution, and is available at 007 * http://www.eclipse.org/legal/epl-v10.html 008 * 009 * Contributors: 010 * Peter Chang - initial API and implementation and/or initial documentation 011 *******************************************************************************/ 012 013// GEN_COMMENT 014 015package org.eclipse.january.dataset; 016 017import java.util.Arrays; 018 019import org.apache.commons.math3.complex.Complex; 020 021/** 022 * Extend compound dataset for double values // PRIM_TYPE 023 */ 024public class CompoundDoubleDataset extends AbstractCompoundDataset { 025 // pin UID to base class 026 private static final long serialVersionUID = Dataset.serialVersionUID; 027 028 protected double[] data; // subclass alias // PRIM_TYPE 029 030 @Override 031 protected void setData() { 032 data = (double[]) odata; // PRIM_TYPE 033 } 034 035 protected double[] createArray(final int size) { // PRIM_TYPE 036 double[] array = null; // PRIM_TYPE 037 038 try { 039 array = new double[isize * size]; // PRIM_TYPE 040 } catch (OutOfMemoryError e) { 041 logger.error("The size of the dataset ({}) that is being created is too large " 042 + "and there is not enough memory to hold it.", size); 043 throw new OutOfMemoryError("The dimensions given are too large, and there is " 044 + "not enough memory available in the Java Virtual Machine"); 045 } 046 return array; 047 } 048 049 @Override 050 public int getDType() { 051 return Dataset.ARRAYFLOAT64; // DATA_TYPE 052 } 053 054 /** 055 * Create a null dataset 056 */ 057 CompoundDoubleDataset() { 058 } 059 060 /** 061 * Create a null dataset 062 * @param itemSize 063 */ 064 CompoundDoubleDataset(final int itemSize) { 065 isize = itemSize; 066 } 067 068 /** 069 * Create a zero-filled dataset of given item size and shape 070 * @param itemSize 071 * @param shape 072 */ 073 CompoundDoubleDataset(final int itemSize, final int[] shape) { 074 isize = itemSize; 075 if (shape != null) { 076 size = ShapeUtils.calcSize(shape); 077 this.shape = shape.clone(); 078 079 try { 080 odata = data = createArray(size); 081 } catch (Throwable t) { 082 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 083 throw new IllegalArgumentException(t); 084 } 085 } 086 } 087 088 /** 089 * Copy a dataset 090 * @param dataset 091 */ 092 CompoundDoubleDataset(final CompoundDoubleDataset dataset) { 093 isize = dataset.isize; 094 095 copyToView(dataset, this, true, true); 096 try { 097 if (dataset.stride == null) { 098 if (dataset.data != null) { 099 odata = data = dataset.data.clone(); 100 } 101 } else { 102 offset = 0; 103 stride = null; 104 base = null; 105 odata = data = createArray(size); 106 IndexIterator iter = dataset.getIterator(); 107 for (int j = 0; iter.hasNext();) { 108 for (int i = 0; i < isize; i++) { 109 data[j++] = dataset.data[iter.index + i]; 110 } 111 } 112 } 113 } catch (Throwable t) { 114 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 115 throw new IllegalArgumentException(t); 116 } 117 } 118 119 /** 120 * Create a dataset using given dataset 121 * @param dataset 122 */ 123 CompoundDoubleDataset(final CompoundDataset dataset) { 124 copyToView(dataset, this, true, false); 125 offset = 0; 126 stride = null; 127 base = null; 128 isize = dataset.getElementsPerItem(); 129 try { 130 odata = data = createArray(size); 131 } catch (Throwable t) { 132 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 133 throw new IllegalArgumentException(t); 134 } 135 136 IndexIterator iter = dataset.getIterator(); 137 for (int j = 0; iter.hasNext();) { 138 for (int i = 0; i < isize; i++) { 139 data[j++] = dataset.getElementDoubleAbs(iter.index + i); // GET_ELEMENT_WITH_CAST 140 } 141 } 142 } 143 144 /** 145 * Create a dataset using given data (elements are grouped together) 146 * @param itemSize 147 * @param data 148 * @param shape 149 * (can be null to create 1D dataset) 150 */ 151 CompoundDoubleDataset(final int itemSize, final double[] data, int... shape) { // PRIM_TYPE 152 isize = itemSize; 153 if (data != null) { 154 if (shape == null || (shape.length == 0 && data.length > isize)) { 155 shape = new int[] { data.length / isize }; 156 } 157 size = ShapeUtils.calcSize(shape); 158 if (size * isize != data.length) { 159 throw new IllegalArgumentException(String.format("Shape %s is not compatible with size of data array, %d", 160 Arrays.toString(shape), data.length / isize)); 161 } 162 this.shape = size == 0 ? null : shape.clone(); 163 164 odata = this.data = data; 165 } 166 } 167 168 /** 169 * Create a dataset using given datasets 170 * @param datasets 171 */ 172 CompoundDoubleDataset(final Dataset... datasets) { 173 if (datasets.length < 1) { 174 throw new IllegalArgumentException("Array of datasets must have length greater than zero"); 175 } 176 177 for (int i = 1; i < datasets.length; i++) { 178 datasets[0].checkCompatibility(datasets[i]); 179 } 180 181 isize = datasets.length; 182 size = ShapeUtils.calcSize(datasets[0].getShapeRef()); 183 shape = datasets[0].getShape(); 184 185 try { 186 odata = data = createArray(size); 187 } catch (Throwable t) { 188 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 189 throw new IllegalArgumentException(t); 190 } 191 192 IndexIterator[] iters = new IndexIterator[isize]; 193 for (int i = 0; i < datasets.length; i++) { 194 iters[i] = datasets[i].getIterator(); 195 } 196 197 for (int j = 0; iters[0].hasNext();) { 198 data[j++] = datasets[0].getElementDoubleAbs(iters[0].index); // GET_ELEMENT_WITH_CAST 199 for (int i = 1; i < datasets.length; i++) { 200 iters[i].hasNext(); 201 data[j++] = datasets[i].getElementDoubleAbs(iters[i].index); // GET_ELEMENT_WITH_CAST 202 } 203 } 204 } 205 206 /** 207 * Cast a dataset to this compound type. If repeat is set, the first element of each item in the given dataset is 208 * repeated across all elements of an item. Otherwise, each item comprises a truncated or zero-padded copy of 209 * elements from the given dataset. 210 * @param itemSize 211 * @param repeat 212 * repeat first element 213 * @param dataset 214 */ 215 CompoundDoubleDataset(final int itemSize, final boolean repeat, final Dataset dataset) { 216 isize = itemSize; 217 size = dataset.getSize(); 218 shape = dataset.getShape(); 219 name = new String(dataset.getName()); 220 221 try { 222 odata = data = createArray(size); 223 } catch (Throwable t) { 224 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 225 throw new IllegalArgumentException(t); 226 } 227 final int os = dataset.getElementsPerItem(); 228 229 IndexIterator iter = dataset.getIterator(); 230 if (repeat) { 231 int i = 0; 232 while (iter.hasNext()) { 233 final double v = dataset.getElementDoubleAbs(iter.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST 234 for (int k = 0; k < isize; k++) { 235 data[i++] = v; 236 } 237 } 238 } else { 239 final int kmax = Math.min(isize, os); 240 int i = 0; 241 while (iter.hasNext()) { 242 for (int k = 0; k < kmax; k++) { 243 data[i + k] = dataset.getElementDoubleAbs(iter.index + k); // GET_ELEMENT_WITH_CAST 244 } 245 i += isize; 246 } 247 } 248 } 249 250 @Override 251 public boolean equals(Object obj) { 252 if (this == obj) { 253 return true; 254 } 255 256 if (obj == null) { 257 return false; 258 } 259 260 if (!getClass().equals(obj.getClass())) { 261 if (getRank() == 0) { // for zero-rank datasets 262 return obj.equals(getObjectAbs(offset)); 263 } 264 return false; 265 } 266 267 CompoundDoubleDataset other = (CompoundDoubleDataset) obj; 268 if (isize != other.isize) { 269 return false; 270 } 271 if (size != other.size) { 272 return false; 273 } 274 if (!Arrays.equals(shape, other.shape)) { 275 return false; 276 } 277 if (data == other.data && stride == null && other.stride == null) { 278 return true; 279 } 280 281 IndexIterator iter = getIterator(); 282 IndexIterator oiter = other.getIterator(); 283 while (iter.hasNext() && oiter.hasNext()) { 284 for (int j = 0; j < isize; j++) { 285 if (data[iter.index+j] != other.data[oiter.index+j]) { 286 return false; 287 } 288 } 289 } 290 return true; 291 } 292 293 @Override 294 public int hashCode() { 295 return super.hashCode(); 296 } 297 298 @Override 299 public CompoundDoubleDataset clone() { 300 return new CompoundDoubleDataset(this); 301 } 302 303 /** 304 * Create a dataset from an object which could be a Java list, array (of arrays...) or Number. Ragged 305 * sequences or arrays are padded with zeros. The item size is the last dimension of the corresponding 306 * elemental dataset 307 * 308 * @param obj 309 * @return dataset with contents given by input 310 */ 311 static CompoundDoubleDataset createFromObject(final Object obj) { 312 DoubleDataset result = DoubleDataset.createFromObject(obj); // CLASS_TYPE 313 return createCompoundDatasetWithLastDimension(result, true); 314 } 315 316 /** 317 * Create a 1D dataset from an object which could be a Java list, array (of arrays...) or Number. Ragged 318 * sequences or arrays are padded with zeros. 319 * 320 * @param itemSize 321 * @param obj 322 * @return dataset with contents given by input 323 */ 324 public static CompoundDoubleDataset createFromObject(final int itemSize, final Object obj) { 325 DoubleDataset result = DoubleDataset.createFromObject(obj); // CLASS_TYPE 326 boolean zeroRank = result.shape == null ? false : result.shape.length == 0; 327 if (zeroRank) { 328 result.resize(itemSize); // special case of single item 329 result.fill(obj); 330 } 331 CompoundDoubleDataset ds = new CompoundDoubleDataset(itemSize, result.getData(), null); 332 if (zeroRank) { 333 ds.setShape(new int[0]); 334 } 335 return ds; 336 } 337 338 /** 339 * @param stop 340 * @return a new 1D dataset, filled with values determined by parameters 341 */ 342 static CompoundDoubleDataset createRange(final int itemSize, final double stop) { 343 return createRange(itemSize, 0., stop, 1.); 344 } 345 346 /** 347 * @param start 348 * @param stop 349 * @param step 350 * @return a new 1D dataset, filled with values determined by parameters 351 */ 352 static CompoundDoubleDataset createRange(final int itemSize, final double start, final double stop, 353 final double step) { 354 int size = calcSteps(start, stop, step); 355 CompoundDoubleDataset result = new CompoundDoubleDataset(itemSize, new int[] { size }); 356 for (int i = 0; i < size; i++) { 357 result.data[i * result.isize] = (start + i * step); // PRIM_TYPE // ADD_CAST 358 } 359 return result; 360 } 361 362 /** 363 * @param shape 364 * @return a dataset filled with ones 365 */ 366 static CompoundDoubleDataset ones(final int itemSize, final int... shape) { 367 return new CompoundDoubleDataset(itemSize, shape).fill(1); 368 } 369 370 /** 371 * Create a compound dataset using last dimension of given dataset 372 * @param a 373 * @param shareData if true, then share data when possible otherwise copy it 374 * @return compound dataset 375 */ 376 public static CompoundDoubleDataset createCompoundDatasetWithLastDimension(final Dataset a, final boolean shareData) { 377 if (a.getElementsPerItem() != 1) { 378 logger.error("Need a single-element dataset"); 379 throw new IllegalArgumentException("Need a single-element dataset"); 380 } 381 if (a.getDType() != Dataset.FLOAT64) { // DATA_TYPE 382 logger.error("Dataset type must be double"); // PRIM_TYPE 383 throw new IllegalArgumentException("Dataset type must be double"); // PRIM_TYPE 384 } 385 386 final int[] shape = a.getShapeRef(); 387 if (shape == null) { 388 return new CompoundDoubleDataset(0); 389 } 390 391 final int rank = shape.length - 1; 392 final int is = rank < 0 ? 1 : shape[rank]; 393 394 CompoundDoubleDataset result = new CompoundDoubleDataset(is); 395 396 result.shape = rank > 0 ? Arrays.copyOf(shape, rank) : (rank < 0 ? new int[0] : new int[] {1}); 397 result.size = ShapeUtils.calcSize(result.shape); 398 result.odata = shareData ? a.flatten().getBuffer() : a.clone().getBuffer(); 399 result.setName(a.getName()); 400 result.setData(); 401 return result; 402 } 403 404 @Override 405 public DoubleDataset asNonCompoundDataset(final boolean shareData) { // CLASS_TYPE 406 DoubleDataset result = new DoubleDataset(); // CLASS_TYPE 407 final int is = getElementsPerItem(); 408 final int rank = is == 1 ? shape.length : shape.length + 1; 409 final int[] nshape = Arrays.copyOf(shape, rank); 410 if (is != 1) 411 nshape[rank-1] = is; 412 413 result.shape = nshape; 414 result.size = ShapeUtils.calcSize(nshape); 415 result.odata = shareData && isContiguous() ? data : clone().getBuffer(); 416 result.setName(name); 417 result.setData(); 418 return result; 419 } 420 421 @Override 422 public CompoundDoubleDataset fill(final Object obj) { 423 setDirty(); 424 double[] vr = DTypeUtils.toDoubleArray(obj, isize); // PRIM_TYPE // CLASS_TYPE 425 IndexIterator iter = getIterator(); 426 427 while (iter.hasNext()) { 428 for (int i = 0; i < isize; i++) { 429 data[iter.index + i] = vr[i]; // PRIM_TYPE 430 } 431 } 432 433 return this; 434 } 435 436 /** 437 * This is a typed version of {@link #getBuffer()} 438 * @return data buffer as linear array 439 */ 440 public double[] getData() { // PRIM_TYPE 441 return data; 442 } 443 444 @Override 445 protected int getBufferLength() { 446 if (data == null) 447 return 0; 448 return data.length; 449 } 450 451 @Override 452 public CompoundDoubleDataset getView(boolean deepCopyMetadata) { 453 CompoundDoubleDataset view = new CompoundDoubleDataset(isize); 454 copyToView(this, view, true, deepCopyMetadata); 455 view.setData(); 456 return view; 457 } 458 459 /** 460 * Get values at absolute index in the internal array. This is an internal method with no checks so can be 461 * dangerous. Use with care or ideally with an iterator. 462 * 463 * @param index 464 * absolute index 465 * @return values 466 */ 467 public double[] getAbs(final int index) { // PRIM_TYPE 468 double[] result = new double[isize]; // PRIM_TYPE 469 for (int i = 0; i < isize; i++) { 470 result[i] = data[index + i]; 471 } 472 return result; 473 } 474 475 /** 476 * Get values at absolute index in the internal array. This is an internal method with no checks so can be 477 * dangerous. Use with care or ideally with an iterator. 478 * 479 * @param index 480 * absolute index 481 * @param values 482 */ 483 public void getAbs(final int index, final double[] values) { // PRIM_TYPE 484 for (int i = 0; i < isize; i++) { 485 values[i] = data[index + i]; 486 } 487 } 488 489 @Override 490 public boolean getElementBooleanAbs(final int index) { 491 return data[index] != 0; 492 } 493 494 @Override 495 public double getElementDoubleAbs(final int index) { 496 return data[index]; 497 } 498 499 @Override 500 public long getElementLongAbs(final int index) { 501 return DTypeUtils.toLong(data[index]); // OMIT_TOLONG_INT 502 } 503 504 @Override 505 protected void setItemDirect(final int dindex, final int sindex, final Object src) { 506 setDirty(); 507 double[] dsrc = (double[]) src; // PRIM_TYPE 508 for (int i = 0; i < isize; i++) { 509 data[dindex + i] = dsrc[sindex + i]; 510 } 511 } 512 513 /** 514 * Set values at absolute index in the internal array. This is an internal method with no checks so can be 515 * dangerous. Use with care or ideally with an iterator. 516 * 517 * @param index 518 * absolute index 519 * @param val 520 * new values 521 */ 522 public void setAbs(final int index, final double[] val) { // PRIM_TYPE 523 setDirty(); 524 for (int i = 0; i < isize; i++) { 525 data[index + i] = val[i]; 526 } 527 } 528 529 /** 530 * Set element value at absolute index in the internal array. This is an internal method with no checks so can be 531 * dangerous. Use with care or ideally with an iterator. 532 * 533 * @param index 534 * absolute index 535 * @param val 536 * new value 537 */ 538 public void setAbs(final int index, final double val) { // PRIM_TYPE 539 setDirty(); 540 data[index] = val; 541 } 542 543 @Override 544 public Object getObject() { 545 return getDoubleArray(); // PRIM_TYPE 546 } 547 548 @Override 549 public Object getObject(final int i) { 550 return getDoubleArray(i); // PRIM_TYPE 551 } 552 553 @Override 554 public Object getObject(final int i, final int j) { 555 return getDoubleArray(i, j); // PRIM_TYPE 556 } 557 558 @Override 559 public Object getObject(final int... pos) { 560 return getDoubleArray(pos); // PRIM_TYPE 561 } 562 563 @Override 564 public byte[] getByteArray() { 565 byte[] result = new byte[isize]; 566 int index = getFirst1DIndex(); 567 for (int k = 0; k < isize; k++) { 568 result[k] = (byte) data[index + k]; // OMIT_UPCAST 569 } 570 return result; 571 } 572 573 @Override 574 public byte[] getByteArray(final int i) { 575 byte[] result = new byte[isize]; 576 int index = get1DIndex(i); 577 for (int k = 0; k < isize; k++) { 578 result[k] = (byte) data[index + k]; // OMIT_UPCAST 579 } 580 return result; 581 } 582 583 @Override 584 public byte[] getByteArray(final int i, final int j) { 585 byte[] result = new byte[isize]; 586 int index = get1DIndex(i, j); 587 for (int k = 0; k < isize; k++) { 588 result[k] = (byte) data[index + k]; // OMIT_UPCAST 589 } 590 return result; 591 } 592 593 @Override 594 public byte[] getByteArray(final int... pos) { 595 byte[] result = new byte[isize]; 596 int index = get1DIndex(pos); 597 for (int k = 0; k < isize; k++) { 598 result[k] = (byte) data[index + k]; // OMIT_UPCAST 599 } 600 return result; 601 } 602 603 @Override 604 public short[] getShortArray() { 605 short[] result = new short[isize]; 606 int index = getFirst1DIndex(); 607 for (int k = 0; k < isize; k++) { 608 result[k] = (short) data[index + k]; // OMIT_UPCAST 609 } 610 return result; 611 } 612 613 @Override 614 public short[] getShortArray(final int i) { 615 short[] result = new short[isize]; 616 int index = get1DIndex(i); 617 for (int k = 0; k < isize; k++) { 618 result[k] = (short) data[index + k]; // OMIT_UPCAST 619 } 620 return result; 621 } 622 623 @Override 624 public short[] getShortArray(final int i, final int j) { 625 short[] result = new short[isize]; 626 int index = get1DIndex(i, j); 627 for (int k = 0; k < isize; k++) { 628 result[k] = (short) data[index + k]; // OMIT_UPCAST 629 } 630 return result; 631 } 632 633 @Override 634 public short[] getShortArray(final int... pos) { 635 short[] result = new short[isize]; 636 int index = get1DIndex(pos); 637 for (int k = 0; k < isize; k++) { 638 result[k] = (short) data[index + k]; // OMIT_UPCAST 639 } 640 return result; 641 } 642 643 @Override 644 public int[] getIntArray() { 645 int[] result = new int[isize]; 646 int index = getFirst1DIndex(); 647 for (int k = 0; k < isize; k++) { 648 result[k] = (int) data[index + k]; // OMIT_UPCAST 649 } 650 return result; 651 } 652 653 @Override 654 public int[] getIntArray(final int i) { 655 int[] result = new int[isize]; 656 int index = get1DIndex(i); 657 for (int k = 0; k < isize; k++) { 658 result[k] = (int) data[index + k]; // OMIT_UPCAST 659 } 660 return result; 661 } 662 663 @Override 664 public int[] getIntArray(final int i, final int j) { 665 int[] result = new int[isize]; 666 int index = get1DIndex(i, j); 667 for (int k = 0; k < isize; k++) { 668 result[k] = (int) data[index + k]; // OMIT_UPCAST 669 } 670 return result; 671 } 672 673 @Override 674 public int[] getIntArray(final int... pos) { 675 int[] result = new int[isize]; 676 int index = get1DIndex(pos); 677 for (int k = 0; k < isize; k++) { 678 result[k] = (int) data[index + k]; // OMIT_UPCAST 679 } 680 return result; 681 } 682 683 @Override 684 public long[] getLongArray() { 685 long[] result = new long[isize]; 686 int index = getFirst1DIndex(); 687 for (int k = 0; k < isize; k++) { 688 result[k] = (long) data[index + k]; // OMIT_UPCAST 689 } 690 return result; 691 } 692 693 @Override 694 public long[] getLongArray(final int i) { 695 long[] result = new long[isize]; 696 int index = get1DIndex(i); 697 for (int k = 0; k < isize; k++) { 698 result[k] = (long) data[index + k]; // OMIT_UPCAST 699 } 700 return result; 701 } 702 703 @Override 704 public long[] getLongArray(final int i, final int j) { 705 long[] result = new long[isize]; 706 int index = get1DIndex(i, j); 707 for (int k = 0; k < isize; k++) { 708 result[k] = (long) data[index + k]; // OMIT_UPCAST 709 } 710 return result; 711 } 712 713 @Override 714 public long[] getLongArray(final int... pos) { 715 long[] result = new long[isize]; 716 int index = get1DIndex(pos); 717 for (int k = 0; k < isize; k++) { 718 result[k] = (long) data[index + k]; // OMIT_UPCAST 719 } 720 return result; 721 } 722 723 @Override 724 public float[] getFloatArray() { 725 float[] result = new float[isize]; 726 int index = getFirst1DIndex(); 727 for (int k = 0; k < isize; k++) { 728 result[k] = (float) data[index + k]; // OMIT_REAL_CAST 729 } 730 return result; 731 } 732 733 @Override 734 public float[] getFloatArray(final int i) { 735 float[] result = new float[isize]; 736 int index = get1DIndex(i); 737 for (int k = 0; k < isize; k++) { 738 result[k] = (float) data[index + k]; // OMIT_REAL_CAST 739 } 740 return result; 741 } 742 743 @Override 744 public float[] getFloatArray(final int i, final int j) { 745 float[] result = new float[isize]; 746 int index = get1DIndex(i, j); 747 for (int k = 0; k < isize; k++) { 748 result[k] = (float) data[index + k]; // OMIT_REAL_CAST 749 } 750 return result; 751 } 752 753 @Override 754 public float[] getFloatArray(final int... pos) { 755 float[] result = new float[isize]; 756 int index = get1DIndex(pos); 757 for (int k = 0; k < isize; k++) { 758 result[k] = (float) data[index + k]; // OMIT_REAL_CAST 759 } 760 return result; 761 } 762 763 @Override 764 public double[] getDoubleArray() { 765 double[] result = new double[isize]; 766 int index = getFirst1DIndex(); 767 for (int k = 0; k < isize; k++) { 768 result[k] = data[index + k]; // OMIT_REAL_CAST 769 } 770 return result; 771 } 772 773 @Override 774 public double[] getDoubleArray(final int i) { 775 double[] result = new double[isize]; 776 int index = get1DIndex(i); 777 for (int k = 0; k < isize; k++) { 778 result[k] = data[index + k]; // OMIT_REAL_CAST 779 } 780 return result; 781 } 782 783 @Override 784 public double[] getDoubleArray(final int i, final int j) { 785 double[] result = new double[isize]; 786 int index = get1DIndex(i, j); 787 for (int k = 0; k < isize; k++) { 788 result[k] = data[index + k]; // OMIT_REAL_CAST 789 } 790 return result; 791 } 792 793 @Override 794 public double[] getDoubleArray(final int... pos) { 795 double[] result = new double[isize]; 796 int index = get1DIndex(pos); 797 for (int k = 0; k < isize; k++) { 798 result[k] = data[index + k]; // OMIT_REAL_CAST 799 } 800 return result; 801 } 802 803 @Override 804 public void getDoubleArrayAbs(final int index, final double[] darray) { 805 for (int i = 0; i < isize; i++) { 806 darray[i] = data[index + i]; 807 } 808 } 809 810 @Override 811 public String getString() { 812 return getStringAbs(getFirst1DIndex()); 813 } 814 815 @Override 816 public String getString(final int i) { 817 return getStringAbs(get1DIndex(i)); 818 } 819 820 @Override 821 public String getString(final int i, final int j) { 822 return getStringAbs(get1DIndex(i, j)); 823 } 824 825 @Override 826 public String getString(final int... pos) { 827 return getStringAbs(get1DIndex(pos)); 828 } 829 830 @Override 831 protected double getFirstValue() { 832 return data[getFirst1DIndex()]; 833 } 834 835 @Override 836 protected double getFirstValue(int i) { 837 return data[get1DIndex(i)]; 838 } 839 840 @Override 841 protected double getFirstValue(int i, int j) { 842 return data[get1DIndex(i, j)]; 843 } 844 845 @Override 846 protected double getFirstValue(final int... pos) { 847 return data[get1DIndex(pos)]; 848 } 849 850 @Override 851 public Object getObjectAbs(final int index) { 852 double[] result = new double[isize]; // PRIM_TYPE 853 for (int i = 0; i < isize; i++) { 854 result[i] = data[index + i]; 855 } 856 return result; 857 } 858 859 @Override 860 public String getStringAbs(final int index) { 861 StringBuilder s = new StringBuilder(); 862 s.append('('); 863 s.append(stringFormat == null ? String.format("%.8g", data[index]) : // FORMAT_STRING 864 stringFormat.format(data[index])); 865 for (int i = 1; i < isize; i++) { 866 s.append(' '); 867 s.append(stringFormat == null ? String.format("%.8g", data[index + i]) : // FORMAT_STRING 868 stringFormat.format(data[index + i])); 869 } 870 s.append(')'); 871 return s.toString(); 872 } 873 874 @Override 875 public void setObjectAbs(final int index, final Object obj) { 876 double[] oa = DTypeUtils.toDoubleArray(obj, isize); // PRIM_TYPE // CLASS_TYPE 877 setAbs(index, oa); 878 } 879 880 @Override 881 public void set(final Object obj) { 882 setItem(DTypeUtils.toDoubleArray(obj, isize)); // CLASS_TYPE 883 } 884 885 @Override 886 public void set(final Object obj, final int i) { 887 setItem(DTypeUtils.toDoubleArray(obj, isize), i); // CLASS_TYPE 888 } 889 890 @Override 891 public void set(final Object obj, final int i, final int j) { 892 setItem(DTypeUtils.toDoubleArray(obj, isize), i, j); // CLASS_TYPE 893 } 894 895 @Override 896 public void set(final Object obj, int... pos) { 897 if (pos == null || (pos.length == 0 && shape.length > 0)) { 898 pos = new int[shape.length]; 899 } 900 901 setItem(DTypeUtils.toDoubleArray(obj, isize), pos); // CLASS_TYPE 902 } 903 904 /** 905 * Set values at first position. The dataset must not be null 906 * 907 * @param d 908 * @since 2.0 909 */ 910 public void setItem(final double[] d) { // PRIM_TYPE 911 if (d.length > isize) { 912 throw new IllegalArgumentException("Array is larger than number of elements in an item"); 913 } 914 setAbs(getFirst1DIndex(), d); 915 } 916 917 /** 918 * Set values at given position. The dataset must be 1D 919 * 920 * @param d 921 * @param i 922 */ 923 public void setItem(final double[] d, final int i) { // PRIM_TYPE 924 if (d.length > isize) { 925 throw new IllegalArgumentException("Array is larger than number of elements in an item"); 926 } 927 setAbs(get1DIndex(i), d); 928 } 929 930 /** 931 * Set values at given position. The dataset must be 1D 932 * 933 * @param d 934 * @param i 935 * @param j 936 */ 937 public void setItem(final double[] d, final int i, final int j) { // PRIM_TYPE 938 if (d.length > isize) { 939 throw new IllegalArgumentException("Array is larger than number of elements in an item"); 940 } 941 setAbs(get1DIndex(i, j), d); 942 } 943 944 /** 945 * Set values at given position 946 * 947 * @param d 948 * @param pos 949 */ 950 public void setItem(final double[] d, final int... pos) { // PRIM_TYPE 951 if (d.length > isize) { 952 throw new IllegalArgumentException("Array is larger than number of elements in an item"); 953 } 954 setAbs(get1DIndex(pos), d); 955 } 956 957 private void setDoubleArrayAbs(final int index, final double[] d) { 958 for (int i = 0; i < isize; i++) 959 data[index + i] = d[i]; // ADD_CAST 960 } 961 962 @Override 963 public void resize(int... newShape) { 964 setDirty(); 965 IndexIterator iter = getIterator(); 966 int nsize = ShapeUtils.calcSize(newShape); 967 double[] ndata; // PRIM_TYPE 968 try { 969 ndata = createArray(nsize); 970 } catch (Throwable t) { 971 logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); 972 throw new IllegalArgumentException(t); 973 } 974 975 int i = 0; 976 while (iter.hasNext() && i < nsize) { 977 for (int j = 0; j < isize; j++) { 978 ndata[i++] = data[iter.index + j]; 979 } 980 } 981 982 odata = data = ndata; 983 size = nsize; 984 shape = newShape; 985 stride = null; 986 offset = 0; 987 base = null; 988 } 989 990 @Override 991 public CompoundDoubleDataset getSlice(final SliceIterator siter) { 992 CompoundDoubleDataset result = new CompoundDoubleDataset(isize, siter.getShape()); 993 double[] rdata = result.data; // PRIM_TYPE 994 IndexIterator riter = result.getIterator(); 995 996 while (siter.hasNext() && riter.hasNext()) { 997 for (int i = 0; i < isize; i++) 998 rdata[riter.index + i] = data[siter.index + i]; 999 } 1000 1001 result.setName(name + BLOCK_OPEN + Slice.createString(siter.shape, siter.start, siter.stop, siter.step) + BLOCK_CLOSE); 1002 return result; 1003 } 1004 1005 @Override 1006 public DoubleDataset getElementsView(int element) { // CLASS_TYPE 1007 if (element < 0) 1008 element += isize; 1009 if (element < 0 || element > isize) { 1010 throw new IllegalArgumentException(String.format("Invalid choice of element: %d/%d", element, isize)); 1011 } 1012 1013 DoubleDataset view = new DoubleDataset(shape); // CLASS_TYPE 1014 1015 copyToView(this, view, true, true); 1016 view.setData(); 1017 if (view.stride == null) { 1018 int[] offset = new int[1]; 1019 view.stride = createStrides(this, offset); 1020 view.offset = offset[0] + element; 1021 view.base = base == null ? this : base; 1022 } else { 1023 view.offset += element; 1024 } 1025 1026 return view; 1027 } 1028 1029 @Override 1030 public DoubleDataset getElements(int element) { // CLASS_TYPE 1031 final DoubleDataset elements = new DoubleDataset(shape); // CLASS_TYPE 1032 1033 copyElements(elements, element); 1034 return elements; 1035 } 1036 1037 @Override 1038 public void copyElements(Dataset destination, int element) { 1039 if (element < 0) 1040 element += isize; 1041 if (element < 0 || element > isize) { 1042 throw new IllegalArgumentException(String.format("Invalid choice of element: %d/%d", element, isize)); 1043 } 1044 if (getElementClass() != destination.getElementClass()) { 1045 throw new IllegalArgumentException("Element class of destination does not match this dataset"); 1046 } 1047 1048 final IndexIterator it = getIterator(element); 1049 final double[] elements = ((DoubleDataset) destination).data; // CLASS_TYPE // PRIM_TYPE 1050 destination.setDirty(); 1051 1052 int n = 0; 1053 while (it.hasNext()) { 1054 elements[n] = data[it.index]; 1055 n++; 1056 } 1057 } 1058 1059 @Override 1060 public void setElements(Dataset source, int element) { 1061 setDirty(); 1062 if (element < 0) 1063 element += isize; 1064 if (element < 0 || element > isize) { 1065 throw new IllegalArgumentException(String.format("Invalid choice of element: %d/%d", element, isize)); 1066 } 1067 if (getElementClass() != source.getElementClass()) { 1068 throw new IllegalArgumentException("Element class of destination does not match this dataset"); 1069 } 1070 1071 final IndexIterator it = getIterator(element); 1072 final double[] elements = ((DoubleDataset) source).data; // CLASS_TYPE // PRIM_TYPE 1073 1074 int n = 0; 1075 while (it.hasNext()) { 1076 data[it.index] = elements[n]; 1077 n++; 1078 } 1079 } 1080 1081 @Override 1082 public void fillDataset(Dataset result, IndexIterator iter) { 1083 IndexIterator riter = result.getIterator(); 1084 result.setDirty(); 1085 1086 double[] rdata = ((CompoundDoubleDataset) result).data; // PRIM_TYPE 1087 1088 while (riter.hasNext() && iter.hasNext()) { 1089 for (int i = 0; i < isize; i++) { 1090 rdata[riter.index + i] = data[iter.index + i]; 1091 } 1092 } 1093 } 1094 1095 @Override 1096 public CompoundDoubleDataset setByBoolean(final Object o, Dataset selection) { 1097 setDirty(); 1098 if (o instanceof Dataset) { 1099 Dataset ds = (Dataset) o; 1100 final int length = ((Number) selection.sum()).intValue(); 1101 if (length != ds.getSize()) { 1102 throw new IllegalArgumentException( 1103 "Number of true items in selection does not match number of items in dataset"); 1104 } 1105 1106 IndexIterator iter = ds.getIterator(); 1107 BooleanIterator biter = getBooleanIterator(selection); 1108 1109 if (ds instanceof AbstractCompoundDataset) { 1110 if (isize != ds.getElementsPerItem()) { 1111 throw new IllegalArgumentException("Input dataset is not compatible with slice"); 1112 } 1113 1114 while (biter.hasNext() && iter.hasNext()) { 1115 for (int i = 0; i < isize; i++) { 1116 data[biter.index + i] = ds.getElementDoubleAbs(iter.index + i); // GET_ELEMENT_WITH_CAST 1117 } 1118 } 1119 } else { 1120 while (biter.hasNext() && iter.hasNext()) { 1121 data[biter.index] = ds.getElementDoubleAbs(iter.index); // GET_ELEMENT_WITH_CAST 1122 for (int i = 1; i < isize; i++) { 1123 data[biter.index + i] = 0; 1124 } 1125 } 1126 } 1127 } else { 1128 try { 1129 final double[] vr = DTypeUtils.toDoubleArray(o, isize); // PRIM_TYPE // CLASS_TYPE 1130 1131 final BooleanIterator biter = getBooleanIterator(selection); 1132 1133 while (biter.hasNext()) { 1134 for (int i = 0; i < isize; i++) { 1135 data[biter.index + i] = vr[i]; 1136 } 1137 } 1138 } catch (IllegalArgumentException e) { 1139 throw new IllegalArgumentException("Object for setting is not a dataset or number"); 1140 } 1141 } 1142 return this; 1143 } 1144 1145 @Override 1146 public CompoundDoubleDataset setBy1DIndex(final Object o, Dataset index) { 1147 setDirty(); 1148 if (o instanceof Dataset) { 1149 Dataset ds = (Dataset) o; 1150 if (index.getSize() != ds.getSize()) { 1151 throw new IllegalArgumentException( 1152 "Number of items in selection does not match number of items in dataset"); 1153 } 1154 1155 IndexIterator oiter = ds.getIterator(); 1156 final IntegerIterator iter = new IntegerIterator(index, size, isize); 1157 1158 if (ds instanceof AbstractCompoundDataset) { 1159 if (isize != ds.getElementsPerItem()) { 1160 throw new IllegalArgumentException("Input dataset is not compatible with slice"); 1161 } 1162 1163 double[] temp = new double[isize]; 1164 while (iter.hasNext() && oiter.hasNext()) { 1165 ((AbstractCompoundDataset) ds).getDoubleArrayAbs(oiter.index, temp); 1166 setDoubleArrayAbs(iter.index, temp); 1167 } 1168 while (iter.hasNext() && oiter.hasNext()) { 1169 for (int i = 0; i < isize; i++) { 1170 data[iter.index + i] = ds.getElementDoubleAbs(oiter.index + i); // GET_ELEMENT_WITH_CAST 1171 } 1172 } 1173 } else { 1174 while (iter.hasNext() && oiter.hasNext()) { 1175 data[iter.index] = ds.getElementDoubleAbs(oiter.index); // GET_ELEMENT_WITH_CAST 1176 for (int i = 1; i < isize; i++) { 1177 data[iter.index + i] = 0; 1178 } 1179 } 1180 } 1181 } else { 1182 try { 1183 final double[] vr = DTypeUtils.toDoubleArray(o, isize); // PRIM_TYPE // CLASS_TYPE 1184 1185 final IntegerIterator iter = new IntegerIterator(index, size, isize); 1186 1187 while (iter.hasNext()) { 1188 setAbs(iter.index, vr); 1189 } 1190 } catch (IllegalArgumentException e) { 1191 throw new IllegalArgumentException("Object for setting is not a dataset or number"); 1192 } 1193 } 1194 return this; 1195 } 1196 1197 @Override 1198 public CompoundDoubleDataset setByIndexes(final Object o, final Object... indexes) { 1199 setDirty(); 1200 final IntegersIterator iter = new IntegersIterator(shape, indexes); 1201 final int[] pos = iter.getPos(); 1202 1203 if (o instanceof Dataset) { 1204 Dataset ds = (Dataset) o; 1205 if (ShapeUtils.calcSize(iter.getShape()) != ds.getSize()) { 1206 throw new IllegalArgumentException( 1207 "Number of items in selection does not match number of items in dataset"); 1208 } 1209 1210 IndexIterator oiter = ds.getIterator(); 1211 1212 if (ds instanceof AbstractCompoundDataset) { 1213 if (isize != ds.getElementsPerItem()) { 1214 throw new IllegalArgumentException("Input dataset is not compatible with slice"); 1215 } 1216 1217 double[] temp = new double[isize]; 1218 while (iter.hasNext() && oiter.hasNext()) { 1219 ((AbstractCompoundDataset) ds).getDoubleArray(temp, pos); 1220 setDoubleArrayAbs(get1DIndex(pos), temp); 1221 } 1222 } else { 1223 while (iter.hasNext() && oiter.hasNext()) { 1224 int n = get1DIndex(pos); 1225 data[n] = ds.getElementDoubleAbs(oiter.index); // GET_ELEMENT_WITH_CAST 1226 for (int i = 1; i < isize; i++) { 1227 data[n + i] = 0; 1228 } 1229 } 1230 } 1231 } else { 1232 try { 1233 final double[] vr = DTypeUtils.toDoubleArray(o, isize); // PRIM_TYPE // CLASS_TYPE 1234 1235 while (iter.hasNext()) { 1236 setAbs(get1DIndex(pos), vr); 1237 } 1238 } catch (IllegalArgumentException e) { 1239 throw new IllegalArgumentException("Object for setting is not a dataset or number"); 1240 } 1241 } 1242 return this; 1243 } 1244 1245 @Override 1246 CompoundDoubleDataset setSlicedView(Dataset view, Dataset d) { 1247 setDirty(); 1248 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(view, d); 1249 1250 final int is = view.getElementsPerItem(); 1251 1252 if (is > 1) { 1253 if (d.getElementsPerItem() == 1) { 1254 while (it.hasNext()) { 1255 final double bv = it.bDouble; // PRIM_TYPE // BCAST_WITH_CAST d.getElementDoubleAbs(it.bIndex); 1256 data[it.aIndex] = bv; 1257 for (int j = 1; j < is; j++) { 1258 data[it.aIndex + j] = bv; 1259 } 1260 } 1261 } else { 1262 while (it.hasNext()) { 1263 data[it.aIndex] = it.bDouble; // BCAST_WITH_CAST d.getElementDoubleAbs(it.bIndex); 1264 for (int j = 1; j < is; j++) { 1265 data[it.aIndex + j] = d.getElementDoubleAbs(it.bIndex + j); // GET_ELEMENT_WITH_CAST 1266 } 1267 } 1268 } 1269 } else { 1270 while (it.hasNext()) { 1271 data[it.aIndex] = it.bDouble; // BCAST_WITH_CAST d.getElementDoubleAbs(it.bIndex); 1272 } 1273 } 1274 return this; 1275 } 1276 1277 @Override 1278 public CompoundDoubleDataset setSlice(final Object o, final IndexIterator siter) { 1279 setDirty(); 1280 if (o instanceof IDataset) { 1281 final IDataset ds = (IDataset) o; 1282 final int[] oshape = ds.getShape(); 1283 1284 if (!ShapeUtils.areShapesCompatible(siter.getShape(), oshape)) { 1285 throw new IllegalArgumentException(String.format( 1286 "Input dataset is not compatible with slice: %s cf %s", Arrays.toString(oshape), 1287 Arrays.toString(siter.getShape()))); 1288 } 1289 1290 if (ds instanceof Dataset) { 1291 final Dataset ads = (Dataset) ds; 1292 IndexIterator oiter = ads.getIterator(); 1293 1294 if (ds instanceof AbstractCompoundDataset) { 1295 if (isize != ads.getElementsPerItem()) { 1296 throw new IllegalArgumentException("Input dataset is not compatible with slice"); 1297 } 1298 1299 while (siter.hasNext() && oiter.hasNext()) { 1300 for (int i = 0; i < isize; i++) { 1301 data[siter.index + i] = ads.getElementDoubleAbs(oiter.index + i); // GET_ELEMENT_WITH_CAST 1302 } 1303 } 1304 } else { 1305 while (siter.hasNext() && oiter.hasNext()) { 1306 data[siter.index] = ads.getElementDoubleAbs(oiter.index); // GET_ELEMENT_WITH_CAST 1307 for (int i = 1; i < isize; i++) { 1308 data[siter.index + i] = 0; 1309 } 1310 } 1311 } 1312 } else { 1313 final IndexIterator oiter = new PositionIterator(oshape); 1314 final int[] pos = oiter.getPos(); 1315 1316 if (ds.getElementsPerItem() == 1) { 1317 while (siter.hasNext() && oiter.hasNext()) { 1318 data[siter.index] = ds.getDouble(pos); // PRIM_TYPE 1319 for (int i = 1; i < isize; i++) { 1320 data[siter.index + i] = 0; 1321 } 1322 } 1323 } else { 1324 while (siter.hasNext() && oiter.hasNext()) { 1325 final double[] val = DTypeUtils.toDoubleArray(ds.getObject(pos), isize); // PRIM_TYPE // CLASS_TYPE 1326 for (int i = 0; i < isize; i++) { 1327 data[siter.index + i] = val[i]; 1328 } 1329 } 1330 } 1331 } 1332 } else { 1333 try { 1334 final double[] vr = DTypeUtils.toDoubleArray(o, isize); // PRIM_TYPE // CLASS_TYPE 1335 1336 while (siter.hasNext()) { 1337 for (int i = 0; i < isize; i++) { 1338 data[siter.index + i] = vr[i]; 1339 } 1340 } 1341 } catch (IllegalArgumentException e) { 1342 throw new IllegalArgumentException("Object for setting slice is not a dataset or number"); 1343 } 1344 } 1345 return this; 1346 } 1347 1348 @Override 1349 public void copyItemsFromAxes(final int[] pos, final boolean[] axes, final Dataset dest) { 1350 double[] ddata = (double[]) dest.getBuffer(); // PRIM_TYPE 1351 1352 if (dest.getElementsPerItem() != isize) { 1353 throw new IllegalArgumentException(String.format( 1354 "Destination dataset is incompatible as it has %d elements per item not %d", 1355 dest.getElementsPerItem(), isize)); 1356 } 1357 1358 SliceIterator siter = getSliceIteratorFromAxes(pos, axes); 1359 int[] sshape = ShapeUtils.squeezeShape(siter.getShape(), false); 1360 1361 IndexIterator diter = dest.getSliceIterator(null, sshape, null); 1362 1363 if (ddata.length < ShapeUtils.calcSize(sshape)) { 1364 throw new IllegalArgumentException("destination array is not large enough"); 1365 } 1366 1367 dest.setDirty(); 1368 while (siter.hasNext() && diter.hasNext()) { 1369 for (int i = 0; i < isize; i++) { 1370 ddata[diter.index + i] = data[siter.index + i]; 1371 } 1372 } 1373 } 1374 1375 @Override 1376 public void setItemsOnAxes(final int[] pos, final boolean[] axes, final Object src) { 1377 setDirty(); 1378 double[] sdata = (double[]) src; // PRIM_TYPE 1379 1380 SliceIterator siter = getSliceIteratorFromAxes(pos, axes); 1381 1382 if (sdata.length < ShapeUtils.calcSize(siter.getShape())) { 1383 throw new IllegalArgumentException("source array is not large enough"); 1384 } 1385 1386 for (int i = 0; siter.hasNext(); i++) { 1387 for (int j = 0; j < isize; j++) { 1388 data[siter.index + j] = sdata[isize * i + j]; 1389 } 1390 } 1391 } 1392 1393 @Override 1394 public boolean containsNans() { 1395 final IndexIterator iter = getIterator(); // REAL_ONLY 1396 while (iter.hasNext()) { // REAL_ONLY 1397 for (int i = 0; i < isize; i++) { // REAL_ONLY 1398 if (Double.isNaN(data[iter.index + i])) // CLASS_TYPE // REAL_ONLY 1399 return true; // REAL_ONLY 1400 } // REAL_ONLY 1401 } // REAL_ONLY 1402 return false; 1403 } 1404 1405 @Override 1406 public boolean containsInfs() { 1407 final IndexIterator iter = getIterator(); // REAL_ONLY 1408 while (iter.hasNext()) { // REAL_ONLY 1409 for (int i = 0; i < isize; i++) { // REAL_ONLY 1410 if (Double.isInfinite(data[iter.index + i])) // CLASS_TYPE // REAL_ONLY 1411 return true; // REAL_ONLY 1412 } // REAL_ONLY 1413 } // REAL_ONLY 1414 return false; 1415 } 1416 1417 @Override 1418 public boolean containsInvalidNumbers() { 1419 IndexIterator iter = getIterator(); // REAL_ONLY 1420 while (iter.hasNext()) { // REAL_ONLY 1421 for (int i = 0; i < isize; i++) { // REAL_ONLY 1422 double x = data[iter.index + i]; // PRIM_TYPE // REAL_ONLY 1423 if (Double.isNaN(x) || Double.isInfinite(x)) // CLASS_TYPE // REAL_ONLY 1424 return true; // REAL_ONLY 1425 } // REAL_ONLY 1426 } // REAL_ONLY 1427 return false; 1428 } 1429 1430 @Override 1431 public CompoundDoubleDataset iadd(final Object b) { 1432 setDirty(); 1433 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1434 boolean useLong = bds.getElementClass().equals(Long.class); 1435 int is = bds.getElementsPerItem(); 1436 if (bds.getSize() == 1) { 1437 final IndexIterator it = getIterator(); 1438 final int bOffset = bds.getOffset(); 1439 if (is == 1) { 1440 if (useLong) { 1441 final long lb = bds.getElementLongAbs(bOffset); 1442 while (it.hasNext()) { 1443 for (int i = 0; i < isize; i++) { 1444 data[it.index + i] += lb; 1445 } 1446 } 1447 } else { 1448 final double db = bds.getElementDoubleAbs(bOffset); 1449 while (it.hasNext()) { 1450 for (int i = 0; i < isize; i++) { 1451 data[it.index + i] += db; 1452 } 1453 } 1454 } 1455 } else if (is == isize) { 1456 if (useLong) { 1457 while (it.hasNext()) { 1458 for (int i = 0; i < isize; i++) { 1459 data[it.index + i] += bds.getElementLongAbs(i); 1460 } 1461 } 1462 } else { 1463 while (it.hasNext()) { 1464 for (int i = 0; i < isize; i++) { 1465 data[it.index + i] += bds.getElementDoubleAbs(i); 1466 } 1467 } 1468 } 1469 } else { 1470 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1471 } 1472 } else { 1473 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1474 it.setOutputDouble(!useLong); 1475 if (is == 1) { 1476 if (useLong) { 1477 while (it.hasNext()) { 1478 final long lb = it.bLong; 1479 data[it.aIndex] += lb; 1480 for (int i = 1; i < isize; i++) { 1481 data[it.aIndex + i] += lb; 1482 } 1483 } 1484 } else { 1485 while (it.hasNext()) { 1486 final double db = it.bDouble; 1487 data[it.aIndex] += db; 1488 for (int i = 1; i < isize; i++) { 1489 data[it.aIndex + i] += db; 1490 } 1491 } 1492 } 1493 } else if (is == isize) { 1494 if (useLong) { 1495 while (it.hasNext()) { 1496 data[it.aIndex] += it.bLong; 1497 for (int i = 1; i < isize; i++) { 1498 data[it.aIndex + i] += bds.getElementLongAbs(it.bIndex + i); 1499 } 1500 } 1501 } else { 1502 while (it.hasNext()) { 1503 data[it.aIndex] += it.bDouble; 1504 for (int i = 1; i < isize; i++) { 1505 data[it.aIndex + i] += bds.getElementDoubleAbs(it.bIndex + i); 1506 } 1507 } 1508 } 1509 } else { 1510 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1511 } 1512 } 1513 return this; 1514 } 1515 1516 @Override 1517 public CompoundDoubleDataset isubtract(final Object b) { 1518 setDirty(); 1519 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1520 boolean useLong = bds.getElementClass().equals(Long.class); 1521 int is = bds.getElementsPerItem(); 1522 if (bds.getSize() == 1) { 1523 final IndexIterator it = getIterator(); 1524 final int bOffset = bds.getOffset(); 1525 if (is == 1) { 1526 if (useLong) { 1527 final long lb = bds.getElementLongAbs(bOffset); 1528 while (it.hasNext()) { 1529 for (int i = 0; i < isize; i++) { 1530 data[it.index + i] -= lb; 1531 } 1532 } 1533 } else { 1534 final double db = bds.getElementDoubleAbs(bOffset); 1535 while (it.hasNext()) { 1536 for (int i = 0; i < isize; i++) { 1537 data[it.index + i] -= db; 1538 } 1539 } 1540 } 1541 } else if (is == isize) { 1542 if (useLong) { 1543 while (it.hasNext()) { 1544 for (int i = 0; i < isize; i++) { 1545 data[it.index + i] -= bds.getElementLongAbs(i); 1546 } 1547 } 1548 } else { 1549 while (it.hasNext()) { 1550 for (int i = 0; i < isize; i++) { 1551 data[it.index + i] -= bds.getElementDoubleAbs(i); 1552 } 1553 } 1554 } 1555 } else { 1556 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1557 } 1558 } else { 1559 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1560 it.setOutputDouble(!useLong); 1561 if (is == 1) { 1562 if (useLong) { 1563 while (it.hasNext()) { 1564 final long lb = it.bLong; 1565 data[it.aIndex] += lb; 1566 for (int i = 1; i < isize; i++) { 1567 data[it.aIndex + i] -= lb; 1568 } 1569 } 1570 } else { 1571 while (it.hasNext()) { 1572 final double db = it.bDouble; 1573 data[it.aIndex] += db; 1574 for (int i = 1; i < isize; i++) { 1575 data[it.aIndex + i] -= db; 1576 } 1577 } 1578 } 1579 } else if (is == isize) { 1580 if (useLong) { 1581 while (it.hasNext()) { 1582 data[it.aIndex] += it.bLong; 1583 for (int i = 1; i < isize; i++) { 1584 data[it.aIndex + i] -= bds.getElementLongAbs(it.bIndex + i); 1585 } 1586 } 1587 } else { 1588 while (it.hasNext()) { 1589 data[it.aIndex] += it.bDouble; 1590 for (int i = 1; i < isize; i++) { 1591 data[it.aIndex + i] -= bds.getElementDoubleAbs(it.bIndex + i); 1592 } 1593 } 1594 } 1595 } else { 1596 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1597 } 1598 } 1599 return this; 1600 } 1601 1602 @Override 1603 public CompoundDoubleDataset imultiply(final Object b) { 1604 setDirty(); 1605 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1606 boolean useLong = bds.getElementClass().equals(Long.class); 1607 int is = bds.getElementsPerItem(); 1608 if (bds.getSize() == 1) { 1609 final IndexIterator it = getIterator(); 1610 final int bOffset = bds.getOffset(); 1611 if (useLong) { 1612 if (is == 1) { 1613 final long lb = bds.getElementLongAbs(bOffset); 1614 while (it.hasNext()) { 1615 for (int i = 0; i < isize; i++) { 1616 data[it.index + i] *= lb; 1617 } 1618 } 1619 } else if (is == isize) { 1620 while (it.hasNext()) { 1621 for (int i = 0; i < isize; i++) { 1622 data[it.index + i] *= bds.getElementLongAbs(i); 1623 } 1624 } 1625 } else { 1626 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1627 } 1628 } else { 1629 if (is == 1) { 1630 final double db = bds.getElementDoubleAbs(bOffset); 1631 while (it.hasNext()) { 1632 for (int i = 0; i < isize; i++) { 1633 data[it.index + i] *= db; 1634 } 1635 } 1636 } else if (is == isize) { 1637 while (it.hasNext()) { 1638 for (int i = 0; i < isize; i++) { 1639 data[it.index + i] *= bds.getElementDoubleAbs(i); 1640 } 1641 } 1642 } else { 1643 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1644 } 1645 } 1646 } else { 1647 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1648 it.setOutputDouble(!useLong); 1649 if (useLong) { 1650 if (is == 1) { 1651 while (it.hasNext()) { 1652 final double lb = it.bLong; 1653 for (int i = 0; i < isize; i++) { 1654 data[it.aIndex + i] *= lb; 1655 } 1656 } 1657 } else if (is == isize) { 1658 while (it.hasNext()) { 1659 data[it.aIndex] *= it.bLong; 1660 for (int i = 1; i < isize; i++) { 1661 data[it.aIndex + i] *= bds.getElementLongAbs(it.bIndex + i); 1662 } 1663 } 1664 } else { 1665 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1666 } 1667 } else { 1668 if (is == 1) { 1669 while (it.hasNext()) { 1670 final double db = it.bDouble; 1671 for (int i = 0; i < isize; i++) { 1672 data[it.aIndex + i] *= db; 1673 } 1674 } 1675 } else if (is == isize) { 1676 while (it.hasNext()) { 1677 data[it.aIndex] *= it.bDouble; 1678 for (int i = 1; i < isize; i++) { 1679 data[it.aIndex + i] *= bds.getElementDoubleAbs(it.bIndex + i); 1680 } 1681 } 1682 } else { 1683 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1684 } 1685 } 1686 } 1687 return this; 1688 } 1689 1690 @Override 1691 public CompoundDoubleDataset idivide(final Object b) { 1692 setDirty(); 1693 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1694 boolean useLong = bds.getElementClass().equals(Long.class); 1695 int is = bds.getElementsPerItem(); 1696 if (bds.getSize() == 1) { 1697 final IndexIterator it = getIterator(); 1698 final int bOffset = bds.getOffset(); 1699 if (useLong) { 1700 if (is == 1) { 1701 final long lb = bds.getElementLongAbs(bOffset); 1702 // if (lb == 0) { // INT_USE 1703 // fill(0); // INT_USE 1704 // } else { // INT_USE 1705 while (it.hasNext()) { 1706 for (int i = 0; i < isize; i++) { 1707 data[it.index + i] /= lb; 1708 } 1709 } 1710 // } // INT_USE 1711 } else if (is == isize) { 1712 while (it.hasNext()) { 1713 for (int i = 0; i < isize; i++) { 1714 final long lb = bds.getElementLongAbs(i); 1715 data[it.index + i] /= lb; // INT_EXCEPTION 1716 } 1717 } 1718 } else { 1719 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1720 } 1721 } else { 1722 if (is == 1) { 1723 final double db = bds.getElementDoubleAbs(bOffset); 1724 // if (db == 0) { // INT_USE 1725 // fill(0); // INT_USE 1726 // } else { // INT_USE 1727 while (it.hasNext()) { 1728 for (int i = 0; i < isize; i++) { 1729 data[it.index + i] /= db; 1730 } 1731 } 1732 // } // INT_USE 1733 } else if (is == isize) { 1734 while (it.hasNext()) { 1735 for (int i = 0; i < isize; i++) { 1736 final double db = bds.getElementDoubleAbs(i); 1737 data[it.index + i] /= db; // INT_EXCEPTION 1738 } 1739 } 1740 } else { 1741 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1742 } 1743 } 1744 } else { 1745 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1746 it.setOutputDouble(!useLong); 1747 if (useLong) { 1748 if (is == 1) { 1749 while (it.hasNext()) { 1750 final long lb = it.bLong; 1751 // if (lb == 0) { // INT_USE 1752 // for (int i = 0; i < isize; i++) { // INT_USE 1753 // data[it.aIndex + i] = 0; // INT_USE 1754 // }// INT_USE 1755 // } else { // INT_USE 1756 for (int i = 0; i < isize; i++) { 1757 data[it.aIndex + i] /= lb; 1758 } 1759 // } // INT_USE 1760 } 1761 } else if (is == isize) { 1762 while (it.hasNext()) { 1763 for (int i = 0; i < isize; i++) { 1764 final long lb = bds.getElementLongAbs(it.bIndex + i); 1765 data[it.aIndex + i] /= lb; // INT_EXCEPTION 1766 } 1767 } 1768 } else { 1769 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1770 } 1771 } else { 1772 if (is == 1) { 1773 while (it.hasNext()) { 1774 final double db = it.bDouble; 1775 // if (db == 0) { // INT_USE 1776 // for (int i = 0; i < isize; i++) { // INT_USE 1777 // data[it.aIndex + i] = 0; // INT_USE 1778 // }// INT_USE 1779 // } else { // INT_USE 1780 for (int i = 0; i < isize; i++) { 1781 data[it.aIndex + i] /= db; 1782 } 1783 // } // INT_USE 1784 } 1785 } else if (is == isize) { 1786 while (it.hasNext()) { 1787 for (int i = 0; i < isize; i++) { 1788 final double db = bds.getElementDoubleAbs(it.bIndex + i); 1789 data[it.aIndex + i] /= db; // INT_EXCEPTION 1790 } 1791 } 1792 } else { 1793 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1794 } 1795 } 1796 } 1797 return this; 1798 } 1799 1800 @Override 1801 public CompoundDoubleDataset ifloor() { 1802 setDirty(); // REAL_ONLY 1803 final IndexIterator it = getIterator(); // REAL_ONLY 1804 while (it.hasNext()) { // REAL_ONLY 1805 for (int i = 0; i < isize; i++) { // REAL_ONLY 1806 data[it.index + i] = Math.floor(data[it.index] + i); // REAL_ONLY // ADD_CAST 1807 } // REAL_ONLY 1808 } // REAL_ONLY 1809 return this; 1810 } 1811 1812 @Override 1813 public CompoundDoubleDataset iremainder(final Object b) { 1814 setDirty(); 1815 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1816 boolean useLong = bds.getElementClass().equals(Long.class); 1817 int is = bds.getElementsPerItem(); 1818 if (bds.getSize() == 1) { 1819 final IndexIterator it = getIterator(); 1820 final int bOffset = bds.getOffset(); 1821 if (useLong) { 1822 if (is == 1) { 1823 final long lb = bds.getElementLongAbs(bOffset); 1824 // if (lb == 0) { // INT_USE 1825 // fill(0); // INT_USE 1826 // } else { // INT_USE 1827 while (it.hasNext()) { 1828 for (int i = 0; i < isize; i++) { 1829 data[it.index + i] %= lb; 1830 } 1831 } 1832 // } // INT_USE 1833 } else if (is == isize) { 1834 while (it.hasNext()) { 1835 for (int i = 0; i < isize; i++) { 1836 data[it.index + i] %= bds.getElementLongAbs(i); // INT_EXCEPTION 1837 } 1838 } 1839 } else { 1840 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1841 } 1842 } else { 1843 if (is == 1) { 1844 final double db = bds.getElementDoubleAbs(bOffset); 1845 // if (db == 0) { // INT_USE 1846 // fill(0); // INT_USE 1847 // } else { // INT_USE 1848 while (it.hasNext()) { 1849 for (int i = 0; i < isize; i++) { 1850 data[it.index + i] %= db; 1851 } 1852 } 1853 // } // INT_USE 1854 } else if (is == isize) { 1855 while (it.hasNext()) { 1856 for (int i = 0; i < isize; i++) { 1857 data[it.index + i] %= bds.getElementDoubleAbs(i); // INT_EXCEPTION 1858 } 1859 } 1860 } else { 1861 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1862 } 1863 } 1864 } else { 1865 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1866 it.setOutputDouble(!useLong); 1867 if (useLong) { 1868 if (is == 1) { 1869 while (it.hasNext()) { 1870 final long lb = it.bLong; 1871 // if (lb == 0) { // INT_USE 1872 // for (int i = 0; i < isize; i++) // INT_USE 1873 // data[it.aIndex + i] = 0; // INT_USE 1874 // } else { // INT_USE 1875 for (int i = 0; i < isize; i++) 1876 data[it.aIndex + i] %= lb; 1877 // } // INT_USE 1878 } 1879 } else if (is == isize) { 1880 while (it.hasNext()) { 1881 for (int i = 0; i < isize; i++) { 1882 final long lb = bds.getElementLongAbs(it.bIndex + i); 1883 data[it.aIndex + i] %= lb; // INT_EXCEPTION 1884 } 1885 } 1886 } else { 1887 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1888 } 1889 } else { 1890 if (is == 1) { 1891 while (it.hasNext()) { 1892 final double db = it.bDouble; 1893 // if (db == 0) { // INT_USE 1894 // for (int i = 0; i < isize; i++) // INT_USE 1895 // data[it.aIndex + i] = 0; // INT_USE 1896 // } else { // INT_USE 1897 for (int i = 0; i < isize; i++) { 1898 data[it.aIndex + i] %= db; 1899 } 1900 // } // INT_USE 1901 } 1902 } else if (is == isize) { 1903 while (it.hasNext()) { 1904 for (int i = 0; i < isize; i++) { 1905 final double db = bds.getElementDoubleAbs(it.bIndex + i); 1906 data[it.aIndex + i] %= db; // INT_EXCEPTION 1907 } 1908 } 1909 } else { 1910 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1911 } 1912 } 1913 } 1914 return this; 1915 } 1916 1917 @Override 1918 public CompoundDoubleDataset ipower(final Object b) { 1919 setDirty(); 1920 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1921 final int is = bds.getElementsPerItem(); 1922 if (bds.getSize() == 1) { 1923 final int bOffset = bds.getOffset(); 1924 final double vr = bds.getElementDoubleAbs(bOffset); 1925 final IndexIterator it = getIterator(); 1926 if (bds.isComplex()) { 1927 final double vi = bds.getElementDoubleAbs(bOffset + 1); 1928 if (vi == 0) { 1929 while (it.hasNext()) { 1930 for (int i = 0; i < isize; i++) { 1931 final double v = Math.pow(data[it.index + i], vr); 1932 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1933 // data[it.index + i] = 0; // INT_USE 1934 // } else { // INT_USE 1935 data[it.index + i] = v; // PRIM_TYPE_LONG // ADD_CAST 1936 // } // INT_USE 1937 } 1938 } 1939 } else { 1940 final Complex zv = new Complex(vr, vi); 1941 while (it.hasNext()) { 1942 for (int i = 0; i < isize; i++) { 1943 Complex zd = new Complex(data[it.index + i], 0); 1944 final double v = zd.pow(zv).getReal(); 1945 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1946 // data[it.index + i] = 0; // INT_USE 1947 // } else { // INT_USE 1948 data[it.index + i] = v; // PRIM_TYPE_LONG // ADD_CAST 1949 // } // INT_USE 1950 } 1951 } 1952 } 1953 } else if (is == 1) { 1954 while (it.hasNext()) { 1955 for (int i = 0; i < isize; i++) { 1956 final double v = Math.pow(data[it.index + i], vr); 1957 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1958 // data[it.index + i] = 0; // INT_USE 1959 // } else { // INT_USE 1960 data[it.index + i] = v; // PRIM_TYPE_LONG // ADD_CAST 1961 // } // INT_USE 1962 } 1963 } 1964 } else if (is == isize) { 1965 while (it.hasNext()) { 1966 for (int i = 0; i < isize; i++) { 1967 final double v = Math.pow(data[it.index + i], bds.getElementDoubleAbs(i)); 1968 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1969 // data[it.index + i] = 0; // INT_USE 1970 // } else { // INT_USE 1971 data[it.index + i] = v; // PRIM_TYPE_LONG // ADD_CAST 1972 // } // INT_USE 1973 } 1974 } 1975 } 1976 } else { 1977 final BroadcastIterator it = BroadcastIterator.createIterator(this, bds); 1978 it.setOutputDouble(true); 1979 if (bds.isComplex()) { 1980 while (it.hasNext()) { 1981 final Complex zv = new Complex(it.bDouble, bds.getElementDoubleAbs(it.bIndex + 1)); 1982 double v = new Complex(it.aDouble, 0).pow(zv).getReal(); 1983 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1984 // data[it.aIndex] = 0; // INT_USE 1985 // } else { // INT_USE 1986 data[it.aIndex] = v; // PRIM_TYPE_LONG // ADD_CAST 1987 // } // INT_USE 1988 for (int i = 1; i < isize; i++) { 1989 v = new Complex(data[it.aIndex + i], 0).pow(zv).getReal(); 1990 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1991 // data[it.aIndex + i] = 0; // INT_USE 1992 // } else { // INT_USE 1993 data[it.aIndex + i] = v; // PRIM_TYPE_LONG // ADD_CAST 1994 // } // INT_USE 1995 } 1996 } 1997 } else { 1998 while (it.hasNext()) { 1999 double v = Math.pow(it.aDouble, it.bDouble); 2000 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 2001 // data[it.aIndex] = 0; // INT_USE 2002 // } else { // INT_USE 2003 data[it.aIndex] = v; // PRIM_TYPE_LONG // ADD_CAST 2004 // } // INT_USE 2005 for (int i = 1; i < isize; i++) { 2006 v = Math.pow(data[it.aIndex + i], bds.getElementDoubleAbs(it.bIndex + i)); 2007 // if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 2008 // data[it.aIndex + i] = 0; // INT_USE 2009 // } else { // INT_USE 2010 data[it.aIndex + i] = v; // PRIM_TYPE_LONG // ADD_CAST 2011 // } // INT_USE 2012 } 2013 } 2014 } 2015 } 2016 return this; 2017 } 2018 2019 @Override 2020 public double residual(final Object b, final Dataset w, boolean ignoreNaNs) { 2021 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 2022 final BroadcastIterator it = BroadcastIterator.createIterator(this, bds); 2023 it.setOutputDouble(true); 2024 double sum = 0; 2025 double comp = 0; 2026 final int bis = bds.getElementsPerItem(); 2027 2028 if (bis == 1) { 2029 if (w == null) { 2030 while (it.hasNext()) { 2031 final double db = it.bDouble; 2032 double diff = it.aDouble - db; 2033 if (ignoreNaNs) { // REAL_ONLY 2034 if (Double.isNaN(diff)) // REAL_ONLY 2035 continue; // REAL_ONLY 2036 boolean skip = false; // REAL_ONLY 2037 for (int i = 1; i < isize; i++) { // REAL_ONLY 2038 if (Double.isNaN(data[it.aIndex + i])) { // REAL_ONLY 2039 skip = true; // REAL_ONLY 2040 break; // REAL_ONLY 2041 } // REAL_ONLY 2042 } // REAL_ONLY 2043 if (skip) { // REAL_ONLY 2044 continue; // REAL_ONLY 2045 } // REAL_ONLY 2046 } // REAL_ONLY 2047 double err = diff * diff - comp; 2048 double temp = sum + err; 2049 comp = (temp - sum) - err; 2050 sum = temp; 2051 for (int i = 1; i < isize; i++) { 2052 diff = data[it.aIndex + i] - db; 2053 err = diff * diff - comp; 2054 temp = sum + err; 2055 comp = (temp - sum) - err; 2056 sum = temp; 2057 } 2058 } 2059 } else { 2060 IndexIterator itw = w.getIterator(); 2061 while (it.hasNext() && itw.hasNext()) { 2062 final double db = it.bDouble; 2063 double diff = it.aDouble - db; 2064 if (ignoreNaNs) { // REAL_ONLY 2065 if (Double.isNaN(diff)) // REAL_ONLY 2066 continue; // REAL_ONLY 2067 boolean skip = false; // REAL_ONLY 2068 for (int i = 1; i < isize; i++) { // REAL_ONLY 2069 if (Double.isNaN(data[it.aIndex + i])) { // REAL_ONLY 2070 skip = true; // REAL_ONLY 2071 break; // REAL_ONLY 2072 } // REAL_ONLY 2073 } // REAL_ONLY 2074 if (skip) { // REAL_ONLY 2075 continue; // REAL_ONLY 2076 } // REAL_ONLY 2077 } // REAL_ONLY 2078 final double dw = w.getElementDoubleAbs(itw.index); 2079 double err = diff * diff * dw - comp; 2080 double temp = sum + err; 2081 comp = (temp - sum) - err; 2082 sum = temp; 2083 for (int i = 1; i < isize; i++) { 2084 diff = data[it.aIndex + i] - db; 2085 err = diff * diff * dw - comp; 2086 temp = sum + err; 2087 comp = (temp - sum) - err; 2088 sum = temp; 2089 } 2090 } 2091 } 2092 } else { 2093 if (w == null) { 2094 while (it.hasNext()) { 2095 double diff = it.aDouble - it.bDouble; 2096 if (ignoreNaNs) { // REAL_ONLY 2097 if (Double.isNaN(diff)) // REAL_ONLY 2098 continue; // REAL_ONLY 2099 boolean skip = false; // REAL_ONLY 2100 for (int i = 1; i < isize; i++) { // REAL_ONLY 2101 if (Double.isNaN(data[it.aIndex + i]) || Double.isNaN(bds.getElementDoubleAbs(it.bIndex + i))) { // REAL_ONLY 2102 skip = true; // REAL_ONLY 2103 break; // REAL_ONLY 2104 } // REAL_ONLY 2105 } // REAL_ONLY 2106 if (skip) { // REAL_ONLY 2107 continue; // REAL_ONLY 2108 } // REAL_ONLY 2109 } // REAL_ONLY 2110 double err = diff * diff - comp; 2111 double temp = sum + err; 2112 comp = (temp - sum) - err; 2113 sum = temp; 2114 for (int i = 1; i < isize; i++) { 2115 diff = data[it.aIndex + i] - bds.getElementDoubleAbs(it.bIndex + i); 2116 err = diff * diff - comp; 2117 temp = sum + err; 2118 comp = (temp - sum) - err; 2119 sum = temp; 2120 } 2121 } 2122 } else { 2123 IndexIterator itw = w.getIterator(); 2124 while (it.hasNext() && itw.hasNext()) { 2125 double diff = it.aDouble - it.bDouble; 2126 if (ignoreNaNs) { // REAL_ONLY 2127 if (Double.isNaN(diff)) // REAL_ONLY 2128 continue; // REAL_ONLY 2129 boolean skip = false; // REAL_ONLY 2130 for (int i = 1; i < isize; i++) { // REAL_ONLY 2131 if (Double.isNaN(data[it.aIndex + i]) || Double.isNaN(bds.getElementDoubleAbs(it.bIndex + i))) { // REAL_ONLY 2132 skip = true; // REAL_ONLY 2133 break; // REAL_ONLY 2134 } // REAL_ONLY 2135 } // REAL_ONLY 2136 if (skip) { // REAL_ONLY 2137 continue; // REAL_ONLY 2138 } // REAL_ONLY 2139 } // REAL_ONLY 2140 final double dw = w.getElementDoubleAbs(itw.index); 2141 double err = diff * diff * dw - comp; 2142 double temp = sum + err; 2143 comp = (temp - sum) - err; 2144 sum = temp; 2145 for (int i = 1; i < isize; i++) { 2146 diff = data[it.aIndex + i] - bds.getElementDoubleAbs(it.bIndex + i); 2147 err = diff * diff * dw - comp; 2148 temp = sum + err; 2149 comp = (temp - sum) - err; 2150 sum = temp; 2151 } 2152 } 2153 } 2154 } 2155 return sum; 2156 } 2157}