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