/** @return all of the centroid values (for each dimension) */ @Override public double[] getCentroidPerDimension() { final NumericData[] ranges = getDataPerDimension(); final double[] centroid = new double[ranges.length]; for (int d = 0; d < ranges.length; d++) { centroid[d] = ranges[d].getCentroid(); } return centroid; }
/** @return all of the maximum values (for each dimension) */ @Override public double[] getMaxValuesPerDimension() { final NumericData[] ranges = getDataPerDimension(); final double[] maxPerDimension = new double[ranges.length]; for (int d = 0; d < ranges.length; d++) { maxPerDimension[d] = ranges[d].getMax(); } return maxPerDimension; }
/** @return all of the minimum values (for each dimension) */ @Override public double[] getMinValuesPerDimension() { final NumericData[] ranges = getDataPerDimension(); final double[] minPerDimension = new double[ranges.length]; for (int d = 0; d < ranges.length; d++) { minPerDimension[d] = ranges[d].getMin(); } return minPerDimension; }
private static int getRanges(final MultiDimensionalNumericData indexedData) { final double[] mins = indexedData.getMinValuesPerDimension(); final double[] maxes = indexedData.getMaxValuesPerDimension(); int ranges = 0; for (int d = 0; d < mins.length; d++) { if (!FloatCompareUtils.checkDoublesEqual(mins[d], maxes[d])) { ranges++; } } return ranges; }
public boolean isWithin(final NumericData timeRange) { final double st = startTime.getTime(); final double et = endTime.getTime(); final double rst = timeRange.getMin(); final double ret = timeRange.getMax(); return (((st < rst) && (et > rst)) || ((st < ret) && (et > ret)) || ((st < rst) && (et > ret))); }
public static MultiDimensionalNumericData getBoundsFromEnvelope(final Envelope envelope) { final NumericRange[] boundsPerDimension = new NumericRange[2]; boundsPerDimension[0] = new NumericRange(envelope.getMinX(), envelope.getMaxX()); boundsPerDimension[1] = new NumericRange(envelope.getMinY(), envelope.getMaxY()); return new BasicNumericDataset(boundsPerDimension); }
@Override public NumericRange getBounds() { return new NumericRange(min, max); } }
@Override public MultiDimensionalNumericData getRangeForId( final byte[] partitionKey, final byte[] sortKey) { final long value = Long.class.cast(lexicoder.fromByteArray(sortKey)); final NumericData[] dataPerDimension = new NumericData[] {new NumericValue(value)}; return new BasicNumericDataset(dataPerDimension); }
/** @return an array of min values associated with each dimension */ @Override public double[] getMinValuesPerDimension() { return indexRanges.getMinValuesPerDimension(); }
/** @return an array of max values associated with each dimension */ @Override public double[] getMaxValuesPerDimension() { return indexRanges.getMaxValuesPerDimension(); }
private static boolean queryRangeDimensionsMatch( final int indexDimensions, final List<MultiDimensionalNumericData> queryRanges) { for (final MultiDimensionalNumericData qr : queryRanges) { if (qr.getDimensionCount() != indexDimensions) { return false; } } return true; } }
@Override public MultiDimensionalNumericData getRanges(final byte[] id) { // use max range per dimension for now // to avoid false negatives final NumericData[] dataPerDimension = new NumericData[dimensionCount]; int i = 0; for (final SFCDimensionDefinition dim : dimensionDefs) { dataPerDimension[i++] = dim.getFullRange(); } return new BasicNumericDataset(dataPerDimension); }
/** @return an array of NumericData objects associated with this object. */ @Override public NumericData[] getDataPerDimension() { return indexRanges.getDataPerDimension(); }
@Override public boolean isEmpty() { return indexRanges.isEmpty(); }
@Override public NumericData toNumericData() { return new NumericValue(time); }
/** @return an array of centroid values associated with each dimension */ @Override public double[] getCentroidPerDimension() { return indexRanges.getCentroidPerDimension(); }
public boolean intersects(final ConstraintData cd) { final double i1 = cd.range.getMin(); final double i2 = cd.range.getMax(); final double j1 = range.getMin(); final double j2 = range.getMax(); return ((i1 < j2) || DoubleMath.fuzzyEquals(i1, j2, DOUBLE_TOLERANCE)) && ((i2 > j1) || DoubleMath.fuzzyEquals(i2, j1, DOUBLE_TOLERANCE)); }
@Override public NumericData getFullRange() { return new NumericRange(min, max); }
/** @return the number of total dimensions */ @Override public int getDimensionCount() { return indexRanges.getDimensionCount(); }
@Override public NumericData toNumericData() { return new NumericRange(startTime, endTime); }