/** Solves a standard form LP problem in the form of min(c) s.t. A.x = b lb <= x <= ub */
protected int optimizeStandardLP(int nOfSlackVariables) throws Exception {
log.info("optimizeStandardLP");
LPOptimizationRequest lpRequest = getLPOptimizationRequest();
if (log.isDebugEnabled() && lpRequest.isDumpProblem()) {
log.debug("LP problem: " + lpRequest.toString());
}
LPOptimizationResponse lpResponse;
if (lpRequest.isPresolvingDisabled()) {
// optimization
LPPrimalDualMethod opt = new LPPrimalDualMethod(minLBValue, maxUBValue);
opt.setLPOptimizationRequest(lpRequest);
if (opt.optimizePresolvedStandardLP() == OptimizationResponse.FAILED) {
return OptimizationResponse.FAILED;
}
lpResponse = opt.getLPOptimizationResponse();
setLPOptimizationResponse(lpResponse);
} else {
// presolving
LPPresolver lpPresolver = new LPPresolver();
lpPresolver.setAvoidScaling(lpRequest.isRescalingDisabled());
lpPresolver.setAvoidFillIn(lpRequest.isAvoidPresolvingFillIn());
lpPresolver.setAvoidIncreaseSparsity(lpRequest.isAvoidPresolvingIncreaseSparsity());
testPresolver = lpPresolver; // just for testing
lpPresolver.setNOfSlackVariables((short) nOfSlackVariables);
lpPresolver.presolve(getC(), getA(), getB(), getLb(), getUb());
int presolvedDim = lpPresolver.getPresolvedN();
if (presolvedDim == 0) {
// deterministic problem
log.debug("presolvedDim : " + presolvedDim);
log.debug("deterministic LP problem");
lpResponse = new LPOptimizationResponse();
lpResponse.setReturnCode(OptimizationResponse.SUCCESS);
lpResponse.setSolution(new double[] {});
} else {
// solving the presolved problem
DoubleMatrix1D presolvedC = lpPresolver.getPresolvedC();
DoubleMatrix2D presolvedA = lpPresolver.getPresolvedA();
DoubleMatrix1D presolvedB = lpPresolver.getPresolvedB();
if (log.isDebugEnabled()) {
if (lpPresolver.getPresolvedYlb() != null) {
log.debug("Ylb: " + ArrayUtils.toString(lpPresolver.getPresolvedYlb().toArray()));
log.debug("Yub: " + ArrayUtils.toString(lpPresolver.getPresolvedYub().toArray()));
}
if (lpPresolver.getPresolvedZlb() != null) {
log.debug("Zlb: " + ArrayUtils.toString(lpPresolver.getPresolvedZlb().toArray()));
log.debug("Zub: " + ArrayUtils.toString(lpPresolver.getPresolvedZub().toArray()));
}
}
// new LP problem (the presolved problem)
LPOptimizationRequest presolvedLPRequest = lpRequest.cloneMe();
presolvedLPRequest.setC(presolvedC);
presolvedLPRequest.setA(presolvedA);
presolvedLPRequest.setB(presolvedB);
presolvedLPRequest.setLb(lpPresolver.getPresolvedLB());
presolvedLPRequest.setUb(lpPresolver.getPresolvedUB());
presolvedLPRequest.setYlb(lpPresolver.getPresolvedYlb());
presolvedLPRequest.setYub(lpPresolver.getPresolvedYub());
presolvedLPRequest.setZlb(lpPresolver.getPresolvedZlb());
presolvedLPRequest.setZub(lpPresolver.getPresolvedZub());
if (getInitialPoint() != null) {
presolvedLPRequest.setInitialPoint(lpPresolver.presolve(getInitialPoint().toArray()));
}
if (getNotFeasibleInitialPoint() != null) {
presolvedLPRequest.setNotFeasibleInitialPoint(
lpPresolver.presolve(getNotFeasibleInitialPoint().toArray()));
}
// optimization
// NB: because of rescaling during the presolving phase, minLB and maxUB could have been
// rescaled
double rescaledMinLBValue =
(Double.isNaN(lpPresolver.getMinRescaledLB()))
? this.minLBValue
: lpPresolver.getMinRescaledLB();
double rescaledMaxUBValue =
(Double.isNaN(lpPresolver.getMaxRescaledUB()))
? this.maxUBValue
: lpPresolver.getMaxRescaledUB();
LPPrimalDualMethod opt = new LPPrimalDualMethod(rescaledMinLBValue, rescaledMaxUBValue);
opt.setLPOptimizationRequest(presolvedLPRequest);
if (opt.optimizePresolvedStandardLP() == OptimizationResponse.FAILED) {
return OptimizationResponse.FAILED;
}
lpResponse = opt.getLPOptimizationResponse();
}
// postsolving
double[] postsolvedSolution = lpPresolver.postsolve(lpResponse.getSolution());
lpResponse.setSolution(postsolvedSolution);
setLPOptimizationResponse(lpResponse);
}
return lpResponse.getReturnCode();
}
/**
* Solves a presolved standard form LP problem in the form of min(c) s.t. A.x = b lb <= x <= ub
*/
protected int optimizePresolvedStandardLP() throws Exception {
log.info("optimizePresolvedStandardLP");
long tStart = System.currentTimeMillis();
LPOptimizationRequest lpRequest = getLPOptimizationRequest();
if (log.isDebugEnabled() && lpRequest.isDumpProblem()) {
log.debug("LP problem: " + lpRequest.toString());
}
if (this.dim <= -1) {
if (getLb().size() != getUb().size()) {
log.error("Lower and upper bounds must have the same dimension");
throw new IllegalArgumentException("Lower and upper bounds must have the same dimension");
}
this.dim = getLb().size();
double minDeltaBoundsValue = Double.MAX_VALUE;
int minDeltaBoundsIndex = -1;
for (int i = 0; i < getDim(); i++) {
double deltai = getUb().getQuick(i) - getLb().getQuick(i);
if (deltai < minDeltaBoundsValue) {
minDeltaBoundsValue = deltai;
minDeltaBoundsIndex = i;
}
}
log.info("min delta bounds index: " + minDeltaBoundsIndex);
log.info("min delta bounds value: " + minDeltaBoundsValue);
}
// this.boundedLb = new boolean[getDim()];
// this.boundedUb = new boolean[getDim()];
// for(int i=0; i<getDim(); i++){
// if(!isLbUnbounded(getLb().getQuick(i))){
// boundedLb[i] = true;
// nOfBoundedLb++;
// }
// if(!isUbUnbounded(getUb().getQuick(i))){
// boundedUb[i] = true;
// nOfBoundedUb++;
// }
// }
this.meq = (this.meq > -1) ? this.meq : ((getA() != null) ? getA().rows() : 0);
// this.mieq = (this.mieq>-1)? this.mieq : (nOfBoundedLb+nOfBoundedUb);
this.mieq = (this.mieq > -1) ? this.mieq : (2 * getDim());
if (log.isDebugEnabled()) {
log.debug("dim : " + getDim());
log.debug("meq : " + getMeq());
log.debug("mieq: " + getMieq());
}
LPOptimizationResponse lpResponse = new LPOptimizationResponse();
DoubleMatrix1D X0 = getInitialPoint();
if (X0 == null) {
DoubleMatrix1D X0NF = getNotFeasibleInitialPoint();
if (X0NF != null) {
double rPriX0NFNorm = Math.sqrt(ALG.norm2(rPri(X0NF)));
DoubleMatrix1D fiX0NF = getFi(X0NF);
int maxIndex = Utils.getMaxIndex(fiX0NF);
double maxValue = fiX0NF.get(maxIndex);
if (log.isDebugEnabled()) {
log.debug("rPriX0NFNorm : " + rPriX0NFNorm);
log.debug("X0NF : " + ArrayUtils.toString(X0NF.toArray()));
log.debug("fiX0NF : " + ArrayUtils.toString(fiX0NF.toArray()));
}
if (maxValue < 0 && rPriX0NFNorm <= getToleranceFeas()) {
// the provided not-feasible starting point is already feasible
log.debug("the provided initial point is already feasible");
X0 = X0NF;
}
}
if (X0 == null) {
BasicPhaseILPPDM bf1 = new BasicPhaseILPPDM(this);
X0 = bf1.findFeasibleInitialPoint();
}
}
// check X0 feasibility
DoubleMatrix1D fiX0 = getFi(X0);
int maxIndex = Utils.getMaxIndex(fiX0);
double maxValue = fiX0.get(maxIndex);
double rPriX0Norm = Math.sqrt(ALG.norm2(rPri(X0)));
if (maxValue >= 0. || rPriX0Norm > getToleranceFeas()) { // must be fi STRICTLY < 0
log.warn("rPriX0Norm : " + rPriX0Norm);
log.warn("ineqX0 : " + ArrayUtils.toString(fiX0.toArray()));
log.warn("max ineq index: " + maxIndex);
log.warn("max ineq value: " + maxValue);
// the point must be INTERNAL, fi are used as denominators
throw new Exception("initial point must be strictly feasible");
}
DoubleMatrix1D V0 = F1.make(getMeq());
if (getYlb() != null && getYub() != null) {
// NB: the Lagrangian multipliers for eq. constraints used in this interior point method (v)
// are the opposite of the Lagrangian multipliers for eq. constraints used in the presolver
// (y)
// and so Ylb<=y<=Yub becomes -Yub<=v<=-Ylb
for (int i = 0; i < getMeq(); i++) {
double v0i = 0;
if (!isLbUnbounded(getYlb().getQuick(i))) {
if (!isUbUnbounded(getYub().getQuick(i))) {
v0i = -(getYub().getQuick(i) + getYlb().getQuick(i)) / 2;
} else {
v0i = -getYlb().getQuick(i);
}
} else {
if (!isUbUnbounded(getYub().getQuick(i))) {
v0i = -getYub().getQuick(i);
} else {
v0i = 0;
}
}
V0.setQuick(i, v0i);
}
}
DoubleMatrix1D L0 = getInitialLagrangian();
if (L0 != null) {
for (int j = 0; j < L0.size(); j++) {
// must be >0
if (L0.get(j) <= 0) {
throw new IllegalArgumentException("initial lagrangian must be strictly > 0");
}
}
} else {
L0 = F1.make(getMieq(), 1.); // must be >0 strictly
if (getZlb() != null && getZub() != null) {
// Zlb<= L <=Zub, meaning that:
// zlb[i] and zub[i] are the bounds on the Lagrangian of the constraint associated with
// lb[i]<x[i]<ub[i]
// note that zlb.size = zub.size = lb.size = ub.size (and = n of variables of the problem (=
// getDim())
// and that L.size = nOfBoundedLb + nOfBoundedUb (and in general < 2*getDim())
int cntLB = 0;
int cntUB = 0;
for (int i = 0; i < getDim(); i++) {
double zlbi =
(isLbUnbounded(getZlb().getQuick(i))) ? 0 : getZlb().getQuick(i); // L must be > 0
double zubi = (isUbUnbounded(getZub().getQuick(i))) ? 1 : getZub().getQuick(i);
L0.setQuick(cntLB, (zubi - zlbi) / 2);
cntLB++;
L0.setQuick(getDim() + cntUB, (zubi - zlbi) / 2);
cntUB++;
}
} else {
// inequalities comes from the pairs lower bounds-upper bounds
// in the calculation of the H matrix fro the KKT system, each pairs gives terms of the
// form:
// t = tl + tu
// tl = -L[i] / fi[i] for the lower bound
// tu = L[dim+i] / fi[dim+i] for the upper bound
// we want t = 1, and hence
// L[i] > -cc * fi[i]
// L[dim+i] = (1 + L[i] / fi[i]) * fi[dim+i]
// double cc = 10;
// int nOfLB = getMieq()/2;
// for (int i = 0; i < nOfLB; i++) {
// L0.setQuick(i, -cc * fiX0.getQuick(i));
// L0.setQuick(nOfLB + i, (1 - 10) * fiX0.getQuick(nOfLB + i));
// double sum = -L0.getQuick(i)/fiX0.getQuick(i)+L0.getQuick(nOfLB +
// i)/fiX0.getQuick(nOfLB + i);
// log.debug("sum["+i+"]: " + sum);
// }
}
}
if (log.isDebugEnabled()) {
log.debug("X0: " + ArrayUtils.toString(X0.toArray()));
log.debug("V0: " + ArrayUtils.toString(V0.toArray()));
log.debug("L0: " + ArrayUtils.toString(L0.toArray()));
}
if (log.isInfoEnabled()) {
log.info("toleranceFeas: " + getToleranceFeas());
log.info("tolerance : " + getTolerance());
}
DoubleMatrix1D X = X0;
DoubleMatrix1D V = V0;
DoubleMatrix1D L = L0;
double previousF0X = Double.NaN;
double previousRPriXNorm = Double.NaN;
double previousRDualXLVNorm = Double.NaN;
double previousSurrDG = Double.NaN;
double t;
int iteration = 0;
// List<DoubleMatrix1D> XList = new ArrayList<DoubleMatrix1D>();
// List<double[]> SList = new ArrayList<double[]>();
while (true) {
iteration++;
// iteration limit condition
if (iteration == getMaxIteration() + 1) {
lpResponse.setReturnCode(OptimizationResponse.FAILED);
log.error("Max iterations limit reached");
throw new Exception("Max iterations limit reached");
}
// XList.add(XList.size(), X);
double F0X = getF0(X);
if (log.isInfoEnabled()) {
log.info("iteration: " + iteration);
log.info("f0(X)=" + F0X);
}
if (log.isDebugEnabled()) {
log.debug("X=" + ArrayUtils.toString(X.toArray()));
log.debug("L=" + ArrayUtils.toString(L.toArray()));
log.debug("V=" + ArrayUtils.toString(V.toArray()));
}
// determine functions evaluations
DoubleMatrix1D gradF0X = getGradF0(X);
DoubleMatrix1D fiX = getFi(X);
log.debug("fiX=" + ArrayUtils.toString(fiX.toArray()));
// DoubleMatrix2D GradFiX = getGradFi(X);
// DoubleMatrix2D GradFiXOLD = getGradFiOLD(X);
// determine t
double surrDG = getSurrogateDualityGap(fiX, L);
t = getMu() * getMieq() / surrDG;
log.debug("t: " + t);
// determine residuals
DoubleMatrix1D rPriX = rPri(X);
DoubleMatrix1D rCentXLt = rCent(fiX, L, t);
DoubleMatrix1D rDualXLV = rDual(gradF0X, L, V);
// DoubleMatrix1D rDualXLVOLD = rDualOLD(GradFiXOLD, gradF0X, L, V);
// log.debug("delta: " + ALG.normInfinity(rDualXLVOLD.assign(rDualXLV, Functions.minus)));
double rPriXNorm = Math.sqrt(ALG.norm2(rPriX));
double rCentXLtNorm = Math.sqrt(ALG.norm2(rCentXLt));
double rDualXLVNorm = Math.sqrt(ALG.norm2(rDualXLV));
double normRXLVt =
Math.sqrt(Math.pow(rPriXNorm, 2) + Math.pow(rCentXLtNorm, 2) + Math.pow(rDualXLVNorm, 2));
// @TODO: set log.debug not log.info
log.info("rPri norm: " + rPriXNorm);
log.info("rCent norm: " + rCentXLtNorm);
log.info("rDual norm: " + rDualXLVNorm);
log.info("surrDG : " + surrDG);
// custom exit condition
if (checkCustomExitConditions(X)) {
lpResponse.setReturnCode(OptimizationResponse.SUCCESS);
break;
}
// exit condition
if (rPriXNorm <= getToleranceFeas()
&& rDualXLVNorm <= getToleranceFeas()
&& surrDG <= getTolerance()) {
lpResponse.setReturnCode(OptimizationResponse.SUCCESS);
break;
}
// progress conditions
if (isCheckProgressConditions()) {
if (!Double.isNaN(previousRPriXNorm)
&& !Double.isNaN(previousRDualXLVNorm)
&& !Double.isNaN(previousSurrDG)) {
if ((previousRPriXNorm <= rPriXNorm && rPriXNorm >= getToleranceFeas())
|| (previousRDualXLVNorm <= rDualXLVNorm && rDualXLVNorm >= getToleranceFeas())) {
log.error("No progress achieved, exit iterations loop without desired accuracy");
lpResponse.setReturnCode(OptimizationResponse.FAILED);
throw new Exception(
"No progress achieved, exit iterations loop without desired accuracy");
}
}
previousRPriXNorm = rPriXNorm;
previousRDualXLVNorm = rDualXLVNorm;
previousSurrDG = surrDG;
}
// compute primal-dual search direction
// a) prepare 11.55 system
DoubleMatrix2D Hpd = GradLSum(L, fiX);
// DoubleMatrix2D HpdOLD = GradLSumOLD(GradFiXOLD, L, fiX);
// log.debug("delta: " + ALG.normInfinity(HpdOLD.assign(Hpd, Functions.minus)));
DoubleMatrix1D gradSum = gradSum(t, fiX);
DoubleMatrix1D g = null;
// if(getAT()==null){
if (getA() == null) {
g = ColtUtils.add(gradF0X, gradSum);
} else {
// g = ColtUtils.add(ColtUtils.add(gradF0X, gradSum), ALG.mult(getAT(), V));
g =
ColtUtils.add(
ColtUtils.add(gradF0X, gradSum),
ColtUtils.zMultTranspose(getA(), V, F1.make(getDim()), 0));
}
// b) solving 11.55 system
if (this.kktSolver == null) {
this.kktSolver = new UpperDiagonalHKKTSolver(getDim(), lpRequest.isRescalingDisabled());
// this.kktSolver = new DiagonalHKKTSolver(getDim(), lpRequest.isRescalingDisabled());
}
if (isCheckKKTSolutionAccuracy()) {
kktSolver.setCheckKKTSolutionAccuracy(true);
kktSolver.setToleranceKKT(getToleranceKKT());
}
kktSolver.setHMatrix(Hpd);
kktSolver.setGVector(g);
if (getA() != null) {
kktSolver.setAMatrix(getA());
// kktSolver.setATMatrix(getAT());
kktSolver.setHVector(rPriX);
// if(rPriXNorm > getToleranceFeas()){
// kktSolver.setHVector(rPriX);
// }
}
DoubleMatrix1D[] sol = kktSolver.solve();
DoubleMatrix1D stepX = sol[0];
// double[] signa = new double[stepX.size()];
// for(int p=0; p<stepX.size(); p++){
// signa[p] = Math.signum(stepX.getQuick(p));
// }
// SList.add(SList.size(), signa);
DoubleMatrix1D stepV = (sol[1] != null) ? sol[1] : F1.make(0);
if (log.isDebugEnabled()) {
log.debug("stepX: " + ArrayUtils.toString(stepX.toArray()));
log.debug("stepV: " + ArrayUtils.toString(stepV.toArray()));
}
// c) solving for L
DoubleMatrix1D stepL = F1.make(getMieq());
DoubleMatrix1D gradFiStepX = gradFiStepX(stepX);
for (int i = 0; i < getMieq(); i++) {
stepL.setQuick(
i, (-L.getQuick(i) * gradFiStepX.getQuick(i) + rCentXLt.getQuick(i)) / fiX.getQuick(i));
}
if (log.isDebugEnabled()) {
log.debug("stepL: " + ArrayUtils.toString(stepL.toArray()));
}
// line search and update
// a) sMax computation
double sMax = Double.MAX_VALUE;
for (int j = 0; j < getMieq(); j++) {
if (stepL.get(j) < 0) {
sMax = Math.min(-L.get(j) / stepL.get(j), sMax);
}
}
sMax = Math.min(1, sMax);
double s = 0.99 * sMax;
// b) backtracking with f
DoubleMatrix1D X1 = F1.make(X.size());
DoubleMatrix1D L1 = F1.make(L.size());
DoubleMatrix1D V1 = F1.make(V.size());
DoubleMatrix1D fiX1 = null;
DoubleMatrix1D gradF0X1 = null;
// DoubleMatrix2D GradFiX1 = null;
// DoubleMatrix2D GradFiX1 = null;
DoubleMatrix1D rPriX1 = null;
DoubleMatrix1D rCentX1L1t = null;
DoubleMatrix1D rDualX1L1V1 = null;
int cnt = 0;
boolean areAllNegative = true;
while (cnt < 500) {
cnt++;
// X1 = X + s*stepX
X1 = stepX.copy().assign(Mult.mult(s)).assign(X, Functions.plus);
DoubleMatrix1D ineqValueX1 = getFi(X1);
areAllNegative = true;
for (int j = 0; areAllNegative && j < getMieq(); j++) {
areAllNegative = (Double.compare(ineqValueX1.get(j), 0.) < 0);
}
if (areAllNegative) {
break;
}
s = getBeta() * s;
}
if (!areAllNegative) {
// exited from the feasible region
throw new Exception("Optimization failed: impossible to remain within the faesible region");
}
log.debug("s: " + s);
// c) backtracking with norm
double previousNormRX1L1V1t = Double.NaN;
cnt = 0;
while (cnt < 500) {
cnt++;
X1 = ColtUtils.add(X, stepX, s);
L1 = ColtUtils.add(L, stepL, s);
V1 = ColtUtils.add(V, stepV, s);
if (isInDomainF0(X1)) {
fiX1 = getFi(X1);
gradF0X1 = getGradF0(X1);
// GradFiX1 = getGradFi(X1);
rPriX1 = rPri(X1);
rCentX1L1t = rCent(fiX1, L1, t);
rDualX1L1V1 = rDual(gradF0X1, L1, V1);
double normRX1L1V1t =
Math.sqrt(ALG.norm2(rPriX1) + ALG.norm2(rCentX1L1t) + ALG.norm2(rDualX1L1V1));
// log.debug("normRX1L1V1t: "+normRX1L1V1t);
if (normRX1L1V1t <= (1 - getAlpha() * s) * normRXLVt) {
break;
}
if (!Double.isNaN(previousNormRX1L1V1t)) {
if (previousNormRX1L1V1t <= normRX1L1V1t) {
log.warn("No progress achieved in backtracking with norm");
break;
}
}
previousNormRX1L1V1t = normRX1L1V1t;
}
s = getBeta() * s;
// log.debug("s: " + s);
}
// update
X = X1;
V = V1;
L = L1;
}
// if(lpRequest.isCheckOptimalDualityConditions()){
// //check duality conditions:
// if(!checkDualityConditions(X, L, V)){
// log.error("duality conditions not satisfied");
// lpResponse.setReturnCode(OptimizationResponse.FAILED);
// throw new Exception("duality conditions not satisfied");
// }
// }
if (lpRequest.isCheckOptimalLagrangianBounds()) {
// check equality constraints Lagrangian bounds
// if(!checkEqConstraintsLagrangianBounds(V)){
// log.error("equality constraints Lagrangian multipliers bounds not satisfied");
// lpResponse.setReturnCode(OptimizationResponse.FAILED);
// throw new Exception("equality constraints Lagrangian multipliers bounds not satisfied");
// }
// check inequality constraints Lagrangian bounds
// if(!checkIneqConstraintsLagrangianBounds(X, L)){
// log.error("inequality constraints Lagrangian multipliers bounds not satisfied");
// lpResponse.setReturnCode(OptimizationResponse.FAILED);
// throw new Exception("inequality constraints Lagrangian multipliers bounds not
// satisfied");
// }
}
long tStop = System.currentTimeMillis();
log.debug("time: " + (tStop - tStart));
log.debug("sol : " + ArrayUtils.toString(X.toArray()));
log.debug("ret code: " + lpResponse.getReturnCode());
// log.debug("XList : " + ArrayUtils.toString(XList));
// for(int s=0; s<SList.size(); s++){
// log.debug("SList : " + ArrayUtils.toString(SList.get(s)));
// }
lpResponse.setSolution(X.toArray());
setLPOptimizationResponse(lpResponse);
return lpResponse.getReturnCode();
}
/** Solves an LP in the form of: min(c) s.t. A.x = b G.x < h lb <= x <= ub */
@Override
public int optimize() throws Exception {
log.info("optimize");
LPOptimizationRequest lpRequest = getLPOptimizationRequest();
if (log.isDebugEnabled() && lpRequest.isDumpProblem()) {
log.debug("LP problem: " + lpRequest.toString());
}
// standard form conversion
LPStandardConverter lpConverter =
new LPStandardConverter(); // the slack variables will have default unboundedUBValue
lpConverter.toStandardForm(getC(), getG(), getH(), getA(), getB(), getLb(), getUb());
int nOfSlackVariables = lpConverter.getStandardS();
log.debug("nOfSlackVariables: " + nOfSlackVariables);
DoubleMatrix1D standardC = lpConverter.getStandardC();
DoubleMatrix2D standardA = lpConverter.getStandardA();
DoubleMatrix1D standardB = lpConverter.getStandardB();
DoubleMatrix1D standardLb = lpConverter.getStandardLB();
DoubleMatrix1D standardUb = lpConverter.getStandardUB();
// solve the standard form problem
LPOptimizationRequest standardLPRequest = lpRequest.cloneMe();
standardLPRequest.setC(standardC);
standardLPRequest.setA(standardA);
standardLPRequest.setB(standardB);
standardLPRequest.setLb(
ColtUtils.replaceValues(
standardLb,
lpConverter.getUnboundedLBValue(),
minLBValue)); // substitute not-double numbers
standardLPRequest.setUb(
ColtUtils.replaceValues(
standardUb,
lpConverter.getUnboundedUBValue(),
maxUBValue)); // substitute not-double numbers
if (getInitialPoint() != null) {
standardLPRequest.setInitialPoint(
lpConverter.getStandardComponents(getInitialPoint().toArray()));
}
if (getNotFeasibleInitialPoint() != null) {
standardLPRequest.setNotFeasibleInitialPoint(
lpConverter.getStandardComponents(getNotFeasibleInitialPoint().toArray()));
}
// optimization
LPPrimalDualMethod opt = new LPPrimalDualMethod(minLBValue, maxUBValue);
opt.setLPOptimizationRequest(standardLPRequest);
if (opt.optimizeStandardLP(nOfSlackVariables) == OptimizationResponse.FAILED) {
return OptimizationResponse.FAILED;
}
// back to original form
LPOptimizationResponse lpResponse = opt.getLPOptimizationResponse();
double[] standardSolution = lpResponse.getSolution();
double[] originalSol = lpConverter.postConvert(standardSolution);
lpResponse.setSolution(originalSol);
setLPOptimizationResponse(lpResponse);
return lpResponse.getReturnCode();
}