/// <summary>
/// Takes the decision domain as a parameter and builds LP/MIP model
/// depending on the domain
/// </summary>
/// <param name="domain"></param>
/// <returns></returns>
private Model BuildMasterModel(Domain domain)
{
_context.ClearModel();
Model masterModel = _context.CreateModel();
//Creating the sets
Set setPattern = new Set(domain: Domain.IntegerNonnegative, name: "Pattern");
//parameter for demanded sizes
Parameter paramDemands = new Parameter(domain: Domain.IntegerNonnegative, name: "ParamDemands", indexSets: _setRoll);
paramDemands.SetBinding(binding: _demands, valueField: "Demand", indexFields: "Width");
//parameter for number that each pattern must be applied to get all sizes and their demanded quantityv
Parameter paramPatternRolls = new Parameter(domain: Domain.IntegerNonnegative, name: "paramPatternRolls", indexSets: new Set[] { setPattern, _setRoll });
paramPatternRolls.SetBinding(binding: _patternRolls, valueField: "Count", indexFields: new string[] { "PatternID", "Width" });
//Add both parameters to model
masterModel.AddParameters(paramDemands, paramPatternRolls);
//Decision: Created, bind data and add to the model
//This is where the solver will place values (how many times to cut each pattern)
Decision decisionPatternCounts = new Decision(domain: domain, name: "PatternCounts", indexSets: setPattern);
decisionPatternCounts.SetBinding(binding: _patterns, valueField: "Count", indexFields: "PatternID");
masterModel.AddDecision(decision: decisionPatternCounts);
//Adding the demand constraint
masterModel.AddConstraint(_demandConstraintName, Model.ForEach
(
_setRoll, roll => //from _setRoll, run for each roll
//sum of (pattern items for given roll) * (pattern count) >= (demandf for size)
Model.Sum
(
Model.ForEach
(
setPattern, pattern => //from setPattern, run for each pattern
decisionPatternCounts[pattern] * paramPatternRolls[pattern, roll]
)
)
>= paramDemands[roll]
));
//Minize the total cuts
masterModel.AddGoal("TotalRolls", GoalKind.Minimize, Model.Sum(Model.ForEach(setPattern, pattern => decisionPatternCounts[pattern])));
return(masterModel);
}
private void TestService2(Directive directive)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Decision x1 = new Decision(Domain.RealNonnegative, "x1");
Decision x2 = new Decision(Domain.RealNonnegative, "x2");
Decision z = new Decision(Domain.IntegerRange(0, 1), "z");
Rational M = 100;
model.AddDecisions(x1, x2, z);
model.AddConstraint("Row0", x1 + x2 >= 1);
model.AddConstraint("Row1", x1 - z * 100 <= 0);
model.AddConstraint("Row2", x2 + z * 100 <= 100);
Goal goal = model.AddGoal("Goal0", GoalKind.Maximize, x1 + x2);
Solution solution = context.Solve(directive);
Assert.IsTrue(goal.ToInt32() == 100);
context.ClearModel();
}
/// <summary>
/// The problem of integer programming:
/// Selection employees necessary to minimize the total cost
/// for given parameters of the cash amount and fixed productivity.
/// </summary>
/// <param name="selector">Contains cash amount and productivity</param>
/// <returns>Possible solutions for the composition of the team of employees</returns>
public override List <Dictionary <FellowWorker, int> > Select(StaffSelector selector)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
// init fellow workers
Junior junior = selector.Staffs.Junior;
Middle middle = selector.Staffs.Middle;
Senior senior = selector.Staffs.Senior;
Lead lead = selector.Staffs.Lead;
// init decisions - counts of number of employees of different qualifications
Decision juniorDecision = new Decision(Domain.IntegerNonnegative, junior.GetQualificationString());
Decision middleDecision = new Decision(Domain.IntegerNonnegative, middle.GetQualificationString());
Decision seniorDecision = new Decision(Domain.IntegerNonnegative, senior.GetQualificationString());
Decision leadDecision = new Decision(Domain.IntegerNonnegative, lead.GetQualificationString());
model.AddDecisions(juniorDecision, middleDecision, seniorDecision, leadDecision);
// constraint of fixed productivity
model.AddConstraints("fixProductivity",
junior.Productivity * juniorDecision +
middle.Productivity * middleDecision +
senior.Productivity * seniorDecision +
lead.Productivity * leadDecision == selector.Productivity);
// constraint of max cash amount
model.AddConstraints("maxAmount",
junior.Salary * juniorDecision +
middle.Salary * middleDecision +
senior.Salary * seniorDecision +
lead.Salary * leadDecision <= selector.Amount);
// criterion of optimization - total cost
model.AddGoal("cost", GoalKind.Minimize,
junior.Salary * juniorDecision +
middle.Salary * middleDecision +
senior.Salary * seniorDecision +
lead.Salary * leadDecision);
Solution solution = context.Solve(new ConstraintProgrammingDirective());
// packing results
List <Dictionary <FellowWorker, int> > solutionsList = new List <Dictionary <FellowWorker, int> >();
while (solution.Quality != SolverQuality.Infeasible)
{
solutionsList.Add(PackSolutionInDictionary(new Decision[] {
juniorDecision,
middleDecision,
seniorDecision,
leadDecision
}, selector.Staffs));
solution.GetNext();
}
context.ClearModel();
return(solutionsList);
}
public static double ComputePortfolioMinimumVariance(LabeledMatrix <Security> matrix, double expectedReturn, out Dictionary <Security, double> weights, bool allowShortSelling = false)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
// since the row securities are the same as the column securities. use row.
var securities = matrix.RowEntities;
var weightDecisions = new Dictionary <Security, Decision>();
var rangeOfWeights = allowShortSelling ? Domain.RealRange(-10, 10) : Domain.RealRange(0, 10);
Term t1 = 0d; // constraint 1, sum of weights = 1
Term t2 = 0d; // constraint 2, expected portfolio return (sum of weight*price) = expectedReturn
foreach (var security in securities)
{
var securityWeightDecision = new Decision(rangeOfWeights, security.Symbol); // -10 <= w <= 10
weightDecisions[security] = securityWeightDecision;
model.AddDecisions(securityWeightDecision);
t1 += securityWeightDecision;
t2 += (securityWeightDecision * security.MarketPrice);
}
model.AddConstraint("SumOfWeights", t1 == 1d);
model.AddConstraint("ExpectedPortfolioReturn", t2 == expectedReturn);
// goal 1, the ptf var to be minimized
Term varianceTerm = 0d;
foreach (Security rowEntity in matrix.RowEntities)
{
foreach (Security columnEntity in matrix.ColumnEntities)
{
varianceTerm += (matrix.Get(rowEntity, columnEntity) * weightDecisions[rowEntity] * weightDecisions[columnEntity]);
}
}
Goal goal = model.AddGoal("MeanVariance", GoalKind.Minimize, varianceTerm);
var gurobiDirective = new GurobiDirective();
//gurobiDirective.OutputFlag = true;
context.Solve(gurobiDirective);
//Report report = solution.GetReport();
//Console.WriteLine("{0}", report);
//Console.WriteLine(goal.ToDouble());
//foreach (var weightDecision in weightDecisions)
//{
// Console.WriteLine(weightDecision.Key.Symbol + ":" + weightDecision.Value.GetDouble());
//}
context.ClearModel();
weights = weightDecisions.ToDictionary(p => p.Key, p => p.Value.GetDouble());
return(goal.ToDouble());
}
public static Tuple <double, List <double> > PlayerBStrategy(List <List <int> > matrix)
{
SolverContext context = SolverContext.GetContext();
context.ClearModel();
Model model = context.CreateModel();
List <Decision> decicionList = new List <Decision>();
for (int j = 0; j < matrix[0].Count; j++)
{
decicionList.Add(new Decision(Domain.RealNonnegative, "B" + j));
}
foreach (var decision in decicionList)
{
model.AddDecision(decision);
}
for (int i = 0; i < matrix.Count; i++)
{
SumTermBuilder rowSum = new SumTermBuilder(decicionList.Count);
for (int j = 0; j < decicionList.Count; j++)
{
rowSum.Add(decicionList[j] * matrix[i][j]);
}
model.AddConstraint("con" + i, rowSum.ToTerm() <= 1);
}
SumTermBuilder decisionSum = new SumTermBuilder(decicionList.Count);
for (int j = 0; j < decicionList.Count; j++)
{
model.AddConstraint("nonneg" + j, decicionList[j] >= 0);
decisionSum.Add(decicionList[j]);
}
model.AddGoal("max", GoalKind.Maximize, decisionSum.ToTerm());
Solution solution = context.Solve(new SimplexDirective());
double gameValue = 1 / solution.Goals.First().ToDouble();
List <double> parsedDecicionList = new List <double>();
foreach (var decision in decicionList)
{
parsedDecicionList.Add(decision.ToDouble() * gameValue);
}
return(new Tuple <double, List <double> >(gameValue, parsedDecicionList));
}
public void GenerateProbabilities()
{
if (_problem.Variables.Count == 0)
{
return;
}
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Dictionary <Variable, (Decision NotNegated, Decision Negated)> decisions =
_problem.Variables.ToDictionary(
variable => variable,
variable => (new Decision(Domain.RealNonnegative, variable.Name), new Decision(Domain.RealNonnegative, "_" + variable.Name)));
model.AddDecisions(decisions.Values.SelectMany(t => new[] { t.NotNegated, t.Negated }).ToArray());
foreach (var pair in decisions)
{
model.AddConstraint("balance_" + pair.Key.Name, pair.Value.NotNegated + pair.Value.Negated == 1);
}
int clauseNum = 0;
foreach (var problemClause in _problem.Clauses)
{
Term term = null;
foreach (var lieral in problemClause)
{
var decisionToAdd = lieral.Value ? decisions[lieral.Key].Negated : decisions[lieral.Key].NotNegated;
term = object.Equals(term, null) ? decisionToAdd : term + decisionToAdd;
}
if (!object.Equals(term, null))
{
model.AddConstraint($"clause_{clauseNum++}", term >= 1);
}
}
foreach (var valueTuple in decisions)
{
model.AddGoal($"goal_{valueTuple.Key.Name}", GoalKind.Maximize,
valueTuple.Value.NotNegated + valueTuple.Value.Negated);
}
Solution solution = context.Solve(new SimplexDirective());
context.ClearModel();
_probailities = decisions.ToDictionary(pair => pair.Key, pair => pair.Value.NotNegated.ToDouble());
}
/// <summary>Create the model.
/// </summary>
/// <param name="project">The project to be scheduled.</param>
public void Initialize(Project project)
{
context = SolverContext.GetContext();
context.ClearModel();
model = context.CreateModel();
int eventCount = project.Tasks.Count;
// we will fill these in in the remainder of the post.
InitializeSets(project.Tasks.Count, eventCount, project.Resources.Count);
InitializeParameters(project.Tasks, project.Resources);
InitializeDecisions();
InitializeGoal();
InitializeConstraints(project, eventCount);
}
private void solveLLP()
{
#region 1 реализация
SolverContext context = SolverContext.GetContext();
context.ClearModel();
modelOfLLP = context.CreateModel();
x1 = new Decision(Domain.IntegerNonnegative, "X1");
x2 = new Decision(Domain.IntegerNonnegative, "X2");
modelOfLLP.AddDecisions(x1, x2);
modelOfLLP.AddConstraints("limits", 0 <= x1, 0 <= x2);
addConstraintsSystem();
addObjectFunction();
solution = context.Solve(new SimplexDirective());
#endregion
}
static void Main(string[] args)
{
try
{
//https://nathanbrixius.wordpress.com/2009/04/24/modeling-a-production-planning-problem-using-solver-foundation/
SolverContext context = SolverContext.GetContext();
context.ClearModel();
Model model = context.CreateModel();
Set fabricas = new Set(Domain.Any, "fabricas");
Set distribuidores = new Set(Domain.Any, "distribuidores");
Parameter demanda = new Parameter(Domain.Integer, "demanda", distribuidores);
demanda.SetBinding(getDemanda().AsEnumerable(), "Demanda", "Distribuidor");
Parameter costos = new Parameter(Domain.Integer, "costos", fabricas, distribuidores);
costos.SetBinding(getCostos().AsEnumerable(), "Costo", "Fabrica", "Distribuidor");
Parameter disponibilidad = new Parameter(Domain.Integer, "disponibilidad", fabricas);
disponibilidad.SetBinding(getDisponibilidad().AsEnumerable(), "Disponibilidad", "Fabrica");
model.AddParameters(demanda, costos, disponibilidad);
Decision x = new Decision(Domain.RealNonnegative, "x", fabricas, distribuidores);
model.AddDecision(x);
model.AddConstraint("Disponibilidad", Model.ForEach(fabricas, f => Model.Sum(Model.ForEach(distribuidores, d => x[f, d])) <= disponibilidad[f]));
model.AddConstraint("Demanda", Model.ForEach(distribuidores, d => Model.Sum(Model.ForEach(fabricas, f => x[f, d])) >= demanda[d]));
model.AddGoal("Meta", GoalKind.Minimize, Model.Sum(Model.ForEach(fabricas, f => Model.ForEach(distribuidores, d => costos[f, d] * x[f, d]))));
Solution solution = context.Solve(new SimplexDirective());
Report report = solution.GetReport();
Console.WriteLine(report);
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex);
Console.ReadLine();
}
}
static void ExecuteZ3(string fileName, Z3BaseDirective directive)
{
SolverContext context = SolverContext.GetContext();
try
{
LoadModel(context, fileName);
Solution solution = context.Solve(directive);
Report report = solution.GetReport();
Console.Write("{0}", report);
}
catch (Exception e)
{
Console.WriteLine("Skipping unsolvable instance in {0} with error message '{1}'.", fileName, e.Message);
}
finally
{
context.ClearModel();
}
}
public string[,] Calculate()
{
Solution solution = context.Solve();
Report report = solution.GetReport();
Console.WriteLine(solution.Quality);
string[,] decisionsValues = new string[model.Decisions.Count(), 2];
for (int i = 0; i < model.Decisions.Count(); i++)
{
Decision d = model.Decisions.ElementAt(i);
decisionsValues[i, 0] = d.Name;
decisionsValues[i, 1] = d.GetDouble().ToString();
}
context.ClearModel();
return(decisionsValues);
}
static void ConvertToSMT2(string fileName, Z3BaseDirective directive)
{
SolverContext context = SolverContext.GetContext();
try
{
LoadModel(context, fileName);
if (context.CurrentModel.Goals.Any())
{
directive.SMT2LogFile = Path.ChangeExtension(fileName, ".smt2");
context.Solve(() => true, directive);
}
}
catch (Exception e)
{
Console.WriteLine("Skipping unconvertable instance in {0} with error message '{1}'.", fileName, e.Message);
}
finally
{
context.ClearModel();
}
}
public void OptFunc(double[,] Forcurve, double[,] injectionVol, double[,] withdrawal)
{
double[,] PriceArray = Forcurve;
double[,] InjectionVol = injectionVol;
double[,] Withdrawal = withdrawal;
//is a combination from the price spread array....
double[,] monthspread = new double[12, 12];
double results = 0;
for (int row = 0; row < PriceArray.GetLength(0); row++)
{
int sprow = row; int i = 1;
for (int col = sprow; col < PriceArray.GetLength(0) - 1; col++)
{
results = Math.Round(((PriceArray[row + i, 1] - con.Widthdrawl) - (PriceArray[row, 1] + con.Injection)), 5);
monthspread[row, sprow + 1] = results;
sprow++;
i++;
}
;
}
Term goal;
Term[,] ty;
Term[,] tv;
SolverContext context = SolverContext.GetContext(); // Get context environment
Model model = context.CreateModel(); // Create a new model
#region decision and constraints
//need 12 decisions for every month remaining in the year......
Decision I1 = new Decision(Domain.RealNonnegative, "I1");
Decision W1 = new Decision(Domain.RealNonnegative, "W1");
Decision I2 = new Decision(Domain.RealNonnegative, "I2");
Decision I3 = new Decision(Domain.RealNonnegative, "I3");
Decision I4 = new Decision(Domain.RealNonnegative, "I4");
Decision I5 = new Decision(Domain.RealNonnegative, "I5");
Decision I6 = new Decision(Domain.RealNonnegative, "I6");
Decision I7 = new Decision(Domain.RealNonnegative, "I7");
Decision I8 = new Decision(Domain.RealNonnegative, "I8");
Decision I9 = new Decision(Domain.RealNonnegative, "I9");
Decision I10 = new Decision(Domain.RealNonnegative, "I10");
Decision I11 = new Decision(Domain.RealNonnegative, "I11");
Decision I12 = new Decision(Domain.RealNonnegative, "I12");
Decision W2 = new Decision(Domain.RealNonnegative, "W2");
Decision W3 = new Decision(Domain.RealNonnegative, "W3");
Decision W4 = new Decision(Domain.RealNonnegative, "W4");
Decision W5 = new Decision(Domain.RealNonnegative, "W5");
Decision W6 = new Decision(Domain.RealNonnegative, "W6");
Decision W7 = new Decision(Domain.RealNonnegative, "W7");
Decision W8 = new Decision(Domain.RealNonnegative, "W8");
Decision W9 = new Decision(Domain.RealNonnegative, "W9");
Decision W10 = new Decision(Domain.RealNonnegative, "W10");
Decision W11 = new Decision(Domain.RealNonnegative, "W11");
Decision W12 = new Decision(Domain.RealNonnegative, "W12");
model.AddDecisions(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12); // Add these to the model (this is where the outputs will be stored)
model.AddConstraints("limits",
//monthly injection withdrawl constraints
W1 + Withdrawal[9, 1] <= con.JulExport, //13333333.2,
I1 + InjectionVol[9, 1] == con.JanImport, //0
W2 + Withdrawal[10, 1] <= con.FebExport, //11999999.88,
I2 + InjectionVol[10, 1] == con.FebImport, //0,
W3 + Withdrawal[11, 1] <= con.MarExport, //5333333.28,
I3 + InjectionVol[11, 1] == con.MarImport, //0,
W4 + Withdrawal[0, 1] == con.AprExport, //0,
I4 + InjectionVol[0, 1] == con.AprImport, //0,
W5 + Withdrawal[1, 1] == con.MayExport, //0,
I5 + InjectionVol[1, 1] <= con.MayImport, //3000000,
W6 + Withdrawal[2, 1] == con.JunExport, //0,
I6 + InjectionVol[2, 1] <= con.JunImport, //16800000,
W7 + Withdrawal[3, 1] == con.JulExport, //0,
I7 + InjectionVol[3, 1] <= con.JulImport, //16800000,
W8 + Withdrawal[4, 1] == con.AugExport, //0,
I8 + InjectionVol[4, 1] <= con.AugImport, //12600000,
W9 + Withdrawal[5, 1] == con.SeptExport, //0,
I9 + InjectionVol[5, 1] <= con.SeptImport, //10800000,
W10 + Withdrawal[6, 1] <= con.OctExport, //6000000,
I10 + InjectionVol[6, 1] == con.OctImport, //0,
W11 + Withdrawal[7, 1] <= con.NovExport, //6000000,
I11 + InjectionVol[7, 1] == con.NovImport, //0,
W12 + Withdrawal[8, 1] <= con.DecExport, //17333333,
I12 + InjectionVol[8, 1] == con.DecImport, //0,
//maximum capacity constraints...
I4 - -W4 <= con.MaxCap,
I4 - W4 + I5 - W5 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 + I2 - W2 <= con.MaxCap,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 + I2 - W2 + I3 - W3 <= con.MaxCap,
//minimum capacity constraints
//you need to take into account any volumes currently in storage...
I4 - W4 >= 0,
I4 - W4 + I5 - W5 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 + I2 - W2 >= 0,
I4 - W4 + I5 - W5 + I6 - W6 + I7 - W7 + I8 - W8 + I9 - W9 + I10 - W10 + I11 - W11 + I12 - W12 + I1 - W1 + I2 - W2 + I3 - W3 == 0
);
#endregion
ty = matrix(monthspread);
tv = new Term[, ] {
{ (I4 - W4), (I5 - W5), (I6 - W6), (I7 - W7), (I8 - W8), (I9 - W9), (I10 - W10), (I11 - W11), (I12 - W12), (I1 - W1), (I2 - W2), (I3 - W3) }
};
//to create the goal we need to find the volumes for each month, if injection greater than
//withdrawals vol is positive vica versa, then multiply by spread and reverse sign to find profit, which is what we want to maximise
//goal = matMult(matSubtract(tx, tw), ty)[0, 0];
goal = matMult(tv, ty)[0, 0];
model.AddGoal("goal", GoalKind.Minimize, goal);
// Specifying the IPM solver, as we have a quadratic goal
Solution solution = context.Solve(new InteriorPointMethodDirective());
//Profit calculation section, you need to store decisions and profit figures......
// DataSet SimulationResults = new DataSet();
#region Fill DataSet
DataRow rowinfo = Withtable.NewRow();
rowinfo[0] = Convert.ToDouble(W4.GetDouble());
rowinfo[1] = Convert.ToDouble(W5.GetDouble());
rowinfo[2] = Convert.ToDouble(W6.GetDouble());
rowinfo[3] = Convert.ToDouble(W7.GetDouble());
rowinfo[4] = Convert.ToDouble(W8.GetDouble());
rowinfo[5] = Convert.ToDouble(W9.GetDouble());
rowinfo[6] = Convert.ToDouble(W10.GetDouble());
rowinfo[7] = Convert.ToDouble(W11.GetDouble());
rowinfo[8] = Convert.ToDouble(W12.GetDouble());
rowinfo[9] = Convert.ToDouble(W1.GetDouble());
rowinfo[10] = Convert.ToDouble(W2.GetDouble());
rowinfo[11] = Convert.ToDouble(W3.GetDouble());
SimulationResults.Tables[1].Rows.Add(rowinfo);
rowinfo = Imptable.NewRow();
rowinfo[0] = Convert.ToDouble(I4.GetDouble());
rowinfo[1] = Convert.ToDouble(I5.GetDouble());
rowinfo[2] = Convert.ToDouble(I6.GetDouble());
rowinfo[3] = Convert.ToDouble(I7.GetDouble());
rowinfo[4] = Convert.ToDouble(I8.GetDouble());
rowinfo[5] = Convert.ToDouble(I9.GetDouble());
rowinfo[6] = Convert.ToDouble(I10.GetDouble());
rowinfo[7] = Convert.ToDouble(I11.GetDouble());
rowinfo[8] = Convert.ToDouble(I12.GetDouble());
rowinfo[9] = Convert.ToDouble(I1.GetDouble());
rowinfo[10] = Convert.ToDouble(I2.GetDouble());
rowinfo[11] = Convert.ToDouble(I3.GetDouble());
SimulationResults.Tables[2].Rows.Add(rowinfo);
rowinfo = Proftable.NewRow();
rowinfo[0] = (Convert.ToDouble(W4.GetDouble()) - Convert.ToDouble(I4.GetDouble())) * PriceArray[0, 1] / 100;
rowinfo[1] = (Convert.ToDouble(W5.GetDouble()) - Convert.ToDouble(I5.GetDouble())) * PriceArray[1, 1] / 100;
rowinfo[2] = (Convert.ToDouble(W6.GetDouble()) - Convert.ToDouble(I6.GetDouble())) * PriceArray[2, 1] / 100;
rowinfo[3] = (Convert.ToDouble(W7.GetDouble()) - Convert.ToDouble(I7.GetDouble())) * PriceArray[3, 1] / 100;
rowinfo[4] = (Convert.ToDouble(W8.GetDouble()) - Convert.ToDouble(I8.GetDouble())) * PriceArray[4, 1] / 100;
rowinfo[5] = (Convert.ToDouble(W9.GetDouble()) - Convert.ToDouble(I9.GetDouble())) * PriceArray[5, 1] / 100;
rowinfo[6] = (Convert.ToDouble(W10.GetDouble()) - Convert.ToDouble(I10.GetDouble())) * PriceArray[6, 1] / 100;
rowinfo[7] = (Convert.ToDouble(W11.GetDouble()) - Convert.ToDouble(I11.GetDouble())) * PriceArray[7, 1] / 100;
rowinfo[8] = (Convert.ToDouble(W12.GetDouble()) - Convert.ToDouble(I12.GetDouble())) * PriceArray[8, 1] / 100;
rowinfo[9] = (Convert.ToDouble(W1.GetDouble()) - Convert.ToDouble(I1.GetDouble())) * PriceArray[9, 1] / 100;
rowinfo[10] = (Convert.ToDouble(W2.GetDouble()) - Convert.ToDouble(I2.GetDouble())) * PriceArray[10, 1] / 100;
rowinfo[11] = (Convert.ToDouble(W3.GetDouble()) - Convert.ToDouble(I3.GetDouble())) * PriceArray[11, 1] / 100;
rowinfo[12] = ((double)rowinfo[0] + (double)rowinfo[1] + (double)rowinfo[2] + (double)rowinfo[3] + (double)rowinfo[4] + (double)rowinfo[5] + (double)rowinfo[6] + (double)rowinfo[7] + (double)rowinfo[8] + (double)rowinfo[9] + (double)rowinfo[10] + (double)rowinfo[11]);
SimulationResults.Tables[4].Rows.Add(rowinfo);
rowinfo = ForCurvetable.NewRow();
rowinfo[0] = PriceArray[0, 1];
rowinfo[1] = PriceArray[1, 1];
rowinfo[2] = PriceArray[2, 1];
rowinfo[3] = PriceArray[3, 1];
rowinfo[4] = PriceArray[4, 1];
rowinfo[5] = PriceArray[5, 1];
rowinfo[6] = PriceArray[6, 1];
rowinfo[7] = PriceArray[7, 1];
rowinfo[8] = PriceArray[8, 1];
rowinfo[9] = PriceArray[9, 1];
rowinfo[10] = PriceArray[10, 1];
rowinfo[11] = PriceArray[11, 1];
SimulationResults.Tables[0].Rows.Add(rowinfo);
rowinfo = Positiontable.NewRow();
rowinfo[0] = (Convert.ToDouble(I4.GetDouble()) - Convert.ToDouble(W4.GetDouble()));
rowinfo[1] = (double)rowinfo[0] + (Convert.ToDouble(I5.GetDouble()) - Convert.ToDouble(W5.GetDouble()));
rowinfo[2] = (double)rowinfo[1] + (Convert.ToDouble(I6.GetDouble()) - Convert.ToDouble(W6.GetDouble()));
rowinfo[3] = (double)rowinfo[2] + (Convert.ToDouble(I7.GetDouble()) - Convert.ToDouble(W7.GetDouble()));
rowinfo[4] = (double)rowinfo[3] + (Convert.ToDouble(I8.GetDouble()) - Convert.ToDouble(W8.GetDouble()));
rowinfo[5] = (double)rowinfo[4] + (Convert.ToDouble(I9.GetDouble()) - Convert.ToDouble(W9.GetDouble()));
rowinfo[6] = (double)rowinfo[5] + (Convert.ToDouble(I10.GetDouble()) - Convert.ToDouble(W10.GetDouble()));
rowinfo[7] = (double)rowinfo[6] + (Convert.ToDouble(I11.GetDouble()) - Convert.ToDouble(W11.GetDouble()));
rowinfo[8] = (double)rowinfo[7] + (Convert.ToDouble(I12.GetDouble()) - Convert.ToDouble(W12.GetDouble()));
rowinfo[9] = (double)rowinfo[8] + (Convert.ToDouble(I1.GetDouble()) - Convert.ToDouble(W1.GetDouble()));
rowinfo[10] = (double)rowinfo[9] + (Convert.ToDouble(I2.GetDouble()) - Convert.ToDouble(W2.GetDouble()));
rowinfo[11] = (double)rowinfo[10] + (Convert.ToDouble(I3.GetDouble()) - Convert.ToDouble(W3.GetDouble()));
SimulationResults.Tables[3].Rows.Add(rowinfo);
#endregion
// System.Diagnostics.Process.GetCurrentProcess().Kill();
context.ClearModel();
}
/// <summary>
/// Handles the given action, which may result in a synchronized transition.
/// </summary>
public bool HandleAction(ActionType type, string channel, Dictionary <string, object> parameters)
{
Log.Debug(this, nameof(HandleAction) + " Type: " + type + " Channel: " + channel + " Parameters:\n" + string.Join("\n", parameters.Select(x => x.Key + ": " + x.Value).ToArray()));
List <SymbolicTransition> validTransitions = new List <SymbolicTransition>();
foreach (SymbolicTransition transition in Transitions)
{
// Transition must come from the current state.
if (transition.From != State)
{
continue;
}
// Transition must have the same type (input or output).
if (transition.Type != type)
{
continue;
}
// Transition must have the same channel name.
if (transition.Channel != channel)
{
continue;
}
bool valid = true;
try
{
SolverContext solver = SolverContext.GetContext();
if (!modelCache.TryGetValue(transition, out Model model))
{
solver.ClearModel();
model = solver.CreateModel();
modelCache.Add(transition, model);
Log.Debug(this, "Created new model: " + model);
// Add location variables, and interaction variables.
//model.AddParameters(Variables.ToArray());
model.AddDecisions(transition.Variables.ToArray());
// Let the transition add its guard expression.
transition.Guard(model, Variables, transition.Variables);
}
else
{
Log.Debug(this, "Re-using existing model: " + model);
solver.ClearModel();
solver.CurrentModel = model;
}
// Does it solve?
Solution solution = solver.Solve(new HybridLocalSearchDirective()
{
TimeLimit = 1000,
});
Log.Debug(this, "Succesfully solved: " + transition);
foreach (Decision decision in transition.Variables)
{
Log.Debug(this, string.Format("<Decision> {0}: {1}", decision.Name, decision));
}
Report report = solution.GetReport();
Log.Debug(this, string.Format("{0}", report));
solver.ClearModel();
}
catch (Exception e)
{
Log.Error(this, "Exception solving: " + transition + "\n" + e);
valid = false;
}
// Transition must have the same parameters (but order does not matter).
//if (!transition.Parameters.SetEquals(new HashSet<string>(parameters.Keys))) continue;
// Transition guard function must evaluate to true.
//if (!transition.GuardFunction(Variables, parameters)) continue;
// All checks passed!
if (valid)
{
validTransitions.Add(transition);
}
}
Log.Debug(this, "Valid transitions:\n" + string.Join("\n", validTransitions.Select(x => x.ToString()).ToArray()));
if (validTransitions.Count == 0)
{
return(false);
}
// DEBUG: For testing, we pick the first compatible transition, not a random one. (TPE)
SymbolicTransition chosenTransition = validTransitions.First();
Log.Debug(this, "Chosen transition:\n" + chosenTransition);
chosenTransition.Update(Variables, chosenTransition.Variables);
Log.Debug(this, "From: " + State + " To: " + chosenTransition.To);
State = chosenTransition.To;
return(true);
}
private void FindSolution(IEnumerable <Node> nodes, IEnumerable <Link> links, List <SolverWorker> workers)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
var nodeSet = new Set(0, nodes.Count(), 1);
var workerSet = new Set(0, workers.Count(), 1);
//-------------Parameters--------------
var weights = new Parameter(Domain.IntegerNonnegative, "weights", nodeSet);
weights.SetBinding(nodes, "Weight", "ID");
var dependencies = new Parameter(Domain.IntegerRange(0, 1), "dependencies", nodeSet, nodeSet);
dependencies.SetBinding(links, "isDependent", "Source", "Parent");
model.AddParameters(weights, dependencies);
//-------------Decisions--------------
var startTimes = new Decision(Domain.IntegerNonnegative, "starts", nodeSet);
var finishTimes = new Decision(Domain.IntegerNonnegative, "finishes", nodeSet);
var makespan = new Decision(Domain.IntegerNonnegative, "makespan");
var allocation = new Decision(Domain.IntegerRange(0, 1), "allocation", nodeSet, workerSet);
model.AddDecisions(startTimes, finishTimes, makespan, allocation);
//-------------Constraints--------------
model.AddConstraint("FinishTime", Model.ForEach(nodeSet, (node) => startTimes[node] + weights[node] == finishTimes[node]));
//model.AddConstraint("OneAtATime", Model.ForEach(nodeSet, (n) =>
// Model.ForEachWhere(nodeSet, (n2) => Model.Or(finishTimes[n] < startTimes[n2], startTimes[n] > finishTimes[n2]), (n2) => n != n2)));
model.AddConstraint("Allocatee", Model.ForEach(nodeSet, (n) => Model.Sum(Model.ForEach(workerSet, (w) => allocation[n, w])) == 1));
//model.AddConstraint("Allocatee", Model.ForEach(nodeSet, (n) => Model.ExactlyMofN(1,allocation[n])));
model.AddConstraint("OneAtATime",
Model.ForEach(workerSet, (w) =>
Model.ForEach(nodeSet, (n) =>
Model.ForEachWhere(nodeSet, (n2) => Model.Implies(Model.And(allocation[n, w] == 1, allocation[n2, w] == 1),
Model.Or(finishTimes[n] <= startTimes[n2], startTimes[n] >= finishTimes[n2])), (n2) => n != n2))));
model.AddConstraint("PrecedenceConstraints", Model.ForEach(nodeSet, task =>
Model.ForEach(nodeSet, parent =>
Model.Implies(dependencies[task, parent] == 1, startTimes[task] >= finishTimes[parent]))));
//model.AddConstraint("ProjectFinish", Model.ForEach(nodeSet, (n) => makespan >= finishTimes[n]));
model.AddConstraint("ProjectFinish", makespan == Model.Max(Model.ForEach(nodeSet, (n) => finishTimes[n])));
model.AddGoal("MinMakeSpan", GoalKind.Minimize, makespan);
context.CheckModel();
//using (StreamWriter sw = new StreamWriter("Stadium.oml")) {
// context.SaveModel(FileFormat.OML, sw); ;
//}
Solution solution = context.Solve();
Report report = solution.GetReport();
Console.WriteLine(@"===== report =====");
Console.Write("{0}", report);
Console.ReadLine();
context.ClearModel();
}
public IActionResult Result(double TempVhod, double FeOVhod, double TempExit, double Osnovnoct, double FeOExit, int dsfsdfdsfdsf)
{
ViewData["Message"] = "Your application description page.";
RashetShlak cls = new RashetShlak(TempVhod, FeOVhod, TempExit, Osnovnoct, FeOExit);
ViewBag.rashet = cls;
// Расчеты
#region расчеты СЛАУ
string[] str = new string[4];
int p = 0;
XmlReader reader = XmlReader.Create(@"phones_.xml");
XmlDocument doc = new XmlDocument();
XmlReaderSettings settings = new XmlReaderSettings();
//settings.
//doc = new XmlReader();
{
//doc.Load("phones_.xml");
doc.Load(reader);
foreach (XmlNode node in doc.SelectNodes("phones"))
{
foreach (XmlNode child in node.ChildNodes)
{
str[p] = (string.Format(child.InnerText)).ToString();
p++;
}
}
}
Char delimiter = '/';
double[] x = new double[6];
double[,] y = new double[3, 6];
for (int u = 0; u < 4; u++)
{
String[] subn = str[u].Split(delimiter);
if (u == 0)
{
for (int j = 0; j < 6; j++)
{
x[j] = double.Parse(subn[j]);
}
}
else
{
for (int j = 0; j < 6; j++)
{
y[u - 1, j] = double.Parse(subn[j]);
}
}
}
double[,] results = new double[3, 6];
SolverContext context = SolverContext.GetContext();
for (int i = 0; i < y.GetLength(0); i++)
{
Decision a = new Decision(Domain.Real, "a");
Decision b = new Decision(Domain.Real, "b");
Decision c = new Decision(Domain.Real, "c");
Decision d = new Decision(Domain.Real, "d");
Decision e = new Decision(Domain.Real, "e");
Decision f = new Decision(Domain.Real, "f");
Microsoft.SolverFoundation.Services.Model model = context.CreateModel();
model.AddDecisions(a, b, c, d, e, f);
model.AddConstraint("eqA1", y[i, 0] == ((Math.Pow(x[0], 1)) * a + (Math.Pow(x[0], 2)) * b + (Math.Pow(x[0], 3)) * c + (Math.Pow(x[0], 4)) * d + (Math.Pow(x[0], 5)) * e + f));
model.AddConstraint("eqA2", y[i, 1] == ((Math.Pow(x[1], 1)) * a + (Math.Pow(x[1], 2)) * b + (Math.Pow(x[1], 3)) * c + (Math.Pow(x[1], 4)) * d + (Math.Pow(x[1], 5)) * e + f));
model.AddConstraint("eqA3", y[i, 2] == ((Math.Pow(x[2], 1)) * a + (Math.Pow(x[2], 2)) * b + (Math.Pow(x[2], 3)) * c + (Math.Pow(x[2], 4)) * d + (Math.Pow(x[2], 5)) * e + f));
model.AddConstraint("eqA4", y[i, 3] == ((Math.Pow(x[3], 1)) * a + (Math.Pow(x[3], 2)) * b + (Math.Pow(x[3], 3)) * c + (Math.Pow(x[3], 4)) * d + (Math.Pow(x[3], 5)) * e + f));
model.AddConstraint("eqA5", y[i, 4] == ((Math.Pow(x[4], 1)) * a + (Math.Pow(x[4], 2)) * b + (Math.Pow(x[4], 3)) * c + (Math.Pow(x[4], 4)) * d + (Math.Pow(x[4], 5)) * e + f));
model.AddConstraint("eqA6", y[i, 5] == ((Math.Pow(x[5], 1)) * a + (Math.Pow(x[5], 2)) * b + (Math.Pow(x[5], 3)) * c + (Math.Pow(x[5], 4)) * d + (Math.Pow(x[5], 5)) * e + f));
Solution solution = context.Solve();
string result = solution.GetReport().ToString();
results[i, 0] = a.ToDouble();
results[i, 1] = b.ToDouble();
results[i, 2] = c.ToDouble();
results[i, 3] = d.ToDouble();
results[i, 4] = e.ToDouble();
results[i, 5] = f.ToDouble();
context.ClearModel();
}
double[] temps = { cls.TempVhod, cls.TempExit };
double[,] koefs = new double[2, 3];
for (int i = 0; i < 2; i++)
{
Decision a = new Decision(Domain.Real, "a");
Decision b = new Decision(Domain.Real, "b");
Decision c = new Decision(Domain.Real, "c");
Microsoft.SolverFoundation.Services.Model model = context.CreateModel();
model.AddDecisions(a, b, c);
double ta = results[0, 5] +
results[0, 0] * Math.Pow(temps[i], 1) +
results[0, 1] * Math.Pow(temps[i], 2) +
results[0, 2] * Math.Pow(temps[i], 3) +
results[0, 3] * Math.Pow(temps[i], 4) +
results[0, 4] * Math.Pow(temps[i], 5);
double tb = results[1, 5] +
results[1, 0] * Math.Pow(temps[i], 1) +
results[1, 1] * Math.Pow(temps[i], 2) +
results[1, 2] * Math.Pow(temps[i], 3) +
results[1, 3] * Math.Pow(temps[i], 4) +
results[1, 4] * Math.Pow(temps[i], 5);
double tc = results[2, 5] +
results[2, 0] * Math.Pow(temps[i], 1) +
results[2, 1] * Math.Pow(temps[i], 2) +
results[2, 2] * Math.Pow(temps[i], 3) +
results[2, 3] * Math.Pow(temps[i], 4) +
results[2, 4] * Math.Pow(temps[i], 5);
//MessageBox.Show(ta.ToString() + "..." + tb.ToString() + "..." + tc.ToString());
model.AddConstraint("eqA1", ta == 0 * a + 0 * b + c);
model.AddConstraint("eqA2", tb == 6.0 * a + 36.0 * b + c);
model.AddConstraint("eqA3", tc == 12.0 * a + 144.0 * b + c);
Solution solution = context.Solve();
// string result = solution.GetReport().ToString();
koefs[i, 0] = a.ToDouble();
koefs[i, 1] = b.ToDouble();
koefs[i, 2] = c.ToDouble();
context.ClearModel();
}
#endregion
cls.VisVhod = koefs[0, 2] + koefs[0, 0] * cls.FeOVhod + koefs[0, 1] * cls.FeOVhod * cls.FeOVhod;
cls.VisExit = koefs[1, 2] + koefs[1, 0] * cls.FeOExit + koefs[1, 1] * cls.FeOExit * cls.FeOExit;
cls.VisOcnVhod = cls.VisVhod + 196 * (cls.Osnovnoct - 1);
cls.VisOsnExit = cls.VisExit + 4 * (cls.Osnovnoct - 1);
cls.KoffB = (Math.Log10(Math.Log10(cls.VisOsnExit)) - Math.Log10(Math.Log10(cls.VisOcnVhod))) / (cls.TempExit - cls.TempVhod);
cls.KoffA = Math.Log10(Math.Log10(cls.VisOcnVhod)) - cls.TempVhod * cls.KoffB;
cls.Vis1180 = Math.Pow(10, Math.Pow(10, cls.KoffA + cls.KoffB * cls.TempVhod));
cls.Vis1200 = Math.Pow(10, Math.Pow(10, cls.KoffA + cls.KoffB * 1200));
cls.Vis1250 = Math.Pow(10, Math.Pow(10, cls.KoffA + cls.KoffB * 1250));
cls.Vis1275 = Math.Pow(10, Math.Pow(10, cls.KoffA + cls.KoffB * 1275));
cls.Vis1300 = Math.Pow(10, Math.Pow(10, cls.KoffA + cls.KoffB * 1300));
cls.TempKristal = (cls.KoffA - Math.Log10(Math.Log10(25))) / ((-1) * cls.KoffB);
#region Excel
// Открываем приложение
application = new Application
{
DisplayAlerts = false
};
// Файл шаблона
const string template = "shlak2.xlsx";
// Открываем книгу
workBook = application.Workbooks.Open(Path.Combine(Environment.CurrentDirectory, template));
// Получаем активную таблицу
worksheet = (Microsoft.Office.Interop.Excel.Worksheet)workBook.Worksheets[1];//.get_Item(2);
// Записываем данные
worksheet.Range["C22"].Value = cls.TempVhod;
worksheet.Range["C23"].Value = cls.FeOVhod;
worksheet.Range["C24"].Value = cls.TempExit;
worksheet.Range["C25"].Value = cls.FeOExit;
worksheet.Range["C26"].Value = cls.Osnovnoct;
//ВВОД данных и р-т
double VisVhodEX = double.Parse(worksheet.Range["C27"].Value.ToString());
double VisExitEX = double.Parse(worksheet.Range["C28"].Value.ToString());
double VisOcnVhodEX = double.Parse(worksheet.Range["C29"].Value.ToString());
double VisOsnExitEX = double.Parse(worksheet.Range["C30"].Value.ToString());
double KoffAEX = double.Parse(worksheet.Range["C31"].Value.ToString());
double KoffBEX = double.Parse(worksheet.Range["C32"].Value.ToString());
double Vis1180EX = double.Parse(worksheet.Range["C33"].Value.ToString());
double Vis1200EX = double.Parse(worksheet.Range["C34"].Value.ToString());
double Vis1250EX = double.Parse(worksheet.Range["C35"].Value.ToString());
double Vis1275EX = double.Parse(worksheet.Range["C36"].Value.ToString());
double Vis1300EX = double.Parse(worksheet.Range["C37"].Value.ToString());
double TempKristalEX = double.Parse(worksheet.Range["C38"].Value.ToString());
// Показываем приложение
workBook.Save();
cls.pogr = Math.Round((((Math.Abs(((Math.Abs(VisVhodEX) - Math.Abs(cls.VisVhod)) / Math.Abs(VisVhodEX))) +
Math.Abs(((Math.Abs(VisExitEX) - Math.Abs(cls.VisExit)) / Math.Abs(VisExitEX))) +
Math.Abs(((Math.Abs(VisOcnVhodEX) - Math.Abs(cls.VisOcnVhod)) / Math.Abs(VisOcnVhodEX))) +
Math.Abs(((Math.Abs(VisOsnExitEX) - Math.Abs(cls.VisOsnExit)) / Math.Abs(VisOsnExitEX))) +
Math.Abs(((Math.Abs(Vis1250EX) - Math.Abs(cls.Vis1250)) / Math.Abs(Vis1250EX))) +
Math.Abs(((Math.Abs(Vis1275EX) - Math.Abs(cls.Vis1275)) / Math.Abs(Vis1275EX))) +
Math.Abs(((Math.Abs(Vis1300EX) - Math.Abs(cls.Vis1300)) / Math.Abs(Vis1300EX))) +
Math.Abs(((Math.Abs(TempKristalEX) - Math.Abs(cls.TempExit)) / Math.Abs(TempKristalEX))) +
Math.Abs(((Math.Abs(KoffAEX) - Math.Abs(cls.KoffA)) / Math.Abs(KoffAEX))) +
Math.Abs(((Math.Abs(KoffBEX) - Math.Abs(cls.KoffB)) / Math.Abs(KoffBEX))) +
Math.Abs(((Math.Abs(Vis1180EX) - Math.Abs(cls.Vis1180)) / Math.Abs(Vis1180EX))) +
Math.Abs(((Math.Abs(Vis1200EX) - Math.Abs(cls.Vis1200)) / Math.Abs(Vis1200EX))))) / 12) * 100, 2);
#endregion
workBook.Close(false, Type.Missing, Type.Missing);
application.Quit();
return(View());
}
public void solve()
{
minU = Convert.ToDouble(minUTB.Text);
maxU = Convert.ToDouble(maxUTB.Text);
double[,] A;
double[] U;
FileInfo newFile = new FileInfo(filePath);
using (ExcelPackage xlPackage = new ExcelPackage(newFile))
{
SolverContext context = SolverContext.GetContext();
context.ClearModel();
Model model = context.CreateModel();
textBlock.Text = "";
ExcelWorksheet worksheet = xlPackage.Workbook.Worksheets[1];
A = Parcer.A(worksheet);
textBlock.Text += Printer.TwoDimensial(A, true);
U = Parcer.Ust(worksheet);
textBlock.Text += "\nСтационарные потенциалы:\n" + Printer.OneDimensial(U);
Decision[] decs = new Decision[A.GetLength(1)];
for (int i = 0; i < decs.Length; i++)
{
decs[i] = new Decision(Domain.RealNonnegative, "I" + i.ToString());
}
model.AddDecisions(decs);
textBlock.Text += "\nСистема уравнений:\n";
for (int i = 0; i < A.GetLength(0); i++)
{
string expression = "";
string max = (minU + "<=").Replace(',', '.');
string min = ("<=" + maxU).Replace(',', '.');
for (int h = 0; h < decs.Length; h++)
{
expression += A[i, h] + "*I" + h + "+";
}
expression += U[i];
model.AddConstraint("U" + i, max + expression.Replace(',', '.') + min);
textBlock.Text += "КИП" + i + ": U" + i + "=" + expression + "\n";
}
model.AddGoal("minI", GoalKind.Minimize, Model.Sum(decs));
Solution solution = context.Solve(new Directive());
textBlock.Text += "\nРезультат расчетов:\n";
for (int h = 0; h < decs.Length; h++)
{
textBlock.Text += decs[h].Name + "=" + decs[h].ToDouble().ToString() + "\n";
}
textBlock.Text += "\nПри этом достигаются следующие потенциалы:\n";
for (int i = 0; i < A.GetLength(0); i++)
{
double Uf = 0;
for (int h = 0; h < decs.Length; h++)
{
Uf += A[i, h] * decs[h].GetDouble();
}
Uf += U[i];
currUChart.Add(new KeyValuePair <string, double>("КИП" + i, Uf));
maxUChart.Add(new KeyValuePair <string, double>("КИП" + i, 1.5));
minUChart.Add(new KeyValuePair <string, double>("КИП" + i, 0.9));
textBlock.Text += "U" + i + " = " + Uf + "\n";
}
textBlock.Text += "\nВремя вычисления: " + solution.GetReport().SolveTime.ToString() + "мс\n";
if (currUChart.Count > 10)
{
chart.Width = 80 * currUChart.Count;
}
else
{
chart.Width = double.NaN;
}
}
}
//Sampling a card distribution considering which suits the players have
//It uses a CSP from Microsoft SolverFoundation
public List <List <int> > SampleHands(Dictionary <int, List <int> > suitHasPlayer, int[] playerIDs, ref List <List <int> > hands)
{
int[] handSizes = new int[] { hands[0].Capacity - hands[0].Count, hands[1].Capacity - hands[1].Count, hands[2].Capacity - hands[2].Count };
if (deck.Count != handSizes[0] + handSizes[1] + handSizes[2])
{
//Remover este bocado de codigo se o erro nunca mais ocorrer
Console.WriteLine("[" + System.Threading.Thread.CurrentThread.ManagedThreadId + "] - PROBLEM! - deck.Count: " + deck.Count + " P0: " + handSizes[0] + " P1: " + handSizes[1] + " P2: " + handSizes[2] + " deck: " + deckToString());
Console.Out.Flush();
//System.Environment.Exit(1);
}
deck = shuffle(deck);
lock (thisLock)
{
var model = solver.CreateModel();
List <Decision> decisions = new List <Decision>(deck.Count);
List <List <int> > players = getDomains(playerIDs, handSizes);
List <int> player1 = players[0];
List <int> player1Copy = new List <int>(player1);
List <int> player2 = players[1];
List <int> player3 = players[2];
List <int> player3Copy = new List <int>(player3);
Domain domain1 = null, domain2 = null, domain3 = null, domain12 = null, domain23 = null, domain13 = null, domain123 = null;
if (player1.Count > 0)
{
domain1 = Domain.Set(player1.ToArray());
}
if (player2.Count > 0)
{
domain2 = Domain.Set(player2.ToArray());
}
if (player3.Count > 0)
{
domain3 = Domain.Set(player3.ToArray());
}
if (player1.Count > 0 && player2.Count > 0)
{
player1.AddRange(player2);
domain12 = Domain.Set(player1.ToArray());
}
if (player2.Count > 0 && player3.Count > 0)
{
player2.AddRange(player3);
domain23 = Domain.Set(player2.ToArray());
}
if (player1.Count > 0 && player3.Count > 0)
{
player3.AddRange(player1Copy);
domain13 = Domain.Set(player3.ToArray());
}
if (player1.Count > 0 && player2.Count > 0 && player3.Count > 0)
{
player1.AddRange(player3Copy);
domain123 = Domain.Set(player1.ToArray());
}
for (int i = 0; i < deck.Count; i++)
{
int card = deck[i];
List <int> playersThatHaveSuit = suitHasPlayer[Card.GetSuit(card)];
Decision d;
if (playersThatHaveSuit.Count == 3 && domain123 != null)
{
d = new Decision(domain123, "c" + card);
}
else if (playersThatHaveSuit.Count >= 2 && playersThatHaveSuit.Contains(playerIDs[0]) && playersThatHaveSuit.Contains(playerIDs[1]) && domain12 != null)
{
d = new Decision(domain12, "c" + card);
}
else if (playersThatHaveSuit.Count >= 2 && playersThatHaveSuit.Contains(playerIDs[0]) && playersThatHaveSuit.Contains(playerIDs[2]) && domain13 != null)
{
d = new Decision(domain13, "c" + card);
}
else if (playersThatHaveSuit.Count >= 2 && playersThatHaveSuit.Contains(playerIDs[1]) && playersThatHaveSuit.Contains(playerIDs[2]) && domain23 != null)
{
d = new Decision(domain23, "c" + card);
}
else if (playersThatHaveSuit.Count >= 1 && playersThatHaveSuit.Contains(playerIDs[0]) && domain1 != null)
{
d = new Decision(domain1, "c" + card);
}
else if (playersThatHaveSuit.Count >= 1 && playersThatHaveSuit.Contains(playerIDs[1]) && domain2 != null)
{
d = new Decision(domain2, "c" + card);
}
else if (playersThatHaveSuit.Count >= 1 && playersThatHaveSuit.Contains(playerIDs[2]) && domain3 != null)
{
d = new Decision(domain3, "c" + card);
}
else
{
solver.ClearModel();
return(null);
}
decisions.Add(d);
model.AddDecision(d);
}
model.AddConstraint("allDiff", Model.AllDifferent(decisions.ToArray()));
var solution = solver.Solve();
if (solution.Quality != SolverQuality.Feasible)
{
Console.Write("CSP Problem - solution {0}", solution.Quality);
return(null);
}
List <List <int> > cardsPerPlayer = new List <List <int> >(3);
cardsPerPlayer.Add(new List <int>(handSizes[0]));
cardsPerPlayer.Add(new List <int>(handSizes[1]));
cardsPerPlayer.Add(new List <int>(handSizes[2]));
for (int i = 0; i < deck.Count; i++)
{
int decision = Convert.ToInt16(decisions[i].ToString());
decision = decision / 10;
if (decision == playerIDs[0])
{
hands[0].Add(deck[i]);
}
else if (decision == playerIDs[1])
{
hands[1].Add(deck[i]);
}
else if (decision == playerIDs[2])
{
hands[2].Add(deck[i]);
}
else
{
Console.WriteLine("Deck::SampleHands(with CSP) >> Unkown decision");
}
}
solver.ClearModel();
}
return(hands);
}
public string Solve()
{
/***************************
/*Construction of the model*
/***************************/
SolverContext context = SolverContext.GetContext();
//For repeating the solution with other minimum returns
context.ClearModel();
//Create an empty model from context
Model portfolio = context.CreateModel();
//Create a string set with stock names
Set setStocks = new Set(Domain.Any, "Stocks");
/****Decisions*****/
//Create decisions bound to the set. There will be as many decisions as there are values in the set
Decision allocations = new Decision(Domain.RealNonnegative, "Allocations", setStocks);
allocations.SetBinding(StocksHistory, "Allocation", "Stock");
portfolio.AddDecision(allocations);
/***Parameters***/
//Create parameters bound to Covariant matrix
Parameter pCovariants = new Parameter(Domain.Real, "Covariants", setStocks, setStocks);
pCovariants.SetBinding(Covariants, "Variance", "StockI", "StockJ");
//Create parameters bound to mean performance of the stocks over 12 month period
Parameter pMeans = new Parameter(Domain.Real, "Means", setStocks);
pMeans.SetBinding(StocksHistory, "Mean", "Stock");
portfolio.AddParameters(pCovariants, pMeans);
/***Constraints***/
//Portion of a stock should be between 0 and 1
portfolio.AddConstraint("portion", Model.ForEach(setStocks, stock => 0 <= allocations[stock] <= 1));
//Sum of all allocations should be equal to unity
portfolio.AddConstraint("SumPortions", Model.Sum(Model.ForEach(setStocks, stock => allocations[stock])) == 1);
//Expected minimum return
portfolio.AddConstraint("ROI", Model.Sum(Model.ForEach(setStocks, stock => Model.Product(allocations[stock], pMeans[stock]))) >= MinROI);
/***Goals***/
portfolio.AddGoal("Variance", GoalKind.Minimize, Model.Sum
(
Model.ForEach
(
setStocks, stockI =>
Model.ForEach
(
setStocks, stockJ =>
Model.Product(pCovariants[stockI, stockJ], allocations[stockI], allocations[stockJ])
)
)
)
);
/************************************************
/*Add SolveEvent to watch the solving progress *
/************************************************/
EventHandler<SolvingEventArgs> handler = new EventHandler<SolvingEventArgs>(SolvingEventHandler);
// ensure the handler is registered only once when hit the Solve button again.
context.Solving -= handler;
context.Solving += handler;
/*******************
/*Solve the model *
/*******************/
//Use IPM algorithm
Solution solution = context.Solve(new InteriorPointMethodDirective());
//Save the decisions back to the array
if (solution.Quality == SolverQuality.Optimal)
context.PropagateDecisions();
using (TextWriter tw = new StreamWriter("portfolio.qps"))
{
context.SaveModel(FileFormat.MPS, tw);
}
Report report = solution.GetReport();
return report.ToString();
}
private void CreateModel()
{
context = SolverContext.GetContext();
context.ClearModel();
model = context.CreateModel();
items = new Set(Domain.Any, "items");
cost = new Parameter(Domain.Integer, "cost", items);
cost.SetBinding(Round.Players, "Cost", "Name");
score = new Parameter(Domain.Integer, "score", items);
score.SetBinding(Round.Players, "Score", "Name");
team = new Parameter(Domain.IntegerNonnegative, "team", items);
team.SetBinding(Round.Players, "TeamId", "Name");
dummy = new Parameter(Domain.Boolean, "dummy", items);
dummy.SetBinding(Round.Players, "IsDummyPlayer", "Name");
model.AddParameters(cost, score, team, dummy);
choose = new Decision(Domain.IntegerRange(0, 1), "choose", items);
choose.SetBinding(Round.Players, "SelectedValue", "Name");
model.AddDecision(choose);
}
static void ValidateZ3(string fileName, Z3BaseDirective directive)
{
SolverContext context = SolverContext.GetContext();
try
{
LoadModel(context, fileName);
if (context.CurrentModel.Goals.Any())
{
var msfDirective = (directive is Z3MILPDirective) ? (Directive) new MixedIntegerProgrammingDirective()
{
TimeLimit = 10000
}
: (Directive) new Directive()
{
TimeLimit = 10000
};
var sol1 = context.Solve(msfDirective);
Console.WriteLine("Solved the model using MSF.");
Console.Write("{0}", sol1.GetReport());
var expectedGoals = sol1.Goals.Select(x => x.ToDouble());
context.ClearModel();
context.LoadModel(FileFormat.OML, Path.GetFullPath(fileName));
directive.SMT2LogFile = Path.ChangeExtension(fileName, ".smt2");
var sol2 = context.Solve(directive);
//Console.Write("{0}", sol2.GetReport());
var actualGoals = sol2.Goals.Select(x => x.ToDouble());
Console.WriteLine("Solved the model using Z3.");
var goalPairs = expectedGoals.Zip(actualGoals, (expected, actual) => new { expected, actual }).ToArray();
bool validated = goalPairs.All(p => Math.Abs(p.expected - p.actual) <= 0.0001);
if (validated)
{
Console.WriteLine("INFO: Two solvers give approximately the same results.");
}
else
{
Console.Error.WriteLine("ERROR: Discrepancy found between results.");
if (!validated && File.Exists(directive.SMT2LogFile))
{
var sb = new StringBuilder();
for (int i = 0; i < goalPairs.Length; i++)
{
sb.AppendFormat("\n(echo \"Goal {0}: actual |-> {1:0.0000}, expected |-> {2:0.0000}\")",
i + 1, goalPairs[i].actual, goalPairs[i].expected);
}
Console.Error.WriteLine(sb.ToString());
File.AppendAllText(directive.SMT2LogFile, sb.ToString());
}
}
}
else
{
Console.WriteLine("Ignoring this instance without having any goal.");
}
}
catch (Exception e)
{
Console.WriteLine("Skipping unsolvable instance in {0} with error message '{1}'.",
fileName, e.Message);
}
finally
{
context.ClearModel();
}
}
private void button_Click(object sender, RoutedEventArgs e)
{
context.ClearModel();
Model model = context.CreateModel();
List <Decision> decisions = new List <Decision>();
var formula = "";
string con = "";
foreach (var item in dataGridVars.Items)
{
string li = "L" + (item as Invester).Line;
double maxValue = Double.Parse((item as Invester).MaxValue) * Double.Parse(Value.Text) / 100f;
String contrain = li + " <= " + maxValue;
ParseContrain(contrain);
con += " " + li + " +";
Decision dc = new Decision(Domain.RealRange(0, maxValue), li);
decisions.Add(dc);
model.AddDecision(dc);
}
ParseContrain(con.Substring(0, con.Length - 1) + " >= " + Value.Text);
foreach (var item in dataGridVars.Items)
{
formula += " " + Double.Parse((item as Invester).Interest) + " * L" + (item as Invester).Line;
if ((item as Invester).Line <= dataGridVars.Items.Count - 1)
{
formula += " +";
}
String contrain = "L" + (item as Invester).Line + " >= 0 ";
ParseContrain(contrain);
}
TargetFormula = formula.Substring(1, formula.Length - 2);
FormulaTB.Text = TargetFormula;
foreach (var list in ListOfContrains)
{
string c = "";
for (int i = 0; i < list.Capacity; i++)
{
if (i != 0 && i < list.Capacity - 1)
{
c += list[i] >= 0 ? " + " : " - ";
}
if (i == list.Capacity - 1)
{
c += " " + listOfStringContrains[ListOfContrains.IndexOf(list)] + " " + list[i];
}
else
{
c += Math.Abs(list[i]) + " * L" + i;
}
}
model.AddConstraint("C" + ListOfContrains.IndexOf(list), c);
Console.WriteLine(c);
}
model.AddGoal("Goal", GoalKind.Minimize, TargetFormula);
var directive = new SimplexDirective()
{
IterationLimit = -1,
TimeLimit = -1,
Arithmetic = Arithmetic.Exact,
GetSensitivity = true
};
Solution solution = context.Solve(directive);
Quality.Text = solution.Quality.ToString();
Console.WriteLine(solution.GetReport().ToString());
if (solution.Quality != SolverQuality.Optimal)
{
return;
}
context.PropagateDecisions();
for (int i = 0; i < decisions.Count; i++)
{
var old = (dataGridVars.Items[i] as Invester);
old.SelectedValue = decisions[i].ToDouble().ToString();
dataGridVars.Items[i] = old;
}
dataGridVars.Items.Refresh();
dataGridVars.UpdateLayout();
}
private void Solv_Click(object sender, EventArgs e)
{
//Coded by : Mohammed Al Sayed
//Zagzig university ,Group B section 13
if (Objtxt.Text == "")
{
MessageBox.Show("Please Enter The Object Function", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return;
}
try
{
Objtxt.Text = Objtxt.Text.ToLower().TrimEnd(Environment.NewLine.ToCharArray());//triming newline at the end
string objectfunction = Objtxt.Text;
//begin Setting object function
Model model = context.CreateModel();//Creating Linear Programming Model
for (int i = 0; i < objectfunction.Length; i++)
{ //extracting Variables and adding decisions
if (char.IsNumber(objectfunction[i]) && char.IsLetter(objectfunction[i + 1]))
{
objectfunction = objectfunction.Insert(i + 1, "*");//Parsing text into an acceptable Term like 2*x+3*y >> 2x become 2*x
}
else if (char.IsLetter(objectfunction[i]))
{
//Adding Decisions(Variables) into model
model.AddDecision(new Decision(Domain.RealNonnegative, objectfunction[i].ToString()));//each literal represent a variable
}
}
//end setting object function
//begin SettingConstrains
if (Cnstrntxt.Text == "")
{
MessageBox.Show("Please Enter The Constrains", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return;
}
Cnstrntxt.Text = Cnstrntxt.Text.ToLower().TrimEnd(Environment.NewLine.ToCharArray()); //removing newline at the end of the text
string constrainsRaw = Cnstrntxt.Text;
//parsing text into an acceptable MOL term ,, something like that 2*x+4*y a programatic equation
for (int i = 0; i < constrainsRaw.Length - 1; i++)
{
if (char.IsNumber(constrainsRaw[i]) && char.IsLetter(constrainsRaw[i + 1])) //2X
{
constrainsRaw = constrainsRaw.Insert(i + 1, "*"); //2*x
}
}
//spliting constrains
string[] constrains = constrainsRaw.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i <= constrains.GetUpperBound(0); i++)
{
model.AddConstraint("Constrain_" + i.ToString(), constrains[i]);//each line represent a constrain
}
//end setting constrains
//begin setting goal
GoalKind goal; //defining a goal
if (tpcom.SelectedIndex == 1) //goal type
{
goal = GoalKind.Minimize;
}
else
{
goal = GoalKind.Maximize;
}
model.AddGoal("target", goal, objectfunction);
//end setting goal
//begin solving
SimplexDirective simplxReactor = new SimplexDirective(); ///solver object
if (Chksensitivity.Checked)
{
simplxReactor.GetSensitivity = true; //sensitivity
}
if (ChkInfeasibility.Checked)
{
simplxReactor.GetInfeasibility = true; //infeasibility
}
if (cmbAlgorithm.SelectedIndex == 1)
{
simplxReactor.Algorithm = SimplexAlgorithm.Dual; //Algorithm used
}
Solution solution = context.Solve(simplxReactor);
Report report = solution.GetReport(); //defining a report
if (ChkFullReport.Checked)
{
txtreport.Text = report.ToString(); //presenting the report in report textbox
}
ResultTextbox.Text = ""; //removing old values if existed
ResultTextbox.Text = solution.Goals.First().ToDouble().ToString();
VarResultTextbox.Text = "";
foreach (Decision d in model.Decisions) //adding decisions(variables) and they production size in variable textbox
{
VarResultTextbox.Text += d.Name + " = " + d.ToString() + Environment.NewLine;
}
//Duals aka shadow prices
if (chkdual.Checked)
{
txtdual.Text = ""; //removing old values if existed
LinearReport lin = ((LinearReport)solution.GetReport()); //generating a linear programming report out of the solution report
foreach (Microsoft.SolverFoundation.Services.Constraint constraint in model.Constraints) //getting constrains from the model
{
foreach (var dual in lin.GetShadowPrices(constraint)) //getting the shadow prices for each constrain
{
txtdual.Text += dual.Key + " = " + dual.Value.ToDouble().ToString() + Environment.NewLine;
}
}
}
//end shadowprices
//begin Sensitivity Analysis
if (Chksensitivity.Checked)
{
txtbound.Text = ""; //removing old values if existed
LinearReport lin = ((LinearReport)solution.GetReport()); //generating a linear programming report out of the solution report
foreach (Microsoft.SolverFoundation.Services.Constraint constraint in model.Constraints) //getting constrains from the model
{
foreach (var bound in lin.GetConstraintBoundsSensitivity(constraint)) //getting the boundaries prices for each constrain
{
//parsing the boundaries into intervals
//opening the interval if infinity existed
txtbound.Text += bound.Key + " = " + bound.Value.Current.ToDouble().ToString() + Environment.NewLine +
(Double.IsInfinity(bound.Value.Lower.ToDouble()) ? "]" : "[") + bound.Value.Lower.ToDouble().ToString() + " , " + bound.Value.Upper.ToDouble().ToString() + (Double.IsInfinity(bound.Value.Upper.ToDouble()) ? "[" : "]")
+ Environment.NewLine + Environment.NewLine
;
}
}
}
context.ClearModel();//killing the model object so we can create a new one
//end solving
//begin handling errors
}
catch (Exception ex)
{
context.ClearModel();
txtreport.Text = "An Error have occured If you're sure about you entries "
+ "Please Send this report to the programmer" + Environment.NewLine + Environment.NewLine;
txtreport.Text += Objtxt.Text + Environment.NewLine + Environment.NewLine;
txtreport.Text += Cnstrntxt.Text + Environment.NewLine + Environment.NewLine;
txtreport.Text += ex.Message;
txtreport.ForeColor = Color.Red;
MessageBox.Show("Error,Please Check your entries" + Environment.NewLine + Environment.NewLine + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
tabControl1.SelectedIndex = 1;
//end handling errors
}
public ZeroCouponCurve BuildZeroCouponCurve()
{
// 1. Linear interpolate the market curve
double gap = 1.0 / (double)CouponFrequency;
SortedDictionary <double, double> interpMarketCurve = new SortedDictionary <double, double>();
List <double> xs = marketCurve.Keys.ToList <double>();
List <double> ys = marketCurve.Values.ToList <double>();
for (double x = gap; x <= 50; x += gap)
{
interpMarketCurve.Add(x, LinearInterpolation(x, xs, ys));
}
// 2. Find discount factors with a bootstrap method
List <double> discountFactors = new List <double>();
List <double> couponRates = interpMarketCurve.Values.Select(x => x / (double)CouponFrequency).ToList <double>();
for (int i = 0; i < interpMarketCurve.Count; i++)
{
double couponRate = couponRates[i];
Func <Decision, Term> error = (df) =>
{
Term guess = 0;
for (int j = 0; j < i; j++)
{
guess += couponRate * discountFactors[j];
}
guess += (1 + couponRate) * df;
return((guess - 1) * (guess - 1));
};
// Create solver context and model
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Decision df = new Decision(Domain.RealNonnegative, "df");
df.SetInitialValue(1.0);
model.AddDecision(df);
model.AddGoal("error", GoalKind.Minimize, error(df));
Solution solution = context.Solve();
discountFactors.Add(df.GetDouble());
context.ClearModel();
}
// 3. Calculate a zero coupon curve by discount factors
SortedDictionary <double, double> zeroCouponCurve = new SortedDictionary <double, double>();
List <double> yearFracs = interpMarketCurve.Keys.ToList <double>();
for (int i = 0; i < interpMarketCurve.Count; i++)
{
double discountFactor = discountFactors[i];
double yearFrac = yearFracs[i];
double zeroCouponRate = Math.Pow(1 / discountFactor, 1 / yearFrac) - 1;
zeroCouponCurve.Add(yearFrac, zeroCouponRate);
}
return(new ZeroCouponCurve(zeroCouponCurve));
}
public static Dictionary <string, MySolver.Parameter> Solve(double[] Xvals, double[] Yvals,
string formula, Dictionary <string, MySolver.Parameter> coefficients)
{
if (formula.StartsWith("If[FRAP"))//Send to frapa model and return the result
{
return(FRAPA_Model.AllModels.Solve(formula, Xvals, Yvals, coefficients));
}
// create solver model
SolverContext solver = SolverContext.GetContext();
solver.ClearModel();
Model model = solver.CreateModel();
foreach (var parameter in coefficients)
{
if (parameter.Value.Variable)//add variable
{
//m.AddDecision(new Decision(Domain.IntegerRange(0, 100), "b"));
//Decision des = new Decision(Domain.Real, parameter.Key);
Decision des = new Decision(Domain.RealRange(parameter.Value.Min, parameter.Value.Max), parameter.Key);
des.SetInitialValue(parameter.Value.Value);
model.AddDecision(des);
}
else // add scalar
{
Microsoft.SolverFoundation.Services.Parameter par =
new Microsoft.SolverFoundation.Services.Parameter(
Domain.Real, parameter.Key);
//par.SetBinding(new double[] { parameter.Value.Value }, parameter.Key);
par.SetBinding((double)parameter.Value.Value);
model.AddParameters(par);
}
}
//operators: https://msdn.microsoft.com/en-us/library/gg261757(v=vs.93).aspx
string theTerm = "((" + formula.Replace("t", Xvals[0].ToString()).Replace("Sqr" + Xvals[0].ToString(), "Sqrt") + ") - " + Yvals[0].ToString() + ") ^ 2";
for (int i = 1; i < Xvals.Length && i < Yvals.Length; i++)
{
theTerm += " + ((" + formula.Replace("t", Xvals[i].ToString()).Replace("Sqr" + Xvals[i].ToString(), "Sqrt") + ") - " + Yvals[i].ToString() + ") ^ 2";
}
//
// define optimization type and give objective function SUM(e^2) to be minimized
model.AddGoal("SumOfSquaredErrors", GoalKind.Minimize, theTerm);
//
// solve model and transfer results (optimized decision variables) from
// model into a dictionary object which will be returned for the caller
Solution solution = solver.Solve();
//return the result
Dictionary <string, MySolver.Parameter> parameters = new Dictionary <string, MySolver.Parameter>();
foreach (Decision parameter in model.Decisions)
{
MySolver.Parameter p;
if (!coefficients.TryGetValue(parameter.Name, out p))
{
p = new Parameter(parameter.Name);
}
parameters.Add(parameter.Name, new Parameter
(parameter.Name, parameter.ToDouble(), p.Min, p.Max, p.Variable));
}
return(parameters);
}
public void SetUp()
{
SolverContext context = SolverContext.GetContext();
context.ClearModel();
}
public static Decision SBFF()
{
// -----------------------------Game Matrix-------------------------------------------
IEnumerable <TheModelStructure> pStrategies = new List <TheModelStructure>()
{
new TheModelStructure()
{
tName = "T1", uDC = 5, uAU = 5, uDU = -20, uAC = -24, dMS = 0.07
},
new TheModelStructure()
{
tName = "T2", uDC = 2, uAU = 2, uDU = -8, uAC = -12, dMS = 0.07
},
new TheModelStructure()
{
tName = "T3", uDC = 6, uAU = 6, uDU = -24, uAC = -28, dMS = 0.09
},
new TheModelStructure()
{
tName = "T4", uDC = 2, uAU = 1, uDU = -8, uAC = -12, dMS = 0.07
},
new TheModelStructure()
{
tName = "T5", uDC = 4, uAU = 4, uDU = -16, uAC = -20, dMS = 0.07
},
new TheModelStructure()
{
tName = "T6", uDC = 3, uAU = 3, uDU = -9, uAC = -13, dMS = 0.07
},
new TheModelStructure()
{
tName = "T7", uDC = 3, uAU = 3, uDU = -12, uAC = -16, dMS = 0.07
},
new TheModelStructure()
{
tName = "T8", uDC = 8, uAU = 7, uDU = -32, uAC = -36, dMS = 0.35
},
new TheModelStructure()
{
tName = "T9", uDC = 2, uAU = 2, uDU = -8, uAC = -12, dMS = 0.07
},
new TheModelStructure()
{
tName = "T10", uDC = 6, uAU = 6, uDU = -24, uAC = -28, dMS = 0.07
}
//new TheModelStructure() {tableName = "Table11", tableValue = 5},
//new TheModelStructure() {tableName = "Table12", tableValue = 3},
//new TheModelStructure() {tableName = "Table13", tableValue = 4},
//new TheModelStructure() {tableName = "Table14", tableValue = 3},
//new TheModelStructure() {tableName = "Table15", tableValue = 4},
//new TheModelStructure() {tableName = "Table16", tableValue = 7},
//new TheModelStructure() {tableName = "Table17", tableValue = 5},
//new TheModelStructure() {tableName = "Table18", tableValue = 8},
//new TheModelStructure() {tableName = "Table19", tableValue = 4},
//new TheModelStructure() {tableName = "Table20", tableValue = 5}
};
//---------------------------Intilizing the solver----------------------------------------------
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Set modelStructure = new Set(Domain.Any, "game");
//----------------------------Game parameters----------------------------------------------------
Parameter uDC = new Parameter(Domain.Integer, "uDC", modelStructure);
uDC.SetBinding(pStrategies, "uDC", "tName"); // bind to the field.
model.AddParameters(uDC);
Parameter uDU = new Parameter(Domain.Integer, "uDU", modelStructure);
uDU.SetBinding(pStrategies, "uDU", "tName"); // bind to the field.
model.AddParameters(uDU);
Parameter uAU = new Parameter(Domain.Integer, "uAU", modelStructure);
uAU.SetBinding(pStrategies, "uAU", "tName"); // bind to the field.
model.AddParameters(uAU);
Parameter uAC = new Parameter(Domain.Integer, "uAC", modelStructure);
uAC.SetBinding(pStrategies, "uAC", "tName"); // bind to the field.
model.AddParameters(uAC);
Parameter dMS = new Parameter(Domain.Real, "dMS", modelStructure);
dMS.SetBinding(pStrategies, "dMS", "tName"); // bind to the field.
model.AddParameters(dMS);
//---------------------------Decision Variables------------------------------------------------
Decision fMS = new Decision(Domain.RealRange(0.03, 0.40), "fMS", modelStructure);
model.AddDecision(fMS);
//----------------------------Objective function----------------------------------------------
model.AddGoal("aGoal", GoalKind.Maximize, Model.Sum(
Model.ForEach(modelStructure, i => fMS[i] * dMS[i] * uAC[i] + (1 - fMS[i]) * (1 - dMS[i]) * uAU[i])));
model.AddConstraint("fms",
Model.Sum(Model.ForEach(modelStructure, i => fMS[i])) == 1);
//-------------------------------Solvig the game------------------------------------
try
{
var solution = context.Solve();
}
catch (Exception e)
{
throw e;
}
context.ClearModel();
return(fMS);
}
private void button1_Click(object sender, EventArgs e)
{
Stenka_Model sm = new Stenka_Model();
if (Tb_l_ogn.Text == "" || Tb_l_1.Text == "" || Tb_l_2.Text == "" || Tb_C1.Text == "" || Tb_C2.Text == "" || Tb_x0.Text == "" || Tb_trab.Text == "" || Tb_tokr.Text == "" || Tb_tnp.Text == "" || Tb_anar.Text == "" || Tb_arab.Text == "")
{
MessageBox.Show("Не все поля заполнены!", "Ошибка");
return;
}
else
{
tp_Graph.Parent = Tab_cont;
chart1.Series[0].Points.Clear();
chart1.Series[1].Points.Clear();
sm.l_ogn = Double.Parse(Tb_l_ogn.Text);
sm.l_1 = Double.Parse(Tb_l_1.Text);
sm.l_2 = Double.Parse(Tb_l_2.Text);
sm.c1 = Double.Parse(Tb_C1.Text);
sm.c2 = Double.Parse(Tb_C2.Text);
sm.x0 = Double.Parse(Tb_x0.Text);
sm.t_rab = Double.Parse(Tb_trab.Text);
sm.t_okr = Double.Parse(Tb_tokr.Text);
sm.t_np = Double.Parse(Tb_tnp.Text);
sm.a_nar = Double.Parse(Tb_anar.Text);
sm.a_rab = Double.Parse(Tb_arab.Text);
List <SolverRow> solverList = new List <SolverRow>();
solverList.Add(new SolverRow {
xId = 1, Koef_C = sm.c1
});
solverList.Add(new SolverRow {
xId = 2, Koef_C = sm.c2
});
SolverContext cntxt = SolverContext.GetContext();
cntxt.ClearModel();
Model model = cntxt.CreateModel();
Set users = new Set(Domain.Any, "users");
//Parameter l_ogn = new Parameter(Domain.Real, "l_ogn", users);
//l_ogn.SetBinding ()
Parameter Koef_C = new Parameter(Domain.Real, "Koef_C", users);
Koef_C.SetBinding(solverList, "Koef_C", "xId");
model.AddParameter(Koef_C);
Decision choose = new Decision(Domain.RealNonnegative, "choose", users);
model.AddDecisions(choose);
model.AddGoal("goal", GoalKind.Minimize, Model.Sum(Model.ForEach(users, xId => choose[xId] * Koef_C[xId])));
//model.AddConstraint("c_choose", Model.ForEach(users, xId => (min[xId] <= choose[xId] <= max[xId])));
model.AddConstraint("X1", choose[1] >= 0);
model.AddConstraint("X2", choose[2] >= 0);
model.AddConstraint("X_Sum", Model.Sum(Model.ForEach(users, xId => choose[xId])) <= sm.x0 / 1000d);
model.AddConstraint("Temp", sm.t_okr <= sm.t_np);
model.AddConstraint("K_sigma", (sm.t_np - (sm.t_okr + ((sm.t_rab - sm.t_okr) / (((1 / sm.a_rab) + (choose[1] / sm.l_1) + (choose[2] / sm.l_2) + (1 / sm.a_nar)) * sm.a_nar)))) >= 0);
try
{
Solution solution = cntxt.Solve();
Report report = solution.GetReport();
//String reportStr = "";
//for (int i = 0; i < solverList.Count; i++)
//{
// reportStr += "Значение X" + (i + 1).ToString() + ": " + choose.GetDouble(solverList[i].xId) + "\n";
//}
// reportStr += "\n" + report.ToString();
//MessageBox.Show(reportStr);
}
catch (Exception ex)
{
MessageBox.Show("При решении задачи оптимизации возникла исключительная ситуация.");
}
double x1 = Math.Round(choose.GetDouble(solverList[0].xId), 3);
double x2 = Math.Round(choose.GetDouble(solverList[1].xId), 3);
this.chart1.Series[0].Points.AddXY("Толщина стенок, м", x1);
this.chart1.Series[1].Points.AddXY("Толщина стенок, м", x2);
if (dataGridView1.RowCount == 1)
{
dataGridView1[0, 0].Value = x1;
dataGridView1[1, 0].Value = x2;
}
else
{
dataGridView1.Rows.Add(x1, x2);
}
}
}
private Dictionary <String, double> solve(List <BinaryOption> variables, List <double> results, List <List <BinaryOption> > configurations, List <Interaction> interactions)
{
Dictionary <String, double> optionInfluences = new Dictionary <string, double>();
foreach (BinaryOption elem in variables)
{
optionInfluences.Add(elem.Name, 0);
}
if (interactions != null)
{
foreach (Interaction inter in interactions)
{
optionInfluences.Add(inter.Name, 0);
}
}
//Building the OML model
StringBuilder omlModel = new StringBuilder();
omlModel.Append("Model[");
String decisions = generateDecisionOML(variables, results);
omlModel.Append(decisions + ",");
String constraints = generateConstraintOML(variables, configurations, interactions, results);
omlModel.Append(constraints + ",");
String goal = generateGoalOML(results.Count);
omlModel.Append(goal + "]");
Console.WriteLine(omlModel);
SolverContext context = SolverContext.GetContext();
context.ClearModel();
//String model = "Model[Decisions[Reals[0,Infinity], f1,f2,y1,y2,y3],Constraints[f1+y1==1,f1+f2+y2==4,f2+y3==3],Goals[Minimize[y1+y2+y3]]]";
//String model = "Model[Decisions[Reals[0,Infinity],fp1,fn1,fp2,fn2,yp1,yn1,yp2,yn2,yp3,yn3],Constraints[fp1-fn1+yp1-yn1==1,fp1-fn1+fp2-fn2+yp2-yn2==0,fp2-fn2+yp3-yn3==-1],Goals[Minimize[yp1+yn1+yp2+yn2+yp3+yn3]]]";
//Console.WriteLine(omlModel.ToString());
context.LoadModel(FileFormat.OML, new StringReader(omlModel.ToString()));
//List<double> erglist = new List<double>();
//Solve the optimization problem
if (context.CheckModel().IsValid)
{
Solution solution = context.Solve();
StringBuilder sb = new StringBuilder();
foreach (Decision d in solution.Decisions)
{
sb.Append(d.ToString() + "; ");
//Constructing feature Values
string option = d.Name.Substring(0, d.Name.Length - 2);
if (d.Name.EndsWith("_p"))
{
optionInfluences[option] += d.ToDouble();
}
else if (d.Name.EndsWith("_n"))
{
optionInfluences[option] -= d.ToDouble();
}
}
/*if (this.withStandardDeviation && this.standardDeviation != 0)
* {
* foreach (BinaryOption elem in variables)
* {
* if(featureValues[elem.Name] == 0)
* continue;
* int configNb = 0;
* foreach (List<BinaryOption> config in configurations)
* {
* bool derivativeRequired = true;
* foreach(Element parent in elem.getDerivativeParents())
* {
* if(config.Contains(parent) == false)
* {
* derivativeRequired = false;
* break;
* }
* }
* if(derivativeRequired)
* {
* double equationValue = results[configNb];
* if (Math.Abs(featureValues[elem.Name]) < Math.Abs(equationValue * this.standardDeviation / 100))
* {
* featureValues[elem.Name] = 0;
* break;
* }
* }
* configNb++;
* }
* }
* }*/
}
return(optionInfluences);
}
private void btnCalc_Click(object sender, EventArgs e)
{
if (
#region ---
(txtRashod_PG_base_DP_1.Text == "") ||
(txtRashod_PG_base_DPmin_1.Text == "") ||
(txtRashod_PG_base_DPmax_1.Text == "") ||
(txtRashod_K_base_DP_1.Text == "") ||
(txtRashod_K_base_DP_E_1.Text == "") ||
(txtProizvoditelnost_chug_base_DP_1.Text == "") ||
(txtTeor_t_base_DP_1.Text == "") ||
(txtTeor_t_base_DPmin_1.Text == "") ||
(txtTeor_t_base_DPmax_1.Text == "") ||
(txtProiz_chug_iz_PG_DP_1.Text == "") ||
(txtProiz_chug_uvel_K_DP_1.Text == "") ||
(txtIz_t_uvel_pg_DP_1.Text == "") ||
(txtRashod_PG_base_DP_2.Text == "") ||
(txtRashod_PG_base_DPmin_2.Text == "") ||
(txtRashod_PG_base_DPmax_2.Text == "") ||
(txtRashod_K_base_DP_2.Text == "") ||
(txtRashod_K_base_DP_E_2.Text == "") ||
(txtProizvoditelnost_chug_base_DP_2.Text == "") ||
(txtTeor_t_base_DP_2.Text == "") ||
(txtTeor_t_base_DPmin_2.Text == "") ||
(txtTeor_t_base_DPmax_2.Text == "") ||
(txtProiz_chug_iz_PG_DP_2.Text == "") ||
(txtProiz_chug_uvel_K_DP_2.Text == "") ||
(txtIz_t_uvel_pg_DP_2.Text == "") ||
(txtRashod_PG_base_DP_3.Text == "") ||
(txtRashod_PG_base_DPmin_3.Text == "") ||
(txtRashod_PG_base_DPmax_3.Text == "") ||
(txtRashod_K_base_DP_3.Text == "") ||
(txtRashod_K_base_DP_E_3.Text == "") ||
(txtProizvoditelnost_chug_base_DP_3.Text == "") ||
(txtTeor_t_base_DP_3.Text == "") ||
(txtTeor_t_base_DPmin_3.Text == "") ||
(txtTeor_t_base_DPmax_3.Text == "") ||
(txtProiz_chug_iz_PG_DP_3.Text == "") ||
(txtProiz_chug_uvel_K_DP_3.Text == "") ||
(txtIz_t_uvel_pg_DP_3.Text == "") ||
(txtRashod_PG_base_DP_4.Text == "") ||
(txtRashod_PG_base_DPmin_4.Text == "") ||
(txtRashod_PG_base_DPmax_4.Text == "") ||
(txtRashod_K_base_DP_4.Text == "") ||
(txtRashod_K_base_DP_E_4.Text == "") ||
(txtProizvoditelnost_chug_base_DP_4.Text == "") ||
(txtTeor_t_base_DP_4.Text == "") ||
(txtTeor_t_base_DPmin_4.Text == "") ||
(txtTeor_t_base_DPmax_4.Text == "") ||
(txtProiz_chug_iz_PG_DP_4.Text == "") ||
(txtProiz_chug_uvel_K_DP_4.Text == "") ||
(txtIz_t_uvel_pg_DP_4.Text == "") ||
(txtRashod_PG_base_DP_5.Text == "") ||
(txtRashod_PG_base_DPmin_5.Text == "") ||
(txtRashod_PG_base_DPmax_5.Text == "") ||
(txtRashod_K_base_DP_5.Text == "") ||
(txtRashod_K_base_DP_E_5.Text == "") ||
(txtProizvoditelnost_chug_base_DP_5.Text == "") ||
(txtTeor_t_base_DP_5.Text == "") ||
(txtTeor_t_base_DPmin_5.Text == "") ||
(txtTeor_t_base_DPmax_5.Text == "") ||
(txtProiz_chug_iz_PG_DP_5.Text == "") ||
(txtProiz_chug_uvel_K_DP_5.Text == "") ||
(txtIz_t_uvel_pg_DP_5.Text == "") ||
(txtRashod_PG_base_DP_6.Text == "") ||
(txtRashod_PG_base_DPmin_6.Text == "") ||
(txtRashod_PG_base_DPmax_6.Text == "") ||
(txtRashod_K_base_DP_6.Text == "") ||
(txtRashod_K_base_DP_E_6.Text == "") ||
(txtProizvoditelnost_chug_base_DP_6.Text == "") ||
(txtTeor_t_base_DP_6.Text == "") ||
(txtTeor_t_base_DPmin_6.Text == "") ||
(txtTeor_t_base_DPmax_6.Text == "") ||
(txtProiz_chug_iz_PG_DP_6.Text == "") ||
(txtProiz_chug_uvel_K_DP_6.Text == "") ||
(txtIz_t_uvel_pg_DP_6.Text == "") ||
(txtRashod_PG_base_DP_7.Text == "") ||
(txtRashod_PG_base_DPmin_7.Text == "") ||
(txtRashod_PG_base_DPmax_7.Text == "") ||
(txtRashod_K_base_DP_7.Text == "") ||
(txtRashod_K_base_DP_E_7.Text == "") ||
(txtProizvoditelnost_chug_base_DP_7.Text == "") ||
(txtTeor_t_base_DP_7.Text == "") ||
(txtTeor_t_base_DPmin_7.Text == "") ||
(txtTeor_t_base_DPmax_7.Text == "") ||
(txtProiz_chug_iz_PG_DP_7.Text == "") ||
(txtProiz_chug_uvel_K_DP_7.Text == "") ||
(txtIz_t_uvel_pg_DP_7.Text == "") ||
(txtRashod_PG_base_DP_8.Text == "") ||
(txtRashod_PG_base_DPmin_8.Text == "") ||
(txtRashod_PG_base_DPmax_8.Text == "") ||
(txtRashod_K_base_DP_8.Text == "") ||
(txtRashod_K_base_DP_E_8.Text == "") ||
(txtProizvoditelnost_chug_base_DP_8.Text == "") ||
(txtTeor_t_base_DP_8.Text == "") ||
(txtTeor_t_base_DPmin_8.Text == "") ||
(txtTeor_t_base_DPmax_8.Text == "") ||
(txtProiz_chug_iz_PG_DP_8.Text == "") ||
(txtProiz_chug_uvel_K_DP_8.Text == "") ||
(txtIz_t_uvel_pg_DP_8.Text == ""))
#endregion ---
{
tPGraph.Parent = null;
MessageBox.Show("Не все поля заполнены!", "Ошибка");
return;
}
//очищаем
chart1.Series[0].Points.Clear();
chart1.Series[1].Points.Clear();
//при нажатии на кнопку, открывается вкладка
tPGraph.Parent = tab;
List <ModelDP> modelDPs = new List <ModelDP>();
#region -- Загрузка первоначальных значений
// ДП-1
_mdp.Rashod_PG_base_DP_1 = Double.Parse(txtRashod_PG_base_DP_1.Text);
_mdp.Rashod_PG_base_DPmin_1 = Double.Parse(txtRashod_PG_base_DPmin_1.Text);
_mdp.Rashod_PG_base_DPmax_1 = Double.Parse(txtRashod_PG_base_DPmax_1.Text);
_mdp.Rashod_K_base_DP_1 = Double.Parse(txtRashod_K_base_DP_1.Text);
_mdp.Rashod_K_base_DP_E_1 = Double.Parse(txtRashod_K_base_DP_E_1.Text);
_mdp.Proizvoditelnost_chug_base_DP_1 = Double.Parse(txtProizvoditelnost_chug_base_DP_1.Text);
_mdp.Teor_t_base_DP_1 = Double.Parse(txtTeor_t_base_DP_1.Text);
_mdp.Teor_t_base_DPmin_1 = Double.Parse(txtTeor_t_base_DPmin_1.Text);
_mdp.Teor_t_base_DPmax_1 = Double.Parse(txtTeor_t_base_DPmax_1.Text);
_mdp.Proiz_chug_iz_PG_DP_1 = Double.Parse(txtProiz_chug_iz_PG_DP_1.Text);
_mdp.Proiz_chug_uvel_K_DP_1 = Double.Parse(txtProiz_chug_uvel_K_DP_1.Text);
_mdp.Iz_t_uvel_pg_DP_1 = Double.Parse(txtIz_t_uvel_pg_DP_1.Text);
// ДП-2
_mdp.Rashod_PG_base_DP_2 = Double.Parse(txtRashod_PG_base_DP_2.Text);
_mdp.Rashod_PG_base_DPmin_2 = Double.Parse(txtRashod_PG_base_DPmin_2.Text);
_mdp.Rashod_PG_base_DPmax_2 = Double.Parse(txtRashod_PG_base_DPmax_2.Text);
_mdp.Rashod_K_base_DP_2 = Double.Parse(txtRashod_K_base_DP_2.Text);
_mdp.Rashod_K_base_DP_E_2 = Double.Parse(txtRashod_K_base_DP_E_2.Text);
_mdp.Proizvoditelnost_chug_base_DP_2 = Double.Parse(txtProizvoditelnost_chug_base_DP_2.Text);
_mdp.Teor_t_base_DP_2 = Double.Parse(txtTeor_t_base_DP_2.Text);
_mdp.Teor_t_base_DPmin_2 = Double.Parse(txtTeor_t_base_DPmin_2.Text);
_mdp.Teor_t_base_DPmax_2 = Double.Parse(txtTeor_t_base_DPmax_2.Text);
_mdp.Proiz_chug_iz_PG_DP_2 = Double.Parse(txtProiz_chug_iz_PG_DP_2.Text);
_mdp.Proiz_chug_uvel_K_DP_2 = Double.Parse(txtProiz_chug_uvel_K_DP_2.Text);
_mdp.Iz_t_uvel_pg_DP_2 = Double.Parse(txtIz_t_uvel_pg_DP_2.Text);
// ДП-3
_mdp.Rashod_PG_base_DP_3 = Double.Parse(txtRashod_PG_base_DP_3.Text);
_mdp.Rashod_PG_base_DPmin_3 = Double.Parse(txtRashod_PG_base_DPmin_3.Text);
_mdp.Rashod_PG_base_DPmax_3 = Double.Parse(txtRashod_PG_base_DPmax_3.Text);
_mdp.Rashod_K_base_DP_3 = Double.Parse(txtRashod_K_base_DP_3.Text);
_mdp.Rashod_K_base_DP_E_3 = Double.Parse(txtRashod_K_base_DP_E_3.Text);
_mdp.Proizvoditelnost_chug_base_DP_3 = Double.Parse(txtProizvoditelnost_chug_base_DP_3.Text);
_mdp.Teor_t_base_DP_3 = Double.Parse(txtTeor_t_base_DP_3.Text);
_mdp.Teor_t_base_DPmin_3 = Double.Parse(txtTeor_t_base_DPmin_3.Text);
_mdp.Teor_t_base_DPmax_3 = Double.Parse(txtTeor_t_base_DPmax_3.Text);
_mdp.Proiz_chug_iz_PG_DP_3 = Double.Parse(txtProiz_chug_iz_PG_DP_3.Text);
_mdp.Proiz_chug_uvel_K_DP_3 = Double.Parse(txtProiz_chug_uvel_K_DP_3.Text);
_mdp.Iz_t_uvel_pg_DP_3 = Double.Parse(txtIz_t_uvel_pg_DP_3.Text);
// ДП-4
_mdp.Rashod_PG_base_DP_4 = Double.Parse(txtRashod_PG_base_DP_4.Text);
_mdp.Rashod_PG_base_DPmin_4 = Double.Parse(txtRashod_PG_base_DPmin_4.Text);
_mdp.Rashod_PG_base_DPmax_4 = Double.Parse(txtRashod_PG_base_DPmax_4.Text);
_mdp.Rashod_K_base_DP_4 = Double.Parse(txtRashod_K_base_DP_4.Text);
_mdp.Rashod_K_base_DP_E_4 = Double.Parse(txtRashod_K_base_DP_E_4.Text);
_mdp.Proizvoditelnost_chug_base_DP_4 = Double.Parse(txtProizvoditelnost_chug_base_DP_4.Text);
_mdp.Teor_t_base_DP_4 = Double.Parse(txtTeor_t_base_DP_4.Text);
_mdp.Teor_t_base_DPmin_4 = Double.Parse(txtTeor_t_base_DPmin_4.Text);
_mdp.Teor_t_base_DPmax_4 = Double.Parse(txtTeor_t_base_DPmax_4.Text);
_mdp.Proiz_chug_iz_PG_DP_4 = Double.Parse(txtProiz_chug_iz_PG_DP_4.Text);
_mdp.Proiz_chug_uvel_K_DP_4 = Double.Parse(txtProiz_chug_uvel_K_DP_4.Text);
_mdp.Iz_t_uvel_pg_DP_4 = Double.Parse(txtIz_t_uvel_pg_DP_4.Text);
// ДП-5
_mdp.Rashod_PG_base_DP_5 = Double.Parse(txtRashod_PG_base_DP_5.Text);
_mdp.Rashod_PG_base_DPmin_5 = Double.Parse(txtRashod_PG_base_DPmin_5.Text);
_mdp.Rashod_PG_base_DPmax_5 = Double.Parse(txtRashod_PG_base_DPmax_5.Text);
_mdp.Rashod_K_base_DP_5 = Double.Parse(txtRashod_K_base_DP_5.Text);
_mdp.Rashod_K_base_DP_E_5 = Double.Parse(txtRashod_K_base_DP_E_5.Text);
_mdp.Proizvoditelnost_chug_base_DP_5 = Double.Parse(txtProizvoditelnost_chug_base_DP_5.Text);
_mdp.Teor_t_base_DP_5 = Double.Parse(txtTeor_t_base_DP_5.Text);
_mdp.Teor_t_base_DPmin_5 = Double.Parse(txtTeor_t_base_DPmin_5.Text);
_mdp.Teor_t_base_DPmax_5 = Double.Parse(txtTeor_t_base_DPmax_5.Text);
_mdp.Proiz_chug_iz_PG_DP_5 = Double.Parse(txtProiz_chug_iz_PG_DP_5.Text);
_mdp.Proiz_chug_uvel_K_DP_5 = Double.Parse(txtProiz_chug_uvel_K_DP_5.Text);
_mdp.Iz_t_uvel_pg_DP_5 = Double.Parse(txtIz_t_uvel_pg_DP_5.Text);
// ДП-6
_mdp.Rashod_PG_base_DP_6 = Double.Parse(txtRashod_PG_base_DP_6.Text);
_mdp.Rashod_PG_base_DPmin_6 = Double.Parse(txtRashod_PG_base_DPmin_6.Text);
_mdp.Rashod_PG_base_DPmax_6 = Double.Parse(txtRashod_PG_base_DPmax_6.Text);
_mdp.Rashod_K_base_DP_6 = Double.Parse(txtRashod_K_base_DP_6.Text);
_mdp.Rashod_K_base_DP_E_6 = Double.Parse(txtRashod_K_base_DP_E_6.Text);
_mdp.Proizvoditelnost_chug_base_DP_6 = Double.Parse(txtProizvoditelnost_chug_base_DP_6.Text);
_mdp.Teor_t_base_DP_6 = Double.Parse(txtTeor_t_base_DP_6.Text);
_mdp.Teor_t_base_DPmin_6 = Double.Parse(txtTeor_t_base_DPmin_6.Text);
_mdp.Teor_t_base_DPmax_6 = Double.Parse(txtTeor_t_base_DPmax_6.Text);
_mdp.Proiz_chug_iz_PG_DP_6 = Double.Parse(txtProiz_chug_iz_PG_DP_6.Text);
_mdp.Proiz_chug_uvel_K_DP_6 = Double.Parse(txtProiz_chug_uvel_K_DP_6.Text);
_mdp.Iz_t_uvel_pg_DP_6 = Double.Parse(txtIz_t_uvel_pg_DP_6.Text);
// ДП-7
_mdp.Rashod_PG_base_DP_7 = Double.Parse(txtRashod_PG_base_DP_7.Text);
_mdp.Rashod_PG_base_DPmin_7 = Double.Parse(txtRashod_PG_base_DPmin_7.Text);
_mdp.Rashod_PG_base_DPmax_7 = Double.Parse(txtRashod_PG_base_DPmax_7.Text);
_mdp.Rashod_K_base_DP_7 = Double.Parse(txtRashod_K_base_DP_7.Text);
_mdp.Rashod_K_base_DP_E_7 = Double.Parse(txtRashod_K_base_DP_E_7.Text);
_mdp.Proizvoditelnost_chug_base_DP_7 = Double.Parse(txtProizvoditelnost_chug_base_DP_7.Text);
_mdp.Teor_t_base_DP_7 = Double.Parse(txtTeor_t_base_DP_7.Text);
_mdp.Teor_t_base_DPmin_7 = Double.Parse(txtTeor_t_base_DPmin_7.Text);
_mdp.Teor_t_base_DPmax_7 = Double.Parse(txtTeor_t_base_DPmax_7.Text);
_mdp.Proiz_chug_iz_PG_DP_7 = Double.Parse(txtProiz_chug_iz_PG_DP_7.Text);
_mdp.Proiz_chug_uvel_K_DP_7 = Double.Parse(txtProiz_chug_uvel_K_DP_7.Text);
_mdp.Iz_t_uvel_pg_DP_7 = Double.Parse(txtIz_t_uvel_pg_DP_7.Text);
// ДП-8
_mdp.Rashod_PG_base_DP_8 = Double.Parse(txtRashod_PG_base_DP_8.Text);
_mdp.Rashod_PG_base_DPmin_8 = Double.Parse(txtRashod_PG_base_DPmin_8.Text);
_mdp.Rashod_PG_base_DPmax_8 = Double.Parse(txtRashod_PG_base_DPmax_8.Text);
_mdp.Rashod_K_base_DP_8 = Double.Parse(txtRashod_K_base_DP_8.Text);
_mdp.Rashod_K_base_DP_E_8 = Double.Parse(txtRashod_K_base_DP_E_8.Text);
_mdp.Proizvoditelnost_chug_base_DP_8 = Double.Parse(txtProizvoditelnost_chug_base_DP_8.Text);
_mdp.Teor_t_base_DP_8 = Double.Parse(txtTeor_t_base_DP_8.Text);
_mdp.Teor_t_base_DPmin_8 = Double.Parse(txtTeor_t_base_DPmin_8.Text);
_mdp.Teor_t_base_DPmax_8 = Double.Parse(txtTeor_t_base_DPmax_8.Text);
_mdp.Proiz_chug_iz_PG_DP_8 = Double.Parse(txtProiz_chug_iz_PG_DP_8.Text);
_mdp.Proiz_chug_uvel_K_DP_8 = Double.Parse(txtProiz_chug_uvel_K_DP_8.Text);
_mdp.Iz_t_uvel_pg_DP_8 = Double.Parse(txtIz_t_uvel_pg_DP_8.Text);
//параметры
_mdp.Stoimoct_k = Double.Parse(txtStoimoct_k.Text);
_mdp.Stoimoct_pg = Double.Parse(txtStoimoct_pg.Text);
_mdp.Rezerf_rashod_pg = Double.Parse(txtRezerf_rashod_pg.Text);
_mdp.Zapas_k = Double.Parse(txtZapas_k.Text);
_mdp.Treb_proiz_chug = Double.Parse(txtTreb_proiz_chug.Text);
#endregion -- Загрузка первоначальных значений
#region ---
//Для ДП1
modelDPs.Add(new ModelDP {
xId = 1,
Koef = (_mdp.Rashod_K_base_DP_E_1 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_1),
KoefNerav11 = (_mdp.Rashod_K_base_DP_1 + 0.001 * _mdp.Rashod_PG_base_DP_1 * _mdp.Rashod_K_base_DP_E_1),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_1 - _mdp.Rashod_K_base_DP_E_1 * _mdp.Proiz_chug_uvel_K_DP_1,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_1 * _mdp.Proiz_chug_iz_PG_DP_1 + _mdp.Rashod_K_base_DP_E_1 * _mdp.Rashod_PG_base_DP_1 * _mdp.Proiz_chug_uvel_K_DP_1 + _mdp.Proizvoditelnost_chug_base_DP_1,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_1 + _mdp.Rashod_PG_base_DP_1 * _mdp.Iz_t_uvel_pg_DP_1 - _mdp.Teor_t_base_DP_1) / _mdp.Iz_t_uvel_pg_DP_1,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_1 + _mdp.Rashod_PG_base_DP_1 * _mdp.Iz_t_uvel_pg_DP_1 - _mdp.Teor_t_base_DP_1) / _mdp.Iz_t_uvel_pg_DP_1,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_1,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_1,
});
//Для ДП2
modelDPs.Add(new ModelDP
{
xId = 2,
Koef = (_mdp.Rashod_K_base_DP_E_2 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_2),
KoefNerav11 = (_mdp.Rashod_K_base_DP_2 + 0.001 * _mdp.Rashod_PG_base_DP_2 * _mdp.Rashod_K_base_DP_E_2),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_2 - _mdp.Rashod_K_base_DP_E_2 * _mdp.Proiz_chug_uvel_K_DP_2,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_2 * _mdp.Proiz_chug_iz_PG_DP_2 + _mdp.Rashod_K_base_DP_E_2 * _mdp.Rashod_PG_base_DP_2 * _mdp.Proiz_chug_uvel_K_DP_2 + _mdp.Proizvoditelnost_chug_base_DP_2,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_2 + _mdp.Rashod_PG_base_DP_2 * _mdp.Iz_t_uvel_pg_DP_2 - _mdp.Teor_t_base_DP_2) / _mdp.Iz_t_uvel_pg_DP_2,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_2 + _mdp.Rashod_PG_base_DP_2 * _mdp.Iz_t_uvel_pg_DP_2 - _mdp.Teor_t_base_DP_2) / _mdp.Iz_t_uvel_pg_DP_2,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_2,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_2
});
//Для ДП3
modelDPs.Add(new ModelDP
{
xId = 3,
Koef = (_mdp.Rashod_K_base_DP_E_3 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_3),
KoefNerav11 = (_mdp.Rashod_K_base_DP_3 + 0.001 * _mdp.Rashod_PG_base_DP_3 * _mdp.Rashod_K_base_DP_E_3),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_3 - _mdp.Rashod_K_base_DP_E_3 * _mdp.Proiz_chug_uvel_K_DP_3,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_3 * _mdp.Proiz_chug_iz_PG_DP_3 + _mdp.Rashod_K_base_DP_E_3 * _mdp.Rashod_PG_base_DP_3 * _mdp.Proiz_chug_uvel_K_DP_3 + _mdp.Proizvoditelnost_chug_base_DP_3,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_3 + _mdp.Rashod_PG_base_DP_3 * _mdp.Iz_t_uvel_pg_DP_3 - _mdp.Teor_t_base_DP_3) / _mdp.Iz_t_uvel_pg_DP_3,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_3 + _mdp.Rashod_PG_base_DP_3 * _mdp.Iz_t_uvel_pg_DP_3 - _mdp.Teor_t_base_DP_3) / _mdp.Iz_t_uvel_pg_DP_3,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_3,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_3
});
//Для ДП4
modelDPs.Add(new ModelDP
{
xId = 4,
Koef = (_mdp.Rashod_K_base_DP_E_4 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_4),
KoefNerav11 = (_mdp.Rashod_K_base_DP_4 + 0.001 * _mdp.Rashod_PG_base_DP_4 * _mdp.Rashod_K_base_DP_E_4),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_4 - _mdp.Rashod_K_base_DP_E_4 * _mdp.Proiz_chug_uvel_K_DP_4,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_4 * _mdp.Proiz_chug_iz_PG_DP_4 + _mdp.Rashod_K_base_DP_E_4 * _mdp.Rashod_PG_base_DP_4 * _mdp.Proiz_chug_uvel_K_DP_4 + _mdp.Proizvoditelnost_chug_base_DP_4,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_4 + _mdp.Rashod_PG_base_DP_4 * _mdp.Iz_t_uvel_pg_DP_4 - _mdp.Teor_t_base_DP_4) / _mdp.Iz_t_uvel_pg_DP_4,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_4 + _mdp.Rashod_PG_base_DP_4 * _mdp.Iz_t_uvel_pg_DP_4 - _mdp.Teor_t_base_DP_4) / _mdp.Iz_t_uvel_pg_DP_4,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_4,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_4
});
//Для ДП5
modelDPs.Add(new ModelDP
{
xId = 5,
Koef = (_mdp.Rashod_K_base_DP_E_5 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_5),
KoefNerav11 = (_mdp.Rashod_K_base_DP_5 + 0.001 * _mdp.Rashod_PG_base_DP_5 * _mdp.Rashod_K_base_DP_E_5),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_5 - _mdp.Rashod_K_base_DP_E_5 * _mdp.Proiz_chug_uvel_K_DP_5,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_5 * _mdp.Proiz_chug_iz_PG_DP_5 + _mdp.Rashod_K_base_DP_E_5 * _mdp.Rashod_PG_base_DP_5 * _mdp.Proiz_chug_uvel_K_DP_5 + _mdp.Proizvoditelnost_chug_base_DP_5,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_5 + _mdp.Rashod_PG_base_DP_5 * _mdp.Iz_t_uvel_pg_DP_5 - _mdp.Teor_t_base_DP_5) / _mdp.Iz_t_uvel_pg_DP_5,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_5 + _mdp.Rashod_PG_base_DP_5 * _mdp.Iz_t_uvel_pg_DP_5 - _mdp.Teor_t_base_DP_5) / _mdp.Iz_t_uvel_pg_DP_5,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_5,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_5
});
//Для ДП6
modelDPs.Add(new ModelDP
{
xId = 6,
Koef = (_mdp.Rashod_K_base_DP_E_6 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_6),
KoefNerav11 = (_mdp.Rashod_K_base_DP_6 + 0.001 * _mdp.Rashod_PG_base_DP_6 * _mdp.Rashod_K_base_DP_E_6),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_6 - _mdp.Rashod_K_base_DP_E_6 * _mdp.Proiz_chug_uvel_K_DP_6,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_6 * _mdp.Proiz_chug_iz_PG_DP_6 + _mdp.Rashod_K_base_DP_E_6 * _mdp.Rashod_PG_base_DP_6 * _mdp.Proiz_chug_uvel_K_DP_6 + _mdp.Proizvoditelnost_chug_base_DP_6,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_6 + _mdp.Rashod_PG_base_DP_6 * _mdp.Iz_t_uvel_pg_DP_6 - _mdp.Teor_t_base_DP_6) / _mdp.Iz_t_uvel_pg_DP_6,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_6 + _mdp.Rashod_PG_base_DP_6 * _mdp.Iz_t_uvel_pg_DP_6 - _mdp.Teor_t_base_DP_6) / _mdp.Iz_t_uvel_pg_DP_6,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_6,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_6
});
//Для ДП7
modelDPs.Add(new ModelDP
{
xId = 7,
Koef = (_mdp.Rashod_K_base_DP_E_7 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_7),
KoefNerav11 = (_mdp.Rashod_K_base_DP_7 + 0.001 * _mdp.Rashod_PG_base_DP_7 * _mdp.Rashod_K_base_DP_E_7),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_7 - _mdp.Rashod_K_base_DP_E_7 * _mdp.Proiz_chug_uvel_K_DP_7,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_7 * _mdp.Proiz_chug_iz_PG_DP_7 + _mdp.Rashod_K_base_DP_E_7 * _mdp.Rashod_PG_base_DP_7 * _mdp.Proiz_chug_uvel_K_DP_7 + _mdp.Proizvoditelnost_chug_base_DP_7,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_7 + _mdp.Rashod_PG_base_DP_7 * _mdp.Iz_t_uvel_pg_DP_7 - _mdp.Teor_t_base_DP_7) / _mdp.Iz_t_uvel_pg_DP_7,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_7 + _mdp.Rashod_PG_base_DP_7 * _mdp.Iz_t_uvel_pg_DP_7 - _mdp.Teor_t_base_DP_7) / _mdp.Iz_t_uvel_pg_DP_7,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_7,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_7
});
//Для ДП8
modelDPs.Add(new ModelDP
{
xId = 8,
Koef = (_mdp.Rashod_K_base_DP_E_8 * _mdp.Stoimoct_k - _mdp.Stoimoct_pg),
KoefNerav1 = (-0.001 * _mdp.Rashod_K_base_DP_E_8),
KoefNerav11 = (_mdp.Rashod_K_base_DP_8 + 0.001 * _mdp.Rashod_PG_base_DP_8 * _mdp.Rashod_K_base_DP_E_8),
KoefNerav2 = _mdp.Proiz_chug_iz_PG_DP_8 - _mdp.Rashod_K_base_DP_E_8 * _mdp.Proiz_chug_uvel_K_DP_8,
KoefNerav22 = -_mdp.Rashod_PG_base_DP_8 * _mdp.Proiz_chug_iz_PG_DP_8 + _mdp.Rashod_K_base_DP_E_8 * _mdp.Rashod_PG_base_DP_8 * _mdp.Proiz_chug_uvel_K_DP_8 + _mdp.Proizvoditelnost_chug_base_DP_8,
KoefNerav3 = (_mdp.Teor_t_base_DPmin_8 + _mdp.Rashod_PG_base_DP_8 * _mdp.Iz_t_uvel_pg_DP_8 - _mdp.Teor_t_base_DP_8) / _mdp.Iz_t_uvel_pg_DP_8,
KoefNerav33 = (_mdp.Teor_t_base_DPmax_8 + _mdp.Rashod_PG_base_DP_8 * _mdp.Iz_t_uvel_pg_DP_8 - _mdp.Teor_t_base_DP_8) / _mdp.Iz_t_uvel_pg_DP_8,
Rashod_PG_base_DPmin = _mdp.Rashod_PG_base_DPmin_8,
Rashod_PG_base_DPmax = _mdp.Rashod_PG_base_DPmax_8
});
#endregion ---
SolverContext context = SolverContext.GetContext();
context.ClearModel();
Model model = context.CreateModel();
Set users = new Set(Domain.Any, "users");
Parameter Koef = new Parameter(Domain.Real, "Koef", users);
Parameter KoefNerav1 = new Parameter(Domain.Real, "KoefNerav1", users);
Parameter KoefNerav11 = new Parameter(Domain.Real, "KoefNerav11", users);
Parameter KoefNerav2 = new Parameter(Domain.Real, "KoefNerav2", users);
Parameter KoefNerav22 = new Parameter(Domain.Real, "KoefNerav22", users);
Parameter KoefNerav3 = new Parameter(Domain.Real, "KoefNerav3", users);
Parameter KoefNerav33 = new Parameter(Domain.Real, "KoefNerav33", users);
Parameter Rashod_PG_base_DPmin = new Parameter(Domain.Real, "Rashod_PG_base_DPmin", users);
Parameter Rashod_PG_base_DPmax = new Parameter(Domain.Real, "Rashod_PG_base_DPmax", users);
Koef.SetBinding(modelDPs, "Koef", "xId");
KoefNerav1.SetBinding(modelDPs, "KoefNerav1", "xId");
KoefNerav11.SetBinding(modelDPs, "KoefNerav11", "xId");
KoefNerav2.SetBinding(modelDPs, "KoefNerav2", "xId");
KoefNerav22.SetBinding(modelDPs, "KoefNerav22", "xId");
KoefNerav3.SetBinding(modelDPs, "KoefNerav3", "xId");
KoefNerav33.SetBinding(modelDPs, "KoefNerav33", "xId");
Rashod_PG_base_DPmin.SetBinding(modelDPs, "Rashod_PG_base_DPmin", "xId");
Rashod_PG_base_DPmax.SetBinding(modelDPs, "Rashod_PG_base_DPmax", "xId");
model.AddParameters(
Koef,
KoefNerav1,
KoefNerav11,
KoefNerav2,
KoefNerav22,
KoefNerav3,
KoefNerav33,
Rashod_PG_base_DPmin,
Rashod_PG_base_DPmax
);
Decision choose = new Decision(Domain.RealNonnegative, "choose", users);
model.AddDecision(choose);
model.AddGoal("Z", GoalKind.Maximize, Model.Sum(Model.ForEach(users, xId => choose[xId] * Koef[xId])));
model.AddConstraint("Z1", Model.ForEach(users, xId => (Rashod_PG_base_DPmin[xId] <= choose[xId] <= Rashod_PG_base_DPmax[xId])));
model.AddConstraint("Z2", Model.Sum(Model.ForEach(users, xId => choose[xId])) <= _mdp.Rezerf_rashod_pg);
model.AddConstraint("Nerav1", Model.Sum(Model.ForEach(users, xId => choose[xId] * KoefNerav1[xId] + KoefNerav11[xId])) <= _mdp.Zapas_k);
model.AddConstraint("Nerav2", Model.Sum(Model.ForEach(users, xId => choose[xId] * KoefNerav2[xId] + KoefNerav22[xId])) >= _mdp.Treb_proiz_chug);
model.AddConstraint("Nerav3", Model.ForEach(users, xId => KoefNerav33[xId] <= choose[xId] <= KoefNerav3[xId]));
try
{
Solution solution = context.Solve();
Report report = solution.GetReport();
String reportStr = "";
for (int i = 0; i < modelDPs.Count; i++)
{
reportStr += "Значение X" + (i + 1).ToString() + ": " + choose.GetDouble(modelDPs[i].xId) + "\n";
}
reportStr += "\n" + report.ToString();
//MessageBox.Show(reportStr);
}
catch (Exception ex)
{
MessageBox.Show("При решении задачи оптимизации возникла исключительная ситуация.");
}
_mdp.DP1 = Math.Round(choose.GetDouble(modelDPs[0].xId), 2);
_mdp.DP2 = Math.Round(choose.GetDouble(modelDPs[1].xId), 2);
_mdp.DP3 = Math.Round(choose.GetDouble(modelDPs[2].xId), 2);
_mdp.DP4 = Math.Round(choose.GetDouble(modelDPs[3].xId), 2);
_mdp.DP5 = Math.Round(choose.GetDouble(modelDPs[4].xId), 2);
_mdp.DP6 = Math.Round(choose.GetDouble(modelDPs[5].xId), 2);
_mdp.DP7 = Math.Round(choose.GetDouble(modelDPs[6].xId), 2);
_mdp.DP8 = Math.Round(choose.GetDouble(modelDPs[7].xId), 2);
txtDP1.Text = _mdp.DP1.ToString();
txtDP2.Text = _mdp.DP2.ToString();
txtDP3.Text = _mdp.DP3.ToString();
txtDP4.Text = _mdp.DP4.ToString();
txtDP5.Text = _mdp.DP5.ToString();
txtDP6.Text = _mdp.DP6.ToString();
txtDP7.Text = _mdp.DP7.ToString();
txtDP8.Text = _mdp.DP8.ToString();
double z = 0;
for (int i = 0; i < 8; i++)
{
double a = choose.GetDouble(modelDPs[i].xId);
double b = modelDPs[i].Koef;
z += a * b;
}
txtZ.Text = z.ToString();
//график
this.chart1.Series[0].Points.AddXY("ДП1", txtRashod_PG_base_DP_1.Text);
this.chart1.Series[0].Points.AddXY("ДП2", txtRashod_PG_base_DP_2.Text);
this.chart1.Series[0].Points.AddXY("ДП3", txtRashod_PG_base_DP_3.Text);
this.chart1.Series[0].Points.AddXY("ДП4", txtRashod_PG_base_DP_4.Text);
this.chart1.Series[0].Points.AddXY("ДП5", txtRashod_PG_base_DP_5.Text);
this.chart1.Series[0].Points.AddXY("ДП6", txtRashod_PG_base_DP_6.Text);
this.chart1.Series[0].Points.AddXY("ДП7", txtRashod_PG_base_DP_7.Text);
this.chart1.Series[0].Points.AddXY("ДП8", txtRashod_PG_base_DP_8.Text);
this.chart1.Series[1].Points.AddXY("ДП1", choose.GetDouble(modelDPs[0].xId));
this.chart1.Series[1].Points.AddXY("ДП2", choose.GetDouble(modelDPs[1].xId));
this.chart1.Series[1].Points.AddXY("ДП3", choose.GetDouble(modelDPs[2].xId));
this.chart1.Series[1].Points.AddXY("ДП4", choose.GetDouble(modelDPs[3].xId));
this.chart1.Series[1].Points.AddXY("ДП5", choose.GetDouble(modelDPs[4].xId));
this.chart1.Series[1].Points.AddXY("ДП6", choose.GetDouble(modelDPs[5].xId));
this.chart1.Series[1].Points.AddXY("ДП7", choose.GetDouble(modelDPs[6].xId));
this.chart1.Series[1].Points.AddXY("ДП8", choose.GetDouble(modelDPs[7].xId));
}
