Next: descriptive-pkg, Previous: combinatorics-pkg, Up: Top [Contents][Index]
| • Introduction to contrib_ode: | ||
| • Functions and Variables for contrib_ode: | ||
| • Possible improvements to contrib_ode: | ||
| • Test cases for contrib_ode: | ||
| • References for contrib_ode: |
Next: Functions and Variables for contrib_ode, Previous: contrib_ode-pkg, Up: contrib_ode-pkg [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.
%c is used to represent the constant of integration for first order equations.
%k1 and %k2 are the constants for second order equations.
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) clairault
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, Clairault, 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.
Categories: Differential equations Share packages Package contrib_ode
Next: Possible improvements to contrib_ode, Previous: Introduction to contrib_ode, Up: contrib_ode-pkg [Contents][Index]
Returns a list of solutions of the ODE eqn with independent variable x and dependent variable y.
Categories: Package contrib_ode
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
Categories: Package contrib_ode
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
Categories: Package contrib_ode
The variable method is set to the successful solution
method.
Categories: Package contrib_ode
%c is the integration constant for first order ODEs.
Categories: Package contrib_ode
%k1 is the first integration constant for second order ODEs.
Categories: Package contrib_ode
%k2 is the second integration constant for second order ODEs.
Categories: Package contrib_ode
gauss_a(a,b,c,x) and gauss_b(a,b,c,x) are 2F1
geometric 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) - aby = 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.
Categories: Package contrib_ode
See gauss_a.
Categories: Package contrib_ode
The derivative with respect to x of gauss_a(a, b, c, x).
Categories: Package contrib_ode
The derivative with respect to x of gauss_b(a, b, c, x).
Categories: Package contrib_ode
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.
Categories: Package contrib_ode
Kummer’s U function, as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 13.1.3.
See kummer_m.
Categories: Package contrib_ode
The derivative with respect to x of kummer_m(a, b, x).
Categories: Package contrib_ode
The derivative with respect to x of kummer_u(a, b, x).
Categories: Package contrib_ode
Simplifies expressions containing Bessel functions bessel_j, bessel_y, bessel_i, bessel_k, hankel_1, hankel_2, strauve_h and strauve_l. Recurrence relations (given in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 9.1.27) are used to replace functions of highest order n by functions of order n-1 and n-2.
This process 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
Categories: Package contrib_ode Bessel functions Special functions
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: contrib_ode-pkg [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 attemps 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: contrib_ode-pkg [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_clairault finds all known solutions,
including singular solutions, of the Clairault equations in Murphy and
Kamke.
ode1_lie are overly complex and
impossible to check.
Previous: Test cases for contrib_ode, Up: contrib_ode-pkg [Contents][Index]
Previous: Test cases for contrib_ode, Up: contrib_ode-pkg [Contents][Index]