java单纯形法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SimpleMethod {

  public static void main(String[] args) {
    // 输入已满足前三个特点的标准形线性规划 初等行变化时（两数相除）会出现小数 int->double
    double a[][] = { { -1, 1, 1, 0, 0 }, { 1, 2, 0, 1, 0 }, { 3, 1, 0, 0, 1 } };
    double b[] = { 2, 10, 15 };
    double c[] = { -2, -3, 0, 0, 0 };
    double z = 0;
    int indexOfBaseVar[] = new int[c.length];
    int indexOfOffBaseVar[] = new int[2];
    // 判断底行元素均为非负
    while (hasNegativeInBottomElement(c)) {
      // 选择进基变量
      indexOfBaseVar = selectBaseVar(a, b, c, z);
      // 选择离基变量
      indexOfOffBaseVar = selectOffBaseVar(a, b, c, z, indexOfBaseVar);
      // 旋转运算
      z = rotationOperation(a, b, c, z, indexOfOffBaseVar);
    }
    System.out.println("最优值为z=" + (-z));
  }

  // 旋转运算
  private static double rotationOperation(double[][] a, double[] b, double[] c, double z, int[] indexOfOffBaseVar) {
    // 若直接将a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]]放进表达式中，此值在循环过程中会变化，故先将此值复制出来
    double temp1 = a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]];
    for (int j = 0; j < a[indexOfOffBaseVar[0]].length; j++) {
      a[indexOfOffBaseVar[0]][j] /= temp1;
    }
    b[indexOfOffBaseVar[0]] /= temp1;
    for (int i = 0; i < a.length; i++) {
      if (i != indexOfOffBaseVar[0]) {
        double[] temp2 = Arrays.copyOf(a[i], a[i].length);
        for (int j = 0; j < a[i].length; j++) {
          a[i][j] -= temp2[indexOfOffBaseVar[1]] / a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]]
              * a[indexOfOffBaseVar[0]][j];
        }
        b[i] -= temp2[indexOfOffBaseVar[1]] / a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]] * b[indexOfOffBaseVar[0]];
      }
    }
    double temp3 = c[indexOfOffBaseVar[1]];
    for (int j = 0; j < c.length; j++) {
      c[j] -= temp3 / a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]] * a[indexOfOffBaseVar[0]][j];
    }
    z -= temp3 / a[indexOfOffBaseVar[0]][indexOfOffBaseVar[1]] * b[indexOfOffBaseVar[0]];
    return z;
  }

  // 选择离基变量
  private static int[] selectOffBaseVar(double[][] a, double[] b, double[] c, double z, int[] indexOfBaseVar) {
    int[] indexOfMin = new int[2];
    // min初始化时设置一个足够大的数
    double min = 9999;
    for (int i : indexOfBaseVar) {
      if (i >= 0)
        for (int j = 0; j < a.length; j++) {
          if (a[j][i] > 0 && b[j] / a[j][i] < min) {
            // min要重新赋最小值
            min = b[j] / a[j][i];
            indexOfMin[0] = j;
            indexOfMin[1] = i;
          }
        }
    }
    return indexOfMin;
  }

  // 判断底行元素均为非负
  private static boolean hasNegativeInBottomElement(double[] c) {
    for (int i = 0; i < c.length; i++) {
      if (c[i] < 0)
        return true;
    }
    return false;
  }

  // 选择进基变量
  private static int[] selectBaseVar(double[][] a, double[] b, double[] c, double z) {
    int indexOfC[] = new int[c.length];
    // 默认值为0，索引有0，故将默认值0改成-1防止造成干扰
    for (int i = 0; i < indexOfC.length; i++) {
      indexOfC[i] = -1;
    }
    List<Integer> indexList = new ArrayList<Integer>();
    for (int i = 0; i < c.length; i++) {
      if (c[i] < 0)
        indexList.add(i);
    }
    for (int i = 0; i < indexList.size(); i++) {
      indexOfC[i] = indexList.get(i);
    }
    return indexOfC;
  }

}