private double[][] getDataTotal(double[] xData, double[] yData) { int nExtraPoints = _xValuesClamped.length; int nData = xData.length; int nTotal = nExtraPoints + nData; double[] xValuesTotal = new double[nTotal]; double[] yValuesTotal = new double[nTotal]; System.arraycopy(xData, 0, xValuesTotal, 0, nData); System.arraycopy(yData, 0, yValuesTotal, 0, nData); System.arraycopy(_xValuesClamped, 0, xValuesTotal, nData, nExtraPoints); System.arraycopy(_yValuesClamped, 0, yValuesTotal, nData, nExtraPoints); DoubleArrayMath.sortPairs(xValuesTotal, yValuesTotal); return new double[][] {xValuesTotal, yValuesTotal }; }
private double[][] getDataTotal(double[] xData, double[] yData) { int nExtraPoints = _xValuesClamped.length; int nData = xData.length; int nTotal = nExtraPoints + nData; double[] xValuesTotal = new double[nTotal]; double[] yValuesTotal = new double[nTotal]; System.arraycopy(xData, 0, xValuesTotal, 0, nData); System.arraycopy(yData, 0, yValuesTotal, 0, nData); System.arraycopy(_xValuesClamped, 0, xValuesTotal, nData, nExtraPoints); System.arraycopy(_yValuesClamped, 0, yValuesTotal, nData, nExtraPoints); DoubleArrayMath.sortPairs(xValuesTotal, yValuesTotal); double[] xyTotal = getProduct(xValuesTotal, yValuesTotal); return new double[][] {xValuesTotal, xyTotal }; }
public void test_sortPairs_doubledouble_sizeDifferent() { double[] keys = {3d, 2d, 5d, 4d}; double[] values = {6d, 4d}; assertThrowsIllegalArg(() -> DoubleArrayMath.sortPairs(keys, values)); }
public void test_sortPairs_doubleObject_sizeDifferent() { double[] keys = {3d, 2d, 5d, 4d}; Integer[] values = {6, 4}; assertThrowsIllegalArg(() -> DoubleArrayMath.sortPairs(keys, values)); }
public void test_sortPairs_doubleObject_2() { double[] keys = {3d, 2d, 5d, 4d}; Integer[] values = {6, 4, 10, 8}; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4, 6, 8, 10); }
public void test_sortPairs_doubledouble_2() { double[] keys = {3d, 2d, 5d, 4d}; double[] values = {6d, 4d, 10d, 8d}; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4d, 6d, 8d, 10d); }
public void test_sortPairs_doubleObject_1() { double[] keys = {3d, 5d, 2d, 4d}; Integer[] values = {6, 10, 4, 8}; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4, 6, 8, 10); }
public void test_sortPairs_doubledouble_1() { double[] keys = {3d, 5d, 2d, 4d}; double[] values = {6d, 10d, 4d, 8d}; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4d, 6d, 8d, 10d); }
private QuantileResult quantileDetails( double level, DoubleArray sample, boolean isExtrapolated, boolean isEs) { int nbData = sample.size(); double[] w = weights(nbData); /* Sorting data and keeping weight information. The arrays are modified */ double[] s = sample.toArray(); DoubleArrayMath.sortPairs(s, w); double[] s2 = sample.toArray(); double[] order = new double[s2.length]; for (int i = 0; i < s2.length; i++) { order[i] = i; } DoubleArrayMath.sortPairs(s2, order); /* Find the index. */ double runningWeight = 0.0d; int index = nbData; while (runningWeight < 1.0d - level) { index--; runningWeight += w[index]; } if (isEs) { return esFromIndexRunningWeight(index, runningWeight, s2, w, order, level); } return quantileFromIndexRunningWeight(index, runningWeight, isExtrapolated, s2, w, order, level); }
DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt);
DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt);
DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt);
@Override public PiecewisePolynomialResult interpolate(final double[] xValues, final double[] yValues) { ArgChecker.notNull(xValues, "xValues"); ArgChecker.notNull(yValues, "yValues"); ArgChecker.isTrue(xValues.length == yValues.length, "xValues length = yValues length"); ArgChecker.isTrue(xValues.length > 1, "Data points should be more than 1"); final int nDataPts = xValues.length; for (int i = 0; i < nDataPts; ++i) { ArgChecker.isFalse(Double.isNaN(xValues[i]), "xData containing NaN"); ArgChecker.isFalse(Double.isInfinite(xValues[i]), "xData containing Infinity"); ArgChecker.isFalse(Double.isNaN(yValues[i]), "yData containing NaN"); ArgChecker.isFalse(Double.isInfinite(yValues[i]), "yData containing Infinity"); } double[] xValuesSrt = Arrays.copyOf(xValues, nDataPts); double[] yValuesSrt = Arrays.copyOf(yValues, nDataPts); DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt); for (int i = 1; i < nDataPts; ++i) { ArgChecker.isFalse(xValuesSrt[i - 1] == xValuesSrt[i], "xValues should be distinct"); } final DoubleMatrix coefMatrix = solve(xValuesSrt, yValuesSrt); for (int i = 0; i < coefMatrix.rowCount(); ++i) { for (int j = 0; j < coefMatrix.columnCount(); ++j) { ArgChecker.isFalse(Double.isNaN(coefMatrix.get(i, j)), "Too large input"); ArgChecker.isFalse(Double.isInfinite(coefMatrix.get(i, j)), "Too large input"); } } return new PiecewisePolynomialResult(DoubleArray.copyOf(xValuesSrt), coefMatrix, coefMatrix.columnCount(), 1); }
DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt);
@Override protected QuantileResult quantile(double level, DoubleArray sample, boolean isExtrapolated) { ArgChecker.isTrue(level > 0, "Quantile should be above 0."); ArgChecker.isTrue(level < 1, "Quantile should be below 1."); int sampleSize = sampleCorrection(sample.size()); double adjustedLevel = checkIndex(level * sampleSize + indexCorrection(), sample.size(), isExtrapolated); double[] order = createIndexArray(sample.size()); double[] s = sample.toArray(); DoubleArrayMath.sortPairs(s, order); int lowerIndex = (int) Math.floor(adjustedLevel); int upperIndex = (int) Math.ceil(adjustedLevel); double lowerWeight = upperIndex - adjustedLevel; double upperWeight = 1d - lowerWeight; return QuantileResult.of( lowerWeight * s[lowerIndex - 1] + upperWeight * s[upperIndex - 1], new int[]{(int) order[lowerIndex - 1], (int) order[upperIndex - 1]}, DoubleArray.of(lowerWeight, upperWeight)); }
private void check_quantile(double level) { double[] w = METHOD.weights(DATA_123.size()); double qComputed = METHOD.quantileFromUnsorted(level, DATA_123); double WI1 = 0.0d; int nbW = 0; for (int i = 0; i < DATA_123.size(); i++) { if (DATA_123.get(i) > qComputed) { WI1 += w[i]; nbW++; } } assertTrue(WI1 < 1.0d - level, "Weight of tail lower than level"); double[] w2 = w.clone(); double[] data = DATA_123.toArray(); DoubleArrayMath.sortPairs(data, w2); double WI = WI1 + w2[w.length - 1 - nbW]; assertTrue(WI > 1.0d - level, "Weight of tail+1 larger than level"); double alpha = (WI - (1 - level)) / (WI - WI1); double qExpected = (1 - alpha) * data[w.length - 1 - nbW] + alpha * data[w.length - 1 - nbW + 1]; assertEquals(qComputed, qExpected, TOLERANCE_WEIGHT, "Quantile."); }
DoubleArrayMath.sortPairs(xValuesSrt, yValuesSrt); for (int i = 1; i < nDataPts; ++i) { ArgChecker.isFalse(xValuesSrt[i - 1] == xValuesSrt[i], "xValues should be distinct");
@Override protected QuantileResult quantile(double level, DoubleArray sample, boolean isExtrapolated) { ArgChecker.isTrue(level > 0, "Quantile should be above 0."); ArgChecker.isTrue(level < 1, "Quantile should be below 1."); int sampleSize = sampleCorrection(sample.size()); double[] order = createIndexArray(sample.size()); double[] s = sample.toArray(); DoubleArrayMath.sortPairs(s, order); int index = (int) checkIndex(index(level * sampleSize), sample.size(), isExtrapolated); int[] ind = new int[1]; ind[0] = (int) order[index - 1]; return QuantileResult.of(s[index - 1], ind, DoubleArray.of(1)); }
double[] order = createIndexArray(sample.size()); double[] s = sample.toArray(); DoubleArrayMath.sortPairs(s, order); int lowerIndex = (int) Math.floor(adjustedLevel); int upperIndex = (int) Math.ceil(adjustedLevel);
@Override protected QuantileResult expectedShortfall(double level, DoubleArray sample) { ArgChecker.isTrue(level > 0, "Quantile should be above 0."); ArgChecker.isTrue(level < 1, "Quantile should be below 1."); int sampleSize = sampleCorrection(sample.size()); double[] order = createIndexArray(sample.size()); double[] s = sample.toArray(); DoubleArrayMath.sortPairs(s, order); double fractionalIndex = level * sampleSize; int index = (int) checkIndex(index(fractionalIndex), sample.size(), true); int[] indices = new int[index]; double[] weights = new double[index]; double interval = 1d / (double) sampleSize; double losses = s[0] * interval * indexShift(); for (int i = 0; i < index - 1; i++) { losses += s[i] * interval; indices[i] = (int) order[i]; weights[i] = interval; } losses += s[index - 1] * (fractionalIndex - index + 1 - indexShift()) * interval; indices[index - 1] = (int) order[index - 1]; weights[0] += interval * indexShift(); weights[index - 1] = (fractionalIndex - index + 1 - indexShift()) * interval; return QuantileResult.of(losses / level, indices, DoubleArray.ofUnsafe(weights).dividedBy(level)); }