I am facing a situation, where a user is allowed to define some conditionals as follows:
x >= 2
x < 6
y >= 2
y > 2*x
where x and y are variables. Does a library exists in Java or Python that is able to compute the domain range for each variable (e.g. x in [2,6] and y in [2,12]), and then validates those expressions? For instance, adding the statement
x + y <= 2
should result in an error.
Best
I guess you could do this manually. AFAIK, there is no built-in way to handle inequalities.
You could create a way to handle the limits, and then manually assign those limits based on your input inequalities.
This can create the inequalities. You can manipulate the limits and directions of multiple inequalities to make a system, and then use those systems to validate the equation.
public class Limit {
public double limit; // limit number
public boolean isUpperLimit; // essentially the direction
public boolean includes; // differentiates between <= and <
public Limit(double limit, boolean isUpperLimit, boolean includes) {
this.limit = limit;
this.isUpperLimit = isUpperLimit;
this.includes = includes;
}
}
public class Inequality {
public Limit limit;
public String variable;
public Inequality(String inequality) { // if inequality is
String variable = inequality.split(" ")[0];
this.variable = variable;
String operator = inequality.split(" ")[1];
Double number = Double.parseDouble(inequality.split(" ")[2]);
double limit = number;
boolean isUpperLimit, includes;
switch(operator) {
case ">":
isUpperLimit = false;
includes = false;
break;
case ">=":
isUpperLimit = false;
includes = true;
break;
case "<":
isUpperLimit = true;
includes = false;
break;
case ">=:
isUpperLimit = true;
includes = true;
break;
}
this.limit = new Limit(limit, isUpperLimit, includes);
}
}
public class System {
public Limit lowerLimit;
public Limit upperLimit;
public System(Inequality ie1, Inequality ie2) {
if(ie1.limit.isUpperLimit == ie2.limit.isUpperLimit) { // if same direction
if(ie1.limit.isUpperLimit == true) {
this.upperLimit = (ie1.limit.limit >= ie2.limit.limit) ? ie1.limit : ie2.limit;
} else {
this.upperLimit = (ie2.limit.limit >= ie1.limit.limit) ? ie1.limit : ie2.limit;
}
}
}
}
Code is untested
If you have systems set, then now you can use their limits to determine if the last equation is possible or not.
It's unclear in your question whether you are talking about parsing text expressions or for a library that allows predicates to be defined.
If you are referring to the latter, Java 8 makes defining the predicates fairly easy. Your predicates could be represented as:
List<BiFunction<Integer, Integer, Boolean>> conditionals;
And then set as:
conditionals.add((x, y) -> x >= 2);
conditionals.add((x, y) -> x < 6);
conditionals.add((x, y) -> y > 2 * x);
And so on.
Then testing against a defined range for x and y could look like:
private boolean anyMatch(int xMin, int xMax, int yMin, int yMax) {
IntStream.rangeClosed(xMin, xMax).anyMatch(x ->
IntStream.rangeClosed(yMin, yMax).anyMatch(y ->
conditionals.stream().allMatch(c -> c.apply(x, y))));
}
At the moment this is assuming two variables. If you want to extend to cover any number it's still possible with the built-in classes by representing the values of the variables as a map:
List<Function<Map<String, Integer>, Boolean>> conditionals;
conditionals.add(vars -> vars.get("x") >= 2);
conditionals.add(vars -> vars.get("y") > 2 * vars.get("x"));
This design could be used fairly easily to exclude adding predicates that are incompatible over a given range.
If you want to do something more complicated that retains information about allowed ranges without iterating over a specified domain then I think you'll need a custom class for that.
