LinearProgram::Result RegularizedLinearProgram::Solve(Vector& x)
{
RobustLPSolver lps;
lps.verbose = verbose;
lps.UpdateGLPK(lp);
LinearProgram::Result res= lps.SolveGLPK();
if(res==LinearProgram::Feasible) {
x.resize(C.n);
lps.xopt.getSubVectorCopy(0,x);
}
return res;
}
LinearProgram::Result MinNormProblem::Solve(Vector& x)
{
if(norm == 2) {
Assert(IsValid());
if(HasInequalities()) { //must use quadratic program for inequalities
Assert(qp.Pobj.m == C.n);
Assert(qp.A.isRef());
/*
QPActiveSetSolver solver(qp);
solver.verbose = verbose;
ConvergenceResult res=solver.Solve();
if(res == ConvergenceError) {
if(verbose >= 1)
cerr<<"Quadratic program unable to solve constrained least-squares problem"<<endl;
getchar();
return LinearProgram::Infeasible;
}
else if(res == MaxItersReached) {
x = solver.x;
return LinearProgram::Error;
}
else {
x = solver.x;
return LinearProgram::Feasible;
}
*/
FatalError("TODO: QP Solve");
}
else if(HasBounds()) {
if(A.m != 0) {
//Equalities done yet
FatalError("Equalities and bounds not done yet");
return LinearProgram::Error;
}
else {
//solve a bounded least squares problem
BoundedLSQRSolver lsqr(C,d,l,u);
LinearProgram::Result res=lsqr.Solve(x);
return res;
}
}
else if(A.m != 0) { //no inequality constraints, just equality
//just transform the problem to an equivalent one
//Ax=p => x = A#*p + N*y = x0 + N*y
//where A# is pseudoinverse, N is nullspace
//so lsq problem becomes min |C*N*y - (d-C*x0)|
Assert(A.m <= A.n); //otherwise overconstrained
Matrix C_new, N;
Vector d_new, x0, y;
MatrixEquation eq(A,p);
if(!eq.AllSolutions(x0,N)) {
if(verbose >= 1)
cerr<<"MinNormProblem (norm 2): Error solving for all solutions to equality constraints"<<endl;
if(verbose >= 2) {
cerr<<"Press any key to continue"<<endl;
getchar();
}
return LinearProgram::Error;
}
if(verbose >= 2) {
Vector r;
eq.Residual(x0,r);
if(r.norm() > 1e-4) {
cout<<"Residual of Aeq*x0=beq: "<<VectorPrinter(r)<<endl;
cout<<"Norm is "<<r.norm()<<endl;
if(r.norm() > 1e-2) {
cout<<MatrixPrinter(A)<<endl;
cout<<"Press any key to continue"<<endl;
getchar();
return LinearProgram::Error;
}
cout<<"Press any key to continue"<<endl;
getchar();
}
}
if(verbose >= 1) {
cout<<"Projecting problem on equality constraints"<<endl;
cout<<"Original dimension "<<A.n<<", nullspace dimension "<<N.n<<endl;
}
//set bnew
C.mul(x0,d_new); d_new-=d; d_new.inplaceNegative();
//set Cnew
C_new.mul(C,N);
if(verbose >= 2) {
cout<<"x0: "<<VectorPrinter(x0)<<endl;
cout<<"N: "<<endl<<MatrixPrinter(N)<<endl;
}
if(verbose >=1) cout<<"Solving transformed problem..."<<endl;
MatrixEquation ls(C_new,d_new);
if(!ls.LeastSquares(y)) {
cerr<<"LeastSquares: Error solving transformed least squares!!!"<<endl;
if(verbose >=1) {
cerr<<"Press any key to continue"<<endl;
getchar();
}
return LinearProgram::Error;
}
//go back to x
x = x0;
N.madd(y,x);
return LinearProgram::Feasible;
}
else {
MatrixEquation ls(C,d);
if(!ls.LeastSquares(x)) {
cout<<"Error solving for least squares!!!"<<endl;
return LinearProgram::Error;
}
return LinearProgram::Feasible;
}
}
else {
RobustLPSolver lps;
lps.verbose = verbose;
lps.UpdateGLPK(lp);
LinearProgram::Result res= lps.SolveGLPK();
if(res==LinearProgram::Feasible) {
x.resize(C.n);
lps.xopt.getSubVectorCopy(0,x);
}
return res;
}
cout<<"Not sure how we got here..."<<endl;
return LinearProgram::Error;
}
