This is the command ode that can be run in the OnWorks free hosting provider using one of our multiple free online workstations such as Ubuntu Online, Fedora Online, Windows online emulator or MAC OS online emulator

**PROGRAM:**

**NAME**

ode - numerical solution of ordinary differential equations

**SYNOPSIS**

**ode**[

__options__] [

__file__]

**DESCRIPTION**

**ode**is a tool that solves, by numerical integration, the initial value problem for a

specified system of first-order ordinary differential equations. Three distinct numerical

integration schemes are available: Runge-Kutta-Fehlberg (the default), Adams-Moulton, and

Euler. The Adams-Moulton and Runge-Kutta schemes are available with adaptive step size.

The operation of

**ode**is specified by a program, written in its input language. The

program is simply a list of expressions for the derivatives of the variables to be

integrated, together with some control statements. Some examples are given in the

**EXAMPLES**section.

**ode**reads the program from the specified file, or from standard input if no file name is

given. If reading from standard input,

**ode**will stop reading and exit when it sees a

single period on a line by itself.

At each time step, the values of variables specified in the program are written to

standard output. So a table of values will be produced, with each column showing the

evolution of a variable. If there are only two columns, the output can be piped to

**graph**(1) or a similar plotting program.

**OPTIONS**

**Input**

**Options**

**-f**

__file__

**--input-file**

__file__

Read input from

__file__before reading from standard input. This option makes it

possible to work interactively, after reading a program fragment that defines the

system of differential equations.

**Output**

**Options**

**-p**

__prec__

**--precision**

__prec__

When printing numerical results, use

__prec__significant digits (the default is 6).

If this option is given, the print format will be scientific notation.

**-t**

**--title**

Print a title line at the head of the output, naming the variables in each column.

If this option is given, the print format will be scientific notation.

**Integration**

**Scheme**

**Options**

The following options specify the numerical integration scheme. Only one of the three

basic options

**-R**,

**-A**,

**-E**may be specified. The default is

**-R**(Runge-Kutta-Fehlberg).

**-R**

__[stepsize]__

**--runge-kutta**

__[stepsize]__

Use a fifth-order Runge-Kutta-Fehlberg algorithm, with an adaptive stepsize unless

a constant stepsize is specified. When a constant stepsize is specified and no

error analysis is requested, then a classical fourth-order Runge-Kutta scheme is

used.

**-A**

__[stepsize]__

**--adams-moulton**

__[stepsize]__

Use a fourth-order Adams-Moulton predictor-corrector scheme, with an adaptive

stepsize unless a constant stepsize,

__stepsize__, is specified. The

Runge-Kutta-Fehlberg algorithm is used to get past `bad' points (if any).

**-E**

__[stepsize]__

**--euler**

__[stepsize]__

Use a `quick and dirty' Euler scheme, with a constant stepsize. The default value

of

__stepsize__is 0.1. Not recommended for serious applications.

The error bound options

**-r**and

**-e**(see below) may not be used if

**-E**is specified.

**-h**

__hmin__

__[hmax]__

**--step-size-bound**

__hmin__

__[hmax]__

Use a lower bound

__hmin__on the stepsize. The numerical scheme will not let the

stepsize go below

__hmin__. The default is to allow the stepsize to shrink to the

machine limit, i.e., the minimum nonzero double-precision floating point number.

The optional argument

__hmax__, if included, specifies a maximum value for the

stepsize. It is useful in preventing the numerical routine from skipping quickly

over an interesting region.

**Error**

**Bound**

**Options**

**-r**

__rmax__

__[rmin]__

**--relative-error-bound**

__rmax__

__[rmin]__

The

**-r**option sets an upper bound on the relative single-step error. If the

**-r**

option is used, the relative single-step error in any dependent variable will never

exceed

__rmax__(the default for which is 10^-9). If this should occur, the solution

will be abandoned and an error message will be printed. If the stepsize is not

constant, the stepsize will be decreased `adaptively', so that the upper bound on

the single-step error is not violated. Thus, choosing a smaller upper bound on the

single-step error will cause smaller stepsizes to be chosen. A lower bound

__rmin__

may optionally be specified, to suggest when the stepsize should be increased (the

default for

__rmin__is

__rmax__/1000).

**-e**

__emax__

__[emin]__

**--absolute-error-bound**

__emax__

__[emin]__

Similar to

**-r**, but bounds the absolute rather than the relative single-step error.

**-s**

**--suppress-error-bound**

Suppress the ceiling on single-step error, allowing

**ode**to continue even if this

ceiling is exceeded. This may result in large numerical errors.

**Informational**

**Options**

**--help**Print a list of command-line options, and exit.

**--version**

Print the version number of

**ode**and the plotting utilities package, and exit.

**DIAGNOSTICS**

Mostly self-explanatory. The biggest exception is `syntax error', meaning there is a

grammatical error. Language error messages are of the form

**ode:**

**nnn:**

**message...**

where `nnn' is the number of the input line containing the error. If the

**-f**option is

used, the phrase "(file)" follows the `nnn' for errors encountered inside the file.

Subsequently, when

**ode**begins reading the standard input, line numbers start over from 1.

No effort is made to recover successfully from syntactic errors in the input. However,

there is a meager effort to resynchronize so more than one error can be found in one scan.

Run-time errors elicit a message describing the problem, and the solution is abandoned.

**EXAMPLES**

The program

**y'**

**=**

**y**

**y**

**=**

**1**

**t,**

**y**

**step**

**0,**

**1**

solves an initial value problem whose solution is

__y=e^t__. When

**ode**runs this program, it

will write two columns of numbers to standard output. Each line will show the value of

the independent variable

__t__, and the variable

__y__, as

__t__is stepped from 0 to 1.

A more sophisticated example would be

**sine'**

**=**

**cosine**

**cosine'**

**=**

**-sine**

**sine**

**=**

**0**

**cosine**

**=**

**1**

**t,**

**sine**

**step**

**0,**

**2*PI**

This program solves an initial value problem for a system of two differential equations.

The initial value problem turns out to define the sine and cosine functions. The program

steps the system over a full period.

**AUTHORS**

**ode**was written by Nicholas B. Tufillaro (

**[email protected]**), and slightly enhanced by Robert

S. Maier (

**[email protected]**) to merge it into the GNU plotting utilities.

Use ode online using onworks.net services