/** @return an array of NumericData objects associated with this object. */ @Override public NumericData[] getDataPerDimension() { return indexRanges.getDataPerDimension(); }
public static BinRange[][] getBinnedRangesPerDimension( final MultiDimensionalNumericData numericData, final NumericDimensionDefinition[] dimensionDefinitions) { if (dimensionDefinitions.length == 0) { return new BinRange[0][]; } final BinRange[][] binRangesPerDimension = new BinRange[dimensionDefinitions.length][]; for (int d = 0; d < dimensionDefinitions.length; d++) { binRangesPerDimension[d] = dimensionDefinitions[d].getNormalizedRanges(numericData.getDataPerDimension()[d]); } return binRangesPerDimension; }
/** * Tool can be used custom index strategies to check if the tiles actual intersect with the * provided bounding box. * * @param boxRangeData * @param innerTile * @return */ private boolean checkCoverage( final MultiDimensionalNumericData boxRangeData, final MultiDimensionalNumericData innerTile) { for (int i = 0; i < boxRangeData.getDimensionCount(); i++) { final double i1 = innerTile.getDataPerDimension()[i].getMin(); final double i2 = innerTile.getDataPerDimension()[i].getMax(); final double j1 = boxRangeData.getDataPerDimension()[i].getMin(); final double j2 = boxRangeData.getDataPerDimension()[i].getMax(); final boolean overlaps = ((i1 < j2) || DoubleMath.fuzzyEquals(i1, j2, DOUBLE_TOLERANCE)) && ((i2 > j1) || DoubleMath.fuzzyEquals(i2, j1, DOUBLE_TOLERANCE)); if (!overlaps) { return false; } } return true; }
final List<NumericData> numericDataPerDimension = new ArrayList<>(); final List<NumericDimensionField<?>> fields = new ArrayList<>(); final NumericData[] data = query.getDataPerDimension(); for (int d = 0; d < orderedConstrainedDimensionDefinitions.length; d++) {
/** * {@inheritDoc} */ @Override public RangeDecomposition decomposeRange( final MultiDimensionalNumericData query, final boolean overInclusiveOnEdge, int maxFilteredIndexedRanges) { if (maxFilteredIndexedRanges == -1) { maxFilteredIndexedRanges = Integer.MAX_VALUE; } final QueryCacheKey key = new QueryCacheKey( query.getMinValuesPerDimension(), query.getMaxValuesPerDimension(), overInclusiveOnEdge, maxFilteredIndexedRanges); RangeDecomposition rangeDecomp = queryDecompositionCache.get(key); if (rangeDecomp == null) { rangeDecomp = decomposeQueryOperations.decomposeRange( query.getDataPerDimension(), compactHilbertCurve, dimensionDefinitions, totalPrecision, maxFilteredIndexedRanges, REMOVE_VACUUM, overInclusiveOnEdge); queryDecompositionCache.put(key, rangeDecomp); } return rangeDecomp; }
@Override public byte[] toBinary() { int byteBufferLength = VarintUtils.unsignedIntByteLength(compareOp.ordinal()); final int dimensions = Math.min(constraints.getDimensionCount(), dimensionFields.length); byteBufferLength += VarintUtils.unsignedIntByteLength(dimensions); final byte[][] lengthDimensionAndQueryBinaries = new byte[dimensions][]; final NumericData[] dataPerDimension = constraints.getDataPerDimension(); for (int d = 0; d < dimensions; d++) { final NumericDimensionField<?> dimension = dimensionFields[d]; final NumericData data = dataPerDimension[d]; final byte[] dimensionBinary = PersistenceUtils.toBinary(dimension); final int currentDimensionByteBufferLength = (16 + dimensionBinary.length + VarintUtils.unsignedIntByteLength(dimensionBinary.length)); final ByteBuffer buf = ByteBuffer.allocate(currentDimensionByteBufferLength); VarintUtils.writeUnsignedInt(dimensionBinary.length, buf); buf.putDouble(data.getMin()); buf.putDouble(data.getMax()); buf.put(dimensionBinary); byteBufferLength += currentDimensionByteBufferLength; lengthDimensionAndQueryBinaries[d] = buf.array(); } final ByteBuffer buf = ByteBuffer.allocate(byteBufferLength); VarintUtils.writeUnsignedInt(compareOp.ordinal(), buf); VarintUtils.writeUnsignedInt(dimensions, buf); for (final byte[] binary : lengthDimensionAndQueryBinaries) { buf.put(binary); } return buf.array(); }
public static MultiDimensionalNumericData getRangeForId( final byte[] rowId, final NumericDimensionDefinition[] baseDefinitions, final SpaceFillingCurve sfc) { final SFCIdAndBinInfo sfcIdAndBinInfo = getSFCIdAndBinInfo(rowId, baseDefinitions); final MultiDimensionalNumericData numericData = sfc.getRanges(sfcIdAndBinInfo.sfcId); // now we need to unapply the bins to the data, denormalizing the // ranges to the native bounds if (sfcIdAndBinInfo.rowIdOffset > 1) { final NumericData[] data = numericData.getDataPerDimension(); for (final Entry<Integer, byte[]> entry : sfcIdAndBinInfo.binIds.entrySet()) { final int dimension = entry.getKey(); final NumericRange range = baseDefinitions[dimension].getDenormalizedRange( new BinRange( entry.getValue(), data[dimension].getMin(), data[dimension].getMax(), false)); data[dimension] = range; } return new BasicNumericDataset(data); } return numericData; }
protected boolean validateConstraints( final BasicQueryCompareOp op, final MultiDimensionalNumericData queryRange, final MultiDimensionalNumericData dataRange) { final NumericData[] queryRangePerDimension = queryRange.getDataPerDimension(); final double[] minPerDimension = dataRange.getMinValuesPerDimension(); final double[] maxPerDimension = dataRange.getMaxValuesPerDimension(); boolean ok = true; for (int d = 0; (d < dimensionFields.length) && ok; d++) { ok &= op.compare( minPerDimension[d], maxPerDimension[d], queryRangePerDimension[d].getMin(), queryRangePerDimension[d].getMax()); } return ok; }
index.getIndexStrategy().getRangeForId(partitionKey, sortKey).getDataPerDimension(), index)) { it.remove();