static void parse_integer(struct csa *csa)
{ int j, binary;
/* parse the keyword 'general', 'integer', or 'binary' */
if (csa->token == T_GENERAL)
binary = 0, scan_token(csa);
else if (csa->token == T_INTEGER)
binary = 0, scan_token(csa);
else if (csa->token == T_BINARY)
binary = 1, scan_token(csa);
else
xassert(csa != csa);
/* parse list of variables (may be empty) */
while (csa->token == T_NAME)
{ /* find the corresponding column */
j = find_col(csa, csa->image);
/* change kind of the variable */
glp_set_col_kind(csa->P, j, GLP_IV);
/* set bounds for the binary variable */
if (binary)
#if 0 /* 07/VIII-2013 */
{ set_lower_bound(csa, j, 0.0);
set_upper_bound(csa, j, 1.0);
}
#else
{ set_lower_bound(csa, j,
csa->lb[j] == +DBL_MAX ? 0.0 : csa->lb[j]);
set_upper_bound(csa, j,
csa->ub[j] == -DBL_MAX ? 1.0 : csa->ub[j]);
}
#endif
scan_token(csa);
}
return;
}
static void parse_integer(struct dsa *dsa)
{ int j, binary;
/* parse the keyword 'general', 'integer', or 'binary' */
if (dsa->token == T_GENERAL)
binary = 0, scan_token(dsa);
else if (dsa->token == T_INTEGER)
binary = 0, scan_token(dsa);
else if (dsa->token == T_BINARY)
binary = 1, scan_token(dsa);
else
xassert(dsa != dsa);
/* parse list of variables (may be empty) */
while (dsa->token == T_NAME)
{ /* find the corresponding column */
j = find_col(dsa, dsa->image);
/* change kind of the variable */
#if 0
lpx_set_class(dsa->lp, LPX_MIP);
#endif
lpx_set_col_kind(dsa->lp, j, LPX_IV);
/* set 0-1 bounds for the binary variable */
if (binary)
{ set_lower_bound(dsa, j, 0.0);
set_upper_bound(dsa, j, 1.0);
}
scan_token(dsa);
}
return;
}
void optimize::variable::copy_bounds(const variable& var)
{
// Calls set_lower_bound and set_upper_bound before set_bound_type
set_lower_bound(var.lower_bound());
set_upper_bound(var.upper_bound());
set_bound_type(var.bound_type());
}
slide_node_slice_function::slide_node_slice_function(Parameters& P_,int b0)
:count(0),P(P_)
{
vector<const_branchview> b;
b.push_back( P.T->directed_branch(b0) );
// choose branches to alter
append(b[0].branches_after(),b);
if (not b.size() == 3)
throw myexception()<<"pointing to leaf node!";
b1 = b[1].undirected_name();
b2 = b[2].undirected_name();
total = P.T->branch(b1).length() + P.T->branch(b2).length();
set_lower_bound(0);
set_upper_bound(total);
}
static void parse_bounds(struct dsa *dsa)
{ int j, lb_flag;
double lb, s;
/* parse the keyword 'bounds' */
xassert(dsa->token == T_BOUNDS);
scan_token(dsa);
loop: /* bound definition can start with a sign, numeric constant, or
a symbolic name */
if (!(dsa->token == T_PLUS || dsa->token == T_MINUS ||
dsa->token == T_NUMBER || dsa->token == T_NAME)) goto done;
/* parse bound definition */
if (dsa->token == T_PLUS || dsa->token == T_MINUS)
{ /* parse signed lower bound */
lb_flag = 1;
s = (dsa->token == T_PLUS ? +1.0 : -1.0);
scan_token(dsa);
if (dsa->token == T_NUMBER)
lb = s * dsa->value, scan_token(dsa);
else if (the_same(dsa->image, "infinity") ||
the_same(dsa->image, "inf"))
{ if (s > 0.0)
fatal(dsa, "invalid use of `+inf' as lower bound");
lb = -DBL_MAX, scan_token(dsa);
}
else
fatal(dsa, "missing lower bound");
}
else if (dsa->token == T_NUMBER)
{ /* parse unsigned lower bound */
lb_flag = 1;
lb = dsa->value, scan_token(dsa);
}
else
{ /* lower bound is not specified */
lb_flag = 0;
}
/* parse the token that should follow the lower bound */
if (lb_flag)
{ if (dsa->token != T_LE)
fatal(dsa, "missing `<', `<=', or `=<' after lower bound");
scan_token(dsa);
}
/* parse variable name */
if (dsa->token != T_NAME)
fatal(dsa, "missing variable name");
j = find_col(dsa, dsa->image);
/* set lower bound */
if (lb_flag) set_lower_bound(dsa, j, lb);
scan_token(dsa);
/* parse the context that follows the variable name */
if (dsa->token == T_LE)
{ /* parse upper bound */
scan_token(dsa);
if (dsa->token == T_PLUS || dsa->token == T_MINUS)
{ /* parse signed upper bound */
s = (dsa->token == T_PLUS ? +1.0 : -1.0);
scan_token(dsa);
if (dsa->token == T_NUMBER)
{ set_upper_bound(dsa, j, s * dsa->value);
scan_token(dsa);
}
else if (the_same(dsa->image, "infinity") ||
the_same(dsa->image, "inf"))
{ if (s < 0.0)
fatal(dsa, "invalid use of `-inf' as upper bound");
set_upper_bound(dsa, j, +DBL_MAX);
scan_token(dsa);
}
else
fatal(dsa, "missing upper bound");
}
else if (dsa->token == T_NUMBER)
{ /* parse unsigned upper bound */
set_upper_bound(dsa, j, dsa->value);
scan_token(dsa);
}
else
fatal(dsa, "missing upper bound");
}
else if (dsa->token == T_GE)
{ /* parse lower bound */
if (lb_flag)
{ /* the context '... <= x >= ...' is invalid */
fatal(dsa, "invalid bound definition");
}
scan_token(dsa);
if (dsa->token == T_PLUS || dsa->token == T_MINUS)
{ /* parse signed lower bound */
s = (dsa->token == T_PLUS ? +1.0 : -1.0);
scan_token(dsa);
if (dsa->token == T_NUMBER)
{ set_lower_bound(dsa, j, s * dsa->value);
scan_token(dsa);
}
else if (the_same(dsa->image, "infinity") ||
the_same(dsa->image, "inf") == 0)
{ if (s > 0.0)
fatal(dsa, "invalid use of `+inf' as lower bound");
set_lower_bound(dsa, j, -DBL_MAX);
scan_token(dsa);
}
else
fatal(dsa, "missing lower bound");
}
else if (dsa->token == T_NUMBER)
{ /* parse unsigned lower bound */
set_lower_bound(dsa, j, dsa->value);
scan_token(dsa);
}
else
fatal(dsa, "missing lower bound");
}
else if (dsa->token == T_EQ)
{ /* parse fixed value */
if (lb_flag)
{ /* the context '... <= x = ...' is invalid */
fatal(dsa, "invalid bound definition");
}
scan_token(dsa);
if (dsa->token == T_PLUS || dsa->token == T_MINUS)
{ /* parse signed fixed value */
s = (dsa->token == T_PLUS ? +1.0 : -1.0);
scan_token(dsa);
if (dsa->token == T_NUMBER)
{ set_lower_bound(dsa, j, s * dsa->value);
set_upper_bound(dsa, j, s * dsa->value);
scan_token(dsa);
}
else
fatal(dsa, "missing fixed value");
}
else if (dsa->token == T_NUMBER)
{ /* parse unsigned fixed value */
set_lower_bound(dsa, j, dsa->value);
set_upper_bound(dsa, j, dsa->value);
scan_token(dsa);
}
else
fatal(dsa, "missing fixed value");
}
else if (the_same(dsa->image, "free"))
{ /* parse the keyword 'free' */
if (lb_flag)
{ /* the context '... <= x free ...' is invalid */
fatal(dsa, "invalid bound definition");
}
set_lower_bound(dsa, j, -DBL_MAX);
set_upper_bound(dsa, j, +DBL_MAX);
scan_token(dsa);
}
else if (!lb_flag)
{ /* neither lower nor upper bounds are specified */
fatal(dsa, "invalid bound definition");
}
goto loop;
done: return;
}
void PROCEDURE_TIMER::set_upper_bound_seconds(double secs) {
struct timeval buf;
buf.tv_sec = static_cast<time_t>(floor(secs));
buf.tv_usec = static_cast<time_t>(1000000.0f * (secs - static_cast<double>(buf.tv_sec)));
set_upper_bound(&buf);
}