Next: Package descriptive, Previous: Package combinatorics [Contents][Index]
Next: Functions and Variables for contrib_ode, Previous: Package contrib_ode, Up: Package contrib_ode [Contents][Index]
Maxima’s ordinary differential equation (ODE) solver ode2 solves
elementary linear ODEs of first and second order. The function
contrib_ode extends ode2 with additional methods for linear
and non-linear first order ODEs and linear homogeneous second order ODEs.
The code is still under development and the calling sequence may change
in future releases. Once the code has stabilized it may be
moved from the contrib directory and integrated into Maxima.
This package must be loaded with the command load("contrib_ode")
before use.
The calling convention for contrib_ode is identical to ode2.
It takes
three arguments: an ODE (only the left hand side need be given if the
right hand side is 0), the dependent variable, and the independent
variable. When successful, it returns a list of solutions.
The form of the solution differs from ode2.
As non-linear equations can have multiple solutions,
contrib_ode returns a list of solutions. Each solution can
have a number of forms:
%t, or
%u.
contrib_ode uses the global variables %c,
%k1, %k2, method and yp
similarly to ode2.
If contrib_ode
cannot obtain a solution for whatever reason, it returns false, after
perhaps printing out an error message.
It is necessary to return a list of solutions, as even first order non-linear ODEs can have multiple solutions. For example:
(%i1) load("contrib_ode")$
(%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;
dy 2 dy
(%o2) x (--) - (1 + x y) -- + y = 0
dx dx
(%i3) contrib_ode(eqn,y,x);
dy 2 dy
(%t3) x (--) - (1 + x y) -- + y = 0
dx dx
first order equation not linear in y'
x
(%o3) [y = log(x) + %c, y = %c %e ]
(%i4) method; (%o4) factor
Nonlinear ODEs can have singular solutions without constants of integration, as in the second solution of the following example:
(%i1) load("contrib_ode")$
(%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;
dy 2 dy
(%o2) (--) + x -- - y = 0
dx dx
(%i3) contrib_ode(eqn,y,x);
dy 2 dy
(%t3) (--) + x -- - y = 0
dx dx
first order equation not linear in y'
2
2 x
(%o3) [y = %c x + %c , y = - --]
4
(%i4) method; (%o4) clairaut
The following ODE has two parametric solutions in terms of the dummy
variable %t. In this case the parametric solutions can be manipulated
to give explicit solutions.
(%i1) load("contrib_ode")$
(%i2) eqn:'diff(y,x)=(x+y)^2;
dy 2
(%o2) -- = (x + y)
dx
(%i3) contrib_ode(eqn,y,x);
(%o3) [[x = %c - atan(sqrt(%t)), y = (- x) - sqrt(%t)],
[x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]]
(%i4) method; (%o4) lagrange
The following example (Kamke 1.112) demonstrates an implicit solution.
(%i1) load("contrib_ode")$
(%i2) assume(x>0,y>0); (%o2) [x > 0, y > 0]
(%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;
dy 2 2
(%o3) x -- - x sqrt(y + x ) - y
dx
(%i4) contrib_ode(eqn,y,x);
y
(%o4) [x - asinh(-) = %c]
x
(%i5) method; (%o5) lie
The following Riccati equation is transformed into a linear
second order ODE in the variable %u. Maxima is unable to
solve the new ODE, so it is returned unevaluated.
(%i1) load("contrib_ode")$
(%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;
2 dy 2 2 n
(%o2) x -- = c x y + b x + a
dx
(%i3) contrib_ode(eqn,y,x);
d%u
--- 2
dx 2 a n - 2 d %u
(%o3) [[y = - ----, %u c (-- + b x ) + ---- c = 0]]
%u c 2 2
x dx
(%i4) method; (%o4) riccati
For first order ODEs contrib_ode calls ode2. It then tries the
following methods: factorization, Clairaut, Lagrange, Riccati,
Abel and Lie symmetry methods. The Lie method is not attempted
on Abel equations if the Abel method fails, but it is tried
if the Riccati method returns an unsolved second order ODE.
For second order ODEs contrib_ode calls ode2 then odelin.
Extensive debugging traces and messages are displayed if the command
put('contrib_ode,true,'verbose) is executed.
Next: Possible improvements to contrib_ode, Previous: Introduction to contrib_ode, Up: Package contrib_ode [Contents][Index]
Returns a list of solutions of the ODE eqn with independent variable x and dependent variable y.
odelin solves linear homogeneous ODEs of first and
second order with
independent variable x and dependent variable y.
It returns a fundamental solution set of the ODE.
For second order ODEs, odelin uses a method, due to Bronstein
and Lafaille, that searches for solutions in terms of given
special functions.
(%i1) load("contrib_ode")$
(%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
gauss_a(- 6, - 2, - 3, - x) gauss_b(- 6, - 2, - 3, - x)
(%o2) {---------------------------, ---------------------------}
4 4
x x
Returns the value of ODE eqn after substituting a possible solution soln. The value is equivalent to zero if soln is a solution of eqn.
(%i1) load("contrib_ode")$
(%i2) eqn:'diff(y,x,2)+(a*x+b)*y;
2
d y
(%o2) --- + (b + a x) y
2
dx
(%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
+bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];
3/2
1 2 (b + a x)
(%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b)
3 3 a
3/2
1 2 (b + a x)
+ bessel_j(-, --------------) %k1 sqrt(a x + b)]
3 3 a
(%i4) ode_check(eqn,ans[1]); (%o4) 0
gauss_a(a,b,c,x) and gauss_b(a,b,c,x) are 2F1
hypergeometric functions. They represent any two independent
solutions of the hypergeometric differential equation
x*(1-x) diff(y,x,2) + [c-(a+b+1)x] diff(y,x) - a*b*y = 0 (A&S 15.5.1).
The only use of these functions is in solutions of ODEs returned by
odelin and contrib_ode. The definition and use of these
functions may change in future releases of Maxima.
See also gauss_b, dgauss_a and gauss_b.
See gauss_a.
The derivative with respect to x
of gauss_a(a, b, c, x).
The derivative with respect to x
of gauss_b(a, b, c, x).
Kummer’s M function, as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 13.1.2.
The only use of this function is in solutions of ODEs returned by
odelin and contrib_ode. The definition and use of this
function may change in future releases of Maxima.
See also kummer_u, dkummer_m, and dkummer_u.
Kummer’s U function, as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 13.1.3.
See kummer_m.
The derivative with respect to x
of kummer_m(a, b, x).
The derivative with respect to x
of kummer_u(a, b, x).
Simplifies expressions containing Bessel functions bessel_j,
bessel_y, bessel_i, bessel_k,
hankel_1, hankel_2, struve_h
and struve_l.
Recurrence relations (DLMF ยง10.6(i))(A&S 9.1.27)
are used to replace functions of highest order n
by functions of order n-1 and n-2.
This process is repeated until all the orders differ by less than 2.
(%i1) load("contrib_ode")$
(%i2) bessel_simplify(4*bessel_j(n,x^2)*(x^2-n^2/x^2) +x*((bessel_j(n-2,x^2)-bessel_j(n,x^2))*x -(bessel_j(n,x^2)-bessel_j(n+2,x^2))*x) -2*bessel_j(n+1,x^2)+2*bessel_j(n-1,x^2)); (%o2) 0
(%i3) bessel_simplify( -2*bessel_j(1,z)*z^3 - 10*bessel_j(2,z)*z^2 + 15*%pi*bessel_j(1,z)*struve_h(3,z)*z - 15*%pi*struve_h(1,z) *bessel_j(3,z)*z - 15*%pi*bessel_j(0,z)*struve_h(2,z)*z + 15*%pi*struve_h(0,z)*bessel_j(2,z)*z - 30*%pi*bessel_j(1,z) *struve_h(2,z) + 30*%pi*struve_h(1,z)*bessel_j(2,z)); (%o3) 0
Simplify expressions containing exponential integral expintegral_e
using the recurrence (A&S 5.1.14).
expintegral_e(n+1,z) = (1/n) * (exp(-z)-z*expintegral_e(n,z)) n = 1,2,3 ....
Next: Test cases for contrib_ode, Previous: Functions and Variables for contrib_ode, Up: Package contrib_ode [Contents][Index]
These routines are work in progress. I still need to:
ode1_factor to work for multiple roots.
ode1_factor to attempt to solve higher
order factors. At present it only attempts to solve linear factors.
ode1_lagrange to prefer real roots over
complex roots.
ode1_lie. There are quite a
few problems with it: some parts are unimplemented; some test cases
seem to run forever; other test cases crash; yet others return very
complex "solutions". I wonder if it really ready for release yet.
Next: References for contrib_ode, Previous: Possible improvements to contrib_ode, Up: Package contrib_ode [Contents][Index]
The routines have been tested on a approximately one thousand test cases from Murphy, Kamke, Zwillinger and elsewhere. These are included in the tests subdirectory.
ode1_clairaut finds all known solutions,
including singular solutions, of the Clairaut equations in Murphy and
Kamke.
ode1_lie are overly complex and
impossible to check.
Previous: Test cases for contrib_ode, Up: Package contrib_ode [Contents][Index]
Next: Package descriptive, Previous: Package combinatorics [Contents][Index]