int LoadBalancing::lp_solve_model() {
//Returns 0 when an optimal solution is found,
//returns 1 if the solution is suboptimal due to an overlap constraint, and we should use fewer nodes
//returns 2 when a suboptimal solution is found (solver timed out)
//returns 3 if another error occurred
int ret;
int Ncol=3*num_using_nodes_+(num_using_nodes_-1)*(num_quantiles_+2);
REAL *vars = (REAL*)malloc(Ncol*sizeof(REAL));
set_verbose(lp, IMPORTANT);
set_timeout(lp, solver_timeout_);
default_basis(lp);
ret = solve(lp);
if(ret==1){
fprintf(stderr, "lp_solve: Suboptimal solution (solver timed out)\n");
return 2;
}
if(ret!=0 && ret!=1){
fprintf(stderr, "lp_solve: Solution not found\n");
return 3;
}
print_solution(lp, 3);
get_variables(lp, vars);
//Cutvector:
optimal_cutvector_.resize(num_using_nodes_);
for(int i=0;i<num_using_nodes_;i++){
optimal_cutvector_.at(i)=round(width_*vars[i]);
}
//Estimated completion time:
est_completion_time_=(float)vars[num_using_nodes_];
/* printf("\nOptimal cutvector:\n");
for(int i=0;i<num_using_nodes_;i++){
printf("%d\n", optimal_cutvector_.at(i));
}
printf("Estimated completion time: %f\n", est_completion_time_);
*/
//If the first cut is 0, that would be an indication that the cutvector we obtained is suboptimal,
//due to the overlap constraint.
//We should most likely use fewer nodes.
if(optimal_cutvector_.front()==0){
fprintf(stderr, "lp_solve: Suboptimal solution (first cut was 0), we should use fewer processing nodes\n");
return 1;
}
free(vars);
return ret;
}
std::optional<Vector> LP::solve(const size_t variables, double * objective) {
auto lp = pimpl_->lp_.get();
// lp_solve uses the result of the previous runs to bootstrap
// the new solution. Sometimes this breaks down for some reason,
// so we just avoid it - it does not really even give a performance
// boost..
default_basis(lp);
// print_lp(pimpl_->lp_.get());
const auto result = ::solve(lp);
REAL * vp;
get_ptr_variables(lp, &vp);
if (objective)
*objective = get_objective(lp);
std::optional<Vector> solution;
if ( result == 0 || result == 1 )
solution = Eigen::Map<Vector>(vp, variables);
return solution;
}
int demoImplicit(void)
{
# if defined ERROR
# undef ERROR
# endif
# define ERROR() { fprintf(stderr, "Error\n"); return(1); }
lprec *lp;
int majorversion, minorversion, release, build;
char buf[1024];
if ((lp = make_lp(0,4)) == NULL)
ERROR();
lp_solve_version(&majorversion, &minorversion, &release, &build);
/* let's first demonstrate the logfunc callback feature */
put_logfunc(lp, Mylogfunc, 0);
sprintf(buf, "lp_solve %d.%d.%d.%d demo\n\n", majorversion, minorversion, release, build);
print_str(lp, buf);
solve(lp); /* just to see that a message is send via the logfunc routine ... */
/* ok, that is enough, no more callback */
put_logfunc(lp, NULL, 0);
/* Now redirect all output to a file */
/* set_outputfile(lp, "result.txt"); */
/* set an abort function. Again optional */
put_abortfunc(lp, Myctrlcfunc, 0);
/* set a message function. Again optional */
put_msgfunc(lp, Mymsgfunc, 0, MSG_PRESOLVE | MSG_LPFEASIBLE | MSG_LPOPTIMAL | MSG_MILPEQUAL | MSG_MILPFEASIBLE | MSG_MILPBETTER);
printf("lp_solve %d.%d.%d.%d demo\n\n", majorversion, minorversion, release, build);
printf("This demo will show most of the features of lp_solve %d.%d.%d.%d\n", majorversion, minorversion, release, build);
press_ret();
printf("\nWe start by creating a new problem with 4 variables and 0 constraints\n");
printf("We use: lp=make_lp(0,4);\n");
press_ret();
printf("We can show the current problem with print_lp(lp)\n");
print_lp(lp);
press_ret();
printf("Now we add some constraints\n");
printf("str_add_constraint(lp, \"3 2 2 1\" ,LE,4)\n");
printf("This is the string version of add_constraint. For the normal version\n");
printf("of add_constraint see the help file.\n");
if (!str_add_constraint(lp, "3 2 2 1", LE, 4))
ERROR();
print_lp(lp);
press_ret();
printf("str_add_constraint(lp, \"0 4 3 1\" ,GE,3)\n");
if (!str_add_constraint(lp, "0 4 3 1", GE, 3))
ERROR();
print_lp(lp);
press_ret();
printf("Set the objective function\n");
printf("str_set_obj_fn(lp, \"2 3 -2 3\")\n");
if (!str_set_obj_fn(lp, "2 3 -2 3"))
ERROR();
print_lp(lp);
press_ret();
printf("Now solve the problem with printf(solve(lp));\n");
printf("%d",solve(lp));
press_ret();
printf("The value is 0, this means we found an optimal solution\n");
printf("We can display this solution with print_objective(lp) and print_solution(lp)\n");
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("The dual variables of the solution are printed with\n");
printf("print_duals(lp);\n");
print_duals(lp);
press_ret();
printf("We can change a single element in the matrix with\n");
printf("set_mat(lp,2,1,0.5)\n");
if (!set_mat(lp,2,1,0.5))
ERROR();
print_lp(lp);
press_ret();
printf("If we want to maximize the objective function use set_maxim(lp);\n");
set_maxim(lp);
print_lp(lp);
press_ret();
printf("after solving this gives us:\n");
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
print_duals(lp);
press_ret();
printf("Change the value of a rhs element with set_rh(lp,1,7.45)\n");
set_rh(lp,1,7.45);
print_lp(lp);
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("We change %s to the integer type with\n", get_col_name(lp, 4));
printf("set_int(lp, 4, TRUE)\n");
set_int(lp, 4, TRUE);
print_lp(lp);
printf("We set branch & bound debugging on with set_debug(lp, TRUE)\n");
set_debug(lp, TRUE);
printf("and solve...\n");
press_ret();
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("We can set bounds on the variables with\n");
printf("set_lowbo(lp,2,2); & set_upbo(lp,4,5.3)\n");
set_lowbo(lp,2,2);
set_upbo(lp,4,5.3);
print_lp(lp);
press_ret();
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("Now remove a constraint with del_constraint(lp, 1)\n");
del_constraint(lp,1);
print_lp(lp);
printf("Add an equality constraint\n");
if (!str_add_constraint(lp, "1 2 1 4", EQ, 8))
ERROR();
print_lp(lp);
press_ret();
printf("A column can be added with:\n");
printf("str_add_column(lp,\"3 2 2\");\n");
if (!str_add_column(lp,"3 2 2"))
ERROR();
print_lp(lp);
press_ret();
printf("A column can be removed with:\n");
printf("del_column(lp,3);\n");
del_column(lp,3);
print_lp(lp);
press_ret();
printf("We can use automatic scaling with:\n");
printf("set_scaling(lp, SCALE_MEAN);\n");
set_scaling(lp, SCALE_MEAN);
print_lp(lp);
press_ret();
printf("The function get_mat(lprec *lp, int row, int column) returns a single\n");
printf("matrix element\n");
printf("%s get_mat(lp,2,3), get_mat(lp,1,1); gives\n","printf(\"%f %f\\n\",");
printf("%f %f\n", (double)get_mat(lp,2,3), (double)get_mat(lp,1,1));
printf("Notice that get_mat returns the value of the original unscaled problem\n");
press_ret();
printf("If there are any integer type variables, then only the rows are scaled\n");
printf("set_scaling(lp, SCALE_MEAN);\n");
set_scaling(lp, SCALE_MEAN);
printf("set_int(lp,3,FALSE);\n");
set_int(lp,3,FALSE);
print_lp(lp);
press_ret();
solve(lp);
printf("print_objective, print_solution gives the solution to the original problem\n");
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("Scaling is turned off with unscale(lp);\n");
unscale(lp);
print_lp(lp);
press_ret();
printf("Now turn B&B debugging off and simplex tracing on with\n");
printf("set_debug(lp, FALSE), set_trace(lp, TRUE) and solve(lp)\n");
set_debug(lp, FALSE);
set_trace(lp, TRUE);
press_ret();
solve(lp);
printf("Where possible, lp_solve will start at the last found basis\n");
printf("We can reset the problem to the initial basis with\n");
printf("default_basis(lp). Now solve it again...\n");
press_ret();
default_basis(lp);
solve(lp);
printf("It is possible to give variables and constraints names\n");
printf("set_row_name(lp,1,\"speed\"); & set_col_name(lp,2,\"money\")\n");
if (!set_row_name(lp,1,"speed"))
ERROR();
if (!set_col_name(lp,2,"money"))
ERROR();
print_lp(lp);
printf("As you can see, all column and rows are assigned default names\n");
printf("If a column or constraint is deleted, the names shift place also:\n");
press_ret();
printf("del_column(lp,1);\n");
del_column(lp,1);
print_lp(lp);
press_ret();
delete_lp(lp);
/*
printf("A lp structure can be created and read from a .lp file\n");
printf("lp = read_LP(\"lp_examples/demo_lag.lp\", TRUE);\n");
printf("The verbose option is used\n");
if ((lp = read_LP("lp_examples/demo_lag.lp", TRUE, "test")) == NULL)
ERROR();
press_ret();
printf("lp is now:\n");
print_lp(lp);
press_ret();
printf("solution:\n");
set_debug(lp, TRUE);
solve(lp);
set_debug(lp, FALSE);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("You can see that branch & bound was used in this problem\n");
printf("Now remove the last constraint and use lagrangian relaxation\n");
printf("del_constraint(lp,6);\n");
printf("str_add_lag_con(lp, \"1 1 1 0 0 0\", LE, 2);\n");
del_constraint(lp,6);
if (!str_add_lag_con(lp, "1 1 1 0 0 0", LE, 2))
ERROR();
print_lp(lp);
*/
/*
printf("Lagrangian relaxation is used in some heuristics. It is now possible\n");
printf("to get a feasible integer solution without usage of branch & bound.\n");
printf("Use lag_solve(lp, 0, 30); 0 is the initial bound, 30 the maximum\n");
printf("number of iterations, the last variable turns the verbose mode on.\n");
press_ret();
set_lag_trace(lp, TRUE);
printf("%d\n",lag_solve(lp, 0, 30));
printf("The returncode of lag_solve is 6 or FEAS_FOUND. this means that a feasible\n");
printf("solution has been found. For a list of other possible return values\n");
printf("see the help file. Print this solution with print_objective, print_solution\n");
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
delete_lp(lp);
*/
press_ret();
return(0);
}
int main ( int argv, char * argc[] )
{
# if defined ERROR
# undef ERROR
# endif
# define ERROR() { fprintf(stderr, "Error\n"); exit(1); }
lprec *lp;
int majorversion, minorversion, release, build;
#if defined FORTIFY
Fortify_EnterScope();
#endif
lp_solve_version(&majorversion, &minorversion, &release, &build);
printf("lp_solve %d.%d.%d.%d demo\n\n", majorversion, minorversion, release, build);
printf("This demo will show most of the features of lp_solve %d.%d.%d.%d\n", majorversion, minorversion, release, build);
press_ret();
printf("\nWe start by creating a new problem with 4 variables and 0 constraints\n");
printf("We use: lp=make_lp(0,4);\n");
if ((lp = make_lp(0,4)) == NULL)
ERROR();
press_ret();
printf("We can show the current problem with print_lp(lp)\n");
print_lp(lp);
press_ret();
printf("Now we add some constraints\n");
printf("add_constraint(lp, {0, 3, 2, 2, 1}, LE, 4)\n");
{
double row[] = {0, 3, 2, 2, 1};
if (!add_constraint(lp, row, LE, 4))
ERROR();
}
print_lp(lp);
press_ret();
printf("add_constraintex is now used to add a row. Only the npn-zero values must be specfied with this call.\n");
printf("add_constraintex(lp, 3, {4, 3, 1}, {2, 3, 4}, GE, 3)\n");
{
int colno[] = {2, 3, 4};
double row[] = {4, 3, 1};
if (!add_constraintex(lp, sizeof(colno) / sizeof(*colno), row, colno, GE, 3))
ERROR();
}
print_lp(lp);
press_ret();
printf("Set the objective function\n");
printf("set_obj_fn(lp, {0, 2, 3, -2, 3})\n");
{
double row[] = {0, 2, 3, -2, 3};
if (!set_obj_fn(lp, row))
ERROR();
}
print_lp(lp);
press_ret();
printf("Now solve the problem with printf(solve(lp));\n");
printf("%d",solve(lp));
press_ret();
printf("The value is 0, this means we found an optimal solution\n");
printf("We can display this solution with print_objective(lp) and print_solution(lp)\n");
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("The dual variables of the solution are printed with\n");
printf("print_duals(lp);\n");
print_duals(lp);
press_ret();
printf("We can change a single element in the matrix with\n");
printf("set_mat(lp,2,1,0.5)\n");
if (!set_mat(lp,2,1,0.5))
ERROR();
print_lp(lp);
press_ret();
printf("If we want to maximize the objective function use set_maxim(lp);\n");
set_maxim(lp);
print_lp(lp);
press_ret();
printf("after solving this gives us:\n");
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
print_duals(lp);
press_ret();
printf("Change the value of a rhs element with set_rh(lp,1,7.45)\n");
set_rh(lp,1,7.45);
print_lp(lp);
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("We change %s to the integer type with\n", get_col_name(lp, 4));
printf("set_int(lp, 4, TRUE)\n");
set_int(lp, 4, TRUE);
print_lp(lp);
printf("We set branch & bound debugging on with set_debug(lp, TRUE)\n");
set_debug(lp, TRUE);
printf("and solve...\n");
press_ret();
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("We can set bounds on the variables with\n");
printf("set_lowbo(lp,2,2); & set_upbo(lp,4,5.3)\n");
set_lowbo(lp,2,2);
set_upbo(lp,4,5.3);
print_lp(lp);
press_ret();
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("Now remove a constraint with del_constraint(lp, 1)\n");
del_constraint(lp,1);
print_lp(lp);
printf("Add an equality constraint\n");
{
double row[] = {0, 1, 2, 1, 4};
if (!add_constraint(lp, row, EQ, 8))
ERROR();
}
print_lp(lp);
press_ret();
printf("A column can be added with:\n");
printf("add_column(lp,{3, 2, 2});\n");
{
double col[] = {3, 2, 2};
if (!add_column(lp, col))
ERROR();
}
print_lp(lp);
press_ret();
printf("A column can be removed with:\n");
printf("del_column(lp,3);\n");
del_column(lp,3);
print_lp(lp);
press_ret();
printf("We can use automatic scaling with:\n");
printf("set_scaling(lp, SCALE_MEAN);\n");
set_scaling(lp, SCALE_MEAN);
print_lp(lp);
press_ret();
printf("The function get_mat(lprec *lp, int row, int column) returns a single\n");
printf("matrix element\n");
printf("%s get_mat(lp,2,3), get_mat(lp,1,1); gives\n","printf(\"%f %f\\n\",");
printf("%f %f\n", (double)get_mat(lp,2,3), (double)get_mat(lp,1,1));
printf("Notice that get_mat returns the value of the original unscaled problem\n");
press_ret();
printf("If there are any integer type variables, then only the rows are scaled\n");
printf("set_scaling(lp, SCALE_MEAN);\n");
set_scaling(lp, SCALE_MEAN);
printf("set_int(lp,3,FALSE);\n");
set_int(lp,3,FALSE);
print_lp(lp);
press_ret();
solve(lp);
printf("print_objective, print_solution gives the solution to the original problem\n");
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
printf("Scaling is turned off with unscale(lp);\n");
unscale(lp);
print_lp(lp);
press_ret();
printf("Now turn B&B debugging off and simplex tracing on with\n");
printf("set_debug(lp, FALSE), set_trace(lp, TRUE) and solve(lp)\n");
set_debug(lp, FALSE);
set_trace(lp, TRUE);
press_ret();
solve(lp);
printf("Where possible, lp_solve will start at the last found basis\n");
printf("We can reset the problem to the initial basis with\n");
printf("default_basis(lp). Now solve it again...\n");
press_ret();
default_basis(lp);
solve(lp);
printf("It is possible to give variables and constraints names\n");
printf("set_row_name(lp,1,\"speed\"); & set_col_name(lp,2,\"money\")\n");
if (!set_row_name(lp,1,"speed"))
ERROR();
if (!set_col_name(lp,2,"money"))
ERROR();
print_lp(lp);
printf("As you can see, all column and rows are assigned default names\n");
printf("If a column or constraint is deleted, the names shift place also:\n");
press_ret();
printf("del_column(lp,1);\n");
del_column(lp,1);
print_lp(lp);
press_ret();
write_lp(lp, "lp.lp");
delete_lp(lp);
printf("An lp structure can be created and read from a .lp file\n");
printf("lp = read_lp(\"lp.lp\", TRUE);\n");
printf("The verbose option is used\n");
if ((lp = read_LP("lp.lp", TRUE, "test")) == NULL)
ERROR();
press_ret();
printf("lp is now:\n");
print_lp(lp);
press_ret();
printf("solution:\n");
set_debug(lp, TRUE);
solve(lp);
set_debug(lp, FALSE);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
press_ret();
delete_lp(lp);
#if defined FORTIFY
Fortify_LeaveScope();
#endif
return 0;
}
MYBOOL crash_basis(lprec *lp)
{
int i;
MATrec *mat = lp->matA;
MYBOOL ok = TRUE;
/* Initialize basis indicators */
if(lp->basis_valid)
lp->var_basic[0] = FALSE;
else
default_basis(lp);
/* Set initial partial pricing blocks */
if(lp->rowblocks != NULL)
lp->rowblocks->blocknow = 1;
if(lp->colblocks != NULL)
lp->colblocks->blocknow = ((lp->crashmode == CRASH_NONE) || (lp->colblocks->blockcount == 1) ? 1 : 2);
/* Construct a basis that is in some measure the "most feasible" */
if((lp->crashmode == CRASH_MOSTFEASIBLE) && mat_validate(mat)) {
/* The logic here follows Maros */
LLrec *rowLL = NULL, *colLL = NULL;
int ii, rx, cx, ix, nz;
REAL wx, tx, *rowMAX = NULL, *colMAX = NULL;
int *rowNZ = NULL, *colNZ = NULL, *rowWT = NULL, *colWT = NULL;
REAL *value;
int *rownr, *colnr;
report(lp, NORMAL, "crash_basis: 'Most feasible' basis crashing selected\n");
/* Tally row and column non-zero counts */
ok = allocINT(lp, &rowNZ, lp->rows+1, TRUE) &&
allocINT(lp, &colNZ, lp->columns+1, TRUE) &&
allocREAL(lp, &rowMAX, lp->rows+1, FALSE) &&
allocREAL(lp, &colMAX, lp->columns+1, FALSE);
if(!ok)
goto Finish;
nz = mat_nonzeros(mat);
rownr = &COL_MAT_ROWNR(0);
colnr = &COL_MAT_COLNR(0);
value = &COL_MAT_VALUE(0);
for(i = 0; i < nz;
i++, rownr += matRowColStep, colnr += matRowColStep, value += matValueStep) {
rx = *rownr;
cx = *colnr;
wx = fabs(*value);
rowNZ[rx]++;
colNZ[cx]++;
if(i == 0) {
rowMAX[rx] = wx;
colMAX[cx] = wx;
colMAX[0] = wx;
}
else {
SETMAX(rowMAX[rx], wx);
SETMAX(colMAX[cx], wx);
SETMAX(colMAX[0], wx);
}
}
/* Reduce counts for small magnitude to preserve stability */
rownr = &COL_MAT_ROWNR(0);
colnr = &COL_MAT_COLNR(0);
value = &COL_MAT_VALUE(0);
for(i = 0; i < nz;
i++, rownr += matRowColStep, colnr += matRowColStep, value += matValueStep) {
rx = *rownr;
cx = *colnr;
wx = fabs(*value);
#ifdef CRASH_SIMPLESCALE
if(wx < CRASH_THRESHOLD * colMAX[0]) {
rowNZ[rx]--;
colNZ[cx]--;
}
#else
if(wx < CRASH_THRESHOLD * rowMAX[rx])
rowNZ[rx]--;
if(wx < CRASH_THRESHOLD * colMAX[cx])
colNZ[cx]--;
#endif
}
/* Set up priority tables */
ok = allocINT(lp, &rowWT, lp->rows+1, TRUE);
createLink(lp->rows, &rowLL, NULL);
ok &= (rowLL != NULL);
if(!ok)
goto Finish;
for(i = 1; i <= lp->rows; i++) {
if(get_constr_type(lp, i)==EQ)
ii = 3;
else if(lp->upbo[i] < lp->infinite)
ii = 2;
else if(fabs(lp->rhs[i]) < lp->infinite)
ii = 1;
else
ii = 0;
rowWT[i] = ii;
if(ii > 0)
appendLink(rowLL, i);
}
ok = allocINT(lp, &colWT, lp->columns+1, TRUE);
createLink(lp->columns, &colLL, NULL);
ok &= (colLL != NULL);
if(!ok)
goto Finish;
for(i = 1; i <= lp->columns; i++) {
ix = lp->rows+i;
if(is_unbounded(lp, i))
ii = 3;
else if(lp->upbo[ix] >= lp->infinite)
ii = 2;
else if(fabs(lp->upbo[ix]-lp->lowbo[ix]) > lp->epsmachine)
ii = 1;
else
ii = 0;
colWT[i] = ii;
if(ii > 0)
appendLink(colLL, i);
}
/* Loop over all basis variables */
for(i = 1; i <= lp->rows; i++) {
/* Select row */
rx = 0;
wx = -lp->infinite;
for(ii = firstActiveLink(rowLL); ii > 0; ii = nextActiveLink(rowLL, ii)) {
tx = rowWT[ii] - CRASH_SPACER*rowNZ[ii];
if(tx > wx) {
rx = ii;
wx = tx;
}
}
if(rx == 0)
break;
removeLink(rowLL, rx);
/* Select column */
cx = 0;
wx = -lp->infinite;
for(ii = mat->row_end[rx-1]; ii < mat->row_end[rx]; ii++) {
/* Update NZ column counts for row selected above */
tx = fabs(ROW_MAT_VALUE(ii));
ix = ROW_MAT_COLNR(ii);
#ifdef CRASH_SIMPLESCALE
if(tx >= CRASH_THRESHOLD * colMAX[0])
#else
if(tx >= CRASH_THRESHOLD * colMAX[ix])
#endif
colNZ[ix]--;
if(!isActiveLink(colLL, ix) || (tx < CRASH_THRESHOLD * rowMAX[rx]))
continue;
/* Now do the test for best pivot */
tx = my_sign(lp->orig_obj[ix]) - my_sign(ROW_MAT_VALUE(ii));
tx = colWT[ix] + CRASH_WEIGHT*tx - CRASH_SPACER*colNZ[ix];
if(tx > wx) {
cx = ix;
wx = tx;
}
}
if(cx == 0)
break;
removeLink(colLL, cx);
/* Update row NZ counts */
ii = mat->col_end[cx-1];
rownr = &COL_MAT_ROWNR(ii);
value = &COL_MAT_VALUE(ii);
for(; ii < mat->col_end[cx];
ii++, rownr += matRowColStep, value += matValueStep) {
wx = fabs(*value);
ix = *rownr;
#ifdef CRASH_SIMPLESCALE
if(wx >= CRASH_THRESHOLD * colMAX[0])
#else
if(wx >= CRASH_THRESHOLD * rowMAX[ix])
#endif
rowNZ[ix]--;
}
/* Set new basis variable */
set_basisvar(lp, rx, lp->rows+cx);
}
/* Clean up */
Finish:
FREE(rowNZ);
FREE(colNZ);
FREE(rowMAX);
FREE(colMAX);
FREE(rowWT);
FREE(colWT);
freeLink(&rowLL);
freeLink(&colLL);
}
/* Construct a basis that is in some measure the "least degenerate" */
else if((lp->crashmode == CRASH_LEASTDEGENERATE) && mat_validate(mat)) {
/* The logic here follows Maros */
LLrec *rowLL = NULL, *colLL = NULL;
int ii, rx, cx, ix, nz, *merit = NULL;
REAL *value, wx, hold, *rhs = NULL, *eta = NULL;
int *rownr, *colnr;
report(lp, NORMAL, "crash_basis: 'Least degenerate' basis crashing selected\n");
/* Create temporary arrays */
ok = allocINT(lp, &merit, lp->columns + 1, FALSE) &&
allocREAL(lp, &eta, lp->rows + 1, FALSE) &&
allocREAL(lp, &rhs, lp->rows + 1, FALSE);
createLink(lp->columns, &colLL, NULL);
createLink(lp->rows, &rowLL, NULL);
ok &= (colLL != NULL) && (rowLL != NULL);
if(!ok)
goto FinishLD;
MEMCOPY(rhs, lp->orig_rhs, lp->rows + 1);
for(i = 1; i <= lp->columns; i++)
appendLink(colLL, i);
for(i = 1; i <= lp->rows; i++)
appendLink(rowLL, i);
/* Loop until we have found enough new bases */
while(colLL->count > 0) {
/* Tally non-zeros matching in RHS and each active column */
nz = mat_nonzeros(mat);
rownr = &COL_MAT_ROWNR(0);
colnr = &COL_MAT_COLNR(0);
ii = 0;
MEMCLEAR(merit, lp->columns + 1);
for(i = 0; i < nz;
i++, rownr += matRowColStep, colnr += matRowColStep) {
rx = *rownr;
cx = *colnr;
if(isActiveLink(colLL, cx) && (rhs[rx] != 0)) {
merit[cx]++;
ii++;
}
}
if(ii == 0)
break;
/* Find maximal match; break ties with column length */
i = firstActiveLink(colLL);
cx = i;
for(i = nextActiveLink(colLL, i); i != 0; i = nextActiveLink(colLL, i)) {
if(merit[i] >= merit[cx]) {
if((merit[i] > merit[cx]) || (mat_collength(mat, i) > mat_collength(mat, cx)))
cx = i;
}
}
/* Determine the best pivot row */
i = mat->col_end[cx-1];
nz = mat->col_end[cx];
rownr = &COL_MAT_ROWNR(i);
value = &COL_MAT_VALUE(i);
rx = 0;
wx = 0;
MEMCLEAR(eta, lp->rows + 1);
for(; i < nz;
i++, rownr += matRowColStep, value += matValueStep) {
ix = *rownr;
hold = *value;
eta[ix] = rhs[ix] / hold;
hold = fabs(hold);
if(isActiveLink(rowLL, ix) && (hold > wx)) {
wx = hold;
rx = ix;
}
}
/* Set new basis variable */
if(rx > 0) {
/* We have to update the rhs vector for the implied transformation
in order to be able to find the new RHS non-zero pattern */
for(i = 1; i <= lp->rows; i++)
rhs[i] -= wx * eta[i];
rhs[rx] = wx;
/* Do the exchange */
set_basisvar(lp, rx, lp->rows+cx);
removeLink(rowLL, rx);
}
removeLink(colLL, cx);
}
/* Clean up */
FinishLD:
FREE(merit);
FREE(rhs);
freeLink(&rowLL);
freeLink(&colLL);
}
return( ok );
}
