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 013package org.eclipse.january.dataset; 014 015import java.math.BigInteger; 016import java.util.Date; 017import java.util.List; 018 019public class DatasetFactory { 020 021 /** 022 * Create dataset with items ranging from 0 up to given stop in steps of 1 023 * @param stop stop value is <strong>not</strong> included 024 * @return a new double dataset of given shape and type, filled with values determined by parameters 025 */ 026 public static DoubleDataset createRange(final double stop) { 027 return createRange(DoubleDataset.class, 0, stop, 1); 028 } 029 030 /** 031 * Create dataset with items ranging from given start up to given stop in given steps 032 * @param start 033 * @param stop stop value is <strong>not</strong> included 034 * @param step spacing between items 035 * @return a new 1D dataset of given type, filled with values determined by parameters 036 * @since 2.1 037 */ 038 public static DoubleDataset createRange(final double start, final double stop, final double step) { 039 return createRange(DoubleDataset.class, start, stop, step); 040 } 041 042 /** 043 * Create dataset with items ranging from 0 up to given stop in steps of 1 044 * @param stop stop value is <strong>not</strong> included 045 * @param dtype 046 * @return a new dataset of given shape and type, filled with values determined by parameters 047 * 048 * @deprecated Please use the class-based methods in DatasetFactory, 049 * such as {@link #createRange(Class, double)} 050 */ 051 @Deprecated 052 public static Dataset createRange(final double stop, final int dtype) { 053 return createRange(0, stop, 1, dtype); 054 } 055 056 /** 057 * Create dataset with items ranging from given start up to given stop in given steps 058 * @param start 059 * @param stop stop value is <strong>not</strong> included 060 * @param step spacing between items 061 * @param dtype 062 * @return a new 1D dataset of given type, filled with values determined by parameters 063 * 064 * @deprecated Please use the class-based methods in DatasetFactory, 065 * such as {@link #createRange(Class, double, double, double)} 066 */ 067 @Deprecated 068 public static Dataset createRange(final double start, final double stop, final double step, final int dtype) { 069 if ((step > 0) != (start <= stop)) { 070 throw new IllegalArgumentException("Invalid parameters: start and stop must be in correct order for step"); 071 } 072 073 switch (dtype) { 074 case Dataset.BOOL: 075 break; 076 case Dataset.INT8: 077 return ByteDataset.createRange(start, stop, step); 078 case Dataset.INT16: 079 return ShortDataset.createRange(start, stop, step); 080 case Dataset.INT32: 081 return IntegerDataset.createRange(start, stop, step); 082 case Dataset.INT64: 083 return LongDataset.createRange(start, stop, step); 084 case Dataset.FLOAT32: 085 return FloatDataset.createRange(start, stop, step); 086 case Dataset.FLOAT64: 087 return DoubleDataset.createRange(start, stop, step); 088 case Dataset.COMPLEX64: 089 return ComplexFloatDataset.createRange(start, stop, step); 090 case Dataset.COMPLEX128: 091 return ComplexDoubleDataset.createRange(start, stop, step); 092 } 093 throw new IllegalArgumentException("dtype not known"); 094 } 095 096 /** 097 * Create compound dataset with items of given size ranging from 0 up to given stop in steps of 1 098 * @param itemSize 099 * @param stop stop value is <strong>not</strong> included 100 * @param dtype 101 * @return a new dataset of given shape and type, filled with values determined by parameters 102 * 103 * @deprecated Please use the class-based methods in DatasetFactory, 104 * such as {@link #createRange(Class, double, double, double)} 105 */ 106 @Deprecated 107 public static CompoundDataset createRange(final int itemSize, final double stop, final int dtype) { 108 return createRange(itemSize, 0, stop, 1, dtype); 109 } 110 111 /** 112 * Create compound dataset with items of given size ranging from given start up to given stop in given steps 113 * @param itemSize 114 * @param start 115 * @param stop stop value is <strong>not</strong> included 116 * @param step spacing between items 117 * @param dtype 118 * @return a new 1D dataset of given type, filled with values determined by parameters 119 * 120 * @deprecated Please use the class-based methods in DatasetFactory, 121 * such as {@link #createRange(Class, double, double, double)} 122 */ 123 @Deprecated 124 public static CompoundDataset createRange(final int itemSize, final double start, final double stop, final double step, final int dtype) { 125 if (itemSize < 1) { 126 throw new IllegalArgumentException("Item size must be greater or equal to 1"); 127 } 128 if ((step > 0) != (start <= stop)) { 129 throw new IllegalArgumentException("Invalid parameters: start and stop must be in correct order for step"); 130 } 131 132 switch (dtype) { 133 case Dataset.BOOL: 134 break; 135 case Dataset.ARRAYINT8: 136 case Dataset.INT8: 137 return CompoundIntegerDataset.createRange(itemSize, start, stop, step); 138 case Dataset.ARRAYINT16: 139 case Dataset.INT16: 140 return CompoundShortDataset.createRange(itemSize, start, stop, step); 141 case Dataset.ARRAYINT32: 142 case Dataset.INT32: 143 return CompoundIntegerDataset.createRange(itemSize, start, stop, step); 144 case Dataset.ARRAYINT64: 145 case Dataset.INT64: 146 return CompoundLongDataset.createRange(itemSize, start, stop, step); 147 case Dataset.ARRAYFLOAT32: 148 case Dataset.FLOAT32: 149 return CompoundFloatDataset.createRange(itemSize, start, stop, step); 150 case Dataset.ARRAYFLOAT64: 151 case Dataset.FLOAT64: 152 return CompoundDoubleDataset.createRange(itemSize, start, stop, step); 153 case Dataset.COMPLEX64: 154 if (itemSize != 2) { 155 throw new IllegalArgumentException("Item size must be equal to 2"); 156 } 157 return ComplexFloatDataset.createRange(start, stop, step); 158 case Dataset.COMPLEX128: 159 if (itemSize != 2) { 160 throw new IllegalArgumentException("Item size must be equal to 2"); 161 } 162 return ComplexFloatDataset.createRange(start, stop, step); 163 } 164 throw new IllegalArgumentException("dtype not known"); 165 } 166 167 /** 168 * Create a dataset from object (automatically detect dataset type) 169 * 170 * @param obj 171 * can be Java list, array or Number 172 * @return dataset 173 */ 174 public static Dataset createFromObject(Object obj) { 175 return createFromObject(obj, null); 176 } 177 178 /** 179 * Create a dataset from object (automatically detect dataset type) 180 * 181 * @param obj 182 * can be Java list, array or Number 183 * @param shape can be null 184 * @return dataset 185 */ 186 public static Dataset createFromObject(Object obj, int... shape) { 187 if (obj instanceof IDataset) { 188 Dataset d = DatasetUtils.convertToDataset((IDataset) obj); 189 if (shape != null) { 190 d.setShape(shape); 191 } 192 return d; 193 } 194 if (obj instanceof BigInteger) { 195 obj = ((BigInteger) obj).longValue(); 196 } 197 198 final int dtype = DTypeUtils.getDTypeFromObject(obj); 199 return createFromObject(dtype, obj, shape); 200 } 201 202 /** 203 * Create a dataset from object (automatically detect dataset type) 204 * @param isUnsigned 205 * if true, interpret integer values as unsigned by increasing element bit width if required 206 * @param obj 207 * can be a Java list, array or Number 208 * @return dataset 209 */ 210 public static Dataset createFromObject(boolean isUnsigned, final Object obj) { 211 Dataset a = createFromObject(obj); 212 if (isUnsigned) { 213 a = DatasetUtils.makeUnsigned(a, true); 214 } 215 return a; 216 } 217 218 /** 219 * Create a dataset from object 220 * @param dtype 221 * @param obj 222 * can be a Java list, array or Number 223 * @return dataset 224 * @throws IllegalArgumentException if dataset type is not known 225 * 226 * @deprecated Please use the class-based methods in DatasetFactory, 227 * such as {@link #createFromObject(Class, Object, int...)} 228 */ 229 @Deprecated 230 public static Dataset createFromObject(final int dtype, final Object obj) { 231 return createFromObject(dtype, obj, null); 232 } 233 234 /** 235 * Create a dataset from object 236 * @param dtype 237 * @param obj 238 * can be a Java list, array or Number 239 * @param shape can be null 240 * @return dataset 241 * @throws IllegalArgumentException if dataset type is not known 242 * 243 * @deprecated Please use the class-based methods in DatasetFactory, 244 * such as {@link #createFromObject(Class, Object, int...)} 245 */ 246 @Deprecated 247 public static Dataset createFromObject(final int dtype, final Object obj, final int... shape) { 248 return createFromObject(1, dtype, obj, shape); 249 } 250 251 /** 252 * Create a dataset from object 253 * @param itemSize 254 * @param dtype 255 * @param obj 256 * can be a Java list, array or Number 257 * @param shape can be null 258 * @return dataset 259 * @throws IllegalArgumentException if dataset type is not known 260 * 261 * @deprecated Please use the class-based methods in DatasetFactory, 262 * such as {@link #createFromObject(int, Class, Object, int...)} 263 */ 264 @Deprecated 265 public static Dataset createFromObject(final int itemSize, final int dtype, final Object obj, final int... shape) { 266 Dataset d = null; 267 268 if (obj instanceof IDataset) { 269 d = itemSize == 1 ? DatasetUtils.cast((IDataset) obj, dtype) : 270 DatasetUtils.cast((IDataset) obj, false, dtype, itemSize); 271 } else { 272 // primitive arrays 273 Class<? extends Object> ca = obj == null ? null : obj.getClass().getComponentType(); 274 if (ca != null && (ca.isPrimitive() || ca.equals(String.class))) { 275 switch (dtype) { 276 case Dataset.COMPLEX64: 277 return new ComplexFloatDataset(DTypeUtils.toFloatArray(obj, DTypeUtils.getLength(obj)), shape); 278 case Dataset.COMPLEX128: 279 return new ComplexDoubleDataset(DTypeUtils.toDoubleArray(obj, DTypeUtils.getLength(obj)), shape); 280 default: 281 d = createFromPrimitiveArray(DTypeUtils.getDTypeFromClass(ca), obj); 282 if (!DTypeUtils.isDTypeElemental(dtype)) { 283 d = DatasetUtils.createCompoundDataset(d, dtype == Dataset.RGB ? 3 : itemSize); 284 if (dtype == Dataset.RGB && d.getSize() == 1) { // special case of allowing a zero-rank RGB dataset 285 d.setShape(); 286 } 287 } 288 d = DatasetUtils.cast(d, dtype); 289 } 290 } else { 291 switch (dtype) { 292 case Dataset.BOOL: 293 d = BooleanDataset.createFromObject(obj); 294 break; 295 case Dataset.INT8: 296 d = ByteDataset.createFromObject(obj); 297 break; 298 case Dataset.INT16: 299 d = ShortDataset.createFromObject(obj); 300 break; 301 case Dataset.INT32: 302 d = IntegerDataset.createFromObject(obj); 303 break; 304 case Dataset.INT64: 305 d = LongDataset.createFromObject(obj); 306 break; 307 case Dataset.ARRAYINT8: 308 d = CompoundByteDataset.createFromObject(itemSize, obj); 309 break; 310 case Dataset.ARRAYINT16: 311 d = CompoundShortDataset.createFromObject(itemSize, obj); 312 break; 313 case Dataset.ARRAYINT32: 314 d = CompoundIntegerDataset.createFromObject(itemSize, obj); 315 break; 316 case Dataset.ARRAYINT64: 317 d = CompoundLongDataset.createFromObject(itemSize, obj); 318 break; 319 case Dataset.FLOAT32: 320 d = FloatDataset.createFromObject(obj); 321 break; 322 case Dataset.FLOAT64: 323 d = DoubleDataset.createFromObject(obj); 324 break; 325 case Dataset.ARRAYFLOAT32: 326 d = CompoundFloatDataset.createFromObject(itemSize, obj); 327 break; 328 case Dataset.ARRAYFLOAT64: 329 d = CompoundDoubleDataset.createFromObject(itemSize, obj); 330 break; 331 case Dataset.COMPLEX64: 332 d = ComplexFloatDataset.createFromObject(obj); 333 break; 334 case Dataset.COMPLEX128: 335 d = ComplexDoubleDataset.createFromObject(obj); 336 break; 337 case Dataset.DATE: 338 d = DateDatasetImpl.createFromObject(obj); 339 break; 340 case Dataset.STRING: 341 d = StringDataset.createFromObject(obj); 342 break; 343 case Dataset.OBJECT: 344 d = ObjectDataset.createFromObject(obj); 345 break; 346 case Dataset.RGB: 347 d = RGBDataset.createFromObject(obj); 348 break; 349 default: 350 throw new IllegalArgumentException("Dataset type is not known"); 351 } 352 } 353 } 354 355 if (shape != null && !(shape.length == 0 && d.getSize() > 1)) { // allow zero-rank datasets 356 d.setShape(shape); 357 } 358 return d; 359 } 360 361 private static Dataset createFromPrimitiveArray(final int dtype, final Object array) { 362 switch (dtype) { 363 case Dataset.BOOL: 364 return new BooleanDataset((boolean []) array); 365 case Dataset.INT8: 366 return new ByteDataset((byte []) array); 367 case Dataset.INT16: 368 return new ShortDataset((short []) array); 369 case Dataset.INT32: 370 return new IntegerDataset((int []) array, null); 371 case Dataset.INT64: 372 return new LongDataset((long []) array); 373 case Dataset.FLOAT32: 374 return new FloatDataset((float []) array); 375 case Dataset.FLOAT64: 376 return new DoubleDataset((double []) array); 377 case Dataset.STRING: 378 return new StringDataset((String []) array); 379 case Dataset.DATE: 380 return new DateDatasetImpl((Date []) array); 381 default: 382 return null; 383 } 384 } 385 386 /** 387 * Create dataset of appropriate type from list 388 * 389 * @param objectList 390 * @return dataset filled with values from list 391 */ 392 public static Dataset createFromList(List<?> objectList) { 393 if (objectList == null || objectList.size() == 0) { 394 throw new IllegalArgumentException("No list or zero-length list given"); 395 } 396 397 Object obj = null; 398 for (Object o : objectList) { 399 if (o != null) { 400 obj = o; 401 break; 402 } 403 } 404 if (obj == null) { 405 return zeros(ObjectDataset.class, objectList.size()); 406 } 407 408 Class<? extends Object> clazz = obj.getClass(); 409 if (DTypeUtils.isClassSupportedAsElement(clazz)) { 410 int dtype = DTypeUtils.getDTypeFromClass(clazz); 411 return createFromList(dtype, objectList); 412 } 413 414 return createFromObject(objectList); 415 } 416 417 /** 418 * Create dataset of given type from list 419 * 420 * @param dtype 421 * @param objectList 422 * @return dataset filled with values from list 423 * 424 * @deprecated Please use the class-based methods in DatasetFactory, 425 * such as {@link #createFromList(Class, List)} 426 */ 427 @Deprecated 428 public static Dataset createFromList(final int dtype, List<?> objectList) { 429 int len = objectList.size(); 430 Dataset result = zeros(new int[] { len }, dtype); 431 432 for (int i = 0; i < len; i++) { 433 result.setObjectAbs(i, objectList.get(i)); 434 } 435 return result; 436 } 437 438 /** 439 * Create compound dataset of given type from given parts 440 * 441 * @param objects 442 * @return compound dataset 443 */ 444 public static CompoundDataset createCompoundDataset(Object... objects) { 445 Dataset[] datasets = new Dataset[objects.length]; 446 for (int i = 0; i < objects.length; i++) { 447 datasets[i] = createFromObject(objects[i]); 448 } 449 return DatasetUtils.createCompoundDataset(datasets); 450 } 451 452 /** 453 * Create compound dataset of given type from given parts 454 * 455 * @param dtype 456 * @param objects 457 * @return compound dataset 458 * 459 * @deprecated Please use the class-based methods in DatasetFactory, 460 * such as {@link #createCompoundDataset(Class, Object...)} 461 */ 462 @Deprecated 463 public static CompoundDataset createCompoundDataset(final int dtype, Object... objects) { 464 Dataset[] datasets = new Dataset[objects.length]; 465 for (int i = 0; i < objects.length; i++) { 466 datasets[i] = createFromObject(objects[i]); 467 } 468 return DatasetUtils.createCompoundDataset(dtype, datasets); 469 } 470 471 /** 472 * Create complex dataset of given type from real and imaginary parts 473 * 474 * @param dtype 475 * @param real 476 * @param imag 477 * @return complex dataset 478 * 479 * @deprecated Please use the class-based methods in DatasetFactory, 480 * such as {@link #createComplexDataset(Class, Object, Object)} 481 */ 482 @Deprecated 483 public static CompoundDataset createComplexDataset(final int dtype, Object real, Object imag) { 484 switch (dtype) { 485 case Dataset.COMPLEX64: 486 return new ComplexFloatDataset(createFromObject(real), createFromObject(imag)); 487 case Dataset.COMPLEX128: 488 return new ComplexDoubleDataset(createFromObject(real), createFromObject(imag)); 489 default: 490 throw new IllegalArgumentException("Dataset class must be a complex one"); 491 } 492 } 493 494 /** 495 * @param shape 496 * @return a new double dataset of given shape, filled with zeros 497 */ 498 public static DoubleDataset zeros(final int... shape) { 499 return zeros(DoubleDataset.class, shape); 500 } 501 502 /** 503 * @param shape 504 * @param dtype 505 * @return a new dataset of given shape and type, filled with zeros 506 * 507 * @deprecated Please use the class-based methods in DatasetFactory, 508 * such as {@link #zeros(Class, int...)} 509 */ 510 @Deprecated 511 public static Dataset zeros(final int[] shape, final int dtype) { 512 switch (dtype) { 513 case Dataset.BOOL: 514 return new BooleanDataset(shape); 515 case Dataset.INT8: 516 case Dataset.ARRAYINT8: 517 return new ByteDataset(shape); 518 case Dataset.INT16: 519 case Dataset.ARRAYINT16: 520 return new ShortDataset(shape); 521 case Dataset.RGB: 522 return new RGBDataset(shape); 523 case Dataset.INT32: 524 case Dataset.ARRAYINT32: 525 return new IntegerDataset(shape); 526 case Dataset.INT64: 527 case Dataset.ARRAYINT64: 528 return new LongDataset(shape); 529 case Dataset.FLOAT32: 530 case Dataset.ARRAYFLOAT32: 531 return new FloatDataset(shape); 532 case Dataset.FLOAT64: 533 case Dataset.ARRAYFLOAT64: 534 return new DoubleDataset(shape); 535 case Dataset.COMPLEX64: 536 return new ComplexFloatDataset(shape); 537 case Dataset.COMPLEX128: 538 return new ComplexDoubleDataset(shape); 539 case Dataset.STRING: 540 return new StringDataset(shape); 541 case Dataset.DATE: 542 return new DateDatasetImpl(shape); 543 case Dataset.OBJECT: 544 return new ObjectDataset(shape); 545 } 546 throw new IllegalArgumentException("dtype not known or unsupported"); 547 } 548 549 /** 550 * @param itemSize 551 * if equal to 1, then non-compound dataset is returned 552 * @param shape 553 * @param dtype 554 * @return a new dataset of given item size, shape and type, filled with zeros 555 * 556 * @deprecated Please use the class-based methods in DatasetFactory, 557 * such as {@link #zeros(int, Class, int...)} 558 */ 559 @Deprecated 560 public static Dataset zeros(final int itemSize, final int[] shape, final int dtype) { 561 if (itemSize == 1) { 562 return zeros(shape, dtype); 563 } 564 return compoundZeros(itemSize, shape, dtype); 565 } 566 567 /** 568 * @param itemSize 569 * @param shape 570 * @param dtype 571 * @return a new dataset of given item size, shape and type, filled with zeros 572 * @since 2.0 573 * 574 * @deprecated Please use the class-based methods in DatasetFactory, 575 * such as {@link #compoundZeros(int, Class, int...)} 576 */ 577 @Deprecated 578 public static CompoundDataset compoundZeros(final int itemSize, final int[] shape, final int dtype) { 579 switch (dtype) { 580 case Dataset.INT8: 581 case Dataset.ARRAYINT8: 582 return new CompoundByteDataset(itemSize, shape); 583 case Dataset.INT16: 584 case Dataset.ARRAYINT16: 585 return new CompoundShortDataset(itemSize, shape); 586 case Dataset.RGB: 587 if (itemSize != 3) { 588 throw new IllegalArgumentException("Number of elements not compatible with RGB type"); 589 } 590 return new RGBDataset(shape); 591 case Dataset.INT32: 592 case Dataset.ARRAYINT32: 593 return new CompoundIntegerDataset(itemSize, shape); 594 case Dataset.INT64: 595 case Dataset.ARRAYINT64: 596 return new CompoundLongDataset(itemSize, shape); 597 case Dataset.FLOAT32: 598 case Dataset.ARRAYFLOAT32: 599 return new CompoundFloatDataset(itemSize, shape); 600 case Dataset.FLOAT64: 601 case Dataset.ARRAYFLOAT64: 602 return new CompoundDoubleDataset(itemSize, shape); 603 case Dataset.COMPLEX64: 604 if (itemSize != 2) { 605 throw new IllegalArgumentException("Number of elements not compatible with complex type"); 606 } 607 return new ComplexFloatDataset(shape); 608 case Dataset.COMPLEX128: 609 if (itemSize != 2) { 610 throw new IllegalArgumentException("Number of elements not compatible with complex type"); 611 } 612 return new ComplexDoubleDataset(shape); 613 } 614 throw new IllegalArgumentException("dtype not a known compound type"); 615 } 616 617 /** 618 * @param dataset 619 * @return a new dataset of same shape and type as input dataset, filled with zeros 620 */ 621 @SuppressWarnings("unchecked") 622 public static <T extends Dataset> T zeros(final T dataset) { 623 int dtype = dataset.getDType(); 624 return (T) (DTypeUtils.isDTypeElemental(dtype) ? zeros(dataset, dtype) : 625 compoundZeros(dataset.getElementsPerItem(), dataset.getShapeRef(), dtype)); 626 } 627 628 /** 629 * Create a new dataset of same shape as input dataset, filled with zeros. If dtype is not 630 * explicitly compound then an elemental dataset is created 631 * @param dataset 632 * @param dtype 633 * @return a new dataset 634 * 635 * @deprecated Please use the class-based methods in DatasetFactory, 636 * such as {@link #zeros(Dataset, Class)} 637 */ 638 @Deprecated 639 public static Dataset zeros(final Dataset dataset, final int dtype) { 640 final int[] shape = dataset.getShapeRef(); 641 final int isize = DTypeUtils.isDTypeElemental(dtype) ? 1 :dataset.getElementsPerItem(); 642 643 return zeros(isize, shape, dtype); 644 } 645 646 /** 647 * @param dataset 648 * @return a new dataset of same shape and type as input dataset, filled with ones 649 */ 650 @SuppressWarnings("unchecked") 651 public static <T extends Dataset> T ones(final T dataset) { 652 return (T) ones(dataset, dataset.getDType()); 653 } 654 655 /** 656 * Create a new dataset of same shape as input dataset, filled with ones. If dtype is not 657 * explicitly compound then an elemental dataset is created 658 * @param dataset 659 * @param dtype 660 * @return a new dataset 661 * 662 * @deprecated Please use the class-based methods in DatasetFactory, 663 * such as {@link #createRange(Class, double, double, double)} 664 */ 665 @Deprecated 666 public static Dataset ones(final Dataset dataset, final int dtype) { 667 final int[] shape = dataset.getShapeRef(); 668 final int isize = DTypeUtils.isDTypeElemental(dtype) ? 1 :dataset.getElementsPerItem(); 669 670 return ones(isize, shape, dtype); 671 } 672 673 /** 674 * @param shape 675 * @return a new double dataset of given shape, filled with ones 676 */ 677 public static DoubleDataset ones(final int... shape) { 678 return ones(DoubleDataset.class, shape); 679 } 680 681 /** 682 * @param shape 683 * @param dtype 684 * @return a new dataset of given shape and type, filled with ones 685 * 686 * @deprecated Please use the class-based methods in DatasetFactory, 687 * such as {@link #ones(Class, int...)} 688 */ 689 @Deprecated 690 public static Dataset ones(final int[] shape, final int dtype) { 691 switch (dtype) { 692 case Dataset.BOOL: 693 return BooleanDataset.ones(shape); 694 case Dataset.INT8: 695 return ByteDataset.ones(shape); 696 case Dataset.INT16: 697 return ShortDataset.ones(shape); 698 case Dataset.RGB: 699 return new RGBDataset(shape).fill(1); 700 case Dataset.INT32: 701 return IntegerDataset.ones(shape); 702 case Dataset.INT64: 703 return LongDataset.ones(shape); 704 case Dataset.FLOAT32: 705 return FloatDataset.ones(shape); 706 case Dataset.FLOAT64: 707 return DoubleDataset.ones(shape); 708 case Dataset.COMPLEX64: 709 return ComplexFloatDataset.ones(shape); 710 case Dataset.COMPLEX128: 711 return ComplexDoubleDataset.ones(shape); 712 } 713 throw new IllegalArgumentException("dtype not known"); 714 } 715 716 /** 717 * @param itemSize 718 * if equal to 1, then non-compound dataset is returned 719 * @param shape 720 * @param dtype 721 * @return a new dataset of given item size, shape and type, filled with ones 722 * 723 * @deprecated Please use the class-based methods in DatasetFactory, 724 * such as {@link #ones(Class, int...)} 725 */ 726 @Deprecated 727 public static Dataset ones(final int itemSize, final int[] shape, final int dtype) { 728 if (itemSize == 1) { 729 return ones(shape, dtype); 730 } 731 switch (dtype) { 732 case Dataset.INT8: 733 case Dataset.ARRAYINT8: 734 return CompoundByteDataset.ones(itemSize, shape); 735 case Dataset.INT16: 736 case Dataset.ARRAYINT16: 737 return CompoundShortDataset.ones(itemSize, shape); 738 case Dataset.RGB: 739 if (itemSize != 3) { 740 throw new IllegalArgumentException("Number of elements not compatible with RGB type"); 741 } 742 return new RGBDataset(shape).fill(1); 743 case Dataset.INT32: 744 case Dataset.ARRAYINT32: 745 return CompoundIntegerDataset.ones(itemSize, shape); 746 case Dataset.INT64: 747 case Dataset.ARRAYINT64: 748 return CompoundLongDataset.ones(itemSize, shape); 749 case Dataset.FLOAT32: 750 case Dataset.ARRAYFLOAT32: 751 return CompoundFloatDataset.ones(itemSize, shape); 752 case Dataset.FLOAT64: 753 case Dataset.ARRAYFLOAT64: 754 return CompoundDoubleDataset.ones(itemSize, shape); 755 case Dataset.COMPLEX64: 756 if (itemSize != 2) { 757 throw new IllegalArgumentException("Number of elements not compatible with complex type"); 758 } 759 return ComplexFloatDataset.ones(shape); 760 case Dataset.COMPLEX128: 761 if (itemSize != 2) { 762 throw new IllegalArgumentException("Number of elements not compatible with complex type"); 763 } 764 return ComplexDoubleDataset.ones(shape); 765 } 766 throw new IllegalArgumentException("dtype not a known compound type"); 767 } 768 769 /** 770 * Create a 1D dataset of linearly spaced values in closed interval 771 * 772 * @param start 773 * @param stop stop value is included 774 * @param length number of points 775 * @param dtype 776 * @return dataset with linearly spaced values 777 * 778 * @deprecated Please use the class-based methods in DatasetFactory, 779 * such as {@link #createLinearSpace(Class, double, double, int)} 780 */ 781 @Deprecated 782 public static Dataset createLinearSpace(final double start, final double stop, final int length, final int dtype) { 783 if (length < 1) { 784 throw new IllegalArgumentException("Length is less than one"); 785 } else if (length == 1) { 786 return createFromObject(dtype, start); 787 } else { 788 Dataset ds = zeros(new int[] {length}, dtype); 789 double num = stop - start; 790 double den = length - 1; 791 double value; 792 793 for (int i = 0; i < length; i++) { 794 value = start + (num * i) / den; 795 ds.setObjectAbs(i, value); 796 } 797 798 return ds; 799 } 800 } 801 802 /** 803 * Create a 1D dataset of logarithmically spaced values in closed interval. The base value is used to 804 * determine the factor between values: factor = base ** step, where step is the interval between linearly 805 * spaced sequence of points 806 * 807 * @param start 808 * @param stop stop value is included 809 * @param length number of points 810 * @param base 811 * @param dtype 812 * @return dataset with logarithmically spaced values 813 * 814 * @deprecated Please use the class-based methods in DatasetFactory, 815 * such as {@link #createLogSpace(Class, double, double, int, double)} 816 */ 817 @Deprecated 818 public static Dataset createLogSpace(final double start, final double stop, final int length, final double base, final int dtype) { 819 if (length < 1) { 820 throw new IllegalArgumentException("Length is less than one"); 821 } else if (length == 1) { 822 return createFromObject(dtype, Math.pow(base, start)); 823 } else { 824 Dataset ds = zeros(new int[] {length}, dtype); 825 double step = (stop - start) / (length - 1); 826 double value; 827 828 for (int i = 0; i < length; i++) { 829 value = start + i * step; 830 ds.setObjectAbs(i, Math.pow(base, value)); 831 } 832 833 return ds; 834 } 835 } 836 837 /** 838 * Create dataset with items ranging from 0 up to given stop in steps of 1 839 * @param clazz 840 * @param stop stop value is <strong>not</strong> included 841 * @return a new dataset of given shape and type, filled with values determined by parameters 842 */ 843 @SuppressWarnings("unchecked") 844 public static <T extends Dataset> T createRange(Class<T> clazz, final double stop) { 845 return (T) createRange(0, stop, 1, DTypeUtils.getDType(clazz)); 846 } 847 848 /** 849 * Create dataset with items ranging from given start up to given stop in given steps 850 * @param clazz dataset class 851 * @param start 852 * @param stop stop value is <strong>not</strong> included 853 * @param step spacing between items 854 * @return a new 1D dataset of given class, filled with values determined by parameters 855 */ 856 @SuppressWarnings("unchecked") 857 public static <T extends Dataset> T createRange(Class<T> clazz, final double start, final double stop, final double step) { 858 return (T) createRange(start, stop, step, DTypeUtils.getDType(clazz)); 859 } 860 861 /** 862 * Create compound dataset with items ranging from 0 up to given stop in steps of 1 863 * @param itemSize 864 * @param clazz compound dataset class 865 * @param stop stop value is <strong>not</strong> included 866 * @return a new 1D dataset of given class, filled with values determined by parameters 867 * @since 2.1 868 */ 869 @SuppressWarnings("unchecked") 870 public static <T extends CompoundDataset> T createRange(final int itemSize, Class<T> clazz, final double stop) { 871 return (T) createRange(itemSize, 0, stop, 1, DTypeUtils.getDType(clazz)); 872 } 873 874 /** 875 * Create compound dataset with items ranging from given start up to given stop in given steps 876 * @param itemSize 877 * @param clazz compound dataset class 878 * @param start 879 * @param stop stop value is <strong>not</strong> included 880 * @param step spacing between items 881 * @return a new 1D dataset of given class, filled with values determined by parameters 882 * @since 2.1 883 */ 884 @SuppressWarnings("unchecked") 885 public static <T extends CompoundDataset> T createRange(final int itemSize, Class<T> clazz, final double start, final double stop, final double step) { 886 return (T) createRange(itemSize, start, stop, step, DTypeUtils.getDType(clazz)); 887 } 888 889 /** 890 * Create a dataset from object 891 * @param clazz dataset class 892 * @param obj 893 * can be a Java list, array or Number 894 * @return dataset 895 * @throws IllegalArgumentException if dataset class is not known 896 * @since 2.1 897 */ 898 @SuppressWarnings("unchecked") 899 public static <T extends Dataset> T createFromObject(Class<T> clazz, Object obj) { 900 return (T) createFromObject(1, DTypeUtils.getDType(clazz), obj, null); 901 } 902 903 904 /** 905 * Create a dataset from object 906 * @param clazz dataset class 907 * @param obj 908 * can be a Java list, array or Number 909 * @param shape can be null 910 * @return dataset 911 * @throws IllegalArgumentException if dataset type is not known 912 */ 913 @SuppressWarnings("unchecked") 914 public static <T extends Dataset> T createFromObject(Class<T> clazz, Object obj, int... shape) { 915 return (T) createFromObject(1, DTypeUtils.getDType(clazz), obj, shape); 916 } 917 918 /** 919 * Create a compound dataset from object 920 * @param itemSize 921 * @param clazz dataset class 922 * @param obj 923 * can be a Java list, array or Number 924 * @param shape can be null 925 * @return dataset 926 * @throws IllegalArgumentException if dataset type is not known 927 */ 928 @SuppressWarnings("unchecked") 929 public static <T extends Dataset> T createFromObject(final int itemSize, Class<T> clazz, Object obj, int... shape) { 930 return (T) createFromObject(itemSize, DTypeUtils.getDType(clazz), obj, shape); 931 } 932 933 /** 934 * Create dataset of given class from list 935 * 936 * @param clazz dataset class 937 * @param objectList 938 * @return dataset filled with values from list 939 */ 940 @SuppressWarnings("unchecked") 941 public static <T extends Dataset> T createFromList(Class<T> clazz, List<?> objectList) { 942 return (T) createFromList(DTypeUtils.getDType(clazz), objectList); 943 } 944 945 /** 946 * Create compound dataset of given class from given parts 947 * 948 * @param clazz 949 * @param objects 950 * @return compound dataset 951 */ 952 @SuppressWarnings("unchecked") 953 public static <T extends Dataset> T createCompoundDataset(Class<T> clazz, Object... objects) { 954 return (T) createCompoundDataset(DTypeUtils.getDType(clazz), objects); 955 } 956 957 /** 958 * Create complex dataset of given class from real and imaginary parts 959 * 960 * @param clazz dataset class 961 * @param real 962 * @param imag 963 * @return complex dataset 964 */ 965 @SuppressWarnings("unchecked") 966 public static <T extends Dataset> T createComplexDataset(Class<T> clazz, Object real, Object imag) { 967 return (T) createComplexDataset(DTypeUtils.getDType(clazz), real, imag); 968 } 969 970 /** 971 * @param clazz dataset class 972 * @param shape 973 * @return a new dataset of given shape and class, filled with zeros 974 */ 975 @SuppressWarnings("unchecked") 976 public static <T extends Dataset> T zeros(Class<T> clazz, int... shape) { 977 return (T) zeros(shape, DTypeUtils.getDType(clazz)); 978 } 979 980 /** 981 * @param itemSize 982 * if equal to 1, then non-compound dataset is returned 983 * @param clazz dataset class 984 * @param shape 985 * @return a new dataset of given item size, shape and class, filled with zeros 986 */ 987 @SuppressWarnings("unchecked") 988 public static <T extends Dataset> T zeros(int itemSize, Class<T> clazz, int... shape) { 989 return (T) zeros(itemSize, shape, DTypeUtils.getDType(clazz)); 990 } 991 992 /** 993 * @param dataset 994 * @param clazz dataset class 995 * @return a new dataset of given class with same shape as input dataset, filled with zeros 996 */ 997 @SuppressWarnings("unchecked") 998 public static <T extends Dataset> T zeros(Dataset dataset, Class<T> clazz) { 999 return (T) zeros(dataset, DTypeUtils.getDType(clazz)); 1000 } 1001 1002 /** 1003 * @param itemSize 1004 * @param clazz compound dataset class 1005 * @param shape 1006 * @return a new compound dataset of given item size, shape and class, filled with zeros 1007 * @since 2.0 1008 */ 1009 @SuppressWarnings("unchecked") 1010 public static <T extends CompoundDataset> T compoundZeros(int itemSize, Class<T> clazz, int... shape) { 1011 return (T) compoundZeros(itemSize, shape, DTypeUtils.getDType(clazz)); 1012 } 1013 1014 /** 1015 * @param clazz dataset class 1016 * @param shape 1017 * @return a new dataset of given shape and class, filled with ones 1018 */ 1019 @SuppressWarnings("unchecked") 1020 public static <T extends Dataset> T ones(Class<T> clazz, int... shape) { 1021 return (T) ones(shape, DTypeUtils.getDType(clazz)); 1022 } 1023 1024 /** 1025 * @param itemSize 1026 * if equal to 1, then non-compound dataset is returned 1027 * @param clazz dataset class 1028 * @param shape 1029 * @return a new dataset of given item size, shape and class, filled with ones 1030 */ 1031 @SuppressWarnings("unchecked") 1032 public static <T extends Dataset> T ones(int itemSize, Class<T> clazz, int... shape) { 1033 return (T) ones(itemSize, shape, DTypeUtils.getDType(clazz)); 1034 } 1035 1036 /** 1037 * @param dataset 1038 * @param clazz dataset class 1039 * @return a new dataset of given class with same shape as input dataset, filled with ones 1040 */ 1041 @SuppressWarnings("unchecked") 1042 public static <T extends Dataset> T ones(Dataset dataset, Class<T> clazz) { 1043 return (T) ones(dataset, DTypeUtils.getDType(clazz)); 1044 } 1045 1046 /** 1047 * Create a 1D dataset of linearly spaced values in closed interval 1048 * 1049 * @param clazz dataset class 1050 * @param start 1051 * @param stop stop value is included 1052 * @param length number of points 1053 * @return dataset with linearly spaced values 1054 */ 1055 @SuppressWarnings("unchecked") 1056 public static <T extends Dataset> T createLinearSpace(Class<T> clazz, final double start, final double stop, final int length) { 1057 return (T) createLinearSpace(start, stop, length, DTypeUtils.getDType(clazz)); 1058 } 1059 1060 /** 1061 * Create a 1D dataset of logarithmically spaced values in closed interval. The base value is used to 1062 * determine the factor between values: factor = base ** step, where step is the interval between linearly 1063 * spaced sequence of points 1064 * 1065 * @param start 1066 * @param stop stop value is included 1067 * @param length number of points 1068 * @param base 1069 * @return dataset with logarithmically spaced values 1070 */ 1071 @SuppressWarnings("unchecked") 1072 public static <T extends Dataset> T createLogSpace(Class<T> clazz, final double start, final double stop, final int length, final double base) { 1073 return (T) createLogSpace(start, stop, length, base, DTypeUtils.getDType(clazz)); 1074 } 1075}