/** * The keys of the map will be List instead of arrays, since arrays don't give a decent hash * code. */ @Override public Map toMap() { Map<List<Object>, Object> result = new HashMap<>(); for (Map.Entry<List<Object>, CalcResult> item : results.entrySet()) { result.put(item.getKey(), item.getValue().getValue()); } return result; }
List result = uniqueVisit.getResult().toList();
public void testCountSumMerge() throws IllegalFilterException, IOException { CountVisitor countVisitor = new CountVisitor(); fc2.accepts(countVisitor, null); // count = 2 SumVisitor sumVisitor = new SumVisitor(3, ft2); fc2.accepts(sumVisitor, null); // sum = 7.5 CalcResult countResult = countVisitor.getResult(); CalcResult sumResult = sumVisitor.getResult(); CalcResult averageResult1 = countResult.merge(sumResult); CalcResult averageResult2 = sumResult.merge(countResult); // both average results were correct? assertEquals((double) 3.75, averageResult1.toDouble(), 0); assertEquals((double) 3.75, averageResult2.toDouble(), 0); // neither sum nor count was destroyed? assertEquals(2, countResult.toInt()); assertEquals((double) 7.5, sumResult.toDouble(), 0); }
public CalcResult merge(CalcResult resultsToAdd) { if (!isCompatible(resultsToAdd)) { throw new IllegalArgumentException("Parameter is not a compatible type"); } if (resultsToAdd == CalcResult.NULL_RESULT) { return this; } if (resultsToAdd instanceof CountResult) { // add the two counts int toAdd = resultsToAdd.toInt(); return new CountResult(count + toAdd); } else if (resultsToAdd instanceof SumResult) { // we don't want to implement this twice, so we'll call the // SumResult version of this function return resultsToAdd.merge(this); } else { throw new IllegalArgumentException( "The CalcResults claim to be compatible, but the appropriate merge method has not been implemented."); } } }
public CalcResult merge(CalcResult resultsToAdd) { if (!isCompatible(resultsToAdd)) { throw new IllegalArgumentException("Parameter is not a compatible type"); } if (resultsToAdd == CalcResult.NULL_RESULT) { return this; } if (resultsToAdd instanceof SumResult) { // create a new strategy object of the correct dataType Number[] sums = new Number[2]; sums[0] = (Number) sum.getResult(); sums[1] = (Number) resultsToAdd.getValue(); SumStrategy newSum = createStrategy(CalcUtil.getObject(sums).getClass()); // add the two sums newSum.add(sums[0]); newSum.add(sums[1]); return new SumResult(newSum); } else if (resultsToAdd instanceof CountResult) { // SumResult + CountResult = AverageResult int count = resultsToAdd.toInt(); AverageResult newResult = new AverageResult(count, sum.getResult()); return newResult; } else { throw new IllegalArgumentException( "The CalcResults claim to be compatible, but the appropriate merge method has not been implemented."); } } }
/** Helper method the checks if the calculation result contains the expected result. */ private void checkResults(CalcResult calcResult, Object[][] expectedResults) { assertThat(calcResult, notNullValue()); // check that the array conversion looks sane Object[] results = calcResult.toArray(); assertThat(results.length, is(expectedResults.length)); // check that map conversion looks sane Map resultMap = calcResult.toMap(); assertThat(resultMap.entrySet().size(), is(expectedResults.length)); // check that the obtained values correspond to the expected ones for (Object[] expectedResult : expectedResults) { assertThat(contains(results, expectedResult), is(true)); } }
fc2.accepts(minVisitor2, null); Object result = minVisitor.getResult().getValue(); int value = ((Integer) result).intValue(); assertEquals(1, value); int value2 = minVisitor.getResult().toInt(); assertEquals(1, value2); CalcResult minResult3 = minResult1.merge(minResult2); assertEquals(1, minResult3.toInt()); CalcResult minResult5 = minResult4.merge(minResult1); assertEquals(1, minResult5.toInt()); assertEquals(10, minResult4.toInt()); CalcResult minResult7 = (MinResult) minResult1.merge(minResult6); assertEquals(-5, minResult7.toInt()); assertEquals(-5, minResult6.toInt()); minResult7 = minResult7.merge(minResult1); assertEquals(-50, minResult7.toInt()); minResult7 = minResult7.merge(minResult1); assertEquals(-100.0, minResult7.toDouble(), 0); assertEquals(-100, minResult7.toInt()); assertSame(minResult2, minVisitor.getResult().merge(minResult2)); assertSame(minResult2, minResult2.merge(minVisitor.getResult()));
public void testQuantileList() throws Exception { FilterFactory factory = CommonFactoryFinder.getFilterFactory(null); Expression expr = factory.property(ft.getDescriptor(0).getLocalName()); QuantileListVisitor visitor = new QuantileListVisitor(expr, 2); fc.accepts(visitor, null); CalcResult result = visitor.getResult(); List[] qResult = (List[]) result.getValue(); assertEquals(2, qResult.length); assertEquals(2, qResult[0].size()); assertEquals(1, qResult[1].size()); // test empty collection QuantileListVisitor emptyVisitor = new QuantileListVisitor(expr, 2); empty.accepts(emptyVisitor, null); assertEquals(CalcResult.NULL_RESULT, emptyVisitor.getResult()); // test merge assertSame(result, emptyVisitor.getResult().merge(result)); assertSame(result, result.merge(emptyVisitor.getResult())); }
public void testAreaInvalidPolygon() throws IllegalFilterException, IOException { SumAreaVisitor areaVisitor = new SumAreaVisitor(1, ft6); fc6.accepts(areaVisitor, null); double value1 = areaVisitor.getResult().toDouble(); assertEquals(0.0, value1); }
public void testArea() throws IllegalFilterException, IOException { SumAreaVisitor areaVisitor = new SumAreaVisitor(1, ft4); fc4.accepts(areaVisitor, null); SumAreaVisitor areaVisitor2 = new SumAreaVisitor(1, ft5); fc5.accepts(areaVisitor2, null); double value1 = areaVisitor.getResult().toDouble(); assertEquals(10.0, value1); double value2 = areaVisitor2.getResult().toDouble(); assertEquals(12.0, value2); CalcResult areaResult1 = areaVisitor.getResult(); CalcResult areaResult2 = areaVisitor2.getResult(); CalcResult areaResult3 = areaResult1.merge(areaResult2); assertEquals((double) 22.0, areaResult3.toDouble(), 0); }
/** * Methods that allow optimizations to directly set the group by visitor result instead of * computing it visiting all the features. Aggregate visitor results are wrapped with the * appropriate feature calculation type. * * @param value the group by visitor result */ public void setValue(List<GroupByRawResult> value) { Map<List<Object>, CalcResult> results = new HashMap<>(); for (GroupByRawResult groupByRawResult : value) { // wrap the aggregate visitor result with the appropriate feature calculation type results.put( groupByRawResult.groupByValues, aggregate.wrap(expression, groupByRawResult.visitorValue)); } // create a new group by result using the raw values returned by the optimization GroupByResult newResult = new GroupByResult(results, aggregate, groupByAttributes); if (optimizationResult == CalcResult.NULL_RESULT) { // if no current result we simply return the new one optimizationResult = newResult; } else { // if a result already exists we merge it with the new one optimizationResult = optimizationResult.merge(newResult); } }
Set value1 = uniqueVisitor.getResult().toSet(); assertEquals(3, value1.size()); // 3 items in the set Object[] value2 = uniqueVisitor2.getResult().toArray(); assertEquals(2, value2.length); // 2 items in the set CalcResult uniqueResult3 = uniqueResult1.merge(uniqueResult2); assertEquals( 5, uniqueResult3.toSet().size()); // 3 and 3.0 are different, so there are actually 5 assertEquals(3, uniqueResult1.toSet().size()); anotherSet.add(Integer.valueOf(4)); CalcResult uniqueResult4 = new UniqueResult(anotherSet); CalcResult uniqueResult5 = uniqueResult1.merge(uniqueResult4); // 1,2,3 + 2,4 assertEquals(4, uniqueResult5.toSet().size()); assertEquals(anotherSet, uniqueResult1.toSet()); uniqueResult3 = uniqueResult2.merge(uniqueResult1); Set<Object> set = uniqueResult3.toSet(); assertTrue(set.size() == 4); assertTrue(set.contains(3.0)); assertSame(uniqueResult2, uniqueVisitor.getResult().merge(uniqueResult2)); assertSame(uniqueResult2, uniqueResult2.merge(uniqueVisitor.getResult()));
public void testUniquePreserveOrder() throws IOException { UniqueVisitor uniqueVisitor = new UniqueVisitor(0, ft); uniqueVisitor.setPreserveOrder(true); fc.accepts(uniqueVisitor, null); Set value1 = uniqueVisitor.getResult().toSet(); assertEquals(1, value1.iterator().next()); uniqueVisitor.reset(); invfc.accepts(uniqueVisitor, null); value1 = uniqueVisitor.getResult().toSet(); assertEquals(3, value1.iterator().next()); }
public void testBounds() throws IOException { BoundsVisitor boundsVisitor1 = new BoundsVisitor(); fc.accepts(boundsVisitor1, null); BoundsVisitor boundsVisitor2 = new BoundsVisitor(); fc2.accepts(boundsVisitor2, null); Envelope env1 = new Envelope(1, 5, 0, 4); CalcResult boundsResult1 = boundsVisitor1.getResult(); assertEquals(env1, boundsResult1.toEnvelope()); Envelope env2 = new Envelope(4, 13, 3, 10); CalcResult boundsResult2 = boundsVisitor2.getResult(); assertEquals(env2, boundsResult2.toEnvelope()); CalcResult boundsResult3 = boundsResult2.merge(boundsResult1); Envelope env3 = new Envelope(1, 13, 0, 10); assertEquals(env3, boundsResult3.toEnvelope()); // test empty collection boundsVisitor1.reset(null); empty.accepts(boundsVisitor1, null); assertEquals(CalcResult.NULL_RESULT, boundsVisitor1.getResult()); // test merge assertSame(boundsResult2, boundsVisitor1.getResult().merge(boundsResult2)); assertSame(boundsResult2, boundsResult2.merge(boundsVisitor1.getResult())); }
private Map<String, Integer> calcToCountMap(CalcResult result) { // the result is a map going from list of grouping attributes to value Map<List<String>, Integer> map = result.toMap(); return map.entrySet() .stream() .collect(Collectors.toMap(x -> x.getKey().get(0), x -> x.getValue())); }
public CalcResult merge(CalcResult resultsToAdd) { if (!isCompatible(resultsToAdd)) { throw new IllegalArgumentException( "Parameter is not a compatible type"); } if (resultsToAdd instanceof SumResult) { //create a new strategy object of the correct dataType Number[] sums = new Number[2]; sums[0] = (Number) sum.getResult(); sums[1] = (Number) resultsToAdd.getValue(); SumStrategy newSum = createStrategy(CalcUtil.getObject(sums).getClass()); //add the two sums newSum.add(sums[0]); newSum.add(sums[1]); return new SumResult(newSum); } else if (resultsToAdd instanceof CountResult) { //SumResult + CountResult = AverageResult int count = resultsToAdd.toInt(); AverageResult newResult = new AverageResult(count, sum.getResult()); return newResult; } else { throw new IllegalArgumentException( "The CalcResults claim to be compatible, but the appropriate merge method has not been implemented."); } } }
return null; double standardDeviation = calcResult.toDouble(); if (standardDeviation == 0) { return new RangedClassifier(
fc2.accepts(countVisitor2, null); int value1 = countVisitor.getResult().toInt(); assertEquals(3, value1); int value2 = countVisitor2.getResult().toInt(); assertEquals(2, value2); CalcResult countResult3 = countResult1.merge(countResult2); assertEquals(5, countResult3.toInt()); assertEquals(20, countResult4.toInt()); CalcResult countResult5 = countResult4.merge(countResult3); assertEquals(5, countResult3.toInt()); assertEquals(20, countResult4.toInt()); assertEquals(25, countResult5.toInt()); assertEquals(CalcResult.NULL_RESULT, countVisitor.getResult()); assertSame(countResult2, countVisitor.getResult().merge(countResult2)); assertSame(countResult2, countResult2.merge(countVisitor.getResult()));
public void testStandardDeviation() throws Exception { FilterFactory factory = CommonFactoryFinder.getFilterFactory(null); Expression expr = factory.property(ft3.getDescriptor(0).getLocalName()); // first do it the old fashioned way to ensure backwards compatibility AverageVisitor visit1 = new AverageVisitor(expr); fc3.accepts(visit1, null); CalcResult result = visit1.getResult(); double average = result.toDouble(); StandardDeviationVisitor visit2 = new StandardDeviationVisitor(expr, average); fc3.accepts(visit2, null); assertEquals(28.86, visit2.getResult().toDouble(), 0.01); // then do it single pass StandardDeviationVisitor visit3 = new StandardDeviationVisitor(expr); fc3.accepts(visit3, null); assertEquals(28.86, visit3.getResult().toDouble(), 0.01); // test empty collection StandardDeviationVisitor emptyVisitor = new StandardDeviationVisitor(expr, average); empty.accepts(emptyVisitor, null); assertEquals(CalcResult.NULL_RESULT, emptyVisitor.getResult()); // test merge assertSame(result, emptyVisitor.getResult().merge(result)); assertSame(result, result.merge(emptyVisitor.getResult())); }
if (existingResult != null) { mergedResults.put(entry.getKey(), existingResult.merge(entry.getValue())); } else {