java - 单纯形算法

我必须建立单纯形算法和它的工作，但我想允许用户输入数据，在方法main我做了几个“for”循环，我把数据放入数组，但我把相同的数据放入另一个数组，（他们有完全相同的数据）我不知道如何修复它。
当我试图为一种类型的日期创建一个数组时，它就崩溃了。
[编辑]
是的，我更新了扫描器（谢谢你们）
现在我有个错误：
“线程中的异常”main“java.lang.ArrayIndexOutOfBoundsException:2
在simplex.simplex$modeler上。（simplex.java:224）
位于simplex.simplex.main（simplex.java:196）

package simplex;

import java.awt.List;
import java.util.ArrayList;
import java.util.Scanner;

public class Simplex {

 private double[][] macierz; // macierz
 private int LiczbaOgraniczen; // liczba ograniczen
 private int LiczbaX; // liczba zmiennych "orginalnych"
 private boolean MaxCzyMin;
 private static final boolean MAX = true;
 private static final boolean MIN = false;

 private int[] baza; // baza[i] = basic variable corresponding to row i

 public Simplex(double[][] macierz, int LiczbaOgraniczen, int numberOfOriginalVariable, boolean MaxCzyMin) {
  this.MaxCzyMin = MaxCzyMin;
  this.LiczbaOgraniczen = LiczbaOgraniczen;
  this.LiczbaX = numberOfOriginalVariable;
  this.macierz = macierz;

  baza = new int[LiczbaOgraniczen];
  for (int i = 0; i < LiczbaOgraniczen; i++)
   baza[i] = LiczbaX + i;

  Licz();

 }

 // Licz algorytm simples od startowych BFS
 private void Licz() {
     while (true) {

         DrukujInteracje();
         int q = 0;
         // znajdz kolumne q wchodzącą do bazy
         if (MaxCzyMin) {
             q = ZnajdzIndexPoz(); //jesli szukamy max
         } else {
             q = ZnajdzIndexNeg(); //jesli szukamy min
         }

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

         // znajdz rzad p wychodzący z bazy
         int p = minRatioRule(q);
         if (p == -1){
             throw new ArithmeticException("BLAD");
         }
         //wiersz - kolumna
         piwot(p, q);

         // zaktualizuj baze
         baza[p] = q;
     }
 }

 // znajdowanie indexu niebazowej kolumny z najbardzoje pozytywnym kosztem
 private int ZnajdzIndexPoz() {
     int q = 0;
     for (int j = 1; j < LiczbaOgraniczen + LiczbaX; j++)
         if (macierz[LiczbaOgraniczen][j] > macierz[LiczbaOgraniczen][q])
             q = j;

     if (macierz[LiczbaOgraniczen][q] <= 0){
        return -1; // optimum
     } else {
        return q;
     }
 }

 // znajdowanie indexu niebazowej kolumny z najbardziej negatywnym kosztem
 private int ZnajdzIndexNeg() {
     int q = 0;
     for (int j = 1; j < LiczbaOgraniczen + LiczbaX; j++)
         if (macierz[LiczbaOgraniczen][j] < macierz[LiczbaOgraniczen][q])
             q = j;

     if (macierz[LiczbaOgraniczen][q] >= 0){
         return -1; // optimum
     } else {
         return q;
     }
}

 // find row p using min ratio rule (-1 if no such row)
 private int minRatioRule(int q) {
     int p = -1;
     for (int i = 0; i < LiczbaOgraniczen; i++) {
         if (macierz[i][q] <= 0)
             continue;
         else if (p == -1)
             p = i;
         else if ((macierz[i][LiczbaOgraniczen
             + LiczbaX] / macierz[i][q]) < (macierz[p][LiczbaOgraniczen
             + LiczbaX] / macierz[p][q]))
             p = i;
     }
     return p;
 }

 //zastosowanie metody Gauss-Jordan, aby doprowadzic macierz do postaci bazowej
 private void piwot(int p, int q) {

  for (int i = 0; i <= LiczbaOgraniczen; i++)
   for (int j = 0; j <= LiczbaOgraniczen + LiczbaX; j++)
    if (i != p && j != q)
     macierz[i][j] -= macierz[p][j] * macierz[i][q] / macierz[p][q];

  for (int i = 0; i <= LiczbaOgraniczen; i++)
   if (i != p)
    macierz[i][q] = 0.0;

  for (int j = 0; j <= LiczbaOgraniczen + LiczbaX; j++)
   if (j != q)
    macierz[p][j] /= macierz[p][q];
  macierz[p][q] = 1.0;
 }

 // Metoda zwraca wartosc funkcji celu
 public double WartoscFunkcjiCelu() {
  return -macierz[LiczbaOgraniczen][LiczbaOgraniczen + LiczbaX];
 }

 // metoda zwaraca wartosc x-ow
 public double[] WyliczX() {
  double[] x = new double[LiczbaX];
  for (int i = 0; i < LiczbaOgraniczen; i++)
  if (baza[i] < LiczbaX)
    x[baza[i]] = macierz[i][LiczbaOgraniczen + LiczbaX];
  return x;
 }

 // drukuj macierz => drukuj tabele
 public void DrukujInteracje() {
  System.out.println("Liczba Ograniczen = " + LiczbaOgraniczen);
  System.out.println("Liczba zmiennych 'orginalnych' = " + LiczbaX);
  for (int i = 0; i <= LiczbaOgraniczen; i++) {
   for (int j = 0; j <= LiczbaOgraniczen
     + LiczbaX; j++) {
    System.out.printf("%7.2f ", macierz[i][j]);
   }
   System.out.println();
  }
  System.out.println("Funkcja celu = " + WartoscFunkcjiCelu());
  for (int i = 0; i < LiczbaOgraniczen; i++)
   if (baza[i] < LiczbaX)
    System.out.println("x_"
      + baza[i]
      + " = "
      + macierz[i][LiczbaOgraniczen + LiczbaX]);
  System.out.println();
 }

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Podaj ilosc x");
        int iloscX = scan.nextInt();
        double[] WspolczynnikiFunkcjiCelu = new double[iloscX + 1];
    for(int ggg = 0; ggg < iloscX; ggg++){
        System.out.println("Podaj x" + ggg);
        WspolczynnikiFunkcjiCelu[ggg]  =scan.nextDouble();
}

    System.out.println("Podaj ilosc ograniczen");
    int iloscOgraniczen = scan.nextInt();
    double[][] LewaStronaOgraniczen = new double[iloscOgraniczen][iloscX];
    double[] PrawaStronaOgraniczen = new double[iloscOgraniczen + 1];
    Znaki[] OperatorOgraniczen = new Znaki [iloscOgraniczen + 1];

    for(int ggh = 0;ggh <iloscOgraniczen; ggh++){
        System.out.println("Podaj znak ograniczenia (lessThan - equal - greatherThan ");
        OperatorOgraniczen[ggh]  = Znaki.valueOf(scan.next());

        System.out.println("Podaj prawa strone ograniczenia");
        PrawaStronaOgraniczen[ggh] = scan.nextDouble();

        for(int haha = 0; haha < iloscX; haha++){
        System.out.println("Lewa strona: Podaj wspolczynnik przy x" + haha);
        LewaStronaOgraniczen[ggh][haha] =scan.nextDouble();
    }
    }


  //double[] WspolczynnikiFunkcjiCelu = {Xsy[0], Xsy[1]};
  // double[][] LewaStronaOgraniczen = {
    //    { TablicaTablic[0][0], TablicaTablic[0][1] }, { TablicaTablic[1][0], TablicaTablic[1][1] }, { TablicaTablic[2][0], TablicaTablic[2][1] }, { TablicaTablic[3][0], TablicaTablic[3][1] } };
  //Znaki[] OperatorOgraniczen = { TablicaOgraniczen[0], TablicaOgraniczen[1], TablicaOgraniczen[2], TablicaOgraniczen[3] };
  //double[] PrawaStronaOgraniczen = {TablicaPrawejStrony[0],TablicaPrawejStrony[1],TablicaPrawejStrony[2],TablicaPrawejStrony[3]};


  Modeler model = new Modeler(LewaStronaOgraniczen, PrawaStronaOgraniczen, OperatorOgraniczen, WspolczynnikiFunkcjiCelu);

  Simplex simplex = new Simplex(model.getmacierz(),
    model.getLiczbaOgraniczen(),
    model.getLiczbaX(), MAX);
  double[] x = simplex.WyliczX();
  for (int i = 0; i < x.length; i++)
   System.out.println("x[" + i + "] = " + x[i]);
  System.out.println("Rozwiazanie optymalne: " + simplex.WartoscFunkcjiCelu());
 }

 //zbior mozliwych znakow ograniczajacych
 private enum Znaki {
  lessThan, equal, greatherThan
 }

 public static class Modeler {
  private double[][] a; // macierz
  private int LiczbaOgraniczen; // Liczba Ograniczen
  private int LiczbaX; // Liczba x w funkcji celu

  public Modeler(double[][] LewaStronaOgraniczen,double[] PrawaStronaOgraniczen, Znaki[] OperatorOgraniczen, double[] WspolczynnikiFunkcjiCelu) {
   LiczbaOgraniczen = PrawaStronaOgraniczen.length;
   LiczbaX = WspolczynnikiFunkcjiCelu.length;
   a = new double[LiczbaOgraniczen + 1][LiczbaX + LiczbaOgraniczen + 1];

   for (int i = 0; i < LiczbaOgraniczen; i++) {
    for (int j = 0; j < LiczbaX; j++) {
     a[i][j] = LewaStronaOgraniczen[i][j];
    }
   }

   for (int i = 0; i < LiczbaOgraniczen; i++)
    a[i][LiczbaOgraniczen + LiczbaX] = PrawaStronaOgraniczen[i];

   for (int i = 0; i < LiczbaOgraniczen; i++) {
    int slack = 0;
    switch (OperatorOgraniczen[i]) {
    case greatherThan:
     slack = -1;
     break;
    case lessThan:
     slack = 1;
     break;
    default:
    }
    a[i][LiczbaX + i] = slack;
   }

   for (int j = 0; j < LiczbaX; j++)
    a[LiczbaOgraniczen][j] = WspolczynnikiFunkcjiCelu[j];
  }

  public double[][] getmacierz() {
   return a;
  }

  public int getLiczbaOgraniczen() {
   return LiczbaOgraniczen;
  }

  public int getLiczbaX() {
   return LiczbaX;
  }
 }

}

最佳答案

为什么你有这么多扫描仪？试着只用一个。在main方法的开头声明并初始化它。

关于java - 单纯形算法，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/41653658/