private LabeledData[] collect_samples(Func <double[], double[]>[] functions, Task task)
{
List <LabeledData> ldata = new List <LabeledData>();
foreach (Func <double[], double[]> func in functions)
{
int j = 0;
while (j < 1)
{
List <double[]> points = get_start_points(j, task, func);
for (int k = 0; k < 1; k++)
{
points.AddRange(testDefWayUntilGood(points.ToArray(), func).ToList <double[]>());
}
ShepardApprox def_model = new ShepardApprox(config.FunctionDimension, points.ToArray());
int[] count = new int[config.FunctionDimension];
for (int i = 0; i < config.FunctionDimension; i++)
{
count[i] = (def_model.Min[i] == def_model.Max[i]) ? 1 : NGRID;
}
Grid grid = new Grid(def_model.N, def_model.M, def_model.Min, def_model.Max, count);
Solver.dist = update_path_to_knowing_points(grid, points.ToArray(), config.FunctionDimension);
int n = grid.Node.Length;
for (int i = 0; i < grid.Node.Length; i++)
{
double[] cuurentNode = (double[])grid.Node[i].Clone();
def_model.Calculate(cuurentNode);
double[] approxFunctionVal = new double[def_model.M];
for (int k = 0; k < def_model.M; ++k)
{
approxFunctionVal[k] = cuurentNode[def_model.N + k];
}
var realFunctionVal = func(grid.Node[i]);
double[] diffs = realFunctionVal.Zip(approxFunctionVal, (d1, d2) => Math.Abs(d1 - d2)).ToArray();
double err = (diffs.Sum() / diffs.Length);
//int pointClass = 0;
//if (err > config.Approximation)
//{
// pointClass = 1;
//}
double pointClass = err;
double[] features = build_features(grid.Node[i], def_model, grid, Solver.dist, points.ToArray(), i);
ldata.Add(new LabeledData(features, pointClass));
featureCount = features.Length;
}
j++;
}
}
return(ldata.ToArray());
}
protected double[][] testDefWayUntilGood(double[][] points, Func <double[], double[]> func)
{
int pointAmount = config.PointAmount;
int i = 0;
double maxErr = 10;
int goodPr = 0;
while (i < 100000000 && maxErr > config.Approximation && goodPr < 50)
{
ShepardApprox model = new ShepardApprox(config.FunctionDimension, points);
Analyzer analyzer = new Analyzer(model, points);
analyzer.do_default_analyse();
goodPr = analyzer.getGoodPr(func, config.Approximation);
Console.WriteLine("Good pr " + goodPr);
double[][] xx = analyzer.Result;
int newPointsAmount = Math.Min(config.PredictionPointAmount, xx.Length);
pointAmount = pointAmount + newPointsAmount;
points = getNewPoints(points, analyzer.Result, newPointsAmount, config.FunctionDimension, func);
double[][] new_points = new double[newPointsAmount][];
for (int j = 0; j < newPointsAmount; j++)
{
new_points[j] = new double[xx[j].Length];
Array.Copy(xx[j], new_points[j], xx[j].Length);
model.Calculate(new_points[j]);
}
double tempErr = 0;
for (int k = 0; k < new_points.Length; k++)
{
double err = Math.Abs(points[pointAmount - newPointsAmount + k][config.FunctionDimension] - new_points[k][config.FunctionDimension]);
if (err > tempErr)
{
tempErr = err;
}
}
maxErr = tempErr;
i++;
}
ShepardApprox model1 = new ShepardApprox(config.FunctionDimension, points);
Analyzer analyzer1 = new Analyzer(model1, points);
analyzer1.do_default_analyse();
//return analyzer1.getGoodSamples(func, parser.Approximation, goodPr);
return(points);
}
private double[] build_features(double[] point, IFunction model, Grid grid, double[] distToKnownPoints, double[][] knownPoints = null, int index = -1)
{
// на сколько образующая домен точка близка
// сколько до и после монотонно
// расстояние до известной точки
Analyzer analyzer = new Analyzer(model, knownPoints);
analyzer.do_some_analyse();
// min, max in locality
double maxNeighbours = double.MinValue;
double minNeighbours = double.MaxValue;
foreach (var neighbour in grid.Neighbours(index))
{
double[] calcNeighbour = (double[])grid.Node[neighbour].Clone();
model.Calculate(calcNeighbour);
double calcNeighbourVal = calcVal(model.M, model.N, calcNeighbour);
if (calcNeighbour[calcNeighbour.Length - 1] < minNeighbours)
{
minNeighbours = calcNeighbourVal;
}
if (calcNeighbour[calcNeighbour.Length - 1] > maxNeighbours)
{
maxNeighbours = calcNeighbourVal;
}
}
// current val
double[] curentNode = (double[])grid.Node[index].Clone();
model.Calculate(curentNode);
double curentNodeVal = calcVal(model.M, model.N, curentNode);
if (curentNodeVal < minNeighbours)
{
minNeighbours = curentNodeVal;
}
if (curentNodeVal > maxNeighbours)
{
maxNeighbours = curentNodeVal;
}
List <double[]> temp_points = new List <double[]>();
temp_points = knownPoints.ToList();
temp_points.RemoveAt(analyzer.Domain(grid.Node[index]));
ShepardApprox new_model = new ShepardApprox(model.N, temp_points.ToArray());
double[] old_model_point = (double[])grid.Node[index].Clone();
model.Calculate(old_model_point);
double[] new_model_point = (double[])grid.Node[index].Clone();
new_model.Calculate(new_model_point);
double err = 0;
for (int k = 0; k < model.M; ++k)
{
double newErr = Math.Abs(old_model_point[model.N + k] - new_model_point[model.N + k]);
if (newErr > err)
{
err = newErr;
}
}
this.featureCount = 4;
double[] features = new double[featureCount];
features[0] = maxNeighbours - curentNodeVal;
features[1] = curentNodeVal - minNeighbours;
features[2] = distToKnownPoints[index];
features[3] = err;
return(features);
}
private void analyse_all_error()
{
//вычисляю экстраполянты
//Shepard[] sh = new Shepard[xf.Length];
//MeasuredPoint[] xfMeasured = MeasuredPoint.getArrayFromDouble(xf, N);
ShepardApprox[] shepardApprox = new ShepardApprox[xf.Length];
for (int i = 0; i < xf.Length; i++)
{
shepardApprox[i] = new ShepardApprox(N, xf, graph[i]);
}
//пересчитываю значения в узлах решетки только на границах доменов
for (int i = 0; i < grid.Node.Length; i++)
{
shepardApprox[domain[i]].Calculate(grid.Node[i]);
}
//вычисляю ошибку на границах доменов
error = new double[grid.Node.Length];
for (int i = 0; i < grid.Node.Length; i++)
{
error[i] = 0;
foreach (var adj in grid.Neighbours(i))
{
double d = distanceF(grid.Node[i], grid.Node[adj]);
if (error[i] < d)
{
error[i] = d;
}
}
}
//интерполирую ошибку
double max = 0;
for (int i = 0; i < grid.Node.Length; i++)
{
int brd = bordernear[i];
double err = error[brd];
error[i] = err * (1 - borderdist[i]);
if (max < error[i])
{
max = error[i];
}
}
//нормирую ошибку
if (max > 0)
{
for (int i = 0; i < grid.Node.Length; i++)
{
error[i] = error[i] / max;
}
}
int maxcandidates = Math.Min(candidates.Length, 1000);
//сортировка потенциальных кандидатов
for (int i = 0; i < maxcandidates - 1; i++)
{
for (int j = i + 1; j < candidates.Length; j++)
{
if (error[candidates[i]] < error[candidates[j]])
{
int temp = candidates[i];
candidates[i] = candidates[j];
candidates[j] = temp;
}
}
}
candidates = Tools.Sub(candidates, 0, maxcandidates);
xfcandidates = Tools.Sub(grid.Node, candidates);
for (int i = 0; i < xfcandidates.Length; i++)
{
for (int j = N; j < N + M; j++)
{
xfcandidates[i][j] = 0;
}
}
Console.WriteLine("Calculation process completed successfully");
}
private void analyse_error()
{
Console.WriteLine("Calculation of local extrapolants");
//вычисляю экстраполянты
//Shepard[] sh = new Shepard[xf.Length];
//MeasuredPoint[] xfMeasured = MeasuredPoint.getArrayFromDouble(xf, N);
ShepardApprox[] shepardApprox = new ShepardApprox[xf.Length];
for (int i = 0; i < xf.Length; i++)
{
shepardApprox[i] = new ShepardApprox(N, xf, graph[i]);
}
Console.WriteLine("Approximation of the values of the initial function at the domain boundaries");
//пересчитываю значения в узлах решетки только на границах доменов
for (int i = 0; i < grid.Node.Length; i++)
{
if (borderdist[i] > 0)
{
continue;
}
shepardApprox[domain[i]].Calculate(grid.Node[i]);
}
Console.WriteLine("Calculation of the approximation error of a function at domain boundaries");
//вычисляю ошибку на границах доменов
error = new double[grid.Node.Length];
for (int i = 0; i < grid.Node.Length; i++)
{
if (borderdist[i] > 0)
{
continue;
}
error[i] = 0;
foreach (var adj in grid.Neighbours(i))
{
double d = distanceF(grid.Node[i], grid.Node[adj]);
if (error[i] < d)
{
error[i] = d;
}
}
}
Console.WriteLine("Interpolation of approximation error function on domain domains");
//интерполирую ошибку
double max = 0;
for (int i = 0; i < grid.Node.Length; i++)
{
int brd = bordernear[i];
double err = error[brd];
error[i] = err * (1 - borderdist[i]);
if (max < error[i])
{
max = error[i];
}
}
Console.WriteLine("Error Function Normalization");
//нормирую ошибку
if (max > 0)
{
for (int i = 0; i < grid.Node.Length; i++)
{
error[i] = error[i] / max;
}
}
int maxcandidates = Math.Min(candidates.Length, 1000);
if (candidates.Length > maxcandidates)
{
Console.WriteLine("Preliminary selection of {1} of {0} candidates", candidates.Length, maxcandidates);
}
Console.WriteLine("Ordering {0} potential candidates", maxcandidates);
//сортировка потенциальных кандидатов
for (int i = 0; i < maxcandidates - 1; i++)
{
for (int j = i + 1; j < candidates.Length; j++)
{
if (error[candidates[i]] < error[candidates[j]])
{
int temp = candidates[i];
candidates[i] = candidates[j];
candidates[j] = temp;
}
}
}
Console.WriteLine("Creating a list of candidates", maxcandidates);
candidates = Tools.Sub(candidates, 0, maxcandidates);
xfcandidates = Tools.Sub(grid.Node, candidates);
for (int i = 0; i < xfcandidates.Length; i++)
{
for (int j = N; j < N + M; j++)
{
xfcandidates[i][j] = 0;
}
}
Console.WriteLine("Calculation process completed successfully");
}
