Introduction to contrib_ode
===========================

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:

  * an explicit solution for the dependent variable,

  * an implicit solution for the dependent variable,

  * a parametric solution in terms of variable %t, or

  * a transformation into another ODE in variable %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.

Categories: Differential equations Share packages Package contrib_ode

Functions and Variables for contrib_ode
=======================================

 -- Function: contrib_ode (EQN, Y, X)

     Returns a list of solutions of the ODE EQN with independent variable X and dependent variable Y.

     Categories: Package contrib_ode

 -- Function: odelin (EQN, Y, X)

     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

 -- Function: ode_check (EQN, SOLN)

     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

 -- Function: gauss_a (A, B, C, X)

     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

     Categories: Package contrib_ode

 -- Function: gauss_b (A, B, C, X)
     See gauss_a

     Categories: Package contrib_ode

 -- Function: dgauss_a (A, B, C, X)
     The derivative with respect to X of gauss_a(A, B, C, X).

     Categories: Package contrib_ode

 -- Function: dgauss_b (A, B, C, X)
     The derivative with respect to X of gauss_b(A, B, C, X).

     Categories: Package contrib_ode

 -- Function: kummer_m (A, B, 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

     Categories: Package contrib_ode

 -- Function: kummer_u (A, B, X)

     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

 -- Function: dkummer_m (A, B, X)
     The derivative with respect to X of kummer_m(A, B, X).

     Categories: Package contrib_ode

 -- Function: dkummer_u (A, B, X)
     The derivative with respect to X of kummer_u(A, B, X).

     Categories: Package contrib_ode

 -- Function: bessel_simplify (EXPR)
     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

     Categories: Package contrib_ode Bessel functions Special functions

 -- Function: expintegral_e_simplify (EXPR)
     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 ....

     Categories: Package contrib_ode Exponential Integrals Special functions

Possible improvements to contrib_ode
====================================

These routines are work in progress.  I still need to:

  * Extend the FACTOR method ode1_factor to work for multiple roots.

  * Extend the FACTOR method ode1_factor to attempt to solve higher order factors.  At present it only attempts to solve linear factors.

  * Fix the LAGRANGE routine ode1_lagrange to prefer real roots over complex roots.

  * Add additional methods for Riccati equations.

  * Improve the detection of Abel equations of second kind.  The existing pattern matching is weak.

  * Work on the Lie symmetry group routine 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.

  * Add more test cases.

Test cases for contrib_ode
==========================

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.

  * The Clairaut routine ode1_clairaut finds all known solutions, including singular solutions, of the Clairaut equations in Murphy and Kamke.

  * The other routines often return a single solution when multiple solutions exist.

  * Some of the "solutions" from ode1_lie are overly complex and impossible to check.

  * There are some crashes.

References for contrib_ode
==========================

 1. E. Kamke, Differentialgleichungen Lösungsmethoden und Lösungen, Vol 1, Geest & Portig, Leipzig, 1961

 2. G. M. Murphy, Ordinary Differential Equations and Their Solutions, Van Nostrand, New York, 1960

 3. D. Zwillinger, Handbook of Differential Equations, 3rd edition, Academic Press, 1998

 4. F. Schwarz, Symmetry Analysis of Abel's Equation, Studies in Applied Mathematics, 100:269-294 (1998)

 5. F. Schwarz, Algorithmic Solution of Abel's Equation, Computing 61, 39-49 (1998)

 6. E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order ODE Patterns, Computer Physics Communications 113 (1998), p 239. (http://lie.uwaterloo.ca/papers/ode_vii.pdf)

 7. E. S. Cheb-Terrab, T. Kolokolnikov,  First Order ODEs, Symmetries and Linear Transformations, European Journal of Applied Mathematics, Vol. 14, No. 2, pp. 231-246 (2003). (http://arxiv.org/abs/math-ph/0007023,

     http://lie.uwaterloo.ca/papers/ode_iv.pdf)

 8. G. W. Bluman, S. C. Anco, Symmetry and Integration Methods for Differential Equations, Springer, (2002)

 9. M. Bronstein, S. Lafaille, Solutions of linear ordinary differential equations in terms of special functions, Proceedings of ISSAC 2002, Lille, ACM Press, 23-28. (http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf)