public BalanceOutput Calculate(BalanceInput balanceInput)
{
DataConverter dataConverter = new DataConverter(balanceInput);
BalanceOutput balanceOutput = dataConverter.Calculate();
return(balanceOutput);
}
public async Task <PodResult <TransferToContact> > TransferFundToContact(long userId, string contactId, BalanceOutput balance)
{
var amount = Convert.ToDecimal(balance.Total);
var address = settingManager.GetSettingValue(AppSettingNames.PodApiBaseAddress);
var apiToken = settingManager.GetSettingValue(AppSettingNames.PodApiToken);
var client = CreateClient();
var url = $"{address}/nzh/transferToContact/?contactId={contactId}&amount={(int)amount}";
using (var httpRequest = new HttpRequestMessage(HttpMethod.Get, url))
{
httpRequest.Headers.Add("_token_", new List <string>()
{
apiToken
});
httpRequest.Headers.Add("_token_issuer_", new List <string>()
{
"1"
});
var httpResponse = await client.SendAsync(httpRequest);
var body = await httpResponse.Content.ReadAsStringAsync();
EnsureSuccessfulResponse(httpResponse, body, "سرویس TransferToContact");
_transactionsAppService.UpdateTransferedCreditStatus(userId);
var result = JsonConvert.DeserializeObject <PodResult <TransferToContact> >(body);
return(result);
}
}
public BalanceOutput BalanceGurobiForGLR(double[] x0, double[,] a, double[,] h, double[] d, double[] technologicLowerBound, double[] technologicUpperBound, double[] metrologicLowerBound, double[] metrologicUpperBound)
{
try
{
GRBEnv env = new GRBEnv();
GRBModel model = new GRBModel(env);
double[] results = new double[x0.Length];
if (inputData.balanceSettings.balanceSettingsConstraints == BalanceSettings.BalanceSettingsConstraints.TECHNOLOGIC)
{
//Create variables
GRBVar[] varsTechnologic = new GRBVar[a.Columns()];
for (int i = 0; i < varsTechnologic.Length; i++)
{
varsTechnologic[i] = model.AddVar(technologicLowerBound[i], technologicUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
//Set objective
GRBQuadExpr objTechnologic = new GRBQuadExpr();
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(h[i, i] / 2.0, varsTechnologic[i], varsTechnologic[i]);
}
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(d[i], varsTechnologic[i]);
}
model.SetObjective(objTechnologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < a.Rows(); i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < a.Columns(); j++)
{
expr.AddTerm(a[i, j], varsTechnologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
model.Optimize();
//results = new double[varsTechnologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsTechnologic[i].Get(GRB.DoubleAttr.X);
}
}
else
{
//Create variables
GRBVar[] varsMetrologic = new GRBVar[a.Columns()];
for (int i = 0; i < varsMetrologic.Length; i++)
{
varsMetrologic[i] = model.AddVar(metrologicLowerBound[i], metrologicUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
//Set objective
GRBQuadExpr objMetrologic = new GRBQuadExpr();
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetrologic.AddTerm(h[i, i] / 2.0, varsMetrologic[i], varsMetrologic[i]);
}
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetrologic.AddTerm(d[i], varsMetrologic[i]);
}
model.SetObjective(objMetrologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < a.Rows(); i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < a.Columns(); j++)
{
expr.AddTerm(a[i, j], varsMetrologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
model.Optimize();
//results = new double[varsMetrologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsMetrologic[i].Get(GRB.DoubleAttr.X);
}
}
model.Dispose();
env.Dispose();
BalanceOutput outb = new BalanceOutput();
var balanceOutputVars = new List <OutputVariables>();
for (int i = 0; i < measuredValues.Count; i++)
{
InputVariables outputVariable = inputData.BalanceInputVariables[i];
balanceOutputVars.Add(new OutputVariables()
{
id = outputVariable.id,
name = outputVariable.name,
value = results[i],
source = outputVariable.sourceId,
target = outputVariable.destinationId
});
}
outb.balanceOutputVariables = balanceOutputVars;
outb.GlobaltestValue = GTR;
outb.Status = "Success";
return(outb);
}
catch (Exception e)
{
return(new BalanceOutput
{
Status = e.Message,
});
}
}
public void BalanceGurobi()
{
GRBEnv env = new GRBEnv();
GRBModel model = new GRBModel(env);
DateTime CalculationTimeStart;
DateTime CalculationTimeFinish;
double[] results = new double[measuredValues.ToArray().Length];
if (inputData.balanceSettings.balanceSettingsConstraints == BalanceSettings.BalanceSettingsConstraints.TECHNOLOGIC)
{
//Create variables
GRBVar[] varsTechnologic = new GRBVar[measuredValues.ToArray().Length];
for (int i = 0; i < varsTechnologic.Length; i++)
{
varsTechnologic[i] = model.AddVar(technologicRangeLowerBound[i], technologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
//Set objective
GRBQuadExpr objTechnologic = new GRBQuadExpr();
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(H[i, i] / 2.0, varsTechnologic[i], varsTechnologic[i]);
}
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(dVector[i], varsTechnologic[i]);
}
model.SetObjective(objTechnologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < incidenceMatrix.RowCount; i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < incidenceMatrix.ColumnCount; j++)
{
expr.AddTerm(incidenceMatrix[i, j], varsTechnologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
CalculationTimeStart = DateTime.Now;
model.Optimize();
CalculationTimeFinish = DateTime.Now;
results = new double[varsTechnologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsTechnologic[i].Get(GRB.DoubleAttr.X);
}
}
else
{
//Create variables
GRBVar[] varsMetrologic = new GRBVar[measuredValues.ToArray().Length];
for (int i = 0; i < varsMetrologic.Length; i++)
{
if (measureIndicator[i, i] == 0)
{
varsMetrologic[i] = model.AddVar(technologicRangeLowerBound[i], technologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
else
{
varsMetrologic[i] = model.AddVar(metrologicRangeLowerBound[i], metrologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
}
//Set objective
GRBQuadExpr objMetroologic = new GRBQuadExpr();
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetroologic.AddTerm(H[i, i] / 2.0, varsMetrologic[i], varsMetrologic[i]);
}
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetroologic.AddTerm(dVector[i], varsMetrologic[i]);
}
model.SetObjective(objMetroologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < incidenceMatrix.RowCount; i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < incidenceMatrix.ColumnCount; j++)
{
expr.AddTerm(incidenceMatrix[i, j], varsMetrologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
CalculationTimeStart = DateTime.Now;
model.Optimize();
CalculationTimeFinish = DateTime.Now;
results = new double[varsMetrologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsMetrologic[i].Get(GRB.DoubleAttr.X);
}
}
model.Dispose();
env.Dispose();
double disbalanceOriginal = incidenceMatrix.Multiply(measuredValues).Subtract(reconciledValues).ToArray().Euclidean();
double disbalance = incidenceMatrix.Multiply(SparseVector.OfVector(new DenseVector(results))).Subtract(reconciledValues).ToArray().Euclidean();
balanceOutput = new BalanceOutput();
balanceOutputVariables = new List <OutputVariables>();
for (int i = 0; i < results.Length; i++)
{
InputVariables outputVariable = inputData.BalanceInputVariables[i];
balanceOutputVariables.Add(new OutputVariables()
{
id = outputVariable.id,
name = outputVariable.name,
value = results[i],
source = outputVariable.sourceId,
target = outputVariable.destinationId,
upperBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeUpperBound[i] : metrologicRangeUpperBound[i],
lowerBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeLowerBound[i] : metrologicRangeLowerBound[i]
});
}
balanceOutput.CalculationTime = (CalculationTimeFinish - CalculationTimeStart).TotalSeconds;
balanceOutput.balanceOutputVariables = balanceOutputVariables;
balanceOutput.DisbalanceOriginal = disbalanceOriginal;
balanceOutput.Disbalance = disbalance;
balanceOutput.GlobaltestValue = 0.0;
balanceOutput.Status = "Success";
}
public void BalanceAccord()
{
var func = new QuadraticObjectiveFunction(H.ToArray(), dVector.ToArray());
var constraints = new List <LinearConstraint>();
//добавление ограничений узлов
for (var j = 0; j < measuredValues.ToArray().Length; j++)
{
if (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[j, j] == 0.0)
{
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].technologicLowerBound
});
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].technologicUpperBound
});
}
else
{
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].metrologicLowerBound
});
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].metrologicUpperBound
});
}
}
//Ограничения для решения задачи баланса
for (var j = 0; j < reconciledValues.ToArray().Length; j++)
{
var notNullElements = Array.FindAll(incidenceMatrix.ToArray().GetRow(j), x => Math.Abs(x) > 0.0000001);
var notNullElementsIndexes = new List <int>();
for (var k = 0; k < measuredValues.ToArray().Length; k++)
{
if (Math.Abs(incidenceMatrix[j, k]) > 0.0000001)
{
notNullElementsIndexes.Add(k);
}
}
constraints.Add(new LinearConstraint(notNullElements.Length)
{
VariablesAtIndices = notNullElementsIndexes.ToArray(),
CombinedAs = notNullElements,
ShouldBe = ConstraintType.EqualTo,
Value = reconciledValues[j]
});
}
var solver = new GoldfarbIdnani(func, constraints);
DateTime CalculationTimeStart = DateTime.Now;
if (!solver.Minimize())
{
throw new ApplicationException("Failed to solve balance task.");
}
DateTime CalculationTimeFinish = DateTime.Now;
double disbalanceOriginal = incidenceMatrix.Multiply(measuredValues).Subtract(reconciledValues).ToArray().Euclidean();
double disbalance = incidenceMatrix.Multiply(SparseVector.OfVector(new DenseVector(solver.Solution))).Subtract(reconciledValues).ToArray().Euclidean();
double[] solution = new double[countOfThreads];
sol = new double[countOfThreads];
for (int i = 0; i < solution.Length; i++)
{
solution[i] = solver.Solution[i];
sol[i] = solution[i];
}
balanceOutput = new BalanceOutput();
balanceOutputVariables = new List <OutputVariables>();
for (int i = 0; i < solution.Length; i++)
{
InputVariables outputVariable = inputData.BalanceInputVariables[i];
balanceOutputVariables.Add(new OutputVariables()
{
id = outputVariable.id,
name = outputVariable.name,
value = solution[i],
source = outputVariable.sourceId,
target = outputVariable.destinationId,
upperBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeUpperBound[i] : metrologicRangeUpperBound[i],
lowerBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeLowerBound[i] : metrologicRangeLowerBound[i]
});
}
balanceOutput.CalculationTime = (CalculationTimeFinish - CalculationTimeStart).TotalSeconds;
balanceOutput.balanceOutputVariables = balanceOutputVariables;
balanceOutput.DisbalanceOriginal = disbalanceOriginal;
balanceOutput.Disbalance = disbalance;
balanceOutput.GlobaltestValue = GTR;
balanceOutput.Status = "Success";
}
public BalanceOutput Calculate()
{
if (ok)
{
flowsName = new List <string>();
nodesName = new List <string>();
for (int i = 0; i < FlowDescription.Count; i++)
{
for (int j = 0; j < flowsName.Count; j++)
{
if (FlowDescription[i].Id.CompareTo(flowsName[j]) == 0)
{
return new BalanceOutput()
{
IsBalanced = false, Message = "Поток с id = '" + FlowDescription[i].Id + "' уже существует в списке", Flows = null
}
}
;
else if (FlowDescription[i].Id.CompareTo("") == 0)
{
return new BalanceOutput()
{
IsBalanced = false, Message = "Поток не может иметь в качестве названия пустую строку", Flows = null
}
}
;
}
flowsName.Add(FlowDescription[i].Id);
}
bool flag1, flag2;
for (int i = 0; i < FlowDescription.Count; i++)
{
flag1 = true;
for (int j = 0; j < nodesName.Count; j++)
{
if (FlowDescription[i].Destination == null || FlowDescription[i].Destination.CompareTo(nodesName[j]) == 0)
{
flag1 = false;
break;
}
}
if (flag1 && FlowDescription[i].Destination.CompareTo("") != 0)
{
nodesName.Add(FlowDescription[i].Destination);
}
flag2 = true;
for (int j = 0; j < nodesName.Count; j++)
{
if (FlowDescription[i].Source == null || FlowDescription[i].Source.CompareTo(nodesName[j]) == 0)
{
flag2 = false;
break;
}
}
if (flag2 && FlowDescription[i].Source.CompareTo("") != 0)
{
nodesName.Add(FlowDescription[i].Source);
}
}
x0 = new double[FlowDescription.Count];
for (int i = 0; i < FlowDescription.Count; i++)
{
x0[i] = FlowDescription[i].Value;
}
tols = new double[FlowDescription.Count];
for (int i = 0; i < FlowDescription.Count; i++)
{
tols[i] = FlowDescription[i].Tolerance;
}
IsMeas = new byte[FlowDescription.Count];
for (int i = 0; i < FlowDescription.Count; i++)
{
if (FlowDescription[i].NonMeasured)
{
IsMeas[i] = 0;
}
else
{
IsMeas[i] = 1;
}
}
double[,] A = new double[nodesName.Count, FlowDescription.Count];
double[] b = new double[nodesName.Count];
double[] lowerBounds = new double[FlowDescription.Count];
for (int i = 0; i < FlowDescription.Count; i++)
{
lowerBounds[i] = FlowDescription[i].LowerBound;
}
double[] upperBounds = new double[FlowDescription.Count];
for (int i = 0; i < FlowDescription.Count; i++)
{
upperBounds[i] = FlowDescription[i].UpperBound;
}
for (int i = 0; i < nodesName.Count; i++)
{
for (int j = 0; j < FlowDescription.Count; j++)
{
if (FlowDescription[j].Destination != null && FlowDescription[j].Destination.CompareTo(nodesName[i]) == 0 && FlowDescription[j].Destination.CompareTo("") != 0)
{
A[i, j] = 1;
}
else if (FlowDescription[j].Source != null && FlowDescription[j].Source.CompareTo(nodesName[i]) == 0 && FlowDescription[j].Source.CompareTo("") != 0)
{
A[i, j] = -1;
}
}
b[i] = 0;
}
MWArray[] res;
try
{
res = Calculator.solve(A, b, x0, tols, IsMeas, lowerBounds, upperBounds);
}
catch (Exception ex)
{
return(new BalanceOutput()
{
IsBalanced = false, Message = "Баланс не сводится", Flows = result
});
}
result = Calculator.xBalanced(res);
if (Calculator.solveErr(res) > delta)
{
return(new BalanceOutput()
{
IsBalanced = false, Message = "Максимальный разбаланс после балансировки превысил ограничение " + delta, Flows = result
});
}
BalanceOutput outputFlow = new BalanceOutput()
{
IsBalanced = true, Message = message, Flows = result
};
return(outputFlow);
}
else
{
BalanceOutput outputFlow = new BalanceOutput()
{
IsBalanced = false, Message = message, Flows = result
};
return(outputFlow);
}
}
