COIN-OR::LEMON - Graph Library

source: glpk-cmake/src/glplpx03.c @ 1:c445c931472f

Last change on this file since 1:c445c931472f was 1:c445c931472f, checked in by Alpar Juttner <alpar@…>, 10 years ago

Import glpk-4.45

  • Generated files and doc/notes are removed
File size: 8.7 KB
Line 
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) */
58int 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
69int 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 */
Note: See TracBrowser for help on using the repository browser.