Interval power and aggregator fix

4 files changed, 198 insertions, 37 deletions

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 173be0be..4f0f594f 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
@@ -54,26 +54,28 @@ abstract class Interval implements Comparable<Interval> {
         }
 
         abstract def Interval min(Interval other)
-        
+
         abstract def Interval max(Interval other)
 
         abstract def Interval join(Interval other)
 
-        def operator_plus() {
+        def +() {
                 this
         }
 
-        abstract def Interval operator_minus()
+        abstract def Interval -()
+
+        abstract def Interval +(Interval other)
 
-        abstract def Interval operator_plus(Interval other)
+        abstract def Interval -(Interval other)
 
-        abstract def Interval operator_minus(Interval other)
+        abstract def Interval *(int count)
 
-        abstract def Interval operator_multiply(int count)
+        abstract def Interval *(Interval other)
 
-        abstract def Interval operator_multiply(Interval other)
+        abstract def Interval /(Interval other)
 
-        abstract def Interval operator_divide(Interval other)
+        abstract def Interval **(Interval other)
 
         public static val EMPTY = new Interval {
                 override mustEqual(Interval other) {
@@ -95,7 +97,7 @@ abstract class Interval implements Comparable<Interval> {
                 override min(Interval other) {
                         EMPTY
                 }
-                
+
                 override max(Interval other) {
                         EMPTY
                 }
@@ -104,27 +106,31 @@ abstract class Interval implements Comparable<Interval> {
                         other
                 }
 
-                override operator_minus() {
+                override -() {
                         EMPTY
                 }
 
-                override operator_plus(Interval other) {
+                override +(Interval other) {
                         EMPTY
                 }
 
-                override operator_minus(Interval other) {
+                override -(Interval other) {
                         EMPTY
                 }
 
-                override operator_multiply(int count) {
+                override *(int count) {
                         EMPTY
                 }
 
-                override operator_multiply(Interval other) {
+                override *(Interval other) {
                         EMPTY
                 }
 
-                override operator_divide(Interval other) {
+                override /(Interval other) {
+                        EMPTY
+                }
+
+                override **(Interval other) {
                         EMPTY
                 }
 
@@ -221,14 +227,14 @@ abstract class Interval implements Comparable<Interval> {
                                 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)
+                                if(other.upper === null) upper else if(upper === null) other.upper else upper.min(other.upper)
                         )
                 }
-                
+
                 override max(Interval other) {
                         switch (other) {
                                 case EMPTY: this
@@ -236,10 +242,10 @@ abstract class Interval implements Comparable<Interval> {
                                 default: throw new IllegalArgumentException("Unknown interval: " + other)
                         }
                 }
-                
+
                 def max(NonEmpty other) {
                         new NonEmpty(
-                                if (other.lower === null) lower else lower?.min(other.lower),
+                                if(other.lower === null) lower else if(lower === null) other.lower else lower.max(other.lower),
                                 upper.tryMax(other.upper)
                         )
                 }
@@ -252,19 +258,19 @@ abstract class Interval implements Comparable<Interval> {
                         }
                 }
 
-                override operator_minus() {
+                override -() {
                         new NonEmpty(upper?.negate(ROUND_DOWN), lower?.negate(ROUND_UP))
                 }
 
-                override operator_plus(Interval other) {
+                override +(Interval other) {
                         switch (other) {
                                 case EMPTY: EMPTY
-                                NonEmpty: operator_plus(other)
+                                NonEmpty: this + other
                                 default: throw new IllegalArgumentException("Unknown interval: " + other)
                         }
                 }
 
-                def operator_plus(NonEmpty other) {
+                def +(NonEmpty other) {
                         new NonEmpty(
                                 lower.tryAdd(other.lower, ROUND_DOWN),
                                 upper.tryAdd(other.upper, ROUND_UP)
@@ -279,15 +285,15 @@ abstract class Interval implements Comparable<Interval> {
                         }
                 }
 
-                override operator_minus(Interval other) {
+                override -(Interval other) {
                         switch (other) {
                                 case EMPTY: EMPTY
-                                NonEmpty: operator_minus(other)
+                                NonEmpty: this - other
                                 default: throw new IllegalArgumentException("Unknown interval: " + other)
                         }
                 }
 
-                def operator_minus(NonEmpty other) {
+                def -(NonEmpty other) {
                         new NonEmpty(
                                 lower.trySubtract(other.upper, ROUND_DOWN),
                                 upper.trySubtract(other.lower, ROUND_UP)
@@ -302,7 +308,7 @@ abstract class Interval implements Comparable<Interval> {
                         }
                 }
 
-                override operator_multiply(int count) {
+                override *(int count) {
                         val bigCount = new BigDecimal(count)
                         new NonEmpty(
                                 lower.tryMultiply(bigCount, ROUND_DOWN),
@@ -310,15 +316,15 @@ abstract class Interval implements Comparable<Interval> {
                         )
                 }
 
-                override operator_multiply(Interval other) {
+                override *(Interval other) {
                         switch (other) {
                                 case EMPTY: EMPTY
-                                NonEmpty: operator_multiply(other)
-                                default: throw new IllegalArgumentException("")
+                                NonEmpty: this * other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
                         }
                 }
 
-                def operator_multiply(NonEmpty other) {
+                def *(NonEmpty other) {
                         if (this == ZERO || other == ZERO) {
                                 ZERO
                         } else if (nonpositive) {
@@ -407,15 +413,15 @@ abstract class Interval implements Comparable<Interval> {
                         }
                 }
 
-                override operator_divide(Interval other) {
+                override /(Interval other) {
                         switch (other) {
                                 case EMPTY: EMPTY
-                                NonEmpty: operator_divide(other)
+                                NonEmpty: this / other
                                 default: throw new IllegalArgumentException("Unknown interval: " + other)
                         }
                 }
 
-                def operator_divide(NonEmpty other) {
+                def /(NonEmpty other) {
                         if (other == ZERO) {
                                 EMPTY
                         } else if (this == ZERO) {
@@ -493,6 +499,51 @@ abstract class Interval implements Comparable<Interval> {
                         }
                 }
 
+                override **(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this ** other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def **(NonEmpty other) {
+                        // XXX This should use proper rounding for log and exp instead of
+                        // converting to double.
+                        // XXX We should not ignore (integer) powers of negative numbers.
+                        val lowerLog = if (lower === null || lower <= BigDecimal.ZERO) {
+                                        null
+                                } else {
+                                        new BigDecimal(Math.log(lower.doubleValue), ROUND_DOWN)
+                                }
+                        val upperLog = if (upper === null) {
+                                        null
+                                } else if (upper == BigDecimal.ZERO) {
+                                        return ZERO
+                                } else if (upper < BigDecimal.ZERO) {
+                                        return EMPTY
+                                } else {
+                                        new BigDecimal(Math.log(upper.doubleValue), ROUND_UP)
+                                }
+                        val log = new NonEmpty(lowerLog, upperLog)
+                        val product = log * other
+                        if (product instanceof NonEmpty) {
+                                val lowerResult = if (product.lower === null) {
+                                                BigDecimal.ZERO
+                                        } else {
+                                                new BigDecimal(Math.exp(product.lower.doubleValue), ROUND_DOWN)
+                                        }
+                                val upperResult = if (product.upper === null) {
+                                                null
+                                        } else {
+                                                new BigDecimal(Math.exp(product.upper.doubleValue), ROUND_UP)
+                                        }
+                                new NonEmpty(lowerResult, upperResult)
+                        } else {
+                                throw new IllegalArgumentException("Unknown interval: " + product)
+                        }
+                }
+
                 override toString() {
                         '''«IF lower === null»(-∞«ELSE»[«lower»«ENDIF», «IF upper === null»∞)«ELSE»«upper»]«ENDIF»'''
                 }
@@ -501,7 +552,7 @@ abstract class Interval implements Comparable<Interval> {
                         switch (o) {
                                 case EMPTY: 1
                                 NonEmpty: compareTo(o)
-                                default: throw new IllegalArgumentException("")
+                                default: throw new IllegalArgumentException("Unknown interval: " + o)
                         }
                 }
 
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend
new file mode 100644
index 00000000..7d46e16c
--- /dev/null
+++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend
@@ -0,0 +1,67 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval
+
+import com.google.common.collect.HashMultiset
+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 hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalRedBlackNode
+import java.math.BigDecimal
+import java.util.Random
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+
+import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.*
+
+class MinAggregatorTest {
+        val aggregator = new IntervalAggregationOperator(IntervalAggregationMode.MIN)
+        var IntervalRedBlackNode value = null
+
+        @Before
+        def void reset() {
+                value = aggregator.createNeutral
+        }
+
+        @Test
+        def void emptyTest() {
+                assertEquals(EMPTY)
+        }
+
+        @Test
+        def void largeTest() {
+                val starts = #[null, new BigDecimal(-3), new BigDecimal(-2), new BigDecimal(-1)]
+                val ends = #[new BigDecimal(1), new BigDecimal(2), new BigDecimal(3), null]
+                val current = HashMultiset.create
+                val random = new Random(1)
+                for (var int i = 0; i < 1000; i++) {
+                        val start = starts.get(random.nextInt(starts.size))
+                        val end = ends.get(random.nextInt(ends.size))
+                        val interval = Interval.of(start, end)
+                        val isInsert = !current.contains(interval) || random.nextInt(3) == 0
+                        if (isInsert) {
+                                current.add(interval)
+                        } else {
+                                current.remove(interval)
+                        }
+                        val expected = current.stream.reduce(aggregator.mode).orElse(EMPTY)
+                        update(interval, isInsert)
+                        assertEquals(expected)
+                }
+        }
+
+        private def update(Interval interval, boolean isInsert) {
+                value = aggregator.update(value, interval, isInsert)
+                val nodes = newArrayList
+                var node = value.min
+                while (node !== null) {
+                        nodes += node
+                        node = node.successor
+                }
+                value.assertSubtreeIsValid
+        }
+
+        private def assertEquals(Interval interval) {
+                val actual = aggregator.getAggregate(value)
+                Assert.assertEquals(interval, actual)
+        }
+}
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend
new file mode 100644
index 00000000..c842d90d
--- /dev/null
+++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend
@@ -0,0 +1,43 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval
+import java.util.Collection
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import org.junit.runners.Parameterized.Parameter
+import org.junit.runners.Parameterized.Parameters
+
+import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.*
+
+@RunWith(Parameterized)
+class PowerTest {
+        @Parameters(name="{index}: {0} ** {1} = {2}")
+        static def Collection<Object[]> data() {
+                #[
+                        #[EMPTY, EMPTY, EMPTY],
+                        #[EMPTY, between(-1, 1), EMPTY],
+                        #[between(-1, 1), EMPTY, EMPTY],
+                        #[upTo(-1), between(-1, 2), EMPTY],
+                        #[upTo(0), between(-1, 2), between(0, 0)],
+                        #[upTo(2), between(-1, 2), above(0)],
+                        #[upTo(2), between(1, 2), between(0, 4)],
+                        #[above(1), between(1, 2), above(1)],
+                        #[between(2, 4), upTo(1), between(0, 4)],
+                        #[between(0.25, 0.5), upTo(1), above(0.25)],
+                        #[between(2, 3), above(1), above(2)],
+                        #[between(0.25, 0.5), above(1), between(0, 0.5)],
+                        #[between(1, 2), between(-1, 2), between(0.5, 4)]
+                ]
+        }
+
+        @Parameter(0) public var Interval a
+        @Parameter(1) public var Interval b
+        @Parameter(2) public var Interval result
+
+        @Test
+        def void powerTest() {
+                Assert.assertEquals(result, a ** b)
+        }
+}
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumAggregatorTest.xtend
index 530c081c..56172b6c 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumTest.xtend
+++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumAggregatorTest.xtend
@@ -13,7 +13,7 @@ import org.junit.Test
 
 import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.*
 
-class SumTest {
+class SumAggregatorTest {
         val aggregator = new IntervalAggregationOperator(IntervalAggregationMode.SUM)
         var IntervalRedBlackNode value = null