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); }