    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 org.eclipse.january.IMonitor;
    016
    017public interface CompoundDataset extends Dataset {
    018
    019        @Override
    020        public CompoundDataset cast(boolean repeat, int dtype, int isize);
    021
    022        @Override
    023        public CompoundDataset cast(int dtype);
    024
    025        @Override
    026        public CompoundDataset clone();
    027
    028        @Override
    029        public CompoundDataset fill(Object obj);
    030
    031        @Override
    032        public CompoundDataset flatten();
    033
    034        @Override
    035        public CompoundDataset getBy1DIndex(IntegerDataset index);
    036
    037        @Override
    038        public CompoundDataset getByBoolean(Dataset selection);
    039
    040        @Override
    041        public CompoundDataset getByIndexes(Object... indexes);
    042
    043        @Override
    044        public CompoundDataset getSlice(IMonitor mon, int[] start, int[] stop, int[] step);
    045
    046        @Override
    047        public CompoundDataset getSlice(IMonitor mon, Slice... slice);
    048
    049        @Override
    050        public CompoundDataset getSlice(IMonitor mon, SliceND slice);
    051
    052        @Override
    053        public CompoundDataset getSlice(int[] start, int[] stop, int[] step);
    054
    055        @Override
    056        public CompoundDataset getSlice(Slice... slice);
    057
    058        @Override
    059        public CompoundDataset getSlice(SliceND slice);
    060
    061        @Override
    062        public CompoundDataset getSliceView(int[] start, int[] stop, int[] step);
    063
    064        @Override
    065        public CompoundDataset getSliceView(Slice... slice);
    066
    067        @Override
    068        public CompoundDataset getSliceView(SliceND slice);
    069
    070        @Override
    071        public CompoundDataset getTransposedView(int... axes);
    072
    073        @Override
    074        public CompoundDataset getView(boolean deepCopyMetadata);
    075
    076        @Override
    077        public CompoundDataset getBroadcastView(int... shape);
    078
    079        @Override
    080        public CompoundDataset iadd(Object o);
    081
    082        @Override
    083        public CompoundDataset idivide(Object o);
    084
    085        @Override
    086        public CompoundDataset ifloor();
    087
    088        @Override
    089        public CompoundDataset ifloorDivide(Object o);
    090
    091        @Override
    092        public CompoundDataset imultiply(Object o);
    093
    094        @Override
    095        public CompoundDataset ipower(Object o);
    096
    097        @Override
    098        public CompoundDataset iremainder(Object o);
    099
    100        @Override
    101        public CompoundDataset isubtract(Object o);
    102
    103        @Override
    104        public CompoundDataset reshape(int... shape);
    105
    106        @Override
    107        public CompoundDataset setBy1DIndex(Object obj, Dataset index);
    108
    109        @Override
    110        public CompoundDataset setByBoolean(Object obj, Dataset selection);
    111
    112        @Override
    113        public CompoundDataset setByIndexes(Object obj, Object... indexes);
    114
    115        @Override
    116        public CompoundDataset setSlice(Object obj, IndexIterator iterator);
    117
    118        @Override
    119        public CompoundDataset setSlice(Object obj, int[] start, int[] stop, int[] step);
    120
    121        @Override
    122        public CompoundDataset setSlice(Object object, Slice... slice);
    123
    124        @Override
    125        public CompoundDataset sort(Integer axis);
    126
    127        @Override
    128        public CompoundDataset squeezeEnds();
    129
    130        @Override
    131        public CompoundDataset squeeze();
    132
    133        @Override
    134        public CompoundDataset squeeze(boolean onlyFromEnd);
    135
    136        @Override
    137        public CompoundDataset swapAxes(int axis1, int axis2);
    138
    139        @Override
    140        public CompoundDataset synchronizedCopy();
    141
    142        @Override
    143        public CompoundDataset transpose(int... axes);
    144
    145        /**
    146         * @since 2.0
    147         */
    148        @Override
    149        public CompoundDataset max(int axis, boolean... ignoreInvalids);
    150
    151        /**
    152         * @since 2.0
    153         */
    154        @Override
    155        public CompoundDataset min(int axis, boolean... ignoreInvalids);
    156
    157        /**
    158         * @since 2.0
    159         */
    160        @Override
    161        public CompoundDataset peakToPeak(int axis, boolean... ignoreInvalids);
    162
    163        /**
    164         * @since 2.0
    165         */
    166        @Override
    167        public CompoundDataset sum(int axis, boolean... ignoreInvalids);
    168
    169        /**
    170         * @since 2.0
    171         */
    172        @Override
    173        public CompoundDataset product(int axis, boolean... ignoreInvalids);
    174
    175        /**
    176         * @since 2.0
    177         */
    178        @Override
    179        public CompoundDataset mean(int axis, boolean... ignoreInvalids);
    180
    181        /**
    182         * @since 2.0
    183         */
    184        @Override
    185        public CompoundDataset rootMeanSquare(int axis, boolean... ignoreInvalids);
    186
    187        @Override
    188        public CompoundDataset stdDeviation(int axis);
    189
    190        /**
    191         * @since 2.0
    192         */
    193        @Override
    194        public CompoundDataset stdDeviation(int axis, boolean isWholePopulation, boolean... ignoreInvalids);
    195
    196        @Override
    197        public CompoundDataset variance(int axis);
    198
    199        /**
    200         * @since 2.0
    201         */
    202        @Override
    203        public CompoundDataset variance(int axis, boolean isWholePopulation, boolean... ignoreInvalids);
    204
    205        /**
    206         * Get first item as a double array
    207         * @param darray double array must be allocated and have sufficient length
    208         * @since 2.0
    209         */
    210        public void getDoubleArray(double[] darray);
    211
    212        /**
    213         * Get an item as a double array
    214         * @param darray double array must be allocated and have sufficient length
    215         * @param i
    216         */
    217        public void getDoubleArray(double[] darray, final int i);
    218
    219        /**
    220         * Get an item as a double array
    221         * @param darray double array must be allocated and have sufficient length
    222         * @param i
    223         * @param j
    224         */
    225        public void getDoubleArray(double[] darray, final int i, final int j);
    226
    227        /**
    228         * Get an item as a double array
    229         * @param darray double array must be allocated and have sufficient length
    230         * @param pos
    231         */
    232        public void getDoubleArray(double[] darray, final int... pos);
    233
    234        /**
    235         * Get an item as a double array
    236         * @param index
    237         * @param darray double array must be allocated and have sufficient length
    238         */
    239        public void getDoubleArrayAbs(int index, double[] darray);
    240
    241        /**
    242         * Get chosen elements from each item as a dataset
    243         * @param element
    244         * @return dataset of chosen elements
    245         */
    246        public Dataset getElements(int element);
    247
    248        /**
    249         * Get chosen elements from each item as a view on dataset
    250         * @param element
    251         * @return view dataset of chosen elements
    252         */
    253        public Dataset getElementsView(int element);
    254
    255        /**
    256         * Set values of chosen elements from each item according to source dataset
    257         * @param source
    258         * @param element
    259         */
    260        public void setElements(Dataset source, int element);
    261
    262        /**
    263         * Copy chosen elements from each item to another dataset
    264         * @param destination
    265         * @param element
    266         */
    267        public void copyElements(Dataset destination, int element);
    268
    269        /**
    270         * Get a non-compound dataset version
    271         * @param shareData if true, then share data when possible otherwise copy it
    272         * @return non-compound dataset
    273         */
    274        public Dataset asNonCompoundDataset(final boolean shareData);
    275
    276        /**
    277         * Calculate maximum values of elements over all items in dataset
    278         * @return double array of element-wise maxima
    279         */
    280        public double[] maxItem();
    281
    282        /**
    283         * Calculate minimum values of elements over all items in dataset
    284         * @return double array of element-wise minima
    285         */
    286        public double[] minItem();
    287
    288        /**
    289         * @since 2.0
    290         */
    291        @Override
    292        public CompoundDataset getErrors();
    293
    294        /**
    295         * @return item in first position
    296         * @since 2.0
    297         */
    298        public byte[] getByteArray();
    299
    300        /**
    301         * @param i
    302         * @return item in given position
    303         */
    304        public byte[] getByteArray(final int i);
    305
    306        /**
    307         * @param i
    308         * @param j
    309         * @return item in given position
    310         */
    311        public byte[] getByteArray(final int i, final int j);
    312
    313        /**
    314         * @param pos
    315         * @return item in given position
    316         */
    317        public byte[] getByteArray(final int... pos);
    318
    319        /**
    320         * @return item in first position
    321         * @since 2.0
    322         */
    323        public short[] getShortArray();
    324
    325        /**
    326         * @param i
    327         * @return item in given position
    328         */
    329        public short[] getShortArray(final int i);
    330
    331        /**
    332         * @param i
    333         * @param j
    334         * @return item in given position
    335         */
    336        public short[] getShortArray(final int i, final int j);
    337
    338        /**
    339         * @param pos
    340         * @return item in given position
    341         */
    342        public short[] getShortArray(final int... pos);
    343
    344        /**
    345         * @return item in first position
    346         * @since 2.0
    347         */
    348        public int[] getIntArray();
    349
    350        /**
    351         * @param i
    352         * @return item in given position
    353         */
    354        public int[] getIntArray(final int i);
    355
    356        /**
    357         * @param i
    358         * @param j
    359         * @return item in given position
    360         */
    361        public int[] getIntArray(final int i, final int j);
    362
    363        /**
    364         * @param pos
    365         * @return item in given position
    366         * @since 2.0
    367         */
    368        public int[] getIntArray(final int... pos);
    369
    370        /**
    371         * @return item in first position
    372         * @since 2.0
    373         */
    374        public long[] getLongArray();
    375
    376        /**
    377         * @param i
    378         * @return item in given position
    379         */
    380        public long[] getLongArray(final int i);
    381
    382        /**
    383         * @param i
    384         * @param j
    385         * @return item in given position
    386         */
    387        public long[] getLongArray(final int i, final int j);
    388
    389        /**
    390         * @param pos
    391         * @return item in given position
    392         */
    393        public long[] getLongArray(final int... pos);
    394
    395        /**
    396         * @return item in first position
    397         * @since 2.0
    398         */
    399        public float[] getFloatArray();
    400
    401        /**
    402         * @param i
    403         * @return item in given position
    404         */
    405        public float[] getFloatArray(final int i);
    406
    407        /**
    408         * @param i
    409         * @param j
    410         * @return item in given position
    411         */
    412        public float[] getFloatArray(final int i, final int j);
    413
    414        /**
    415         * @param pos
    416         * @return item in given position
    417         */
    418        public float[] getFloatArray(final int... pos);
    419
    420        /**
    421         * @return item in first position
    422         * @since 2.0
    423         */
    424        public double[] getDoubleArray();
    425
    426        /**
    427         * @param i
    428         * @return item in given position
    429         */
    430        public double[] getDoubleArray(final int i);
    431
    432        /**
    433         * @param i
    434         * @param j
    435         * @return item in given position
    436         */
    437        public double[] getDoubleArray(final int i, final int j);
    438
    439        /**
    440         * @param pos
    441         * @return item in given position
    442         */
    443        public double[] getDoubleArray(final int... pos);
    444}