public static (double, double) GetABRange(ParametersForDefined parameters)
{
double minA = double.MaxValue, maxA = double.MinValue, minB = double.MaxValue, maxB = double.MinValue;
for (var i = 0; i < parameters.A.Length; i++)
{
if (parameters.A[i] < minA)
{
minA = parameters.A[i];
}
if (parameters.A[i] > maxA)
{
maxA = parameters.A[i];
}
if (parameters.B[i] < minB)
{
minB = parameters.B[i];
}
if (parameters.B[i] > maxB)
{
maxB = parameters.B[i];
}
}
return(((minA + minB) / 2), ((maxA + maxB) / 2));
}
public static (double, double) GetCsRange(ParametersForDefined parameters)
{
double averMin = 0.0, averMax = 0.0;
foreach (var c in parameters.Cs)
{
var min = double.MaxValue;
var max = double.MinValue;
foreach (var x in c)
{
if (x < min)
{
min = x;
}
if (x > max)
{
max = x;
}
}
averMin += min;
averMax += max;
}
return((averMin / parameters.Cs.Length), (averMax / parameters.Cs.Length));
}
public FullSolution Run()
{
Solver solver = new Solver();
Random rand = new Random();
if (A is null)
{
if (_generator is null)
{
throw new System.InvalidOperationException("Generating values parameters in GeneratorTaskCondition must be assigned to Problem");
}
(A, B) = _generator.GenerateAB(N, rand);
L = _generator.GenerateL(R, rand);
Alpha = _generator.GenerateAlpha(R);
Cs = new double[R][];
for (var i = 0; i < R; i++)
{
Cs[i] = _generator.GenerateMatrix(N, rand);
}
}
(double[][] xs, double[] fsForXs) = solver.GetSolutions(Cs, A, B);
(double[] solution, _) = solver.SolveSeveral(Cs, A, B, L, Alpha, fsForXs);
double[] newAlpha = new double[R];
Alpha.CopyTo(newAlpha, 0);
double[] optimalX = solver.UpdateX(Cs, A, B, L, ref newAlpha, fsForXs, solution);
double[] fsForX = solver.CalculateFs(Cs, optimalX);
double[] deltas = solver.CalculateDeltas(fsForX, fsForXs);
double[] ys = solver.CalculateYs(deltas, L);
double functionValue = solver.CalculateOptimalFunc(ys, newAlpha);
double[] distances = solver.CalculateDistances(xs, optimalX);
Solution solutionWithoutChange = new Solution(optimalX, functionValue, Alpha, newAlpha, Cs, fsForX, xs, fsForXs, deltas, ys, distances, B.Length);
double[][] newCs = new double[R][];
PercentFinder.CopyMultidimensional(Cs, ref newCs);
ParametersForDefined parameters = new ParametersForDefined(optimalX, newCs, A, B, L, Alpha, _cChangeParameters);
ParametersForDefined = parameters;
double persentOfChange = PercentFinder.FindPercentOfChange(parameters, solver, rand);
//double persentOfChange = PercentFinder.SearchMeanPercent(PercentFinder.FindPercentOfChange, parameters, 0.01, solver, rand);
double[] newX = parameters.NewX;
double[] newNewAlpha = new double[R];
newAlpha.CopyTo(newNewAlpha, 0);
(double[][] newXs, double[] newFsForXs) = solver.GetSolutions(newCs, A, B);
newX = solver.UpdateX(newCs, A, B, L, ref newNewAlpha, newFsForXs, newX);
double[] newfsForX = solver.CalculateFs(newCs, newX);
double[] newDeltas = solver.CalculateDeltas(newfsForX, newFsForXs);
double[] newYs = solver.CalculateYs(newDeltas, L);
double newFunctionValue = solver.CalculateOptimalFunc(newYs, newNewAlpha);
double[] newDistances = solver.CalculateDistances(newXs, newX);
Solution solutionWithChange = new Solution(newX, newFunctionValue, newAlpha, newNewAlpha, newCs, newfsForX, newXs, newFsForXs, newDeltas, newYs, newDistances, B.Length);
return(new FullSolution(A, B, L, solutionWithoutChange, persentOfChange, solutionWithChange));
}
public static (double, double) GetLRange(ParametersForDefined parameters)
{
double min = double.MaxValue, max = double.MinValue;
foreach (var l in parameters.L)
{
if (l < min)
{
min = l;
}
if (l > max)
{
max = l;
}
}
return(min, max);
}
private int GetPercentOfChange(SearchParameters parameters, Solver solver, Random random)
{
if (!(parameters is ParametersForRandom))
{
throw new ArgumentException("Wrong parameters type in method Experiment.GetPercentOfChange. Need to be ParametersForRandom.");
}
var param = (ParametersForRandom)parameters;
int percent;
double[] x = new double[param.Size * param.Size];
double[][] cs = new double[param.MatrixQuantity][];
double[] a = new double[param.Size];
double[] b = new double[param.Size];
double[] l = new double[param.MatrixQuantity];
double[] alpha = new double[param.MatrixQuantity];
double[] solutions;
bool success = false;
while (!success)
{
(a, b) = _generator.GenerateAB(param.Size, random);
l = _generator.GenerateL(param.MatrixQuantity, random);
alpha = _generator.GenerateAlpha(param.MatrixQuantity);
for (int i = 0; i < param.MatrixQuantity; i++)
{
cs[i] = _generator.GenerateMatrix(param.Size, random);
}
(_, solutions) = solver.GetSolutions(cs, a, b);
(x, _) = solver.SolveSeveral(cs, a, b, l, alpha, solutions);
x = solver.DivideX(solver.RoundVector(x), param.MatrixQuantity);
if (!solver.CheckABConstraints(x, a, b))
{
continue;
}
success = true;
}
var parametersForDefined = new ParametersForDefined(x, cs, a, b, l, alpha, _cChangeParameters);
percent = PercentFinder.FindPercentOfChange(parametersForDefined, solver, random);
return(percent);
}
