From 3ab6f907e44d993830bad4d25a8b03811731c481 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Fri, 10 May 2019 12:05:10 -0400 Subject: More aggregation operators --- .../logic2viatra/interval/Interval.xtend | 54 +++++++++++++++++++--- .../interval/IntervalAggregationMode.java | 24 ++++++++++ .../aggregators/IntervalAggregatorFactory.xtend | 50 ++++++++++++++++++++ 3 files changed, 122 insertions(+), 6 deletions(-) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme') 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 229656c0..173be0be 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 @@ -53,6 +53,10 @@ abstract class Interval implements Comparable { other.mayBeLessThanOrEqual(this) } + abstract def Interval min(Interval other) + + abstract def Interval max(Interval other) + abstract def Interval join(Interval other) def operator_plus() { @@ -88,6 +92,14 @@ abstract class Interval implements Comparable { false } + override min(Interval other) { + EMPTY + } + + override max(Interval other) { + EMPTY + } + override join(Interval other) { other } @@ -173,7 +185,7 @@ abstract class Interval implements Comparable { switch (other) { case EMPTY: true NonEmpty: lower == upper && lower == other.lower && lower == other.upper - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } @@ -190,7 +202,7 @@ abstract class Interval implements Comparable { switch (other) { case EMPTY: true NonEmpty: upper !== null && other.lower !== null && upper < other.lower - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } @@ -202,11 +214,41 @@ abstract class Interval implements Comparable { } } + override min(Interval other) { + switch (other) { + case EMPTY: this + NonEmpty: min(other) + default: throw new IllegalArgumentException("Unknown interval: " + other) + } + } + + def min(NonEmpty other) { + new NonEmpty( + lower.tryMin(other.lower), + if (other.upper === null) upper else upper?.min(other.upper) + ) + } + + override max(Interval other) { + switch (other) { + case EMPTY: this + NonEmpty: max(other) + default: throw new IllegalArgumentException("Unknown interval: " + other) + } + } + + def max(NonEmpty other) { + new NonEmpty( + if (other.lower === null) lower else lower?.min(other.lower), + upper.tryMax(other.upper) + ) + } + override join(Interval other) { switch (other) { case EMPTY: this NonEmpty: new NonEmpty(lower.tryMin(other.lower), upper.tryMax(other.upper)) - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } @@ -218,7 +260,7 @@ abstract class Interval implements Comparable { switch (other) { case EMPTY: EMPTY NonEmpty: operator_plus(other) - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } @@ -241,7 +283,7 @@ abstract class Interval implements Comparable { switch (other) { case EMPTY: EMPTY NonEmpty: operator_minus(other) - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } @@ -369,7 +411,7 @@ abstract class Interval implements Comparable { switch (other) { case EMPTY: EMPTY NonEmpty: operator_divide(other) - default: throw new IllegalArgumentException("") + default: throw new IllegalArgumentException("Unknown interval: " + other) } } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java index 66dcb00f..f106e305 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java @@ -27,6 +27,30 @@ public enum IntervalAggregationMode implements BinaryOperator { return Interval.ZERO; } }, + + MIN("intervalMin", "Find the minimum a set of intervals") { + @Override + public IntervalRedBlackNode createNode(Interval interval) { + return new IntervalRedBlackNode(interval) { + @Override + public Interval op(Interval left, Interval right) { + return left.min(right); + } + }; + } + }, + + MAX("intervalMax", "Find the maximum a set of intervals") { + @Override + public IntervalRedBlackNode createNode(Interval interval) { + return new IntervalRedBlackNode(interval) { + @Override + public Interval op(Interval left, Interval right) { + return left.max(right); + } + }; + } + }, JOIN("intervalJoin", "Calculate the smallest interval containing all the intervals in a set") { @Override 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 new file mode 100644 index 00000000..2b6059da --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend @@ -0,0 +1,50 @@ +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.IntervalAggregationMode +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationOperator +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 +import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor + +@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) + } else { + throw new IllegalArgumentException("Unknown domain class: " + domainClass) + } + } +} + +class intervalSum extends IntervalAggregatorFactory { + new() { + super(IntervalAggregationMode.SUM) + } +} + +class intervalMin extends IntervalAggregatorFactory { + new() { + super(IntervalAggregationMode.MIN) + } +} + +class intervalMax extends IntervalAggregatorFactory { + new() { + super(IntervalAggregationMode.MAX) + } +} + +class intervalJoin extends IntervalAggregatorFactory { + new() { + super(IntervalAggregationMode.JOIN) + } +} -- cgit v1.2.3-54-g00ecf