public static List<ValueAndArgument> integrateEquationVector(ValueAndArgument begin, Func<double, double[], double[]> system, double epsilon, Func<ValueAndArgument,bool> condition)
{
List<ValueAndArgument> result = new List<ValueAndArgument>();
result.Add(begin);
ValueAndArgument current = begin;
double h = 0.00001;
while (condition(current))
{
ValueAndArgument y2h = nextStepVector4order(h, current, system);
ValueAndArgument yh = nextStepVector4order(h / 2, current, system);
if (difference(y2h.value, yh.value) / 15 < epsilon)
{
if (difference(y2h.value, yh.value) / 15 < 0.5 * epsilon)
{
h *= 1.2;
}
result.Add(y2h);
current = y2h;
}
else
{
h *= 0.9;
}
}
return result;
}
public static ValueAndArgument nextStep(double h,ValueAndArgument prev, Func<double,double,double> f)
{
ValueAndArgument next = new ValueAndArgument();
next.N = prev.N + 1;
next.x = prev.x + h;
next.y = prev.y + h * f(prev.x, prev.y);
return next;
}
public static ValueAndArgument nextStep(double h, ValueAndArgument prev, Func<double, double, double> f)
{
ValueAndArgument result = new ValueAndArgument();
result.N = prev.N + 1;
result.x = prev.x + h;
double h2 = h / 2;
result.y = prev.y + h * f(prev.x + h2, prev.y + h2 * f(prev.x, prev.y));
return result;
}
public static ValueAndArgument nextStep(double h, ValueAndArgument prev, Func<double, double, double> f)
{
ValueAndArgument next = new ValueAndArgument();
next.N = prev.N + 1;
next.x = prev.x + h;
double multiplicator = f(prev.x, prev.y);
double y = prev.y + h * multiplicator;
next.y = prev.y + h * (multiplicator + f(prev.x+h, y)) / 2;
return next;
}
public static ValueAndArgument nextStep(double h, List<ValueAndArgument> preSteps, Func<double, double, double> f)
{
ValueAndArgument result = new ValueAndArgument();
int li = preSteps.Count - 1;
int li1 = li - 1;
int li2 = li - 2;
result.x = preSteps[li].x + h;
result.y = preSteps[li].y + h * (double)1 / 3 * (5.75*f(preSteps[li].x,preSteps[li].y)-4*f(preSteps[li1].x,preSteps[li1].y)+1.25*f(preSteps[li2].x,preSteps[li2].y));
result.N = preSteps[li].N + 1;
return result;
}
public static ValueAndArgument nextStep(double h, ValueAndArgument prev, Func<double, double, double> f)
{
ValueAndArgument result = new ValueAndArgument();
result.x = prev.x + h;
result.N = prev.N + 1;
double k1 = f(prev.x, prev.y);
double k2 = f(prev.x + h / 2, prev.y + h / 2 * k1);
double k3 = f(prev.x + h / 2, prev.y + h / 2 * k2);
double k4 = f(prev.x + h, prev.y + h * k3);
result.y = prev.y + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4);
return result;
}
public static ValueAndArgument nextStep(double h, List<ValueAndArgument> preSteps,Func<double,double,double> f)
{
ValueAndArgument result = new ValueAndArgument();
int li = preSteps.Count - 1;
int li1 = li - 1;
result.x = preSteps[li].x + h;
Func<double, double> equation = y => -y + preSteps[li1].y + h / 3 * (f(preSteps[li].x + h, y) + 4 * f(preSteps[li].x, preSteps[li].y) + f(preSteps[li1].x, preSteps[li1].y));
Func<double, double> derivative = new MathNet.Numerics.Differentiation.NumericalDerivative(5, 2).CreateDerivativeFunctionHandle(equation, 1);
double lowerBound = preSteps[li].y - 3 * Math.Abs(preSteps[li].y - preSteps[li1].y);
double upperBound = lowerBound + 6 * Math.Abs(preSteps[li].y - preSteps[li1].y);
result.y = MathNet.Numerics.RootFinding.NewtonRaphson.FindRoot(equation, derivative, lowerBound, upperBound, 1e-12, 2000);
result.N = preSteps[li].N + 1;
return result;
}
public static ValueAndArgument nextStepVector4order(double h, ValueAndArgument preStep, Func<double, double[], double[]> system)
{
return nextStepVector(h, preStep, system,
new double[] { 0, 0.5, 0.5, 1 },
new double[][] {
new double[] { 0, 0, 0, 0 },
new double[] { 0.5, 0, 0, 0 },
new double[] { 0, 0.5, 0, 0 },
new double[] { 0, 0, 0.5, 0 }
},
new double[] { 1.0 / 6, 1.0 / 3, 1.0 / 3, 1.0 / 6 });
}
public static ValueAndArgument nextStepVector(double h, ValueAndArgument preStep, Func<double, double[], double[]> system, double[] p1, double[][] p2, double[] p3)
{
double[] value = new double[preStep.value.Length];
double[] dyV = new double[preStep.value.Length];
for (int p = 0; p < value.Length; p++)
{
double dy = 0;
double[] K_i_k = new double[p1.Length];
for (int i = 0; i < p1.Length; i++)
{
double sumForSecondArgument = 0;
for (int j = 0; j < i; j++)
{
sumForSecondArgument += p2[i][j] * K_i_k[j];
}
double[] vectorY_k = new double[value.Length];
for (int q = 0; q < value.Length; q++)
{
vectorY_k[q] = preStep.value[q] + h * sumForSecondArgument;
}
K_i_k[i] = h * system(preStep.argument + p1[i] * h, vectorY_k)[p];
dy += p3[i] * K_i_k[i];
}
dyV[p] = dy;
}
for(int q = 0; q < value.Length; q++)
{
value[q] = preStep.value[q] + dyV[q];
}
return new ValueAndArgument(value,preStep.argument+ h);
}
public static ValueAndArgument nextStep4order(double h, ValueAndArgument preStep, Func<double, double, double> derivative, double epsilon)
{
return nextStep(h, preStep, derivative,
new double[] { 0, 0.5, 0.5, 1 },
new double[][] {
new double[] { 0, 0, 0, 0 },
new double[] { 0.5, 0, 0, 0 },
new double[] { 0, 0.5, 0, 0 },
new double[] { 0, 0, 0.5, 0 }
},
new double[] { 1.0 / 6, 1.0 / 3, 1.0 / 3, 1.0 / 6 });
}
public static ValueAndArgument nextStep(double h, ValueAndArgument preStep, Func<double, double, double> derivative, double[] p1, double[][] p2, double[] p3)
{
return nextStepVector(h, preStep, (x, y) => new double[] { derivative(x, y[0]) }, p1, p2, p3);
}
