Context Navigation

glpapi11.c @ 1:c445c931472f

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

Import glpk-4.45

Generated files and doc/notes are removed

File size: 43.5 KB

Line
1	/* glpapi11.c (utility routines) */
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	int glp_print_sol(glp_prob P, const char fname)
28	{ /* write basic solution in printable format */
29	XFILE *fp;
30	GLPROW *row;
31	GLPCOL *col;
32	int i, j, t, ae_ind, re_ind, ret;
33	double ae_max, re_max;
34	xprintf("Writing basic solution to `%s'...\n", fname);
35	fp = xfopen(fname, "w");
36	if (fp == NULL)
37	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
38	ret = 1;
39	goto done;
40	}
41	xfprintf(fp, "%-12s%s\n", "Problem:",
42	P->name == NULL ? "" : P->name);
43	xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
44	xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
45	xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
46	t = glp_get_status(P);
47	xfprintf(fp, "%-12s%s\n", "Status:",
48	t == GLP_OPT ? "OPTIMAL" :
49	t == GLP_FEAS ? "FEASIBLE" :
50	t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
51	t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" :
52	t == GLP_UNBND ? "UNBOUNDED" :
53	t == GLP_UNDEF ? "UNDEFINED" : "???");
54	xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
55	P->obj == NULL ? "" : P->obj,
56	P->obj == NULL ? "" : " = ", P->obj_val,
57	P->dir == GLP_MIN ? "MINimum" :
58	P->dir == GLP_MAX ? "MAXimum" : "???");
59	xfprintf(fp, "\n");
60	xfprintf(fp, " No. Row name St Activity Lower bound "
61	" Upper bound Marginal\n");
62	xfprintf(fp, "------ ------------ -- ------------- ------------- "
63	"------------- -------------\n");
64	for (i = 1; i <= P->m; i++)
65	{ row = P->row[i];
66	xfprintf(fp, "%6d ", i);
67	if (row->name == NULL \|\| strlen(row->name) <= 12)
68	xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
69	else
70	xfprintf(fp, "%s\n%20s", row->name, "");
71	xfprintf(fp, "%s ",
72	row->stat == GLP_BS ? "B " :
73	row->stat == GLP_NL ? "NL" :
74	row->stat == GLP_NU ? "NU" :
75	row->stat == GLP_NF ? "NF" :
76	row->stat == GLP_NS ? "NS" : "??");
77	xfprintf(fp, "%13.6g ",
78	fabs(row->prim) <= 1e-9 ? 0.0 : row->prim);
79	if (row->type == GLP_LO \|\| row->type == GLP_DB \|\|
80	row->type == GLP_FX)
81	xfprintf(fp, "%13.6g ", row->lb);
82	else
83	xfprintf(fp, "%13s ", "");
84	if (row->type == GLP_UP \|\| row->type == GLP_DB)
85	xfprintf(fp, "%13.6g ", row->ub);
86	else
87	xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
88	if (row->stat != GLP_BS)
89	{ if (fabs(row->dual) <= 1e-9)
90	xfprintf(fp, "%13s", "< eps");
91	else
92	xfprintf(fp, "%13.6g ", row->dual);
93	}
94	xfprintf(fp, "\n");
95	}
96	xfprintf(fp, "\n");
97	xfprintf(fp, " No. Column name St Activity Lower bound "
98	" Upper bound Marginal\n");
99	xfprintf(fp, "------ ------------ -- ------------- ------------- "
100	"------------- -------------\n");
101	for (j = 1; j <= P->n; j++)
102	{ col = P->col[j];
103	xfprintf(fp, "%6d ", j);
104	if (col->name == NULL \|\| strlen(col->name) <= 12)
105	xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
106	else
107	xfprintf(fp, "%s\n%20s", col->name, "");
108	xfprintf(fp, "%s ",
109	col->stat == GLP_BS ? "B " :
110	col->stat == GLP_NL ? "NL" :
111	col->stat == GLP_NU ? "NU" :
112	col->stat == GLP_NF ? "NF" :
113	col->stat == GLP_NS ? "NS" : "??");
114	xfprintf(fp, "%13.6g ",
115	fabs(col->prim) <= 1e-9 ? 0.0 : col->prim);
116	if (col->type == GLP_LO \|\| col->type == GLP_DB \|\|
117	col->type == GLP_FX)
118	xfprintf(fp, "%13.6g ", col->lb);
119	else
120	xfprintf(fp, "%13s ", "");
121	if (col->type == GLP_UP \|\| col->type == GLP_DB)
122	xfprintf(fp, "%13.6g ", col->ub);
123	else
124	xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
125	if (col->stat != GLP_BS)
126	{ if (fabs(col->dual) <= 1e-9)
127	xfprintf(fp, "%13s", "< eps");
128	else
129	xfprintf(fp, "%13.6g ", col->dual);
130	}
131	xfprintf(fp, "\n");
132	}
133	xfprintf(fp, "\n");
134	xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
135	xfprintf(fp, "\n");
136	_glp_check_kkt(P, GLP_SOL, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
137	&re_ind);
138	xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
139	ae_max, ae_ind);
140	xfprintf(fp, " max.rel.err = %.2e on row %d\n",
141	re_max, re_ind);
142	xfprintf(fp, "%8s%s\n", "",
143	re_max <= 1e-9 ? "High quality" :
144	re_max <= 1e-6 ? "Medium quality" :
145	re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
146	xfprintf(fp, "\n");
147	_glp_check_kkt(P, GLP_SOL, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
148	&re_ind);
149	xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
150	ae_max, ae_ind <= P->m ? "row" : "column",
151	ae_ind <= P->m ? ae_ind : ae_ind - P->m);
152	xfprintf(fp, " max.rel.err = %.2e on %s %d\n",
153	re_max, re_ind <= P->m ? "row" : "column",
154	re_ind <= P->m ? re_ind : re_ind - P->m);
155	xfprintf(fp, "%8s%s\n", "",
156	re_max <= 1e-9 ? "High quality" :
157	re_max <= 1e-6 ? "Medium quality" :
158	re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
159	"E");
160	xfprintf(fp, "\n");
161	_glp_check_kkt(P, GLP_SOL, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
162	&re_ind);
163	xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
164	ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
165	xfprintf(fp, " max.rel.err = %.2e on column %d\n",
166	re_max, re_ind == 0 ? 0 : re_ind - P->m);
167	xfprintf(fp, "%8s%s\n", "",
168	re_max <= 1e-9 ? "High quality" :
169	re_max <= 1e-6 ? "Medium quality" :
170	re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
171	xfprintf(fp, "\n");
172	_glp_check_kkt(P, GLP_SOL, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
173	&re_ind);
174	xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
175	ae_max, ae_ind <= P->m ? "row" : "column",
176	ae_ind <= P->m ? ae_ind : ae_ind - P->m);
177	xfprintf(fp, " max.rel.err = %.2e on %s %d\n",
178	re_max, re_ind <= P->m ? "row" : "column",
179	re_ind <= P->m ? re_ind : re_ind - P->m);
180	xfprintf(fp, "%8s%s\n", "",
181	re_max <= 1e-9 ? "High quality" :
182	re_max <= 1e-6 ? "Medium quality" :
183	re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
184	;
185	xfprintf(fp, "\n");
186	xfprintf(fp, "End of output\n");
187	xfflush(fp);
188	if (xferror(fp))
189	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
190	ret = 1;
191	goto done;
192	}
193	ret = 0;
194	done: if (fp != NULL) xfclose(fp);
195	return ret;
196	}
197
198	/***********************************************************************
199	* NAME
200	*
201	* glp_read_sol - read basic solution from text file
202	*
203	* SYNOPSIS
204	*
205	* int glp_read_sol(glp_prob lp, const char fname);
206	*
207	* DESCRIPTION
208	*
209	* The routine glp_read_sol reads basic solution from a text file whose
210	* name is specified by the parameter fname into the problem object.
211	*
212	* For the file format see description of the routine glp_write_sol.
213	*
214	* RETURNS
215	*
216	* On success the routine returns zero, otherwise non-zero. */
217
218	int glp_read_sol(glp_prob lp, const char fname)
219	{ glp_data *data;
220	jmp_buf jump;
221	int i, j, k, ret = 0;
222	xprintf("Reading basic solution from `%s'...\n", fname);
223	data = glp_sdf_open_file(fname);
224	if (data == NULL)
225	{ ret = 1;
226	goto done;
227	}
228	if (setjmp(jump))
229	{ ret = 1;
230	goto done;
231	}
232	glp_sdf_set_jump(data, jump);
233	/* number of rows, number of columns */
234	k = glp_sdf_read_int(data);
235	if (k != lp->m)
236	glp_sdf_error(data, "wrong number of rows\n");
237	k = glp_sdf_read_int(data);
238	if (k != lp->n)
239	glp_sdf_error(data, "wrong number of columns\n");
240	/* primal status, dual status, objective value */
241	k = glp_sdf_read_int(data);
242	if (!(k == GLP_UNDEF \|\| k == GLP_FEAS \|\| k == GLP_INFEAS \|\|
243	k == GLP_NOFEAS))
244	glp_sdf_error(data, "invalid primal status\n");
245	lp->pbs_stat = k;
246	k = glp_sdf_read_int(data);
247	if (!(k == GLP_UNDEF \|\| k == GLP_FEAS \|\| k == GLP_INFEAS \|\|
248	k == GLP_NOFEAS))
249	glp_sdf_error(data, "invalid dual status\n");
250	lp->dbs_stat = k;
251	lp->obj_val = glp_sdf_read_num(data);
252	/* rows (auxiliary variables) */
253	for (i = 1; i <= lp->m; i++)
254	{ GLPROW *row = lp->row[i];
255	/* status, primal value, dual value */
256	k = glp_sdf_read_int(data);
257	if (!(k == GLP_BS \|\| k == GLP_NL \|\| k == GLP_NU \|\|
258	k == GLP_NF \|\| k == GLP_NS))
259	glp_sdf_error(data, "invalid row status\n");
260	glp_set_row_stat(lp, i, k);
261	row->prim = glp_sdf_read_num(data);
262	row->dual = glp_sdf_read_num(data);
263	}
264	/* columns (structural variables) */
265	for (j = 1; j <= lp->n; j++)
266	{ GLPCOL *col = lp->col[j];
267	/* status, primal value, dual value */
268	k = glp_sdf_read_int(data);
269	if (!(k == GLP_BS \|\| k == GLP_NL \|\| k == GLP_NU \|\|
270	k == GLP_NF \|\| k == GLP_NS))
271	glp_sdf_error(data, "invalid column status\n");
272	glp_set_col_stat(lp, j, k);
273	col->prim = glp_sdf_read_num(data);
274	col->dual = glp_sdf_read_num(data);
275	}
276	xprintf("%d lines were read\n", glp_sdf_line(data));
277	done: if (ret) lp->pbs_stat = lp->dbs_stat = GLP_UNDEF;
278	if (data != NULL) glp_sdf_close_file(data);
279	return ret;
280	}
281
282	/***********************************************************************
283	* NAME
284	*
285	* glp_write_sol - write basic solution to text file
286	*
287	* SYNOPSIS
288	*
289	* int glp_write_sol(glp_prob lp, const char fname);
290	*
291	* DESCRIPTION
292	*
293	* The routine glp_write_sol writes the current basic solution to a
294	* text file whose name is specified by the parameter fname. This file
295	* can be read back with the routine glp_read_sol.
296	*
297	* RETURNS
298	*
299	* On success the routine returns zero, otherwise non-zero.
300	*
301	* FILE FORMAT
302	*
303	* The file created by the routine glp_write_sol is a plain text file,
304	* which contains the following information:
305	*
306	* m n
307	* p_stat d_stat obj_val
308	* r_stat[1] r_prim[1] r_dual[1]
309	* . . .
310	* r_stat[m] r_prim[m] r_dual[m]
311	* c_stat[1] c_prim[1] c_dual[1]
312	* . . .
313	* c_stat[n] c_prim[n] c_dual[n]
314	*
315	* where:
316	* m is the number of rows (auxiliary variables);
317	* n is the number of columns (structural variables);
318	* p_stat is the primal status of the basic solution (GLP_UNDEF = 1,
319	* GLP_FEAS = 2, GLP_INFEAS = 3, or GLP_NOFEAS = 4);
320	* d_stat is the dual status of the basic solution (GLP_UNDEF = 1,
321	* GLP_FEAS = 2, GLP_INFEAS = 3, or GLP_NOFEAS = 4);
322	* obj_val is the objective value;
323	* r_stat[i], i = 1,...,m, is the status of i-th row (GLP_BS = 1,
324	* GLP_NL = 2, GLP_NU = 3, GLP_NF = 4, or GLP_NS = 5);
325	* r_prim[i], i = 1,...,m, is the primal value of i-th row;
326	* r_dual[i], i = 1,...,m, is the dual value of i-th row;
327	* c_stat[j], j = 1,...,n, is the status of j-th column (GLP_BS = 1,
328	* GLP_NL = 2, GLP_NU = 3, GLP_NF = 4, or GLP_NS = 5);
329	* c_prim[j], j = 1,...,n, is the primal value of j-th column;
330	* c_dual[j], j = 1,...,n, is the dual value of j-th column. */
331
332	int glp_write_sol(glp_prob lp, const char fname)
333	{ XFILE *fp;
334	int i, j, ret = 0;
335	xprintf("Writing basic solution to `%s'...\n", fname);
336	fp = xfopen(fname, "w");
337	if (fp == NULL)
338	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
339	ret = 1;
340	goto done;
341	}
342	/* number of rows, number of columns */
343	xfprintf(fp, "%d %d\n", lp->m, lp->n);
344	/* primal status, dual status, objective value */
345	xfprintf(fp, "%d %d %.*g\n", lp->pbs_stat, lp->dbs_stat, DBL_DIG,
346	lp->obj_val);
347	/* rows (auxiliary variables) */
348	for (i = 1; i <= lp->m; i++)
349	{ GLPROW *row = lp->row[i];
350	/* status, primal value, dual value */
351	xfprintf(fp, "%d %.g %.g\n", row->stat, DBL_DIG, row->prim,
352	DBL_DIG, row->dual);
353	}
354	/* columns (structural variables) */
355	for (j = 1; j <= lp->n; j++)
356	{ GLPCOL *col = lp->col[j];
357	/* status, primal value, dual value */
358	xfprintf(fp, "%d %.g %.g\n", col->stat, DBL_DIG, col->prim,
359	DBL_DIG, col->dual);
360	}
361	xfflush(fp);
362	if (xferror(fp))
363	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
364	ret = 1;
365	goto done;
366	}
367	xprintf("%d lines were written\n", 2 + lp->m + lp->n);
368	done: if (fp != NULL) xfclose(fp);
369	return ret;
370	}
371
372	/**********************************************************************/
373
374	static char *format(char buf[13+1], double x)
375	{ /* format floating-point number in MPS/360-like style */
376	if (x == -DBL_MAX)
377	strcpy(buf, " -Inf");
378	else if (x == +DBL_MAX)
379	strcpy(buf, " +Inf");
380	else if (fabs(x) <= 999999.99998)
381	{ sprintf(buf, "%13.5f", x);
382	#if 1
383	if (strcmp(buf, " 0.00000") == 0 \|\|
384	strcmp(buf, " -0.00000") == 0)
385	strcpy(buf, " . ");
386	else if (memcmp(buf, " 0.", 8) == 0)
387	memcpy(buf, " .", 8);
388	else if (memcmp(buf, " -0.", 8) == 0)
389	memcpy(buf, " -.", 8);
390	#endif
391	}
392	else
393	sprintf(buf, "%13.6g", x);
394	return buf;
395	}
396
397	int glp_print_ranges(glp_prob *P, int len, const int list[],
398	int flags, const char *fname)
399	{ /* print sensitivity analysis report */
400	XFILE *fp = NULL;
401	GLPROW *row;
402	GLPCOL *col;
403	int m, n, pass, k, t, numb, type, stat, var1, var2, count, page,
404	ret;
405	double lb, ub, slack, coef, prim, dual, value1, value2, coef1,
406	coef2, obj1, obj2;
407	const char name, limit;
408	char buf[13+1];
409	/* sanity checks */
410	if (P == NULL \|\| P->magic != GLP_PROB_MAGIC)
411	xerror("glp_print_ranges: P = %p; invalid problem object\n",
412	P);
413	m = P->m, n = P->n;
414	if (len < 0)
415	xerror("glp_print_ranges: len = %d; invalid list length\n",
416	len);
417	if (len > 0)
418	{ if (list == NULL)
419	xerror("glp_print_ranges: list = %p: invalid parameter\n",
420	list);
421	for (t = 1; t <= len; t++)
422	{ k = list[t];
423	if (!(1 <= k && k <= m+n))
424	xerror("glp_print_ranges: list[%d] = %d; row/column numb"
425	"er out of range\n", t, k);
426	}
427	}
428	if (flags != 0)
429	xerror("glp_print_ranges: flags = %d; invalid parameter\n",
430	flags);
431	if (fname == NULL)
432	xerror("glp_print_ranges: fname = %p; invalid parameter\n",
433	fname);
434	if (glp_get_status(P) != GLP_OPT)
435	{ xprintf("glp_print_ranges: optimal basic solution required\n");
436	ret = 1;
437	goto done;
438	}
439	if (!glp_bf_exists(P))
440	{ xprintf("glp_print_ranges: basis factorization required\n");
441	ret = 2;
442	goto done;
443	}
444	/* start reporting */
445	xprintf("Write sensitivity analysis report to `%s'...\n", fname);
446	fp = xfopen(fname, "w");
447	if (fp == NULL)
448	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
449	ret = 3;
450	goto done;
451	}
452	page = count = 0;
453	for (pass = 1; pass <= 2; pass++)
454	for (t = 1; t <= (len == 0 ? m+n : len); t++)
455	{ if (t == 1) count = 0;
456	k = (len == 0 ? t : list[t]);
457	if (pass == 1 && k > m \|\| pass == 2 && k <= m)
458	continue;
459	if (count == 0)
460	{ xfprintf(fp, "GLPK %-4s - SENSITIVITY ANALYSIS REPORT%73sPa"
461	"ge%4d\n", glp_version(), "", ++page);
462	xfprintf(fp, "\n");
463	xfprintf(fp, "%-12s%s\n", "Problem:",
464	P->name == NULL ? "" : P->name);
465	xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
466	P->obj == NULL ? "" : P->obj,
467	P->obj == NULL ? "" : " = ", P->obj_val,
468	P->dir == GLP_MIN ? "MINimum" :
469	P->dir == GLP_MAX ? "MAXimum" : "???");
470	xfprintf(fp, "\n");
471	xfprintf(fp, "%6s %-12s %2s %13s %13s %13s %13s %13s %13s "
472	"%s\n", "No.", pass == 1 ? "Row name" : "Column name",
473	"St", "Activity", pass == 1 ? "Slack" : "Obj coef",
474	"Lower bound", "Activity", "Obj coef", "Obj value at",
475	"Limiting");
476	xfprintf(fp, "%6s %-12s %2s %13s %13s %13s %13s %13s %13s "
477	"%s\n", "", "", "", "", "Marginal", "Upper bound",
478	"range", "range", "break point", "variable");
479	xfprintf(fp, "------ ------------ -- ------------- --------"
480	"----- ------------- ------------- ------------- ------"
481	"------- ------------\n");
482	}
483	if (pass == 1)
484	{ numb = k;
485	xassert(1 <= numb && numb <= m);
486	row = P->row[numb];
487	name = row->name;
488	type = row->type;
489	lb = glp_get_row_lb(P, numb);
490	ub = glp_get_row_ub(P, numb);
491	coef = 0.0;
492	stat = row->stat;
493	prim = row->prim;
494	if (type == GLP_FR)
495	slack = - prim;
496	else if (type == GLP_LO)
497	slack = lb - prim;
498	else if (type == GLP_UP \|\| type == GLP_DB \|\| type == GLP_FX)
499	slack = ub - prim;
500	dual = row->dual;
501	}
502	else
503	{ numb = k - m;
504	xassert(1 <= numb && numb <= n);
505	col = P->col[numb];
506	name = col->name;
507	lb = glp_get_col_lb(P, numb);
508	ub = glp_get_col_ub(P, numb);
509	coef = col->coef;
510	stat = col->stat;
511	prim = col->prim;
512	slack = 0.0;
513	dual = col->dual;
514	}
515	if (stat != GLP_BS)
516	{ glp_analyze_bound(P, k, &value1, &var1, &value2, &var2);
517	if (stat == GLP_NF)
518	coef1 = coef2 = coef;
519	else if (stat == GLP_NS)
520	coef1 = -DBL_MAX, coef2 = +DBL_MAX;
521	else if (stat == GLP_NL && P->dir == GLP_MIN \|\|
522	stat == GLP_NU && P->dir == GLP_MAX)
523	coef1 = coef - dual, coef2 = +DBL_MAX;
524	else
525	coef1 = -DBL_MAX, coef2 = coef - dual;
526	if (value1 == -DBL_MAX)
527	{ if (dual < -1e-9)
528	obj1 = +DBL_MAX;
529	else if (dual > +1e-9)
530	obj1 = -DBL_MAX;
531	else
532	obj1 = P->obj_val;
533	}
534	else
535	obj1 = P->obj_val + dual * (value1 - prim);
536	if (value2 == +DBL_MAX)
537	{ if (dual < -1e-9)
538	obj2 = -DBL_MAX;
539	else if (dual > +1e-9)
540	obj2 = +DBL_MAX;
541	else
542	obj2 = P->obj_val;
543	}
544	else
545	obj2 = P->obj_val + dual * (value2 - prim);
546	}
547	else
548	{ glp_analyze_coef(P, k, &coef1, &var1, &value1, &coef2,
549	&var2, &value2);
550	if (coef1 == -DBL_MAX)
551	{ if (prim < -1e-9)
552	obj1 = +DBL_MAX;
553	else if (prim > +1e-9)
554	obj1 = -DBL_MAX;
555	else
556	obj1 = P->obj_val;
557	}
558	else
559	obj1 = P->obj_val + (coef1 - coef) * prim;
560	if (coef2 == +DBL_MAX)
561	{ if (prim < -1e-9)
562	obj2 = -DBL_MAX;
563	else if (prim > +1e-9)
564	obj2 = +DBL_MAX;
565	else
566	obj2 = P->obj_val;
567	}
568	else
569	obj2 = P->obj_val + (coef2 - coef) * prim;
570	}
571	/* first line */
572	/* row/column number */
573	xfprintf(fp, "%6d", numb);
574	/* row/column name */
575	xfprintf(fp, " %-12.12s", name == NULL ? "" : name);
576	if (name != NULL && strlen(name) > 12)
577	xfprintf(fp, "%s\n%6s %12s", name+12, "", "");
578	/* row/column status */
579	xfprintf(fp, " %2s",
580	stat == GLP_BS ? "BS" : stat == GLP_NL ? "NL" :
581	stat == GLP_NU ? "NU" : stat == GLP_NF ? "NF" :
582	stat == GLP_NS ? "NS" : "??");
583	/* row/column activity */
584	xfprintf(fp, " %s", format(buf, prim));
585	/* row slack, column objective coefficient */
586	xfprintf(fp, " %s", format(buf, k <= m ? slack : coef));
587	/* row/column lower bound */
588	xfprintf(fp, " %s", format(buf, lb));
589	/* row/column activity range */
590	xfprintf(fp, " %s", format(buf, value1));
591	/* row/column objective coefficient range */
592	xfprintf(fp, " %s", format(buf, coef1));
593	/* objective value at break point */
594	xfprintf(fp, " %s", format(buf, obj1));
595	/* limiting variable name */
596	if (var1 != 0)
597	{ if (var1 <= m)
598	limit = glp_get_row_name(P, var1);
599	else
600	limit = glp_get_col_name(P, var1 - m);
601	if (limit != NULL)
602	xfprintf(fp, " %s", limit);
603	}
604	xfprintf(fp, "\n");
605	/* second line */
606	xfprintf(fp, "%6s %-12s %2s %13s", "", "", "", "");
607	/* row/column reduced cost */
608	xfprintf(fp, " %s", format(buf, dual));
609	/* row/column upper bound */
610	xfprintf(fp, " %s", format(buf, ub));
611	/* row/column activity range */
612	xfprintf(fp, " %s", format(buf, value2));
613	/* row/column objective coefficient range */
614	xfprintf(fp, " %s", format(buf, coef2));
615	/* objective value at break point */
616	xfprintf(fp, " %s", format(buf, obj2));
617	/* limiting variable name */
618	if (var2 != 0)
619	{ if (var2 <= m)
620	limit = glp_get_row_name(P, var2);
621	else
622	limit = glp_get_col_name(P, var2 - m);
623	if (limit != NULL)
624	xfprintf(fp, " %s", limit);
625	}
626	xfprintf(fp, "\n");
627	xfprintf(fp, "\n");
628	/* print 10 items per page */
629	count = (count + 1) % 10;
630	}
631	xfprintf(fp, "End of report\n");
632	xfflush(fp);
633	if (xferror(fp))
634	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
635	ret = 4;
636	goto done;
637	}
638	ret = 0;
639	done: if (fp != NULL) xfclose(fp);
640	return ret;
641	}
642
643	/**********************************************************************/
644
645	int glp_print_ipt(glp_prob P, const char fname)
646	{ /* write interior-point solution in printable format */
647	XFILE *fp;
648	GLPROW *row;
649	GLPCOL *col;
650	int i, j, t, ae_ind, re_ind, ret;
651	double ae_max, re_max;
652	xprintf("Writing interior-point solution to `%s'...\n", fname);
653	fp = xfopen(fname, "w");
654	if (fp == NULL)
655	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
656	ret = 1;
657	goto done;
658	}
659	xfprintf(fp, "%-12s%s\n", "Problem:",
660	P->name == NULL ? "" : P->name);
661	xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
662	xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
663	xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
664	t = glp_ipt_status(P);
665	xfprintf(fp, "%-12s%s\n", "Status:",
666	t == GLP_OPT ? "OPTIMAL" :
667	t == GLP_UNDEF ? "UNDEFINED" :
668	t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
669	t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" : "???");
670	xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
671	P->obj == NULL ? "" : P->obj,
672	P->obj == NULL ? "" : " = ", P->ipt_obj,
673	P->dir == GLP_MIN ? "MINimum" :
674	P->dir == GLP_MAX ? "MAXimum" : "???");
675	xfprintf(fp, "\n");
676	xfprintf(fp, " No. Row name Activity Lower bound "
677	" Upper bound Marginal\n");
678	xfprintf(fp, "------ ------------ ------------- ------------- "
679	"------------- -------------\n");
680	for (i = 1; i <= P->m; i++)
681	{ row = P->row[i];
682	xfprintf(fp, "%6d ", i);
683	if (row->name == NULL \|\| strlen(row->name) <= 12)
684	xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
685	else
686	xfprintf(fp, "%s\n%20s", row->name, "");
687	xfprintf(fp, "%3s", "");
688	xfprintf(fp, "%13.6g ",
689	fabs(row->pval) <= 1e-9 ? 0.0 : row->pval);
690	if (row->type == GLP_LO \|\| row->type == GLP_DB \|\|
691	row->type == GLP_FX)
692	xfprintf(fp, "%13.6g ", row->lb);
693	else
694	xfprintf(fp, "%13s ", "");
695	if (row->type == GLP_UP \|\| row->type == GLP_DB)
696	xfprintf(fp, "%13.6g ", row->ub);
697	else
698	xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
699	if (fabs(row->dval) <= 1e-9)
700	xfprintf(fp, "%13s", "< eps");
701	else
702	xfprintf(fp, "%13.6g ", row->dval);
703	xfprintf(fp, "\n");
704	}
705	xfprintf(fp, "\n");
706	xfprintf(fp, " No. Column name Activity Lower bound "
707	" Upper bound Marginal\n");
708	xfprintf(fp, "------ ------------ ------------- ------------- "
709	"------------- -------------\n");
710	for (j = 1; j <= P->n; j++)
711	{ col = P->col[j];
712	xfprintf(fp, "%6d ", j);
713	if (col->name == NULL \|\| strlen(col->name) <= 12)
714	xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
715	else
716	xfprintf(fp, "%s\n%20s", col->name, "");
717	xfprintf(fp, "%3s", "");
718	xfprintf(fp, "%13.6g ",
719	fabs(col->pval) <= 1e-9 ? 0.0 : col->pval);
720	if (col->type == GLP_LO \|\| col->type == GLP_DB \|\|
721	col->type == GLP_FX)
722	xfprintf(fp, "%13.6g ", col->lb);
723	else
724	xfprintf(fp, "%13s ", "");
725	if (col->type == GLP_UP \|\| col->type == GLP_DB)
726	xfprintf(fp, "%13.6g ", col->ub);
727	else
728	xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
729	if (fabs(col->dval) <= 1e-9)
730	xfprintf(fp, "%13s", "< eps");
731	else
732	xfprintf(fp, "%13.6g ", col->dval);
733	xfprintf(fp, "\n");
734	}
735	xfprintf(fp, "\n");
736	xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
737	xfprintf(fp, "\n");
738	_glp_check_kkt(P, GLP_IPT, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
739	&re_ind);
740	xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
741	ae_max, ae_ind);
742	xfprintf(fp, " max.rel.err = %.2e on row %d\n",
743	re_max, re_ind);
744	xfprintf(fp, "%8s%s\n", "",
745	re_max <= 1e-9 ? "High quality" :
746	re_max <= 1e-6 ? "Medium quality" :
747	re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
748	xfprintf(fp, "\n");
749	_glp_check_kkt(P, GLP_IPT, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
750	&re_ind);
751	xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
752	ae_max, ae_ind <= P->m ? "row" : "column",
753	ae_ind <= P->m ? ae_ind : ae_ind - P->m);
754	xfprintf(fp, " max.rel.err = %.2e on %s %d\n",
755	re_max, re_ind <= P->m ? "row" : "column",
756	re_ind <= P->m ? re_ind : re_ind - P->m);
757	xfprintf(fp, "%8s%s\n", "",
758	re_max <= 1e-9 ? "High quality" :
759	re_max <= 1e-6 ? "Medium quality" :
760	re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
761	"E");
762	xfprintf(fp, "\n");
763	_glp_check_kkt(P, GLP_IPT, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
764	&re_ind);
765	xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
766	ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
767	xfprintf(fp, " max.rel.err = %.2e on column %d\n",
768	re_max, re_ind == 0 ? 0 : re_ind - P->m);
769	xfprintf(fp, "%8s%s\n", "",
770	re_max <= 1e-9 ? "High quality" :
771	re_max <= 1e-6 ? "Medium quality" :
772	re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
773	xfprintf(fp, "\n");
774	_glp_check_kkt(P, GLP_IPT, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
775	&re_ind);
776	xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
777	ae_max, ae_ind <= P->m ? "row" : "column",
778	ae_ind <= P->m ? ae_ind : ae_ind - P->m);
779	xfprintf(fp, " max.rel.err = %.2e on %s %d\n",
780	re_max, re_ind <= P->m ? "row" : "column",
781	re_ind <= P->m ? re_ind : re_ind - P->m);
782	xfprintf(fp, "%8s%s\n", "",
783	re_max <= 1e-9 ? "High quality" :
784	re_max <= 1e-6 ? "Medium quality" :
785	re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
786	;
787	xfprintf(fp, "\n");
788	xfprintf(fp, "End of output\n");
789	xfflush(fp);
790	if (xferror(fp))
791	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
792	ret = 1;
793	goto done;
794	}
795	ret = 0;
796	done: if (fp != NULL) xfclose(fp);
797	return ret;
798	}
799
800	/***********************************************************************
801	* NAME
802	*
803	* glp_read_ipt - read interior-point solution from text file
804	*
805	* SYNOPSIS
806	*
807	* int glp_read_ipt(glp_prob lp, const char fname);
808	*
809	* DESCRIPTION
810	*
811	* The routine glp_read_ipt reads interior-point solution from a text
812	* file whose name is specified by the parameter fname into the problem
813	* object.
814	*
815	* For the file format see description of the routine glp_write_ipt.
816	*
817	* RETURNS
818	*
819	* On success the routine returns zero, otherwise non-zero. */
820
821	int glp_read_ipt(glp_prob lp, const char fname)
822	{ glp_data *data;
823	jmp_buf jump;
824	int i, j, k, ret = 0;
825	xprintf("Reading interior-point solution from `%s'...\n", fname);
826	data = glp_sdf_open_file(fname);
827	if (data == NULL)
828	{ ret = 1;
829	goto done;
830	}
831	if (setjmp(jump))
832	{ ret = 1;
833	goto done;
834	}
835	glp_sdf_set_jump(data, jump);
836	/* number of rows, number of columns */
837	k = glp_sdf_read_int(data);
838	if (k != lp->m)
839	glp_sdf_error(data, "wrong number of rows\n");
840	k = glp_sdf_read_int(data);
841	if (k != lp->n)
842	glp_sdf_error(data, "wrong number of columns\n");
843	/* solution status, objective value */
844	k = glp_sdf_read_int(data);
845	if (!(k == GLP_UNDEF \|\| k == GLP_OPT))
846	glp_sdf_error(data, "invalid solution status\n");
847	lp->ipt_stat = k;
848	lp->ipt_obj = glp_sdf_read_num(data);
849	/* rows (auxiliary variables) */
850	for (i = 1; i <= lp->m; i++)
851	{ GLPROW *row = lp->row[i];
852	/* primal value, dual value */
853	row->pval = glp_sdf_read_num(data);
854	row->dval = glp_sdf_read_num(data);
855	}
856	/* columns (structural variables) */
857	for (j = 1; j <= lp->n; j++)
858	{ GLPCOL *col = lp->col[j];
859	/* primal value, dual value */
860	col->pval = glp_sdf_read_num(data);
861	col->dval = glp_sdf_read_num(data);
862	}
863	xprintf("%d lines were read\n", glp_sdf_line(data));
864	done: if (ret) lp->ipt_stat = GLP_UNDEF;
865	if (data != NULL) glp_sdf_close_file(data);
866	return ret;
867	}
868
869	/***********************************************************************
870	* NAME
871	*
872	* glp_write_ipt - write interior-point solution to text file
873	*
874	* SYNOPSIS
875	*
876	* int glp_write_ipt(glp_prob lp, const char fname);
877	*
878	* DESCRIPTION
879	*
880	* The routine glp_write_ipt writes the current interior-point solution
881	* to a text file whose name is specified by the parameter fname. This
882	* file can be read back with the routine glp_read_ipt.
883	*
884	* RETURNS
885	*
886	* On success the routine returns zero, otherwise non-zero.
887	*
888	* FILE FORMAT
889	*
890	* The file created by the routine glp_write_ipt is a plain text file,
891	* which contains the following information:
892	*
893	* m n
894	* stat obj_val
895	* r_prim[1] r_dual[1]
896	* . . .
897	* r_prim[m] r_dual[m]
898	* c_prim[1] c_dual[1]
899	* . . .
900	* c_prim[n] c_dual[n]
901	*
902	* where:
903	* m is the number of rows (auxiliary variables);
904	* n is the number of columns (structural variables);
905	* stat is the solution status (GLP_UNDEF = 1 or GLP_OPT = 5);
906	* obj_val is the objective value;
907	* r_prim[i], i = 1,...,m, is the primal value of i-th row;
908	* r_dual[i], i = 1,...,m, is the dual value of i-th row;
909	* c_prim[j], j = 1,...,n, is the primal value of j-th column;
910	* c_dual[j], j = 1,...,n, is the dual value of j-th column. */
911
912	int glp_write_ipt(glp_prob lp, const char fname)
913	{ XFILE *fp;
914	int i, j, ret = 0;
915	xprintf("Writing interior-point solution to `%s'...\n", fname);
916	fp = xfopen(fname, "w");
917	if (fp == NULL)
918	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
919	ret = 1;
920	goto done;
921	}
922	/* number of rows, number of columns */
923	xfprintf(fp, "%d %d\n", lp->m, lp->n);
924	/* solution status, objective value */
925	xfprintf(fp, "%d %.*g\n", lp->ipt_stat, DBL_DIG, lp->ipt_obj);
926	/* rows (auxiliary variables) */
927	for (i = 1; i <= lp->m; i++)
928	{ GLPROW *row = lp->row[i];
929	/* primal value, dual value */
930	xfprintf(fp, "%.g %.g\n", DBL_DIG, row->pval, DBL_DIG,
931	row->dval);
932	}
933	/* columns (structural variables) */
934	for (j = 1; j <= lp->n; j++)
935	{ GLPCOL *col = lp->col[j];
936	/* primal value, dual value */
937	xfprintf(fp, "%.g %.g\n", DBL_DIG, col->pval, DBL_DIG,
938	col->dval);
939	}
940	xfflush(fp);
941	if (xferror(fp))
942	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
943	ret = 1;
944	goto done;
945	}
946	xprintf("%d lines were written\n", 2 + lp->m + lp->n);
947	done: if (fp != NULL) xfclose(fp);
948	return ret;
949	}
950
951	/**********************************************************************/
952
953	int glp_print_mip(glp_prob P, const char fname)
954	{ /* write MIP solution in printable format */
955	XFILE *fp;
956	GLPROW *row;
957	GLPCOL *col;
958	int i, j, t, ae_ind, re_ind, ret;
959	double ae_max, re_max;
960	xprintf("Writing MIP solution to `%s'...\n", fname);
961	fp = xfopen(fname, "w");
962	if (fp == NULL)
963	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
964	ret = 1;
965	goto done;
966	}
967	xfprintf(fp, "%-12s%s\n", "Problem:",
968	P->name == NULL ? "" : P->name);
969	xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
970	xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
971	P->n, glp_get_num_int(P), glp_get_num_bin(P));
972	xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
973	t = glp_mip_status(P);
974	xfprintf(fp, "%-12s%s\n", "Status:",
975	t == GLP_OPT ? "INTEGER OPTIMAL" :
976	t == GLP_FEAS ? "INTEGER NON-OPTIMAL" :
977	t == GLP_NOFEAS ? "INTEGER EMPTY" :
978	t == GLP_UNDEF ? "INTEGER UNDEFINED" : "???");
979	xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
980	P->obj == NULL ? "" : P->obj,
981	P->obj == NULL ? "" : " = ", P->mip_obj,
982	P->dir == GLP_MIN ? "MINimum" :
983	P->dir == GLP_MAX ? "MAXimum" : "???");
984	xfprintf(fp, "\n");
985	xfprintf(fp, " No. Row name Activity Lower bound "
986	" Upper bound\n");
987	xfprintf(fp, "------ ------------ ------------- ------------- "
988	"-------------\n");
989	for (i = 1; i <= P->m; i++)
990	{ row = P->row[i];
991	xfprintf(fp, "%6d ", i);
992	if (row->name == NULL \|\| strlen(row->name) <= 12)
993	xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
994	else
995	xfprintf(fp, "%s\n%20s", row->name, "");
996	xfprintf(fp, "%3s", "");
997	xfprintf(fp, "%13.6g ",
998	fabs(row->mipx) <= 1e-9 ? 0.0 : row->mipx);
999	if (row->type == GLP_LO \|\| row->type == GLP_DB \|\|
1000	row->type == GLP_FX)
1001	xfprintf(fp, "%13.6g ", row->lb);
1002	else
1003	xfprintf(fp, "%13s ", "");
1004	if (row->type == GLP_UP \|\| row->type == GLP_DB)
1005	xfprintf(fp, "%13.6g ", row->ub);
1006	else
1007	xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
1008	xfprintf(fp, "\n");
1009	}
1010	xfprintf(fp, "\n");
1011	xfprintf(fp, " No. Column name Activity Lower bound "
1012	" Upper bound\n");
1013	xfprintf(fp, "------ ------------ ------------- ------------- "
1014	"-------------\n");
1015	for (j = 1; j <= P->n; j++)
1016	{ col = P->col[j];
1017	xfprintf(fp, "%6d ", j);
1018	if (col->name == NULL \|\| strlen(col->name) <= 12)
1019	xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
1020	else
1021	xfprintf(fp, "%s\n%20s", col->name, "");
1022	xfprintf(fp, "%s ",
1023	col->kind == GLP_CV ? " " :
1024	col->kind == GLP_IV ? "*" : "?");
1025	xfprintf(fp, "%13.6g ",
1026	fabs(col->mipx) <= 1e-9 ? 0.0 : col->mipx);
1027	if (col->type == GLP_LO \|\| col->type == GLP_DB \|\|
1028	col->type == GLP_FX)
1029	xfprintf(fp, "%13.6g ", col->lb);
1030	else
1031	xfprintf(fp, "%13s ", "");
1032	if (col->type == GLP_UP \|\| col->type == GLP_DB)
1033	xfprintf(fp, "%13.6g ", col->ub);
1034	else
1035	xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
1036	xfprintf(fp, "\n");
1037	}
1038	xfprintf(fp, "\n");
1039	xfprintf(fp, "Integer feasibility conditions:\n");
1040	xfprintf(fp, "\n");
1041	_glp_check_kkt(P, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
1042	&re_ind);
1043	xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
1044	ae_max, ae_ind);
1045	xfprintf(fp, " max.rel.err = %.2e on row %d\n",
1046	re_max, re_ind);
1047	xfprintf(fp, "%8s%s\n", "",
1048	re_max <= 1e-9 ? "High quality" :
1049	re_max <= 1e-6 ? "Medium quality" :
1050	re_max <= 1e-3 ? "Low quality" : "SOLUTION IS WRONG");
1051	xfprintf(fp, "\n");
1052	_glp_check_kkt(P, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
1053	&re_ind);
1054	xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
1055	ae_max, ae_ind <= P->m ? "row" : "column",
1056	ae_ind <= P->m ? ae_ind : ae_ind - P->m);
1057	xfprintf(fp, " max.rel.err = %.2e on %s %d\n",
1058	re_max, re_ind <= P->m ? "row" : "column",
1059	re_ind <= P->m ? re_ind : re_ind - P->m);
1060	xfprintf(fp, "%8s%s\n", "",
1061	re_max <= 1e-9 ? "High quality" :
1062	re_max <= 1e-6 ? "Medium quality" :
1063	re_max <= 1e-3 ? "Low quality" : "SOLUTION IS INFEASIBLE");
1064	xfprintf(fp, "\n");
1065	xfprintf(fp, "End of output\n");
1066	xfflush(fp);
1067	if (xferror(fp))
1068	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
1069	ret = 1;
1070	goto done;
1071	}
1072	ret = 0;
1073	done: if (fp != NULL) xfclose(fp);
1074	return ret;
1075	}
1076
1077	/***********************************************************************
1078	* NAME
1079	*
1080	* glp_read_mip - read MIP solution from text file
1081	*
1082	* SYNOPSIS
1083	*
1084	* int glp_read_mip(glp_prob mip, const char fname);
1085	*
1086	* DESCRIPTION
1087	*
1088	* The routine glp_read_mip reads MIP solution from a text file whose
1089	* name is specified by the parameter fname into the problem object.
1090	*
1091	* For the file format see description of the routine glp_write_mip.
1092	*
1093	* RETURNS
1094	*
1095	* On success the routine returns zero, otherwise non-zero. */
1096
1097	int glp_read_mip(glp_prob mip, const char fname)
1098	{ glp_data *data;
1099	jmp_buf jump;
1100	int i, j, k, ret = 0;
1101	xprintf("Reading MIP solution from `%s'...\n", fname);
1102	data = glp_sdf_open_file(fname);
1103	if (data == NULL)
1104	{ ret = 1;
1105	goto done;
1106	}
1107	if (setjmp(jump))
1108	{ ret = 1;
1109	goto done;
1110	}
1111	glp_sdf_set_jump(data, jump);
1112	/* number of rows, number of columns */
1113	k = glp_sdf_read_int(data);
1114	if (k != mip->m)
1115	glp_sdf_error(data, "wrong number of rows\n");
1116	k = glp_sdf_read_int(data);
1117	if (k != mip->n)
1118	glp_sdf_error(data, "wrong number of columns\n");
1119	/* solution status, objective value */
1120	k = glp_sdf_read_int(data);
1121	if (!(k == GLP_UNDEF \|\| k == GLP_OPT \|\| k == GLP_FEAS \|\|
1122	k == GLP_NOFEAS))
1123	glp_sdf_error(data, "invalid solution status\n");
1124	mip->mip_stat = k;
1125	mip->mip_obj = glp_sdf_read_num(data);
1126	/* rows (auxiliary variables) */
1127	for (i = 1; i <= mip->m; i++)
1128	{ GLPROW *row = mip->row[i];
1129	row->mipx = glp_sdf_read_num(data);
1130	}
1131	/* columns (structural variables) */
1132	for (j = 1; j <= mip->n; j++)
1133	{ GLPCOL *col = mip->col[j];
1134	col->mipx = glp_sdf_read_num(data);
1135	if (col->kind == GLP_IV && col->mipx != floor(col->mipx))
1136	glp_sdf_error(data, "non-integer column value");
1137	}
1138	xprintf("%d lines were read\n", glp_sdf_line(data));
1139	done: if (ret) mip->mip_stat = GLP_UNDEF;
1140	if (data != NULL) glp_sdf_close_file(data);
1141	return ret;
1142	}
1143
1144	/***********************************************************************
1145	* NAME
1146	*
1147	* glp_write_mip - write MIP solution to text file
1148	*
1149	* SYNOPSIS
1150	*
1151	* int glp_write_mip(glp_prob mip, const char fname);
1152	*
1153	* DESCRIPTION
1154	*
1155	* The routine glp_write_mip writes the current MIP solution to a text
1156	* file whose name is specified by the parameter fname. This file can
1157	* be read back with the routine glp_read_mip.
1158	*
1159	* RETURNS
1160	*
1161	* On success the routine returns zero, otherwise non-zero.
1162	*
1163	* FILE FORMAT
1164	*
1165	* The file created by the routine glp_write_sol is a plain text file,
1166	* which contains the following information:
1167	*
1168	* m n
1169	* stat obj_val
1170	* r_val[1]
1171	* . . .
1172	* r_val[m]
1173	* c_val[1]
1174	* . . .
1175	* c_val[n]
1176	*
1177	* where:
1178	* m is the number of rows (auxiliary variables);
1179	* n is the number of columns (structural variables);
1180	* stat is the solution status (GLP_UNDEF = 1, GLP_FEAS = 2,
1181	* GLP_NOFEAS = 4, or GLP_OPT = 5);
1182	* obj_val is the objective value;
1183	* r_val[i], i = 1,...,m, is the value of i-th row;
1184	* c_val[j], j = 1,...,n, is the value of j-th column. */
1185
1186	int glp_write_mip(glp_prob mip, const char fname)
1187	{ XFILE *fp;
1188	int i, j, ret = 0;
1189	xprintf("Writing MIP solution to `%s'...\n", fname);
1190	fp = xfopen(fname, "w");
1191	if (fp == NULL)
1192	{ xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
1193	ret = 1;
1194	goto done;
1195	}
1196	/* number of rows, number of columns */
1197	xfprintf(fp, "%d %d\n", mip->m, mip->n);
1198	/* solution status, objective value */
1199	xfprintf(fp, "%d %.*g\n", mip->mip_stat, DBL_DIG, mip->mip_obj);
1200	/* rows (auxiliary variables) */
1201	for (i = 1; i <= mip->m; i++)
1202	xfprintf(fp, "%.*g\n", DBL_DIG, mip->row[i]->mipx);
1203	/* columns (structural variables) */
1204	for (j = 1; j <= mip->n; j++)
1205	xfprintf(fp, "%.*g\n", DBL_DIG, mip->col[j]->mipx);
1206	xfflush(fp);
1207	if (xferror(fp))
1208	{ xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
1209	ret = 1;
1210	goto done;
1211	}
1212	xprintf("%d lines were written\n", 2 + mip->m + mip->n);
1213	done: if (fp != NULL) xfclose(fp);
1214	return ret;
1215	}
1216
1217	/* eof */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

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

Download in other formats: