public Vector <double>[] bvpsolver_zzz(Func <double, Vector <double>, Vector <double> > system, double ya, double yb, double xa, double xb, int N) { //先求解方程得到初始斜率的估计值,再进行打靶法迭代。--zzz Vector <double>[] res; Vector <double> y0; double s_guess, s_guess_pre; double fais, fais_pre; double dfai, ds; int count = 0; //计算20组s_guess和fais,然后样条插值得到连续函数,再通过解方程,得到使fais=0的初始s_guess int M = 50; double[] sLst = Vector <double> .Build.Dense(M, i => yb / M *i).ToArray(); double[] faisLst = new double[M]; count = 0; while (count < M) { y0 = Vector <double> .Build.DenseOfArray(new[] { ya, sLst[count] }); // observer_pr ob_pr = this->write_targetFunc_end; res = RungeKutta.FourthOrder(y0, xa, xb, N, system); faisLst[count] = res[N - 1][0] - yb; count++; } //样条插值得到连续函数 var cubicSpl = CubicSpline.InterpolateNatural(sLst, faisLst); /*如果初始值离解太远,牛顿法会不收敛。故采用Mathnet包中的RobustNewtonRaphson * double s_cur = 0, s_next; * count = 0; * while (count < 1000) * { * fais = cubicSpl.Interpolate(s_cur); * dfaids = cubicSpl.Differentiate(s_cur); * if (fais < 1e-5 && fais > -1e-5) * { * break; * } * * s_next = s_cur - fais / dfaids; * s_cur = s_next; * count += 1; * }*/ //解方程fais=0,得到初始斜率s_guess。该法先尝试牛顿法,如失败会采用二分法(bisection)。 s_guess = RobustNewtonRaphson.FindRoot(cubicSpl.Interpolate, cubicSpl.Differentiate, 0, yb, 1e-5); //利用解得的s_guess,构造s_guess_pre,目的是求导数dfai/ds。 if (s_guess == 0) { s_guess_pre = 1e-2; } else { s_guess_pre = s_guess * 0.99; } //求s_guess_pre对应的fais_pre,目的是求导数dfai/ds。 y0 = Vector <double> .Build.DenseOfArray(new[] { ya, s_guess_pre }); res = RungeKutta.FourthOrder(y0, xa, xb, N, system); fais_pre = res[N - 1][0] - yb; count = 0; while (count < 50) { y0 = Vector <double> .Build.DenseOfArray(new[] { ya, s_guess }); res = RungeKutta.FourthOrder(y0, xa, xb, N, system); fais = res[N - 1][0] - yb; dfai = fais - fais_pre; ds = s_guess - s_guess_pre; if (fais < 1e-5 && fais > -1e-5) { break; } fais_pre = fais; s_guess_pre = s_guess; s_guess = s_guess - fais * ds / dfai; count++; } return(res); }
public double[,] rabbit_fox_horizontal_diff_ts(float r, float r_ts, float f, float f_ts, int yr, string r_integ_method, string f_integ_method) { int ts_factor = 10; //time step factor, to define numer of loops in unit of time, e.g. if ts=0.1 then we will have 10 loops in each unit of time float ts; if (r_ts > f_ts) ts = f_ts; else if (r_ts > f_ts) ts = r_ts; else ts = r_ts; if (ts >= 0.1) { ts_factor = 10; } else if (ts >= 0.009) //>=0.01 { ts_factor = 100; } else if (ts >= 0.0009) //>=0.001 ts_factor = 1000; //ts_factor = 1000; Rabbit rab = new Rabbit(); Fox fx_m = new Fox(); RungeKutta rk = new RungeKutta(); //the system will loop for each time step //int lp = Convert.ToInt32(Math.Truncate(yr / 0.1)); //total number of loop due to the defined year int lp = yr * ts_factor; lp = lp + 1; // r_result = new double[lp]; //array for rab //f_result = new double[lp]; //array for fox double[,] result = new double[lp, 2]; double[] t = new double[3]; t[1] = Convert.ToDouble(r_ts.ToString("#.####")); //time step of rabbit t[2] = Convert.ToDouble(f_ts.ToString("#.####")); //time step of fox int temp_r_ts = Convert.ToInt16(r_ts * ts_factor); int temp_f_ts = Convert.ToInt16(f_ts * ts_factor); float rx = r; float ry = f; float fx = r; float fy = f; for (int i = 1; i < lp; i++) { int m = i % temp_r_ts; //m for maintaining result of % operation if (m == 0 && i > 0) //check if the current time step is valid to run rabit model { if (r_integ_method == "Runge-Kutta") // Runge-Kutta integration of rabbit model { rx = rk.calc_Rabbit_Runge_Kutta(rx, ry, r_ts); } else rx = rx + rab.rabbit_model(rx, ry) * r_ts; //rx = rx + rabbit_with_diff_func(rx, ry) * r_ts; r = rx; } int n = i % temp_f_ts; if (n == 0 && i > 0) //check if the current time step is valid to run fox model { if (m == 0) fx = r; if (f_integ_method == "Runge-Kutta") // for Runge-Kutta integration of fox model { fy = rk.calc_Fox_Runge_Kutta(fy, fx, f_ts); } else fy = fy + fx_m.fox_model(fy, fx) * f_ts; //fy = fy + fox_with_diff_func(fy, fx) * f_ts; f = fy; fx = r; } if (m == 0) //if the time step meets ts of rabbit then copy value of f ry = f; //r_result[i] = r; // Convert.ToDouble(r.ToString("#.##")); result[i,0] = r; if (f >= 0) //f_result[i] = f; result[i, 1] = f; else //if fox pop <0 set it to 0 { f = 0; //f_result[i] = 0; result[i, 1] = 0; } if (result[i, 0] < 0) // (r_result[i] < 0) { //r_result[i] = 0;//if rab pop<0 then set the pop value to 0 and quit //f_result[i] = 0; result[i, 0] = 0;//if rab pop<0 then set the pop value to 0 and quit result[i, 1] = 0; break; } } return result; }
/// <summary> /// Obtaining the time integrated spatial discretization of the reinitialization equation in a narrow band around the zero level set, based on a Godunov's numerical Hamiltonian calculation /// </summary> /// <param name="LS"> The level set function </param> /// <param name="Restriction"> The narrow band around the zero level set </param> /// <param name="NumberOfTimesteps"> /// maximum number of pseudo-timesteps /// </param> /// <param name="thickness"> /// The smoothing width of the signum function. /// This is the main stabilization parameter for re-initialization. /// It should be set to approximately 3 cells. /// </param> /// <param name="TimestepSize"> /// size of the pseudo-timestep /// </param> public void ReInitialize(LevelSet LS, SubGrid Restriction, double thickness, double TimestepSize, int NumberOfTimesteps) { using (var tr = new FuncTrace()) { // log parameters: tr.Info("thickness: " + thickness.ToString(NumberFormatInfo.InvariantInfo)); tr.Info("TimestepSize: " + TimestepSize.ToString(NumberFormatInfo.InvariantInfo)); tr.Info("NumberOfTimesteps: " + NumberOfTimesteps); ExplicitEuler TimeIntegrator; SpatialOperator SO; Func <int[], int[], int[], int> QuadratureOrder = QuadOrderFunc.NonLinear(3); if (m_ctx.SpatialDimension == 2) { SO = new SpatialOperator(1, 5, 1, QuadratureOrder, new string[] { "LS", "LSCGV", "LSDG[0]", "LSUG[0]", "LSDG[1]", "LSUG[1]", "Result" }); SO.EquationComponents["Result"].Add(new GodunovHamiltonian(m_ctx, thickness)); SO.Commit(); TimeIntegrator = new RungeKutta(m_Scheme, SO, new CoordinateMapping(LS), new CoordinateMapping(LSCGV, LSDG[0], LSUG[0], LSDG[1], LSUG[1]), sgrd: Restriction); } else { SO = new SpatialOperator(1, 7, 1, QuadratureOrder, new string[] { "LS", "LSCGV", "LSDG[0]", "LSUG[0]", "LSDG[1]", "LSUG[1]", "LSDG[2]", "LSUG[2]", "Result" }); SO.EquationComponents["Result"].Add(new GodunovHamiltonian(m_ctx, thickness)); SO.Commit(); TimeIntegrator = new RungeKutta(m_Scheme, SO, new CoordinateMapping(LS), new CoordinateMapping(LSCGV, LSDG[0], LSUG[0], LSDG[1], LSUG[1], LSDG[2], LSUG[2]), sgrd: Restriction); } // Calculating the gradients in each sub-stage of a Runge-Kutta integration procedure ExplicitEuler.ChangeRateCallback EvalGradients = delegate(double t1, double t2) { LSUG.Clear(); CalculateLevelSetGradient(LS, LSUG, "Upwind", Restriction); LSDG.Clear(); CalculateLevelSetGradient(LS, LSDG, "Downwind", Restriction); LSCG.Clear(); CalculateLevelSetGradient(LS, LSCG, "Central", Restriction); LSCGV.Clear(); var VolMask = (Restriction != null) ? Restriction.VolumeMask : null; LSCGV.ProjectAbs(1.0, VolMask, LSCG.ToArray()); }; TimeIntegrator.OnBeforeComputeChangeRate += EvalGradients; { EvalGradients(0, 0); var GodunovResi = new SinglePhaseField(LS.Basis, "Residual"); SO.Evaluate(1.0, 0.0, LS.Mapping, TimeIntegrator.ParameterMapping.Fields, GodunovResi.Mapping, Restriction); //Tecplot.Tecplot.PlotFields(ArrayTools.Cat<DGField>( LSUG, LSDG, LS, GodunovResi), "Residual", 0, 3); } // pseudo-timestepping // =================== double factor = 1.0; double time = 0; LevelSet prevLevSet = new LevelSet(LS.Basis, "prevLevSet"); CellMask RestrictionMask = (Restriction == null) ? null : Restriction.VolumeMask; for (int i = 0; (i < NumberOfTimesteps); i++) { tr.Info("Level set reinitialization pseudo-timestepping, timestep " + i); // backup old Levelset // ------------------- prevLevSet.Clear(); prevLevSet.Acc(1.0, LS, RestrictionMask); // time integration // ---------------- double dt = TimestepSize * factor; tr.Info("dt = " + dt.ToString(NumberFormatInfo.InvariantInfo) + " (factor = " + factor.ToString(NumberFormatInfo.InvariantInfo) + ")"); TimeIntegrator.Perform(dt); time += dt; // change norm // ------ prevLevSet.Acc(-1.0, LS, RestrictionMask); double ChangeNorm = prevLevSet.L2Norm(RestrictionMask); Console.WriteLine("Reinit: PseudoTime: {0} - Changenorm: {1}", i, ChangeNorm); //Tecplot.Tecplot.PlotFields(new SinglePhaseField[] { LS }, m_ctx, "Reinit-" + i, "Reinit-" + i, i, 3); } //*/ } }
private static void Main() //****************************************************************************80 // // Purpose: // // MAIN is the main program for LORENZ_ODE. // // Discussion: // // Thanks to Ben Whitney for pointing out an error in specifying a loop, // 24 May 2016. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 May 2016 // // Author: // // John Burkardt // { const string command_filename = "lorenz_ode_commands.txt"; List <string> command_unit = new(); const string data_filename = "lorenz_ode_data.txt"; List <string> data_unit = new(); int j; const int m = 3; const int n = 200000; Console.WriteLine(""); Console.WriteLine("LORENZ_ODE"); Console.WriteLine(" Compute solutions of the Lorenz system."); Console.WriteLine(" Write data to a file for use by gnuplot."); // // Data // double t_final = 40.0; double dt = t_final / n; // // Store the initial conditions in entry 0. // double[] t = typeMethods.r8vec_linspace_new(n + 1, 0.0, t_final); double[] x = new double[m * (n + 1)]; x[0 + 0 * m] = 8.0; x[0 + 1 * m] = 1.0; x[0 + 2 * m] = 1.0; // // Compute the approximate solution at equally spaced times. // for (j = 0; j < n; j++) { double[] xnew = RungeKutta.rk4vec(t[j], m, x, dt, Lorenz.lorenz_rhs, index: +j * m); int i; for (i = 0; i < m; i++) { x[i + (j + 1) * m] = xnew[i]; } } // // Create the plot data file. // for (j = 0; j <= n; j += 50) { data_unit.Add(" " + t[j].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[0 + j * m].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[1 + j * m].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[2 + j * m].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } File.WriteAllLines(data_filename, data_unit); Console.WriteLine(" Created data file \"" + data_filename + "\"."); /* * Create the plot command file. */ command_unit.Add("# " + command_filename + ""); command_unit.Add("#"); command_unit.Add("# Usage:"); command_unit.Add("# gnuplot < " + command_filename + ""); command_unit.Add("#"); command_unit.Add("set term png"); command_unit.Add("set output 'xyz_time.png'"); command_unit.Add("set xlabel '<--- T --->'"); command_unit.Add("set ylabel '<--- X(T), Y(T), Z(T) --->'"); command_unit.Add("set title 'X, Y and Z versus Time'"); command_unit.Add("set grid"); command_unit.Add("set style data lines"); command_unit.Add("plot '" + data_filename + "' using 1:2 lw 3 linecolor rgb 'blue'," + "'' using 1:3 lw 3 linecolor rgb 'red'," + "'' using 1:4 lw 3 linecolor rgb 'green'"); command_unit.Add("set output 'xyz_3d.png'"); command_unit.Add("set xlabel '<--- X(T) --->'"); command_unit.Add("set ylabel '<--- Y(T) --->'"); command_unit.Add("set zlabel '<--- Z(T) --->'"); command_unit.Add("set title '(X(T),Y(T),Z(T)) trajectory'"); command_unit.Add("set grid"); command_unit.Add("set style data lines"); command_unit.Add("splot '" + data_filename + "' using 2:3:4 lw 1 linecolor rgb 'blue'"); command_unit.Add("quit"); File.WriteAllLines(command_filename, command_unit); Console.WriteLine(" Created command file '" + command_filename + "'"); Console.WriteLine(""); Console.WriteLine("LORENZ_ODE:"); Console.WriteLine(" Normal end of execution."); Console.WriteLine(""); }
/// <summary> /// Método Runge Kutta de Segunda ordem para equações diferenciais /// </summary> /// <param name="y0">Valor Inicial</param> /// <param name="start">Tempo Inicial</param> /// <param name="end">Tempo Final</param> /// <param name="dydx">Equação diferencial a ser calculada</param> /// <returns></returns> public double RungeKutta2(double y0, double start, double end, Func <double, double, double> dydx) { return(RungeKutta.SecondOrder(y0, start, end, 10, dydx)[9]); }
/// <summary> /// Método Runge Kutta de Quarta ordem para equações diferenciais /// </summary> /// <param name="y0">Valor Inicial</param> /// <param name="start">Tempo Inicial</param> /// <param name="end">Tempo Final</param> /// <param name="dydx">Equação diferencial a ser calculada</param> /// <returns></returns> public double RungeKutta4(double y0, double start, double end, Func <double, double, double> dydx) { return(RungeKutta.FourthOrder(y0, start, end, 10, dydx)[9]); }
public double[,] rabbit_fox_horizontal_same_ts(float r, float f, int yr, float ts, string r_integ_method, string f_integ_method) { int ts_factor = 10; //time step factor, to define numer of loops in unit of time, e.g. if ts=0.1 then we will have 10 loops in each unit of time if (ts >= 0.1) { ts_factor = 10; } else if (ts >= 0.009) //>=0.01 { ts_factor = 100; } else if (ts >= 0.0009) //>=0.001 ts_factor = 1000; //ts_factor = 1000; Rabbit rab = new Rabbit(); Fox fx = new Fox(); RungeKutta rk = new RungeKutta(); //the system will loop according to the defined time step //int lp = Convert.ToInt16(Math.Truncate(yr / ts)); //total number of loop due to the defined time step //int lp = Convert.ToInt32(Math.Truncate(yr / 0.1)); //10 timestep in 1 year int lp = yr * ts_factor; lp = lp + 2; double[,] result = new double[lp, 2]; float fr = r; //rabbit population for fox model for (int i = 1; i < lp; i++) { //if (i % (Convert.ToInt16(Math.Truncate(ts * 10))) == 0) if (i % (Convert.ToInt16(ts * ts_factor)) == 0) { //run rabbit model if (r_integ_method == "Runge-Kutta") // for Runge-Kutta integration of rabbit { r = rk.calc_Rabbit_Runge_Kutta(r, f, ts); } else //for euler integration r = r + rab.rabbit_model(r, f) * ts; // r = r + rabbit_with_diff_func(r, f) * ts; //rabbit with px/(q+x) function than bx //run fox model if (f_integ_method == "Runge-Kutta") // for Runge-Kutta integration of fox model { f = rk.calc_Fox_Runge_Kutta(f, fr, ts); } else f = f + fx.fox_model(f, fr) * ts; //f = f + fox_with_diff_func(f, fr) * ts; //fox with px/(q+x) function than bx fr = r; //update current rabbit population for fox model if (r < 0) result[i, 0] = 0; else result[i, 0] = r; //Convert.ToDouble(r.ToString("#.##")); if (f < 0) result[i, 1] = 0; else result[i, 1] = f; // Convert.ToDouble(f.ToString("#.##")); if (result[i, 0] < 0) //(result[i, 0] < 1) { result[i, 0] = 0; //if pop<0 then set the pop value to 0 result[i, 1] = 0; break; } } else { if (r < 0) //(result[i, 0] < 1) { result[i, 0] = 0; //if pop<0 then set the pop value to 0 result[i, 1] = 0; break; } else { result[i, 0] = r; result[i, 1] = f; } } } return result; }
/// <summary> /// Creates the appropriate time-stepper for a given /// <paramref name="timeStepperType"/> /// </summary> /// <param name="timeStepperType"> /// The type of the time-stepper (e.g., Runge-Kutta) to be created /// </param> /// <param name="control"> /// Configuration options /// </param> /// <param name="equationSystem"> /// The equation system to be solved /// </param> /// <param name="fieldSet"> /// Fields affected by the time-stepper /// </param> /// <param name="parameterMap"> /// Fields serving as parameter for the time-stepper. /// </param> /// <param name="speciesMap"> /// Mapping of different species inside the domain /// </param> /// <param name="program"></param> /// <returns> /// Depending on <paramref name="timeStepperType"/>, an appropriate /// implementation of <see cref="ITimeStepper"/>. /// </returns> /// <remarks> /// Currently limiting is not supported for Adams-Bashforth methods /// </remarks> public static ITimeStepper Instantiate <T>( this ExplicitSchemes timeStepperType, CNSControl control, OperatorFactory equationSystem, CNSFieldSet fieldSet, CoordinateMapping parameterMap, ISpeciesMap speciesMap, IProgram <T> program) where T : CNSControl, new() { CoordinateMapping variableMap = new CoordinateMapping(fieldSet.ConservativeVariables); IBMControl ibmControl = control as IBMControl; IBMOperatorFactory ibmFactory = equationSystem as IBMOperatorFactory; if (control.DomainType != DomainTypes.Standard && (ibmFactory == null || ibmControl == null)) { throw new Exception(); } ITimeStepper timeStepper; switch (timeStepperType) { case ExplicitSchemes.RungeKutta when control.DomainType == DomainTypes.Standard: timeStepper = new RungeKutta( RungeKutta.GetDefaultScheme(control.ExplicitOrder), equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.RungeKutta: timeStepper = ibmControl.TimesteppingStrategy.CreateRungeKuttaTimeStepper( ibmControl, equationSystem, fieldSet, parameterMap, speciesMap, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.AdamsBashforth when control.DomainType == DomainTypes.Standard: timeStepper = new AdamsBashforth( equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, control.ExplicitOrder, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.AdamsBashforth: timeStepper = new IBMAdamsBashforth( ibmFactory.GetJoinedOperator().ToSpatialOperator(fieldSet), ibmFactory.GetImmersedBoundaryOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, speciesMap, ibmControl, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.LTS when control.DomainType == DomainTypes.Standard: timeStepper = new AdamsBashforthLTS( equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, control.ExplicitOrder, control.NumberOfSubGrids, equationSystem.GetJoinedOperator().CFLConstraints, reclusteringInterval: control.ReclusteringInterval, fluxCorrection: control.FluxCorrection, saveToDBCallback: program.SaveToDatabase, maxNumOfSubSteps: control.maxNumOfSubSteps); break; case ExplicitSchemes.LTS: timeStepper = new IBMAdamsBashforthLTS( equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), ibmFactory.GetImmersedBoundaryOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, speciesMap, ibmControl, equationSystem.GetJoinedOperator().CFLConstraints, reclusteringInterval: control.ReclusteringInterval, fluxCorrection: control.FluxCorrection, maxNumOfSubSteps: control.maxNumOfSubSteps); break; case ExplicitSchemes.Rock4 when control.DomainType == DomainTypes.Standard: timeStepper = new ROCK4(equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), new CoordinateVector(variableMap), null); break; case ExplicitSchemes.SSP54 when control.DomainType == DomainTypes.Standard: timeStepper = new RungeKutta( RungeKuttaScheme.SSP54, equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.RKC84 when control.DomainType == DomainTypes.Standard: timeStepper = new RungeKutta( RungeKuttaScheme.RKC84, equationSystem.GetJoinedOperator().ToSpatialOperator(fieldSet), variableMap, parameterMap, equationSystem.GetJoinedOperator().CFLConstraints); break; case ExplicitSchemes.None: throw new System.ArgumentException("Cannot instantiate empty scheme"); default: throw new NotImplementedException(String.Format( "Explicit time stepper type '{0}' not implemented for domain type '{1}'", timeStepperType, control.DomainType)); } // Make sure shock sensor is updated before every flux evaluation if (control.ShockSensor != null) { ExplicitEuler explicitEulerBasedTimestepper = timeStepper as ExplicitEuler; if (explicitEulerBasedTimestepper == null) { throw new Exception(String.Format( "Shock-capturing currently not implemented for time-steppers of type '{0}'", timeStepperType)); } explicitEulerBasedTimestepper.OnBeforeComputeChangeRate += delegate(double absTime, double relTime) { // Note: Only shock sensor is updated, _NOT_ the corresponding variable program.Control.ShockSensor.UpdateSensorValues( program.WorkingSet, program.SpeciesMap, explicitEulerBasedTimestepper.SubGrid.VolumeMask); // Note: When being called, artificial viscosity is updated in the _ENTIRE_ (fluid) domain var avField = program.WorkingSet.DerivedFields[Variables.ArtificialViscosity]; Variables.ArtificialViscosity.UpdateFunction(avField, program.SpeciesMap.SubGrid.VolumeMask, program); // Test //double sensorNorm = program.WorkingSet.DerivedFields[Variables.ShockSensor].L2Norm(); //double avNorm = program.WorkingSet.DerivedFields[Variables.ArtificialViscosity].L2Norm(); //Console.WriteLine("\r\nThis is OnBeforeComputeChangeRate"); //Console.WriteLine("SensorNeu: {0}", sensorNorm); //Console.WriteLine("AVNeu: {0}", avNorm); }; } // Make sure limiter is applied after each modification of conservative variables if (control.Limiter != null) { ExplicitEuler explicitEulerBasedTimestepper = timeStepper as ExplicitEuler; if (explicitEulerBasedTimestepper == null) { throw new Exception(String.Format( "Limiting currently not implemented for time-steppers of type '{0}~", timeStepperType)); } explicitEulerBasedTimestepper.OnAfterFieldUpdate += (t, f) => control.Limiter.LimitFieldValues(program); } return(timeStepper); }
static void Main(string[] args) { RungeKutta Result = new RungeKutta(); Result.Wynik(); }
private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 tests RK1_TI_STEP. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 06 July 2010 // // Author: // // John Burkardt // { const double t0 = 0.0; const double tn = 1.0; Console.WriteLine(""); Console.WriteLine("TEST01"); Console.WriteLine(" RK1_TI_STEP uses a first order RK method"); Console.WriteLine(" for a problem whose right hand side does not"); Console.WriteLine(" depend explicitly on time."); const int n = 10; double[] x = new double[n + 1]; const double h = (tn - t0) / n; const double q = 1.0; int seed = 123456789; int i = 0; double t = t0; x[i] = 0.0; Console.WriteLine(""); Console.WriteLine(" I T X"); Console.WriteLine(""); Console.WriteLine(" " + i.ToString().PadLeft(8) + " " + t.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); for (i = 1; i <= n; i++) { t = ((n - i) * t0 + i * tn) / n; x[i] = RungeKutta.rk1_ti_step(x[i - 1], t, h, q, fi, gi, ref seed); Console.WriteLine(" " + i.ToString().PadLeft(8) + " " + t.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public Vector <double>[] Integrate(IReadOnlyList <double> Control) { _params = Control; return(RungeKutta.FourthOrder(_x0, 0, _tMax, _sizeOfRes, OdeFunction)); }