rkv89_class – rklib

type, public, extends(rk_variable_step_class) :: rkv89_class

Verner 8(9)

Inherits

Help

Type-Bound Procedures

procedure, public :: destroy

destructor

private subroutine destroy(me)

Destructor for rk_class.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(out)			::	me

procedure, public :: stop => rk_class_stop

user-callable method to stop the integration

private subroutine rk_class_stop(me)

User-callable method to stop the integration (e.g., from f, g, or report). No further function evaluations are done, and the integrator returns, with the status set to RKLIB_ERROR_USER_STOPPED. This is not treated as an error (i.e., it does not stop the program if stop_on_errors is true).

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(inout)			::	me

procedure, public :: status => rk_class_status

get status code and message

private subroutine rk_class_status(me, istatus, message)

Get the status of an integration.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(in)			::	me
integer,	intent(out),	optional		::	istatus	status code (`<0` means an error)
character(len=:),	intent(out),	optional,	allocatable	::	message	status message

procedure, public :: failed

private function failed(me)

Returns true if there was an error. Can use rk_class_status to get more info.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(in)			::	me

Return Value logical

procedure, public :: interpolate

dense output for the last accepted step

private recursive subroutine interpolate(me, t, x, istatus)

Dense output: compute the state at a time within the last accepted step, using the continuous extension of the method (if it has one, see rklib_properties dense).

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(inout)			::	me
real(kind=wp),	intent(in)			::	t	time at which to compute the state
real(kind=wp),	intent(out),		dimension(me%n)	::	x	state at `t`
integer,	intent(out),	optional		::	istatus	status of this call

procedure, public :: dense_interval

interval of the last accepted step for the dense output

private subroutine dense_interval(me, available, t0, tf, x0, xf)

Returns the interval of the last accepted step, which is where interpolate can be used. For example, this can be called from the report function to get the previous time and state, so that points in between can be computed.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_class),	intent(inout)			::	me
logical,	intent(out)			::	available	if dense output is available
real(kind=wp),	intent(out),	optional		::	t0	initial time of the step
real(kind=wp),	intent(out),	optional		::	tf	final time of the step
real(kind=wp),	intent(out),	optional,	dimension(me%n)	::	x0	initial state of the step
real(kind=wp),	intent(out),	optional,	dimension(me%n)	::	xf	final state of the step

procedure, public :: initialize => initialize_variable_step

initialize the class (set n,f, and report)

private subroutine initialize_variable_step(me, n, f, rtol, atol, stepsize_method, hinit_method, report, g, stop_on_errors, max_number_of_steps, report_rate, solver, dense_output, dense_output_step)

Initialize the rk_variable_step_class.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_variable_step_class),	intent(inout)			::	me
integer,	intent(in)			::	n	number of equations
procedure(deriv_func)				::	f	derivative function
real(kind=wp),	intent(in),	optional,	dimension(:)	::	rtol	relative tolerance (if size=1, then same tol used for all equations). If not present, a default of `100*eps` is used
real(kind=wp),	intent(in),	optional,	dimension(:)	::	atol	absolute tolerance (if size=1, then same tol used for all equations). If not present, a default of `100*eps` is used
type(stepsize_class),	intent(in),	optional		::	stepsize_method	method for varying the step size
integer,	intent(in),	optional		::	hinit_method	which method (1 or 2) to use for automatic initial step size computation. 1 = use `hstart`, 2 = use `hinit`.
procedure(report_func),		optional		::	report	for reporting the steps
procedure(event_func),		optional		::	g	for stopping at an event
logical,	intent(in),	optional		::	stop_on_errors	stop the program for any errors (default is False)
integer,	intent(in),	optional		::	max_number_of_steps	max number of steps allowed
integer,	intent(in),	optional		::	report_rate	how often to call report function: `0` : no reporting (same as not associating `report`), `1` : report every point, `2` : report every other point, etc. The first and last point are always reported.
class(root_method),	intent(in),	optional		::	solver	the root-finding method to use for even finding. if not present, then `brent_solver` is used.
logical,	intent(in),	optional		::	dense_output	to enable the dense output (default is False, unless `dense_output_step` is present and not zero). If enabled, interpolate can be used (e.g., from the `report` function), and the dense output is also used for event location in integrate_to_event_variable_step. The method must have a dense output. When not enabled, there is no overhead for the dense output.
real(kind=wp),	intent(in),	optional		::	dense_output_step	if present and not zero, the points are reported at this fixed time interval (starting from the initial time), using the dense output of the method, rather than at the steps taken by the integrator. The first and last point are also reported (so the last interval will generally be shorter). This is only used if `report` is present and `report_rate>0` (`report_rate` is otherwise ignored). The method must have a dense output. This automatically enables the dense output (it is an error if `dense_output=.false.` is also specified).

procedure, public :: integrate => integrate_variable_step

private subroutine integrate_variable_step(me, t0, x0, h, tf, xf)

Main integration routine for the rk_variable_step_class.

Arguments

Type	Intent	Attributes		Name
class(rk_variable_step_class),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	t0	initial time
real(kind=wp),	intent(in),	dimension(:)	::	x0	initial state
real(kind=wp),	intent(in)		::	h	initial abs(time step)
real(kind=wp),	intent(in)		::	tf	final time
real(kind=wp),	intent(out),	dimension(:)	::	xf	final state

procedure, public :: integrate_to_event => integrate_to_event_variable_step

private subroutine integrate_to_event_variable_step(me, t0, x0, h, tmax, tol, tf, xf, gf)

Event-finding integration routine for the rk_variable_step_class. Integrates until g(t,x)=0, or until t=tf (whichever happens first).

Arguments

Type	Intent	Attributes		Name
class(rk_variable_step_class),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	t0	initial time
real(kind=wp),	intent(in),	dimension(me%n)	::	x0	initial state
real(kind=wp),	intent(in)		::	h	abs(time step)
real(kind=wp),	intent(in)		::	tmax	max final time if event not located
real(kind=wp),	intent(in)		::	tol	function tolerance for root finding
real(kind=wp),	intent(out)		::	tf	actual final time reached
real(kind=wp),	intent(out),	dimension(me%n)	::	xf	final state (at tf)
real(kind=wp),	intent(out)		::	gf	g value at tf

procedure, public :: info => info_variable_step

private subroutine info_variable_step(me, num_steps, num_rejected_steps, last_accepted_step_size)

Return some info about the integration.

Arguments

Type	Intent	Optional		Name
class(rk_variable_step_class),	intent(in)		::	me
integer,	intent(out),	optional	::	num_steps	number of steps taken
integer,	intent(out),	optional	::	num_rejected_steps	number of rejected steps
real(kind=wp),	intent(out),	optional	::	last_accepted_step_size	the last accepted step size `dt` from the integration (positive or negative)

procedure, public :: destroy_fsal_cache

private subroutine destroy_fsal_cache(me)

Destructor for the function evaluation cache.

Arguments

Type	Intent	Optional	Attributes		Name
class(rk_variable_step_class),	intent(inout)			::	me

procedure, public :: check_fsal_cache

private subroutine check_fsal_cache(me, t, x, f)

Compute the function at t and x, or get it from the function evaluation cache if it is there (see set_fsal_cache). This is used by all the variable-step methods for the first stage of a step. It may already be in the cache because:

Arguments

Type	Intent	Attributes		Name
class(rk_variable_step_class),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	t
real(kind=wp),	intent(in),	dimension(:)	::	x
real(kind=wp),	intent(out),	dimension(:)	::	f

procedure, public :: set_fsal_cache

private subroutine set_fsal_cache(me, t, x, f)

Compute the function and add it to the function evaluation cache, so that it can be reused by the next step (see check_fsal_cache). This is used for f at the end of a step: by the first-same-as-last (FSAL) methods (the last stage of the step), and by the methods whose dense output needs it as one of its extra stages (see dense_extra_stages).

Arguments

Type	Intent	Attributes		Name
class(rk_variable_step_class),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	t
real(kind=wp),	intent(in),	dimension(:)	::	x
real(kind=wp),	intent(out),	dimension(:)	::	f

procedure, public :: step => rkv89

interface

private module subroutine rkv89(me, t, x, h, xf, xerr)

Arguments

Type	Intent	Attributes		Name
class(rkv89_class),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	t	initial time
real(kind=wp),	intent(in),	dimension(me%n)	::	x	initial state
real(kind=wp),	intent(in)		::	h	time step
real(kind=wp),	intent(out),	dimension(me%n)	::	xf	state at time `t+h`
real(kind=wp),	intent(out),	dimension(me%n)	::	xerr	truncation error estimate for `x`

procedure, public :: properties => rkv89_properties

interface

private pure module function rkv89_properties(me) result(p)

Arguments

Type	Intent	Optional	Attributes		Name
class(rkv89_class),	intent(in)			::	me

Return Value type(rklib_properties)

properties of the method

rkv89_class Derived Type

Contents

Type-Bound Procedures

type, public, extends(rk_variable_step_class) :: rkv89_class

Inherits

Type-Bound Procedures

procedure, public :: destroy

private subroutine destroy(me)

Arguments

procedure, public :: stop => rk_class_stop

private subroutine rk_class_stop(me)

Arguments

procedure, public :: status => rk_class_status

private subroutine rk_class_status(me, istatus, message)

Arguments

procedure, public :: failed

private function failed(me)

Arguments

Return Value logical

procedure, public :: interpolate

private recursive subroutine interpolate(me, t, x, istatus)

Arguments

procedure, public :: dense_interval

private subroutine dense_interval(me, available, t0, tf, x0, xf)

Arguments

procedure, public :: initialize => initialize_variable_step

private subroutine initialize_variable_step(me, n, f, rtol, atol, stepsize_method, hinit_method, report, g, stop_on_errors, max_number_of_steps, report_rate, solver, dense_output, dense_output_step)

Arguments

procedure, public :: integrate => integrate_variable_step

private subroutine integrate_variable_step(me, t0, x0, h, tf, xf)

Arguments

procedure, public :: integrate_to_event => integrate_to_event_variable_step

private subroutine integrate_to_event_variable_step(me, t0, x0, h, tmax, tol, tf, xf, gf)

Arguments

procedure, public :: info => info_variable_step

private subroutine info_variable_step(me, num_steps, num_rejected_steps, last_accepted_step_size)

Arguments

procedure, public :: destroy_fsal_cache

private subroutine destroy_fsal_cache(me)

Arguments

procedure, public :: check_fsal_cache

private subroutine check_fsal_cache(me, t, x, f)

Arguments

procedure, public :: set_fsal_cache

private subroutine set_fsal_cache(me, t, x, f)

Arguments

procedure, public :: step => rkv89

interface

private module subroutine rkv89(me, t, x, h, xf, xerr) Implementation →

Arguments

procedure, public :: properties => rkv89_properties

interface

private pure module function rkv89_properties(me) result(p) Implementation →

Arguments

Return Value type(rklib_properties)

private module subroutine rkv89(me, t, x, h, xf, xerr)

private pure module function rkv89_properties(me) result(p)