1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
/*
* SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
*
* SPDX-License-Identifier: EPL-2.0
*/
package tools.refinery.store.query.term.int_;
import tools.refinery.store.query.term.Aggregator;
import tools.refinery.store.query.term.ConstantTerm;
import tools.refinery.store.query.term.ExtremeValueAggregator;
import tools.refinery.store.query.term.Term;
import tools.refinery.store.query.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);
}
}
|
