More aggregation operators

4 files changed, 123 insertions, 6 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
index 2bc35ae6..b2ee3981 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
@@ -5,6 +5,7 @@ Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;s
 Bundle-Version: 1.0.0.qualifier
 Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries
 Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
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<Interval> {
                 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<Interval> {
                         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<Interval> {
                         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<Interval> {
                         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<Interval> {
                         }
                 }
 
+                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<Interval> {
                         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<Interval> {
                         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<Interval> {
                         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<Interval> {
                         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)
+        }
+}