daily pastebin goal
25%
SHARE
TWEET

Untitled

a guest Feb 13th, 2018 61 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <glpk.h>
  5.  
  6. #define STRINGLENGTH 30
  7.  // Compilation : gcc -o rouleaux rouleaux.c -I/usr/local/include -lglpk -L/usr/local/lib
  8. typedef struct Rouleau Rouleau;
  9. struct Rouleau {
  10.     int quantite;
  11.     int taille;
  12. };
  13.  
  14. Rouleau creer_rouleau(int quantite, int taille){
  15.         Rouleau rouleau;
  16.         rouleau.quantite = quantite;
  17.         rouleau.taille = taille;
  18.         return rouleau;
  19. }
  20.  
  21.  
  22. void init_matrix(double *matrix_coefs,int nbrouleau){
  23.     int tmp = 1;
  24.     int taille = nbrouleau*nbrouleau;
  25.     matrix_coefs[0] = 0;
  26.     for(int i=1; i<=taille; i++){
  27.         if(i==tmp){
  28.             matrix_coefs[i] = 1;
  29.             tmp = tmp + nbrouleau + 1;
  30.         }
  31.         else
  32.             matrix_coefs[i] = 0;
  33.     }
  34. }
  35.  
  36. void init_row(int *nbr_rows, int nbr_row, int nbr_col){
  37.     int taille = nbr_row*nbr_col;
  38.     nbr_rows[0] = 0;
  39.     for(int i=1; i<=nbr_row; i++){
  40.         for(int j=1; j<=nbr_col; j++){
  41.         nbr_rows[(i-1)*nbr_col+j] = i;
  42.         }
  43.     }
  44. }
  45.  
  46. void init_column(int *nbr_rows, int nbr_row, int nbr_col){
  47.     int taille = nbr_row*nbr_col;
  48.     nbr_rows[0] = 0;
  49.     for(int i=1; i<=nbr_row; i++){
  50.         for(int j=1; j<=nbr_col; j++){
  51.         nbr_rows[(i-1)*nbr_col+j] = j;
  52.         }
  53.     }
  54. }
  55.  
  56. void init_obj_coefs(double *obj_coefs, int nbr_columns){
  57.     obj_coefs[0] = 0;
  58.     for(int i=1; i<=nbr_columns; i++)
  59.         obj_coefs[i] = 1;
  60. }
  61.  
  62. int main(int argc, char *argv[]) {
  63.    
  64.     if(argc != 2){
  65.         printf("Usage : %s [fichier]\n", argv[0]);
  66.         exit(0);
  67.     }
  68.     int largeur = 0;
  69.     Rouleau *listerouleau;
  70.     int tmp_taile,tmp_quantite;
  71.     int nbrouleau = 0;
  72.     listerouleau = malloc(nbrouleau * sizeof(Rouleau));
  73.    
  74.     FILE * fichier = fopen(argv[1],"r");
  75.     if (fichier != NULL){
  76.        
  77.         fscanf(fichier,"%d\n",&largeur);
  78.        
  79.         while(fscanf(fichier,"%d %d\n",&tmp_quantite,&tmp_taile) == 2){
  80.             nbrouleau++;
  81.             listerouleau = realloc(listerouleau, nbrouleau*sizeof(Rouleau));
  82.             listerouleau[nbrouleau-1] = creer_rouleau(tmp_quantite,tmp_taile);
  83.         }
  84.     }
  85.                
  86.     printf("Largeur initiale : %d\n",largeur);
  87.    
  88.     printf("Liste rouleaux :\n");
  89.     for(int i=0; i<nbrouleau; i++){
  90.         printf("\t%d\tRouleaux de largeur %d\n", listerouleau[i].quantite, listerouleau[i].taille);
  91.     }
  92.  
  93.    
  94.     int nbr_rows = nbrouleau;
  95.     int nbr_columns = nbrouleau;
  96.     int nbr_coefs = nbr_rows*nbr_columns;
  97.    
  98.     /* Tableau des coefficients de la matrice */
  99.     double *matrix_coefs;
  100.     matrix_coefs = malloc((nbr_coefs + 1)*sizeof(double));
  101.    
  102.    
  103.     init_matrix(matrix_coefs, nbrouleau);
  104.  
  105.  
  106.    
  107.    
  108.    
  109.     double z=42;
  110.    
  111.     do{
  112.    
  113.         /* Position de chaque coefficient */
  114.    
  115.         int *row_of_coef = malloc((nbr_coefs + 1)*sizeof(int));
  116.         init_row(row_of_coef, nbr_rows, nbr_columns);  
  117.    
  118.         int *column_of_coef = malloc((nbr_coefs + 1)*sizeof(int));
  119.         init_column(column_of_coef, nbr_rows, nbr_columns);
  120.  
  121.    
  122.         /* matrix_coef[i] est le coefficient de la matrice en ligne
  123.            row_of_coefs[i] et en colonne column_of_coefs[i].*/
  124.    
  125.         double row_bounds[] = {0, 97, 610, 395, 211}; //TODO Une fonction automatique. ne change jamais
  126.         double *obj_coefs = malloc((nbr_columns+1) * sizeof(double));
  127.         init_obj_coefs(obj_coefs, nbr_columns);
  128.         /* création d'un programme linéaire */
  129.         glp_prob *lp;
  130.         lp = glp_create_prob();
  131.         glp_set_prob_name(lp, "example"); /* Nommer le problème est obligatoire */
  132.         glp_set_obj_dir(lp, GLP_MIN); /* Détermine l'objectif MIN ou MAX */
  133.  
  134.         /* Initialisation du problème */
  135.  
  136.         /* ajoute des lignes (contraintes) */
  137.         glp_add_rows(lp, nbr_rows);
  138.         for(int row_index = 1; row_index <= nbr_rows; row_index++) {
  139.             char constraint_name[STRINGLENGTH];
  140.             sprintf(constraint_name, "contrainte_PL %d", row_index);
  141.             /* nomme la contrainte */
  142.             glp_set_row_name(lp, row_index, constraint_name);
  143.             glp_set_row_bnds(lp, row_index, GLP_FX, row_bounds[row_index], row_bounds[row_index]);
  144.            
  145.         }
  146.  
  147.         /* Ajoute des variables */
  148.         glp_add_cols(lp, nbr_columns);
  149.         for (int column_index = 1 ; column_index <= nbr_columns; column_index++){
  150.             char variable_name[STRINGLENGTH];
  151.             sprintf(variable_name, "x_%d", column_index);
  152.             glp_set_col_name(lp, column_index,variable_name);
  153.             glp_set_col_bnds(lp, column_index, GLP_LO, 0.0, 0.0);
  154.             /* définit le coefficient de la variable dans l'objectif */
  155.             glp_set_obj_coef(lp, column_index, obj_coefs[column_index]);
  156.         }
  157.  
  158.         /* Chargement de la matrice */
  159.         glp_load_matrix (lp,
  160.         nbr_coefs,
  161.         row_of_coef,
  162.         column_of_coef,
  163.         matrix_coefs);
  164.  
  165.         /* Lancer la résolution du problème */
  166.         glp_simplex(lp, NULL);
  167.  
  168.  
  169.         double *solutiondual = malloc((nbrouleau+1)*sizeof(double));
  170.         solutiondual[0]=0;
  171.         for(int i=1; i<=nbrouleau; i++){
  172.             solutiondual[i] = glp_get_row_dual(lp,i);
  173.             printf("%f ||| ", solutiondual[i]);
  174.         }
  175.         /*sac a dos*/
  176.  
  177.         glp_prob *sac_a_dos;
  178.         int nbrow = 1;
  179.         int nbcol = nbrouleau;
  180.         int nbcoefs = nbrouleau;
  181.  
  182.         /* Tableau des coefficients de la matrice */
  183.         double matrix_coefs_sac[] = {0, 45, 36, 31, 14};//TODO
  184.         /* Position de chaque coefficient */
  185.    
  186.         int row_of_coef_sac[] = {0, 1, 1, 1, 1}; //TODO
  187.    
  188.         int column_of_coef_sac[] = {0, 1, 2, 3, 4}; //TODO
  189.  
  190.    
  191.         /* matrix_coef[i] est le coefficient de la matrice en ligne
  192.            row_of_coefs[i] et en colonne column_of_coefs[i].*/
  193.    
  194.         double row_bounds_sac[] = {0, 100}; //TODO Une fonction automatique.
  195.         /*obj_coef devient solutiondual*/
  196.  
  197.         /* création d'un programme linéaire sac a dos*/
  198.         sac_a_dos = glp_create_prob();
  199.         glp_set_prob_name(sac_a_dos, "sac_a_dos"); /* Nommer le problème est obligatoire */
  200.         glp_set_obj_dir(sac_a_dos, GLP_MAX); /* Détermine l'objectif MIN ou MAX */
  201.  
  202.         /* Initialisation du problème */
  203.  
  204.         /* ajoute des lignes (contraintes) */
  205.         glp_add_rows(sac_a_dos, nbrow);
  206.         for(int row_index = 1; row_index <= nbrow; row_index++) {
  207.             char constraint_name_sac[STRINGLENGTH];
  208.             sprintf(constraint_name_sac, "contrainte_sac %d", row_index);
  209.             /* nomme la contrainte */
  210.             glp_set_row_name(sac_a_dos, row_index, constraint_name_sac);
  211.             glp_set_row_bnds(sac_a_dos, row_index, GLP_FX, row_bounds_sac[row_index], row_bounds_sac[row_index]);
  212.            
  213.         }
  214.  
  215.         /* Ajoute des variables */
  216.         glp_add_cols(sac_a_dos, nbcol);
  217.         for (int column_index = 1 ; column_index <= nbcol; column_index++){
  218.             char variable_name[STRINGLENGTH];
  219.             sprintf(variable_name, "y_%d", column_index);
  220.             glp_set_col_name(lp, column_index,variable_name);
  221.             glp_set_col_bnds(sac_a_dos, column_index, GLP_LO, 0.0, 0.0);
  222.             /* définit le coefficient de la variable dans l'objectif */
  223.             glp_set_obj_coef(sac_a_dos, column_index, solutiondual[column_index]);
  224.             glp_set_col_kind(sac_a_dos, column_index, GLP_IV);
  225.         }
  226.  
  227.         /* Chargement de la matrice */
  228.         glp_load_matrix (sac_a_dos,
  229.         nbcoefs,
  230.         row_of_coef_sac,
  231.         column_of_coef_sac,
  232.         matrix_coefs_sac);
  233.  
  234.         /* Lancer la résolution du problème */
  235.         glp_simplex(sac_a_dos, NULL);
  236.         glp_intopt(sac_a_dos,NULL);
  237.    
  238.         z = glp_mip_obj_val(sac_a_dos);
  239.         printf("solution : z = %f\n",z);
  240.        
  241.         double recup[nbrouleau];
  242.         for(int i=0; i<nbrouleau; i++){
  243.             recup[i] = (double) glp_mip_col_val(sac_a_dos,i+1);
  244.             printf("%f | ",recup[i]);
  245.         }
  246.         printf("\n");
  247.        
  248.         if(z<1) {
  249.  
  250.             glp_delete_prob(lp);
  251.             glp_delete_prob(sac_a_dos);
  252.  
  253.         }
  254.        
  255.         else {       
  256.            
  257.             double *tmp_matrix = malloc((nbr_coefs + 1)*sizeof(double));;
  258.            
  259.             for(int i=0; i<nbr_coefs+1;i++)
  260.               tmp_matrix[i] = matrix_coefs[i];
  261.            
  262.            
  263.            
  264.            
  265.             matrix_coefs = realloc(matrix_coefs, ((nbr_columns+1)*nbr_rows)*sizeof(double));
  266.  
  267.  
  268.  
  269.             int k=1;
  270.             matrix_coefs[0] = 0;
  271.             for(int i=0; i<nbr_rows;i++){
  272.                 for(int j=0; j<nbr_columns; j++){
  273.                     matrix_coefs[k] = tmp_matrix[i*nbr_columns+j+1];
  274.                     if(j == nbr_columns-1){
  275.                         k++;
  276.                         matrix_coefs[k] = recup[i];
  277.                     }
  278.                     k++;
  279.                 }
  280.             }
  281.  
  282.    
  283.  
  284.            
  285.            
  286.             nbr_columns++;
  287.             nbr_coefs = nbr_rows*nbr_columns;
  288.             glp_delete_prob(lp);
  289.             glp_delete_prob(sac_a_dos);
  290.  
  291.            
  292.            
  293.         }
  294.        
  295.        
  296.        
  297.        
  298.         free(row_of_coef);
  299.         free(column_of_coef);
  300.         free(obj_coefs);
  301.         free(solutiondual);
  302.  
  303.     }
  304.     while(z>1);
  305.    
  306.     /* libération du problème */
  307.  
  308.     glp_free_env();
  309.  
  310.     return 0;
  311. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top