dsolve/numeric/taylorseries
numerical solution of ordinary differential equations
Calling Sequence
Parameters
Description
Examples
References
dsolve(odesys, numeric, method=taylorseries)
dsolve(odesys, numeric, method=taylorseries[choice], vars, options)
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
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'
'minstep'
'order'
integer
'range'
l..r
'storage'
'steppast'
Specifies the desired output from dsolve .
Specifies user-defined 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 user-defined 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 user-defined function provides the total derivative in terms of another user-defined 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 floating-point number that controls the absolute error for any individual step. The default value is Float(1,-Digits).
A floating-point number that gives the minimum step size be used. The default value is 0.00001.
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.
'listprocedure' output
Digits≔20:
dsys1≔diff⁡x⁡t,t=y⁡t,diff⁡y⁡t,t=x⁡t+y⁡t,x⁡0=2,y⁡0=1
dsys1≔ⅆⅆtx⁡t=y⁡t,ⅆⅆty⁡t=x⁡t+y⁡t,x⁡0=2,y⁡0=1
dsol1≔dsolve⁡dsys1,numeric,method=taylorseries,output=listprocedure,abserr=Float⁡1,−20:
dsol1x≔eval⁡x⁡t,dsol1:dsol1y≔eval⁡y⁡t,dsol1:
dsol1x⁡0,dsol1y⁡0
2.,1.
dsol1x⁡0.4,dsol1y⁡0.4
2.6911846499155574031,2.6081175867723888825
dsol1x⁡1.0,dsol1y⁡1.0
5.5821687260840732723,7.8268911966878259776
'array' output
dsola1≔dsolve⁡dsys1,numeric,method=taylorseries,output=Array⁡0,0.2,0.4,0.6,0.8,1,abserr=Float⁡1,−20
dsola1≔tx⁡ty⁡t0.2.1.0.22.26583101007906083231.69011736881425090500.42.69118464991555740312.60811758677238888250.63.33027738839202266843.84523969015730942530.84.25882542465858062305.52710131705538946431.5.58216872608407327237.8268911966878259776
'procedurelist' output (the default)
dsys2≔D2⁡x⁡t=−y⁡t,D2⁡y⁡t=D⁡x⁡t+y⁡t
init2≔x⁡0=1,y⁡0=0,D⁡x⁡0=0,D⁡y⁡0=1
dsol2≔dsolve⁡dsys2unioninit2,numeric,method=taylorseries,output=Array⁡0,0.6,1.1,1.5,2.3,2.5,abserr=Float⁡1,−20:
dsol21,11=dsol22,16,1,dsol21,15=dsol22,16,5
t=2.5,ⅆⅆty⁡t=1.9487171722808526958
Digits≔30:
deqn3≔diff⁡y⁡t,`$`⁡t,3−2⁢diff⁡y⁡t,`$`⁡t,2+2⁢y⁡t
deqn3≔ⅆ3ⅆt3y⁡t−2⁢ⅆ2ⅆt2y⁡t+2⁢y⁡t
init3≔y⁡0=1,D⁡y⁡0=1,D2⁡y⁡0=1
dsol3≔dsolve⁡deqn3unioninit3,numeric,method=taylorseries,abserr=Float⁡1,−30:
dsol3⁡0.5
t=0.5,y⁡t=1.61793485679327790141188491578,ⅆⅆty⁡t=1.43910267665026980485200277955,ⅆ2ⅆt2y⁡t=0.587882166803234441848359099341
Using storage via 'range'
dsys4≔diff⁡y⁡t,t,t+y⁡t,y⁡0=0,D⁡y⁡0=1
dsys4≔ⅆ2ⅆt2y⁡t+y⁡t,y⁡0=0,D⁡y⁡0=1
dsol4≔dsolve⁡dsys4,numeric,method=taylorseries,abserr=Float⁡1,−20,range=0..10⁢π
dsol4 ≔ procx_taylorseries...end proc
Can now randomly access values in the specified range (for example, using fsolve) without cost of re-integrating:
fsolve⁡t↦rhs⁡dsol4⁡t2,3..4
3.1415926535897932385
−evalf⁡π
0.
fsolve⁡t↦rhs⁡dsol4⁡t2,6..7
6.2831853071795864769
fsolve⁡t↦rhs⁡dsol4⁡t2,9..10
9.4247779607693797154
fsolve⁡t↦rhs⁡dsol4⁡t2,26..30
28.274333882308139146
Example of dense output with/without 'steppast'
dsol5a≔dsolve⁡dsys4,numeric,method=taylorseries,abserr=Float⁡1,−20
dsol5a ≔ procx_taylorseries...end proc
tt≔time⁡:
forito100dodsol5a⁡π⁢i100enddo:
time⁡−tt
0.020
dsol5b≔dsolve⁡dsys4,numeric,method=taylorseries,abserr=Float⁡1,−20,steppast=false
dsol5b ≔ procx_taylorseries...end proc
forito100dodsol5b⁡π⁢i100enddo:
0.069
Comparison of 'lazyseries' and 'series' options:
dsys6≔t+12⁢diff⁡y⁡t,t,t+t+1⁢diff⁡y⁡t,t+t+12−0.25⁢y⁡t=0,y⁡0=0.6713967071418030,D⁡y⁡0=0.09540051444747446
dsys6≔t+12⁢ⅆ2ⅆt2y⁡t+t+1⁢ⅆⅆty⁡t+t+12−0.25⁢y⁡t=0,y⁡0=0.6713967071418030,D⁡y⁡0=0.09540051444747446
ds1≔dsolve⁡dsys6,numeric,method=taylorseriesseries,abserr=Float⁡1,−20
ds1 ≔ procx_taylorseries...end proc
ds1⁡3.0
t=3.0,y⁡t=−0.30192051329163941472,ⅆⅆty⁡t=−0.22302601251572382302
0.307
ds1≔dsolve⁡dsys6,numeric,method=taylorserieslazyseries,abserr=Float⁡1,−20
0.014
Use of the 'known' option for multiple argument functions (requires diff rule). Given the function
f⁡x,y⁡x=Int⁡exp⁡−t⋅210010,t=0..x−y⁡x
f⁡x,y⁡x=∫0xⅇ−t5010ⅆt−y⁡x
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;
f ≔ procx,ylocalt;ifnottype⁡evalf⁡x,'numeric'andtype⁡evalf⁡y,'numeric'then'procname'⁡x,yelseevalf⁡Int⁡1/10*exp⁡−1/50*t,t=0..x − yend ifend proc
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)/10-f(x,y); elif args[3]=y then error "should not happen"; else error "unable to differentiate"; end if; end proc;
diff/f ≔ procx,yifargs[3]=xthen1/10*diff⁡x,args[3]*exp⁡−1/50*x − f⁡x,yelifargs[3]=ythenerrorshould not happenelseerrorunable to differentiateend ifend proc
Using this information you can now call dsolve to obtain a solution procedure, then obtain solution values.
dsol≔dsolve⁡diff⁡y⁡x,x=f⁡x,y⁡x,y⁡0=0,numeric,known=f,method=taylorseries
dsol ≔ procx_taylorseries...end proc
dsol⁡10
x=10.,y⁡x=0.82280691286027374071
Barton, D.; Willers, I.M.; and Zahar, R.V.M. Mathematical Software, pp. 369-389. Edited by J.R. Rice. New York: Academic Press, 1972 .
See Also
dsolve[ck45]
dsolve[classical]
dsolve[dverk78]
dsolve[gear]
dsolve[lsode]
dsolve[numeric,IVP]
dsolve[numeric]
dsolve[rkf45]
dsolve[rosenbrock]
plots[odeplot]
Download Help Document