/// <summary>
/// Method to evaluate the "Euler method" for any given function.
/// </summary>
/// <param name="function">the function to </param>
/// <param name="stepSize"></param>
/// <param name="lowerBound">Lower bound of range to evaluate over</param>
/// <param name="upperBound">Upper bound of range to evaluate over</param>
/// <param name="dependentInitial">Initial dependent value, e.g. y(lowerBound) = ____</param>
/// <returns></returns>
public static double Euler(ODEFunction Function, double stepSize, double lowerBound, double upperBound, double dependentInitial)
{
// using convention defining "y" as dependent variable and "x" as independent variable
// i may have screwed the termoinology up b/c differential eqns are hard
var totalSteps = (upperBound - lowerBound) / stepSize;
double dependentFinal = 0.0;
// declare as blank to keep compiler happy
double independent = lowerBound;
for (int i = 0; i < totalSteps; i++)
{
dependentFinal = dependentInitial + (stepSize * (Function(independent, dependentInitial)));
independent += stepSize;
dependentInitial = dependentFinal;
}
// FUN FACT: if you implement the algo as written in the example it breaks for small step sizes
// beacuse you're using a double-precision float for flow of control. when the step size is super small
// and then added to "independent", floating point errors are introduced, which means when you get to the final
// iteration that doesn't actually occur becuse if upper bound is 1.0 independent is like 1.00000000000012
// due to floating point errors.
//while (independent <= upperBound)
//{
// dependentFinal = dependentInitial + (stepSize * (Function(independent, dependentInitial)));
// independent += stepSize;
// dependentInitial = dependentFinal;
//}
return dependentFinal;
}
protected StandardODESolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
if (discretizer == null)
{
throw new ArgumentNullException("discretizer", "Null discretizer passed");
}
this.discretizer = discretizer;
if (function == null)
{
throw new ArgumentNullException("function", "Null function passed");
}
this.function = function;
if (maxIterations <= 0)
{
throw new ArgumentOutOfRangeException("maxIterations", "The number of maximum iterations must be positive");
}
this.maxIterations = maxIterations;
if (!initialCondition.IsFinite())
{
throw new ArgumentOutOfRangeException("initialCondition", "Non-finite initial condition");
}
this.initialCondition = initialCondition;
}
public RK4Solver(ODEFunction ode, double initialTime, Vector <double> initialState) : base(ode, initialTime, initialState)
{
}
public ODESolver(ODEFunction ode, double initialTime, Vector <double> initialState)
{
this.ode = ode;
Init(initialTime, initialState);
}
public static Function RungeKuttaSolve(this ODEFunction argument, Vector2D initialCondition, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(RungeKuttaSolver.MakeSolution(argument, initialCondition, maxIterations));
}
public static Function RungeKuttaSolve(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(RungeKuttaSolver.MakeSolution(argument, initialCondition, discretizer, options, maxIterations));
}
protected StandardODESolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS) :
this(function, initialCondition, discretizer, maxIterations)
{
nodeSelector = GenerateSelector(options);
}
private HeunSolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS) :
base(function, initialCondition, discretizer, maxIterations)
{
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, new UniformDiscretizer(DEFAULT_DISCRETIZER_STEP), options, maxIterations).Solve);
}
public static ArraySolver HeunArraySolver(this ODEFunction argument, Vector2D initialCondition, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(HeunSolver.MakeArraySolver(argument, initialCondition, maxIterations));
}
public static double RKOrder2(ODEFunction Function, double stepSize, double lowerBound, double upperBound, double dependentInitial)
{
double dependentFinal = 0.0;
// declare as blank to keep compiler happy
double KIncrement1, KIncrement2, u;
// using KIncrementN for k1-k4 increments, u staying as u despite not being very human readable oh well
double independent = lowerBound;
var totalSteps = (upperBound - lowerBound) / stepSize;
for (int i = 0; i < totalSteps; i++)
{
// calculating intermediary values
KIncrement1 = Function(independent, dependentInitial);
u = dependentInitial + (stepSize * KIncrement1);
KIncrement2 = Function(independent + stepSize, u);
// calculating value
dependentFinal = dependentInitial + (stepSize * 0.5 * (KIncrement1 + KIncrement2));
// iterating
independent += stepSize;
dependentInitial = dependentFinal;
}
return dependentFinal;
}
public static double RKOrder4(ODEFunction Function, double stepSize, double lowerBound, double upperBound, double dependentInitial)
{
double dependentFinal = 0.0;
// declare as blank to keep compiler happy
double KIncrement1, KIncrement2, KIncrement3, KIncrement4;
// using KIncrementN for k1-k4 increments, u staying as u despite not being very human readable oh well
double independent = lowerBound;
var totalSteps = (upperBound - lowerBound) / stepSize;
for (int i = 0; i < totalSteps; i++)
{
// Calculating k increments
KIncrement1 = stepSize * Function(independent, dependentInitial);
KIncrement2 = stepSize * (Function(independent + (0.5 * stepSize), dependentInitial +
(0.5 * KIncrement1)));
KIncrement3 = stepSize * (Function(independent + (0.5 * stepSize), dependentInitial +
(0.5 * KIncrement2)));
KIncrement4 = stepSize * (Function(independent + stepSize, dependentInitial + KIncrement3));
// summing k increments
dependentFinal = dependentInitial + ((1.0/6.0) * (KIncrement1 + (2 * (KIncrement2 +
KIncrement3)) + KIncrement4));
// iterating
independent += stepSize;
dependentInitial = dependentFinal;
}
return dependentFinal;
}
private RungeKuttaSolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS) :
base(function, initialCondition, discretizer, options, maxIterations)
{
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new RungeKuttaSolver(argument, initialCondition, discretizer, DEFAULT_MAX_ITERATIONS).Solve);
}
public static ArraySolver MakeArraySolver(ODEFunction argument, Vector2D initialCondition, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, new UniformDiscretizer(DEFAULT_DISCRETIZER_STEP), maxIterations).Solve);
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, discretizer, options, maxIterations).Solve);
}
public static Function HeunSolve(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(HeunSolver.MakeSolution(argument, initialCondition, discretizer, maxIterations));
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, int maxIterations)
{
return(new HeunSolver(argument, initialCondition, new UniformDiscretizer(DEFAULT_DISCRETIZER_STEP), maxIterations).Solve);
}
public static Function HeunSolve(this ODEFunction argument, Vector2D initialCondition, OptimizationOptions options, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(HeunSolver.MakeSolution(argument, initialCondition, options, maxIterations));
}
public static ArraySolver MakeArraySolver(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, discretizer, maxIterations).Solve);
}
//Euler solver extension
public static ArraySolver EulerArraySolver(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(EulerSolver.MakeArraySolver(argument, initialCondition, discretizer, maxIterations));
}
