From 1f60bda44172f1dedaf30785c88163ba6c36a0b9 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sat, 18 May 2019 14:25:00 -0400 Subject: Interval hull aggregation operator --- .../logic2viatra/interval/Interval.xtend | 4 +- .../interval/IntervalHullAggregatorOperator.xtend | 87 ++++++++++++++++++++++ .../aggregators/IntervalAggregatorFactory.xtend | 6 +- .../interval/aggregators/intervalHull.xtend | 74 ++++++++++++++++++ 4 files changed, 166 insertions(+), 5 deletions(-) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend index 4f0f594f..691c8783 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend @@ -7,8 +7,8 @@ import org.eclipse.xtend.lib.annotations.Data abstract class Interval implements Comparable { static val PRECISION = 32 - static val ROUND_DOWN = new MathContext(PRECISION, RoundingMode.FLOOR) - static val ROUND_UP = new MathContext(PRECISION, RoundingMode.CEILING) + package static val ROUND_DOWN = new MathContext(PRECISION, RoundingMode.FLOOR) + package static val ROUND_UP = new MathContext(PRECISION, RoundingMode.CEILING) private new() { } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend new file mode 100644 index 00000000..ce48eca1 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend @@ -0,0 +1,87 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval + +import java.math.BigDecimal +import java.math.MathContext +import java.util.SortedMap +import java.util.TreeMap +import java.util.stream.Stream +import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator + +abstract class IntervalHullAggregatorOperator> implements IMultisetAggregationOperator, Interval> { + protected new() { + } + + override getName() { + "intervalHull" + } + + override getShortDescription() { + "Calculates the interval hull of a set of numbers" + } + + override createNeutral() { + new TreeMap + } + + override getAggregate(SortedMap result) { + if (result.neutral) { + Interval.EMPTY + } else { + toInterval(result.firstKey, result.lastKey) + } + } + + protected abstract def BigDecimal toBigDecimal(T value, MathContext mc) + + private def toInterval(T min, T max) { + Interval.of(min.toBigDecimal(Interval.ROUND_DOWN), max.toBigDecimal(Interval.ROUND_UP)) + } + + override isNeutral(SortedMap result) { + result.empty + } + + override update(SortedMap oldResult, T updateValue, boolean isInsertion) { + if (isInsertion) { + oldResult.compute(updateValue) [ key, value | + if (value === null) { + 1 + } else if (value > 0) { + value + 1 + } else { + throw new IllegalStateException("Invalid count: " + value) + } + ] + } else { + oldResult.compute(updateValue) [ key, value | + if (value === 1) { + null + } else if (value > 1) { + value - 1 + } else { + throw new IllegalStateException("Invalid count: " + value) + } + ] + } + oldResult + } + + override aggregateStream(Stream stream) { + val iterator = stream.iterator + if (!iterator.hasNext) { + return Interval.EMPTY + } + var min = iterator.next + var max = min + while (iterator.hasNext) { + val element = iterator.next + if (element.compareTo(min) < 0) { + min = element + } + if (element.compareTo(max) > 0) { + max = element + } + } + toInterval(min, max) + } +} diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend index 2b6059da..dee31f67 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend @@ -8,14 +8,14 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggre import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor -@AggregatorType(parameterTypes = #[Interval], returnTypes = #[Interval]) +@AggregatorType(parameterTypes=#[Interval], returnTypes=#[Interval]) abstract class IntervalAggregatorFactory implements IAggregatorFactory { val IntervalAggregationMode mode - + @FinalFieldsConstructor protected new() { } - + override getAggregatorLogic(Class domainClass) { if (domainClass == Interval) { new BoundAggregator(new IntervalAggregationOperator(mode), Interval, Interval) diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend new file mode 100644 index 00000000..72605f57 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend @@ -0,0 +1,74 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators + +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalHullAggregatorOperator +import java.math.BigDecimal +import java.math.BigInteger +import java.math.MathContext +import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.AggregatorType +import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator +import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory + +@AggregatorType(parameterTypes=#[BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short], returnTypes=#[ + Interval, Interval, Interval, Interval, Interval, Interval, Interval, Interval]) +class intervalHull implements IAggregatorFactory { + + override getAggregatorLogic(Class domainClass) { + new BoundAggregator(getAggregationOperator(domainClass), domainClass, Interval) + } + + private def getAggregationOperator(Class domainClass) { + switch (domainClass) { + case BigDecimal: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(BigDecimal value, MathContext mc) { + value.round(mc) + } + } + case BigInteger: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(BigInteger value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Byte: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Byte value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Double: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Double value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Float: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Float value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Integer: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Integer value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Long: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Long value, MathContext mc) { + new BigDecimal(value, mc) + } + } + case Short: + new IntervalHullAggregatorOperator() { + override protected toBigDecimal(Short value, MathContext mc) { + new BigDecimal(value, mc) + } + } + default: + throw new IllegalArgumentException("Unknown domain class: " + domainClass) + } + } +} -- cgit v1.2.3-54-g00ecf