API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 13th, 2018
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 8.62 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!