public MultiDimensionalNumericData getIndexConstraints( final NumericIndexStrategy indexStrategy) { if (constraintsPerTypeOfDimensionDefinition.isEmpty()) { return new BasicNumericDataset(); } final NumericDimensionDefinition[] dimensionDefinitions = indexStrategy.getOrderedDimensionDefinitions(); final NumericData[] dataPerDimension = new NumericData[dimensionDefinitions.length]; // all or nothing...for now for (int d = 0; d < dimensionDefinitions.length; d++) { final ConstraintData dimConstraint = constraintsPerTypeOfDimensionDefinition.get(dimensionDefinitions[d].getClass()); if (dimConstraint == null) { return new BasicNumericDataset(); } dataPerDimension[d] = dimConstraint.range; } return new BasicNumericDataset(dataPerDimension); }
/** @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; }
@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 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; }
public static MultiDimensionalNumericData getFullBounds( final NumericDimensionDefinition[] dimensionDefinitions) { final NumericRange[] boundsPerDimension = new NumericRange[dimensionDefinitions.length]; for (int d = 0; d < dimensionDefinitions.length; d++) { boundsPerDimension[d] = dimensionDefinitions[d].getBounds(); } return new BasicNumericDataset(boundsPerDimension); }
/** @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; }
@Override public MultiDimensionalNumericData getRanges(final byte[] id) { return new BasicNumericDataset( ZOrderUtils.decodeRanges(id, cardinalityPerDimension, dimensionDefs)); }
@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); }
new BasicNumericDataset( numericDataPerDimension.toArray(new NumericData[numericDataPerDimension.size()])), fields.toArray(new NumericDimensionField<?>[fields.size()]),
new BasicNumericDataset(orderedConstraintsPerDimension), orderedConstrainedDimensionFields, unconstrainedDimensionFields,
@Override public MultiDimensionalNumericData convertFromHilbert( final byte[] hilbertValue, final CompactHilbertCurve compactHilbertCurve, final SFCDimensionDefinition[] dimensionDefinitions) { final BitVector[] perDimensionBitVectors = indexInverse(hilbertValue, compactHilbertCurve, dimensionDefinitions); final NumericRange[] retVal = new NumericRange[dimensionDefinitions.length]; for (int i = 0; i < retVal.length; i++) { retVal[i] = denormalizeDimension( dimensionDefinitions[i], perDimensionBitVectors[i].toExactLong(), binsPerDimension[i]); } return new BasicNumericDataset(retVal); }
@Override public void fromBinary(final byte[] bytes) { final ByteBuffer buf = ByteBuffer.wrap(bytes); compareOp = BasicQueryCompareOperation.values()[VarintUtils.readUnsignedInt(buf)]; final int numDimensions = VarintUtils.readUnsignedInt(buf); dimensionFields = new NumericDimensionField<?>[numDimensions]; final NumericData[] data = new NumericData[numDimensions]; for (int d = 0; d < numDimensions; d++) { final byte[] field = new byte[VarintUtils.readUnsignedInt(buf)]; data[d] = new NumericRange(buf.getDouble(), buf.getDouble()); buf.get(field); dimensionFields[d] = (NumericDimensionField<?>) PersistenceUtils.fromBinary(field); } constraints = new BasicNumericDataset(data); init(constraints, dimensionFields); } }
@Override public MultiDimensionalNumericData convertFromHilbert( final byte[] hilbertValue, final CompactHilbertCurve compactHilbertCurve, final SFCDimensionDefinition[] dimensionDefinitions) { final BitVector[] perDimensionBitVectors = PrimitiveHilbertSFCOperations.indexInverse( hilbertValue, compactHilbertCurve, dimensionDefinitions); final NumericRange[] retVal = new NumericRange[dimensionDefinitions.length]; for (int i = 0; i < retVal.length; i++) { retVal[i] = denormalizeDimension( dimensionDefinitions[i], perDimensionBitVectors[i].toBigInteger(), binsPerDimension[i]); } return new BasicNumericDataset(retVal); }
new BinnedNumericDataset( binRangesPerDimension[dimension][i].getBinId(), new BasicNumericDataset(rangePerDimension)); current.getBinId(), binRangesPerDimension[dimension][i].getBinId()); next = new BinnedNumericDataset(combinedBinId, new BasicNumericDataset(rangePerDimension));
/** * Given an ordered set of dimensions, convert this persistent encoding common index data into a * MultiDimensionalNumericData object that can then be used by the Index * * @param dimensions * @return */ @SuppressWarnings({"rawtypes", "unchecked"}) public MultiDimensionalNumericData getNumericData(final NumericDimensionField[] dimensions) { final NumericData[] dataPerDimension = new NumericData[dimensions.length]; for (int d = 0; d < dimensions.length; d++) { final CommonIndexValue val = getCommonData().getValue(dimensions[d].getFieldName()); if (val != null) { dataPerDimension[d] = dimensions[d].getNumericData(val); } } return new BasicNumericDataset(dataPerDimension); }
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; }
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); }
new BasicNumericDataset(ranges)).getFirstPartitionAndSortKeyPair();