/* glplpx03.c (OPB format) */

/***********************************************************************

*  This code is part of GLPK (GNU Linear Programming Kit).

*

*  Author: Oscar Gustafsson <oscarg@isy.liu.se>.

*

*  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: <mao@gnu.org>.

*

*  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 <http://www.gnu.org/licenses/>.

***********************************************************************/

#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 */