@Override public void setElements(AbstractDataset source, int element) { if (element < 0) element += isize; if (element < 0 || element > isize) { throw new IllegalArgumentException( String.format("Invalid choice of element: %d/%d", element, isize)); } if (elementClass() != source.elementClass()) { throw new IllegalArgumentException( "Element class of destination does not match this dataset"); } final IndexIterator it = getIterator(element); final int[] elements = ((IntegerDataset) source).data; // CLASS_TYPE // PRIM_TYPE if (source.isContiguous()) { int n = 0; while (it.hasNext()) { data[it.index] = elements[n]; n++; } } else { final IndexIterator sit = source.getIterator(); while (it.hasNext() && sit.hasNext()) { data[it.index] = elements[sit.index]; } } }
private void showValues2D(CoordinateAxis2D axis2D) { Formatter f = new Formatter(); if (axis2D.isInterval()) { ArrayDouble.D2 coords = axis2D.getCoordValuesArray(); ArrayDouble.D3 bounds = axis2D.getCoordBoundsArray(); if (bounds == null) { infoTA.appendLine("No bounds for interval " + axis2D.getFullName()); return; } IndexIterator coordIter = coords.getIndexIterator(); IndexIterator boundsIter = bounds.getIndexIterator(); while (coordIter.hasNext()) { double coordValue = coordIter.getDoubleNext(); if (!boundsIter.hasNext()) break; double bounds1 = boundsIter.getDoubleNext(); if (!boundsIter.hasNext()) break; double bounds2 = boundsIter.getDoubleNext(); f.format("%f (%f,%f) = %f%n", coordValue, bounds1, bounds2, bounds2 - bounds1); } } else { ArrayDouble.D2 coords = axis2D.getCoordValuesArray(); IndexIterator coordIter = coords.getIndexIterator(); while (coordIter.hasNext()) { double coordValue = coordIter.getDoubleNext(); f.format("%f%n", coordValue); } } infoTA.appendLine(f.toString()); }
/** * Cast a dataset to this compound type. If repeat is set, the first element of each item in the * given dataset is repeated across all elements of an item. Otherwise, each item comprises a * truncated or zero-padded copy of elements from the given dataset. * * @param itemSize * @param repeat repeat first element * @param dataset */ public CompoundIntegerDataset( final int itemSize, final boolean repeat, final AbstractDataset dataset) { isize = itemSize; size = dataset.size; shape = dataset.shape.clone(); name = new String(dataset.name); odata = data = createArray(size); final int os = dataset.getElementsPerItem(); IndexIterator iter = dataset.getIterator(); if (repeat) { int i = 0; while (iter.hasNext()) { final int v = (int) dataset.getElementLongAbs(iter.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST for (int k = 0; k < isize; k++) data[i++] = v; } } else { final int kmax = Math.min(isize, os); int i = 0; while (iter.hasNext()) { for (int k = 0; k < kmax; k++) data[i + k] = (int) dataset.getElementLongAbs(iter.index + k); // GET_ELEMENT_WITH_CAST i += isize; } } }
@Override public void fillDataset(Dataset result, IndexIterator iter) { IndexIterator riter = result.getIterator(); String[] rdata = ((StringDatasetBase) result).data; // PRIM_TYPE while (riter.hasNext() && iter.hasNext()) rdata[riter.index] = data[iter.index]; }
@Override public CompoundIntegerDataset ipower(final Object b) { if (b instanceof AbstractDataset) { final AbstractDataset bds = (AbstractDataset) b; checkCompatibility(bds); final IndexIterator it1 = getIterator(); final IndexIterator it2 = bds.getIterator(); final int bis = bds.getElementsPerItem(); if (bis == 1) { while (it1.hasNext() && it2.hasNext()) { final int db = (int) bds.getElementLongAbs(it2.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], db); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } else if (bis == isize) { while (it1.hasNext() && it2.hasNext()) { for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], bds.getElementDoubleAbs(it2.index + i)); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } else { throw new IllegalArgumentException( "Argument does not have same number of elements per item or is not a non-compound dataset"); } } else { final int[] vr = toIntegerArray(b, isize); // PRIM_TYPE // CLASS_TYPE final IndexIterator it1 = getIterator(); while (it1.hasNext()) { for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], vr[i]); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } setDirty(); return this; }
@Override public void fillDataset(AbstractDataset result, IndexIterator iter) { IndexIterator riter = result.getIterator(); int[] rdata = ((CompoundIntegerDataset) result).data; // PRIM_TYPE while (riter.hasNext() && iter.hasNext()) { for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[iter.index + i]; } }
@Override public double residual(final Object b) { double sum = 0; if (b instanceof AbstractDataset) { final AbstractDataset bds = (AbstractDataset) b; checkCompatibility(bds); final IndexIterator it1 = getIterator(); final IndexIterator it2 = bds.getIterator(); final int bis = bds.getElementsPerItem(); if (bis == 1) { double comp = 0; while (it1.hasNext() && it2.hasNext()) { final double db = bds.getElementDoubleAbs(it2.index); for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - db; final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } else if (bis == isize) { double comp = 0; while (it1.hasNext() && it2.hasNext()) { for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - bds.getElementDoubleAbs(it2.index + i); final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } else { throw new IllegalArgumentException( "Argument does not have same number of elements per item or is not a non-compound dataset"); } } else { final double[] vr = toDoubleArray(b, isize); final IndexIterator it1 = getIterator(); double comp = 0; while (it1.hasNext()) { for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - vr[i]; final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } return sum; }
@Override public IntegerDataset real() { // CLASS_TYPE IntegerDataset rdataset = new IntegerDataset(shape); // CLASS_TYPE IndexIterator iter = getIterator(); IndexIterator riter = rdataset.getIterator(); int[] rdata = rdataset.data; // PRIM_TYPE while (iter.hasNext() && riter.hasNext()) rdata[riter.index] = data[iter.index]; return rdataset; }
@Override public CompoundIntegerDataset iremainder(final Object b) { if (b instanceof AbstractDataset) { final AbstractDataset bds = (AbstractDataset) b; checkCompatibility(bds); final IndexIterator it1 = getIterator(); final IndexIterator it2 = bds.getIterator(); final int bis = bds.getElementsPerItem(); if (bis == 1) { while (it1.hasNext() && it2.hasNext()) { final int db = (int) bds.getElementLongAbs(it2.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST if (db == 0) { // INT_ZEROTEST for (int i = 0; i < isize; i++) // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST } else { // INT_ZEROTEST for (int i = 0; i < isize; i++) data[it1.index + i] %= db; } // INT_ZEROTEST } } else if (bis == isize) { while (it1.hasNext() && it2.hasNext()) { for (int i = 0; i < isize; i++) { try { data[it1.index + i] %= bds.getElementLongAbs(it2.index + i); // GET_ELEMENT // INT_EXCEPTION } catch (ArithmeticException e) { data[it1.index + i] = 0; } } } } else { throw new IllegalArgumentException( "Argument does not have same number of elements per item or is not a non-compound dataset"); } } else { final double[] vr = toDoubleArray(b, isize); final IndexIterator it1 = getIterator(); while (it1.hasNext()) { for (int i = 0; i < isize; i++) { if (vr[i] == 0) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST } else { // INT_ZEROTEST data[it1.index + i] %= vr[i]; } // INT_ZEROTEST } } } setDirty(); return this; }
private void allocateArray(final int... nshape) { if (data == null) { throw new IllegalStateException("Data buffer in dataset is null"); } if (dataShape != null) { // see if reserved space is sufficient if (isShapeInDataShape(nshape)) { shape = nshape; size = calcSize(shape); if (Arrays.equals(shape, dataShape)) { dataShape = null; // no reserved space } return; } } final IndexIterator iter = getIterator(); // not enough room so need to expand the allocated memory if (dataShape == null) dataShape = shape.clone(); expandDataShape(nshape); dataSize = calcSize(dataShape); final int[] ndata = createArray(dataSize); // PRIM_TYPE final int[] oshape = shape; // now this object has the new dimensions so specify them correctly shape = nshape; size = calcSize(nshape); // make sure that all the data is set to NaN, minimum value or false Arrays.fill(ndata, Integer.MIN_VALUE); // CLASS_TYPE // DEFAULT_VAL // now copy the data back to the correct positions final IndexIterator niter = getSliceIterator(null, oshape, null); while (niter.hasNext() && iter.hasNext()) for (int j = 0; j < isize; j++) { ndata[niter.index + j] = data[iter.index + j]; } odata = data = ndata; // if fully expanded then reset the reserved space dimensions if (dataSize == size) { dataShape = null; } }
// @todo Make sure units are meters public Array getElevation(Range range) throws IOException, InvalidRangeException { List section = new ArrayList(1); section.add(range); Array a = elevVar.read(section); if (elevVarUnitsConversionFactor == 1.0) return (a); for (IndexIterator it = a.getIndexIterator(); it.hasNext(); ) { if (elevVar.getDataType() == DataType.DOUBLE) { double val = it.getDoubleNext(); it.setDoubleCurrent(val * elevVarUnitsConversionFactor); } else if (elevVar.getDataType() == DataType.FLOAT) { float val = it.getFloatNext(); it.setFloatCurrent((float) (val * elevVarUnitsConversionFactor)); } else if (elevVar.getDataType() == DataType.INT) { int val = it.getIntNext(); it.setIntCurrent((int) (val * elevVarUnitsConversionFactor)); } else if (elevVar.getDataType() == DataType.LONG) { long val = it.getLongNext(); it.setLongCurrent((long) (val * elevVarUnitsConversionFactor)); } else { throw new IllegalStateException( "Elevation variable type <" + elevVar.getDataType().toString() + "> not double, float, int, or long."); } } return (a); }
@Override public StringDatasetBase setByBoolean(final Object obj, Dataset selection) { if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; final int length = ((Number) selection.sum()).intValue(); if (length != ds.getSize()) { throw new IllegalArgumentException( "Number of true items in selection does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); final BooleanIterator biter = getBooleanIterator(selection); while (biter.hasNext() && oiter.hasNext()) { data[biter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT final BooleanIterator biter = getBooleanIterator(selection); while (biter.hasNext()) { data[biter.index] = dv; } } setDirty(); return this; }
@Override public StringDatasetBase setBy1DIndex(final Object obj, final Dataset index) { if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; if (index.getSize() != ds.getSize()) { throw new IllegalArgumentException( "Number of items in index dataset does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); final IntegerIterator iter = new IntegerIterator(index, size); while (iter.hasNext() && oiter.hasNext()) { data[iter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT IntegerIterator iter = new IntegerIterator(index, size); while (iter.hasNext()) { data[iter.index] = dv; } } setDirty(); return this; }
public void testEnhanceDefer() throws IOException { NetcdfDataset ncd = NetcdfDataset.openDataset( filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissing), -1, null, null); VariableDS enhancedVar = (VariableDS) ncd.findVariable("t1"); NetcdfDataset ncdefer = NetcdfDataset.openDataset( filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissingDefer), -1, null, null); VariableDS deferVar = (VariableDS) ncdefer.findVariable("t1"); Array data = enhancedVar.read(); Array dataDefer = deferVar.read(); System.out.printf("Enhanced="); NCdumpW.printArray(data); System.out.printf("%nDeferred="); NCdumpW.printArray(dataDefer); System.out.printf("%nProcessed="); CompareNetcdf2 nc = new CompareNetcdf2(new Formatter(System.out), false, false, true); assert !nc.compareData(enhancedVar.getShortName(), data, dataDefer, false); IndexIterator ii = dataDefer.getIndexIterator(); while (ii.hasNext()) { double val = deferVar.convertScaleOffsetMissing(ii.getDoubleNext()); ii.setDoubleCurrent(val); } NCdumpW.printArray(dataDefer); assert nc.compareData(enhancedVar.getShortName(), data, dataDefer, false); ncd.close(); ncdefer.close(); }
@Override public StringDatasetBase setByIndexes(final Object obj, final Object... indexes) { final IntegersIterator iter = new IntegersIterator(shape, indexes); final int[] pos = iter.getPos(); if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; if (calcSize(iter.getShape()) != ds.getSize()) { throw new IllegalArgumentException( "Number of items in index datasets does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); while (iter.hasNext() && oiter.hasNext()) { setItem(ds.getStringAbs(oiter.index), pos); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT while (iter.hasNext()) { setItem(dv, pos); } } setDirty(); return this; }
/** * Translate missing data to NaNs. Data must be DOUBLE or FLOAT * * @param in convert this array * @return same array, with missing values replaced by NaNs */ private Array convertMissing(Array in) { if (debugRead) System.out.println("convertMissing "); IndexIterator iterIn = in.getIndexIterator(); if (in.getElementType() == double.class) { while (iterIn.hasNext()) { double val = iterIn.getDoubleNext(); if (isMissing_(val)) iterIn.setDoubleCurrent(Double.NaN); } } else if (in.getElementType() == float.class) { while (iterIn.hasNext()) { float val = iterIn.getFloatNext(); if (isMissing_(val)) iterIn.setFloatCurrent(Float.NaN); } } return in; }
private void convertScaleOffsetUnsignedInt(IndexIterator iterIn, IndexIterator iterOut) { boolean checkMissing = useNaNs && hasMissing(); while (iterIn.hasNext()) { int valb = iterIn.getIntNext(); double val = scale * DataType.unsignedIntToLong(valb) + offset; iterOut.setDoubleNext(checkMissing && isMissing_(val) ? Double.NaN : val); } }
private void showValuesAsDates(CoordinateAxis axis) { String units = axis.getUnitsString(); String cal = getCalendarAttribute(axis); CalendarDateUnit cdu = CalendarDateUnit.of(cal, units); try { infoTA.appendLine(units); infoTA.appendLine(NCdumpW.printVariableData(axis, null)); if (axis.getDataType().isNumeric()) { if (axis instanceof CoordinateAxis2D) { showDates2D((CoordinateAxis2D) axis, cdu); } else if (axis instanceof CoordinateAxis1D) { // 1D showDates1D((CoordinateAxis1D) axis, cdu); } else { // > 2D Array data = axis.read(); IndexIterator ii = data.getIndexIterator(); while (ii.hasNext()) { double val = ii.getDoubleNext(); infoTA.appendLine(makeCalendarDateStringOrMissing(cdu, val)); } } } else { // must be iso dates Array data = axis.read(); Formatter f = new Formatter(); if (data instanceof ArrayChar) { ArrayChar dataS = (ArrayChar) data; ArrayChar.StringIterator iter = dataS.getStringIterator(); while (iter.hasNext()) f.format(" %s%n", iter.next()); infoTA.appendLine(f.toString()); } else if (data instanceof ArrayObject) { IndexIterator iter = data.getIndexIterator(); while (iter.hasNext()) f.format(" %s%n", iter.next()); infoTA.appendLine(f.toString()); } } } catch (Exception ex) { ex.printStackTrace(); infoTA.appendLine(ex.getMessage()); } }
@Override public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } if (getRank() == 0) // already true for zero-rank dataset return true; StringDatasetBase other = (StringDatasetBase) obj; IndexIterator iter = getIterator(); IndexIterator oiter = other.getIterator(); while (iter.hasNext() && oiter.hasNext()) { if (!data[iter.index].equals(other.data[oiter.index])) // OBJECT_UNEQUAL return false; } return true; }
@Override public CompoundIntegerDataset setByBoolean(final Object o, BooleanDataset selection) { if (o instanceof AbstractDataset) { AbstractDataset ds = (AbstractDataset) o; final int length = ((Number) selection.sum()).intValue(); if (length != ds.getSize()) { throw new IllegalArgumentException( "Number of true items in selection does not match number of items in dataset"); } IndexIterator iter = ds.getIterator(); BooleanIterator biter = getBooleanIterator(selection); if (ds instanceof AbstractCompoundDataset) { if (isize != ds.getElementsPerItem()) { throw new IllegalArgumentException("Input dataset is not compatible with slice"); } while (biter.hasNext() && iter.hasNext()) { for (int i = 0; i < isize; i++) data[biter.index + i] = (int) ds.getElementLongAbs(iter.index + i); // GET_ELEMENT_WITH_CAST } } else { while (biter.hasNext() && iter.hasNext()) { data[biter.index] = (int) ds.getElementLongAbs(iter.index); // GET_ELEMENT_WITH_CAST for (int i = 1; i < isize; i++) data[biter.index + i] = 0; } } } else { try { final int[] vr = toIntegerArray(o, isize); // PRIM_TYPE // CLASS_TYPE final BooleanIterator biter = getBooleanIterator(selection); while (biter.hasNext()) { for (int i = 0; i < isize; i++) data[biter.index + i] = vr[i]; } } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Object for setting is not a dataset or number"); } } return this; }
// get a list of station obs for this station public List getData(Station s, CancelTask cancel) throws IOException { ArrayStructure stationData = readData("ID " + s.getName(), cancel); ArrayList stationObs = new ArrayList(); IndexIterator ii = stationData.getIndexIterator(); while (ii.hasNext()) { stationObs.add(new StationObs((Station) s, (StructureData) ii.getObjectNext())); } return stationObs; }
/** * Copy a dataset or just wrap in a new reference (for Jython sub-classing) * * @param dataset * @param wrap */ public CompoundIntegerDataset(final CompoundIntegerDataset dataset, final boolean wrap) { isize = dataset.isize; size = dataset.size; if (wrap) { shape = dataset.shape; dataSize = dataset.dataSize; dataShape = dataset.dataShape; name = dataset.name; metadata = dataset.metadata; if (dataset.metadataStructure != null) metadataStructure = dataset.metadataStructure; odata = data = dataset.data; return; } shape = dataset.shape.clone(); name = new String(dataset.name); metadata = copyMetadataMap(dataset.metadata); if (dataset.metadataStructure != null) metadataStructure = dataset.metadataStructure.clone(); int[] gdata = dataset.data; // PRIM_TYPE if (dataset.isContiguous()) { odata = data = gdata.clone(); } else { odata = data = createArray(size); IndexIterator diter = dataset.getIterator(); IndexIterator iter = getIterator(); while (iter.hasNext() && diter.hasNext()) { for (int i = 0; i < isize; i++) { data[iter.index + i] = gdata[diter.index + i]; } } } errorValue = dataset.errorValue; errorData = dataset.errorData; errorArray = dataset.errorArray; errorCompoundData = dataset.errorCompoundData; }
/** * @param obj * @return dataset filled with given object */ @Override public CompoundIntegerDataset fill(final Object obj) { IndexIterator iter = getIterator(); int[] vr = toIntegerArray(obj, isize); // PRIM_TYPE // CLASS_TYPE while (iter.hasNext()) { for (int i = 0; i < isize; i++) data[iter.index + i] = vr[i]; // PRIM_TYPE } return this; }
@Override public StringDatasetBase fill(final Object obj) { String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT IndexIterator iter = getIterator(); while (iter.hasNext()) { data[iter.index] = dv; } setDirty(); return this; }
private Array convertToChar(Variable newVar, Array oldData) { ArrayChar newData = (ArrayChar) Array.factory(DataType.CHAR, newVar.getShape()); Index ima = newData.getIndex(); IndexIterator ii = oldData.getIndexIterator(); while (ii.hasNext()) { String s = (String) ii.getObjectNext(); int[] c = ii.getCurrentCounter(); for (int i = 0; i < c.length; i++) ima.setDim(i, c[i]); newData.setString(ima, s); } return newData; }
@Override public StringDatasetBase setSlice(final Object obj, final IndexIterator siter) { if (obj instanceof IDataset) { final IDataset ds = (IDataset) obj; final int[] oshape = ds.getShape(); if (!areShapesCompatible(siter.getShape(), oshape)) { throw new IllegalArgumentException( String.format( "Input dataset is not compatible with slice: %s cf %s", Arrays.toString(oshape), Arrays.toString(siter.getShape()))); } if (ds instanceof Dataset) { final Dataset ads = (Dataset) ds; final IndexIterator oiter = ads.getIterator(); while (siter.hasNext() && oiter.hasNext()) data[siter.index] = ads.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST } else { final IndexIterator oiter = new PositionIterator(oshape); final int[] pos = oiter.getPos(); while (siter.hasNext() && oiter.hasNext()) data[siter.index] = ds.getString(pos); // PRIM_TYPE } } else { try { String v = obj.toString(); // PRIM_TYPE // FROM_OBJECT while (siter.hasNext()) data[siter.index] = v; } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Object for setting slice is not a dataset or number"); } } setDirty(); return this; }
@Override public CompoundIntegerDataset getSlice(final SliceIterator siter) { CompoundIntegerDataset result = new CompoundIntegerDataset(isize, siter.getSliceShape()); int[] rdata = result.data; // PRIM_TYPE IndexIterator riter = result.getIterator(); while (siter.hasNext() && riter.hasNext()) { for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[siter.index + i]; } result.setName(name + ".slice"); return result; }
private List<int[]> findPositions(final String value) { // PRIM_TYPE IndexIterator iter = getIterator(true); List<int[]> posns = new ArrayList<int[]>(); int[] pos = iter.getPos(); { while (iter.hasNext()) { if (data[iter.index] == value) { posns.add(pos.clone()); } } } return posns; }
/** * Get the minimum and the maximum data value of the previously read Array, skipping missing * values as defined by isMissingData(double val). * * @param a Array to get min/max values * @return both min and max value. */ public MAMath.MinMax getMinMaxSkipMissingData(Array a) { if (!hasMissingData()) return MAMath.getMinMax(a); IndexIterator iter = a.getIndexIterator(); double max = -Double.MAX_VALUE; double min = Double.MAX_VALUE; while (iter.hasNext()) { double val = iter.getDoubleNext(); if (isMissingData(val)) continue; if (val > max) max = val; if (val < min) min = val; } return new MAMath.MinMax(min, max); }
// for jon blower private Array getEnhancedArray(VariableDS vds) throws IOException { Array data = vds.read(); EnumSet<NetcdfDataset.Enhance> mode = vds.getEnhanceMode(); if (mode.contains(NetcdfDataset.Enhance.ScaleMissing)) return data; if (!mode.contains(NetcdfDataset.Enhance.ScaleMissingDefer)) throw new IllegalStateException("Must include " + NetcdfDataset.Enhance.ScaleMissingDefer); IndexIterator ii = data.getIndexIterator(); while (ii.hasNext()) { double val = vds.convertScaleOffsetMissing(ii.getDoubleNext()); ii.setDoubleCurrent(val); } return data; }