dsolve/numeric/taylorseries  numerical solution of ordinary differential equations

Calling Sequence


dsolve(, numeric, method=taylorseries)
dsolve(, numeric, method=taylorseries[choice], vars, options)


Parameters


odesys



set or list; ordinary differential equation(s) and initial conditions

numeric



literal name; instruct dsolve to find a numerical solution

method=taylorseries



literal equation; numerical method to use

choice



submethod to use

vars



(optional) dependent variable or a set or list of dependent variables for odesys

options



(optional) equations of the form keyword = value





Description


•

The dsolve command with options numeric and method=taylorseries finds a numerical solution to the differential equations, using a Taylor series method. This method can be used for high accuracy solutions.


Note: This method usually takes more time than other methods for low accuracy results. Therefore, it is better to use this method only when a high accuracy solution is desired.

•

There are two choices for the submethod. The lazyseries choice specifies that dsolve should construct a routine to generate the taylor series coefficients using lazy series expansion prior to any integration. This is the default, and generally the most efficient method. The series choice specifies that at each integration step dsolve,series be called to compute a local series expansion.

•

The following options are available for the taylorseries method:

'output'

=

keyword or array

'known'

=

name or list of names

'startinit'

=

boolean

'abserr'

=

numeric

'minstep'

=

numeric

'order'

=

integer

'range'

=

l..r

'storage'

=

boolean

'steppast'

=

boolean




Specifies the desired output from dsolve .


Specifies userdefined known functions. Basic usage is discussed in dsolve[numeric]. As mentioned there, in addition to the requirement of a procedural definition for the function that evaluates with numeric arguments, this method also requires `diff/` rules.


This `diff/` rule must provide the total derivative of the function with respect to the independent variable. Note: The key word here is total, and an example can be found below. This is in contrast to the rosenbrock method, for which the diff rule must provide partial derivatives.


An arbitrary number of total derivatives are required, which means that if the derivative of a known function is provided in terms of another userdefined function, then that function must also have a `diff/` rule for computation of the total derivative with respect to independent variable. If again, this new userdefined function provides the total derivative in terms of another userdefined function, then it must also have a `diff/` rule for computation of the total derivative with respect to independent variable, ad nauseum.


The final requirement is that the 'known' option can only be used for the default taylorseries choice, namely lazyseries.


Indicates whether successive computations should use continuation from a previously computed result, or start from the initial condition for every requested solution value.


Note: The continuation is so that the direction of integration is never reversed, relative to the initial condition.


A positive floatingpoint number that controls the absolute error for any individual step. The default value is Float(1,Digits).


A floatingpoint number that gives the minimum step size be used. The default value is .


Specifies the order of taylor series expansion used in the integration. The default value is given by max(22,trunc(3*Digits/2)).


Specifies a range over which the solution is precomputed and stored. With this option, all returned solution values are computed from one of the stored taylor series expansions  one stored for each step of the method. Use of this option has the effect of turning storage on.


Causes the method to store the solution for all computed steps, and use the taylor polynomial over any regions where a solution has previously been computed and stored. By default this is false.


Causes the method to use the natural step size (that is, the step size proscribed by the error control) when integrating the solution, even if that natural step size would place the independent variable value (internally) past the requested point. The solution is then computed from the taylor polynomial spanning the region containing the requested point. This is more efficient for dense output, and continuation of the solution past the requested point. By default this is true.

•

Results can be plotted using the odeplot function in the plots package.



Examples


'listprocedure' output
>


>


 (1) 
>


>


>


 (2) 
>


 (3) 
>


 (4) 
'array' output
>


 (5) 
'procedurelist' output (the default)
>


 (6) 
>


 (7) 
>


>


 (8) 
>


>


 (9) 
>


 (10) 
>


>


 (11) 
Using storage via 'range'
>


>


 (12) 
>


 (13) 
Can now randomly access values in the specified range (for example, using fsolve) without cost of reintegrating:
>


 (14) 
>


 (15) 
>


 (16) 
>


 (17) 
>


 (18) 
Example of dense output with/without 'steppast'
>


 (19) 
>


>


>


 (20) 
>


 (21) 
>


>


>


 (22) 
Comparison of 'lazyseries' and 'series' options:
>


 (23) 
>


 (24) 
>


>


 (25) 
>


 (26) 
>


 (27) 
>


>


 (28) 
>


 (29) 
Use of the 'known' option for multiple argument functions (requires diff rule). Given the function
>


 (30) 
define 'f' as
>

f := proc(x,y) local t;
if not type(evalf(x),'numeric') or
not type(evalf(y),'numeric') then
'procname'(x,y);
else
evalf(Int(exp(t*2/100)/10,t=0..x))y;
end if;
end proc;

 (31) 
Also, use a `diff/` rule for the total derivative with respect to x. Note that the diff rule provides the total derivative in terms of Maple known functions, and the original f(x,y), for which a `diff/` rule is already defined.
>

`diff/f` := proc(x,y);
if args[3]=x then
diff(x,args[3])*exp(x*2/100)/10f(x,y);
elif args[3]=y then
error "should not happen";
else
error "unable to differentiate";
end if;
end proc;

 (32) 
Using this information you can now call dsolve to obtain a solution procedure, then obtain solution values.
>


 (33) 
>


 (34) 


See Also


dsolve[ck45], dsolve[classical], dsolve[dverk78], dsolve[gear], dsolve[lsode], dsolve[numeric,IVP], dsolve[numeric], dsolve[rkf45], dsolve[rosenbrock], plots[odeplot]


References



Barton, D.; Willers, I.M.; and Zahar, R.V.M. Mathematical Software, pp. 369389. Edited by J.R. Rice. New York: Academic Press, 1972 .


