Ticket #8616: trac_8616_symbolic_sage.2.patch

sage/calculus/all.py

@@ -8 +8 @@
 
 from functions import (wronskian,jacobian)
 
-from desolvers import (desolve, desolve_laplace, desolve_system,
-                       eulers_method, eulers_method_2x2, 
+from desolvers import (desolve, dsolve, desolve_laplace, dsolve_laplace, desolve_system,
+                       eulers_method, eulers_method_2x2,
                        eulers_method_2x2_plot, desolve_rk4, desolve_system_rk4)
 
 from var import (var, function, clear_vars)
@@ -27 +27 @@
     - a symbolic expression.
 
     EXAMPLES::
-    
+
         sage: a = symbolic_expression(3/2); a
         3/2
         sage: type(a)
@@ -53 +53 @@
         sage: symbolic_expression(E)
         x*y + y^2 + y == x^3 + x^2 - 10*x - 10
         sage: symbolic_expression(E) in SR
-        True 
+        True
     """
     from sage.symbolic.expression import Expression
     from sage.symbolic.ring import SR

sage/calculus/desolvers.py

@@ -32 +32 @@
 - ``eulers_method_2x2_plot`` - Plots the sequence of points obtained
   from Euler's method.
 
-AUTHORS: 
+AUTHORS:
 
 - David Joyner (3-2006) - Initial version of functions
 
@@ -42 +42 @@
 
 - Robert Marik (10-2009) - Some bugfixes and enhancements
 
+- Yuri Karadzhov (2010-03-27) - Autodetection of dependent and independent vars
+
 """
 
 ##########################################################################
@@ -58 +60 @@
 from sage.symbolic.expression import is_SymbolicEquation
 from sage.symbolic.ring import is_SymbolicVariable
 from sage.calculus.functional import diff
+from sage.symbolic.mtype import *
 
 maxima = Maxima()
 
-def desolve(de, dvar, ics=None, ivar=None, show_method=False, contrib_ode=False):
+def desolve(de, dvar=None, ics=None, ivar=None, show_method=False, contrib_ode=False):
     """
     Solves a 1st or 2nd order linear ODE via maxima. Including IVP and BVP.
-    
+
     *Use* ``desolve? <tab>`` *if the output in truncated in notebook.*
 
     INPUT:
-    
+
     - ``de`` - an expression or equation representing the ODE
-    
-    - ``dvar`` - the dependent variable (hereafter called ``y``)
+
+    - ``dvar`` - (optional) the dependent variable (hereafter called ``y``)
 
     - ``ics`` - (optional) the initial or boundary conditions
 
@@ -79 +82 @@
 
       - for a second-order equation, specify the initial ``x``, ``y``,
         and ``dy/dx``
-      
+
       - for a second-order boundary solution, specify initial and
         final ``x`` and ``y`` initial conditions gives error if the
         solution is not SymbolicEquation (as happens for example for
         clairot equation)
-       
+
     - ``ivar`` - (optional) the independent variable (hereafter called
       x), which must be specified if there is more than one
       independent variable in the equation.
-                    
+
     - ``show_method`` - (optional) if true, then Sage returns pair
       ``[solution, method]``, where method is the string describing
       method which has been used to get solution (Maxima uses the
@@ -107 +110 @@
 
 
     OUTPUT:
-    
+
     In most cases returns SymbolicEquation which defines the solution
     implicitly.  If the result is in the form y(x)=... (happens for
     linear eqs.), returns the right-hand side only.  The possible
@@ -118 +121 @@
 
         sage: x = var('x')
         sage: y = function('y', x)
-        sage: desolve(diff(y,x) + y - 1, y)
+        sage: desolve(diff(y,x) + y - 1)
         (c + e^x)*e^(-x)
-    
+
     ::
 
-        sage: f = desolve(diff(y,x) + y - 1, y, ics=[10,2]); f
+        sage: f = desolve(diff(y,x) + y - 1, ics=[10,2]); f
         (e^10 + e^x)*e^(-x)
 
     ::
 
         sage: plot(f)
-        
+
     We can also solve second-order differential equations.::
-    
+
         sage: x = var('x')
         sage: y = function('y', x)
         sage: de = diff(y,x,2) - y == x
-        sage: desolve(de, y)
+        sage: desolve(de)
         k1*e^x + k2*e^(-x) - x
-        
+
 
     ::
 
@@ -150 +153 @@
 
     ::
 
+        sage: f = desolve(de, ics=[10,2,1]); f
+        -x + 5*e^(-x + 10) + 7*e^(x - 10)
+        sage: f(x=10)
+        2
+        sage: diff(f,x)(x=10)
+        1
+
+    ::
+
         sage: de = diff(y,x,2) + y == 0
-        sage: desolve(de, y)
+        sage: desolve(de)
         k1*sin(x) + k2*cos(x)
-        sage: desolve(de, y, [0,1,pi/2,4]) 
+        sage: desolve(de, ics=[0,1,pi/2,4])
         4*sin(x) + cos(x)
-        
-        sage: desolve(y*diff(y,x)+sin(x)==0,y)
+
+        sage: desolve(y*diff(y,x)+sin(x)==0)
         -1/2*y(x)^2 == c - cos(x)
 
     Clairot equation: general and singular solutions::
 
-        sage: desolve(diff(y,x)^2+x*diff(y,x)-y==0,y,contrib_ode=True,show_method=True)
+        sage: desolve(diff(y,x)^2+x*diff(y,x)-y==0,contrib_ode=True,show_method=True)
         [[y(x) == c^2 + c*x, y(x) == -1/4*x^2], 'clairault']
-    
-    For equations involving more variables we specify independent variable::
+
+    For equations involving more variables we shouldn't specify independent variable if they are obvious::
 
         sage: a,b,c,n=var('a b c n')
-        sage: desolve(x^2*diff(y,x)==a+b*x^n+c*x^2*y^2,y,ivar=x,contrib_ode=True)
+        sage: desolve(x^2*diff(y,x)==a+b*x^n+c*x^2*y^2,contrib_ode=True)
         [[y(x) == 0, (b*x^(n - 2) + a/x^2)*c^2*u == 0]]
-        sage: desolve(x^2*diff(y,x)==a+b*x^n+c*x^2*y^2,y,ivar=x,contrib_ode=True,show_method=True)
+        sage: desolve(x^2*diff(y,x)==a+b*x^n+c*x^2*y^2,contrib_ode=True,show_method=True)
         [[[y(x) == 0, (b*x^(n - 2) + a/x^2)*c^2*u == 0]], 'riccati']
 
 
     Higher orded, not involving independent variable::
 
-        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,y).expand()
+        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0).expand()
         1/6*y(x)^3 + k1*y(x) == k2 + x
-        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,y,[0,1,1,3]).expand()
+        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,ics=[0,1,1,3]).expand()
         1/6*y(x)^3 - 5/3*y(x) == x - 3/2
-        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,y,[0,1,1,3],show_method=True)
+        sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,ics=[0,1,1,3],show_method=True)
         [1/6*y(x)^3 - 5/3*y(x) == x - 3/2, 'freeofx']
 
     Separable equations - Sage returns solution in implicit form::
 
-        sage: desolve(diff(y,x)*sin(y) == cos(x),y)
+        sage: desolve(diff(y,x)*sin(y) == cos(x))
         -cos(y(x)) == c + sin(x)
-        sage: desolve(diff(y,x)*sin(y) == cos(x),y,show_method=True)
+        sage: desolve(diff(y,x)*sin(y) == cos(x),show_method=True)
         [-cos(y(x)) == c + sin(x), 'separable']
-        sage: desolve(diff(y,x)*sin(y) == cos(x),y,[pi/2,1])
+        sage: desolve(diff(y,x)*sin(y) == cos(x),ics=[pi/2,1])
         -cos(y(x)) == sin(x) - cos(1) - 1
 
     Linear equation - Sage returns the expression on the right hand side only::
 
-        sage: desolve(diff(y,x)+(y) == cos(x),y)
+        sage: desolve(diff(y,x)+(y) == cos(x))
         1/2*((sin(x) + cos(x))*e^x + 2*c)*e^(-x)
-        sage: desolve(diff(y,x)+(y) == cos(x),y,show_method=True)
+        sage: desolve(diff(y,x)+(y) == cos(x),show_method=True)
         [1/2*((sin(x) + cos(x))*e^x + 2*c)*e^(-x), 'linear']
-        sage: desolve(diff(y,x)+(y) == cos(x),y,[0,1])
+        sage: desolve(diff(y,x)+(y) == cos(x),ics=[0,1])
         1/2*(e^x*sin(x) + e^x*cos(x) + 1)*e^(-x)
 
     This ODE with separated variables is solved as
     exact. Explanation - factor does not split `e^{x-y}` in Maxima
     into `e^{x}e^{y}`::
 
-        sage: desolve(diff(y,x)==exp(x-y),y,show_method=True)
+        sage: desolve(diff(y,x)==exp(x-y),show_method=True)
         [-e^x + e^y(x) == c, 'exact']
 
     You can solve Bessel equations. You can also use initial
@@ -212 +224 @@
     condition at x=0, since this point is singlar point of the
     equation. Anyway, if the solution should be bounded at x=0, then
     k2=0.::
-            
-        sage: desolve(x^2*diff(y,x,x)+x*diff(y,x)+(x^2-4)*y==0,y)
+
+        sage: desolve(x^2*diff(y,x,x)+x*diff(y,x)+(x^2-4)*y==0)
         k1*bessel_j(2, x) + k2*bessel_y(2, x)
-    
+
     Difficult ODE produces error::
 
         sage: desolve(sqrt(y)*diff(y,x)+e^(y)+cos(x)-sin(x+y)==0,y) # not tested
         Traceback (click to the left for traceback)
         ...
         NotImplementedError, "Maxima was unable to solve this ODE. Consider to set option contrib_ode to True."
-        
+
     Difficult ODE produces error - moreover, takes a long time ::
 
         sage: desolve(sqrt(y)*diff(y,x)+e^(y)+cos(x)-sin(x+y)==0,y,contrib_ode=True) # not tested
@@ -233 +245 @@
         [[y(x) == c + log(x), y(x) == c*e^x], 'factor']
 
     ::
-    
+
         sage: desolve(diff(y,x)==(x+y)^2,y,contrib_ode=True,show_method=True)
         [[[x == c - arctan(sqrt(t)), y(x) == -x - sqrt(t)], [x == c + arctan(sqrt(t)), y(x) == -x + sqrt(t)]], 'lagrange']
 
@@ -245 +257 @@
         Traceback (click to the left for traceback)
         ...
         NotImplementedError, "Maxima was unable to solve this ODE. Consider to set option contrib_ode to True."
-        
+
     ::
 
         sage: desolve(diff(y,x,2)+y*(diff(y,x,1))^3==0,y,[0,1,2],show_method=True) # not tested
@@ -267 +279 @@
         3*((e^(1/2*pi) - 2)*x/pi + 1)*e^(-x) + 1/2*sin(x)
         sage: desolve(diff(y,x,2)+2*diff(y,x)+y == cos(x),y,[0,3,pi/2,2],show_method=True)
         [3*((e^(1/2*pi) - 2)*x/pi + 1)*e^(-x) + 1/2*sin(x), 'variationofparameters']
-        
+
         sage: desolve(diff(y,x,2)+2*diff(y,x)+y == 0,y)
         (k2*x + k1)*e^(-x)
         sage: desolve(diff(y,x,2)+2*diff(y,x)+y == 0,y,show_method=True)
@@ -281 +293 @@
         sage: desolve(diff(y,x,2)+2*diff(y,x)+y == 0,y,[0,3,pi/2,2],show_method=True)
         [(2*(2*e^(1/2*pi) - 3)*x/pi + 3)*e^(-x), 'constcoeff']
 
-        
+
     This equation can be solved within Maxima but not within Sage. It
     needs assumptions assume(x>0,y>0) and works in Maxima, but not in Sage::
 
@@ -289 +301 @@
         sage: assume(y>0) # not tested
         sage: desolve(x*diff(y,x)-x*sqrt(y^2+x^2)-y,y,show_method=True) # not tested
 
-        
+
     TESTS:
-    
+
     Trac #6479 fixed::
 
         sage: x = var('x')
@@ -300 +312 @@
         x
 
     ::
-    
+
         sage: desolve( diff(y,x,x) == 0, y, [0,1,1])
         x + 1
 
 
     AUTHORS:
- 
+
     - David Joyner (1-2006)
 
     - Robert Bradshaw (10-2008)
 
     - Robert Marik (10-2009)
 
+    - Yuri Karadzhov (2010-03-27)
+
     """
     if is_SymbolicEquation(de):
         de = de.lhs() - de.rhs()
-    if is_SymbolicVariable(dvar):
-        raise ValueError, "You have to declare dependent variable as a function, eg. y=function('y',x)"
-    # for backwards compatibility
-    if isinstance(dvar, list):
-        dvar, ivar = dvar
-    elif ivar is None:
-        ivars = de.variables()
-        ivars = [t for t in ivars if t is not dvar]
+    diff_list = map(ops,indets(de,'_diff'))
+    if len(diff_list) == 0:
+        raise ValueError, "First argument is not differential equation."
+    if dvar is None:
+        dvars = set([x[0] for x in diff_list])
+        if len(dvars) != 1:
+            raise ValueError, "Unable to determine dependent variable, please specify."
+        dvar=dvars.pop()
+    else:
+        if is_SymbolicVariable(dvar):
+            raise ValueError, "You have to declare dependent variable as a function, eg. y=function('y',x)"
+        # for backwards compatibility
+        if isinstance(dvar, list):
+            dvar, ivar = dvar
+    if ivar is None:
+        ivars = set()
+        for el in diff_list:
+            ivars = ivars.union(el[1:])
         if len(ivars) != 1:
             raise ValueError, "Unable to determine independent variable, please specify."
-        ivar = ivars[0]
+        ivar = ivars.pop()
     def sanitize_var(exprs):
-        return exprs.replace("'"+dvar_str+"("+ivar_str+")",dvar_str)    
+        return exprs.replace("'"+dvar_str+"("+ivar_str+")",dvar_str)
     dvar_str=dvar.operator()._maxima_().str()
     ivar_str=ivar._maxima_().str()
     de00 = de._maxima_().str()
     de0 = sanitize_var(de00)
     ode_solver="ode2"
-    cmd="(TEMP:%s(%s,%s,%s), if TEMP=false then TEMP else substitute(%s=%s(%s),TEMP))"%(ode_solver,de0,dvar_str,ivar_str,dvar_str,dvar_str,ivar_str)    
+    cmd="(TEMP:%s(%s,%s,%s), if TEMP=false then TEMP else substitute(%s=%s(%s),TEMP))"%(ode_solver,de0,dvar_str,ivar_str,dvar_str,dvar_str,ivar_str)
     # we produce string like this
     # ode2('diff(y,x,2)+2*'diff(y,x,1)+y-cos(x),y(x),x)
     soln = maxima(cmd)
@@ -343 +367 @@
         if contrib_ode:
             ode_solver="contrib_ode"
             maxima("load('contrib_ode)")
-            cmd="(TEMP:%s(%s,%s,%s), if TEMP=false then TEMP else substitute(%s=%s(%s),TEMP))"%(ode_solver,de0,dvar_str,ivar_str,dvar_str,dvar_str,ivar_str)    
+            cmd="(TEMP:%s(%s,%s,%s), if TEMP=false then TEMP else substitute(%s=%s(%s),TEMP))"%(ode_solver,de0,dvar_str,ivar_str,dvar_str,dvar_str,ivar_str)
             # we produce string like this
             # (TEMP:contrib_ode(x*('diff(y,x,1))^2-(x*y+1)*'diff(y,x,1)+y,y,x), if TEMP=false then TEMP else substitute(y=y(x),TEMP))
             soln = maxima(cmd)
             if str(soln).strip() == 'false':
-                raise NotImplementedError, "Maxima was unable to solve this ODE."    
+                raise NotImplementedError, "Maxima was unable to solve this ODE."
         else:
             raise NotImplementedError, "Maxima was unable to solve this ODE. Consider to set option contrib_ode to True."
 
@@ -357 +381 @@
 
     if (ics is not None):
         if not is_SymbolicEquation(soln.sage()):
-             raise NotImplementedError, "Maxima was unable to use initial condition for this equation (%s)"%(maxima_method.str())   
+             raise NotImplementedError, "Maxima was unable to use initial condition for this equation (%s)"%(maxima_method.str())
         if len(ics) == 2:
             tempic=(ivar==ics[0])._maxima_().str()
             tempic=tempic+","+(dvar==ics[1])._maxima_().str()
@@ -367 +391 @@
             # (TEMP:ic2(ode2('diff(y,x,2)+2*'diff(y,x,1)+y-cos(x),y,x),x=0,y=3,'diff(y,x)=1),substitute(y=y(x),TEMP))
             soln=maxima(cmd)
         if len(ics) == 3:
-            #fixed ic2 command from Maxima - we have to ensure that %k1, %k2 do not depend on variables, should be removed when fixed in Maxima 
+            #fixed ic2 command from Maxima - we have to ensure that %k1, %k2 do not depend on variables, should be removed when fixed in Maxima
             maxima("ic2_sage(soln,xa,ya,dya):=block([programmode:true,backsubst:true,singsolve:true,temp,%k2,%k1,TEMP_k], \
                 noteqn(xa), noteqn(ya), noteqn(dya), boundtest('%k1,%k1), boundtest('%k2,%k2), \
                 temp: lhs(soln) - rhs(soln), \
@@ -384 +408 @@
             # (TEMP:ic2(ode2('diff(y,x,2)+2*'diff(y,x,1)+y-cos(x),y,x),x=0,y=3,'diff(y,x)=1),substitute(y=y(x),TEMP))
             soln=maxima(cmd)
             if str(soln).strip() == 'false':
-                raise NotImplementedError, "Maxima was unable to solve this IVP. Remove the initial contition to get the general solution."    
+                raise NotImplementedError, "Maxima was unable to solve this IVP. Remove the initial contition to get the general solution."
         if len(ics) == 4:
-            #fixed bc2 command from Maxima - we have to ensure that %k1, %k2 do not depend on variables, should be removed when fixed in Maxima 
+            #fixed bc2 command from Maxima - we have to ensure that %k1, %k2 do not depend on variables, should be removed when fixed in Maxima
             maxima("bc2_sage(soln,xa,ya,xb,yb):=block([programmode:true,backsubst:true,singsolve:true,temp,%k1,%k2,TEMP_k], \
                 noteqn(xa), noteqn(ya), noteqn(xb), noteqn(yb), boundtest('%k1,%k1), boundtest('%k2,%k2), \
                 TEMP_k:solve([subst([xa,ya],soln), subst([xb,yb],soln)], [%k1,%k2]), \
@@ -394 +418 @@
                 temp: maplist(lambda([zz], subst(zz,soln)),TEMP_k), \
                 if length(temp)=1 then return(first(temp)) else return(temp))")
             cmd="bc2_sage(%s(%s,%s,%s),%s,%s=%s,%s,%s=%s)"%(ode_solver,de00,dvar_str,ivar_str,(ivar==ics[0])._maxima_().str(),dvar_str,(ics[1])._maxima_().str(),(ivar==ics[2])._maxima_().str(),dvar_str,(ics[3])._maxima_().str())
-            cmd="(TEMP:%s,substitute(%s=%s(%s),TEMP))"%(cmd,dvar_str,dvar_str,ivar_str)            
+            cmd="(TEMP:%s,substitute(%s=%s(%s),TEMP))"%(cmd,dvar_str,dvar_str,ivar_str)
             cmd=sanitize_var(cmd)
             # we produce string like this
             # (TEMP:bc2(ode2('diff(y,x,2)+2*'diff(y,x,1)+y-cos(x),y,x),x=0,y=3,x=%pi/2,y=2),substitute(y=y(x),TEMP))
             soln=maxima(cmd)
             if str(soln).strip() == 'false':
-                raise NotImplementedError, "Maxima was unable to solve this BVP. Remove the initial contition to get the general solution."    
+                raise NotImplementedError, "Maxima was unable to solve this BVP. Remove the initial contition to get the general solution."
 
     soln=soln.sage()
     if is_SymbolicEquation(soln) and soln.lhs() == dvar:
@@ -409 +433 @@
         soln = soln.rhs()
     if show_method:
         return [soln,maxima_method.str()]
-    else:    
+    else:
         return soln
 
+def dsolve(de, ics=None, dvar=None, ivar=None, show_method=False, contrib_ode=False):
+    """
+    ALIAS for desolve
+    sage: y=function('y',x)
+    sage: desolve(de,[0,1,pi/2,4])
+    4*sin(x) + cos(x)
+    """
+    return desolve(de, dvar, ics, ivar, show_method, contrib_ode)
 
 #def desolve_laplace2(de,vars,ics=None):
 ##     """
@@ -454 +486 @@
 #    #return maxima.eval(cmd)
 #    return de0.desolve(vars[0]).rhs()
 
-    
-def desolve_laplace(de, dvar, ics=None, ivar=None):
+
+def desolve_laplace(de, dvar=None, ics=None, ivar=None):
     """
     Solves an ODE using laplace transforms. Initials conditions are optional.
 
     INPUT:
-    
+
     - ``de`` - a lambda expression representing the ODE (eg, de =
       diff(y,x,2) == diff(y,x)+sin(x))
 
-    - ``dvar`` - the dependent variable (eg y)
+    - ``dvar`` - (optional) the dependent variable (eg y)
 
     - ``ivar`` - (optional) the independent variable (hereafter called
       x), which must be specified if there is more than one
@@ -478 +510 @@
     Solution of the ODE as symbolic expression
 
     EXAMPLES::
-    
+
         sage: u=function('u',x)
         sage: eq = diff(u,x) - exp(-x) - u == 0
         sage: desolve_laplace(eq,u)
         1/2*(2*u(0) + 1)*e^x - 1/2*e^(-x)
-    
+
     We can use initial conditions::
 
         sage: desolve_laplace(eq,u,ics=[0,3])
         -1/2*e^(-x) + 7/2*e^x
 
-    The initial conditions do not persist in the system (as they persisted 
+    The initial conditions do not persist in the system (as they persisted
     in previous versions)::
 
         sage: desolve_laplace(eq,u)
@@ -501 +533 @@
         sage: eq = diff(f,x) + f == 0
         sage: desolve_laplace(eq,f,[0,1])
         e^(-x)
-    
+
     ::
-    
+
         sage: x = var('x')
         sage: f = function('f', x)
         sage: de = diff(f,x,x) - 2*diff(f,x) + f
@@ -523 +555 @@
         e^(-t) + 1
         sage: soln(t=3)
         e^(-3) + 1
-    
-    AUTHORS: 
+
+    AUTHORS:
 
     - David Joyner (1-2006,8-2007)
-    
+
     - Robert Marik (10-2009)
+
+    - Yuri Karadzhov (2010-03-27)
     """
     #This is the original code from David Joyner (inputs and outputs strings)
     #maxima("de:"+de._repr_()+"=0;")
@@ -544 +578 @@
     ## verbatim copy from desolve - begin
     if is_SymbolicEquation(de):
         de = de.lhs() - de.rhs()
-    if is_SymbolicVariable(dvar):
-        raise ValueError, "You have to declare dependent variable as a function, eg. y=function('y',x)"
-    # for backwards compatibility
-    if isinstance(dvar, list):
-        dvar, ivar = dvar
-    elif ivar is None:
-        ivars = de.variables()
-        ivars = [t for t in ivars if t != dvar]
+    diff_list = map(ops,indets(de,'_diff'))
+    if len(diff_list) == 0:
+        raise ValueError, "First argument is not differential equation."
+    if dvar is None:
+        dvars = set([x[0] for x in diff_list])
+        if len(dvars) != 1:
+            raise ValueError, "Unable to determine dependent variable, please specify."
+        dvar=dvars.pop()
+    else:
+        if is_SymbolicVariable(dvar):
+            raise ValueError, "You have to declare dependent variable as a function, eg. y=function('y',x)"
+        # for backwards compatibility
+        if isinstance(dvar, list):
+            dvar, ivar = dvar
+    if ivar is None:
+        ivars = set()
+        for el in diff_list:
+            ivars = ivars.union(el[1:])
         if len(ivars) != 1:
             raise ValueError, "Unable to determine independent variable, please specify."
-        ivar = ivars[0]
+        ivar = ivars.pop()
     ## verbatim copy from desolve - end
 
     def sanitize_var(exprs):  # 'y(x) -> y(x)
-        return exprs.replace("'"+str(dvar),str(dvar))    
+        return exprs.replace("'"+str(dvar),str(dvar))
     de0=de._maxima_()
     cmd = sanitize_var("desolve("+de0.str()+","+str(dvar)+")")
     soln=maxima(cmd).rhs()
     if str(soln).strip() == 'false':
-        raise NotImplementedError, "Maxima was unable to solve this ODE."    
+        raise NotImplementedError, "Maxima was unable to solve this ODE."
     soln=soln.sage()
     if ics!=None:
         d = len(ics)
         for i in range(0,d-1):
-            soln=eval('soln.substitute(diff(dvar,ivar,i)('+str(ivar)+'=ics[0])==ics[i+1])') 
+            soln=eval('soln.substitute(diff(dvar,ivar,i)('+str(ivar)+'=ics[0])==ics[i+1])')
     return soln
-    
-    
+
+def dsolve_laplace(de, ics=None, dvar=None, ivar=None):
+    """
+    ALIAS for desolve_laplace
+    sage: x = var('x')
+        sage: f = function('f', x)
+        sage: de = diff(f,x,x) - 2*diff(f,x) + f
+        sage: desolve_laplace(de)
+        -x*e^x*f(0) + x*e^x*D[0](f)(0) + e^x*f(0)
+        sage: desolve_laplace(de,[0,1,2])
+        x*e^x + e^x
+    """
+    return desolve_laplace(de, dvar, ics, ivar)
+
 def desolve_system(des, vars, ics=None, ivar=None):
     """
     Solves any size system of 1st order ODE's. Initials conditions are optional.
 
     INPUT:
-    
+
     - ``des`` - list of ODEs
-    
+
     - ``vars`` - list of dependent variables
-    
+
     - ``ics`` - (optional) list of initial values for ivar and vars
-    
+
     - ``ivar`` - (optional) the independent variable, which must be
       specified if there is more than one independent variable in the
       equation.
@@ -598 +654 @@
         sage: desolve_system([de1, de2], [x,y])
         [x(t) == (x(0) - 1)*cos(t) - (y(0) - 1)*sin(t) + 1,
          y(t) == (x(0) - 1)*sin(t) + (y(0) - 1)*cos(t) + 1]
-         
+
     Now we give some initial conditions::
-    
+
         sage: sol = desolve_system([de1, de2], [x,y], ics=[0,1,2]); sol
         [x(t) == -sin(t) + 1, y(t) == cos(t) + 1]
         sage: solnx, solny = sol[0].rhs(), sol[1].rhs()
         sage: plot([solnx,solny],(0,1))
         sage: parametric_plot((solnx,solny),(0,1))
 
-    AUTHORS: 
+    AUTHORS:
 
     - Robert Bradshaw (10-2008)
     """
@@ -637 +693 @@
         for dvar, ic in zip(dvars, ics[:1]):
             dvar.atvalue(ivar==ivar_ic, dvar)
     return soln
-        
+
 
 def desolve_system_strings(des,vars,ics=None):
     r"""
@@ -687 +743 @@
         sage: P2 = parametric_plot((solnx,solny),(0,1))
 
     Now type show(P1), show(P2) to view these.
-                      
 
-    AUTHORS: 
+
+    AUTHORS:
 
     - David Joyner (3-2006, 8-2007)
     """
@@ -721 +777 @@
     last column.
 
     *For pedagogical purposes only.*
-    
+
     EXAMPLES::
-    
+
         sage: from sage.calculus.desolvers import eulers_method
         sage: x,y = PolynomialRing(QQ,2,"xy").gens()
         sage: eulers_method(5*x+y-5,0,1,1/2,1)
@@ -777 +833 @@
         sage: P2 = line(pts)
         sage: (P1+P2).show()
 
-    AUTHORS: 
+    AUTHORS:
 
     - David Joyner
     """
@@ -812 +868 @@
     next (last) column.
 
     *For pedagogical purposes only.*
-    
+
     EXAMPLES::
 
         sage: from sage.calculus.desolvers import eulers_method_2x2
@@ -858 +914 @@
            3/4                 0.63                   -0.0078               -0.031                 0.11
              1                 0.63                     0.020                0.079                0.071
 
-    To numerically approximate y(1), where `y''+ty'+y=0`, `y(0)=1`, `y'(0)=0`:: 
+    To numerically approximate y(1), where `y''+ty'+y=0`, `y(0)=1`, `y'(0)=0`::
 
         sage: t,x,y=PolynomialRing(RR,3,"txy").gens()
         sage: f = y; g = -x-y*t
@@ -870 +926 @@
            3/4                 0.88                     -0.15                -0.62                -0.10
              1                 0.75                     -0.17                -0.68               -0.015
 
-    AUTHORS: 
+    AUTHORS:
 
     - David Joyner
     """
@@ -900 +956 @@
     `x(a)=x_0`, `y' = g(t,x,y)`, `y(a) = y_0`.
 
     *For pedagogical purposes only.*
-    
+
     EXAMPLES::
 
         sage: from sage.calculus.desolvers import eulers_method_2x2_plot
@@ -930 +986 @@
 def desolve_rk4_determine_bounds(ics,end_points=None):
     """
     Used to determine bounds for numerical integration.
-    
+
     - If end_points is None, the interval for integration is from ics[0]
       to ics[0]+10
 
@@ -945 +1001 @@
         sage: from sage.calculus.desolvers import desolve_rk4_determine_bounds
         sage: desolve_rk4_determine_bounds([0,2],1)
         (0, 1)
-   
+
     ::
 
-        sage: desolve_rk4_determine_bounds([0,2])  
+        sage: desolve_rk4_determine_bounds([0,2])
         (0, 10)
-   
+
     ::
 
         sage: desolve_rk4_determine_bounds([0,2],[-2])
         (-2, 0)
-   
+
     ::
 
         sage: desolve_rk4_determine_bounds([0,2],[-2,4])
         (-2, 4)
-   
+
     """
-    if end_points is None: 
+    if end_points is None:
         return((ics[0],ics[0]+10))
     if not isinstance(end_points,list):
         end_points=[end_points]
@@ -970 +1026 @@
         return (min(ics[0],end_points[0]),max(ics[0],end_points[0]))
     else:
         return (min(ics[0],end_points[0]),max(ics[0],end_points[1]))
-    
+
 
 def desolve_rk4(de, dvar, ics=None, ivar=None, end_points=None, step=0.1, output='list', **kwds):
     """
@@ -978 +1034 @@
     equation. See also ``ode_solver``.
 
     INPUT:
-    
-    input is similar to ``desolve`` command. The differential equation can be 
+
+    input is similar to ``desolve`` command. The differential equation can be
     written in a form close to the plot_slope_field or desolve command
 
     - Variant 1 (function in two variables)
-      
+
       - ``de`` - right hand side, i.e. the function `f(x,y)` from ODE `y'=f(x,y)`
-      
+
       - ``dvar`` - dependent variable (symbolic variable declared by var)
 
     - Variant 2 (symbolic equation)
@@ -994 +1050 @@
 
       - ``dvar``` - dependent variable (declared as funciton of independent variable)
 
-    - Other parameters 
+    - Other parameters
 
       - ``ivar`` - should be specified, if there are more variables or if the equation is autonomous
 
       - ``ics`` - initial conditions in the form [x0,y0]
-     
+
       - ``end_points`` - the end points of the interval
 
         - if end_points is a or [a], we integrate on between min(ics[0],a) and max(ics[0],a)
@@ -1008 +1064 @@
         - if end_points is [a,b] we integrate on between min(ics[0],a) and max(ics[0],b)
 
       - ``step`` - (optional, default:0.1) the length of the step (positive number)
- 
+
       - ``output`` - (optional, default: 'list') one of 'list',
         'plot', 'slope_field' (graph of the solution with slope field)
 
-    OUTPUT: 
+    OUTPUT:
 
     Returns a list of points, or plot produced by list_plot,
     optionally with slope field.
@@ -1030 +1086 @@
 
     Variant 1 for input - we can pass ODE in the form used by
     desolve function In this example we integrate bakwards, since
-    ``end_points < ics[0]``:: 
+    ``end_points < ics[0]``::
 
-        sage: y=function('y',x) 
-        sage: desolve_rk4(diff(y,x)+y*(y-1) == x-2,y,ics=[1,1],step=0.5, end_points=0) 
+        sage: y=function('y',x)
+        sage: desolve_rk4(diff(y,x)+y*(y-1) == x-2,y,ics=[1,1],step=0.5, end_points=0)
         [[0.0, 8.90425710896], [0.5, 1.90932794536], [1, 1]]
 
     Here we show how to plot simple pictures. For more advanced
@@ -1042 +1098 @@
 
         sage: x,y=var('x y')
         sage: P=desolve_rk4(y*(2-y),y,ics=[0,.1],ivar=x,output='slope_field',end_points=[-4,6],thickness=3)
-                
+
     ALGORITHM:
 
     4th order Runge-Kutta method. Wrapper for command ``rk`` in
     Maxima's dynamics package.  Perhaps could be faster by using
     fast_float instead.
 
-    AUTHORS: 
+    AUTHORS:
 
     - Robert Marik (10-2009)
     """
-    if ics is None: 
+    if ics is None:
         raise ValueError, "No initial conditions, specify with ics=[x0,y0]."
 
     if ivar is None:
@@ -1110 +1166 @@
         YMIN=sol[0][1]
         XMAX=XMIN
         YMAX=YMIN
-        for s,t in sol: 
+        for s,t in sol:
             if s>XMAX:XMAX=s
             if s<XMIN:XMIN=s
             if t>YMAX:YMAX=t
@@ -1124 +1180 @@
     r"""
     Solves numerically system of first-order ordinary differential
     equations using the 4th order Runge-Kutta method. Wrapper for
-    Maxima command ``rk``. See also ``ode_solver``. 
+    Maxima command ``rk``. See also ``ode_solver``.
 
     INPUT:
-    
+
     input is similar to desolve_system and desolve_rk4 commands
-    
+
     - ``des`` - right hand sides of the system
 
     - ``vars`` - dependent variables
@@ -1139 +1195 @@
       missing
 
     - ``ics`` - initial conditions in the form [x0,y01,y02,y03,....]
-    
+
     - ``end_points`` - the end points of the interval
-    
+
       - if end_points is a or [a], we integrate on between min(ics[0],a) and max(ics[0],a)
       - if end_points is None, we use end_points=ics[0]+10
 
@@ -1164 +1220 @@
         sage: P=desolve_system_rk4([x*(1-y),-y*(1-x)],[x,y],ics=[0,0.5,2],ivar=t,end_points=20)
         sage: Q=[ [i,j] for i,j,k in P]
         sage: LP=list_plot(Q)
-        
+
         sage: Q=[ [j,k] for i,j,k in P]
         sage: LP=list_plot(Q)
-    
+
     ALGORITHM:
 
     4th order Runge-Kutta method. Wrapper for command ``rk`` in Maxima's
     dynamics package.  Perhaps could be faster by using ``fast_float``
     instead.
 
-    AUTHOR: 
+    AUTHOR:
 
     - Robert Marik (10-2009)
     """
 
-    if ics is None: 
+    if ics is None:
         raise ValueError, "No initial conditions, specify with ics=[x0,y01,y02,...]."
 
     ivars = set([])
@@ -1199 +1255 @@
     x0=ics[0]
     icss = [ics[i]._maxima_().str() for i in range(1,len(ics))]
     icstr = "[" + ",".join(icss) + "]"
-    step=abs(step) 
+    step=abs(step)
 
     maxima("load('dynamics)")
     lower_bound,upper_bound=desolve_rk4_determine_bounds(ics,end_points)

sage/symbolic/all.py

@@ -8 +8 @@
 
 from sage.symbolic.relation import solve, solve_mod, solve_ineq
 from sage.symbolic.assumptions import assume, forget, assumptions
+
+from sage.symbolic.mtype import *