| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.datasketches.req; |
| |
| import static org.apache.datasketches.InequalitySearch.GE; |
| import static org.apache.datasketches.InequalitySearch.GT; |
| import static org.apache.datasketches.InequalitySearch.LE; |
| import static org.apache.datasketches.InequalitySearch.LT; |
| import static org.testng.Assert.assertEquals; |
| import static org.testng.Assert.assertNotNull; |
| import static org.testng.Assert.assertNull; |
| import static org.testng.Assert.assertTrue; |
| import static org.testng.Assert.fail; |
| |
| import org.apache.datasketches.InequalitySearch; |
| import org.apache.datasketches.SketchesArgumentException; |
| import org.testng.annotations.Test; |
| |
| /** |
| * @author Lee Rhodes |
| */ |
| @SuppressWarnings({"javadoc", "unused"}) |
| public class ReqSketchOtherTest { |
| final ReqSketchTest reqSketchTest = new ReqSketchTest(); |
| static InequalitySearch critLT = LT; |
| static InequalitySearch critLE = LE; |
| static InequalitySearch critGT = GT; |
| static InequalitySearch critGE = GE; |
| |
| @Test |
| public void checkConstructors() { |
| final ReqSketch sk = ReqSketch.builder().build(); |
| assertEquals(sk.getK(), 12); |
| } |
| |
| @Test |
| public void checkCopyConstructors() { |
| final boolean ltEq = true; |
| final ReqSketch sk = reqSketchTest.loadSketch( 6, 1, 50, true, true, ltEq, 0); |
| final long n = sk.getN(); |
| final float min = sk.getMinValue(); |
| final float max = sk.getMaxValue(); |
| final ReqSketch sk2 = new ReqSketch(sk); |
| assertEquals(sk2.getMinValue(), min); |
| assertEquals(sk2.getMaxValue(), max); |
| } |
| |
| @Test |
| public void checkNonFinitePMF_CDF() { |
| final ReqSketch sk = ReqSketch.builder().build(); |
| sk.update(1); |
| try { //splitpoint values must be finite |
| sk.getCDF(new float[] { Float.NaN }); |
| fail(); |
| } |
| catch (final SketchesArgumentException e) {} |
| } |
| |
| @Test |
| public void checkQuantilesExceedLimits() { |
| final boolean ltEq = true; |
| final ReqSketch sk = reqSketchTest.loadSketch( 6, 1, 200, true, true, ltEq, 0); |
| try { sk.getQuantile(2.0f); fail(); } catch (final SketchesArgumentException e) {} |
| try { sk.getQuantile(-2.0f); fail(); } catch (final SketchesArgumentException e) {} |
| } |
| |
| @Test |
| public void checkEstimationMode() { |
| final boolean up = true; |
| final boolean hra = true; |
| final boolean ltEq = true; |
| final ReqSketch sk = reqSketchTest.loadSketch( 20, 1, 119, up, hra, ltEq, 0); |
| assertEquals(sk.isEstimationMode(), false); |
| final double lb = sk.getRankLowerBound(1.0, 1); |
| final double ub = sk.getRankUpperBound(1.0, 1); |
| assertEquals(lb, 1.0); |
| assertEquals(ub, 1.0); |
| int maxNomSize = sk.getMaxNomSize(); |
| assertEquals(maxNomSize, 120); |
| sk.update(120); |
| assertEquals(sk.isEstimationMode(), true); |
| // lb = sk.getRankLowerBound(0, 1); |
| // ub = sk.getRankUpperBound(1.0, 1); |
| // assertEquals(lb, 0.0); |
| // assertEquals(ub, 2.0); |
| maxNomSize = sk.getMaxNomSize(); |
| assertEquals(maxNomSize, 240); |
| final float v = sk.getQuantile(1.0); |
| assertEquals(v, 120.0f); |
| final ReqAuxiliary aux = sk.getAux(); |
| assertNotNull(aux); |
| assertTrue(sk.getRSE(sk.getK(), .5, false, 120) > 0); |
| assertTrue(sk.getSerializationBytes() > 0); |
| } |
| |
| @Test |
| public void checkNaNUpdate() { |
| final InequalitySearch criterion = LE; |
| final ReqSketch sk = ReqSketch.builder().build(); |
| sk.update(Float.NaN); |
| assertTrue(sk.isEmpty()); |
| } |
| |
| @Test |
| public void checkNonFiniteGetRank() { |
| final ReqSketch sk = ReqSketch.builder().build(); |
| sk.update(1); |
| try { sk.getRank(Float.POSITIVE_INFINITY); fail(); } catch (final AssertionError e) {} |
| } |
| |
| @Test |
| public void checkFlags() { |
| final ReqSketch sk = ReqSketch.builder().build(); |
| sk.setLessThanOrEqual(true); |
| assertEquals(sk.isLessThanOrEqual(), true); |
| sk.setLessThanOrEqual(false); //LT |
| assertEquals(sk.isLessThanOrEqual(), false); |
| } |
| |
| @Test |
| public void moreMergeTests() { |
| final ReqSketch sk1 = ReqSketch.builder().build(); |
| final ReqSketch sk2 = ReqSketch.builder().build(); |
| for (int i = 5; i < 10; i++) {sk1.update(i); } |
| sk1.merge(sk2); //does nothing |
| for (int i = 1; i <= 15; i++) {sk2.update(i); } |
| sk1.merge(sk2); |
| assertEquals(sk1.getN(), 20); |
| for (int i = 16; i <= 300; i++) { sk2.update(i); } |
| sk1.merge(sk2); |
| } |
| |
| @Test |
| public void simpleTest() { |
| ReqSketch sk; |
| final ReqSketchBuilder bldr = ReqSketch.builder(); |
| bldr.setK(50).setHighRankAccuracy(false); |
| bldr.setReqDebug(null); |
| sk = bldr.build(); |
| final float[] vArr = { 5, 5, 5, 6, 6, 6, 7, 8, 8, 8 }; |
| for (int i = 0; i < vArr.length; i++) { sk.update(vArr[i]); } |
| sk.setLessThanOrEqual(false); |
| final double[] rArrLT = {0.0, 0.0, 0.0, 0.3, 0.3, 0.3, 0.6, 0.7, 0.7, 0.7}; |
| for (int i = 0; i < vArr.length; i++) { |
| assertEquals(sk.getRank(vArr[i]), rArrLT[i]); |
| //System.out.println("v:" + vArr[i] + " r:" + sk.getRank(vArr[i])); |
| } |
| sk.setLessThanOrEqual(true); |
| final double[] rArrLE = {0.3, 0.3, 0.3, 0.6, 0.6, 0.6, 0.7, 1.0, 1.0, 1.0}; |
| for (int i = 0; i < vArr.length; i++) { |
| assertEquals(sk.getRank(vArr[i]), rArrLE[i]); |
| //System.out.println("v:" + vArr[i] + " r:" + sk.getRank(vArr[i])); |
| } |
| } |
| |
| @Test |
| public void checkGetRankUBLB() { |
| checkGetRank(true, false); |
| checkGetRank(false, true); |
| } |
| |
| @Test |
| public void checkEmpty() { |
| final ReqSketchBuilder bldr = new ReqSketchBuilder(); |
| bldr.setLessThanOrEqual(false); |
| final ReqSketch sk = bldr.build(); |
| assertEquals(sk.getRank(1f), Double.NaN); |
| assertNull(sk.getRanks(new float[] { 1f })); |
| assertEquals(sk.getQuantile(0.5), Float.NaN); |
| assertNull(sk.getQuantiles(new double[] {0.5})); |
| assertNull(sk.getPMF(new float[] { 1f })); |
| assertNull(sk.getCDF(new float[] { 1f })); |
| assertTrue(sk.getRSE(50, 0.5, true, 0) > 0); |
| assertTrue(sk.getRankUpperBound(0.5, 1) > 0); |
| } |
| |
| private void checkGetRank(final boolean hra, final boolean ltEq) { |
| final int k = 12; |
| final boolean up = true; |
| final int min = 1; |
| final int max = 1000; |
| final int skDebug = 0; |
| final ReqSketch sk = reqSketchTest.loadSketch(k, min, max, up, hra, ltEq, skDebug); |
| double rLB = sk.getRankLowerBound(0.5, 1); |
| assertTrue(rLB > 0); |
| if (hra) { rLB = sk.getRankLowerBound(995.0/1000, 1); } |
| else { rLB = sk.getRankLowerBound(5.0/1000, 1); } |
| assertTrue(rLB > 0); |
| double rUB = sk.getRankUpperBound(0.5, 1); |
| assertTrue(rUB > 0); |
| if (hra) { rUB = sk.getRankUpperBound(995.0/1000, 1); } |
| else { rUB = sk.getRankUpperBound(5.0/1000, 1); } |
| assertTrue(rUB > 0); |
| final double[] ranks = sk.getRanks(new float[] {5f, 100f}); |
| } |
| |
| private static void myAssertEquals(final double v1, final double v2) { |
| if (Double.isNaN(v1) && Double.isNaN(v2)) { assert true; } |
| else if (v1 == v2) { assert true; } |
| else { assert false; } |
| } |
| |
| private static void myAssertEquals(final float v1, final float v2) { |
| if (Float.isNaN(v1) && Float.isNaN(v2)) { assert true; } |
| else if (v1 == v2) { assert true; } |
| else { assert false; } |
| } |
| |
| } |