private void button1_Click(object sender, EventArgs e)
{
//library uses one solver type (more will come if there will be demand): dense output stepper based on runge_kutta_dopri5 with standard error bounds 10^(-6) for the steps.
try
{
_columns.Clear();
_rows.Clear();
var stepper = (StepperTypeCode) Enum.Parse(typeof (StepperTypeCode), StepperBox.Text);
var integrateFunction =
(IntegrateFunctionTypeCode) Enum.Parse(typeof (IntegrateFunctionTypeCode), IntegrateFunctionBox.Text);
var @from = (double)FromGUI.Value;
var to = (double)ToGUI.Value;
var step = (double)StepGUI.Value;
var solver = new Solver {StepperCode = stepper};
solver.Solve(_lorenz, @from,step, to, integrateFunction);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return;
}
//Draw ZedGraph
var graph = zg1;
var graphPane = zg1.GraphPane;
graphPane.CurveList.Clear();
graphPane.GraphObjList.Clear();
graphPane.AddCurve(
"Lorenz",
_rows.ToArray(),
_columns.ToArray(),
Color.CornflowerBlue);
graph.AxisChange();
graph.Invalidate();
graph.Refresh();
}
static void Main()
{
//library uses one solver type (more will come if there will be demand): dense output stepper based on runge_kutta_dopri5 with standard error bounds 10^(-6) for the steps.
var solver = new Solver();
const double @from = 0.0;
const double to = 25.0;
const double step = 0.1;
//Say we have a class describing our system:
var myLorenz = new LorenzOde
{
InitialConditions = new StateType(new[] { 10, 1.0, 1.0 })
};
// All we need to solve it:
solver.ConvenienceSolve(myLorenz, from, to, step);
//library class provides a simple to use Lambda API for ODE system defenition (example of lorenz, 50 steps)
var lorenz = new LambdaOde
{
InitialConditions = new StateType(new[] { 10, 1.0, 1.0 }),
OdeObserver = (x, t) => Console.WriteLine("{0} : {1} : {2}", x[0], x[1], x[2]),
OdeSystem =
(x, dxdt, t) => {
const double sigma = 10.0;
const double r = 28.0;
const double b = 8.0 / 3.0;
dxdt[0] = sigma * (x[1] - x[0]);
dxdt[1] = r * x[0] - x[1] - x[0] * x[2];
dxdt[2] = -b * x[2] + x[0] * x[1];
}
};
// And all we need to solve it:
solver.ConvenienceSolve(lorenz, from, to, step);
// We can select stepper that our stepper would use
solver.StepperCode = StepperTypeCode.RungeKutta4;
// We can select how our IntegrateFunction will work:
solver.Solve(lorenz, from, step, to, IntegrateFunctionTypeCode.Adaptive);
// We can integrate for first N steps
solver.Solve(lorenz, from, step, 5 );
// Or at given time periods
solver.Solve(lorenz, new StateType(new[] { 0, 10.0, 100.0, 1000.0 }), step);
Console.ReadLine();
Console.WriteLine("Complex Test");
var complexSolver = new ComplexSolver();
const double eta = 2;
const double alpha = 1;
var complexEta = new Complex(1, eta);
var complexAlpha = new Complex(1,alpha);
var stuartLandauOscillator = new ComplexLambdaOde
{
InitialConditions = new ComplexStateType {new Complex(1, 0)},
OdeObserver = (x, t) => Console.WriteLine("{0}", x[0]),
OdeSystem =
(x, dxdt, t) =>
{
dxdt[0] = complexEta * x[0] - (complexAlpha * x[0].Norm()) * x[0];
}
};
// And all we need to solve it:
complexSolver.ConvenienceSolve(stuartLandauOscillator, from, to, step);
// We can select stepper that our stepper would use
complexSolver.StepperCode = StepperTypeCode.RungeKutta4;
// We can select how our IntegrateFunction will work:
complexSolver.Solve(stuartLandauOscillator, from, step, to, IntegrateFunctionTypeCode.Adaptive);
// We can integrate for first N steps
complexSolver.Solve(stuartLandauOscillator, from, step, 5);
// Or at given time periods
complexSolver.Solve(stuartLandauOscillator, new StateType(new[] { 0, 10.0, 100.0, 1000.0 }), step);
Console.ReadLine();
}