src/glplpx02.c
author Alpar Juttner <alpar@cs.elte.hu>
Mon, 06 Dec 2010 13:09:21 +0100
changeset 1 c445c931472f
permissions -rw-r--r--
Import glpk-4.45

- Generated files and doc/notes are removed
     1 /* glplpx02.c */
     2 
     3 /***********************************************************************
     4 *  This code is part of GLPK (GNU Linear Programming Kit).
     5 *
     6 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
     7 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,
     8 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
     9 *  E-mail: <mao@gnu.org>.
    10 *
    11 *  GLPK is free software: you can redistribute it and/or modify it
    12 *  under the terms of the GNU General Public License as published by
    13 *  the Free Software Foundation, either version 3 of the License, or
    14 *  (at your option) any later version.
    15 *
    16 *  GLPK is distributed in the hope that it will be useful, but WITHOUT
    17 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    18 *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
    19 *  License for more details.
    20 *
    21 *  You should have received a copy of the GNU General Public License
    22 *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
    23 ***********************************************************************/
    24 
    25 #include "glpapi.h"
    26 
    27 /***********************************************************************
    28 *  NAME
    29 *
    30 *  lpx_put_solution - store basic solution components
    31 *
    32 *  SYNOPSIS
    33 *
    34 *  void lpx_put_solution(glp_prob *lp, int inval, const int *p_stat,
    35 *     const int *d_stat, const double *obj_val, const int r_stat[],
    36 *     const double r_prim[], const double r_dual[], const int c_stat[],
    37 *     const double c_prim[], const double c_dual[])
    38 *
    39 *  DESCRIPTION
    40 *
    41 *  The routine lpx_put_solution stores basic solution components to the
    42 *  specified problem object.
    43 *
    44 *  The parameter inval is the basis factorization invalidity flag.
    45 *  If this flag is clear, the current status of the basis factorization
    46 *  remains unchanged. If this flag is set, the routine invalidates the
    47 *  basis factorization.
    48 *
    49 *  The parameter p_stat is a pointer to the status of primal basic
    50 *  solution, which should be specified as follows:
    51 *
    52 *  GLP_UNDEF  - primal solution is undefined;
    53 *  GLP_FEAS   - primal solution is feasible;
    54 *  GLP_INFEAS - primal solution is infeasible;
    55 *  GLP_NOFEAS - no primal feasible solution exists.
    56 *
    57 *  If the parameter p_stat is NULL, the current status of primal basic
    58 *  solution remains unchanged.
    59 *
    60 *  The parameter d_stat is a pointer to the status of dual basic
    61 *  solution, which should be specified as follows:
    62 *
    63 *  GLP_UNDEF  - dual solution is undefined;
    64 *  GLP_FEAS   - dual solution is feasible;
    65 *  GLP_INFEAS - dual solution is infeasible;
    66 *  GLP_NOFEAS - no dual feasible solution exists.
    67 *
    68 *  If the parameter d_stat is NULL, the current status of dual basic
    69 *  solution remains unchanged.
    70 *
    71 *  The parameter obj_val is a pointer to the objective function value.
    72 *  If it is NULL, the current value of the objective function remains
    73 *  unchanged.
    74 *
    75 *  The array element r_stat[i], 1 <= i <= m (where m is the number of
    76 *  rows in the problem object), specifies the status of i-th auxiliary
    77 *  variable, which should be specified as follows:
    78 *
    79 *  GLP_BS - basic variable;
    80 *  GLP_NL - non-basic variable on lower bound;
    81 *  GLP_NU - non-basic variable on upper bound;
    82 *  GLP_NF - non-basic free variable;
    83 *  GLP_NS - non-basic fixed variable.
    84 *
    85 *  If the parameter r_stat is NULL, the current statuses of auxiliary
    86 *  variables remain unchanged.
    87 *
    88 *  The array element r_prim[i], 1 <= i <= m (where m is the number of
    89 *  rows in the problem object), specifies a primal value of i-th
    90 *  auxiliary variable. If the parameter r_prim is NULL, the current
    91 *  primal values of auxiliary variables remain unchanged.
    92 *
    93 *  The array element r_dual[i], 1 <= i <= m (where m is the number of
    94 *  rows in the problem object), specifies a dual value (reduced cost)
    95 *  of i-th auxiliary variable. If the parameter r_dual is NULL, the
    96 *  current dual values of auxiliary variables remain unchanged.
    97 *
    98 *  The array element c_stat[j], 1 <= j <= n (where n is the number of
    99 *  columns in the problem object), specifies the status of j-th
   100 *  structural variable, which should be specified as follows:
   101 *
   102 *  GLP_BS - basic variable;
   103 *  GLP_NL - non-basic variable on lower bound;
   104 *  GLP_NU - non-basic variable on upper bound;
   105 *  GLP_NF - non-basic free variable;
   106 *  GLP_NS - non-basic fixed variable.
   107 *
   108 *  If the parameter c_stat is NULL, the current statuses of structural
   109 *  variables remain unchanged.
   110 *
   111 *  The array element c_prim[j], 1 <= j <= n (where n is the number of
   112 *  columns in the problem object), specifies a primal value of j-th
   113 *  structural variable. If the parameter c_prim is NULL, the current
   114 *  primal values of structural variables remain unchanged.
   115 *
   116 *  The array element c_dual[j], 1 <= j <= n (where n is the number of
   117 *  columns in the problem object), specifies a dual value (reduced cost)
   118 *  of j-th structural variable. If the parameter c_dual is NULL, the
   119 *  current dual values of structural variables remain unchanged. */
   120 
   121 void lpx_put_solution(glp_prob *lp, int inval, const int *p_stat,
   122       const int *d_stat, const double *obj_val, const int r_stat[],
   123       const double r_prim[], const double r_dual[], const int c_stat[],
   124       const double c_prim[], const double c_dual[])
   125 {     GLPROW *row;
   126       GLPCOL *col;
   127       int i, j;
   128       /* invalidate the basis factorization, if required */
   129       if (inval) lp->valid = 0;
   130       /* store primal status */
   131       if (p_stat != NULL)
   132       {  if (!(*p_stat == GLP_UNDEF  || *p_stat == GLP_FEAS ||
   133                *p_stat == GLP_INFEAS || *p_stat == GLP_NOFEAS))
   134             xerror("lpx_put_solution: p_stat = %d; invalid primal statu"
   135                "s\n", *p_stat);
   136          lp->pbs_stat = *p_stat;
   137       }
   138       /* store dual status */
   139       if (d_stat != NULL)
   140       {  if (!(*d_stat == GLP_UNDEF  || *d_stat == GLP_FEAS ||
   141                *d_stat == GLP_INFEAS || *d_stat == GLP_NOFEAS))
   142             xerror("lpx_put_solution: d_stat = %d; invalid dual status "
   143                "\n", *d_stat);
   144          lp->dbs_stat = *d_stat;
   145       }
   146       /* store objective function value */
   147       if (obj_val != NULL) lp->obj_val = *obj_val;
   148       /* store row solution components */
   149       for (i = 1; i <= lp->m; i++)
   150       {  row = lp->row[i];
   151          if (r_stat != NULL)
   152          {  if (!(r_stat[i] == GLP_BS ||
   153                   row->type == GLP_FR && r_stat[i] == GLP_NF ||
   154                   row->type == GLP_LO && r_stat[i] == GLP_NL ||
   155                   row->type == GLP_UP && r_stat[i] == GLP_NU ||
   156                   row->type == GLP_DB && r_stat[i] == GLP_NL ||
   157                   row->type == GLP_DB && r_stat[i] == GLP_NU ||
   158                   row->type == GLP_FX && r_stat[i] == GLP_NS))
   159                xerror("lpx_put_solution: r_stat[%d] = %d; invalid row s"
   160                   "tatus\n", i, r_stat[i]);
   161             row->stat = r_stat[i];
   162          }
   163          if (r_prim != NULL) row->prim = r_prim[i];
   164          if (r_dual != NULL) row->dual = r_dual[i];
   165       }
   166       /* store column solution components */
   167       for (j = 1; j <= lp->n; j++)
   168       {  col = lp->col[j];
   169          if (c_stat != NULL)
   170          {  if (!(c_stat[j] == GLP_BS ||
   171                   col->type == GLP_FR && c_stat[j] == GLP_NF ||
   172                   col->type == GLP_LO && c_stat[j] == GLP_NL ||
   173                   col->type == GLP_UP && c_stat[j] == GLP_NU ||
   174                   col->type == GLP_DB && c_stat[j] == GLP_NL ||
   175                   col->type == GLP_DB && c_stat[j] == GLP_NU ||
   176                   col->type == GLP_FX && c_stat[j] == GLP_NS))
   177                xerror("lpx_put_solution: c_stat[%d] = %d; invalid colum"
   178                   "n status\n", j, c_stat[j]);
   179             col->stat = c_stat[j];
   180          }
   181          if (c_prim != NULL) col->prim = c_prim[j];
   182          if (c_dual != NULL) col->dual = c_dual[j];
   183       }
   184       return;
   185 }
   186 
   187 /*----------------------------------------------------------------------
   188 -- lpx_put_mip_soln - store mixed integer solution components.
   189 --
   190 -- *Synopsis*
   191 --
   192 -- #include "glplpx.h"
   193 -- void lpx_put_mip_soln(glp_prob *lp, int i_stat, double row_mipx[],
   194 --    double col_mipx[]);
   195 --
   196 -- *Description*
   197 --
   198 -- The routine lpx_put_mip_soln stores solution components obtained by
   199 -- branch-and-bound solver into the specified problem object.
   200 --
   201 -- NOTE: This routine is intended for internal use only. */
   202 
   203 void lpx_put_mip_soln(glp_prob *lp, int i_stat, double row_mipx[],
   204       double col_mipx[])
   205 {     GLPROW *row;
   206       GLPCOL *col;
   207       int i, j;
   208       double sum;
   209       /* store mixed integer status */
   210 #if 0
   211       if (!(i_stat == LPX_I_UNDEF || i_stat == LPX_I_OPT ||
   212             i_stat == LPX_I_FEAS  || i_stat == LPX_I_NOFEAS))
   213          fault("lpx_put_mip_soln: i_stat = %d; invalid mixed integer st"
   214             "atus", i_stat);
   215       lp->i_stat = i_stat;
   216 #else
   217       switch (i_stat)
   218       {  case LPX_I_UNDEF:
   219             lp->mip_stat = GLP_UNDEF; break;
   220          case LPX_I_OPT:
   221             lp->mip_stat = GLP_OPT;  break;
   222          case LPX_I_FEAS:
   223             lp->mip_stat = GLP_FEAS; break;
   224          case LPX_I_NOFEAS:
   225             lp->mip_stat = GLP_NOFEAS; break;
   226          default:
   227             xerror("lpx_put_mip_soln: i_stat = %d; invalid mixed intege"
   228                "r status\n", i_stat);
   229       }
   230 #endif
   231       /* store row solution components */
   232       if (row_mipx != NULL)
   233       {  for (i = 1; i <= lp->m; i++)
   234          {  row = lp->row[i];
   235             row->mipx = row_mipx[i];
   236          }
   237       }
   238       /* store column solution components */
   239       if (col_mipx != NULL)
   240       {  for (j = 1; j <= lp->n; j++)
   241          {  col = lp->col[j];
   242             col->mipx = col_mipx[j];
   243          }
   244       }
   245       /* if the solution is claimed to be integer feasible, check it */
   246       if (lp->mip_stat == GLP_OPT || lp->mip_stat == GLP_FEAS)
   247       {  for (j = 1; j <= lp->n; j++)
   248          {  col = lp->col[j];
   249             if (col->kind == GLP_IV && col->mipx != floor(col->mipx))
   250                xerror("lpx_put_mip_soln: col_mipx[%d] = %.*g; must be i"
   251                   "ntegral\n", j, DBL_DIG, col->mipx);
   252          }
   253       }
   254       /* compute the objective function value */
   255       sum = lp->c0;
   256       for (j = 1; j <= lp->n; j++)
   257       {  col = lp->col[j];
   258          sum += col->coef * col->mipx;
   259       }
   260       lp->mip_obj = sum;
   261       return;
   262 }
   263 
   264 /* eof */