Приложение а Исходный код приложения
import java.util.ArrayList;
import javax.swing.JTable;
import latex.LPPtoLaTeX;
import main.BigTable;
import main.LP_Solver;
public class LPP{
public String ObjFuncType;
public ArrayList<String> VariableNames;
public ArrayList<Double> ObjFuncCoeff;
public ArrayList<ArrayList<Double>> ConstraintCoeff;
public ArrayList<String> ConstraintTypes;
public ArrayList<Double> ConstraintRHSs;
public Double ObjFuncValue;
LPP(String oFT, ArrayList<String> vN, ArrayList<Double> oFC, ArrayList<ArrayList<Double>> A, ArrayList<String> cT, ArrayList<Double> cRHSs, Double OFV)
{
this.ObjFuncType = oFT;
this.VariableNames = vN;
this.ObjFuncCoeff = oFC;
this.ConstraintCoeff = A;
this.ConstraintTypes = cT;
this.ConstraintRHSs = cRHSs;
this.ObjFuncValue = OFV;
}
public LPP(JTable Table, ArrayList<Integer> variableIndex) {
this.ObjFuncType = Table.getValueAt(0, Table.getColumnCount() - 2).toString();
this.VariableNames = new ArrayList();
this.ObjFuncCoeff = new ArrayList();
this.ConstraintCoeff = new ArrayList();
this.ConstraintTypes = new ArrayList();
this.ConstraintRHSs = new ArrayList();
for (int i = 0; i < variableIndex.size(); i++) {
this.VariableNames.add(Table.getColumnName(i));
if (LP_Solver.Table.getValueAt(0, i) != null) {
this.ObjFuncCoeff.add((Double)LP_Solver.Table.getValueAt(0,i));
}
else {
this.ObjFuncCoeff.add(new Double(0.0D));
}
}
if (LP_Solver.Table.getValueAt(0, LP_Solver.Table.getColumnCount() - 1) != null) {
this.ObjFuncValue = ((Double)LP_Solver.Table.getValueAt(0,LP_Solver.Table.getColumnCount() - 1));
}
else {
this.ObjFuncValue = new Double(0.0D);
}
for (int j = 1; j < LP_Solver.Table.getRowCount(); j++) {
ArrayList Constraint = new ArrayList();
for (int i = 0; i < variableIndex.size(); i++) {
if (LP_Solver.Table.getValueAt(j, i) != null) {
Constraint.add((Double)LP_Solver.Table.getValueAt(j, i));
}
else {
Constraint.add(new Double(0.0D));
}
}
this.ConstraintCoeff.add(Constraint);
this.ConstraintTypes.add(LP_Solver.Table.getValueAt(j, variableIndex.size()).toString());
if (LP_Solver.Table.getValueAt(j, variableIndex.size() + 1) != null) {
this.ConstraintRHSs.add((Double)LP_Solver.Table.getValueAt(j, variableIndex.size() + 1));
}
else{
this.ConstraintRHSs.add(new Double(0.0D));
}
}
public static String getDisplay(LPP Input){
String Output = "";
if (Input.ObjFuncType == "Max") {
Output = "Maximize";
}
else {
Output = "Minimize";
}
Output = Output + " " + displayEqLine(Input.ObjFuncCoeff, Input.VariableNames);
if (Input.ObjFuncValue.doubleValue() != 0.0D) {
Output = Output + " + " + Toolbox.formatDecimals(Input.ObjFuncValue);
}
Output = Output + '\n' + "subject to the constraints:" + '\n';
for (int j = 0; j < Input.ConstraintRHSs.size(); j++) {
ArrayList Constraint = (ArrayList)Input.ConstraintCoeff.get(j);
Output = Output + displayEqLine(Constraint, Input.VariableNames);
Output = Output + " " + (String)Input.ConstraintTypes.get(j);
Output = Output + " " + Toolbox.formatDecimals((Double)Input.ConstraintRHSs.get(j));
Output = Output + '\n';
}
return Output + '\n';
}
private static String displayEqLine(ArrayList<Double> coefficients, ArrayList<String> variableNames) {
String Output = "";
int startIndex = 1;
for (int i = 0; i < variableNames.size(); i++) {
if ((((Double)coefficients.get(i)).doubleValue() != 0.0D) || (((Double)coefficients.get(i)).doubleValue() != -0.0D)) {
Output = Output + Toolbox.formatDecimals((Double)coefficients.get(i)) + (String)variableNames.get(i);
break;
}
startIndex++;
}
for (int i = startIndex; i < variableNames.size(); i++) {
String signString = " + ";
Double sign = Double.valueOf(1.0D);
if (Double.compare(((Double)coefficients.get(i)).doubleValue(), 0.0D) < 0) {
signString = " - ";
sign = Double.valueOf(-1.0D);
}
if ((((Double)coefficients.get(i)).doubleValue() != 0.0D) || (((Double)coefficients.get(i)).doubleValue() != -0.0D)) {
Output = Output + signString + Toolbox.formatDecimals(Double.valueOf(sign.doubleValue() * ((Double)coefficients.get(i)).doubleValue())) + (String)variableNames.get(i);
}
}
return Output;
}
public static LPP makeStandardForm(LPP Input) {
LPP Output = Input;
for (int i = 0; i < Input.ConstraintTypes.size(); i++){
if (Input.ConstraintTypes.get(i) == "≥") {
Output = addVariableAt(Output, i, -1.0D);
Output.ConstraintTypes.set(i, "=");
}
if (Input.ConstraintTypes.get(i) == "≤") {
Output = addVariableAt(Output, i, 1.0D);
Output.ConstraintTypes.set(i, "=");
}
}
return Output;
}
private static LPP makeStandardForm(LPP Input, ArrayList<Integer> ArtificialVariables) {
LPP Output = Input;
for (int i = 0; i < Input.ConstraintTypes.size(); i++){
if (Input.ConstraintTypes.get(i) == "≥") {
Output = addVariableAt(Output, i, -1.0D);
Output.ConstraintTypes.set(i, "=");
ArtificialVariables = increaseArtificialVariableIndices(ArtificialVariables);
}
if (Input.ConstraintTypes.get(i) == "≤") {
Output = addVariableAt(Output, i, 1.0D);
Output.ConstraintTypes.set(i, "=");
ArtificialVariables = increaseArtificialVariableIndices(ArtificialVariables);
}
}
return Output;
}
private static ArrayList<Integer> increaseArtificialVariableIndices(ArrayList<Integer> ArtificialVariables) {
for (int j = 0; j < ArtificialVariables.size(); j++) {
if (((Integer)ArtificialVariables.get(j)).intValue() != -1) {
ArtificialVariables.set(j, Integer.valueOf(((Integer)ArtificialVariables.get(j)).intValue() + 1));
}
}
return ArtificialVariables;
}
private static ArrayList<Integer> getArtificialVariableAssignments(LPP Input) {
ArrayList Output = new ArrayList();
int k = 0;
for (int j = 0; j < Input.ConstraintTypes.size(); j++) {
if (Input.ConstraintTypes.get(j) == "=") {
Output.add(Integer.valueOf(Input.ObjFuncCoeff.size() + k));
k++;
}
else {
Output.add(Integer.valueOf(-1));
}
}
return Output;
}
private static LPP addArtificialVariables(LPP Input, ArrayList<Integer> ArtificialVariables) {
LPP Output = Input;
for (int j = 0; j < Input.ConstraintTypes.size(); j++) {
if (((Integer)ArtificialVariables.get(j)).intValue() != -1) {
Output = addVariableAt(Output, j, 1.0D);
}
}
return Output;
}
public static LPP pivot(LPP Input, int varIndex, int constIndex) {
LPP Output = Input;
ArrayList PivotConstraint = (ArrayList)Output.ConstraintCoeff.get(constIndex);
Double PivotConstRHS = (Double)Output.ConstraintRHSs.get(constIndex);
if (((Double)PivotConstraint.get(varIndex)).doubleValue() == 0.0D) {
return Input;
}
Double PivotVarCoeff = (Double)PivotConstraint.get(varIndex);
for (int i = 0; i < PivotConstraint.size(); i++) {
Double coeff = (Double)PivotConstraint.get(i);
PivotConstraint.set(i, Double.valueOf(coeff.doubleValue() / PivotVarCoeff.doubleValue()));
}
PivotConstRHS = Double.valueOf(PivotConstRHS.doubleValue() / PivotVarCoeff.doubleValue());
Output.ConstraintCoeff.set(constIndex, PivotConstraint);
Output.ConstraintRHSs.set(constIndex, PivotConstRHS);
for (int j = 0; j < Input.ConstraintCoeff.size(); j++){
if (j != constIndex){
ArrayList Constraint = (ArrayList)Output.ConstraintCoeff.get(j);
Double ConstRHS = (Double)Output.ConstraintRHSs.get(j);
if (((Double)Constraint.get(varIndex)).doubleValue() != 0.0D) {
Double ConstraintPivotVarCoeff = (Double)Constraint.get(varIndex);
for (int i = 0; i < Constraint.size(); i++) {
Double ConstraintCoeff = (Double)Constraint.get(i);
Double PivotConstraintCoeff = (Double)PivotConstraint.get(i);
Constraint.set(i, Double.valueOf(ConstraintCoeff.doubleValue() - PivotConstraintCoeff.doubleValue() * ConstraintPivotVarCoeff.doubleValue()));
}
ConstRHS = Double.valueOf(ConstRHS.doubleValue() - PivotConstRHS.doubleValue() * ConstraintPivotVarCoeff.doubleValue());
Output.ConstraintCoeff.set(j, Constraint);
Output.ConstraintRHSs.set(j, ConstRHS);
}
}
}
Double PivotVarCoeff = (Double)Output.ObjFuncCoeff.get(varIndex);
PivotConstraint = (ArrayList)Output.ConstraintCoeff.get(constIndex);
PivotConstRHS = (Double)Output.ConstraintRHSs.get(constIndex);
Output.ObjFuncCoeff.set(varIndex, new Double(0.0D));
Output.ObjFuncValue = Double.valueOf(Output.ObjFuncValue.doubleValue() + PivotVarCoeff.doubleValue() * PivotConstRHS.doubleValue());
for (int i = 0; i < Output.ObjFuncCoeff.size(); i++) {
if (i != varIndex) {
Double q = Double.valueOf(((Double)Output.ObjFuncCoeff.get(i)).doubleValue() + -1.0D * ((Double)PivotConstraint.get(i)).doubleValue() * PivotVarCoeff.doubleValue());
Output.ObjFuncCoeff.set(i, q);
}
}
return Output;
}
private static LPP addVariableAt(LPP Input, int constraintIndex, double value) {
LPP Output = Input;
Output.VariableNames.add(Toolbox.getSubscript(Output.VariableNames.size()));
Output.ObjFuncCoeff.add(new Double(0.0D));
for (int j = 0; j < Output.ConstraintCoeff.size(); j++) {
if (j != constraintIndex) {
ArrayList Constraint = (ArrayList)Output.ConstraintCoeff.get(j);
Constraint.add(new Double(0.0D));
Output.ConstraintCoeff.set(j, Constraint);
}
else {
ArrayList Constraint = (ArrayList)Output.ConstraintCoeff.get(j);
Constraint.add(new Double(value));
Output.ConstraintCoeff.set(j, Constraint);
}
}
return Output;
}
private static boolean isFeasible(LPP Input, ArrayList<Integer> x) {
for (int j = 0; j < Input.ConstraintRHSs.size(); j++) {
Input = pivot(Input, ((Integer)x.get(j)).intValue(), j);
}
for (int j = 0; j < Input.ConstraintRHSs.size(); j++) {
ArrayList Constraint = (ArrayList)Input.ConstraintCoeff.get(j);
if (((Double)Input.ConstraintRHSs.get(j)).doubleValue() < 0.0D) {
return false;
}
double q = 0.0D;
for (int i = 0; i < Constraint.size(); i++) {
if (x.contains(Integer.valueOf(i))) {
q += ((Double)Constraint.get(i)).doubleValue() * ((Double)Input.ConstraintRHSs.get(x.indexOf(Integer.valueOf(i)))).doubleValue();
}
}
if (Double.compare(q, ((Double)Input.ConstraintRHSs.get(j)).doubleValue()) != 0) {
return false;
}
}
return true;
}
private static ArrayList<Integer> getInitialBasicVariables(LPP Input, ArrayList<Integer> ArtificialVariables){
ArrayList alpha = new ArrayList();
boolean foundBasicFeasSol = false;
int q = 0;
for (int j = 0; j < ArtificialVariables.size(); j++) {
if (((Integer)ArtificialVariables.get(j)).intValue() != -1) {
q++;
}
}
int n = Input.VariableNames.size() - q;
int powersetsize = (int)Math.pow(2.0D, n);
for (int i = 0; i < powersetsize; i++){
alpha = new ArrayList();
String binary = Toolbox.intToBinary(i, n);
for (int j = 0; j < binary.length(); j++) {
if (binary.charAt(j) == '1') {
alpha.add(Integer.valueOf(j));
}
}
if ((alpha.size() == Input.ConstraintRHSs.size()) && (isFeasible(Input, alpha))) {
foundBasicFeasSol = true;
break;
}
}
if (!foundBasicFeasSol) {
alpha = new ArrayList();
for (int j = 0; j < Input.ConstraintRHSs.size(); j++) {
alpha.add(Integer.valueOf(-1));
}
}
return alpha;
}
private static int choosePivotVar(LPP Input, ArrayList<Integer> ArtificialVariables) {
Double q = new Double(0.0D);
int Output = -1;
Double maxormin = new Double(1.0D);
if (Input.ObjFuncType == "Max") {
maxormin = Double.valueOf(maxormin.doubleValue() * -1.0D);
}
for (int i = 0; i < Input.ObjFuncCoeff.size(); i++) {
Double coefficientTerm = Double.valueOf(maxormin.doubleValue() * ((Double)Input.ObjFuncCoeff.get(i)).doubleValue());
if (!ArtificialVariables.contains(Integer.valueOf(i))) {
if (coefficientTerm.doubleValue() == -0.0D) {
coefficientTerm = Double.valueOf(0.0D);
}
if (Double.compare(coefficientTerm.doubleValue(), q.doubleValue()) < 0) {
q = coefficientTerm;
Output = i;
}
}
}
return Output;
}
private static int choosePivotConst(LPP Input, int n){
Double q = Double.valueOf((1.0D / 0.0D));
int Output = -1;
for (int j = 0; j < Input.ConstraintRHSs.size(); j++) {
ArrayList Constraint = (ArrayList)Input.ConstraintCoeff.get(j);
if (Double.compare(((Double)Constraint.get(n)).doubleValue(), 0.0D) > 0) {
Double ratio = Double.valueOf(((Double)Input.ConstraintRHSs.get(j)).doubleValue() / ((Double)Constraint.get(n)).doubleValue());
if (Double.compare(ratio.doubleValue(), q.doubleValue()) < 0) {
q = ratio;
Output = j;
}
}
}
return Output;
}
public static Solution solve(LPP Input){
int varnum = new Integer(Input.VariableNames.size()).intValue();
ArrayList cTypes = new ArrayList(Input.ConstraintTypes);
ArrayList ArtificialVariables = getArtificialVariableAssignments(Input);
ArrayList varNames = Input.VariableNames;
String LaTeXString = LPPtoLaTeX.displayLPP(Input) + '\n';
String ConsoleString = "Make Standard Form\n";
Input = makeStandardForm(Input, ArtificialVariables);
long StartTime = System.currentTimeMillis();
Input = addArtificialVariables(Input, ArtificialVariables);
ArrayList BasicVars = getInitialBasicVariables(Input, ArtificialVariables);
long GetFeasSolTime = System.currentTimeMillis() - StartTime;
ConsoleString = ConsoleString + "Basic Variables: " + BasicVars + '\n';
if (((Integer)BasicVars.get(0)).intValue() == -1) {
Solution q = new Solution(false);
q.solutionDisplay = "Could not find a Basic Feasible Solution.";
q.ConsoleString = ConsoleString;
q.GetFeasSolTime = GetFeasSolTime;
return q;
}
boolean go = true;
int limiter = 1;
LaTeXString = LaTeXString + LPPtoLaTeX.beginTableaus(Input);
while (go){
int n = choosePivotVar(Input, ArtificialVariables);
LaTeXString = LaTeXString + LPPtoLaTeX.makeTableau(Input, BasicVars, limiter);
if (n == -1) {
go = false;
}
else{
if ((limiter == 1000) || (choosePivotConst(Input, n) == -1)) {
Solution q = new Solution(false);
q.ConsoleString = ConsoleString;
q.GetFeasSolTime = GetFeasSolTime;
if (limiter == 1000) {
q.solutionDisplay = "The pivot limiter timed out.";
}
else if (choosePivotConst(Input, n) == -1) {
q.solutionDisplay = "The given LPP is unbounded.";
}
return q;
}
int k = choosePivotConst(Input, n);
pivot(Input, n, k);
BasicVars.set(k, Integer.valueOf(n));
ConsoleString = ConsoleString + "Pivot at " + n + ", " + k + "\n";
}
limiter++;
}
LaTeXString = LaTeXString + LPPtoLaTeX.endTableaus();
ArrayList OptimalSolution = new ArrayList();
ArrayList Slack = new ArrayList();
ArrayList ShPr = new ArrayList();
ArrayList redCost = new ArrayList();
for (int i = 0; i < varnum; i++) {
if (BasicVars.contains(Integer.valueOf(i))) {
int basicVarIndex = BasicVars.indexOf(Integer.valueOf(i));
if (BasicVars.indexOf(Integer.valueOf(i)) != BasicVars.lastIndexOf(Integer.valueOf(i))) {
for (int k = 0; k < BasicVars.size(); k++) {
if (((Integer)BasicVars.get(k)).intValue() == i) {
ArrayList constraint = (ArrayList)Input.ConstraintCoeff.get(basicVarIndex);
for (int m = 0; m < constraint.size(); m++) {
if ((((Double)constraint.get(m)).doubleValue() != 0.0D) || (((Double)constraint.get(m)).doubleValue() != -0.0D)) {
basicVarIndex = k;
break;
}
}
}
}
}
OptimalSolution.add((Double)Input.ConstraintRHSs.get(basicVarIndex));
redCost.add((Double)Input.ObjFuncCoeff.get(i));
}
else {
OptimalSolution.add(new Double(0.0D));
redCost.add((Double)Input.ObjFuncCoeff.get(i));
for (int j = 0; j < cTypes.size(); j++) {
if (cTypes.get(j) == "=") {
Slack.add(Double.valueOf(0.0D));
ShPr.add(Double.valueOf(-1.0D * ((Double)Input.ObjFuncCoeff.get(((Integer)ArtificialVariables.get(j)).intValue())).doubleValue()));
}
else if ((((Double)Input.ObjFuncCoeff.get(varnum)).doubleValue() == 0.0D) && (((Double)Input.ObjFuncCoeff.get(varnum)).doubleValue() == -0.0D)) {
Slack.add((Double)Input.ConstraintRHSs.get(j));
ShPr.add(Double.valueOf(0.0D));
varnum++;
}
else {
Slack.add(Double.valueOf(0.0D));
ShPr.add(Double.valueOf(-1.0D * (Double)Input.ObjFuncCoeff.get(varnum)).doubleValue()));
varnum++;
}
}
Solution Solved = new Solution(OptimalSolution, Input.ObjFuncValue, varNames, cTypes, Slack, ShPr, redCost);
Solved.SolTime = (System.currentTimeMillis() - StartTime);
Solved.GetFeasSolTime = GetFeasSolTime;
Solved.LaTeXString = LaTeXString;
Solved.ConsoleString = ConsoleString;
return Solved; }}