/farmR/src/glpapi11.c

https://code.google.com/p/javawfm/ · C · 967 lines · 701 code · 20 blank · 246 comment · 260 complexity · c5ca2f35d221beda9e37806526fbcd07 MD5 · raw file 

    

  1. /* glpapi11.c (utility routines) */
    2. 

  2. 

  3. /***********************************************************************
    4. 

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

  5. *
    6. 

  6. *  Copyright (C) 2000,01,02,03,04,05,06,07,08,2009 Andrew Makhorin,
    7. 

  7. *  Department for Applied Informatics, Moscow Aviation Institute,
    8. 

  8. *  Moscow, Russia. All rights reserved. E-mail: <mao@mai2.rcnet.ru>.
    9. 

  9. *
    10. 

  10. *  GLPK is free software: you can redistribute it and/or modify it
    11. 

  11. *  under the terms of the GNU General Public License as published by
    12. 

  12. *  the Free Software Foundation, either version 3 of the License, or
    13. 

  13. *  (at your option) any later version.
    14. 

  14. *
    15. 

  15. *  GLPK is distributed in the hope that it will be useful, but WITHOUT
    16. 

  16. *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    17. 

  17. *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
    18. 

  18. *  License for more details.
    19. 

  19. *
    20. 

  20. *  You should have received a copy of the GNU General Public License
    21. 

  21. *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
    22. 

  22. ***********************************************************************/
    23. 

  23. 

  24. #include "glpapi.h"
    25. 

  25. #define PDS _glp_data
    26. 

  26. #define pds_open_file _glp_sds_open
    27. 

  27. #define pds_set_jump _glp_sds_jump
    28. 

  28. #define pds_error _glp_sds_error
    29. 

  29. #define pds_scan_int _glp_sds_int
    30. 

  30. #define pds_scan_num _glp_sds_num
    31. 

  31. #define pds_close_file _glp_sds_close
    32. 

  32. #undef FILE
    33. 

  33. #define FILE XFILE
    34. 

  34. #undef fopen
    35. 

  35. #define fopen xfopen
    36. 

  36. #undef strerror
    37. 

  37. #define strerror(errno) xerrmsg()
    38. 

  38. #undef fprintf
    39. 

  39. #define fprintf xfprintf
    40. 

  40. #undef fflush
    41. 

  41. #define fflush xfflush
    42. 

  42. #undef ferror
    43. 

  43. #define ferror xferror
    44. 

  44. #undef fclose
    45. 

  45. #define fclose xfclose
    46. 

  46. 

  47. int glp_print_sol(glp_prob *P, const char *fname)
    48. 

  48. {     /* write basic solution in printable format */
    49. 

  49.       XFILE *fp;
    50. 

  50.       GLPROW *row;
    51. 

  51.       GLPCOL *col;
    52. 

  52.       int i, j, t, ae_ind, re_ind, ret;
    53. 

  53.       double ae_max, re_max;
    54. 

  54.       xprintf("Writing basic solution to `%s'...\n", fname);
    55. 

  55.       fp = xfopen(fname, "w");
    56. 

  56.       if (fp == NULL)
    57. 

  57.       {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
    58. 

  58.          ret = 1;
    59. 

  59.          goto done;
    60. 

  60.       }
    61. 

  61.       xfprintf(fp, "%-12s%s\n", "Problem:",
    62. 

  62.          P->name == NULL ? "" : P->name);
    63. 

  63.       xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
    64. 

  64.       xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
    65. 

  65.       xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
    66. 

  66.       t = glp_get_status(P);
    67. 

  67.       xfprintf(fp, "%-12s%s\n", "Status:",
    68. 

  68.          t == GLP_OPT    ? "OPTIMAL" :
    69. 

  69.          t == GLP_FEAS   ? "FEASIBLE" :
    70. 

  70.          t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
    71. 

  71.          t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" :
    72. 

  72.          t == GLP_UNBND  ? "UNBOUNDED" :
    73. 

  73.          t == GLP_UNDEF  ? "UNDEFINED" : "???");
    74. 

  74.       xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
    75. 

  75.          P->obj == NULL ? "" : P->obj,
    76. 

  76.          P->obj == NULL ? "" : " = ", P->obj_val,
    77. 

  77.          P->dir == GLP_MIN ? "MINimum" :
    78. 

  78.          P->dir == GLP_MAX ? "MAXimum" : "???");
    79. 

  79.       xfprintf(fp, "\n");
    80. 

  80.       xfprintf(fp, "   No.   Row name   St   Activity     Lower bound  "
    81. 

  81.          " Upper bound    Marginal\n");
    82. 

  82.       xfprintf(fp, "------ ------------ -- ------------- ------------- "
    83. 

  83.          "------------- -------------\n");
    84. 

  84.       for (i = 1; i <= P->m; i++)
    85. 

  85.       {  row = P->row[i];
    86. 

  86.          xfprintf(fp, "%6d ", i);
    87. 

  87.          if (row->name == NULL || strlen(row->name) <= 12)
    88. 

  88.             xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
    89. 

  89.          else
    90. 

  90.             xfprintf(fp, "%s\n%20s", row->name, "");
    91. 

  91.          xfprintf(fp, "%s ",
    92. 

  92.             row->stat == GLP_BS ? "B " :
    93. 

  93.             row->stat == GLP_NL ? "NL" :
    94. 

  94.             row->stat == GLP_NU ? "NU" :
    95. 

  95.             row->stat == GLP_NF ? "NF" :
    96. 

  96.             row->stat == GLP_NS ? "NS" : "??");
    97. 

  97.          xfprintf(fp, "%13.6g ",
    98. 

  98.             fabs(row->prim) <= 1e-9 ? 0.0 : row->prim);
    99. 

  99.          if (row->type == GLP_LO || row->type == GLP_DB ||
    100. 

  100.              row->type == GLP_FX)
    101. 

  101.             xfprintf(fp, "%13.6g ", row->lb);
    102. 

  102.          else
    103. 

  103.             xfprintf(fp, "%13s ", "");
    104. 

  104.          if (row->type == GLP_UP || row->type == GLP_DB)
    105. 

  105.             xfprintf(fp, "%13.6g ", row->ub);
    106. 

  106.          else
    107. 

  107.             xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
    108. 

  108.          if (row->stat != GLP_BS)
    109. 

  109.          {  if (fabs(row->dual) <= 1e-9)
    110. 

  110.                xfprintf(fp, "%13s", "< eps");
    111. 

  111.             else
    112. 

  112.                xfprintf(fp, "%13.6g ", row->dual);
    113. 

  113.          }
    114. 

  114.          xfprintf(fp, "\n");
    115. 

  115.       }
    116. 

  116.       xfprintf(fp, "\n");
    117. 

  117.       xfprintf(fp, "   No. Column name  St   Activity     Lower bound  "
    118. 

  118.          " Upper bound    Marginal\n");
    119. 

  119.       xfprintf(fp, "------ ------------ -- ------------- ------------- "
    120. 

  120.          "------------- -------------\n");
    121. 

  121.       for (j = 1; j <= P->n; j++)
    122. 

  122.       {  col = P->col[j];
    123. 

  123.          xfprintf(fp, "%6d ", j);
    124. 

  124.          if (col->name == NULL || strlen(col->name) <= 12)
    125. 

  125.             xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
    126. 

  126.          else
    127. 

  127.             xfprintf(fp, "%s\n%20s", col->name, "");
    128. 

  128.          xfprintf(fp, "%s ",
    129. 

  129.             col->stat == GLP_BS ? "B " :
    130. 

  130.             col->stat == GLP_NL ? "NL" :
    131. 

  131.             col->stat == GLP_NU ? "NU" :
    132. 

  132.             col->stat == GLP_NF ? "NF" :
    133. 

  133.             col->stat == GLP_NS ? "NS" : "??");
    134. 

  134.          xfprintf(fp, "%13.6g ",
    135. 

  135.             fabs(col->prim) <= 1e-9 ? 0.0 : col->prim);
    136. 

  136.          if (col->type == GLP_LO || col->type == GLP_DB ||
    137. 

  137.              col->type == GLP_FX)
    138. 

  138.             xfprintf(fp, "%13.6g ", col->lb);
    139. 

  139.          else
    140. 

  140.             xfprintf(fp, "%13s ", "");
    141. 

  141.          if (col->type == GLP_UP || col->type == GLP_DB)
    142. 

  142.             xfprintf(fp, "%13.6g ", col->ub);
    143. 

  143.          else
    144. 

  144.             xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
    145. 

  145.          if (col->stat != GLP_BS)
    146. 

  146.          {  if (fabs(col->dual) <= 1e-9)
    147. 

  147.                xfprintf(fp, "%13s", "< eps");
    148. 

  148.             else
    149. 

  149.                xfprintf(fp, "%13.6g ", col->dual);
    150. 

  150.          }
    151. 

  151.          xfprintf(fp, "\n");
    152. 

  152.       }
    153. 

  153.       xfprintf(fp, "\n");
    154. 

  154.       xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
    155. 

  155.       xfprintf(fp, "\n");
    156. 

  156.       _glp_check_kkt(P, GLP_SOL, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
    157. 

  157.          &re_ind);
    158. 

  158.       xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
    159. 

  159.          ae_max, ae_ind);
    160. 

  160.       xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
    161. 

  161.          re_max, re_ind);
    162. 

  162.       xfprintf(fp, "%8s%s\n", "",
    163. 

  163.          re_max <= 1e-9 ? "High quality" :
    164. 

  164.          re_max <= 1e-6 ? "Medium quality" :
    165. 

  165.          re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
    166. 

  166.       xfprintf(fp, "\n");
    167. 

  167.       _glp_check_kkt(P, GLP_SOL, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
    168. 

  168.          &re_ind);
    169. 

  169.       xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
    170. 

  170.             ae_max, ae_ind <= P->m ? "row" : "column",
    171. 

  171.             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    172. 

  172.       xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
    173. 

  173.             re_max, re_ind <= P->m ? "row" : "column",
    174. 

  174.             re_ind <= P->m ? re_ind : re_ind - P->m);
    175. 

  175.       xfprintf(fp, "%8s%s\n", "",
    176. 

  176.          re_max <= 1e-9 ? "High quality" :
    177. 

  177.          re_max <= 1e-6 ? "Medium quality" :
    178. 

  178.          re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
    179. 

  179.             "E");
    180. 

  180.       xfprintf(fp, "\n");
    181. 

  181.       _glp_check_kkt(P, GLP_SOL, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
    182. 

  182.          &re_ind);
    183. 

  183.       xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
    184. 

  184.          ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
    185. 

  185.       xfprintf(fp, "        max.rel.err = %.2e on column %d\n",
    186. 

  186.          re_max, re_ind == 0 ? 0 : re_ind - P->m);
    187. 

  187.       xfprintf(fp, "%8s%s\n", "",
    188. 

  188.          re_max <= 1e-9 ? "High quality" :
    189. 

  189.          re_max <= 1e-6 ? "Medium quality" :
    190. 

  190.          re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
    191. 

  191.       xfprintf(fp, "\n");
    192. 

  192.       _glp_check_kkt(P, GLP_SOL, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
    193. 

  193.          &re_ind);
    194. 

  194.       xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
    195. 

  195.             ae_max, ae_ind <= P->m ? "row" : "column",
    196. 

  196.             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    197. 

  197.       xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
    198. 

  198.             re_max, re_ind <= P->m ? "row" : "column",
    199. 

  199.             re_ind <= P->m ? re_ind : re_ind - P->m);
    200. 

  200.       xfprintf(fp, "%8s%s\n", "",
    201. 

  201.          re_max <= 1e-9 ? "High quality" :
    202. 

  202.          re_max <= 1e-6 ? "Medium quality" :
    203. 

  203.          re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
    204. 

  204.             ;
    205. 

  205.       xfprintf(fp, "\n");
    206. 

  206.       xfprintf(fp, "End of output\n");
    207. 

  207.       xfflush(fp);
    208. 

  208.       if (xferror(fp))
    209. 

  209.       {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
    210. 

  210.          ret = 1;
    211. 

  211.          goto done;
    212. 

  212.       }
    213. 

  213.       ret = 0;
    214. 

  214. done: if (fp != NULL) xfclose(fp);
    215. 

  215.       return ret;
    216. 

  216. }
    217. 

  217. 

  218. /***********************************************************************
    219. 

  219. *  NAME
    220. 

  220. *
    221. 

  221. *  glp_read_sol - read basic solution from text file
    222. 

  222. *
    223. 

  223. *  SYNOPSIS
    224. 

  224. *
    225. 

  225. *  int glp_read_sol(glp_prob *lp, const char *fname);
    226. 

  226. *
    227. 

  227. *  DESCRIPTION
    228. 

  228. *
    229. 

  229. *  The routine glp_read_sol reads basic solution from a text file whose
    230. 

  230. *  name is specified by the parameter fname into the problem object.
    231. 

  231. *
    232. 

  232. *  For the file format see description of the routine glp_write_sol.
    233. 

  233. *
    234. 

  234. *  RETURNS
    235. 

  235. *
    236. 

  236. *  On success the routine returns zero, otherwise non-zero. */
    237. 

  237. 

  238. int glp_read_sol(glp_prob *lp, const char *fname)
    239. 

  239. {     PDS *pds;
    240. 

  240.       jmp_buf jump;
    241. 

  241.       int i, j, k, ret = 0;
    242. 

  242.       xprintf("Reading basic solution from `%s'...\n", fname);
    243. 

  243.       pds = pds_open_file(fname);
    244. 

  244.       if (pds == NULL)
    245. 

  245.       {  ret = 1;
    246. 

  246.          goto done;
    247. 

  247.       }
    248. 

  248.       if (setjmp(jump))
    249. 

  249.       {  ret = 1;
    250. 

  250.          goto done;
    251. 

  251.       }
    252. 

  252.       pds_set_jump(pds, jump);
    253. 

  253.       /* number of rows, number of columns */
    254. 

  254.       k = pds_scan_int(pds);
    255. 

  255.       if (k != lp->m)
    256. 

  256.          pds_error(pds, "wrong number of rows\n");
    257. 

  257.       k = pds_scan_int(pds);
    258. 

  258.       if (k != lp->n)
    259. 

  259.          pds_error(pds, "wrong number of columns\n");
    260. 

  260.       /* primal status, dual status, objective value */
    261. 

  261.       k = pds_scan_int(pds);
    262. 

  262.       if (!(k == GLP_UNDEF || k == GLP_FEAS || k == GLP_INFEAS ||
    263. 

  263.             k == GLP_NOFEAS))
    264. 

  264.          pds_error(pds, "invalid primal status\n");
    265. 

  265.       lp->pbs_stat = k;
    266. 

  266.       k = pds_scan_int(pds);
    267. 

  267.       if (!(k == GLP_UNDEF || k == GLP_FEAS || k == GLP_INFEAS ||
    268. 

  268.             k == GLP_NOFEAS))
    269. 

  269.          pds_error(pds, "invalid dual status\n");
    270. 

  270.       lp->dbs_stat = k;
    271. 

  271.       lp->obj_val = pds_scan_num(pds);
    272. 

  272.       /* rows (auxiliary variables) */
    273. 

  273.       for (i = 1; i <= lp->m; i++)
    274. 

  274.       {  GLPROW *row = lp->row[i];
    275. 

  275.          /* status, primal value, dual value */
    276. 

  276.          k = pds_scan_int(pds);
    277. 

  277.          if (!(k == GLP_BS || k == GLP_NL || k == GLP_NU ||
    278. 

  278.                k == GLP_NF || k == GLP_NS))
    279. 

  279.             pds_error(pds, "invalid row status\n");
    280. 

  280.          glp_set_row_stat(lp, i, k);
    281. 

  281.          row->prim = pds_scan_num(pds);
    282. 

  282.          row->dual = pds_scan_num(pds);
    283. 

  283.       }
    284. 

  284.       /* columns (structural variables) */
    285. 

  285.       for (j = 1; j <= lp->n; j++)
    286. 

  286.       {  GLPCOL *col = lp->col[j];
    287. 

  287.          /* status, primal value, dual value */
    288. 

  288.          k = pds_scan_int(pds);
    289. 

  289.          if (!(k == GLP_BS || k == GLP_NL || k == GLP_NU ||
    290. 

  290.                k == GLP_NF || k == GLP_NS))
    291. 

  291.             pds_error(pds, "invalid column status\n");
    292. 

  292.          glp_set_col_stat(lp, j, k);
    293. 

  293.          col->prim = pds_scan_num(pds);
    294. 

  294.          col->dual = pds_scan_num(pds);
    295. 

  295.       }
    296. 

  296.       xprintf("%d lines were read\n", _glp_sds_line(pds));
    297. 

  297. done: if (ret) lp->pbs_stat = lp->dbs_stat = GLP_UNDEF;
    298. 

  298.       if (pds != NULL) pds_close_file(pds);
    299. 

  299.       return ret;
    300. 

  300. }
    301. 

  301. 

  302. /***********************************************************************
    303. 

  303. *  NAME
    304. 

  304. *
    305. 

  305. *  glp_write_sol - write basic solution to text file
    306. 

  306. *
    307. 

  307. *  SYNOPSIS
    308. 

  308. *
    309. 

  309. *  int glp_write_sol(glp_prob *lp, const char *fname);
    310. 

  310. *
    311. 

  311. *  DESCRIPTION
    312. 

  312. *
    313. 

  313. *  The routine glp_write_sol writes the current basic solution to a
    314. 

  314. *  text file whose name is specified by the parameter fname. This file
    315. 

  315. *  can be read back with the routine glp_read_sol.
    316. 

  316. *
    317. 

  317. *  RETURNS
    318. 

  318. *
    319. 

  319. *  On success the routine returns zero, otherwise non-zero.
    320. 

  320. *
    321. 

  321. *  FILE FORMAT
    322. 

  322. *
    323. 

  323. *  The file created by the routine glp_write_sol is a plain text file,
    324. 

  324. *  which contains the following information:
    325. 

  325. *
    326. 

  326. *     m n
    327. 

  327. *     p_stat d_stat obj_val
    328. 

  328. *     r_stat[1] r_prim[1] r_dual[1]
    329. 

  329. *     . . .
    330. 

  330. *     r_stat[m] r_prim[m] r_dual[m]
    331. 

  331. *     c_stat[1] c_prim[1] c_dual[1]
    332. 

  332. *     . . .
    333. 

  333. *     c_stat[n] c_prim[n] c_dual[n]
    334. 

  334. *
    335. 

  335. *  where:
    336. 

  336. *  m is the number of rows (auxiliary variables);
    337. 

  337. *  n is the number of columns (structural variables);
    338. 

  338. *  p_stat is the primal status of the basic solution (GLP_UNDEF = 1,
    339. 

  339. *     GLP_FEAS = 2, GLP_INFEAS = 3, or GLP_NOFEAS = 4);
    340. 

  340. *  d_stat is the dual status of the basic solution (GLP_UNDEF = 1,
    341. 

  341. *     GLP_FEAS = 2, GLP_INFEAS = 3, or GLP_NOFEAS = 4);
    342. 

  342. *  obj_val is the objective value;
    343. 

  343. *  r_stat[i], i = 1,...,m, is the status of i-th row (GLP_BS = 1,
    344. 

  344. *     GLP_NL = 2, GLP_NU = 3, GLP_NF = 4, or GLP_NS = 5);
    345. 

  345. *  r_prim[i], i = 1,...,m, is the primal value of i-th row;
    346. 

  346. *  r_dual[i], i = 1,...,m, is the dual value of i-th row;
    347. 

  347. *  c_stat[j], j = 1,...,n, is the status of j-th column (GLP_BS = 1,
    348. 

  348. *     GLP_NL = 2, GLP_NU = 3, GLP_NF = 4, or GLP_NS = 5);
    349. 

  349. *  c_prim[j], j = 1,...,n, is the primal value of j-th column;
    350. 

  350. *  c_dual[j], j = 1,...,n, is the dual value of j-th column. */
    351. 

  351. 

  352. int glp_write_sol(glp_prob *lp, const char *fname)
    353. 

  353. {     FILE *fp;
    354. 

  354.       int i, j, ret = 0;
    355. 

  355.       xprintf("Writing basic solution to `%s'...\n", fname);
    356. 

  356.       fp = fopen(fname, "w");
    357. 

  357.       if (fp == NULL)
    358. 

  358.       {  xprintf("Unable to create `%s' - %s\n", fname,
    359. 

  359.             strerror(errno));
    360. 

  360.          ret = 1;
    361. 

  361.          goto done;
    362. 

  362.       }
    363. 

  363.       /* number of rows, number of columns */
    364. 

  364.       fprintf(fp, "%d %d\n", lp->m, lp->n);
    365. 

  365.       /* primal status, dual status, objective value */
    366. 

  366.       fprintf(fp, "%d %d %.*g\n", lp->pbs_stat, lp->dbs_stat, DBL_DIG,
    367. 

  367.          lp->obj_val);
    368. 

  368.       /* rows (auxiliary variables) */
    369. 

  369.       for (i = 1; i <= lp->m; i++)
    370. 

  370.       {  GLPROW *row = lp->row[i];
    371. 

  371.          /* status, primal value, dual value */
    372. 

  372.          fprintf(fp, "%d %.*g %.*g\n", row->stat, DBL_DIG, row->prim,
    373. 

  373.             DBL_DIG, row->dual);
    374. 

  374.       }
    375. 

  375.       /* columns (structural variables) */
    376. 

  376.       for (j = 1; j <= lp->n; j++)
    377. 

  377.       {  GLPCOL *col = lp->col[j];
    378. 

  378.          /* status, primal value, dual value */
    379. 

  379.          fprintf(fp, "%d %.*g %.*g\n", col->stat, DBL_DIG, col->prim,
    380. 

  380.             DBL_DIG, col->dual);
    381. 

  381.       }
    382. 

  382.       fflush(fp);
    383. 

  383.       if (ferror(fp))
    384. 

  384.       {  xprintf("Write error on `%s' - %s\n", fname, strerror(errno));
    385. 

  385.          ret = 1;
    386. 

  386.          goto done;
    387. 

  387.       }
    388. 

  388.       xprintf("%d lines were written\n", 2 + lp->m + lp->n);
    389. 

  389. done: if (fp != NULL) fclose(fp);
    390. 

  390.       return ret;
    391. 

  391. }
    392. 

  392. 

  393. /**********************************************************************/
    394. 

  394. 

  395. int glp_print_ipt(glp_prob *P, const char *fname)
    396. 

  396. {     /* write interior-point solution in printable format */
    397. 

  397.       XFILE *fp;
    398. 

  398.       GLPROW *row;
    399. 

  399.       GLPCOL *col;
    400. 

  400.       int i, j, t, ae_ind, re_ind, ret;
    401. 

  401.       double ae_max, re_max;
    402. 

  402.       xprintf("Writing interior-point solution to `%s'...\n", fname);
    403. 

  403.       fp = xfopen(fname, "w");
    404. 

  404.       if (fp == NULL)
    405. 

  405.       {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
    406. 

  406.          ret = 1;
    407. 

  407.          goto done;
    408. 

  408.       }
    409. 

  409.       xfprintf(fp, "%-12s%s\n", "Problem:",
    410. 

  410.          P->name == NULL ? "" : P->name);
    411. 

  411.       xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
    412. 

  412.       xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
    413. 

  413.       xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
    414. 

  414.       t = glp_ipt_status(P);
    415. 

  415.       xfprintf(fp, "%-12s%s\n", "Status:",
    416. 

  416.          t == GLP_OPT    ? "OPTIMAL" :
    417. 

  417.          t == GLP_UNDEF  ? "UNDEFINED" : "???");
    418. 

  418.       xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
    419. 

  419.          P->obj == NULL ? "" : P->obj,
    420. 

  420.          P->obj == NULL ? "" : " = ", P->ipt_obj,
    421. 

  421.          P->dir == GLP_MIN ? "MINimum" :
    422. 

  422.          P->dir == GLP_MAX ? "MAXimum" : "???");
    423. 

  423.       xfprintf(fp, "\n");
    424. 

  424.       xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
    425. 

  425.          " Upper bound    Marginal\n");
    426. 

  426.       xfprintf(fp, "------ ------------    ------------- ------------- "
    427. 

  427.          "------------- -------------\n");
    428. 

  428.       for (i = 1; i <= P->m; i++)
    429. 

  429.       {  row = P->row[i];
    430. 

  430.          xfprintf(fp, "%6d ", i);
    431. 

  431.          if (row->name == NULL || strlen(row->name) <= 12)
    432. 

  432.             xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
    433. 

  433.          else
    434. 

  434.             xfprintf(fp, "%s\n%20s", row->name, "");
    435. 

  435.          xfprintf(fp, "%3s", "");
    436. 

  436.          xfprintf(fp, "%13.6g ",
    437. 

  437.             fabs(row->pval) <= 1e-9 ? 0.0 : row->pval);
    438. 

  438.          if (row->type == GLP_LO || row->type == GLP_DB ||
    439. 

  439.              row->type == GLP_FX)
    440. 

  440.             xfprintf(fp, "%13.6g ", row->lb);
    441. 

  441.          else
    442. 

  442.             xfprintf(fp, "%13s ", "");
    443. 

  443.          if (row->type == GLP_UP || row->type == GLP_DB)
    444. 

  444.             xfprintf(fp, "%13.6g ", row->ub);
    445. 

  445.          else
    446. 

  446.             xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
    447. 

  447.          if (fabs(row->dval) <= 1e-9)
    448. 

  448.             xfprintf(fp, "%13s", "< eps");
    449. 

  449.          else
    450. 

  450.             xfprintf(fp, "%13.6g ", row->dval);
    451. 

  451.          xfprintf(fp, "\n");
    452. 

  452.       }
    453. 

  453.       xfprintf(fp, "\n");
    454. 

  454.       xfprintf(fp, "   No. Column name       Activity     Lower bound  "
    455. 

  455.          " Upper bound    Marginal\n");
    456. 

  456.       xfprintf(fp, "------ ------------    ------------- ------------- "
    457. 

  457.          "------------- -------------\n");
    458. 

  458.       for (j = 1; j <= P->n; j++)
    459. 

  459.       {  col = P->col[j];
    460. 

  460.          xfprintf(fp, "%6d ", j);
    461. 

  461.          if (col->name == NULL || strlen(col->name) <= 12)
    462. 

  462.             xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
    463. 

  463.          else
    464. 

  464.             xfprintf(fp, "%s\n%20s", col->name, "");
    465. 

  465.          xfprintf(fp, "%3s", "");
    466. 

  466.          xfprintf(fp, "%13.6g ",
    467. 

  467.             fabs(col->pval) <= 1e-9 ? 0.0 : col->pval);
    468. 

  468.          if (col->type == GLP_LO || col->type == GLP_DB ||
    469. 

  469.              col->type == GLP_FX)
    470. 

  470.             xfprintf(fp, "%13.6g ", col->lb);
    471. 

  471.          else
    472. 

  472.             xfprintf(fp, "%13s ", "");
    473. 

  473.          if (col->type == GLP_UP || col->type == GLP_DB)
    474. 

  474.             xfprintf(fp, "%13.6g ", col->ub);
    475. 

  475.          else
    476. 

  476.             xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
    477. 

  477.          if (fabs(col->dval) <= 1e-9)
    478. 

  478.             xfprintf(fp, "%13s", "< eps");
    479. 

  479.          else
    480. 

  480.             xfprintf(fp, "%13.6g ", col->dval);
    481. 

  481.          xfprintf(fp, "\n");
    482. 

  482.       }
    483. 

  483.       xfprintf(fp, "\n");
    484. 

  484.       xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
    485. 

  485.       xfprintf(fp, "\n");
    486. 

  486.       _glp_check_kkt(P, GLP_IPT, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
    487. 

  487.          &re_ind);
    488. 

  488.       xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
    489. 

  489.          ae_max, ae_ind);
    490. 

  490.       xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
    491. 

  491.          re_max, re_ind);
    492. 

  492.       xfprintf(fp, "%8s%s\n", "",
    493. 

  493.          re_max <= 1e-9 ? "High quality" :
    494. 

  494.          re_max <= 1e-6 ? "Medium quality" :
    495. 

  495.          re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
    496. 

  496.       xfprintf(fp, "\n");
    497. 

  497.       _glp_check_kkt(P, GLP_IPT, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
    498. 

  498.          &re_ind);
    499. 

  499.       xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
    500. 

  500.             ae_max, ae_ind <= P->m ? "row" : "column",
    501. 

  501.             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    502. 

  502.       xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
    503. 

  503.             re_max, re_ind <= P->m ? "row" : "column",
    504. 

  504.             re_ind <= P->m ? re_ind : re_ind - P->m);
    505. 

  505.       xfprintf(fp, "%8s%s\n", "",
    506. 

  506.          re_max <= 1e-9 ? "High quality" :
    507. 

  507.          re_max <= 1e-6 ? "Medium quality" :
    508. 

  508.          re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
    509. 

  509.             "E");
    510. 

  510.       xfprintf(fp, "\n");
    511. 

  511.       _glp_check_kkt(P, GLP_IPT, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
    512. 

  512.          &re_ind);
    513. 

  513.       xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
    514. 

  514.          ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
    515. 

  515.       xfprintf(fp, "        max.rel.err = %.2e on column %d\n",
    516. 

  516.          re_max, re_ind == 0 ? 0 : re_ind - P->m);
    517. 

  517.       xfprintf(fp, "%8s%s\n", "",
    518. 

  518.          re_max <= 1e-9 ? "High quality" :
    519. 

  519.          re_max <= 1e-6 ? "Medium quality" :
    520. 

  520.          re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
    521. 

  521.       xfprintf(fp, "\n");
    522. 

  522.       _glp_check_kkt(P, GLP_IPT, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
    523. 

  523.          &re_ind);
    524. 

  524.       xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
    525. 

  525.             ae_max, ae_ind <= P->m ? "row" : "column",
    526. 

  526.             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    527. 

  527.       xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
    528. 

  528.             re_max, re_ind <= P->m ? "row" : "column",
    529. 

  529.             re_ind <= P->m ? re_ind : re_ind - P->m);
    530. 

  530.       xfprintf(fp, "%8s%s\n", "",
    531. 

  531.          re_max <= 1e-9 ? "High quality" :
    532. 

  532.          re_max <= 1e-6 ? "Medium quality" :
    533. 

  533.          re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
    534. 

  534.             ;
    535. 

  535.       xfprintf(fp, "\n");
    536. 

  536.       xfprintf(fp, "End of output\n");
    537. 

  537.       xfflush(fp);
    538. 

  538.       if (xferror(fp))
    539. 

  539.       {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
    540. 

  540.          ret = 1;
    541. 

  541.          goto done;
    542. 

  542.       }
    543. 

  543.       ret = 0;
    544. 

  544. done: if (fp != NULL) xfclose(fp);
    545. 

  545.       return ret;
    546. 

  546. }
    547. 

  547. 

  548. /***********************************************************************
    549. 

  549. *  NAME
    550. 

  550. *
    551. 

  551. *  glp_read_ipt - read interior-point solution from text file
    552. 

  552. *
    553. 

  553. *  SYNOPSIS
    554. 

  554. *
    555. 

  555. *  int glp_read_ipt(glp_prob *lp, const char *fname);
    556. 

  556. *
    557. 

  557. *  DESCRIPTION
    558. 

  558. *
    559. 

  559. *  The routine glp_read_ipt reads interior-point solution from a text
    560. 

  560. *  file whose name is specified by the parameter fname into the problem
    561. 

  561. *  object.
    562. 

  562. *
    563. 

  563. *  For the file format see description of the routine glp_write_ipt.
    564. 

  564. *
    565. 

  565. *  RETURNS
    566. 

  566. *
    567. 

  567. *  On success the routine returns zero, otherwise non-zero. */
    568. 

  568. 

  569. int glp_read_ipt(glp_prob *lp, const char *fname)
    570. 

  570. {     PDS *pds;
    571. 

  571.       jmp_buf jump;
    572. 

  572.       int i, j, k, ret = 0;
    573. 

  573.       xprintf("Reading interior-point solution from `%s'...\n", fname);
    574. 

  574.       pds = pds_open_file(fname);
    575. 

  575.       if (pds == NULL)
    576. 

  576.       {  ret = 1;
    577. 

  577.          goto done;
    578. 

  578.       }
    579. 

  579.       if (setjmp(jump))
    580. 

  580.       {  ret = 1;
    581. 

  581.          goto done;
    582. 

  582.       }
    583. 

  583.       pds_set_jump(pds, jump);
    584. 

  584.       /* number of rows, number of columns */
    585. 

  585.       k = pds_scan_int(pds);
    586. 

  586.       if (k != lp->m)
    587. 

  587.          pds_error(pds, "wrong number of rows\n");
    588. 

  588.       k = pds_scan_int(pds);
    589. 

  589.       if (k != lp->n)
    590. 

  590.          pds_error(pds, "wrong number of columns\n");
    591. 

  591.       /* solution status, objective value */
    592. 

  592.       k = pds_scan_int(pds);
    593. 

  593.       if (!(k == GLP_UNDEF || k == GLP_OPT))
    594. 

  594.          pds_error(pds, "invalid solution status\n");
    595. 

  595.       lp->ipt_stat = k;
    596. 

  596.       lp->ipt_obj = pds_scan_num(pds);
    597. 

  597.       /* rows (auxiliary variables) */
    598. 

  598.       for (i = 1; i <= lp->m; i++)
    599. 

  599.       {  GLPROW *row = lp->row[i];
    600. 

  600.          /* primal value, dual value */
    601. 

  601.          row->pval = pds_scan_num(pds);
    602. 

  602.          row->dval = pds_scan_num(pds);
    603. 

  603.       }
    604. 

  604.       /* columns (structural variables) */
    605. 

  605.       for (j = 1; j <= lp->n; j++)
    606. 

  606.       {  GLPCOL *col = lp->col[j];
    607. 

  607.          /* primal value, dual value */
    608. 

  608.          col->pval = pds_scan_num(pds);
    609. 

  609.          col->dval = pds_scan_num(pds);
    610. 

  610.       }
    611. 

  611.       xprintf("%d lines were read\n", _glp_sds_line(pds));
    612. 

  612. done: if (ret) lp->ipt_stat = GLP_UNDEF;
    613. 

  613.       if (pds != NULL) pds_close_file(pds);
    614. 

  614.       return ret;
    615. 

  615. }
    616. 

  616. 

  617. /***********************************************************************
    618. 

  618. *  NAME
    619. 

  619. *
    620. 

  620. *  glp_write_ipt - write interior-point solution to text file
    621. 

  621. *
    622. 

  622. *  SYNOPSIS
    623. 

  623. *
    624. 

  624. *  int glp_write_ipt(glp_prob *lp, const char *fname);
    625. 

  625. *
    626. 

  626. *  DESCRIPTION
    627. 

  627. *
    628. 

  628. *  The routine glp_write_ipt writes the current interior-point solution
    629. 

  629. *  to a text file whose name is specified by the parameter fname. This
    630. 

  630. *  file can be read back with the routine glp_read_ipt.
    631. 

  631. *
    632. 

  632. *  RETURNS
    633. 

  633. *
    634. 

  634. *  On success the routine returns zero, otherwise non-zero.
    635. 

  635. *
    636. 

  636. *  FILE FORMAT
    637. 

  637. *
    638. 

  638. *  The file created by the routine glp_write_ipt is a plain text file,
    639. 

  639. *  which contains the following information:
    640. 

  640. *
    641. 

  641. *     m n
    642. 

  642. *     stat obj_val
    643. 

  643. *     r_prim[1] r_dual[1]
    644. 

  644. *     . . .
    645. 

  645. *     r_prim[m] r_dual[m]
    646. 

  646. *     c_prim[1] c_dual[1]
    647. 

  647. *     . . .
    648. 

  648. *     c_prim[n] c_dual[n]
    649. 

  649. *
    650. 

  650. *  where:
    651. 

  651. *  m is the number of rows (auxiliary variables);
    652. 

  652. *  n is the number of columns (structural variables);
    653. 

  653. *  stat is the solution status (GLP_UNDEF = 1 or GLP_OPT = 5);
    654. 

  654. *  obj_val is the objective value;
    655. 

  655. *  r_prim[i], i = 1,...,m, is the primal value of i-th row;
    656. 

  656. *  r_dual[i], i = 1,...,m, is the dual value of i-th row;
    657. 

  657. *  c_prim[j], j = 1,...,n, is the primal value of j-th column;
    658. 

  658. *  c_dual[j], j = 1,...,n, is the dual value of j-th column. */
    659. 

  659. 

  660. int glp_write_ipt(glp_prob *lp, const char *fname)
    661. 

  661. {     FILE *fp;
    662. 

  662.       int i, j, ret = 0;
    663. 

  663.       xprintf("Writing interior-point solution to `%s'...\n", fname);
    664. 

  664.       fp = fopen(fname, "w");
    665. 

  665.       if (fp == NULL)
    666. 

  666.       {  xprintf("Unable to create `%s' - %s\n", fname,
    667. 

  667.             strerror(errno));
    668. 

  668.          ret = 1;
    669. 

  669.          goto done;
    670. 

  670.       }
    671. 

  671.       /* number of rows, number of columns */
    672. 

  672.       fprintf(fp, "%d %d\n", lp->m, lp->n);
    673. 

  673.       /* solution status, objective value */
    674. 

  674.       fprintf(fp, "%d %.*g\n", lp->ipt_stat, DBL_DIG, lp->ipt_obj);
    675. 

  675.       /* rows (auxiliary variables) */
    676. 

  676.       for (i = 1; i <= lp->m; i++)
    677. 

  677.       {  GLPROW *row = lp->row[i];
    678. 

  678.          /* primal value, dual value */
    679. 

  679.          fprintf(fp, "%.*g %.*g\n", DBL_DIG, row->pval, DBL_DIG,
    680. 

  680.             row->dval);
    681. 

  681.       }
    682. 

  682.       /* columns (structural variables) */
    683. 

  683.       for (j = 1; j <= lp->n; j++)
    684. 

  684.       {  GLPCOL *col = lp->col[j];
    685. 

  685.          /* primal value, dual value */
    686. 

  686.          fprintf(fp, "%.*g %.*g\n", DBL_DIG, col->pval, DBL_DIG,
    687. 

  687.             col->dval);
    688. 

  688.       }
    689. 

  689.       fflush(fp);
    690. 

  690.       if (ferror(fp))
    691. 

  691.       {  xprintf("Write error on `%s' - %s\n", fname, strerror(errno));
    692. 

  692.          ret = 1;
    693. 

  693.          goto done;
    694. 

  694.       }
    695. 

  695.       xprintf("%d lines were written\n", 2 + lp->m + lp->n);
    696. 

  696. done: if (fp != NULL) fclose(fp);
    697. 

  697.       return ret;
    698. 

  698. }
    699. 

  699. 

  700. /**********************************************************************/
    701. 

  701. 

  702. int glp_print_mip(glp_prob *P, const char *fname)
    703. 

  703. {     /* write MIP solution in printable format */
    704. 

  704.       XFILE *fp;
    705. 

  705.       GLPROW *row;
    706. 

  706.       GLPCOL *col;
    707. 

  707.       int i, j, t, ae_ind, re_ind, ret;
    708. 

  708.       double ae_max, re_max;
    709. 

  709.       xprintf("Writing MIP solution to `%s'...\n", fname);
    710. 

  710.       fp = xfopen(fname, "w");
    711. 

  711.       if (fp == NULL)
    712. 

  712.       {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
    713. 

  713.          ret = 1;
    714. 

  714.          goto done;
    715. 

  715.       }
    716. 

  716.       xfprintf(fp, "%-12s%s\n", "Problem:",
    717. 

  717.          P->name == NULL ? "" : P->name);
    718. 

  718.       xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
    719. 

  719.       xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
    720. 

  720.          P->n, glp_get_num_int(P), glp_get_num_bin(P));
    721. 

  721.       xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
    722. 

  722.       t = glp_mip_status(P);
    723. 

  723.       xfprintf(fp, "%-12s%s\n", "Status:",
    724. 

  724.          t == GLP_OPT    ? "INTEGER OPTIMAL" :
    725. 

  725.          t == GLP_FEAS   ? "INTEGER NON-OPTIMAL" :
    726. 

  726.          t == GLP_NOFEAS ? "INTEGER EMPTY" :
    727. 

  727.          t == GLP_UNDEF  ? "INTEGER UNDEFINED" : "???");
    728. 

  728.       xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
    729. 

  729.          P->obj == NULL ? "" : P->obj,
    730. 

  730.          P->obj == NULL ? "" : " = ", P->mip_obj,
    731. 

  731.          P->dir == GLP_MIN ? "MINimum" :
    732. 

  732.          P->dir == GLP_MAX ? "MAXimum" : "???");
    733. 

  733.       xfprintf(fp, "\n");
    734. 

  734.       xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
    735. 

  735.          " Upper bound\n");
    736. 

  736.       xfprintf(fp, "------ ------------    ------------- ------------- "
    737. 

  737.          "-------------\n");
    738. 

  738.       for (i = 1; i <= P->m; i++)
    739. 

  739.       {  row = P->row[i];
    740. 

  740.          xfprintf(fp, "%6d ", i);
    741. 

  741.          if (row->name == NULL || strlen(row->name) <= 12)
    742. 

  742.             xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
    743. 

  743.          else
    744. 

  744.             xfprintf(fp, "%s\n%20s", row->name, "");
    745. 

  745.          xfprintf(fp, "%3s", "");
    746. 

  746.          xfprintf(fp, "%13.6g ",
    747. 

  747.             fabs(row->mipx) <= 1e-9 ? 0.0 : row->mipx);
    748. 

  748.          if (row->type == GLP_LO || row->type == GLP_DB ||
    749. 

  749.              row->type == GLP_FX)
    750. 

  750.             xfprintf(fp, "%13.6g ", row->lb);
    751. 

  751.          else
    752. 

  752.             xfprintf(fp, "%13s ", "");
    753. 

  753.          if (row->type == GLP_UP || row->type == GLP_DB)
    754. 

  754.             xfprintf(fp, "%13.6g ", row->ub);
    755. 

  755.          else
    756. 

  756.             xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
    757. 

  757.          xfprintf(fp, "\n");
    758. 

  758.       }
    759. 

  759.       xfprintf(fp, "\n");
    760. 

  760.       xfprintf(fp, "   No. Column name       Activity     Lower bound  "
    761. 

  761.          " Upper bound\n");
    762. 

  762.       xfprintf(fp, "------ ------------    ------------- ------------- "
    763. 

  763.          "-------------\n");
    764. 

  764.       for (j = 1; j <= P->n; j++)
    765. 

  765.       {  col = P->col[j];
    766. 

  766.          xfprintf(fp, "%6d ", j);
    767. 

  767.          if (col->name == NULL || strlen(col->name) <= 12)
    768. 

  768.             xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
    769. 

  769.          else
    770. 

  770.             xfprintf(fp, "%s\n%20s", col->name, "");
    771. 

  771.          xfprintf(fp, "%s  ",
    772. 

  772.             col->kind == GLP_CV ? " " :
    773. 

  773.             col->kind == GLP_IV ? "*" : "?");
    774. 

  774.          xfprintf(fp, "%13.6g ",
    775. 

  775.             fabs(col->mipx) <= 1e-9 ? 0.0 : col->mipx);
    776. 

  776.          if (col->type == GLP_LO || col->type == GLP_DB ||
    777. 

  777.              col->type == GLP_FX)
    778. 

  778.             xfprintf(fp, "%13.6g ", col->lb);
    779. 

  779.          else
    780. 

  780.             xfprintf(fp, "%13s ", "");
    781. 

  781.          if (col->type == GLP_UP || col->type == GLP_DB)
    782. 

  782.             xfprintf(fp, "%13.6g ", col->ub);
    783. 

  783.          else
    784. 

  784.             xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
    785. 

  785.          xfprintf(fp, "\n");
    786. 

  786.       }
    787. 

  787.       xfprintf(fp, "\n");
    788. 

  788.       xfprintf(fp, "Integer feasibility conditions:\n");
    789. 

  789.       xfprintf(fp, "\n");
    790. 

  790.       _glp_check_kkt(P, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
    791. 

  791.          &re_ind);
    792. 

  792.       xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
    793. 

  793.          ae_max, ae_ind);
    794. 

  794.       xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
    795. 

  795.          re_max, re_ind);
    796. 

  796.       xfprintf(fp, "%8s%s\n", "",
    797. 

  797.          re_max <= 1e-9 ? "High quality" :
    798. 

  798.          re_max <= 1e-6 ? "Medium quality" :
    799. 

  799.          re_max <= 1e-3 ? "Low quality" : "SOLUTION IS WRONG");
    800. 

  800.       xfprintf(fp, "\n");
    801. 

  801.       _glp_check_kkt(P, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
    802. 

  802.          &re_ind);
    803. 

  803.       xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
    804. 

  804.             ae_max, ae_ind <= P->m ? "row" : "column",
    805. 

  805.             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    806. 

  806.       xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
    807. 

  807.             re_max, re_ind <= P->m ? "row" : "column",
    808. 

  808.             re_ind <= P->m ? re_ind : re_ind - P->m);
    809. 

  809.       xfprintf(fp, "%8s%s\n", "",
    810. 

  810.          re_max <= 1e-9 ? "High quality" :
    811. 

  811.          re_max <= 1e-6 ? "Medium quality" :
    812. 

  812.          re_max <= 1e-3 ? "Low quality" : "SOLUTION IS INFEASIBLE");
    813. 

  813.       xfprintf(fp, "\n");
    814. 

  814.       xfprintf(fp, "End of output\n");
    815. 

  815.       xfflush(fp);
    816. 

  816.       if (xferror(fp))
    817. 

  817.       {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
    818. 

  818.          ret = 1;
    819. 

  819.          goto done;
    820. 

  820.       }
    821. 

  821.       ret = 0;
    822. 

  822. done: if (fp != NULL) xfclose(fp);
    823. 

  823.       return ret;
    824. 

  824. }
    825. 

  825. 

  826. /***********************************************************************
    827. 

  827. *  NAME
    828. 

  828. *
    829. 

  829. *  glp_read_mip - read MIP solution from text file
    830. 

  830. *
    831. 

  831. *  SYNOPSIS
    832. 

  832. *
    833. 

  833. *  int glp_read_mip(glp_prob *mip, const char *fname);
    834. 

  834. *
    835. 

  835. *  DESCRIPTION
    836. 

  836. *
    837. 

  837. *  The routine glp_read_mip reads MIP solution from a text file whose
    838. 

  838. *  name is specified by the parameter fname into the problem object.
    839. 

  839. *
    840. 

  840. *  For the file format see description of the routine glp_write_mip.
    841. 

  841. *
    842. 

  842. *  RETURNS
    843. 

  843. *
    844. 

  844. *  On success the routine returns zero, otherwise non-zero. */
    845. 

  845. 

  846. int glp_read_mip(glp_prob *mip, const char *fname)
    847. 

  847. {     PDS *pds;
    848. 

  848.       jmp_buf jump;
    849. 

  849.       int i, j, k, ret = 0;
    850. 

  850.       xprintf("Reading MIP solution from `%s'...\n", fname);
    851. 

  851.       pds = pds_open_file(fname);
    852. 

  852.       if (pds == NULL)
    853. 

  853.       {  ret = 1;
    854. 

  854.          goto done;
    855. 

  855.       }
    856. 

  856.       if (setjmp(jump))
    857. 

  857.       {  ret = 1;
    858. 

  858.          goto done;
    859. 

  859.       }
    860. 

  860.       pds_set_jump(pds, jump);
    861. 

  861.       /* number of rows, number of columns */
    862. 

  862.       k = pds_scan_int(pds);
    863. 

  863.       if (k != mip->m)
    864. 

  864.          pds_error(pds, "wrong number of rows\n");
    865. 

  865.       k = pds_scan_int(pds);
    866. 

  866.       if (k != mip->n)
    867. 

  867.          pds_error(pds, "wrong number of columns\n");
    868. 

  868.       /* solution status, objective value */
    869. 

  869.       k = pds_scan_int(pds);
    870. 

  870.       if (!(k == GLP_UNDEF || k == GLP_OPT || k == GLP_FEAS ||
    871. 

  871.             k == GLP_NOFEAS))
    872. 

  872.          pds_error(pds, "invalid solution status\n");
    873. 

  873.       mip->mip_stat = k;
    874. 

  874.       mip->mip_obj = pds_scan_num(pds);
    875. 

  875.       /* rows (auxiliary variables) */
    876. 

  876.       for (i = 1; i <= mip->m; i++)
    877. 

  877.       {  GLPROW *row = mip->row[i];
    878. 

  878.          row->mipx = pds_scan_num(pds);
    879. 

  879.       }
    880. 

  880.       /* columns (structural variables) */
    881. 

  881.       for (j = 1; j <= mip->n; j++)
    882. 

  882.       {  GLPCOL *col = mip->col[j];
    883. 

  883.          col->mipx = pds_scan_num(pds);
    884. 

  884.          if (col->kind == GLP_IV && col->mipx != floor(col->mipx))
    885. 

  885.             pds_error(pds, "non-integer column value");
    886. 

  886.       }
    887. 

  887.       xprintf("%d lines were read\n", _glp_sds_line(pds));
    888. 

  888. done: if (ret) mip->mip_stat = GLP_UNDEF;
    889. 

  889.       if (pds != NULL) pds_close_file(pds);
    890. 

  890.       return ret;
    891. 

  891. }
    892. 

  892. 

  893. /***********************************************************************
    894. 

  894. *  NAME
    895. 

  895. *
    896. 

  896. *  glp_write_mip - write MIP solution to text file
    897. 

  897. *
    898. 

  898. *  SYNOPSIS
    899. 

  899. *
    900. 

  900. *  int glp_write_mip(glp_prob *mip, const char *fname);
    901. 

  901. *
    902. 

  902. *  DESCRIPTION
    903. 

  903. *
    904. 

  904. *  The routine glp_write_mip writes the current MIP solution to a text
    905. 

  905. *  file whose name is specified by the parameter fname. This file can
    906. 

  906. *  be read back with the routine glp_read_mip.
    907. 

  907. *
    908. 

  908. *  RETURNS
    909. 

  909. *
    910. 

  910. *  On success the routine returns zero, otherwise non-zero.
    911. 

  911. *
    912. 

  912. *  FILE FORMAT
    913. 

  913. *
    914. 

  914. *  The file created by the routine glp_write_sol is a plain text file,
    915. 

  915. *  which contains the following information:
    916. 

  916. *
    917. 

  917. *     m n
    918. 

  918. *     stat obj_val
    919. 

  919. *     r_val[1]
    920. 

  920. *     . . .
    921. 

  921. *     r_val[m]
    922. 

  922. *     c_val[1]
    923. 

  923. *     . . .
    924. 

  924. *     c_val[n]
    925. 

  925. *
    926. 

  926. *  where:
    927. 

  927. *  m is the number of rows (auxiliary variables);
    928. 

  928. *  n is the number of columns (structural variables);
    929. 

  929. *  stat is the solution status (GLP_UNDEF = 1, GLP_FEAS = 2,
    930. 

  930. *     GLP_NOFEAS = 4, or GLP_OPT = 5);
    931. 

  931. *  obj_val is the objective value;
    932. 

  932. *  r_val[i], i = 1,...,m, is the value of i-th row;
    933. 

  933. *  c_val[j], j = 1,...,n, is the value of j-th column. */
    934. 

  934. 

  935. int glp_write_mip(glp_prob *mip, const char *fname)
    936. 

  936. {     FILE *fp;
    937. 

  937.       int i, j, ret = 0;
    938. 

  938.       xprintf("Writing MIP solution to `%s'...\n", fname);
    939. 

  939.       fp = fopen(fname, "w");
    940. 

  940.       if (fp == NULL)
    941. 

  941.       {  xprintf("Unable to create `%s' - %s\n", fname,
    942. 

  942.             strerror(errno));
    943. 

  943.          ret = 1;
    944. 

  944.          goto done;
    945. 

  945.       }
    946. 

  946.       /* number of rows, number of columns */
    947. 

  947.       fprintf(fp, "%d %d\n", mip->m, mip->n);
    948. 

  948.       /* solution status, objective value */
    949. 

  949.       fprintf(fp, "%d %.*g\n", mip->mip_stat, DBL_DIG, mip->mip_obj);
    950. 

  950.       /* rows (auxiliary variables) */
    951. 

  951.       for (i = 1; i <= mip->m; i++)
    952. 

  952.          fprintf(fp, "%.*g\n", DBL_DIG, mip->row[i]->mipx);
    953. 

  953.       /* columns (structural variables) */
    954. 

  954.       for (j = 1; j <= mip->n; j++)
    955. 

  955.          fprintf(fp, "%.*g\n", DBL_DIG, mip->col[j]->mipx);
    956. 

  956.       fflush(fp);
    957. 

  957.       if (ferror(fp))
    958. 

  958.       {  xprintf("Write error on `%s' - %s\n", fname, strerror(errno));
    959. 

  959.          ret = 1;
    960. 

  960.          goto done;
    961. 

  961.       }
    962. 

  962.       xprintf("%d lines were written\n", 2 + mip->m + mip->n);
    963. 

  963. done: if (fp != NULL) fclose(fp);
    964. 

  964.       return ret;
    965. 

  965. }
    966. 

  966. 

  967. /* eof */
    968.