char const *
range_as_string (GnmRange const *src)
{
static char buffer[(6 + 4 * sizeof (long)) * 2 + 1];
g_return_val_if_fail (src != NULL, "");
sprintf (buffer, "%s%s",
col_name (src->start.col), row_name (src->start.row));
if (src->start.col != src->end.col || src->start.row != src->end.row)
sprintf (buffer + strlen(buffer), ":%s%s",
col_name (src->end.col), row_name (src->end.row));
return buffer;
}
void
range_dump (GnmRange const *src, char const *suffix)
{
/*
* keep these as 2 print statements, because
* col_name and row_name use a static buffer
*/
g_printerr ("%s%s",
col_name (src->start.col),
row_name (src->start.row));
if (src->start.col != src->end.col ||
src->start.row != src->end.row)
g_printerr (":%s%s",
col_name (src->end.col),
row_name (src->end.row));
g_printerr ("%s", suffix);
}
void PrintProxy(CTFBotProxy *proxy)
{
CFmtStr col_addr("0x%08x", (uintptr_t)proxy);
CFmtStr col_eidx("#%d", ENTINDEX(proxy));
CFmtStr col_name("%s", STRING(proxy->GetEntityName()));
CFmtStr col_vt ("0x%08x", *reinterpret_cast<uintptr_t *>(proxy));
Msg("%-10s %5s %-12s | %10s\n", col_addr.Get(), col_eidx.Get(), col_name.Get(), col_vt.Get());
}
static gchar *
col_row_name (Sheet *sheet, int col, int row, gboolean header, gboolean is_cols)
{
GnmCell *cell;
gchar *str = NULL;
if (is_cols)
str = g_strdup_printf (_("Column %s"), col_name (col));
else
str = g_strdup_printf (_("Row %s"), row_name (row));
if (header) {
cell = sheet_cell_get (sheet, col, row);
if (cell && !gnm_cell_is_blank (cell)) {
gchar *header_str, *generic_str = str;
header_str = value_get_as_string (cell->value);
str = g_strdup_printf (_("%s (%s)"), header_str, generic_str);
g_free (header_str);
g_free (generic_str);
}
}
return str;
}
int lpx_write_cpxlp(LPX *lp, const char *fname)
{ /* write problem data in CPLEX LP format */
FILE *fp;
int nrows, ncols, i, j, t, len, typx, flag, kind, *ind;
double lb, ub, temp, *val;
char line[1023+1], term[1023+1], rname[255+1], cname[255+1];
print("lpx_write_cpxlp: writing problem data to `%s'...", fname);
/* open the output text file */
fp = xfopen(fname, "w");
if (fp == NULL)
{ print("lpx_write_cpxlp: unable to create `%s' - %s", fname,
strerror(errno));
goto fail;
}
/* determine the number of rows and columns */
nrows = lpx_get_num_rows(lp);
ncols = lpx_get_num_cols(lp);
/* the problem should contain at least one row and one column */
if (!(nrows > 0 && ncols > 0))
fault("lpx_write_cpxlp: problem has no rows/columns");
/* write problem name */
{ const char *name = lpx_get_prob_name(lp);
if (name == NULL) name = "Unknown";
fprintf(fp, "\\* Problem: %s *\\\n", name);
fprintf(fp, "\n");
}
/* allocate working arrays */
ind = xcalloc(1+ncols, sizeof(int));
val = xcalloc(1+ncols, sizeof(double));
/* write the objective function definition and the constraints
section */
for (i = 0; i <= nrows; i++)
{ if (i == 0)
{ switch (lpx_get_obj_dir(lp))
{ case LPX_MIN:
fprintf(fp, "Minimize\n");
break;
case LPX_MAX:
fprintf(fp, "Maximize\n");
break;
default:
xassert(lp != lp);
}
}
else if (i == 1)
{ temp = lpx_get_obj_coef(lp, 0);
if (temp != 0.0)
fprintf(fp, "\\* constant term = %.*g *\\\n", DBL_DIG,
temp);
fprintf(fp, "\n");
fprintf(fp, "Subject To\n");
}
row_name(lp, i, rname);
if (i == 0)
{ len = 0;
for (j = 1; j <= ncols; j++)
{ temp = lpx_get_obj_coef(lp, j);
if (temp != 0.0)
len++, ind[len] = j, val[len] = temp;
}
}
else
{ lpx_get_row_bnds(lp, i, &typx, &lb, &ub);
if (typx == LPX_FR) continue;
len = lpx_get_mat_row(lp, i, ind, val);
}
flag = 0;
more: if (!flag)
sprintf(line, " %s:", rname);
else
sprintf(line, " %*s ", strlen(rname), "");
for (t = 1; t <= len; t++)
{ col_name(lp, ind[t], cname);
if (val[t] == +1.0)
sprintf(term, " + %s", cname);
else if (val[t] == -1.0)
sprintf(term, " - %s", cname);
else if (val[t] > 0.0)
sprintf(term, " + %.*g %s", DBL_DIG, +val[t], cname);
else if (val[t] < 0.0)
sprintf(term, " - %.*g %s", DBL_DIG, -val[t], cname);
else
xassert(lp != lp);
if (strlen(line) + strlen(term) > 72)
fprintf(fp, "%s\n", line), line[0] = '\0';
strcat(line, term);
}
if (len == 0)
{ /* empty row */
sprintf(term, " 0 %s", col_name(lp, 1, cname));
strcat(line, term);
}
if (i > 0)
{ switch (typx)
{ case LPX_LO:
case LPX_DB:
sprintf(term, " >= %.*g", DBL_DIG, lb);
break;
case LPX_UP:
sprintf(term, " <= %.*g", DBL_DIG, ub);
break;
case LPX_FX:
sprintf(term, " = %.*g", DBL_DIG, lb);
break;
default:
xassert(typx != typx);
}
if (strlen(line) + strlen(term) > 72)
fprintf(fp, "%s\n", line), line[0] = '\0';
strcat(line, term);
}
fprintf(fp, "%s\n", line);
if (i > 0 && typx == LPX_DB)
{ /* double-bounded row needs a copy for its upper bound */
flag = 1;
typx = LPX_UP;
goto more;
}
}
/* free working arrays */
xfree(ind);
xfree(val);
/* write the bounds section */
flag = 0;
for (j = 1; j <= ncols; j++)
{ col_name(lp, j, cname);
lpx_get_col_bnds(lp, j, &typx, &lb, &ub);
if (typx == LPX_LO && lb == 0.0) continue;
if (!flag)
{ fprintf(fp, "\n");
fprintf(fp, "Bounds\n");
flag = 1;
}
switch (typx)
{ case LPX_FR:
fprintf(fp, " %s free\n", cname);
break;
case LPX_LO:
fprintf(fp, " %s >= %.*g\n", cname, DBL_DIG, lb);
break;
case LPX_UP:
fprintf(fp, " %s <= %.*g\n", cname, DBL_DIG, ub);
break;
case LPX_DB:
fprintf(fp, " %.*g <= %s <= %.*g\n", DBL_DIG, lb, cname,
DBL_DIG, ub);
break;
case LPX_FX:
fprintf(fp, " %s = %.*g\n", cname, DBL_DIG, lb);
break;
default:
xassert(typx != typx);
}
}
/* write the general section */
if (lpx_get_class(lp) == LPX_MIP)
{ flag = 0;
for (j = 1; j <= ncols; j++)
{ kind = lpx_get_col_kind(lp, j);
if (kind == LPX_CV) continue;
xassert(kind == LPX_IV);
if (!flag)
{ fprintf(fp, "\n");
fprintf(fp, "Generals\n");
flag = 1;
}
fprintf(fp, " %s\n", col_name(lp, j, cname));
}
}
/* write the end keyword */
fprintf(fp, "\n");
fprintf(fp, "End\n");
/* close the output text file */
fflush(fp);
if (ferror(fp))
{ print("lpx_write_cpxlp: write error on `%s' - %s", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
/* return to the calling program */
return 0;
fail: /* the operation failed */
if (fp != NULL) xfclose(fp);
return 1;
}
int lpx_print_prob(LPX *lp, const char *fname)
{ XFILE *fp;
int m, n, mip, i, j, len, t, type, *ndx;
double coef, lb, ub, *val;
char *str, name[255+1];
xprintf("lpx_write_prob: writing problem data to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_write_prob: unable to create `%s' - %s\n",
fname, strerror(errno));
goto fail;
}
m = lpx_get_num_rows(lp);
n = lpx_get_num_cols(lp);
mip = (lpx_get_class(lp) == LPX_MIP);
str = (void *)lpx_get_prob_name(lp);
xfprintf(fp, "Problem: %s\n", str == NULL ? "(unnamed)" : str);
xfprintf(fp, "Class: %s\n", !mip ? "LP" : "MIP");
xfprintf(fp, "Rows: %d\n", m);
if (!mip)
xfprintf(fp, "Columns: %d\n", n);
else
xfprintf(fp, "Columns: %d (%d integer, %d binary)\n",
n, lpx_get_num_int(lp), lpx_get_num_bin(lp));
xfprintf(fp, "Non-zeros: %d\n", lpx_get_num_nz(lp));
xfprintf(fp, "\n");
xfprintf(fp, "*** OBJECTIVE FUNCTION ***\n");
xfprintf(fp, "\n");
switch (lpx_get_obj_dir(lp))
{ case LPX_MIN:
xfprintf(fp, "Minimize:");
break;
case LPX_MAX:
xfprintf(fp, "Maximize:");
break;
default:
xassert(lp != lp);
}
str = (void *)lpx_get_obj_name(lp);
xfprintf(fp, " %s\n", str == NULL ? "(unnamed)" : str);
coef = lpx_get_obj_coef(lp, 0);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(constant term)");
for (i = 1; i <= m; i++)
#if 0
{ coef = lpx_get_row_coef(lp, i);
#else
{ coef = 0.0;
#endif
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
row_name(lp, i, name));
}
for (j = 1; j <= n; j++)
{ coef = lpx_get_obj_coef(lp, j);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
col_name(lp, j, name));
}
xfprintf(fp, "\n");
xfprintf(fp, "*** ROWS (CONSTRAINTS) ***\n");
ndx = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
for (i = 1; i <= m; i++)
{ xfprintf(fp, "\n");
xfprintf(fp, "Row %d: %s", i, row_name(lp, i, name));
lpx_get_row_bnds(lp, i, &type, &lb, &ub);
switch (type)
{ case LPX_FR:
xfprintf(fp, " free");
break;
case LPX_LO:
xfprintf(fp, " >= %.*g", DBL_DIG, lb);
break;
case LPX_UP:
xfprintf(fp, " <= %.*g", DBL_DIG, ub);
break;
case LPX_DB:
xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
ub);
break;
case LPX_FX:
xfprintf(fp, " = %.*g", DBL_DIG, lb);
break;
default:
xassert(type != type);
}
xfprintf(fp, "\n");
#if 0
coef = lpx_get_row_coef(lp, i);
#else
coef = 0.0;
#endif
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(objective)");
len = lpx_get_mat_row(lp, i, ndx, val);
for (t = 1; t <= len; t++)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
col_name(lp, ndx[t], name));
}
xfree(ndx);
xfree(val);
xfprintf(fp, "\n");
xfprintf(fp, "*** COLUMNS (VARIABLES) ***\n");
ndx = xcalloc(1+m, sizeof(int));
val = xcalloc(1+m, sizeof(double));
for (j = 1; j <= n; j++)
{ xfprintf(fp, "\n");
xfprintf(fp, "Col %d: %s", j, col_name(lp, j, name));
if (mip)
{ switch (lpx_get_col_kind(lp, j))
{ case LPX_CV:
break;
case LPX_IV:
xfprintf(fp, " integer");
break;
default:
xassert(lp != lp);
}
}
lpx_get_col_bnds(lp, j, &type, &lb, &ub);
switch (type)
{ case LPX_FR:
xfprintf(fp, " free");
break;
case LPX_LO:
xfprintf(fp, " >= %.*g", DBL_DIG, lb);
break;
case LPX_UP:
xfprintf(fp, " <= %.*g", DBL_DIG, ub);
break;
case LPX_DB:
xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
ub);
break;
case LPX_FX:
xfprintf(fp, " = %.*g", DBL_DIG, lb);
break;
default:
xassert(type != type);
}
xfprintf(fp, "\n");
coef = lpx_get_obj_coef(lp, j);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(objective)");
len = lpx_get_mat_col(lp, j, ndx, val);
for (t = 1; t <= len; t++)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
row_name(lp, ndx[t], name));
}
xfree(ndx);
xfree(val);
xfprintf(fp, "\n");
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_write_prob: write error on `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
#undef row_name
#undef col_name
/*----------------------------------------------------------------------
-- lpx_print_sol - write LP problem solution in printable format.
--
-- *Synopsis*
--
-- #include "glplpx.h"
-- int lpx_print_sol(LPX *lp, char *fname);
--
-- *Description*
--
-- The routine lpx_print_sol writes the current basic solution of an LP
-- problem, which is specified by the pointer lp, to a text file, whose
-- name is the character string fname, in printable format.
--
-- Information reported by the routine lpx_print_sol is intended mainly
-- for visual analysis.
--
-- *Returns*
--
-- If the operation was successful, the routine returns zero. Otherwise
-- the routine prints an error message and returns non-zero. */
int lpx_print_sol(LPX *lp, const char *fname)
{ XFILE *fp;
int what, round;
xprintf(
"lpx_print_sol: writing LP problem solution to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_print_sol: can't create `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
/* problem name */
{ const char *name;
name = lpx_get_prob_name(lp);
if (name == NULL) name = "";
xfprintf(fp, "%-12s%s\n", "Problem:", name);
}
/* number of rows (auxiliary variables) */
{ int nr;
nr = lpx_get_num_rows(lp);
xfprintf(fp, "%-12s%d\n", "Rows:", nr);
}
/* number of columns (structural variables) */
{ int nc;
nc = lpx_get_num_cols(lp);
xfprintf(fp, "%-12s%d\n", "Columns:", nc);
}
/* number of non-zeros (constraint coefficients) */
{ int nz;
nz = lpx_get_num_nz(lp);
xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
}
/* solution status */
{ int status;
status = lpx_get_status(lp);
xfprintf(fp, "%-12s%s\n", "Status:",
status == LPX_OPT ? "OPTIMAL" :
status == LPX_FEAS ? "FEASIBLE" :
status == LPX_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
status == LPX_NOFEAS ? "INFEASIBLE (FINAL)" :
status == LPX_UNBND ? "UNBOUNDED" :
status == LPX_UNDEF ? "UNDEFINED" : "???");
}
/* objective function */
{ char *name;
int dir;
double obj;
name = (void *)lpx_get_obj_name(lp);
dir = lpx_get_obj_dir(lp);
obj = lpx_get_obj_val(lp);
xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
name == NULL ? "" : name,
name == NULL ? "" : " = ", obj,
dir == LPX_MIN ? "(MINimum)" :
dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
}
/* main sheet */
for (what = 1; what <= 2; what++)
{ int mn, ij;
xfprintf(fp, "\n");
xfprintf(fp, " No. %-12s St Activity Lower bound Upp"
"er bound Marginal\n",
what == 1 ? " Row name" : "Column name");
xfprintf(fp, "------ ------------ -- ------------- -----------"
"-- ------------- -------------\n");
mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
for (ij = 1; ij <= mn; ij++)
{ const char *name;
int typx, tagx;
double lb, ub, vx, dx;
if (what == 1)
{ name = lpx_get_row_name(lp, ij);
if (name == NULL) name = "";
lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
lpx_get_row_info(lp, ij, &tagx, &vx, &dx);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
else
{ name = lpx_get_col_name(lp, ij);
if (name == NULL) name = "";
lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
lpx_get_col_info(lp, ij, &tagx, &vx, &dx);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
/* row/column ordinal number */
xfprintf(fp, "%6d ", ij);
/* row column/name */
if (strlen(name) <= 12)
xfprintf(fp, "%-12s ", name);
else
xfprintf(fp, "%s\n%20s", name, "");
/* row/column status */
xfprintf(fp, "%s ",
tagx == LPX_BS ? "B " :
tagx == LPX_NL ? "NL" :
tagx == LPX_NU ? "NU" :
tagx == LPX_NF ? "NF" :
tagx == LPX_NS ? "NS" : "??");
/* row/column primal activity */
xfprintf(fp, "%13.6g ", vx);
/* row/column lower bound */
if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX)
xfprintf(fp, "%13.6g ", lb);
else
xfprintf(fp, "%13s ", "");
/* row/column upper bound */
if (typx == LPX_UP || typx == LPX_DB)
xfprintf(fp, "%13.6g ", ub);
else if (typx == LPX_FX)
xfprintf(fp, "%13s ", "=");
else
xfprintf(fp, "%13s ", "");
/* row/column dual activity */
if (tagx != LPX_BS)
{ if (dx == 0.0)
xfprintf(fp, "%13s", "< eps");
else
xfprintf(fp, "%13.6g", dx);
}
/* end of line */
xfprintf(fp, "\n");
}
}
xfprintf(fp, "\n");
#if 1
if (lpx_get_prim_stat(lp) != LPX_P_UNDEF &&
lpx_get_dual_stat(lp) != LPX_D_UNDEF)
{ int m = lpx_get_num_rows(lp);
LPXKKT kkt;
xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n\n");
lpx_check_kkt(lp, 1, &kkt);
xfprintf(fp, "KKT.PE: max.abs.err. = %.2e on row %d\n",
kkt.pe_ae_max, kkt.pe_ae_row);
xfprintf(fp, " max.rel.err. = %.2e on row %d\n",
kkt.pe_re_max, kkt.pe_re_row);
switch (kkt.pe_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " PRIMAL SOLUTION IS WRONG\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.PB: max.abs.err. = %.2e on %s %d\n",
kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column",
kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m);
xfprintf(fp, " max.rel.err. = %.2e on %s %d\n",
kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column",
kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m);
switch (kkt.pb_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " PRIMAL SOLUTION IS INFEASIBLE\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.DE: max.abs.err. = %.2e on column %d\n",
kkt.de_ae_max, kkt.de_ae_col);
xfprintf(fp, " max.rel.err. = %.2e on column %d\n",
kkt.de_re_max, kkt.de_re_col);
switch (kkt.de_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " DUAL SOLUTION IS WRONG\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.DB: max.abs.err. = %.2e on %s %d\n",
kkt.db_ae_max, kkt.db_ae_ind <= m ? "row" : "column",
kkt.db_ae_ind <= m ? kkt.db_ae_ind : kkt.db_ae_ind - m);
xfprintf(fp, " max.rel.err. = %.2e on %s %d\n",
kkt.db_re_max, kkt.db_re_ind <= m ? "row" : "column",
kkt.db_re_ind <= m ? kkt.db_re_ind : kkt.db_re_ind - m);
switch (kkt.db_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " DUAL SOLUTION IS INFEASIBLE\n");
break;
}
xfprintf(fp, "\n");
}
#endif
#if 1
if (lpx_get_status(lp) == LPX_UNBND)
{ int m = lpx_get_num_rows(lp);
int k = lpx_get_ray_info(lp);
xfprintf(fp, "Unbounded ray: %s %d\n",
k <= m ? "row" : "column", k <= m ? k : k - m);
xfprintf(fp, "\n");
}
#endif
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_print_sol: can't write to `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
ListUsb::ListUsb()
{
set_title("lsusb");
maximize();
add(m_box);
m_scrolled_window.add(m_tree_view);
m_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC,Gtk::POLICY_AUTOMATIC);
m_refActionGroup=Gtk::ActionGroup::create();
m_refActionGroup->add(Gtk::Action::create("Quit", Gtk::Stock::QUIT),
sigc::mem_fun(*this, &ListUsb::on_quit));
m_refActionGroup->add(Gtk::Action::create("Refresh", Gtk::Stock::REFRESH),
sigc::mem_fun(*this, &ListUsb::on_refresh));
m_refUIManager=Gtk::UIManager::create();
m_refUIManager->insert_action_group(m_refActionGroup);
add_accel_group(m_refUIManager->get_accel_group());
Glib::ustring ui_info =
"<ui>"
" <toolbar name='ToolBar'>"
" <toolitem action='Refresh'/>"
" <toolitem action='Quit'/>"
" </toolbar>"
"</ui>";
#ifdef GLIBMM_EXCEPTIONS_ENABLED
try
{
m_refUIManager->add_ui_from_string(ui_info);
}
catch(const Glib::Error& ex)
{
fprintf(stderr,"building menus failed: %s",ex.what().c_str());
}
#else
std::auto_ptr<Glib::Error> ex;
m_refUIManager->add_ui_from_string(ui_info,ex);
if(ex.get())
{
fprintf(stderr,"building menus failed: %s",ex->what());
}
#endif //GLIBMM_EXCEPTIONS_ENABLED
Gtk::Widget* pToolbar = m_refUIManager->get_widget("/ToolBar") ;
if(pToolbar)
m_box.pack_start(*pToolbar,Gtk::PACK_SHRINK);
m_box.pack_start(m_scrolled_window);
m_ref_tree_model=Gtk::TreeStore::create(m_columns);
m_tree_view.set_model(m_ref_tree_model);
//Add the TreeView's view columns:
Gtk::TreeViewColumn col_name("Name",m_columns.m_col_name);
Gtk::TreeViewColumn col_value("Value",m_columns.m_col_value);
Gtk::TreeViewColumn col_comment("Comment",m_columns.m_col_comment);
col_name.set_resizable();
col_value.set_resizable();
col_comment.set_resizable();
m_tree_view.append_column(col_name);
m_tree_view.append_column(col_value);
m_tree_view.append_column(col_comment);
show_all_children();
on_refresh();
}
/* Debugging utility to print a GnmValue */
void
value_dump (GnmValue const *value)
{
switch (value->v_any.type){
case VALUE_EMPTY:
g_print ("EMPTY\n");
break;
case VALUE_ERROR:
g_print ("ERROR: %s\n", value->v_err.mesg->str);
break;
case VALUE_BOOLEAN:
g_print ("BOOLEAN: %s\n", go_locale_boolean_name (value->v_bool.val));
break;
case VALUE_STRING:
g_print ("STRING: %s\n", value->v_str.val->str);
break;
case VALUE_FLOAT:
g_print ("NUMBER: %" GNM_FORMAT_f "\n", value_get_as_float (value));
break;
case VALUE_ARRAY: {
int x, y;
g_print ("Array: { ");
for (y = 0; y < value->v_array.y; y++)
for (x = 0; x < value->v_array.x; x++)
value_dump (value->v_array.vals [x][y]);
g_print ("}\n");
break;
}
case VALUE_CELLRANGE: {
/*
* Do NOT normalize the ranges.
* Lets see them in their inverted glory if need be.
*/
GnmCellRef const *c = &value->v_range.cell.a;
Sheet const *sheet = c->sheet;
g_print ("CellRange\n");
if (sheet && sheet->name_unquoted)
g_print ("%s:", sheet->name_quoted);
else
g_print ("%p :", (void *)sheet);
g_print ("%s%s%s%s\n",
(c->col_relative ? "":"$"), col_name(c->col),
(c->row_relative ? "":"$"), row_name(c->row));
c = &value->v_range.cell.b;
if (sheet && sheet->name_quoted)
g_print ("%s:", sheet->name_unquoted);
else
g_print ("%p :", (void *)sheet);
g_print ("%s%s%s%s\n",
(c->col_relative ? "":"$"), col_name(c->col),
(c->row_relative ? "":"$"), row_name(c->row));
break;
}
default:
g_print ("Unhandled item type\n");
}
}
int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)
{ /* write problem data in CPLEX LP format */
glp_cpxcp _parm;
struct csa _csa, *csa = &_csa;
glp_file *fp;
GLPROW *row;
GLPCOL *col;
GLPAIJ *aij;
int i, j, len, flag, count, ret;
char line[1000+1], term[500+1], name[255+1];
xprintf("Writing problem data to '%s'...\n", fname);
if (parm == NULL)
glp_init_cpxcp(&_parm), parm = &_parm;
/* check control parameters */
check_parm("glp_write_lp", parm);
/* initialize common storage area */
csa->P = P;
csa->parm = parm;
/* create output CPLEX LP file */
fp = glp_open(fname, "w"), count = 0;
if (fp == NULL)
{ xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
ret = 1;
goto done;
}
/* write problem name */
xfprintf(fp, "\\* Problem: %s *\\\n",
P->name == NULL ? "Unknown" : P->name), count++;
xfprintf(fp, "\n"), count++;
/* the problem should contain at least one row and one column */
if (!(P->m > 0 && P->n > 0))
{ xprintf("Warning: problem has no rows/columns\n");
xfprintf(fp, "\\* WARNING: PROBLEM HAS NO ROWS/COLUMNS *\\\n"),
count++;
xfprintf(fp, "\n"), count++;
goto skip;
}
/* write the objective function definition */
if (P->dir == GLP_MIN)
xfprintf(fp, "Minimize\n"), count++;
else if (P->dir == GLP_MAX)
xfprintf(fp, "Maximize\n"), count++;
else
xassert(P != P);
row_name(csa, 0, name);
sprintf(line, " %s:", name);
len = 0;
for (j = 1; j <= P->n; j++)
{ col = P->col[j];
if (col->coef != 0.0 || col->ptr == NULL)
{ len++;
col_name(csa, j, name);
if (col->coef == 0.0)
sprintf(term, " + 0 %s", name); /* empty column */
else if (col->coef == +1.0)
sprintf(term, " + %s", name);
else if (col->coef == -1.0)
sprintf(term, " - %s", name);
else if (col->coef > 0.0)
sprintf(term, " + %.*g %s", DBL_DIG, +col->coef, name);
else
sprintf(term, " - %.*g %s", DBL_DIG, -col->coef, name);
if (strlen(line) + strlen(term) > 72)
xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
strcat(line, term);
}
}
if (len == 0)
{ /* empty objective */
sprintf(term, " 0 %s", col_name(csa, 1, name));
strcat(line, term);
}
xfprintf(fp, "%s\n", line), count++;
if (P->c0 != 0.0)
xfprintf(fp, "\\* constant term = %.*g *\\\n", DBL_DIG, P->c0),
count++;
xfprintf(fp, "\n"), count++;
/* write the constraints section */
xfprintf(fp, "Subject To\n"), count++;
for (i = 1; i <= P->m; i++)
{ row = P->row[i];
if (row->type == GLP_FR) continue; /* skip free row */
row_name(csa, i, name);
sprintf(line, " %s:", name);
/* linear form */
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
{ col_name(csa, aij->col->j, name);
if (aij->val == +1.0)
sprintf(term, " + %s", name);
else if (aij->val == -1.0)
sprintf(term, " - %s", name);
else if (aij->val > 0.0)
sprintf(term, " + %.*g %s", DBL_DIG, +aij->val, name);
else
sprintf(term, " - %.*g %s", DBL_DIG, -aij->val, name);
if (strlen(line) + strlen(term) > 72)
xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
strcat(line, term);
}
if (row->type == GLP_DB)
{ /* double-bounded (ranged) constraint */
sprintf(term, " - ~r_%d", i);
if (strlen(line) + strlen(term) > 72)
xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
strcat(line, term);
}
else if (row->ptr == NULL)
{ /* empty constraint */
sprintf(term, " 0 %s", col_name(csa, 1, name));
strcat(line, term);
}
/* right hand-side */
if (row->type == GLP_LO)
sprintf(term, " >= %.*g", DBL_DIG, row->lb);
else if (row->type == GLP_UP)
sprintf(term, " <= %.*g", DBL_DIG, row->ub);
else if (row->type == GLP_DB || row->type == GLP_FX)
sprintf(term, " = %.*g", DBL_DIG, row->lb);
else
xassert(row != row);
if (strlen(line) + strlen(term) > 72)
xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
strcat(line, term);
xfprintf(fp, "%s\n", line), count++;
}
xfprintf(fp, "\n"), count++;
/* write the bounds section */
flag = 0;
for (i = 1; i <= P->m; i++)
{ row = P->row[i];
if (row->type != GLP_DB) continue;
if (!flag)
xfprintf(fp, "Bounds\n"), flag = 1, count++;
xfprintf(fp, " 0 <= ~r_%d <= %.*g\n",
i, DBL_DIG, row->ub - row->lb), count++;
}
for (j = 1; j <= P->n; j++)
{ col = P->col[j];
if (col->type == GLP_LO && col->lb == 0.0) continue;
if (!flag)
xfprintf(fp, "Bounds\n"), flag = 1, count++;
col_name(csa, j, name);
if (col->type == GLP_FR)
xfprintf(fp, " %s free\n", name), count++;
else if (col->type == GLP_LO)
xfprintf(fp, " %s >= %.*g\n",
name, DBL_DIG, col->lb), count++;
else if (col->type == GLP_UP)
xfprintf(fp, " -Inf <= %s <= %.*g\n",
name, DBL_DIG, col->ub), count++;
else if (col->type == GLP_DB)
xfprintf(fp, " %.*g <= %s <= %.*g\n",
DBL_DIG, col->lb, name, DBL_DIG, col->ub), count++;
else if (col->type == GLP_FX)
xfprintf(fp, " %s = %.*g\n",
name, DBL_DIG, col->lb), count++;
else
xassert(col != col);
}
if (flag) xfprintf(fp, "\n"), count++;
/* write the integer section */
flag = 0;
for (j = 1; j <= P->n; j++)
{ col = P->col[j];
if (col->kind == GLP_CV) continue;
xassert(col->kind == GLP_IV);
if (!flag)
xfprintf(fp, "Generals\n"), flag = 1, count++;
xfprintf(fp, " %s\n", col_name(csa, j, name)), count++;
}
if (flag) xfprintf(fp, "\n"), count++;
skip: /* write the end keyword */
xfprintf(fp, "End\n"), count++;
#if 0 /* FIXME */
xfflush(fp);
#endif
if (glp_ioerr(fp))
{ xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
ret = 1;
goto done;
}
/* problem data has been successfully written */
xprintf("%d lines were written\n", count);
ret = 0;
done: if (fp != NULL) glp_close(fp);
return ret;
}
