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}