## functions in rkutta.i - r

rk4
```
y_at_x_plus_dx= rk4(y,dydx, x,dx, derivative)

takes a single 4th order Runge-Kutta step from X to X+DX.
DERIVATIVE(y,x) is a function returning dydx; the input DYDX
is DERIVATIVE(y,x) at the input (X,Y).  This fourth evaluation
of DERIVATIVE must be performed by the caller of rk4.
Interpreted function, defined at i/rkutta.i   line 233

```

rk_integrate
```
y= rk_integrate(derivative, y1, x, epsilon, dx1)

integrates dydx= DERIVATIVE(y,x) beginning at (X(1),Y1) and
going to X(0) with fractional error EPSILON.  The result is
the value of y at each value in the list X.  If non-nil, DX1
will be used as initial guess for the first step size.
Otherwise, X(2)-X(1) will be the first step size guess.
The list of X values must be monotone -- strictly increasing
or strictly decreasing; the Runge-Kutta step sizes are selected
adaptively until the next X value would be passed, when the
step size is adjusted to complete the step exactly.
The external variable rk_maxits (default 10000) is the
maximum number of steps rk_integrate will take.
If a function rk_yscale(y,dydx,x,dx) exists, it is used
to compute an appropriate yscale to give the EPSILON error
criterion meaning.  Otherwise, yscale is taken to be:
abs(y)+abs(dydx*dx)+1.e-30
Based on odeint from Numerical Recipes (Press, et.al.).
If the function you are trying to integrate is very
smooth, and your X values are fairly far apart, bs_integrate
may work better than rk_integrate.
Interpreted function, defined at i/rkutta.i   line 14

```
SEE ALSO: rkutta,   bs_integrate,   rk_maxits,   rk_minstep,   rk_maxstep,   rk_ngood,

rk_maxits
```
rk_maxits

Keyword,  defined at i/rkutta.i   line 142

```
SEE rk_nstore

rk_maxstep
```
rk_maxstep

Keyword,  defined at i/rkutta.i   line 142

```
SEE rk_nstore

rk_minstep
```
rk_minstep

Keyword,  defined at i/rkutta.i   line 142

```
SEE rk_nstore

```

Keyword,  defined at i/rkutta.i   line 142

```
SEE rk_nstore

rk_ngood
```
rk_ngood

Keyword,  defined at i/rkutta.i   line 142

```
SEE rk_nstore

rk_nstore
```
rk_nstore, rk_maxits, rk_minstep, rk_maxstep,

rk_nstore      maximum number of y values rkutta (bstoer) will store
after rkutta (bstoer) call, rk_y and rk_x contain stored values
The other variables are inputs or outputs for rkutta, bstoer,
rk_integrate, or bs_integrate:
rk_maxits      maximum number of steps (default 10000)
rk_minstep     minimum step size (default 0.0)
rk_maxstep     maximum step size (default 1.e35)
rk_ngood       number of good steps taken
rk_nbad        number of failed (but repaired) steps taken
Keyword,  defined at i/rkutta.i   line 142

```

rk_store
```
rk_store

Interpreted function, defined at i/rkutta.i   line 163

```

rkdumb
```
y_of_x= rkdumb(derivative, y0,x0, x1,nsteps)

integrates dydx= DERIVATIVE(y,x) beginning at (X0,Y0) and
going to X1 in NSTEPS 4th order Runge-Kutta steps.  The
result is dimsof(Y0)-by-(NSTEPS+1) values of y at the points
span(X0, X1, NSTEPS+1).
If the nosave= keyword is non-zero, the returned value will
simply be the final y value.
Interpreted function, defined at i/rkutta.i   line 184

```

rkqc
```
rkqc

Interpreted function, defined at i/rkutta.i   line 205

```

rkutta
```
y1= rkutta(derivative, y0,x0, x1,epsilon, dx0)

integrates dydx= DERIVATIVE(y,x) beginning at (X0,Y0) and
going to X1 with fractional error EPSILON.  The result is
the value of y at X1.  DX0 will be used as the initial guess
for a step size.
If the external variable rk_nstore is >0, rk_y and rk_x
will contain up to rk_nstore intermediate values after the
call to rkutta.  Consider using rk_integrate if you need
this feature; using rk_nstore gives you the results at
intermediate values which will tend to be closer where
the Runge-Kutta step size was smaller, while rk_integrate
forces you to specify precisely which x values you want.
The external variable rk_maxits (default 10000) is the
maximum number of steps rkutta will take.  The variable
rk_minstep (default 0.0) is the minimum step size.  The
variable rk_maxstep (default 1.e35) is the maximum step
size, which you may need if you are storing intermediate
values (particularly with bstoer).
If a function rk_yscale(y,dydx,x,dx) exists, it is used
to compute an appropriate yscale to give the EPSILON error
criterion meaning.  Otherwise, yscale is taken to be:
abs(y)+abs(dydx*dx)+1.e-30
Based on odeint from Numerical Recipes (Press, et.al.).
If the function you are trying to integrate is very
smooth, bstoer will probably work better than rkutta.
Interpreted function, defined at i/rkutta.i   line 52

```
SEE ALSO: rk_integrate,   bstoer,   rk_nstore,   rk_maxits,   rk_minstep,   rk_maxstep,
rk_ngood,   rk_nbad,   rkdumb,   rk4

rzextr
```
rzextr

Interpreted function, defined at i/rkutta.i   line 338

```