mned

type AdaptiveStepMethod ¶

type AdaptiveStepMethod struct {
	Step      float64
	Hmin      float64
	Hmax      float64
	Tolerance float64
	Method    func(*IVP, float64) bool
	Order     uint8
}

An AdaptiveStepMethod is a kind of adaptive method (that is, one that changes the step over time for greater precision and performance) that can be adapted from a fixed-step method.

Step, Hmin, and Hmax are the initial, minimum, and maximum step. If the step must go lower than Hmin to satisfy the tolerance, the stepper ends; if it could get greater than Hmax, it saturates to Hmax. The Tolerance is such that the Euclidean norm of the estimated error of any step of size `h` must be lower than `h*Tolerance`.

Method works the same way as in `FixedStepMethod` except that its error for a given interval of time must be on the order of `O(h^Order)`, with the variable `h` being the step. Order must be positive.

The algorithm used is the following, where `(t,x(t))` are the initial values, `y(h,t,x(t))` is the result of applying the inner method with step `h` from `(t,x(t))`, `k` is the order of the method and `h` is the step.

1. First, `F:=y(h,t,x(t))` and `H:=y(h/2,t+h/2,y(h/2,t,x(t)))` are obtained, and the error is estimated as `e:=|(1+1/(2^k-1))*(H-F)|`.
2. If that error is lower than `|h|*Tolerance`, the step is accepted. Otherwise we set `q:=(|h|*Tolerance)/(2*e)`, saturate so that `q` is in `[0.1, 4]`, set `h:=q*h`, check bounds on `h` and return to the start.
3. The next value is taken to be `(t+h, (2^k*H - H)/(2^k - 1))`, and the next step size is calculated by changing `h` as in step 2.

The steppers are *not* `ConfigurableStepper`s.

func (m *AdaptiveStepMethod) Backward(ivp *IVP) Stepper

func (m *AdaptiveStepMethod) Forward(ivp *IVP) Stepper

type CacheSolver ¶

type CacheSolver struct {
	// contains filtered or unexported fields
}

A CacheSolver is like a dynamic version of a DenseSolution. It stores points of the solution of a problem in a conceptually maximal interval that is evaluated lazily; that is, it starts with the solutions in a range that only includes the initial point and, when a point is asked for a Time value outside the range, the range is expanded to cover that point.

func CacheSolve(
	m Method, ivp *IVP, interp Interpolator, evs ...Event,
) CacheSolver

func (c *CacheSolver) BackwardPoints() []Point

func (c *CacheSolver) End() float64

func (c *CacheSolver) ForwardPoints() []Point

func (c *CacheSolver) Get(t float64) (x []float64, ok bool)

func (c *CacheSolver) PointCoords() [][]float64

func (c *CacheSolver) Start() float64

func (c *CacheSolver) StepBackward(h float64) ([]float64, bool)

func (c *CacheSolver) StepForward(h float64) ([]float64, bool)

func (c *CacheSolver) StepToBeginning()

func (c *CacheSolver) StepToEnd()

type ConfigurableStepper ¶

type ConfigurableStepper interface {
	Stepper
	// Like Stepper.Next but the time of the next point is specified to be
	// the time of the latest point plus the value given.
	NextStep(float64) (*Point, bool)
}

A ConfigurableStepper is a Stepper which allows specifying the delta of the next step; that is, the difference between the time of a point and that of the previous point.

type DenseSolution ¶

type DenseSolution struct {
	// contains filtered or unexported fields
}

A DenseSolution is a structure with precalculated points of a solution within a given interval. It allows getting the value of any point within that interval via interpolation. The zero value is meaningless.

func DenseSolve(
	method Method,
	ivp *IVP,
	start float64,
	end float64,
	interp Interpolator,
) (DenseSolution, bool)

func (d *DenseSolution) End() float64

func (d *DenseSolution) Get(time float64) ([]float64, bool)

func (d *DenseSolution) InnerPoints() []Point

func (d *DenseSolution) PointCoords() [][]float64

func (d *DenseSolution) Start() float64

type Event ¶

type Event struct {
	Cross     func(*Point) float64
	Tolerance float64
	Action    func(*Point) bool
}

An Event is a condition that can happen in a point in the solution of an initial value problem and an associated action to take. The event happens at the point of the solution where a given function changes its sign.

The Cross function is a continuous function whose zeroes are the points where the event happens. The Tolerance is the margin of error allowed; the maximum absolute value of `Cross(p)` such that `p` is considered to be close enough to an event to be passed to Action. The Action is to be called when an occurrence of the event is found; it can use the point in some way and it returns a boolean indicating whether the calculation should continue.

func (e *Event) FindPoint(i Interpolator, p1 *Point, p2 *Point) Point

type FixedStepMethod ¶

type FixedStepMethod struct {
	Step   float64
	Method func(*IVP, float64) bool
}

Create a fixed step method, one where all steps increment or decrement the time by the same amount, with the added condition that it shouldn't depend on extra state. The Step is the fixed increment/decrement of time, which must be positive. The steppers returned by this method are `ConfigurableStepper`s.

The Method is a function that takes an IVP and a step and stores in IVP.Start.Value the value for IVP.Start.Time+step, while leaving IVP.Start.Time untouched. The return value of `method` is true if the operation completed successfully or false if there was a problem, such as going out of the domain of the IVP.Derivative, in which case the resulting state of the IVP is unspecified.

func (m FixedStepMethod) Backward(ivp *IVP) Stepper

func (m FixedStepMethod) Forward(ivp *IVP) Stepper

type HermiteInterpolator ¶

type HermiteInterpolator struct {
	F func(Point) ([]float64, bool) // The derivative function.
}

A HermiteInterpolator is an interpolator that takes into account the derivative of the solution function in the end points.

func HermiteForIVP(ivp *IVP) HermiteInterpolator

func (h HermiteInterpolator) FindValue(
	p1 *Point, p2 *Point, t float64,
) []float64

type IVP ¶

type IVP struct {
	Derivative func(Point) ([]float64, bool)
	Start      Point
}

An IVP is an initial value problem given by a first-order ODE. It's given by the Derivative function, which is a pure function, and the initial values.

The second return value of Derivative indicates if the Point was in the domain of the function. If it wasn't the first return value should not be used. Ideally, the domain should be restricted to the connected component of the initial value, as otherwise a solving method could "jump" to another component and the results from there on would be invalid.

func (ivp *IVP) Clone() IVP

type Interpolator ¶

type Interpolator interface {
	// Approximate the value of a function in a point `t` given two
	// **different** points `p1` and `p2` of the function such that `t`
	// is between `p1.Time` and `p2.Time`.
	FindValue(p1 *Point, p2 *Point, t float64) []float64
}

An Interpolator tries to approximate a function based on a finite set of known points in it. We'll focus just on interpolation with two points since this is precise enough for our purposes, although the interpolator might be constructed with some knowledge about the underlying function.

type LinearInterpolator ¶

type LinearInterpolator struct{}

A LinearInterpolator is an interpolator that assumes that there's a straight line between the two points given. It can be constructed with `new`.

func (li LinearInterpolator) FindValue(
	p1 *Point, p2 *Point, t float64,
) []float64

type Method ¶

type Method interface {
	// Make a stepper over the solution of the given IVP that starts at the
	// initial values of the problem and goes to ever increasing values for
	// the independent variable.
	Forward(*IVP) Stepper
	// Make a stepper over the solution of the given IVP that starts at the
	// initial values of the problem and goes to ever decreasing values for
	// the independent variable.
	Backward(*IVP) Stepper
}

A Method is a way of approximating points of the solution to an IVP. It works as a factory of Steppers that step forward and backward from the initial values of the problem.

type Point ¶

type Point struct {
	Time  float64   // The independent variable.
	Value []float64 // The dependent variable.
}

A Point is an element of the solution, given by the values of the independent and dependent variables.

func (p *Point) Clone() Point

type Stepper ¶

type Stepper interface {
	// Go to the next point and return a pointer to it. If the second value
	// is false, there are no more points in the direction the Stepper is
	// following and the value of Point should not be trusted.
	//
	// The point returned might change after the next call to next() on the
	// same Stepper.
	Next() (*Point, bool)
}

A Stepper is an iterator over points of the solution of an IVP. ODE solver methods generally produce steppers that go from the initial values of the problems to lower or greater values.