14 files changed, 485 insertions, 0 deletions

diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntAddTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntAddTerm.java
new file mode 100644
index 00000000..73533d9b
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntAddTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntAddTerm extends IntBinaryTerm {
+        public IntAddTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntAddTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue + rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s + %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntBinaryTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntBinaryTerm.java
new file mode 100644
index 00000000..9543c21f
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntBinaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.term.BinaryTerm;
+import tools.refinery.logic.term.Term;
+
+public abstract class IntBinaryTerm extends BinaryTerm<Integer, Integer, Integer> {
+        protected IntBinaryTerm(Term<Integer> left, Term<Integer> right) {
+                super(Integer.class, Integer.class, Integer.class, left, right);
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntDivTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntDivTerm.java
new file mode 100644
index 00000000..f9fa70ef
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntDivTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntDivTerm extends IntBinaryTerm {
+        public IntDivTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntDivTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return rightValue == 0 ? null : leftValue / rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s / %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMaxTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMaxTerm.java
new file mode 100644
index 00000000..f7b315df
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMaxTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntMaxTerm extends IntBinaryTerm {
+        public IntMaxTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                      Term<Integer> substitutedRight) {
+                return new IntMaxTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return Math.max(rightValue, leftValue);
+        }
+
+        @Override
+        public String toString() {
+                return "max(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinTerm.java
new file mode 100644
index 00000000..73247db1
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntMinTerm extends IntBinaryTerm {
+        public IntMinTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntMinTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return Math.min(rightValue, leftValue);
+        }
+
+        @Override
+        public String toString() {
+                return "min(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinusTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinusTerm.java
new file mode 100644
index 00000000..006e1977
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMinusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntMinusTerm extends IntUnaryTerm {
+        public IntMinusTerm(Term<Integer> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntMinusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer bodyValue) {
+                return -bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(-%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMulTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMulTerm.java
new file mode 100644
index 00000000..18fdcb45
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntMulTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntMulTerm extends IntBinaryTerm {
+        public IntMulTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                      Term<Integer> substitutedRight) {
+                return new IntMulTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue * rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s * %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPlusTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPlusTerm.java
new file mode 100644
index 00000000..1a905293
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPlusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntPlusTerm extends IntUnaryTerm {
+        public IntPlusTerm(Term<Integer> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntPlusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer bodyValue) {
+                return bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(+%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPowTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPowTerm.java
new file mode 100644
index 00000000..dac490b0
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntPowTerm.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntPowTerm extends IntBinaryTerm {
+        public IntPowTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                      Term<Integer> substitutedRight) {
+                return new IntPowTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return rightValue < 0 ? null : power(leftValue, rightValue);
+        }
+
+        private static int power(int base, int exponent) {
+                int accum = 1;
+                while (exponent > 0) {
+                        if (exponent % 2 == 1) {
+                                accum = accum * base;
+                        }
+                        base = base * base;
+                        exponent = exponent / 2;
+                }
+                return accum;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s ** %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSubTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSubTerm.java
new file mode 100644
index 00000000..94326677
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSubTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.substitution.Substitution;
+import tools.refinery.logic.term.Term;
+
+public class IntSubTerm extends IntBinaryTerm {
+        public IntSubTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntSubTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue - rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s - %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSumAggregator.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSumAggregator.java
new file mode 100644
index 00000000..b42038ab
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntSumAggregator.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.term.StatelessAggregator;
+
+public final class IntSumAggregator implements StatelessAggregator<Integer, Integer> {
+        public static final IntSumAggregator INSTANCE = new IntSumAggregator();
+
+        private IntSumAggregator() {
+        }
+
+        @Override
+        public Class<Integer> getResultType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Class<Integer> getInputType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Integer getEmptyResult() {
+                return 0;
+        }
+
+        @Override
+        public Integer add(Integer current, Integer value) {
+                return current + value;
+        }
+
+        @Override
+        public Integer remove(Integer current, Integer value) {
+                return current - value;
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntTerms.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntTerms.java
new file mode 100644
index 00000000..b152a138
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntTerms.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.term.Aggregator;
+import tools.refinery.logic.term.ConstantTerm;
+import tools.refinery.logic.term.ExtremeValueAggregator;
+import tools.refinery.logic.term.Term;
+import tools.refinery.logic.term.comparable.*;
+import tools.refinery.logic.term.comparable.*;
+
+import java.util.Comparator;
+
+public final class IntTerms {
+        public static final Aggregator<Integer, Integer> INT_SUM = IntSumAggregator.INSTANCE;
+        public static final Aggregator<Integer, Integer> INT_MIN = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MAX_VALUE);
+        public static final Aggregator<Integer, Integer> INT_MAX = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MIN_VALUE, Comparator.reverseOrder());
+
+        private IntTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Term<Integer> constant(Integer value) {
+                return new ConstantTerm<>(Integer.class, value);
+        }
+
+        public static Term<Integer> plus(Term<Integer> body) {
+                return new IntPlusTerm(body);
+        }
+
+        public static Term<Integer> minus(Term<Integer> body) {
+                return new IntMinusTerm(body);
+        }
+
+        public static Term<Integer> add(Term<Integer> left, Term<Integer> right) {
+                return new IntAddTerm(left, right);
+        }
+
+        public static Term<Integer> sub(Term<Integer> left, Term<Integer> right) {
+                return new IntSubTerm(left, right);
+        }
+
+        public static Term<Integer> mul(Term<Integer> left, Term<Integer> right) {
+                return new IntMulTerm(left, right);
+        }
+
+        public static Term<Integer> div(Term<Integer> left, Term<Integer> right) {
+                return new IntDivTerm(left, right);
+        }
+
+        public static Term<Integer> pow(Term<Integer> left, Term<Integer> right) {
+                return new IntPowTerm(left, right);
+        }
+
+        public static Term<Integer> min(Term<Integer> left, Term<Integer> right) {
+                return new IntMinTerm(left, right);
+        }
+
+        public static Term<Integer> max(Term<Integer> left, Term<Integer> right) {
+                return new IntMaxTerm(left, right);
+        }
+
+        public static Term<Boolean> eq(Term<Integer> left, Term<Integer> right) {
+                return new EqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> notEq(Term<Integer> left, Term<Integer> right) {
+                return new NotEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> less(Term<Integer> left, Term<Integer> right) {
+                return new LessTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> lessEq(Term<Integer> left, Term<Integer> right) {
+                return new LessEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> greater(Term<Integer> left, Term<Integer> right) {
+                return new GreaterTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> greaterEq(Term<Integer> left, Term<Integer> right) {
+                return new GreaterEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Integer> asInt(Term<Double> body) {
+                return new RealToIntTerm(body);
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntUnaryTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntUnaryTerm.java
new file mode 100644
index 00000000..20449e67
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/IntUnaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.term.UnaryTerm;
+import tools.refinery.logic.term.Term;
+
+public abstract class IntUnaryTerm extends UnaryTerm<Integer, Integer> {
+        protected IntUnaryTerm(Term<Integer> body) {
+                super(Integer.class, Integer.class, body);
+        }
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/RealToIntTerm.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/RealToIntTerm.java
new file mode 100644
index 00000000..7611af90
--- /dev/null
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/int_/RealToIntTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.logic.term.int_;
+
+import tools.refinery.logic.term.Term;
+import tools.refinery.logic.term.UnaryTerm;
+import tools.refinery.logic.substitution.Substitution;
+
+public class RealToIntTerm extends UnaryTerm<Integer, Double> {
+        protected RealToIntTerm(Term<Double> body) {
+                super(Integer.class, Double.class, body);
+        }
+
+        @Override
+        protected Integer doEvaluate(Double bodyValue) {
+                return bodyValue.isNaN() ? null : bodyValue.intValue();
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Double> substitutedBody) {
+                return new RealToIntTerm(substitutedBody);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s as int)".formatted(getBody());
+        }
+}