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// This is generated from CompoundDoubleDataset.java by fromcpddouble.py 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 long values // PRIM_TYPE 023 */ 024public class CompoundLongDataset extends AbstractCompoundDataset { 025 // pin UID to base class 026 private static final long serialVersionUID = Dataset.serialVersionUID; 027 028 protected long[] data; // subclass alias // PRIM_TYPE 029 030 @Override 031 protected void setData() { 032 data = (long[]) odata; // PRIM_TYPE 033 } 034 035 protected long[] createArray(final int size) { // PRIM_TYPE 036 long[] array = null; // PRIM_TYPE 037 038 try { 039 array = new long[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.ARRAYINT64; // DATA_TYPE 052 } 053 054 /** 055 * Create a null dataset 056 */ 057 CompoundLongDataset() { 058 } 059 060 /** 061 * Create a null dataset 062 * @param itemSize 063 */ 064 CompoundLongDataset(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 CompoundLongDataset(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 CompoundLongDataset(final CompoundLongDataset 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 CompoundLongDataset(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.getElementLongAbs(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 CompoundLongDataset(final int itemSize, final long[] 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 CompoundLongDataset(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].getElementLongAbs(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].getElementLongAbs(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 CompoundLongDataset(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 long v = dataset.getElementLongAbs(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.getElementLongAbs(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 CompoundLongDataset other = (CompoundLongDataset) 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 CompoundLongDataset clone() { 300 return new CompoundLongDataset(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 CompoundLongDataset createFromObject(final Object obj) { 312 LongDataset result = LongDataset.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 CompoundLongDataset createFromObject(final int itemSize, final Object obj) { 325 LongDataset result = LongDataset.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 CompoundLongDataset ds = new CompoundLongDataset(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 CompoundLongDataset 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 CompoundLongDataset createRange(final int itemSize, final double start, final double stop, 353 final double step) { 354 int size = calcSteps(start, stop, step); 355 CompoundLongDataset result = new CompoundLongDataset(itemSize, new int[] { size }); 356 for (int i = 0; i < size; i++) { 357 result.data[i * result.isize] = (long) (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 CompoundLongDataset ones(final int itemSize, final int... shape) { 367 return new CompoundLongDataset(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 CompoundLongDataset 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.INT64) { // DATA_TYPE 382 logger.error("Dataset type must be long"); // PRIM_TYPE 383 throw new IllegalArgumentException("Dataset type must be long"); // PRIM_TYPE 384 } 385 386 final int[] shape = a.getShapeRef(); 387 if (shape == null) { 388 return new CompoundLongDataset(0); 389 } 390 391 final int rank = shape.length - 1; 392 final int is = rank < 0 ? 1 : shape[rank]; 393 394 CompoundLongDataset result = new CompoundLongDataset(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 LongDataset asNonCompoundDataset(final boolean shareData) { // CLASS_TYPE 406 LongDataset result = new LongDataset(); // 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 CompoundLongDataset fill(final Object obj) { 423 setDirty(); 424 long[] vr = DTypeUtils.toLongArray(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 long[] 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 CompoundLongDataset getView(boolean deepCopyMetadata) { 453 CompoundLongDataset view = new CompoundLongDataset(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 long[] getAbs(final int index) { // PRIM_TYPE 468 long[] result = new long[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 long[] 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 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 long[] dsrc = (long[]) 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 long[] 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 long val) { // PRIM_TYPE 539 setDirty(); 540 data[index] = val; 541 } 542 543 @Override 544 public Object getObject() { 545 return getLongArray(); // PRIM_TYPE 546 } 547 548 @Override 549 public Object getObject(final int i) { 550 return getLongArray(i); // PRIM_TYPE 551 } 552 553 @Override 554 public Object getObject(final int i, final int j) { 555 return getLongArray(i, j); // PRIM_TYPE 556 } 557 558 @Override 559 public Object getObject(final int... pos) { 560 return getLongArray(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] = 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] = 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] = 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] = 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] = 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] = 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] = 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] = 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 long[] result = new long[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("%d", 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("%d", 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 long[] oa = DTypeUtils.toLongArray(obj, isize); // PRIM_TYPE // CLASS_TYPE 877 setAbs(index, oa); 878 } 879 880 @Override 881 public void set(final Object obj) { 882 setItem(DTypeUtils.toLongArray(obj, isize)); // CLASS_TYPE 883 } 884 885 @Override 886 public void set(final Object obj, final int i) { 887 setItem(DTypeUtils.toLongArray(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.toLongArray(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.toLongArray(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 long[] 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 long[] 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 long[] 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 long[] 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] = (long) 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 long[] 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 CompoundLongDataset getSlice(final SliceIterator siter) { 992 CompoundLongDataset result = new CompoundLongDataset(isize, siter.getShape()); 993 long[] 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 LongDataset 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 LongDataset view = new LongDataset(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 LongDataset getElements(int element) { // CLASS_TYPE 1031 final LongDataset elements = new LongDataset(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 long[] elements = ((LongDataset) 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 long[] elements = ((LongDataset) 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 long[] rdata = ((CompoundLongDataset) 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 CompoundLongDataset 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.getElementLongAbs(iter.index + i); // GET_ELEMENT_WITH_CAST 1117 } 1118 } 1119 } else { 1120 while (biter.hasNext() && iter.hasNext()) { 1121 data[biter.index] = ds.getElementLongAbs(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 long[] vr = DTypeUtils.toLongArray(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 CompoundLongDataset 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.getElementLongAbs(oiter.index + i); // GET_ELEMENT_WITH_CAST 1171 } 1172 } 1173 } else { 1174 while (iter.hasNext() && oiter.hasNext()) { 1175 data[iter.index] = ds.getElementLongAbs(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 long[] vr = DTypeUtils.toLongArray(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 CompoundLongDataset 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.getElementLongAbs(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 long[] vr = DTypeUtils.toLongArray(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 CompoundLongDataset 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 long bv = it.bLong; // PRIM_TYPE // BCAST_WITH_CAST d.getElementLongAbs(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.bLong; // BCAST_WITH_CAST d.getElementLongAbs(it.bIndex); 1264 for (int j = 1; j < is; j++) { 1265 data[it.aIndex + j] = d.getElementLongAbs(it.bIndex + j); // GET_ELEMENT_WITH_CAST 1266 } 1267 } 1268 } 1269 } else { 1270 while (it.hasNext()) { 1271 data[it.aIndex] = it.bLong; // BCAST_WITH_CAST d.getElementLongAbs(it.bIndex); 1272 } 1273 } 1274 return this; 1275 } 1276 1277 @Override 1278 public CompoundLongDataset 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.getElementLongAbs(oiter.index + i); // GET_ELEMENT_WITH_CAST 1302 } 1303 } 1304 } else { 1305 while (siter.hasNext() && oiter.hasNext()) { 1306 data[siter.index] = ads.getElementLongAbs(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.getLong(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 long[] val = DTypeUtils.toLongArray(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 long[] vr = DTypeUtils.toLongArray(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 long[] ddata = (long[]) 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 long[] sdata = (long[]) 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 return false; 1396 } 1397 1398 @Override 1399 public boolean containsInfs() { 1400 return false; 1401 } 1402 1403 @Override 1404 public boolean containsInvalidNumbers() { 1405 return false; 1406 } 1407 1408 @Override 1409 public CompoundLongDataset iadd(final Object b) { 1410 setDirty(); 1411 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1412 boolean useLong = bds.getElementClass().equals(Long.class); 1413 int is = bds.getElementsPerItem(); 1414 if (bds.getSize() == 1) { 1415 final IndexIterator it = getIterator(); 1416 final int bOffset = bds.getOffset(); 1417 if (is == 1) { 1418 if (useLong) { 1419 final long lb = bds.getElementLongAbs(bOffset); 1420 while (it.hasNext()) { 1421 for (int i = 0; i < isize; i++) { 1422 data[it.index + i] += lb; 1423 } 1424 } 1425 } else { 1426 final double db = bds.getElementDoubleAbs(bOffset); 1427 while (it.hasNext()) { 1428 for (int i = 0; i < isize; i++) { 1429 data[it.index + i] += db; 1430 } 1431 } 1432 } 1433 } else if (is == isize) { 1434 if (useLong) { 1435 while (it.hasNext()) { 1436 for (int i = 0; i < isize; i++) { 1437 data[it.index + i] += bds.getElementLongAbs(i); 1438 } 1439 } 1440 } else { 1441 while (it.hasNext()) { 1442 for (int i = 0; i < isize; i++) { 1443 data[it.index + i] += bds.getElementDoubleAbs(i); 1444 } 1445 } 1446 } 1447 } else { 1448 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1449 } 1450 } else { 1451 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1452 it.setOutputDouble(!useLong); 1453 if (is == 1) { 1454 if (useLong) { 1455 while (it.hasNext()) { 1456 final long lb = it.bLong; 1457 data[it.aIndex] += lb; 1458 for (int i = 1; i < isize; i++) { 1459 data[it.aIndex + i] += lb; 1460 } 1461 } 1462 } else { 1463 while (it.hasNext()) { 1464 final double db = it.bDouble; 1465 data[it.aIndex] += db; 1466 for (int i = 1; i < isize; i++) { 1467 data[it.aIndex + i] += db; 1468 } 1469 } 1470 } 1471 } else if (is == isize) { 1472 if (useLong) { 1473 while (it.hasNext()) { 1474 data[it.aIndex] += it.bLong; 1475 for (int i = 1; i < isize; i++) { 1476 data[it.aIndex + i] += bds.getElementLongAbs(it.bIndex + i); 1477 } 1478 } 1479 } else { 1480 while (it.hasNext()) { 1481 data[it.aIndex] += it.bDouble; 1482 for (int i = 1; i < isize; i++) { 1483 data[it.aIndex + i] += bds.getElementDoubleAbs(it.bIndex + i); 1484 } 1485 } 1486 } 1487 } else { 1488 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1489 } 1490 } 1491 return this; 1492 } 1493 1494 @Override 1495 public CompoundLongDataset isubtract(final Object b) { 1496 setDirty(); 1497 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1498 boolean useLong = bds.getElementClass().equals(Long.class); 1499 int is = bds.getElementsPerItem(); 1500 if (bds.getSize() == 1) { 1501 final IndexIterator it = getIterator(); 1502 final int bOffset = bds.getOffset(); 1503 if (is == 1) { 1504 if (useLong) { 1505 final long lb = bds.getElementLongAbs(bOffset); 1506 while (it.hasNext()) { 1507 for (int i = 0; i < isize; i++) { 1508 data[it.index + i] -= lb; 1509 } 1510 } 1511 } else { 1512 final double db = bds.getElementDoubleAbs(bOffset); 1513 while (it.hasNext()) { 1514 for (int i = 0; i < isize; i++) { 1515 data[it.index + i] -= db; 1516 } 1517 } 1518 } 1519 } else if (is == isize) { 1520 if (useLong) { 1521 while (it.hasNext()) { 1522 for (int i = 0; i < isize; i++) { 1523 data[it.index + i] -= bds.getElementLongAbs(i); 1524 } 1525 } 1526 } else { 1527 while (it.hasNext()) { 1528 for (int i = 0; i < isize; i++) { 1529 data[it.index + i] -= bds.getElementDoubleAbs(i); 1530 } 1531 } 1532 } 1533 } else { 1534 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1535 } 1536 } else { 1537 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1538 it.setOutputDouble(!useLong); 1539 if (is == 1) { 1540 if (useLong) { 1541 while (it.hasNext()) { 1542 final long lb = it.bLong; 1543 data[it.aIndex] += lb; 1544 for (int i = 1; i < isize; i++) { 1545 data[it.aIndex + i] -= lb; 1546 } 1547 } 1548 } else { 1549 while (it.hasNext()) { 1550 final double db = it.bDouble; 1551 data[it.aIndex] += db; 1552 for (int i = 1; i < isize; i++) { 1553 data[it.aIndex + i] -= db; 1554 } 1555 } 1556 } 1557 } else if (is == isize) { 1558 if (useLong) { 1559 while (it.hasNext()) { 1560 data[it.aIndex] += it.bLong; 1561 for (int i = 1; i < isize; i++) { 1562 data[it.aIndex + i] -= bds.getElementLongAbs(it.bIndex + i); 1563 } 1564 } 1565 } else { 1566 while (it.hasNext()) { 1567 data[it.aIndex] += it.bDouble; 1568 for (int i = 1; i < isize; i++) { 1569 data[it.aIndex + i] -= bds.getElementDoubleAbs(it.bIndex + i); 1570 } 1571 } 1572 } 1573 } else { 1574 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1575 } 1576 } 1577 return this; 1578 } 1579 1580 @Override 1581 public CompoundLongDataset imultiply(final Object b) { 1582 setDirty(); 1583 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1584 boolean useLong = bds.getElementClass().equals(Long.class); 1585 int is = bds.getElementsPerItem(); 1586 if (bds.getSize() == 1) { 1587 final IndexIterator it = getIterator(); 1588 final int bOffset = bds.getOffset(); 1589 if (useLong) { 1590 if (is == 1) { 1591 final long lb = bds.getElementLongAbs(bOffset); 1592 while (it.hasNext()) { 1593 for (int i = 0; i < isize; i++) { 1594 data[it.index + i] *= lb; 1595 } 1596 } 1597 } else if (is == isize) { 1598 while (it.hasNext()) { 1599 for (int i = 0; i < isize; i++) { 1600 data[it.index + i] *= bds.getElementLongAbs(i); 1601 } 1602 } 1603 } else { 1604 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1605 } 1606 } else { 1607 if (is == 1) { 1608 final double db = bds.getElementDoubleAbs(bOffset); 1609 while (it.hasNext()) { 1610 for (int i = 0; i < isize; i++) { 1611 data[it.index + i] *= db; 1612 } 1613 } 1614 } else if (is == isize) { 1615 while (it.hasNext()) { 1616 for (int i = 0; i < isize; i++) { 1617 data[it.index + i] *= bds.getElementDoubleAbs(i); 1618 } 1619 } 1620 } else { 1621 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1622 } 1623 } 1624 } else { 1625 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1626 it.setOutputDouble(!useLong); 1627 if (useLong) { 1628 if (is == 1) { 1629 while (it.hasNext()) { 1630 final double lb = it.bLong; 1631 for (int i = 0; i < isize; i++) { 1632 data[it.aIndex + i] *= lb; 1633 } 1634 } 1635 } else if (is == isize) { 1636 while (it.hasNext()) { 1637 data[it.aIndex] *= it.bLong; 1638 for (int i = 1; i < isize; i++) { 1639 data[it.aIndex + i] *= bds.getElementLongAbs(it.bIndex + 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 } else { 1646 if (is == 1) { 1647 while (it.hasNext()) { 1648 final double db = it.bDouble; 1649 for (int i = 0; i < isize; i++) { 1650 data[it.aIndex + i] *= db; 1651 } 1652 } 1653 } else if (is == isize) { 1654 while (it.hasNext()) { 1655 data[it.aIndex] *= it.bDouble; 1656 for (int i = 1; i < isize; i++) { 1657 data[it.aIndex + i] *= bds.getElementDoubleAbs(it.bIndex + i); 1658 } 1659 } 1660 } else { 1661 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1662 } 1663 } 1664 } 1665 return this; 1666 } 1667 1668 @Override 1669 public CompoundLongDataset idivide(final Object b) { 1670 setDirty(); 1671 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1672 boolean useLong = bds.getElementClass().equals(Long.class); 1673 int is = bds.getElementsPerItem(); 1674 if (bds.getSize() == 1) { 1675 final IndexIterator it = getIterator(); 1676 final int bOffset = bds.getOffset(); 1677 if (useLong) { 1678 if (is == 1) { 1679 final long lb = bds.getElementLongAbs(bOffset); 1680 if (lb == 0) { // INT_USE 1681 fill(0); // INT_USE 1682 } else { // INT_USE 1683 while (it.hasNext()) { 1684 for (int i = 0; i < isize; i++) { 1685 data[it.index + i] /= lb; 1686 } 1687 } 1688 } // INT_USE 1689 } else if (is == isize) { 1690 while (it.hasNext()) { 1691 for (int i = 0; i < isize; i++) { 1692 final long lb = bds.getElementLongAbs(i); 1693 try { 1694 data[it.index + i] /= lb; // INT_EXCEPTION 1695 } catch (ArithmeticException e) { 1696 data[it.index + i] = 0; 1697 } 1698 } 1699 } 1700 } else { 1701 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1702 } 1703 } else { 1704 if (is == 1) { 1705 final double db = bds.getElementDoubleAbs(bOffset); 1706 if (db == 0) { // INT_USE 1707 fill(0); // INT_USE 1708 } else { // INT_USE 1709 while (it.hasNext()) { 1710 for (int i = 0; i < isize; i++) { 1711 data[it.index + i] /= db; 1712 } 1713 } 1714 } // INT_USE 1715 } else if (is == isize) { 1716 while (it.hasNext()) { 1717 for (int i = 0; i < isize; i++) { 1718 final double db = bds.getElementDoubleAbs(i); 1719 try { 1720 data[it.index + i] /= db; // INT_EXCEPTION 1721 } catch (ArithmeticException e) { 1722 data[it.index + i] = 0; 1723 } 1724 } 1725 } 1726 } else { 1727 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1728 } 1729 } 1730 } else { 1731 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1732 it.setOutputDouble(!useLong); 1733 if (useLong) { 1734 if (is == 1) { 1735 while (it.hasNext()) { 1736 final long lb = it.bLong; 1737 if (lb == 0) { // INT_USE 1738 for (int i = 0; i < isize; i++) { // INT_USE 1739 data[it.aIndex + i] = 0; // INT_USE 1740 }// INT_USE 1741 } else { // INT_USE 1742 for (int i = 0; i < isize; i++) { 1743 data[it.aIndex + i] /= lb; 1744 } 1745 } // INT_USE 1746 } 1747 } else if (is == isize) { 1748 while (it.hasNext()) { 1749 for (int i = 0; i < isize; i++) { 1750 final long lb = bds.getElementLongAbs(it.bIndex + i); 1751 try { 1752 data[it.aIndex + i] /= lb; // INT_EXCEPTION 1753 } catch (ArithmeticException e) { 1754 data[it.aIndex + i] = 0; 1755 } 1756 } 1757 } 1758 } else { 1759 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1760 } 1761 } else { 1762 if (is == 1) { 1763 while (it.hasNext()) { 1764 final double db = it.bDouble; 1765 if (db == 0) { // INT_USE 1766 for (int i = 0; i < isize; i++) { // INT_USE 1767 data[it.aIndex + i] = 0; // INT_USE 1768 }// INT_USE 1769 } else { // INT_USE 1770 for (int i = 0; i < isize; i++) { 1771 data[it.aIndex + i] /= db; 1772 } 1773 } // INT_USE 1774 } 1775 } else if (is == isize) { 1776 while (it.hasNext()) { 1777 for (int i = 0; i < isize; i++) { 1778 final double db = bds.getElementDoubleAbs(it.bIndex + i); 1779 try { 1780 data[it.aIndex + i] /= db; // INT_EXCEPTION 1781 } catch (ArithmeticException e) { 1782 data[it.aIndex + i] = 0; 1783 } 1784 } 1785 } 1786 } else { 1787 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1788 } 1789 } 1790 } 1791 return this; 1792 } 1793 1794 @Override 1795 public CompoundLongDataset ifloor() { 1796 return this; 1797 } 1798 1799 @Override 1800 public CompoundLongDataset iremainder(final Object b) { 1801 setDirty(); 1802 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1803 boolean useLong = bds.getElementClass().equals(Long.class); 1804 int is = bds.getElementsPerItem(); 1805 if (bds.getSize() == 1) { 1806 final IndexIterator it = getIterator(); 1807 final int bOffset = bds.getOffset(); 1808 if (useLong) { 1809 if (is == 1) { 1810 final long lb = bds.getElementLongAbs(bOffset); 1811 if (lb == 0) { // INT_USE 1812 fill(0); // INT_USE 1813 } else { // INT_USE 1814 while (it.hasNext()) { 1815 for (int i = 0; i < isize; i++) { 1816 data[it.index + i] %= lb; 1817 } 1818 } 1819 } // INT_USE 1820 } else if (is == isize) { 1821 while (it.hasNext()) { 1822 for (int i = 0; i < isize; i++) { 1823 try { 1824 data[it.index + i] %= bds.getElementLongAbs(i); // INT_EXCEPTION 1825 } catch (ArithmeticException e) { 1826 data[it.index + i] = 0; 1827 } 1828 } 1829 } 1830 } else { 1831 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1832 } 1833 } else { 1834 if (is == 1) { 1835 final double db = bds.getElementDoubleAbs(bOffset); 1836 if (db == 0) { // INT_USE 1837 fill(0); // INT_USE 1838 } else { // INT_USE 1839 while (it.hasNext()) { 1840 for (int i = 0; i < isize; i++) { 1841 data[it.index + i] %= db; 1842 } 1843 } 1844 } // INT_USE 1845 } else if (is == isize) { 1846 while (it.hasNext()) { 1847 for (int i = 0; i < isize; i++) { 1848 try { 1849 data[it.index + i] %= bds.getElementDoubleAbs(i); // INT_EXCEPTION 1850 } catch (ArithmeticException e) { 1851 data[it.index + i] = 0; 1852 } 1853 } 1854 } 1855 } else { 1856 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1857 } 1858 } 1859 } else { 1860 final BroadcastSelfIterator it = BroadcastSelfIterator.createIterator(this, bds); 1861 it.setOutputDouble(!useLong); 1862 if (useLong) { 1863 if (is == 1) { 1864 while (it.hasNext()) { 1865 final long lb = it.bLong; 1866 if (lb == 0) { // INT_USE 1867 for (int i = 0; i < isize; i++) // INT_USE 1868 data[it.aIndex + i] = 0; // INT_USE 1869 } else { // INT_USE 1870 for (int i = 0; i < isize; i++) 1871 data[it.aIndex + i] %= lb; 1872 } // INT_USE 1873 } 1874 } else if (is == isize) { 1875 while (it.hasNext()) { 1876 for (int i = 0; i < isize; i++) { 1877 final long lb = bds.getElementLongAbs(it.bIndex + i); 1878 try { 1879 data[it.aIndex + i] %= lb; // INT_EXCEPTION 1880 } catch (ArithmeticException e) { 1881 data[it.aIndex + i] = 0; 1882 } 1883 } 1884 } 1885 } else { 1886 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1887 } 1888 } else { 1889 if (is == 1) { 1890 while (it.hasNext()) { 1891 final double db = it.bDouble; 1892 if (db == 0) { // INT_USE 1893 for (int i = 0; i < isize; i++) // INT_USE 1894 data[it.aIndex + i] = 0; // INT_USE 1895 } else { // INT_USE 1896 for (int i = 0; i < isize; i++) { 1897 data[it.aIndex + i] %= db; 1898 } 1899 } // INT_USE 1900 } 1901 } else if (is == isize) { 1902 while (it.hasNext()) { 1903 for (int i = 0; i < isize; i++) { 1904 final double db = bds.getElementDoubleAbs(it.bIndex + i); 1905 try { 1906 data[it.aIndex + i] %= db; // INT_EXCEPTION 1907 } catch (ArithmeticException e) { 1908 data[it.aIndex + i] = 0; 1909 } 1910 } 1911 } 1912 } else { 1913 throw new IllegalArgumentException("Argument does not have same number of elements per item or is not a non-compound dataset"); 1914 } 1915 } 1916 } 1917 return this; 1918 } 1919 1920 @Override 1921 public CompoundLongDataset ipower(final Object b) { 1922 setDirty(); 1923 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 1924 final int is = bds.getElementsPerItem(); 1925 if (bds.getSize() == 1) { 1926 final int bOffset = bds.getOffset(); 1927 final double vr = bds.getElementDoubleAbs(bOffset); 1928 final IndexIterator it = getIterator(); 1929 if (bds.isComplex()) { 1930 final double vi = bds.getElementDoubleAbs(bOffset + 1); 1931 if (vi == 0) { 1932 while (it.hasNext()) { 1933 for (int i = 0; i < isize; i++) { 1934 final double v = Math.pow(data[it.index + i], vr); 1935 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1936 data[it.index + i] = 0; // INT_USE 1937 } else { // INT_USE 1938 data[it.index + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1939 } // INT_USE 1940 } 1941 } 1942 } else { 1943 final Complex zv = new Complex(vr, vi); 1944 while (it.hasNext()) { 1945 for (int i = 0; i < isize; i++) { 1946 Complex zd = new Complex(data[it.index + i], 0); 1947 final double v = zd.pow(zv).getReal(); 1948 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1949 data[it.index + i] = 0; // INT_USE 1950 } else { // INT_USE 1951 data[it.index + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1952 } // INT_USE 1953 } 1954 } 1955 } 1956 } else if (is == 1) { 1957 while (it.hasNext()) { 1958 for (int i = 0; i < isize; i++) { 1959 final double v = Math.pow(data[it.index + i], vr); 1960 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1961 data[it.index + i] = 0; // INT_USE 1962 } else { // INT_USE 1963 data[it.index + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1964 } // INT_USE 1965 } 1966 } 1967 } else if (is == isize) { 1968 while (it.hasNext()) { 1969 for (int i = 0; i < isize; i++) { 1970 final double v = Math.pow(data[it.index + i], bds.getElementDoubleAbs(i)); 1971 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1972 data[it.index + i] = 0; // INT_USE 1973 } else { // INT_USE 1974 data[it.index + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1975 } // INT_USE 1976 } 1977 } 1978 } 1979 } else { 1980 final BroadcastIterator it = BroadcastIterator.createIterator(this, bds); 1981 it.setOutputDouble(true); 1982 if (bds.isComplex()) { 1983 while (it.hasNext()) { 1984 final Complex zv = new Complex(it.bDouble, bds.getElementDoubleAbs(it.bIndex + 1)); 1985 double v = new Complex(it.aDouble, 0).pow(zv).getReal(); 1986 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1987 data[it.aIndex] = 0; // INT_USE 1988 } else { // INT_USE 1989 data[it.aIndex] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1990 } // INT_USE 1991 for (int i = 1; i < isize; i++) { 1992 v = new Complex(data[it.aIndex + i], 0).pow(zv).getReal(); 1993 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 1994 data[it.aIndex + i] = 0; // INT_USE 1995 } else { // INT_USE 1996 data[it.aIndex + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 1997 } // INT_USE 1998 } 1999 } 2000 } else { 2001 while (it.hasNext()) { 2002 double v = Math.pow(it.aDouble, it.bDouble); 2003 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 2004 data[it.aIndex] = 0; // INT_USE 2005 } else { // INT_USE 2006 data[it.aIndex] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 2007 } // INT_USE 2008 for (int i = 1; i < isize; i++) { 2009 v = Math.pow(data[it.aIndex + i], bds.getElementDoubleAbs(it.bIndex + i)); 2010 if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_USE 2011 data[it.aIndex + i] = 0; // INT_USE 2012 } else { // INT_USE 2013 data[it.aIndex + i] = (long) v; // PRIM_TYPE_LONG // ADD_CAST 2014 } // INT_USE 2015 } 2016 } 2017 } 2018 } 2019 return this; 2020 } 2021 2022 @Override 2023 public double residual(final Object b, final Dataset w, boolean ignoreNaNs) { 2024 Dataset bds = b instanceof Dataset ? (Dataset) b : DatasetFactory.createFromObject(b); 2025 final BroadcastIterator it = BroadcastIterator.createIterator(this, bds); 2026 it.setOutputDouble(true); 2027 double sum = 0; 2028 double comp = 0; 2029 final int bis = bds.getElementsPerItem(); 2030 2031 if (bis == 1) { 2032 if (w == null) { 2033 while (it.hasNext()) { 2034 final double db = it.bDouble; 2035 double diff = it.aDouble - db; 2036 double err = diff * diff - comp; 2037 double temp = sum + err; 2038 comp = (temp - sum) - err; 2039 sum = temp; 2040 for (int i = 1; i < isize; i++) { 2041 diff = data[it.aIndex + i] - db; 2042 err = diff * diff - comp; 2043 temp = sum + err; 2044 comp = (temp - sum) - err; 2045 sum = temp; 2046 } 2047 } 2048 } else { 2049 IndexIterator itw = w.getIterator(); 2050 while (it.hasNext() && itw.hasNext()) { 2051 final double db = it.bDouble; 2052 double diff = it.aDouble - db; 2053 final double dw = w.getElementDoubleAbs(itw.index); 2054 double err = diff * diff * dw - comp; 2055 double temp = sum + err; 2056 comp = (temp - sum) - err; 2057 sum = temp; 2058 for (int i = 1; i < isize; i++) { 2059 diff = data[it.aIndex + i] - db; 2060 err = diff * diff * dw - comp; 2061 temp = sum + err; 2062 comp = (temp - sum) - err; 2063 sum = temp; 2064 } 2065 } 2066 } 2067 } else { 2068 if (w == null) { 2069 while (it.hasNext()) { 2070 double diff = it.aDouble - it.bDouble; 2071 double err = diff * diff - comp; 2072 double temp = sum + err; 2073 comp = (temp - sum) - err; 2074 sum = temp; 2075 for (int i = 1; i < isize; i++) { 2076 diff = data[it.aIndex + i] - bds.getElementDoubleAbs(it.bIndex + i); 2077 err = diff * diff - comp; 2078 temp = sum + err; 2079 comp = (temp - sum) - err; 2080 sum = temp; 2081 } 2082 } 2083 } else { 2084 IndexIterator itw = w.getIterator(); 2085 while (it.hasNext() && itw.hasNext()) { 2086 double diff = it.aDouble - it.bDouble; 2087 final double dw = w.getElementDoubleAbs(itw.index); 2088 double err = diff * diff * dw - comp; 2089 double temp = sum + err; 2090 comp = (temp - sum) - err; 2091 sum = temp; 2092 for (int i = 1; i < isize; i++) { 2093 diff = data[it.aIndex + i] - bds.getElementDoubleAbs(it.bIndex + i); 2094 err = diff * diff * dw - comp; 2095 temp = sum + err; 2096 comp = (temp - sum) - err; 2097 sum = temp; 2098 } 2099 } 2100 } 2101 } 2102 return sum; 2103 } 2104}