diff -r d59bea55db9b -r c445c931472f src/glplpx03.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/glplpx03.c Mon Dec 06 13:09:21 2010 +0100 @@ -0,0 +1,302 @@ +/* glplpx03.c (OPB format) */ + +/*********************************************************************** +* This code is part of GLPK (GNU Linear Programming Kit). +* +* Author: Oscar Gustafsson . +* +* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, +* 2009, 2010 Andrew Makhorin, Department for Applied Informatics, +* Moscow Aviation Institute, Moscow, Russia. All rights reserved. +* E-mail: . +* +* GLPK is free software: you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* GLPK is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public +* License for more details. +* +* You should have received a copy of the GNU General Public License +* along with GLPK. If not, see . +***********************************************************************/ + +#define _GLPSTD_ERRNO +#define _GLPSTD_STDIO +#include "glpapi.h" +#if 0 /* 24/XII-2009; by mao */ +#include "glpipp.h" +#endif + +/*---------------------------------------------------------------------- +-- lpx_write_pb - write problem data in (normalized) OPB format. +-- +-- *Synopsis* +-- +-- #include "glplpx.h" +-- int lpx_write_pb(LPX *lp, const char *fname, int normalized, +-- int binarize); +-- +-- *Description* +-- +-- The routine lpx_write_pb writes problem data in OPB format +-- to an output text file whose name is the character string fname. +-- If normalized is non-zero the output will be generated in a +-- normalized form with sequentially numbered variables, x1, x2 etc. +-- If binarize, any integer variable will be repalzec by binary ones, +-- see ipp_binarize +-- +-- *Returns* +-- +-- If the operation was successful, the routine returns zero. Otherwise +-- the routine prints an error message and returns non-zero. */ + +#if 1 /* 24/XII-2009; by mao (disabled, because IPP was removed) */ +int lpx_write_pb(LPX *lp, const char *fname, int normalized, + int binarize) +{ xassert(lp == lp); + xassert(fname == fname); + xassert(normalized == normalized); + xassert(binarize == binarize); + xprintf("lpx_write_pb: sorry, currently this operation is not ava" + "ilable\n"); + return 1; +} +#else +int lpx_write_pb(LPX *lp, const char *fname, int normalized, + int binarize) +{ + FILE* fp; + int m,n,i,j,k,o,nonfree=0, obj_dir, dbl, *ndx, row_type, emptylhs=0; + double coeff, *val, bound, constant/*=0.0*/; + char* objconstname = "dummy_one"; + char* emptylhsname = "dummy_zero"; + + /* Variables needed for possible binarization */ + /*LPX* tlp;*/ + IPP *ipp = NULL; + /*tlp=lp;*/ + + if(binarize) /* Transform integer variables to binary ones */ + { + ipp = ipp_create_wksp(); + ipp_load_orig(ipp, lp); + ipp_binarize(ipp); + lp = ipp_build_prob(ipp); + } + fp = fopen(fname, "w"); + + if(fp!= NULL) + { + xprintf( + "lpx_write_pb: writing problem in %sOPB format to `%s'...\n", + (normalized?"normalized ":""), fname); + + m = glp_get_num_rows(lp); + n = glp_get_num_cols(lp); + for(i=1;i<=m;i++) + { + switch(glp_get_row_type(lp,i)) + { + case GLP_LO: + case GLP_UP: + case GLP_FX: + { + nonfree += 1; + break; + } + case GLP_DB: + { + nonfree += 2; + break; + } + } + } + constant=glp_get_obj_coef(lp,0); + fprintf(fp,"* #variables = %d #constraints = %d\n", + n + (constant == 0?1:0), nonfree + (constant == 0?1:0)); + /* Objective function */ + obj_dir = glp_get_obj_dir(lp); + fprintf(fp,"min: "); + for(i=1;i<=n;i++) + { + coeff = glp_get_obj_coef(lp,i); + if(coeff != 0.0) + { + if(obj_dir == GLP_MAX) + coeff=-coeff; + if(normalized) + fprintf(fp, " %d x%d", (int)coeff, i); + else + fprintf(fp, " %d*%s", (int)coeff, + glp_get_col_name(lp,i)); + + } + } + if(constant) + { + if(normalized) + fprintf(fp, " %d x%d", (int)constant, n+1); + else + fprintf(fp, " %d*%s", (int)constant, objconstname); + } + fprintf(fp,";\n"); + + if(normalized && !binarize) /* Name substitution */ + { + fprintf(fp,"* Variable name substitution:\n"); + for(j=1;j<=n;j++) + { + fprintf(fp, "* x%d = %s\n", j, glp_get_col_name(lp,j)); + } + if(constant) + fprintf(fp, "* x%d = %s\n", n+1, objconstname); + } + + ndx = xcalloc(1+n, sizeof(int)); + val = xcalloc(1+n, sizeof(double)); + + /* Constraints */ + for(j=1;j<=m;j++) + { + row_type=glp_get_row_type(lp,j); + if(row_type!=GLP_FR) + { + if(row_type == GLP_DB) + { + dbl=2; + row_type = GLP_UP; + } + else + { + dbl=1; + } + k=glp_get_mat_row(lp, j, ndx, val); + for(o=1;o<=dbl;o++) + { + if(o==2) + { + row_type = GLP_LO; + } + if(k==0) /* Empty LHS */ + { + emptylhs = 1; + if(normalized) + { + fprintf(fp, "0 x%d ", n+2); + } + else + { + fprintf(fp, "0*%s ", emptylhsname); + } + } + + for(i=1;i<=k;i++) + { + if(val[i] != 0.0) + { + + if(normalized) + { + fprintf(fp, "%d x%d ", + (row_type==GLP_UP)?(-(int)val[i]):((int)val[i]), ndx[i]); + } + else + { + fprintf(fp, "%d*%s ", (int)val[i], + glp_get_col_name(lp,ndx[i])); + } + } + } + switch(row_type) + { + case GLP_LO: + { + fprintf(fp, ">="); + bound = glp_get_row_lb(lp,j); + break; + } + case GLP_UP: + { + if(normalized) + { + fprintf(fp, ">="); + bound = -glp_get_row_ub(lp,j); + } + else + { + fprintf(fp, "<="); + bound = glp_get_row_ub(lp,j); + } + + break; + } + case GLP_FX: + { + fprintf(fp, "="); + bound = glp_get_row_lb(lp,j); + break; + } + } + fprintf(fp," %d;\n",(int)bound); + } + } + } + xfree(ndx); + xfree(val); + + if(constant) + { + xprintf( + "lpx_write_pb: adding constant objective function variable\n"); + + if(normalized) + fprintf(fp, "1 x%d = 1;\n", n+1); + else + fprintf(fp, "1*%s = 1;\n", objconstname); + } + if(emptylhs) + { + xprintf( + "lpx_write_pb: adding dummy variable for empty left-hand si" + "de constraint\n"); + + if(normalized) + fprintf(fp, "1 x%d = 0;\n", n+2); + else + fprintf(fp, "1*%s = 0;\n", emptylhsname); + } + + } + else + { + xprintf("Problems opening file for writing: %s\n", fname); + return(1); + } + fflush(fp); + if (ferror(fp)) + { xprintf("lpx_write_pb: can't write to `%s' - %s\n", fname, + strerror(errno)); + goto fail; + } + fclose(fp); + + + if(binarize) + { + /* delete the resultant problem object */ + if (lp != NULL) lpx_delete_prob(lp); + /* delete MIP presolver workspace */ + if (ipp != NULL) ipp_delete_wksp(ipp); + /*lp=tlp;*/ + } + return 0; + fail: if (fp != NULL) fclose(fp); + return 1; +} +#endif + +/* eof */