1 /* glplpx03.c (OPB format) */
2 
3 /***********************************************************************
4 *  This code is part of GLPK (GNU Linear Programming Kit).
5 *
6 *  Author: Oscar Gustafsson <oscarg@isy.liu.se>.
7 *
8 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
9 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,
10 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
11 *  E-mail: <mao@gnu.org>.
12 *
13 *  GLPK is free software: you can redistribute it and/or modify it
14 *  under the terms of the GNU General Public License as published by
15 *  the Free Software Foundation, either version 3 of the License, or
16 *  (at your option) any later version.
17 *
18 *  GLPK is distributed in the hope that it will be useful, but WITHOUT
19 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
20 *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
21 *  License for more details.
22 *
23 *  You should have received a copy of the GNU General Public License
24 *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
25 ***********************************************************************/
26 
27 #define _GLPSTD_ERRNO
28 #define _GLPSTD_STDIO
29 #include "glpapi.h"
30 #if 0 /* 24/XII-2009; by mao */
31 #include "glpipp.h"
32 #endif
33 
34 /*----------------------------------------------------------------------
35 -- lpx_write_pb - write problem data in (normalized) OPB format.
36 --
37 -- *Synopsis*
38 --
39 -- #include "glplpx.h"
40 -- int lpx_write_pb(LPX *lp, const char *fname, int normalized,
41 --    int binarize);
42 --
43 -- *Description*
44 --
45 -- The routine lpx_write_pb writes problem data in OPB format
46 -- to an output text file whose name is the character string fname.
47 -- If normalized is non-zero the output will be generated in a
48 -- normalized form with sequentially numbered variables, x1, x2 etc.
49 -- If binarize, any integer variable will be repalzec by binary ones,
50 -- see ipp_binarize
51 --
52 -- *Returns*
53 --
54 -- If the operation was successful, the routine returns zero. Otherwise
55 -- the routine prints an error message and returns non-zero. */
56 
57 #if 1 /* 24/XII-2009; by mao (disabled, because IPP was removed) */
lpx_write_pb(LPX * lp,const char * fname,int normalized,int binarize)58 int lpx_write_pb(LPX *lp, const char *fname, int normalized,
59       int binarize)
60 {     xassert(lp == lp);
61       xassert(fname == fname);
62       xassert(normalized == normalized);
63       xassert(binarize == binarize);
64       xprintf("lpx_write_pb: sorry, currently this operation is not ava"
65          "ilable\n");
66       return 1;
67 }
68 #else
lpx_write_pb(LPX * lp,const char * fname,int normalized,int binarize)69 int lpx_write_pb(LPX *lp, const char *fname, int normalized,
70       int binarize)
71 {
72   FILE* fp;
73   int m,n,i,j,k,o,nonfree=0, obj_dir, dbl, *ndx, row_type, emptylhs=0;
74   double coeff, *val, bound, constant/*=0.0*/;
75   char* objconstname = "dummy_one";
76   char* emptylhsname = "dummy_zero";
77 
78   /* Variables needed for possible binarization */
79   /*LPX* tlp;*/
80   IPP *ipp = NULL;
81   /*tlp=lp;*/
82 
83   if(binarize) /* Transform integer variables to binary ones */
84     {
85       ipp = ipp_create_wksp();
86       ipp_load_orig(ipp, lp);
87       ipp_binarize(ipp);
88       lp = ipp_build_prob(ipp);
89     }
90   fp = fopen(fname, "w");
91 
92   if(fp!= NULL)
93     {
94       xprintf(
95           "lpx_write_pb: writing problem in %sOPB format to `%s'...\n",
96               (normalized?"normalized ":""), fname);
97 
98       m = glp_get_num_rows(lp);
99       n = glp_get_num_cols(lp);
100       for(i=1;i<=m;i++)
101         {
102           switch(glp_get_row_type(lp,i))
103             {
104             case GLP_LO:
105             case GLP_UP:
106             case GLP_FX:
107               {
108                 nonfree += 1;
109                 break;
110               }
111             case GLP_DB:
112               {
113                 nonfree += 2;
114                 break;
115               }
116             }
117         }
118       constant=glp_get_obj_coef(lp,0);
119       fprintf(fp,"* #variables = %d #constraints = %d\n",
120          n + (constant == 0?1:0), nonfree + (constant == 0?1:0));
121       /* Objective function */
122       obj_dir = glp_get_obj_dir(lp);
123       fprintf(fp,"min: ");
124       for(i=1;i<=n;i++)
125         {
126           coeff = glp_get_obj_coef(lp,i);
127           if(coeff != 0.0)
128             {
129               if(obj_dir == GLP_MAX)
130                 coeff=-coeff;
131               if(normalized)
132                 fprintf(fp, " %d x%d", (int)coeff, i);
133               else
134                 fprintf(fp, " %d*%s", (int)coeff,
135                   glp_get_col_name(lp,i));
136 
137             }
138         }
139       if(constant)
140         {
141           if(normalized)
142             fprintf(fp, " %d x%d", (int)constant, n+1);
143           else
144             fprintf(fp, " %d*%s", (int)constant, objconstname);
145         }
146       fprintf(fp,";\n");
147 
148       if(normalized && !binarize)  /* Name substitution */
149         {
150           fprintf(fp,"* Variable name substitution:\n");
151           for(j=1;j<=n;j++)
152             {
153               fprintf(fp, "* x%d = %s\n", j, glp_get_col_name(lp,j));
154             }
155           if(constant)
156             fprintf(fp, "* x%d = %s\n", n+1, objconstname);
157         }
158 
159       ndx = xcalloc(1+n, sizeof(int));
160       val = xcalloc(1+n, sizeof(double));
161 
162       /* Constraints */
163       for(j=1;j<=m;j++)
164         {
165           row_type=glp_get_row_type(lp,j);
166           if(row_type!=GLP_FR)
167             {
168               if(row_type == GLP_DB)
169                 {
170                   dbl=2;
171                   row_type = GLP_UP;
172                 }
173               else
174                 {
175                   dbl=1;
176                 }
177               k=glp_get_mat_row(lp, j, ndx, val);
178               for(o=1;o<=dbl;o++)
179                 {
180                   if(o==2)
181                     {
182                       row_type = GLP_LO;
183                     }
184                   if(k==0) /* Empty LHS */
185                     {
186                       emptylhs = 1;
187                       if(normalized)
188                         {
189                           fprintf(fp, "0 x%d ", n+2);
190                         }
191                       else
192                         {
193                           fprintf(fp, "0*%s ", emptylhsname);
194                         }
195                     }
196 
197                   for(i=1;i<=k;i++)
198                     {
199                       if(val[i] != 0.0)
200                         {
201 
202                           if(normalized)
203                             {
204                               fprintf(fp, "%d x%d ",
205               (row_type==GLP_UP)?(-(int)val[i]):((int)val[i]), ndx[i]);
206                             }
207                           else
208                             {
209                               fprintf(fp, "%d*%s ", (int)val[i],
210                                       glp_get_col_name(lp,ndx[i]));
211                             }
212                         }
213                     }
214                   switch(row_type)
215                     {
216                     case GLP_LO:
217                       {
218                         fprintf(fp, ">=");
219                         bound = glp_get_row_lb(lp,j);
220                         break;
221                       }
222                     case GLP_UP:
223                       {
224                         if(normalized)
225                           {
226                             fprintf(fp, ">=");
227                             bound = -glp_get_row_ub(lp,j);
228                           }
229                         else
230                           {
231                             fprintf(fp, "<=");
232                             bound = glp_get_row_ub(lp,j);
233                           }
234 
235                         break;
236                       }
237                     case GLP_FX:
238                       {
239                         fprintf(fp, "=");
240                         bound = glp_get_row_lb(lp,j);
241                         break;
242                       }
243                     }
244                   fprintf(fp," %d;\n",(int)bound);
245                 }
246             }
247         }
248       xfree(ndx);
249       xfree(val);
250 
251       if(constant)
252         {
253           xprintf(
254         "lpx_write_pb: adding constant objective function variable\n");
255 
256           if(normalized)
257             fprintf(fp, "1 x%d = 1;\n", n+1);
258           else
259             fprintf(fp, "1*%s = 1;\n", objconstname);
260         }
261       if(emptylhs)
262         {
263           xprintf(
264             "lpx_write_pb: adding dummy variable for empty left-hand si"
265             "de constraint\n");
266 
267           if(normalized)
268             fprintf(fp, "1 x%d = 0;\n", n+2);
269           else
270             fprintf(fp, "1*%s = 0;\n", emptylhsname);
271         }
272 
273     }
274   else
275     {
276       xprintf("Problems opening file for writing: %s\n", fname);
277       return(1);
278     }
279   fflush(fp);
280   if (ferror(fp))
281     {  xprintf("lpx_write_pb: can't write to `%s' - %s\n", fname,
282                strerror(errno));
283     goto fail;
284     }
285   fclose(fp);
286 
287 
288   if(binarize)
289     {
290       /* delete the resultant problem object */
291       if (lp != NULL) lpx_delete_prob(lp);
292       /* delete MIP presolver workspace */
293       if (ipp != NULL) ipp_delete_wksp(ipp);
294       /*lp=tlp;*/
295     }
296   return 0;
297  fail: if (fp != NULL) fclose(fp);
298   return 1;
299 }
300 #endif
301 
302 /* eof */
303