Constraint programming 使用Java计算在某个时间间隔内找到的变量值

我试图找到x和y的值，因此以下不等式成立：

1/24<1/15*y<1/10*x<2/24<2/15*y<3/24

有没有一种方法可以用Java描述这样的问题？ 约束编程可能会解决这样一个问题，但有没有替代方法

如果约束编程是唯一的方法，这是什么样子的

下面是我使用或工具对约束编程所做的尝试。如何表述严格的不等式

MPSolver solver = new MPSolver(
            "SimpleMipProgram", MPSolver.OptimizationProblemType.CBC_MIXED_INTEGER_PROGRAMMING);
    // [END solver]

    // [START variables]
    double infinity = java.lang.Double.POSITIVE_INFINITY;
    // x and y are float/double variables.
    MPVariable x = solver.makeNumVar(0,1,"x"); //makeIntVar(0.0, infinity, "x");
    MPVariable y = solver.makeNumVar(0,1,"y"); //makeIntVar(0.0, infinity, "y");

    System.out.println("Number of variables = " + solver.numVariables());
    // [END variables]

    // [START constraints]
    // x + 7 * y <= 17.5.
    /*MPConstraint c0 = solver.makeConstraint(-1, 17.5, "c0");
    c0.setCoefficient(x, 1);
    c0.setCoefficient(y, 7);

    // x <= 3.5.
    MPConstraint c1 = solver.makeConstraint(-infinity, 3.5, "c1");
    c1.setCoefficient(x, 1);
    c1.setCoefficient(y, 0);*/

    // 1/24 < 1/15*y ---> -1/15 * y < -1/24
    MPConstraint c0 = solver.makeConstraint(-1000,-1/24.0,"c0");
    c0.setCoefficient(y,-1/15.0);

    //  1/15*y < 1/10*x ---> 1/15*y - 1/10*x < 0
    MPConstraint c1 = solver.makeConstraint(-1000,0,"c1");
    c1.setCoefficient(y,1/15.0);
    c1.setCoefficient(x,-1/10.0);

    // 1/10*x < 2/24 ---> 1/10*x < 2/24
    MPConstraint c2 = solver.makeConstraint(-1000,2/24.0,"c2");
    c2.setCoefficient(x,1/10.0);

    // 2/24 < 2/15*y ---> -2/15*y < -2/24
    MPConstraint c3 = solver.makeConstraint(-1000, -2/24.0);
    c3.setCoefficient(y,-2/15.0);

    // 2/15*y < 3/24 ---> 2/15*y < 3/24
    MPConstraint c4 = solver.makeConstraint(-1000,3/24.0);
    c4.setCoefficient(y,2/15.0);

MPSolver=新的MPSolver(
“SimpleImprogram”，MPSolver.OptimizationProblemType.CBC_混合整数规划）；
//[结束解算器]
//[开始变量]
double infinity=java.lang.double.POSITIVE_infinity；
//x和y是浮点/双变量。
MPVariable x=solver.makeNumVar（0,1，“x”）//makeIntVar（0.0，无穷大，“x”）；
MPVariable y=solver.makeNumVar（0,1，“y”）//makeIntVar（0.0，无穷大，“y”）；
System.out.println（“变量数=“+solver.numVariables（））；
//[结束变量]
//[启动限制]
//x+7*y 1/15*y-1/10*x<0
MPConstraint c1=solver.makeConstraint（-1000,0，“c1”）；
c1.设定系数（y，1/15.0）；
c1.设定系数（x，-1/10.0）；
//1/10*x<2/24--->1/10*x<2/24
MPConstraint c2=解算器.makeConstraint（-1000,2/24.0，“c2”）；
c2.设定系数（x，1/10.0）；
//2/24<2/15*y--->2/15*y<-2/24
MPConstraint c3=解算器.makeConstraint（-1000，-2/24.0）；
c3.设定系数（y，-2/15.0）；
//2/15*y<3/24--->2/15*y<3/24
MPConstraint c4=解算器.makeConstraint（-1000,3/24.0）；
c4.设定系数（y，2/15.0）；

我通过写下一个循环找到了解决方案，该循环生成随机值，直到所有语句都完成

现在我对wolfram alpha如何如此快速地解决这些问题感兴趣

public class inequalities {
private static double x;
private static double y;
private static double Ratio3 = 1/24.0;
private static double Ratio2 = 1/15.0;
private static double Ratio1 = 1/10.0;
public static void main(String[] args) {
    x = Math.random();
    y = Math.random();
    boolean loop = true;
    while (loop) {
        loop = calculatingTheInequalities();
        if (loop) {
            x = Math.random();
            y = Math.random();
        }
    }
    System.out.println("x value: " + x);
    System.out.println("y value: " + y);
}
public static boolean calculatingTheInequalities() {
    if (Ratio3<Ratio2*y && Ratio2*y<Ratio1*x &&
    Ratio1*x<2*Ratio3 && 2*Ratio3<2*Ratio2*y &&
    2*Ratio2*y<3*Ratio3) {
        return false;
    } else {
        return true;
    }
    /*if (Ratio3 < Ratio2 *y) {
        if (Ratio2 *y < Ratio1 *x) {
            if (Ratio1 *x<2* Ratio3) {
                if (2* Ratio3 < 2* Ratio2 *y) {
                    if (2* Ratio2 *y < 3* Ratio3) {
                        return false;
                    } else {
                        return true;
                    }
                } else {
                    return true;
                }
            } else {
                return true;
            }
        } else {
            return true;
        }
    } else {
        return true;
    }*/
}
}

公共类不等式{
私有静态双x；
私有静态双y；
专用静态双比值3=1/24.0；
专用静态双比值2=1/15.0；
专用静态双比值1=1/10.0；
公共静态void main（字符串[]args）{
x=数学随机（）；
y=数学随机（）；
布尔循环=真；
while（循环）{
循环=计算等式（）；
如果（循环）{
x=数学随机（）；
y=数学随机（）；
}
}
System.out.println（“x值：+x”）；
System.out.println（“y值：+y”）；
}
公共静态布尔计算等式（）{
if（Ratio3这里有一个使用整数解算器的工作代码

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from ortools.sat.python import cp_model


model = cp_model.CpModel()
scale = 1000

x = model.NewIntVar(0, scale, 'x')
y = model.NewIntVar(0, scale, 'y')

# 1/24 < 1/15*y < 1/10*x < 2/24 < 2/15*y < 3/24

model.Add(5 * scale < 8 * y)
model.Add(8 * y < 12 * x)
model.Add(12 * x < 10 * scale)
model.Add(10 * scale < 16 * y)
model.Add(16 * y < 15 * scale)

solver = cp_model.CpSolver()
solver.parameters.log_search_progress = True
status = solver.Solve(model)

if status == cp_model.FEASIBLE:
    print('x =', solver.Value(x) * 1.0 / scale)
    print('y =', solver.Value(y) * 1.0 / scale)

当比例=100时，它输出：

x = 0.418
y = 0.626

x = 0.43
y = 0.63

当刻度=10时，它输出

x = 0.5
y = 0.7

注意整数除法。在Java中，
2/24
（以及其他类似的表达式）的计算结果为
0
。请尝试使用
2.0/24
。事实上，您可以将所有值乘以120。请注意，由于算法不精确，线性解算器不接受严格的不等式。@LaurentPerron您的意思是什么“将一切乘以120”。这有助于我建立不等式吗？内部是否有允许严格不等式的类、解算器或工具？一开始我尝试使用
CpModel model=new CpModel（）；
它只能创建采用int或二进制值的变量。1/15乘以120得到8，1/24乘以120得到5。它不会改变解决方案，并且可以帮助解决数值问题。为什么使用此
只是一个错误。修复了。谢谢