#include "hashptr.h"
#include "debug.h"
#include "set.h"
+#include "debug.h"
#include "sp_matrix.h"
#include "mps.h"
#include "lpp_solvers.h"
#include "lpp_net.h"
-#define HASH_NAME_T(n) HASH_STR((n)->name, strlen((n)->name))
+#define HASH_NAME_T(n) hash_str((n)->name)
-static firm_dbg_module_t *dbg = NULL;
+DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
static inline char *obst_xstrdup(struct obstack *obst, const char *str)
{
- return obstack_copy0(obst, str, strlen(str));
+ return (char*)obstack_copy0(obst, str, strlen(str));
}
static int cmp_name_t(const void *x, const void *y, size_t size)
{
- const lpp_name_t *n = x;
- const lpp_name_t *m = y;
+ const lpp_name_t *n = (const lpp_name_t*)x;
+ const lpp_name_t *m = (const lpp_name_t*)y;
(void)size;
return strcmp(n->name, m->name);
}
lpp_t *lpp;
int idx;
- dbg = firm_dbg_register("lpp");
+ DEBUG_ONLY(dbg = firm_dbg_register("lpp");)
lpp = XMALLOCZ(lpp_t);
obstack_init(&lpp->obst);
{
lpp_name_t find, *found;
find.name = name;
- found = set_find(where, &find, sizeof(find), HASH_NAME_T(&find));
+ found = set_find(lpp_name_t, where, &find, sizeof(find), HASH_NAME_T(&find));
return (found ? found->nr : -1);
}
static inline char *get_next_name(lpp_t *lpp)
{
- char *res = obstack_alloc(&lpp->obst, 12);
+ char *res = OALLOCN(&lpp->obst, char, 12);
snprintf(res, 12, "_%u", lpp->next_name_number++);
return res;
}
n.name = get_next_name(lpp);
n.nr = -1;
- inner = set_insert(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
+ inner = set_insert(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
assert(inner);
if (inner->nr == -1) {
n.name = cst_name;
n.nr = -1;
- assert(!set_find(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
+ assert(!set_find(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
"constraint already exists");
}
return lpp_add_cst(lpp, cst_name, cst_type, rhs);
n.name = get_next_name(lpp);
n.nr = -1;
- inner = set_insert(lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
+ inner = set_insert(lpp_name_t, lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
assert(inner);
if (inner->nr == -1) {
inner->nr = lpp->var_next;
- inner->value_kind = 0;
+ inner->value_kind = lpp_none;
inner->value = 0;
inner->type.var_type = var_type;
fprintf(stderr, "constraint %s unsatisfied: %g != %g\n", cst->name, sum, cst_val);
}
break;
- case lpp_less:
+ case lpp_less_equal:
if(sum > cst_val) {
- fprintf(stderr, "constraint %s unsatisfied: %g > %g\n", cst->name, sum, cst_val);
+ fprintf(stderr, "constraint %s unsatisfied: %g >= %g\n", cst->name, sum, cst_val);
}
break;
- case lpp_greater:
+ case lpp_greater_equal:
if(sum < cst_val) {
- fprintf(stderr, "constraint %s unsatisfied: %g < %g\n", cst->name, sum, cst_val);
+ fprintf(stderr, "constraint %s unsatisfied: %g <= %g\n", cst->name, sum, cst_val);
}
break;
default:
switch(cst) {
case lpp_equal:
return "=";
- case lpp_less:
+ case lpp_less_equal:
return "<=";
- case lpp_greater:
+ case lpp_greater_equal:
return ">=";
default:
return "";
{
int i;
+ fprintf(f, lpp->opt_type == lpp_minimize ? "Minimize\n" : "Maximize\n");
for(i = 0; i < lpp->cst_next; ++i) {
- const matrix_elem_t *elm;
lpp_name_t *cst = lpp->csts[i];
+
fprintf(f, "%16s: ", cst->name);
matrix_foreach_in_row(lpp->m, cst->nr, elm) {
lpp_name_t *var = lpp->vars[elm->col];
/* TODO Perhaps better a define LPP_COL_RHS */
if(elm->col > 0)
- fprintf(f, "%+4.1f*%-16s ", elm->val, var->name);
+ fprintf(f, "%+4.1f %-16s ", elm->val, var->name);
+ }
+
+ if (i == 0) {
+ fprintf(f, "\nSubject To\n");
+ continue;
}
fprintf(f, "%3s %+4.1f\n",
lpp_cst_op_to_str(cst->type.cst_type), matrix_get(lpp->m, cst->nr, 0));
}
+
+ fprintf(f, "Binary\n");
+ for(i = 0; i < lpp->var_next; ++i) {
+ lpp_name_t *var = lpp->vars[i];
+ if (var->type.var_type == lpp_binary)
+ fprintf(f, "%16s\n", var->name);
+ }
+ fprintf(f, "End\n");
}
/**
lpp_writel(comm, lpp->set_bound);
lpp_writed(comm, lpp->bound);
lpp_writed(comm, lpp->time_limit_secs);
- lpp_writed(comm, lpp->emphasis);
+ lpp_writel(comm, lpp->emphasis);
for(i = 0; i < lpp->cst_next; ++i) {
lpp_name_t *name = lpp->csts[i];
lpp_writes(comm, name->name);
}
- {
- const matrix_elem_t *elm;
- n = 0;
-
- matrix_foreach(lpp->m, elm)
- n++;
+ n = 0;
+ matrix_foreach(lpp->m, elm)
+ n++;
- assert(n == matrix_get_entries(lpp->m));
- lpp_writel(comm, n);
- matrix_foreach(lpp->m, elm) {
- lpp_writel(comm, elm->row);
- lpp_writel(comm, elm->col);
- lpp_writed(comm, elm->val);
- }
+ assert(n == matrix_get_entries(lpp->m));
+ lpp_writel(comm, n);
+ matrix_foreach(lpp->m, elm) {
+ lpp_writel(comm, elm->row);
+ lpp_writel(comm, elm->col);
+ lpp_writed(comm, elm->val);
}
}
with_names = lpp_readl(comm);
lpp->cst_next = lpp_readl(comm);
lpp->var_next = lpp_readl(comm);
- lpp->opt_type = lpp_readl(comm);
+ lpp->opt_type = (lpp_opt_t)lpp_readl(comm);
lpp->name = lpp_reads(comm);
/* read options */
lpp->set_bound = lpp_readl(comm);
lpp->bound = lpp_readd(comm);
lpp->time_limit_secs = lpp_readd(comm);
- lpp->emphasis = lpp_readd(comm);
+ lpp->emphasis = (lpp_emphasis_t)lpp_readl(comm);
lpp->cst_size = lpp->cst_next;
lpp->var_size = lpp->var_next;
lpp_name_t name, *res;
name.nr = lpp_readl(comm);
- name.value_kind = lpp_readl(comm);
- name.type.cst_type = lpp_readl(comm);
+ name.value_kind = (lpp_value_kind_t)lpp_readl(comm);
+ name.type.cst_type = (lpp_cst_t)lpp_readl(comm);
if(with_names) {
name.name = lpp_reads(comm);
name.name = buf;
}
- res = set_insert(lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
+ res = set_insert(lpp_name_t, lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
lpp->csts[name.nr] = res;
}
lpp_name_t name, *res;
name.nr = lpp_readl(comm);
- name.value_kind = lpp_readl(comm);
- name.type.var_type = lpp_readl(comm);
+ name.value_kind = (lpp_value_kind_t)lpp_readl(comm);
+ name.type.var_type = (lpp_var_t)lpp_readl(comm);
if(with_names) {
name.name = lpp_reads(comm);
name.name = buf;
}
- res = set_insert(lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
+ res = set_insert(lpp_name_t, lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
lpp->vars[name.nr] = res;
}
void lpp_deserialize_stats(lpp_comm_t *comm, lpp_t *lpp)
{
- lpp->sol_state = lpp_readl(comm);
+ lpp->sol_state = (lpp_sol_state_t)lpp_readl(comm);
lpp->iterations = lpp_readl(comm);
lpp->sol_time = lpp_readd(comm);
lpp->objval = lpp_readd(comm);