# brainpy.integrators.ode.Heun2#

class brainpy.integrators.ode.Heun2(f, var_type=None, dt=None, name=None, show_code=False, state_delays=None, neutral_delays=None)[source]#

Heun’s method for ODEs.

This method is named after Karl Heun [1]. It is also known as the explicit trapezoid rule, improved Euler’s method, or modified Euler’s method.

Given ODEs with a given initial value,

$y'(t) = f(t,y(t)), \qquad y(t_0)=y_0,$

the two-stage Heun’s method is formulated as:

$\tilde{y}_{n+1} = y_n + h f(t_n,y_n)$
$y_{n+1} = y_n + \frac{h}{2}[f(t_n, y_n) + f(t_{n+1},\tilde{y}_{n+1})],$

where $$h$$ is the step size and $$t_{n+1}=t_n+h$$.

Therefore, the Butcher tableau of the two-stage Heun’s method is:

$\begin{split}\begin{array}{c|cc} 0.0 & 0.0 & 0.0 \\ 1.0 & 1.0 & 0.0 \\ \hline & 0.5 & 0.5 \end{array}\end{split}$

Geometric interpretation

In the brainpy.integrators.ode.midpoint(), we have already known Euler method has big estimation error because it uses the line tangent to the function at the beginning of the interval $$t_n$$ as an estimate of the slope of the function over the interval $$(t_n, t_{n+1})$$.

In order to address this problem, Heun’s Method considers the tangent lines to the solution curve at both ends of the interval ($$t_n$$ and $$t_{n+1}$$), one ($$f(t_n, y_n)$$) which underestimates, and one ($$f(t_{n+1},\tilde{y}_{n+1})$$, approximated using Euler’s Method) which overestimates the ideal vertical coordinates. The ideal point lies approximately halfway between the erroneous overestimation and underestimation, the average of the two slopes.

\begin{split}\begin{aligned} {\text{Slope}}_{\text{left}}=&f(t_{n},y_{n}) \\ {\text{Slope}}_{\text{right}}=&f(t_{n}+h,y_{n}+hf(t_{n},y_{n})) \\ {\text{Slope}}_{\text{ideal}}=&{\frac {1}{2}}({\text{Slope}}_{\text{left}}+{\text{Slope}}_{\text{right}}) \end{aligned}\end{split}

References

__init__(f, var_type=None, dt=None, name=None, show_code=False, state_delays=None, neutral_delays=None)#

Methods

 __init__(f[, var_type, dt, name, show_code, ...]) build() cpu() Move all variable into the CPU device. cuda() Move all variables into the GPU device. load_state_dict(state_dict[, warn, compatible]) Copy parameters and buffers from state_dict into this module and its descendants. load_states(filename[, verbose]) Load the model states. nodes([method, level, include_self]) Collect all children nodes. register_implicit_nodes(*nodes[, node_cls]) register_implicit_vars(*variables[, var_cls]) save_states(filename[, variables]) Save the model states. set_integral(f) Set the integral function. state_dict() Returns a dictionary containing a whole state of the module. to(device) Moves all variables into the given device. tpu() Move all variables into the TPU device. train_vars([method, level, include_self]) The shortcut for retrieving all trainable variables. tree_flatten() Flattens the object as a PyTree. tree_unflatten(aux, dynamic_values) Unflatten the data to construct an object of this class. unique_name([name, type_]) Get the unique name for this object. vars([method, level, include_self, ...]) Collect all variables in this node and the children nodes.

Attributes

 A B C arguments All arguments when calling the numer integrator of the differential equation. dt The numerical integration precision. integral The integral function. name Name of the model. neutral_delays neutral delays. parameters The parameters defined in the differential equation. state_delays State delays. variables The variables defined in the differential equation.