int engine(int numassets, int numfactors,
double *ub, double *lb, double *mu, double *sigma2,
double *V, double *F, double lambda)
{
int retcode = 0;
GRBenv *env = NULL;
GRBmodel *model = NULL;
int n, i, j, k;
double *x;
int *qrow, *qcol, Nq;
double *qval;
int *cind;
double rhs;
char sense;
double *cval;
int numnonz;
char **names, bigname[100];
double expectedreturnval;
printf("running solver engine\n");
n = numassets + numfactors;
retcode = GRBloadenv(&env, "engine.log");
if (retcode) goto BACK;
/* Create initial model */
retcode = GRBnewmodel(env, &model, "factors", n,
NULL, NULL, NULL, NULL, NULL);
if (retcode) goto BACK;
names = (char **) calloc(n, sizeof(char *));
/** next we create the remaining attributes for the n columns **/
x = (double *) calloc (n, sizeof(double));
for(j = 0; j < numassets; j++){
names[j] = (char *)calloc(3, sizeof(char));
if(names[j] == NULL){
retcode = 1; goto BACK;
}
sprintf(names[j],"x%d", j);
}
for(j = numassets; j < numassets + numfactors; j++){
names[j] = (char *)calloc(3, sizeof(char));
if(names[j] == NULL){
retcode = 1; goto BACK;
}
sprintf(names[j],"F%d", j - numassets);
}
/* initialize variables */
for(j = 0; j < n; j++){
retcode = GRBsetstrattrelement(model, "VarName", j, names[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "Obj", j, -mu[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "LB", j, lb[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "UB", j, ub[j]);
if (retcode) goto BACK;
}
/** next, the quadratic -- there are numassets + numfactors*numfactors nonzeroes:
numassets residual variances plus the numfactors x numfactors
factor covariance matrix**/
Nq = numassets + numfactors*numfactors;
qrow = (int *) calloc(Nq, sizeof(int)); /** row indices **/
qcol = (int *) calloc(Nq, sizeof(int)); /** column indices **/
qval = (double *) calloc(Nq, sizeof(double)); /** values **/
if( ( qrow == NULL) || ( qcol == NULL) || (qval == NULL) ){
printf("could not create quadratic\n");
retcode = 1; goto BACK;
}
for (j = 0; j < numassets; j++){
qval[j] = lambda*sigma2[j];
qrow[j] = qcol[j] = j;
}
for (i = 0; i < numfactors; i++){
for (j = 0; j < numfactors; j++){
k = i*numfactors + j;
qval[k + numassets] = lambda*F[k];
qrow[k + numassets] = numassets + i;
qcol[k + numassets] = numassets + j;
}
}
retcode = GRBaddqpterms(model, Nq, qrow, qcol, qval);
if (retcode) goto BACK;
/** now we will add one constraint at a time **/
/** we need to have a couple of auxiliary arrays **/
cind = (int *)calloc(n, sizeof(int)); /** n is over the top since no constraint is totally dense; but it's not too bad here **/
cval= (double *)calloc(n, sizeof(double));
if(!cval){
printf("cannot allocate cval\n"); retcode = 2; goto BACK;
}
for(i = 0; i < numfactors; i++){
for(j = 0; j < numassets; j++){
cval[j] = V[i*numassets + j];
cind[j] = j;
}
cind[numassets] = /* j */ numassets + i;
cval[numassets] = -1;
numnonz = numassets + 1;
rhs = 0;
sense = GRB_EQUAL;
sprintf(bigname,"factor%d",i);
retcode = GRBaddconstr(model, numnonz, cind, cval, sense, rhs, bigname);
if (retcode) goto BACK;
}
/** sum of x variables = 1 **/
for (j = 0; j < numassets; j++){
cval[j] = 1.0; cind[j] = j;
}
numnonz = numassets;
rhs = 1.0;
sense = GRB_EQUAL;
/* let's reuse some space */
sprintf(bigname, "sum");
retcode = GRBaddconstr(model, numnonz, cind, cval, sense, rhs, bigname);
if (retcode) goto BACK;
retcode = GRBupdatemodel(model);
if (retcode) goto BACK;
/** optional: write the problem **/
retcode = GRBwrite(model, "engine.lp");
if (retcode) goto BACK;
retcode = GRBoptimize(model);
if (retcode) goto BACK;
/** get solution **/
retcode = GRBgetdblattrarray(model,
GRB_DBL_ATTR_X, 0, n,
x);
if(retcode) goto BACK;
/** now let's see the values **/
expectedreturnval = 0;
for(j = 0; j < numassets; j++){
if( x[j] > 1.0e-09){
printf("%s = %g\n", names[j], x[j]);
expectedreturnval += x[j]*mu[j];
}
}
printf("\n*** expected portfolio return: %g\n", expectedreturnval);
GRBfreemodel(model);
GRBfreeenv(env);
BACK:
printf("engine exits with code %d\n", retcode);
return retcode;
}
void GurobiInterface::
eval(void* mem, const double** arg, double** res, int* iw, double* w) const {
auto m = static_cast<GurobiMemory*>(mem);
// Inputs
const double *h=arg[CONIC_H],
*g=arg[CONIC_G],
*a=arg[CONIC_A],
*lba=arg[CONIC_LBA],
*uba=arg[CONIC_UBA],
*lbx=arg[CONIC_LBX],
*ubx=arg[CONIC_UBX],
*x0=arg[CONIC_X0],
*lam_x0=arg[CONIC_LAM_X0];
// Outputs
double *x=res[CONIC_X],
*cost=res[CONIC_COST],
*lam_a=res[CONIC_LAM_A],
*lam_x=res[CONIC_LAM_X];
// Temporary memory
double *val=w; w+=nx_;
int *ind=iw; iw+=nx_;
int *ind2=iw; iw+=nx_;
int *tr_ind=iw; iw+=nx_;
// Greate an empty model
GRBmodel *model = 0;
try {
int flag = GRBnewmodel(m->env, &model, name_.c_str(), 0, 0, 0, 0, 0, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
// Add variables
for (int i=0; i<nx_; ++i) {
// Get bounds
double lb = lbx ? lbx[i] : 0., ub = ubx ? ubx[i] : 0.;
if (isinf(lb)) lb = -GRB_INFINITY;
if (isinf(ub)) ub = GRB_INFINITY;
// Get variable type
char vtype;
if (!vtype_.empty()) {
// Explicitly set 'vtype' takes precedence
vtype = vtype_.at(i);
} else if (!discrete_.empty() && discrete_.at(i)) {
// Variable marked as discrete (integer or binary)
vtype = lb==0 && ub==1 ? GRB_BINARY : GRB_INTEGER;
} else {
// Continious variable
vtype = GRB_CONTINUOUS;
}
// Pass to model
flag = GRBaddvar(model, 0, 0, 0, g ? g[i] : 0., lb, ub, vtype, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
flag = GRBupdatemodel(model);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
// Add quadratic terms
const int *H_colind=sparsity_in(CONIC_H).colind(), *H_row=sparsity_in(CONIC_H).row();
for (int i=0; i<nx_; ++i) {
// Quadratic term nonzero indices
int numqnz = H_colind[1]-H_colind[0];
casadi_copy(H_row, numqnz, ind);
H_colind++;
H_row += numqnz;
// Corresponding column
casadi_fill(ind2, numqnz, i);
// Quadratic term nonzeros
if (h) {
casadi_copy(h, numqnz, val);
casadi_scal(numqnz, 0.5, val);
h += numqnz;
} else {
casadi_fill(val, numqnz, 0.);
}
// Pass to model
flag = GRBaddqpterms(model, numqnz, ind, ind2, val);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
// Add constraints
const int *A_colind=sparsity_in(CONIC_A).colind(), *A_row=sparsity_in(CONIC_A).row();
casadi_copy(A_colind, nx_, tr_ind);
for (int i=0; i<na_; ++i) {
// Get bounds
double lb = lba ? lba[i] : 0., ub = uba ? uba[i] : 0.;
// if (isinf(lb)) lb = -GRB_INFINITY;
// if (isinf(ub)) ub = GRB_INFINITY;
// Constraint nonzeros
int numnz = 0;
for (int j=0; j<nx_; ++j) {
if (tr_ind[j]<A_colind[j+1] && A_row[tr_ind[j]]==i) {
ind[numnz] = j;
val[numnz] = a ? a[tr_ind[j]] : 0;
numnz++;
tr_ind[j]++;
}
}
// Pass to model
if (isinf(lb)) {
if (isinf(ub)) {
// Neither upper or lower bounds, skip
} else {
// Only upper bound
flag = GRBaddconstr(model, numnz, ind, val, GRB_LESS_EQUAL, ub, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
} else {
if (isinf(ub)) {
// Only lower bound
flag = GRBaddconstr(model, numnz, ind, val, GRB_GREATER_EQUAL, lb, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
} else if (lb==ub) {
// Upper and lower bounds equal
flag = GRBaddconstr(model, numnz, ind, val, GRB_EQUAL, lb, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
} else {
// Both upper and lower bounds
flag = GRBaddrangeconstr(model, numnz, ind, val, lb, ub, 0);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
}
}
// Solve the optimization problem
flag = GRBoptimize(model);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
int optimstatus;
flag = GRBgetintattr(model, GRB_INT_ATTR_STATUS, &optimstatus);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
// Get the objective value, if requested
if (cost) {
flag = GRBgetdblattr(model, GRB_DBL_ATTR_OBJVAL, cost);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
// Get the optimal solution, if requested
if (x) {
flag = GRBgetdblattrarray(model, GRB_DBL_ATTR_X, 0, nx_, x);
casadi_assert_message(!flag, GRBgeterrormsg(m->env));
}
// Free memory
GRBfreemodel(model);
} catch (...) {
// Free memory
if (model) GRBfreemodel(model);
throw;
}
}
int main(void)
{
int retcode = 0;
GRBenv *env = NULL;
GRBmodel *model = NULL;
int n, j;
double *obj = NULL;
double *lb = NULL;
double *ub = NULL;
double *x;
int *qrow, *qcol, Nq;
double *qval;
int *cind;
double rhs;
char sense;
double *cval;
int numnonz;
char **names;
n = 9; /** 7 'x' variables, 2 factor variables **/
retcode = GRBloadenv(&env, "factormodel.log");
if (retcode) goto BACK;
/* Create initial model */
retcode = GRBnewmodel(env, &model, "second", n,
NULL, NULL, NULL, NULL, NULL);
if (retcode) goto BACK;
names = (char **) calloc(n, sizeof(char *));
/** next we create the remaining attributes for the n columns **/
obj = (double *) calloc (n, sizeof(double));
ub = (double *) calloc (n, sizeof(double));
lb = (double *) calloc (n, sizeof(double));
x = (double *) calloc (n, sizeof(double));
for(j = 0; j < 7; j++){
names[j] = (char *)calloc(3, sizeof(char));
if(names[j] == NULL){
retcode = 1; goto BACK;
}
sprintf(names[j],"x%d", j);
}
for(j = 7; j < 9; j++){
names[j] = (char *)calloc(3, sizeof(char));
if(names[j] == NULL){
retcode = 1; goto BACK;
}
sprintf(names[j],"y%d", j - 7);
}
obj[0] = -.233; obj[1] = -3.422; obj[2] = -.1904; obj[3] = -.5411;
obj[4] = -.045; obj[5] = -1.271; obj[6] = -0.955;
/** calloc initializes memory to zero, so all other obj[j] are zero **/
/**next, the upper bounds on the x variables **/
ub[0] = 0.6; ub[1] = 0.8; ub[2] = 0.8; ub[3] = 0.5;
ub[4] = 0.5; ub[5] = 0.26; ub[6] = 0.99;
/** the upper bounds on the two factor variables -- we make them large **/
ub[7] = 100; ub[8] = 100;
/** the lower bounds on the factor variables **/
lb[7] = -100; lb[8] = -100;
/* initialize variables */
for(j = 0; j < n; j++){
retcode = GRBsetstrattrelement(model, "VarName", j, names[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "Obj", j, obj[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "LB", j, lb[j]);
if (retcode) goto BACK;
retcode = GRBsetdblattrelement(model, "UB", j, ub[j]);
if (retcode) goto BACK;
}
/** next, the quadratic -- there are 11 nonzeroes: 7 residual variances plus the 2x2
factor covariance matrix**/
Nq = 11;
qrow = (int *) calloc(Nq, sizeof(int)); /** row indices **/
qcol = (int *) calloc(Nq, sizeof(int)); /** column indices **/
qval = (double *) calloc(Nq, sizeof(double)); /** values **/
if( ( qrow == NULL) || ( qcol == NULL) || (qval == NULL) ){
printf("could not create quadratic\n");
retcode = 1; goto BACK;
}
qval[0] = 10.0; qrow[0] = 0; qcol[0] = 0;
qval[1] = 20.0; qrow[1] = 1; qcol[1] = 1;
qval[2] = 30.0; qrow[2] = 2; qcol[2] = 2;
qval[3] = 40.0; qrow[3] = 3; qcol[3] = 3;
qval[4] = 50.0; qrow[4] = 4; qcol[4] = 4;
qval[5] = 60.0; qrow[5] = 5; qcol[5] = 5;
qval[6] = 70.0; qrow[6] = 6; qcol[6] = 6;
qval[7] = 100.0; qrow[7] = 7; qcol[7] = 7;
qval[8] = 200.0; qrow[8] = 8; qcol[8] = 8;
qval[9] = 0.1; qrow[9] = 7; qcol[9] = 8;
qval[10] = 0.1; qrow[10] = 8; qcol[10] = 7;
retcode = GRBaddqpterms(model, 11, qrow, qcol, qval);
if (retcode) goto BACK;
/** now we will add one constraint at a time **/
/** we need to have a couple of auxiliary arrays **/
cind = (int *)calloc(n, sizeof(int)); /** n is over the top since no constraint is totally dense;
but it's not too bad here **/
cval= (double *)calloc(n, sizeof(double));
/** two factor constraints, first one is next**/
cval[0] = 1.508; cval[1] = .7802; cval[2] = 1.8796;
cval[3] = 4.256; cval[4] = 1.335; cval[5] = 2.026; cval[6] = 1.909;
cval[7] = -1;
for(j = 0; j < 7; j++) cind[j] = j;
cind[7] = 7;
numnonz = 8;
rhs = 0;
sense = GRB_EQUAL;
retcode = GRBaddconstr(model, numnonz, cind, cval, sense, rhs, "first_constraint");
if (retcode) goto BACK;
/** second factor constraint **/
cval[0] = 4.228; cval[1] = 1.2945; cval[2] = .827;
cval[3] = 2.149;
cval[4] = 2.353; cval[5] = 0.3026; cval[6] = 1.487;
cval[7] = -1;
for(j = 0; j < 7; j++) cind[j] = j; /** redundant! but let's keep it here so that we know it
will be used **/
cind[7] = 7;
numnonz = 8;
rhs = 0;
sense = GRB_EQUAL;
retcode = GRBaddconstr(model, numnonz, cind, cval, sense, rhs, "second_constraint");
if (retcode) goto BACK;
/** sum of x variables = 1 **/
cval[0] = 1.0; cval[1] = 1.0; cval[2] = 1.0;
cval[3] = 1.0; cval[4] = 1.0; cval[5] = 1.0; cval[6] = 1.0;
for(j = 0; j < 7; j++) cind[j] = j;
numnonz = 7;
rhs = 1.0;
sense = GRB_EQUAL;
retcode = GRBaddconstr(model, numnonz, cind, cval, sense, rhs, "convexity");
if (retcode) goto BACK;
retcode = GRBupdatemodel(model);
if (retcode) goto BACK;
/** optional: write the problem **/
retcode = GRBwrite(model, "factorqp.lp");
if (retcode) goto BACK;
retcode = GRBoptimize(model);
if (retcode) goto BACK;
/** get solution **/
retcode = GRBgetdblattrarray(model,
GRB_DBL_ATTR_X, 0, n,
x);
if(retcode) goto BACK;
/** now let's see the values **/
for(j = 0; j < n; j++){
printf("%s = %g\n", names[j], x[j]);
}
GRBfreemodel(model);
GRBfreeenv(env);
BACK:
printf("\nexiting with retcode %d\n", retcode);
return retcode;
}
