

import org.gnu.glpk.GlpkSolver;


public class main {
    /** Creates a new instance of Main */
    public main() {
    }


   // le tableau des colonnes
       static String[] mon_tableau = new String[100];
       static int mon_numero=0;

       static void ajouter_nom_col (String un_nom)
       {
         mon_numero = mon_numero +1;
         mon_tableau [mon_numero]=un_nom;
       }

       static int rechercher (String un_nom)
       {
         int trouve=0;
         int i=1;

         while ((trouve==0) && (i<=mon_numero) )
         {
           // cette ligne est fausse
           if (mon_tableau[i].equals(un_nom))
           {
           trouve = 1;
           }
           else
             i = i+1;
         } // fin du while
       if (trouve==0)
           return 0;
       else return i;

       }



    public static void main(String[] args) {

  // declaration des variables du probleme
  int[] ia, ja;
  double[] ar;
  ia = new int[1000];
  ja = new int[1000];
  ar = new double[1000];
  double [] Coefficient_obj = new double [6];
  double [] Coefficient_obj_MP = new double [30];
  double [][] Coefficient_contrainte_MP = new double [30][30];
  double [] Coefficient_obj_Sous_Probleme = new double [6];
  double [][] Coefficient_contrainte = new double [7][6];
  double [][] Coefficient_x_en_fonction_lambda = new double [6][11];
  double [] ecart = new double [10];
  double [] Part_droit = new double [10];

  double [][] coefficient_Lambda = new double [6][11];
  double [][] Base_1 = new double [31][6];
  double [][] Base_2 = new double [31][6];

  double [] Rayon_Base_1 = new double [30];
  double [] Rayon_Base_2 = new double [30];
  double [] x = new double [6];
  double x_couplante, x_convexe_1, x_convexe_2, somme;

  double Z, x1, x2, x3, x4, xj;
  int i,j,k;
  int CompteurCol;
  int CompteurContrainte;
  int CompteurIA;
  int Compteur;
  int nbligne;
  int position;
  int i_suite;
  int Iter;
  boolean Stop;
  String nomcol;
  String nomcontrainte;
  String strE = "mon_modele.txt";
  String master_glp = "Master_probleme";
  String out1_glp = "modeleP";
  String sp_glp = "Sous_probleme";
  int nb_base_1, nb_base_2, res;
  double epsilon=0.000001;



  Coefficient_obj[1]=-1;
  Coefficient_obj[2]=-1;
  Coefficient_obj[3]=-1;
  Coefficient_obj[4]=-1;

  // les contraintes
  // C1
  Coefficient_contrainte[1][1]=1;
  Coefficient_contrainte[1][2]=2;
  Coefficient_contrainte[1][3]=2;
  Coefficient_contrainte[1][4]=1;
  Part_droit[1]=40;

  // C2
  Coefficient_contrainte[2][1]=1;
  Coefficient_contrainte[2][2]=3;
  Coefficient_contrainte[2][3]=0;
  Coefficient_contrainte[2][4]=0;
  Part_droit[2]=30;

  // C3
  Coefficient_contrainte[3][1]=2;
  Coefficient_contrainte[3][2]=1;
  Coefficient_contrainte[3][3]=0;
  Coefficient_contrainte[3][4]=0;
  Part_droit[3]=20;

  // C4
  Coefficient_contrainte[4][1]=0;
  Coefficient_contrainte[4][2]=0;
  Coefficient_contrainte[4][3]=1;
  Coefficient_contrainte[4][4]=0;
  Part_droit[4]=10;

  // C5
  Coefficient_contrainte[5][1]=0;
  Coefficient_contrainte[5][2]=0;
  Coefficient_contrainte[5][3]=0;
  Coefficient_contrainte[5][4]=1;
  Part_droit[5]=10;

  // C5
  Coefficient_contrainte[6][1]=0;
  Coefficient_contrainte[6][2]=0;
  Coefficient_contrainte[6][3]=1;
  Coefficient_contrainte[6][4]=1;
  Part_droit[6]=15;

  System.out.println("---------- bloc 1 ------------");

  Compteur=0;
  CompteurContrainte=0;
  CompteurCol=0;
  CompteurIA=0;
  mon_numero=0;

  GlpkSolver solver = new GlpkSolver();
  solver.setProbName("Simple");




  // declaration des variables xj

  nomcol="x_1";
  solver.addCols(1);
  CompteurCol++;
  ajouter_nom_col (nomcol);
  solver.setColName(CompteurCol, nomcol);
  solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 1.0);

  nomcol="x_2";
  solver.addCols(1);
  CompteurCol++;
  ajouter_nom_col (nomcol);
  solver.setColName(CompteurCol, nomcol);
  solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 1.0);



  CompteurContrainte=0;


  // contrainte 1
  nbligne=1;

  for (k=2; k<=3; k++)
  {
   solver.addRows(1);
   CompteurContrainte++;
   nomcontrainte="C_"+CompteurContrainte;
   solver.setRowName(CompteurContrainte, nomcontrainte);
   solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[k]);

   for (i=1; i<=2; i++)
   {
    if (Coefficient_contrainte[k][i]!=0)
    {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[k][i];
    }
   }

  }

 for (i=1; i<=2; i++)
 {
    if (Coefficient_obj[i]!=0.0)
    {
     nomcol="x_"+i;
     position=rechercher(nomcol);
     solver.setObjCoef(position , Coefficient_obj[i]);
    }
 }


  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("bloc_1_Minimisation.txt");

  solver.setObjDir(solver.LPX_MIN);
  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("sol. opt = "+Z);

  nomcol="x_1";
  position=rechercher(nomcol);
  x1=solver.getColPrim(position);
  System.out.println("x1 = "+x1);

  nomcol="x_2";
  position=rechercher(nomcol);
  x2=solver.getColPrim(position);
  System.out.println("x2 = "+x2);

  Base_1[1][1]=x1;
  Base_1[1][2]=x2;
  Base_1[1][3]=0;
  Base_1[1][4]=0;
  Rayon_Base_1[1]=0;


  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("bloc_1_Maximisation.txt");

  solver.setObjDir(solver.LPX_MAX);
  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("Sol. Opt. = "+ Z);

  nomcol="x_1";
  position=rechercher(nomcol);
  x1=solver.getColPrim(position);
  System.out.println(nomcol+" : "+x1);

  nomcol="x_2";
  position=rechercher(nomcol);
  x2=solver.getColPrim(position);
  System.out.println(nomcol+" : "+x2);

  solver.deleteProb();


  Base_1[2][1]=x1;
  Base_1[2][2]=x2;
  Base_1[2][3]=0;
  Base_1[2][4]=0;
  Rayon_Base_1[2]=0;

  System.out.println("---------- bloc 2 ------------");


  Compteur=0;
  CompteurContrainte=0;
  CompteurCol=0;
  CompteurIA=0;
  mon_numero=0;

  solver = new GlpkSolver();
  solver.setProbName("Simple");



  // declaration des variables xj

  nomcol="x_3";
  solver.addCols(1);
  CompteurCol++;
  ajouter_nom_col (nomcol);
  solver.setColName(CompteurCol, nomcol);
  solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 1.0);

  nomcol="x_4";
  solver.addCols(1);
  CompteurCol++;
  ajouter_nom_col (nomcol);
  solver.setColName(CompteurCol, nomcol);
  solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 1.0);

  CompteurContrainte=0;

  // contrainte 1
  nbligne=1;

  for (k=4; k<=6; k++)
  {
   solver.addRows(1);
   CompteurContrainte++;
   nomcontrainte="C_"+CompteurContrainte;
   solver.setRowName(CompteurContrainte, nomcontrainte);
   solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[k]);

   for (i=3; i<=4; i++)
   {
    if (Coefficient_contrainte[k][i]!=0)
    {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[k][i];
    }
   }

  }


  nomcol="x_3";
  position=rechercher(nomcol);
  solver.setObjCoef(position , Coefficient_obj[3]);

  nomcol="x_4";
  position=rechercher(nomcol);
  solver.setObjCoef(position , Coefficient_obj[4]);

  solver.setObjDir(solver.LPX_MIN);
  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("bloc_2_Minimisation.txt");
  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("sol. opt = "+Z);

  nomcol="x_3";
  position=rechercher(nomcol);
  x3=solver.getColPrim(position);
  System.out.println("x3 = "+x3);

  nomcol="x_4";
  position=rechercher(nomcol);
  x4=solver.getColPrim(position);
  System.out.println("x4 = "+x4);

  Base_2[1][1]=0;
  Base_2[1][2]=0;
  Base_2[1][3]=x3;
  Base_2[1][4]=x4;
  Rayon_Base_2[1]=0;

  solver.setObjDir(solver.LPX_MAX);

  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("bloc_2_Maximisation.txt");
  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("Sol. Opt. = "+ Z);

  nomcol="x_3";
  position=rechercher(nomcol);
  x3=solver.getColPrim(position);
  System.out.println(nomcol+" : "+x3);

  nomcol="x_4";
  position=rechercher(nomcol);
  x4=solver.getColPrim(position);
  System.out.println(nomcol+" : "+x4);

  Base_2[2][1]=0;
  Base_2[2][2]=0;
  Base_2[2][3]=x3;
  Base_2[2][4]=x4;
  Rayon_Base_2[2]=0;

  solver.deleteProb();

  System.out.println(".... resume....");
  System.out.println("base 1");
  for (i=1; i<=2; i++)
  {
    for (j=1; j<=4; j++)
    {
     System.out.print("x_"+j+" : "+Base_1[i][j]+ " ");
    }
    System.out.println("");
  }

  System.out.println("base 2");
  for (i=1; i<=2; i++)
  {
    for (j=1; j<=4; j++)
    {
     System.out.print("x_"+j+" : "+ Base_2[i][j]+ " ");
    }
    System.out.println(" ");
  }

  nb_base_1=2;
  nb_base_2=2;

  for (i=1; i<=4; i++)
  {
    Coefficient_obj_Sous_Probleme[i]=Coefficient_obj[i];
  }

  System.out.println("");
  System.out.println("");
  System.out.println("****** DANTZIG WOLFE ************");

  Iter=1;
  Stop=false;
  while ( (Iter<20) && (Stop==false) )
  {
   System.out.println("");
   System.out.println("");
   System.out.println("Iteration numero "+ Iter);

   for (i=1; i<=5; i++)
      for (j=1; j<=10; j++)
         Coefficient_x_en_fonction_lambda[i][j]=0;

   for (i=1; i<=2; i++)
   {
      // i ==> xi
      for (j=1; j<=nb_base_1; j++)
      {                        // i ==> Lambda_i
      Coefficient_x_en_fonction_lambda[i][j]=Coefficient_x_en_fonction_lambda[i][j]+Base_1[j][i];
      }
   }


   for (i=3; i<=4; i++)
   {
      // i ==> xi
      for (j=1; j<=nb_base_2; j++)
      {                        // i ==> Lambda_i
      Coefficient_x_en_fonction_lambda[i][j]=Coefficient_x_en_fonction_lambda[i][j]+Base_2[j][i];
      }
   }



  // coefficient foncton obj
  for (i=1; i<=nb_base_1; i++)
  {
   Coefficient_obj_MP[i]=0;
   for (j=1; j<=2; j++)
   {
     Coefficient_obj_MP[i]= Coefficient_obj_MP[i]+Coefficient_obj[j]*Coefficient_x_en_fonction_lambda[j][i];
   }
  }

  i_suite = i-1;
  for (i=1; i<=nb_base_2; i++)
  {
   i_suite=i_suite+1;
   Coefficient_obj_MP[i_suite]=0;
   for (j=3; j<=4; j++)
   {
     Coefficient_obj_MP[i_suite]= Coefficient_obj_MP[i_suite]+
               Coefficient_obj[j]*Coefficient_x_en_fonction_lambda[j][i];
   }
  }

  // les contraintes

  for (i=1; i<=nb_base_1; i++)
  {
   Coefficient_contrainte_MP[1][i]=0;
   for (j=1; j<=2; j++)
   {
     Coefficient_contrainte_MP[1][i]= Coefficient_contrainte_MP[1][i]+
                 Coefficient_contrainte[1][j]*Coefficient_x_en_fonction_lambda[j][i];
   }
  }

  i_suite = i-1;

  for (i=1; i<=nb_base_2; i++)
  {
   i_suite=i_suite+1;
   Coefficient_contrainte_MP[1][i_suite]=0;
   for (j=3; j<=4; j++)
   {
     Coefficient_contrainte_MP[1][i_suite]= Coefficient_contrainte_MP[1][i_suite]+
                 Coefficient_contrainte[1][j]*Coefficient_x_en_fonction_lambda[j][i];
   }
  }

  System.out.println("");
  System.out.println("resolution probleme maitre ....");
  System.out.println("----------------------------------");

  Compteur=0;
  CompteurContrainte=0;
  CompteurCol=0;
  CompteurIA=0;
  mon_numero=0;


  solver = new GlpkSolver();
  solver.setProbName("Master Problem");
  solver.setObjDir(solver.LPX_MIN);

  // declaration des variables x1
  for (i=1; i<=nb_base_1; i++)
  {
   nomcol="L_"+i;
   solver.addCols(1);
   CompteurCol++;
   ajouter_nom_col (nomcol);
   solver.setColName(CompteurCol, nomcol);
   solver.setColBnds(CompteurCol, solver.LPX_UP, 0.0, 1.0);
  }

  for (i=1; i<=nb_base_2; i++)
  {
   nomcol="B_"+i;
   solver.addCols(1);
   CompteurCol++;
   ajouter_nom_col (nomcol);
   solver.setColName(CompteurCol, nomcol);
   solver.setColBnds(CompteurCol, solver.LPX_UP, 0.0, 1.0);
  }

  CompteurContrainte=0;
  nbligne=1;


  // contrainte couplante

 for (k=1; k<=1; k++)
 {

  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_FX, Part_droit[k], Part_droit[k]);

  for (i=1; i<=nb_base_1; i++)
  {
   if (Coefficient_contrainte_MP[k][i]!=0)
   {
    nomcol="L_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte_MP[k][i];
   }
  }

  i_suite=i-1;
  for (i=1; i<=nb_base_2; i++)
  {
   i_suite++;
   if (Coefficient_contrainte_MP[k][i_suite]!=0)
   {
    nomcol="B_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte_MP[k][i_suite];
   }
  }

 }

 // contrainte de convexite

  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_FX, 1.0, 1);


  for (i=1; i<=nb_base_1; i++)
  {
    if (Rayon_Base_1[i]==0)
    {
    nomcol="L_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = 1;
    }
  }

  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_FX, 1.0, 1);



  for (i=1; i<=nb_base_2; i++)
  { if (Rayon_Base_2[i]==0)
    {
    nomcol="B_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = 1;
    }
  }


  // attention les Li et Bi sont >=0

  for (i=1; i<=nb_base_1; i++)
  {
    solver.addRows(1);
    CompteurContrainte++;
    nomcontrainte="C_"+CompteurContrainte;
    solver.setRowName(CompteurContrainte, nomcontrainte);
    solver.setRowBnds(CompteurContrainte, solver.LPX_LO, 0.0, 0.0);

    nomcol="L_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = 1;
  }

  for (i=1; i<=nb_base_2; i++)
  {
    solver.addRows(1);
    CompteurContrainte++;
    nomcontrainte="C_"+CompteurContrainte;
    solver.setRowName(CompteurContrainte, nomcontrainte);
    solver.setRowBnds(CompteurContrainte, solver.LPX_LO, 0.0, 0.0);

    nomcol="B_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = 1;
  }

  // definition de la fonction objectif

  for (i=1; i<=nb_base_1; i++)
  {
    if (Coefficient_obj_MP[i]!=0)
    {
     nomcol="L_"+i;
     position=rechercher(nomcol);
     solver.setObjCoef(position , Coefficient_obj_MP[i]);
     }
  }

  i_suite=i-1;
  for (i=1; i<=nb_base_2; i++)
  {
    i_suite=i_suite+1;
    if (Coefficient_obj_MP[i_suite]!=0)
    {
     nomcol="B_"+i;
     position=rechercher(nomcol);
     solver.setObjCoef(position , Coefficient_obj_MP[i_suite]);
    }
  }

  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp(master_glp+Iter+".txt");

  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("Z = "+ Z);


  for (i=1; i<=nb_base_1; i++)
  {
    nomcol="L_"+i;
    position=rechercher(nomcol);
    xj=solver.getColPrim(position);
    if (Math.abs(xj)<1E-6)
        xj=0;
    System.out.println(nomcol+" : "+xj);
  }

  for (i=1; i<=nb_base_2; i++)
  {
    nomcol="B_"+i;
    position=rechercher(nomcol);
    xj=solver.getColPrim(position);
    if (Math.abs(xj)<1E-6)
        xj=0;
    System.out.println(nomcol+" : "+xj);
  }


  solver.printSol("Sol_master_"+Iter+".txt");

  x_couplante=solver.getRowDual(1);
  System.out.println("variable duale de la contrainte couplante : "+x_couplante);

  x_convexe_1=solver.getRowDual(2);
  System.out.println("variable duale contrainte convexite 1 : "+x_convexe_1);

  //index :=  lpx_get_col_b_ind(lp,3);
  x_convexe_2=solver.getRowDual(3);
  System.out.println("variable duale contrainte convexite 2 : "+x_convexe_2);


  solver.deleteProb();

  System.out.println("");
  System.out.println("resolution du sous-probleme numero 1 avec x1 et x2");
  System.out.println("--------------------------------------------------");

  // creation du sous probleme
  for (i=1; i<=4; i++)
  {
    Coefficient_obj_Sous_Probleme[i]=(Coefficient_obj[i]-x_couplante*Coefficient_contrainte[1][i]);
  }

  // sous_probleme a
  Compteur=0;
  CompteurContrainte=0;
  CompteurCol=0;
  CompteurIA=0;
  mon_numero=0;

  solver = new GlpkSolver();
  solver.setProbName("Sous Probleme 1");
  solver.setObjDir(solver.LPX_MIN);

  for (i=1; i<=2; i++)
  {
   nomcol="x_"+i;
   solver.addCols(1);
   CompteurCol++;
   ajouter_nom_col (nomcol);
   solver.setColName(CompteurCol, nomcol);
  // lpx_set_col_kind(lp, CompteurCol, LPX_IV);
   solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 0.0);
  }

  // les contraintes

  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[2]);

  for (i=1; i<=2; i++)
  {
   if ( Coefficient_contrainte[2][i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[2][i];
   }
  }


  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[3]);

  for (i=1; i<=2; i++)
  {
   if ( Coefficient_contrainte[3][i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[3][i];
   }
  }



  for (i=1; i<=2; i++)
  {
   if ( Coefficient_obj_Sous_Probleme[i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    solver.setObjCoef(position, Coefficient_obj_Sous_Probleme[i]);
   }
  }




  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("Sous_Probleme_A_"+Iter+".txt");

  solver.simplex();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("Z = "+Z);

  for (i=1; i<=2; i++)
  {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    x[i]=solver.getColPrim(position);
    System.out.println(nomcol+" : "+x[i]);
  }

  res=solver.getStatus();





  if (res==solver.LPX_UNBND)
  {
    System.out.println("sol. non bornee...");
    System.out.println("ajout d''un rayon");
    k=solver.getRayInfo();
    k--;
    System.out.println("le rayon est du a x_"+ k);
    nb_base_1=nb_base_1+1;
    Base_1[nb_base_1][1]=0;
    Base_1[nb_base_1][2]=0;
    Base_1[nb_base_1][3]=0;
    Base_1[nb_base_1][4]=0;
    //le rayon
    Base_1[nb_base_1][k]=1;
    Stop=false;
    Rayon_Base_1[nb_base_1]=1; // c'est un rayon
  }
  else
  {
    Stop=true;
    double diff = Z-x_convexe_1;
    if (Math.abs(diff)<epsilon)
    {    diff=0;
         System.out.println("sqdfdfdsf");
    }
    if (diff<0)
    {
     // un element supplementaire est ajout  la base_1
     nb_base_1=nb_base_1+1;
     Base_1[nb_base_1][1]=x[1];
     Base_1[nb_base_1][2]=x[2];
     Base_1[nb_base_1][3]=0;
     Base_1[nb_base_1][4]=0;
     Rayon_Base_1[nb_base_1]=0;
     Stop=false;
    }

  }


  solver.deleteProb();

  System.out.println("");
  System.out.println("resolution du sous-probleme numero 2 avec x3 et x4");
  System.out.println("--------------------------------------------------");

  // sous_probleme b

  Compteur=0;
  CompteurContrainte=0;
  CompteurCol=0;
  CompteurIA=0;
  mon_numero=0;

  solver= new GlpkSolver();
  solver.setProbName("sous_probleme_2");
  solver.setObjDir(solver.LPX_MIN);

  // les variables
  for (i=3; i<=4; i++)
  {
   nomcol="x_"+i;
   solver.addCols(1);
   CompteurCol++;
   ajouter_nom_col (nomcol);
   solver.setColName(CompteurCol, nomcol);
   solver.setColBnds(CompteurCol, solver.LPX_LO, 0.0, 0.0);
  }

 // les contraintes

  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[4]);

  for (i=3; i<=4; i++)
  {
   if ( Coefficient_contrainte[4][i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[4][i];
   }
  }


  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[5]);

  for (i=3; i<=4; i++)
  {
   if ( Coefficient_contrainte[5][i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[5][i];
   }
  }


  solver.addRows(1);
  CompteurContrainte++;
  nomcontrainte="C_"+CompteurContrainte;
  solver.setRowName(CompteurContrainte, nomcontrainte);
  solver.setRowBnds(CompteurContrainte, solver.LPX_UP, 0.0, Part_droit[6]);

  for (i=3; i<=4; i++)
  {
   if ( Coefficient_contrainte[6][i]!=0)
   {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    CompteurIA++;
    ia[CompteurIA] = CompteurContrainte;
    ja[CompteurIA] = position;
    ar[CompteurIA] = Coefficient_contrainte[6][i];
   }
  }



  for (i=3; i<=4; i++)
  {
    if (Coefficient_obj_Sous_Probleme[i]!=0)
    {
     nomcol="x_"+i;
     position=rechercher(nomcol);
     solver.setObjCoef(position , Coefficient_obj_Sous_Probleme[i]);
    }
  }

  solver.loadMatrix(CompteurIA, ia, ja, ar);
  solver.writeCpxlp("Sous_Probleme_B_"+Iter+".txt");


  solver.simplex();
//  solver.integer();

  // recuparation de la fonction objectif
  Z = solver.getObjVal();
  System.out.println("Z = "+ Z);

  for (i=3;i<=4; i++)
  {
    nomcol="x_"+i;
    position=rechercher(nomcol);
    x[i]=solver.getColPrim(position);
    System.out.println(nomcol+" : "+x[i]);
  }




  res=solver.getStatus();

  if (res==solver.LPX_UNBND)
  {
    System.out.println("sol. non bornee...");
    System.out.println("ajout d''un rayon");
    k=solver.getRayInfo();
    k--;
    System.out.println("le rayon est du a x_"+ k);
    nb_base_2=nb_base_2+1;
    Base_2[nb_base_2][1]=0;
    Base_2[nb_base_2][2]=0;
    Base_2[nb_base_2][3]=0;
    Base_2[nb_base_2][4]=0;
    // le rayon
    Base_2[nb_base_2][k]=1;
    Rayon_Base_2[nb_base_2]=1; // c'est un rayon
    Stop=false;
  }
  else
  {
	double diff =  Z-x_convexe_2;
	if (Math.abs(diff)<epsilon)
	{
      diff = 0;
	}
    if (diff<0)
    {
     // un element supplementaire est ajout  la base_1
     nb_base_2=nb_base_2+1;
     Base_2[nb_base_2][1]=0;
     Base_2[nb_base_2][2]=0;
     Base_2[nb_base_2][3]=x[3];
     Base_2[nb_base_2][4]=x[4];
     Rayon_Base_2[nb_base_2]=0;
     Stop=false;
    }

  }

  solver.deleteProb();

  Iter=Iter+1;

  } // fin du while




  }
}