Examples with SortedNumericDoubleValues org.elasticsearch.index.fielddata.SortedNumericDoubleValues used on opensource projects

Example 11 with SortedNumericDoubleValues

use of org.elasticsearch.index.fielddata.SortedNumericDoubleValues in project elasticsearch by elastic.

the class MultiValueModeTests method testUnsortedSingleValuedDoubles.

public void testUnsortedSingleValuedDoubles() throws Exception {
    final int numDocs = scaledRandomIntBetween(1, 100);
    final double[] array = new double[numDocs];
    final FixedBitSet docsWithValue = randomBoolean() ? null : new FixedBitSet(numDocs);
    for (int i = 0; i < array.length; ++i) {
        if (randomBoolean()) {
            array[i] = randomDouble();
            if (docsWithValue != null) {
                docsWithValue.set(i);
            }
        } else if (docsWithValue != null && randomBoolean()) {
            docsWithValue.set(i);
        }
    }
    final NumericDoubleValues singleValues = new NumericDoubleValues() {

        @Override
        public double get(int docID) {
            return array[docID];
        }
    };
    final SortedNumericDoubleValues singletonValues = FieldData.singleton(singleValues, docsWithValue);
    final MultiValueMode.UnsortedNumericDoubleValues multiValues = new MultiValueMode.UnsortedNumericDoubleValues() {

        @Override
        public int count() {
            return singletonValues.count();
        }

        @Override
        public void setDocument(int doc) {
            singletonValues.setDocument(doc);
        }

        @Override
        public double valueAt(int index) {
            return Math.cos(singletonValues.valueAt(index));
        }
    };
    verify(multiValues, numDocs);
}

Example 12 with SortedNumericDoubleValues

use of org.elasticsearch.index.fielddata.SortedNumericDoubleValues in project elasticsearch by elastic.

the class MultiValueModeTests method verify.

private void verify(SortedNumericDoubleValues values, int maxDoc, FixedBitSet rootDocs, FixedBitSet innerDocs) throws IOException {
    for (long missingValue : new long[] { 0, randomLong() }) {
        for (MultiValueMode mode : new MultiValueMode[] { MultiValueMode.MIN, MultiValueMode.MAX, MultiValueMode.SUM, MultiValueMode.AVG }) {
            final NumericDoubleValues selected = mode.select(values, missingValue, rootDocs, new BitSetIterator(innerDocs, 0L), maxDoc);
            int prevRoot = -1;
            for (int root = rootDocs.nextSetBit(0); root != -1; root = root + 1 < maxDoc ? rootDocs.nextSetBit(root + 1) : -1) {
                final double actual = selected.get(root);
                double expected = 0.0;
                if (mode == MultiValueMode.MAX) {
                    expected = Long.MIN_VALUE;
                } else if (mode == MultiValueMode.MIN) {
                    expected = Long.MAX_VALUE;
                }
                int numValues = 0;
                for (int child = innerDocs.nextSetBit(prevRoot + 1); child != -1 && child < root; child = innerDocs.nextSetBit(child + 1)) {
                    values.setDocument(child);
                    for (int j = 0; j < values.count(); ++j) {
                        if (mode == MultiValueMode.SUM || mode == MultiValueMode.AVG) {
                            expected += values.valueAt(j);
                        } else if (mode == MultiValueMode.MIN) {
                            expected = Math.min(expected, values.valueAt(j));
                        } else if (mode == MultiValueMode.MAX) {
                            expected = Math.max(expected, values.valueAt(j));
                        }
                        ++numValues;
                    }
                }
                if (numValues == 0) {
                    expected = missingValue;
                } else if (mode == MultiValueMode.AVG) {
                    expected = expected / numValues;
                }
                assertEquals(mode.toString() + " docId=" + root, expected, actual, 0.1);
                prevRoot = root;
            }
        }
    }
}

Example 13 with SortedNumericDoubleValues

use of org.elasticsearch.index.fielddata.SortedNumericDoubleValues in project elasticsearch by elastic.

the class MultiValueModeTests method verify.

private void verify(SortedNumericDoubleValues values, int maxDoc) {
    for (long missingValue : new long[] { 0, randomLong() }) {
        for (MultiValueMode mode : MultiValueMode.values()) {
            if (MultiValueMode.MEDIAN.equals(mode)) {
                continue;
            }
            final NumericDoubleValues selected = mode.select(values, missingValue);
            for (int i = 0; i < maxDoc; ++i) {
                final double actual = selected.get(i);
                double expected = 0.0;
                values.setDocument(i);
                int numValues = values.count();
                if (numValues == 0) {
                    expected = missingValue;
                } else {
                    if (mode == MultiValueMode.MAX) {
                        expected = Long.MIN_VALUE;
                    } else if (mode == MultiValueMode.MIN) {
                        expected = Long.MAX_VALUE;
                    }
                    for (int j = 0; j < numValues; ++j) {
                        if (mode == MultiValueMode.SUM || mode == MultiValueMode.AVG) {
                            expected += values.valueAt(j);
                        } else if (mode == MultiValueMode.MIN) {
                            expected = Math.min(expected, values.valueAt(j));
                        } else if (mode == MultiValueMode.MAX) {
                            expected = Math.max(expected, values.valueAt(j));
                        }
                    }
                    if (mode == MultiValueMode.AVG) {
                        expected = expected / numValues;
                    } else if (mode == MultiValueMode.MEDIAN) {
                        int value = numValues / 2;
                        if (numValues % 2 == 0) {
                            expected = (values.valueAt(value - 1) + values.valueAt(value)) / 2.0;
                        } else {
                            expected = values.valueAt(value);
                        }
                    }
                }
                assertEquals(mode.toString() + " docId=" + i, expected, actual, 0.1);
            }
        }
    }
}

Example 14 with SortedNumericDoubleValues

use of org.elasticsearch.index.fielddata.SortedNumericDoubleValues in project elasticsearch by elastic.

the class MissingValuesTests method testMissingDoubles.

public void testMissingDoubles() {
    final int numDocs = TestUtil.nextInt(random(), 1, 100);
    final double[][] values = new double[numDocs][];
    for (int i = 0; i < numDocs; ++i) {
        values[i] = new double[random().nextInt(4)];
        for (int j = 0; j < values[i].length; ++j) {
            values[i][j] = randomDouble();
        }
        Arrays.sort(values[i]);
    }
    SortedNumericDoubleValues asNumericValues = new SortedNumericDoubleValues() {

        int i = -1;

        @Override
        public double valueAt(int index) {
            return values[i][index];
        }

        @Override
        public void setDocument(int docId) {
            i = docId;
        }

        @Override
        public int count() {
            return values[i].length;
        }
    };
    final long missing = randomInt();
    SortedNumericDoubleValues withMissingReplaced = MissingValues.replaceMissing(asNumericValues, missing);
    for (int i = 0; i < numDocs; ++i) {
        withMissingReplaced.setDocument(i);
        if (values[i].length > 0) {
            assertEquals(values[i].length, withMissingReplaced.count());
            for (int j = 0; j < values[i].length; ++j) {
                assertEquals(values[i][j], withMissingReplaced.valueAt(j), 0);
            }
        } else {
            assertEquals(1, withMissingReplaced.count());
            assertEquals(missing, withMissingReplaced.valueAt(0), 0);
        }
    }
}

Example 15 with SortedNumericDoubleValues

use of org.elasticsearch.index.fielddata.SortedNumericDoubleValues in project elasticsearch by elastic.

the class RangeAggregator method getLeafCollector.

@Override
public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, final LeafBucketCollector sub) throws IOException {
    final SortedNumericDoubleValues values = valuesSource.doubleValues(ctx);
    return new LeafBucketCollectorBase(sub, values) {

        @Override
        public void collect(int doc, long bucket) throws IOException {
            values.setDocument(doc);
            final int valuesCount = values.count();
            for (int i = 0, lo = 0; i < valuesCount; ++i) {
                final double value = values.valueAt(i);
                lo = collect(doc, value, bucket, lo);
            }
        }

        private int collect(int doc, double value, long owningBucketOrdinal, int lowBound) throws IOException {
            // all candidates are between these indexes
            int lo = lowBound, hi = ranges.length - 1;
            int mid = (lo + hi) >>> 1;
            while (lo <= hi) {
                if (value < ranges[mid].from) {
                    hi = mid - 1;
                } else if (value >= maxTo[mid]) {
                    lo = mid + 1;
                } else {
                    break;
                }
                mid = (lo + hi) >>> 1;
            }
            // no potential candidate
            if (lo > hi)
                return lo;
            // binary search the lower bound
            int startLo = lo, startHi = mid;
            while (startLo <= startHi) {
                final int startMid = (startLo + startHi) >>> 1;
                if (value >= maxTo[startMid]) {
                    startLo = startMid + 1;
                } else {
                    startHi = startMid - 1;
                }
            }
            // binary search the upper bound
            int endLo = mid, endHi = hi;
            while (endLo <= endHi) {
                final int endMid = (endLo + endHi) >>> 1;
                if (value < ranges[endMid].from) {
                    endHi = endMid - 1;
                } else {
                    endLo = endMid + 1;
                }
            }
            assert startLo == lowBound || value >= maxTo[startLo - 1];
            assert endHi == ranges.length - 1 || value < ranges[endHi + 1].from;
            for (int i = startLo; i <= endHi; ++i) {
                if (ranges[i].matches(value)) {
                    collectBucket(sub, doc, subBucketOrdinal(owningBucketOrdinal, i));
                }
            }
            return endHi + 1;
        }
    };
}