Java 改变单纯形算法使目标函数最小化而不是最大化

我已经创建了下面的单纯形算法，使目标函数最大化。我希望相反的事情发生。在本例中，有两个变量，算法必须计算出这两个变量（13.0和23.0）的乘积，以便在约束集内获得最大可能的结果。我想让算法计算出最低可能的结果

我的代码：

import java.util.*;


public class Simplex
{
private static final double EPSILON = 1.0E-10;
private double[][] tableaux;
private int numOfConstraints;
private int numOfVariables;

private int[] basis;
/**
 * Constructor for objects of class Simplex
 */
public Simplex()
{


    double[][] thisTableaux = {
        {  5.0, 15.0 },
        {  4.0,  4.0 },
        { 35.0, 20.0 },
    };

    double[] constraints = { 480.0, 160.0, 1190.0 };

    double[] variables = {  13.0,  23.0 };

    numOfConstraints = constraints.length;
    numOfVariables = variables.length;

    tableaux = new double[numOfConstraints+1][numOfVariables+numOfConstraints+1];

    //adds all elements from thisTableaux to tableaux
    for(int i=0; i < numOfConstraints; i++)
    {
        for(int j=0; j < numOfVariables; j++)
        {
            tableaux[i][j] = thisTableaux[i][j];
        }
    } 


    //adds a slack variable for each variable there is and sets it to 1.0
    for(int i=0; i < numOfConstraints; i++)
    {
        tableaux[i][numOfVariables+i] = 1.0;
    }


    //adds variables into the second [] of tableux
    for(int j=0; j < numOfVariables; j++)
    {
        tableaux[numOfConstraints][j] = variables[j];
    }



    //adds constraints to first [] of tableaux
    for(int k=0; k < numOfConstraints; k++)
    {
        tableaux[k][numOfConstraints+numOfVariables] = constraints[k];
    }



    basis = new int[numOfConstraints];

    for(int i=0; i < numOfConstraints; i++)
    {
        basis[i] = numOfVariables + i;
    }

    //show();

    //optimise();

    //assert check(thisTableaux, constraints, variables);


}

public void optimise() {
    while(true) {

        int q = findLowestNonBasicCol();

        if(q == -1) {
            break;
        }

        int p = getPivotRow(q);
        if(p == -1) throw new ArithmeticException("Linear Program Unbounded");

        pivot(p, q);

        basis[p] = q;
    }

}

public int findLowestNonBasicCol() {

    for(int i=0; i < numOfConstraints + numOfVariables; i++)
    {
        if(tableaux[numOfConstraints][i] > 0) {


            return i;
        }
    }

    return -1;


}

public int findIndexOfLowestNonBasicCol() {

    int q = 0;
    for(int i=1; i < numOfConstraints + numOfVariables; i++)
    {
        if(tableaux[numOfConstraints][i] > tableaux[numOfConstraints][q]) {
            q = i;
        }
    }

    if(tableaux[numOfConstraints][q] <= 0) {
        return -1;
    }

    else {
        return q;
    }
}

/**
 * Finds row p which will be the pivot row using the minimum ratio rule.
 * -1 if there is no pivot row
 */
public int getPivotRow(int q) {

    int p = -1;

    for(int i=0; i < numOfConstraints; i++) {

        if (tableaux[i][q] <=0) {
            continue;
        }

        else if (p == -1) {
            p = i;
        }

        else if((tableaux[i][numOfConstraints+numOfVariables] / tableaux[i][q] < tableaux[p][numOfConstraints+numOfVariables] / tableaux[p][q])) {
            p = i;
        }
    }



    return p;


}

public void pivot(int p, int q) {

    for(int i=0; i <= numOfConstraints; i++) {
        for (int j=0; j <= numOfConstraints + numOfVariables; j++) {
            if(i != p && j != q) {
                tableaux[i][j] -= tableaux[p][j] * tableaux[i][q] / tableaux[p][q];
            }
        }
    }

    for(int i=0; i <= numOfConstraints; i++) {
        if(i != p) {
            tableaux[i][q] = 0.0;
        }
    }

    for(int j=0; j <= numOfConstraints + numOfVariables; j++) {
        if(j != q) {
            tableaux[p][j] /= tableaux[p][q];
        }
    }

    tableaux[p][q] = 1.0;

    show();
}

public double result() {
    return -tableaux[numOfConstraints][numOfConstraints+numOfVariables];
}


public double[] primal() {
    double[] x = new double[numOfVariables];
    for(int i=0; i < numOfConstraints; i++) {
        if(basis[i] < numOfVariables) {
            x[basis[i]] = tableaux[i][numOfConstraints+numOfVariables];
        }
    }

    return x;
}

public double[] dual() {
    double[] y = new double[numOfConstraints];

    for(int i=0; i < numOfConstraints; i++) {
        y[i] = -tableaux[numOfConstraints][numOfVariables];
    }

    return y;
}

public boolean isPrimalFeasible(double[][] thisTableaux, double[] constraints) {
    double[] x = primal();

    for(int j=0; j < x.length; j++) {
        if(x[j] < 0.0) {
            StdOut.println("x[" + j + "] = " + x[j] + " is negative");
            return false;
        }
    }

    for(int i=0; i < numOfConstraints; i++) {
        double sum = 0.0;

        for(int j=0; j < numOfVariables; j++) {
            sum += thisTableaux[i][j] * x[j];
        }

        if(sum > constraints[i] + EPSILON) {
            StdOut.println("not primal feasible");
            StdOut.println("constraints[" + i + "] = " + constraints[i] + ", sum = " + sum);
            return false;
        }
    }
    return true;
}


private boolean isDualFeasible(double[][] thisTableaux, double[] variables) {

    double[] y = dual();

    for(int i=0; i < y.length; i++) {
        if(y[i] < 0.0) {
            StdOut.println("y[" + i + "] = " + y[i] + " is negative");
            return false;
        }
    }

    for(int j=0; j < numOfVariables; j++) {
        double sum = 0.0;

        for(int i=0; i < numOfConstraints; i++) {
            sum += thisTableaux[i][j] * y[i];
        }

        if(sum < variables[j] - EPSILON) {
            StdOut.println("not dual feasible");
            StdOut.println("variables[" + j + "] = " + variables[j] + ", sum = " + sum);
            return false;
        }
    }

    return true;

}

private boolean isOptimal(double[] constraints, double[] variables) {

    double[] x = primal();
    double[] y = dual();
    double value = result();

    double value1 = 0.0;
    for(int j=0; j < x.length; j++) {
        value1 += variables[j] * x[j];
    }

    double value2 = 0.0;
    for(int i=0; i < y.length; i++) {
        value2 += y[i] * constraints[i];
    }

    if(Math.abs(value - value1) > EPSILON || Math.abs(value - value2) > EPSILON) {
        StdOut.println("value = " + value + ", cx = " + value1 + ", yb = " + value2);
        return true;
    }

    return true;
}

private boolean check(double[][] thisTableaux, double[] constraints, double [] variables) {
    return isPrimalFeasible(thisTableaux, constraints) && isDualFeasible(thisTableaux, variables) && isOptimal(constraints, variables);
}


}

import java.util.*；
公共类单纯形
{
专用静态最终双ε=1.0E-10；
私人双[][]表；
私有约束；
私有变量；
私人基础；
/**
*单纯形类对象的构造函数
*/
公共单纯形（）
{
双[][]此表格={
{  5.0, 15.0 },
{  4.0,  4.0 },
{ 35.0, 20.0 },
};
双[]约束={480.0,160.0,1190.0}；
双[]变量={13.0,23.0}；
numOfConstraints=constraints.length；
numOfVariables=variables.length；
tableaux=新的双精度[numOfConstraints+1][numOfVariables+numOfConstraints+1]；
//将此tableaux中的所有元素添加到tableaux
对于（int i=0；i0）{
返回i；
}
}
返回-1；
}
public int findIndexOfLowestNonBasicCol（）{
int q=0；
对于（int i=1；itableaux[numOfConstraints][q]）{
q=i；
}
}
如果（tableaux[numOfConstraints][q]如果您想最小化f（x），这相当于最大化-f（x），因此如果您发布的代码正确地解决了最大化问题，您可以使用它来最小化任何目标函数f（x），只需通过最大化其相加逆-f（x）

请注意，您不更改约束，只更改目标函数

例如，最小化f（x）=3x+5，x>=1相当于最大化-f（x）=-3x-5，x>=1

最小值[f（x），x>=1]=f（1）=8=-（-8）=-[-f（1）]=-max[-f（x），x>=1]

通常，min[f（x）]=f（Xmin）=-[-f（Xmax）]=-max[-f（x）]，Xmin=Xmax

在上面的示例中，min[f（x）]=-max[-f（x）]=8，Xmin=Xmax=1

在您给出的特定示例中，您只需要更改行

double[] variables = {  13.0,  23.0 };

到

然后，返回的变量值应与以下情况的最小值相同：

double[] variables = {  13.0,  23.0 };

将目标函数的值乘以-1，将得到在下列情况下目标的最小值：

double[] variables = {  13.0,  23.0 };

如果您想最小化f（x），这相当于最大化-f（x），因此如果您发布的代码正确地解决了最大化问题，您可以使用它来最小化任何目标函数f（x），只需通过最大化其加性逆-f（x）

请注意，您不更改约束，只更改目标函数

例如，最小化f（x）=3x+5，x>=1相当于最大化-f（x）=-3x-5，x>=1

最小值[f（x），x>=1]=f（1）=8=-（-8）=-[-f（1）]=-max[-f（x），x>=1]

通常，min[f（x）]=f（Xmin）=-[-f（Xmax）]=-max[-f（x）]，Xmin=Xmax

在上面的示例中，min[f（x）]=-max[-f（x）]=8，Xmin=Xmax=1

在您给出的特定示例中，您只需要更改行

double[] variables = {  13.0,  23.0 };

到

然后，返回的变量值应与以下情况的最小值相同：

double[] variables = {  13.0,  23.0 };

将目标函数的值乘以-1，将得到在下列情况下目标的最小值：

double[] variables = {  13.0,  23.0 };

如果您想最小化f（x），这相当于最大化-f（x），因此如果您发布的代码正确地解决了最大化问题，您可以使用它来最小化任何目标函数f（x），只需通过最大化其加性逆-f（x）

请注意，您不更改约束，只更改目标函数

例如，最小化f（x）=3x+5，x>=1相当于最大化-f（x）=-3x-5，x>=1

最小值[f（x），x>=1]=f（1）=8=-（-8）=-[-f（1）]=-max[-f（x），x>=1]

通常，min[f（x）]=f（Xmin）=-[-f（Xmax）]=-max[-f（x）]，Xmin=Xmax

在上面的示例中，min[f（x）]=-max[-f（x）]=8，Xmin=Xmax=1

在您给出的特定示例中，您只需要更改行

double[] variables = {  13.0,  23.0 };

到

然后，返回的变量值应与以下情况的最小值相同：

double[] variables = {  13.0,  23.0 };

将目标函数的值乘以-1，将得到在下列情况下目标的最小值：

double[] variables = {  13.0,  23.0 };

如果您希望最小化f（x），这相当于最大化-f（x），因此如果您发布的代码正确地解决了最大化问题，您可以