char *var_make_xname(const struct var_variable *var)
{
static char name[81];
char *res;
sprintf(name,"x%d",var_sindex(var));
res=ASC_NEW_ARRAY(char,strlen(name)+1);
sprintf(res,"%s",name);
return res;
}
//-------------------------------------------------------------------------
void Prg_ASCEND::setup()
{
int n, me, m;
int i, j, row_idx, idx;
SPMAT *J;
int nincidences;
const struct var_variable **incidences;
// obtain ASCEND system
// todo: should check that system can be solved with HQP (e.g. no integers)
_nvars = slv_get_num_solvers_vars(_slv_system);
_vars = slv_get_solvers_var_list(_slv_system);
_nrels = slv_get_num_solvers_rels(_slv_system);
_rels = slv_get_solvers_rel_list(_slv_system);
_obj = slv_get_obj_relation(_slv_system);
// count number of optimization variables and bounds
_var_lb = v_resize(_var_lb, _nvars);
_var_ub = v_resize(_var_ub, _nvars);
_var_asc2hqp = iv_resize(_var_asc2hqp, _nvars);
_derivatives = v_resize(_derivatives, _nvars);
_var_master_idxs = iv_resize(_var_master_idxs, _nvars);
_var_solver_idxs = iv_resize(_var_solver_idxs, _nvars);
n = 0;
me = 0;
m = 0;
for (i = 0; i < _nvars; i++) {
_var_lb[i] = var_lower_bound(_vars[i]);
_var_ub[i] = var_upper_bound(_vars[i]);
/*
var_write_name(_slv_system, _vars[i], stderr);
fprintf(stderr, ":\t%i,\t%g,\t%g\n", var_fixed(_vars[i]),
_var_lb[i], _var_ub[i]);
*/
if (var_fixed(_vars[i])) {
_var_asc2hqp[i] = -1;
}
else {
_var_asc2hqp[i] = n++;
if (_var_lb[i] == _var_ub[i])
++me;
else {
if (_var_lb[i] > -_Inf)
++m;
if (_var_ub[i] < _Inf)
++m;
}
}
}
// consider bounds as linear constraints (i.e. no Jacobian update)
_me_bounds = me;
_m_bounds = m;
// count number of HQP constraints
for (i = 0; i < _nrels; i++) {
if (rel_equal(_rels[i]))
++me; // equality constraint
else
++m; // inequality constraint
}
// allocate QP approximation and optimization variables vector
_qp->resize(n, me, m);
_x = v_resize(_x, n);
// allocate sparse structure for bounds
// (write constant elements in Jacobians)
me = m = 0;
for (i = 0; i < _nvars; i++) {
idx = _var_asc2hqp[i];
if (idx < 0)
continue;
if (_var_lb[i] == _var_ub[i]) {
row_idx = me++;
sp_set_val(_qp->A, row_idx, idx, 1.0);
}
else {
if (_var_lb[i] > -_Inf) {
row_idx = m++;
sp_set_val(_qp->C, row_idx, idx, 1.0);
}
if (_var_ub[i] < _Inf) {
row_idx = m++;
sp_set_val(_qp->C, row_idx, idx, -1.0);
}
}
}
// allocate sparse structure for general constraints
// (just insert dummy values; actual values are set in update method)
for (i = 0; i < _nrels; i++) {
if (rel_equal(_rels[i])) {
row_idx = me++;
J = _qp->A;
}
else {
row_idx = m++;
J = _qp->C;
}
nincidences = rel_n_incidences(_rels[i]);
incidences = rel_incidence_list(_rels[i]);
for (j = 0; j < nincidences; j++) {
idx = _var_asc2hqp[var_sindex(incidences[j])];
if (idx >= 0)
sp_set_val(J, row_idx, idx, 1.0);
}
}
// todo: setup sparse structure of Hessian
// for now initialize something resulting in dense BFGS update
for (j = 0; j < n-1; j++) {
sp_set_val(_qp->Q, j, j, 0.0);
sp_set_val(_qp->Q, j, j+1, 0.0);
}
sp_set_val(_qp->Q, j, j, 0.0);
}
