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