Симплекс метод нахождения максимума целевой функции

package optimization;
 
import static java.lang.Math.*;
 
public class Simplex {
 
    // общее количество переменных
    final static int n = 2;
    
    // количество базисных переменных   
    final static int m = 8;
    
    //большое число
    final static double M = Double.MAX_VALUE;
 
    public static void main(String[] args) {
        double[] c = new double[n];// коэффициенты из целевой функции
        double[][] a = new double[m][n]; // коэффициенты из ограничений
        double[] cB = new double[m]; // коэффициенты при базисных переменных
        int[] bV = new int[m]; // базисные переменные
        double[] bD = new double[m]; // базисное решение
 
        c[0] = 4;
        c[1] = 5;
       
 
        a[0][0] = 2; a[0][1] =8; 
        a[1][0] = 2; a[1][1] =1; 
        a[2][0] = 0; a[2][1] = 3;
        a[3][0] = 3; a[3][1] = 0;
        
 
        cB[0] = 2;
        cB[1] = 8;
        cB[2] = 2;
        cB[3] = 1;
        cB[4] = 0;
        cB[5] = 3;
        cB[6] = 3;
        cB[7] = 8;
 
        bV[0] = 4;
      bV[1] = 5;
 
        bD[0] = 0;
     
 
 
 
        double[] max = simplexMax(c, a, cB, bV, bD);
     //   printArray(max);
    }
 
 
 
    static double[] simplexMax(double[] c, double[][] a, double[] cB, int[] bV,
            double[] bD) {
        double[] delta = new double[n];
        double[] min = new double[m];
 
        System.out.println("\n\nПоиск максимума\n\n");
        int i, j, r = -1, s = -1;
        double[][] tmpA = new double[m][];
        double[] tmpBD = new double[m];
 
        int k = 0;
        while (true) {
            ++k;
 
            double deltaMax = Double.NEGATIVE_INFINITY;
            r = -1;
            for (j = 0; j < n; ++j) {
                double z = 0;
                for (i = 0; i < m; ++i) {
                    z += cB[i] * a[i][j];
                }
                delta[j] = c[j] - z;
                if (deltaMax < delta[j]) {
                    deltaMax = delta[j];
                    r = j;
                }
            }
 
            // Условие выхода (все оценки неположительны)
            if (deltaMax <= 0 || k > 100) {
                break;
            }
 
            // Определяем разрешающую строку (с минимальным отношением
            // bD[i] / a[i][r])
            double minRow = Double.POSITIVE_INFINITY;
            s = -1;
            for (i = 0; i < m; ++i) {
                min[i] = bD[i] / a[i][r];
                if (min[i] < 0) {
                    min[i] = Double.NaN;
                }
                if (minRow > min[i]) {
                    minRow = min[i];
                    s = i;
                }
            }
 
            System.out.println("Разрешающий столбец: r = " + r);
            System.out.println("Разрешающая строка:  s = " + s);
            printTable(c, a, cB, bV, bD, min);
 
            double element = a[s][r];
            // Сохраняем содержимое массивов (т.к. их значения в ходе
            // вычисления изменяются, но остаются нужными для этих вычислений
            // ну как-то так :)
            for (i = 0; i < m; ++i) {
                tmpA[i] = new double[n];
                for (j = 0; j < n; ++j) {
                    tmpA[i][j] = a[i][j];
                }
                tmpBD[i] = bD[i];
            }
 
            // Вносим переменную в базис,
            // Пересчитываем базисное решение и коэффицетов переменных -
 
            // - в разрешающей строке
            bV[s] = r;
            cB[s] = c[r];
            for (j = 0; j < n; ++j) {
                a[s][j] /= element;
            }
            bD[s] /= element;
 
            // - в остальных строках
            for (i = 0; i < m; ++i) {
                // разрешающая строка уже пересчитана
                if (i == s) {
                    continue;
                }
 
                // элемент разрешающего столбца
                double air = tmpA[i][r];
 
                // пересчет коэфициентов
                for (j = 0; j < n; ++j) {
                    a[i][j] -= (air * tmpA[s][j]) / element;
                }
 
                // пересчет базисного решения
                bD[i] -= (air * tmpBD[s]) / element;
            }
 
      
            System.out.println("----------------------------------------------------");
        }
 
        System.out.println("Разрешающий столбец: r = " + (r + 1));
        System.out.println("Разрешающая строка:  s = " + (s + 1));
        printTable(c, a, cB, bV, bD, min);
   
        return printDecision(bV, bD);
    }
 
    /**
     * Печатает решение
     */
    static double[] printDecision(int[] bV, double[] bD) {
        int i, j;
        System.out.println("Все оценки неположительны, подсчет завершен.");
        System.out.print("Решение x = (");
        double[] res = new double[m];
        boolean f;
        for (j = 0; j < n; ++j) {
            f = false;
            for (i = 0; i < m; ++i) {
                if (bV[i] == j) {
                    if (j < m) {
                        res[j] = bD[i];
                    }
                    System.out.print(round(bD[i], 2));
                    f = true;
                    break;
                }
            }
            if (!f) {
                 System.out.print("0");
            }
            if (j < n - 1) {
                 System.out.print(", ");
            }
        }
        System.out.print(")");
        return res;
    }
 
    
    static void printTable(double[] c, double[][] a, double[] cB, int[] bV,
            double[] bD, double[] min) {
        int i, j;
        // вывод: строка коэффициентов
        System.out.print("\t\t\t\t");
        for (j = 0; j < n; ++j) {
             System.out.print(round(c[j], 2) + "\t");
        }
        System.out.println("C[j]");
 
        // вывод: ряд x
        System.out.print("\tcB\tbV\tbD\t");
        for (j = 0; j < n; ++j) {
             System.out.print("x[" + j + "]\t");
        }
        System.out.println("bD[i] / a[i][r]");
 
        for (i = 0; i < m; ++i) {
             System.out.print("\t" + round(cB[i], 2) + "\tx[" + (bV[i] + 1) + "]\t"
                    + round(bD[i], 2) + "\t");
            for (j = 0; j < n; ++j) {
                 System.out.print(round(a[i][j], 2) + "\t");
            }
            System.out.println(round(min[i], 2));
        }
    }
    
   /* static void printArray(double[] ar)
    {
         System.out.println();
        for (int i = 0; i < ar.length; ++i) {
             System.out.println("\t[" + i + "] = " + ar[i]);
        }
        System.out.println();
    }
 */
    static String round(double n, int p) {
        if (Double.isNaN(n)) {
            return "NaN";
        }
        if (Double.isInfinite(n)) {
            return "\u221E";
        }
        double d = pow(10, p);
        return (Math.round(n * d) / d) + "";
    }
}