Ticket #7377: trac_7377-fastcalculus-p1.patch

File trac_7377-fastcalculus-p1.patch, 22.6 KB (added by nbruin, 8 years ago)

improved fastcalculus (includes previous fixes)

  • sage/calculus/calculus.py

    # HG changeset patch
    # User Nils Bruin <nbruin@sfu.ca>
    # Date 1265693495 28800
    # Node ID 2aa53d20ef6082fac0ec6218b29a469ea7cf13ae
    # Parent  6d5b89f947d1a7ce14bc4ff23ad63fbd6f7dbd5a
    Let calculus use the maxima_lib instance and implement some preliminary
    routines for communicating directly (not via strings) with maxima_lib
    
    diff -r 6d5b89f947d1 -r 2aa53d20ef60 sage/calculus/calculus.py
    a b  
    386386    f1
    387387"""
    388388maxima = sage.interfaces.maxima_lib.maxima
     389#maxima = Maxima(init_code = ['display2d:false', 'domain: complex',
     390#                             'keepfloat: true', 'load(to_poly_solver)', 'load(simplify_sum)'],
     391#                script_subdirectory=None)
    389392
    390393########################################################
    391394def symbolic_sum(expression, v, a, b, algorithm='maxima'):
     
    522525        raise ValueError, "summation limits must not depend on the summation variable"
    523526
    524527    if algorithm == 'maxima':
    525         sum  = "'sum(%s, %s, %s, %s)" % tuple([repr(expr._maxima_()) for expr in (expression, v, a, b)])
    526528        try:
    527             result = maxima.simplify_sum(sum)
    528             result = result.ratsimp()
    529             return expression.parent()(result)
     529            return maxima.sr_sum(expression,v,a,b)
    530530        except TypeError, error:
    531531            s = str(error)
    532532            if "divergent" in s or 'Pole encountered' in s:
     
    10941094
    10951095    if algorithm == 'maxima':
    10961096        if dir is None:
    1097             l = ex._maxima_().limit(v, a)
     1097            l = maxima.sr_limit(ex, v, a)
    10981098        elif dir in ['plus', '+', 'right', 'above']:
    10991099            if dir == 'above':
    11001100                from sage.misc.misc import deprecation
    11011101                deprecation("the keyword 'above' is deprecated. Please use 'right' or '+' instead.", 'Sage version 4.6')
    1102             l = ex._maxima_().limit(v, a, 'plus')
     1102            l = maxima.sr_limit(ex, v, a, 'plus')
    11031103        elif dir in ['minus', '-', 'left', 'below']:
    11041104            if dir == 'below':
    11051105                from sage.misc.misc import deprecation
    11061106                deprecation("the keyword 'below' is deprecated. Please use 'left' or '-' instead.", 'Sage version 4.6')
    1107             l = ex._maxima_().limit(v, a, 'minus')
     1107            l = maxima.sr_limit(ex, v, a, 'minus')
    11081108    elif algorithm == 'maxima_taylor':
    11091109        if dir is None:
    1110             l = ex._maxima_().tlimit(v, a)
     1110            l = maxima.sr_tlimit(ex, v, a)
    11111111        elif dir == 'plus' or dir == 'above' or dir == 'from_right':
    1112             l = ex._maxima_().tlimit(v, a, 'plus')
     1112            l = maxima.sr_tlimit(ex, v, a, 'plus')
    11131113        elif dir == 'minus' or dir == 'below' or dir == 'from_left':
    1114             l = ex._maxima_().tlimit(v, a, 'minus')
     1114            l = maxima.sr_tlimit(ex, v, a, 'minus')
    11151115    elif algorithm == 'sympy':
    11161116        if dir is None:
    11171117            import sympy
     
    11191119        else:
    11201120            raise NotImplementedError, "sympy does not support one-sided limits"
    11211121
    1122     return l.sage()
     1122    #return l.sage()
    11231123    return ex.parent()(l)
    11241124
    11251125# lim is alias for limit
  • sage/interfaces/maxima.py

    diff -r 6d5b89f947d1 -r 2aa53d20ef60 sage/interfaces/maxima.py
    a b  
    10081008        """
    10091009        return maxima_version()
    10101010
     1011##some helper functions to wrap tha calculus use of the maxima interface.
     1012##these routines expect arguments living in the symbolic ring and return something
     1013##that is hopefully coercible into the symbolic ring again.
    10111014
     1015    def sr_integral(self,*args):
     1016        return args[0]._maxima_().integrate(*args[1:])
     1017
     1018    def sr_sum(self,expression,v,a,b):
     1019        sum  = "'sum(%s, %s, %s, %s)" % tuple([repr(expr._maxima_()) for expr in (expression, v, a, b)])
     1020        result = self.simplify_sum(sum)
     1021        result = result.ratsimp()
     1022        return expression.parent()(result)
     1023
     1024    def sr_limit(self,ex,*args):
     1025        return ex._maxima_().limit(*args)
     1026
     1027    def sr_tlimit(self,ex,*args):
     1028        return ex._maxima_().tlimit(*args)
     1029   
    10121030##     def display2d(self, flag=True):
    10131031##         """
    10141032##         Set the flag that determines whether Maxima objects are
     
    10741092def __doctest_cleanup():
    10751093    import sage.interfaces.quit
    10761094    sage.interfaces.quit.expect_quitall()
    1077 
    1078 
  • sage/interfaces/maxima_lib.py

    diff -r 6d5b89f947d1 -r 2aa53d20ef60 sage/interfaces/maxima_lib.py
    a b  
    423423    sage: var('Ax,Bx,By')
    424424    (Ax, Bx, By)
    425425    sage: t = -Ax*sin(sqrt(Ax^2)/2)/(sqrt(Ax^2)*sqrt(By^2 + Bx^2))
    426     sage: t.limit(Ax=0,dir='above')
     426    sage: t.limit(Ax=0,dir='+')
    427427    0
    428428
    429429A long complicated input expression::
     
    470470import sage.server.support
    471471
    472472import maxima_abstract
    473 from maxima_abstract import MaximaFunctionElement, MaximaExpectFunction, MaximaElement, MaximaFunction, maxima_console
     473from maxima_abstract import MaximaFunctionElement, MaximaExpectFunction, MaximaFunction, maxima_console
    474474
    475475# The Maxima "apropos" command, e.g., apropos(det) gives a list
    476476# of all identifiers that begin in a certain way.  This could
     
    485485ecl_eval("(in-package :maxima)")
    486486ecl_eval("(setq $nolabels t))")
    487487ecl_eval("(defvar *MAXIMA-LANG-SUBDIR* NIL)")
     488ecl_eval("(set-locale-subdir)")
    488489ecl_eval("(set-pathnames)")
    489490ecl_eval("(defun add-lineinfo (x) x)")
    490491ecl_eval("""(defun retrieve (msg flag &aux (print? nil))(error (concatenate 'string "Maxima asks:" (meval (list '($string) msg)))))""")
    491492ecl_eval('(defparameter *dev-null* (make-two-way-stream (make-concatenated-stream) (make-broadcast-stream)))')
    492493ecl_eval('(defun principal nil (error "Divergent Integral"))')
    493494
     495ecl_eval("(setf $errormsg nil)")
     496
    494497maxima_eval=ecl_eval("""
    495     (defun maxima-eval( form )
    496         (let ((result (catch 'macsyma-quit (cons 'maxima_eval (meval form)))))
    497             ;(princ (list "result=" result))
    498             ;(terpri)
    499             ;(princ (list "$error=" $error))
    500             ;(terpri)
    501             (cond
    502                 ((and (consp result) (eq (car result) 'maxima_eval)) (cdr result))
    503                 ((eq result 'maxima-error) (error (cadr $error)))
    504                 (t (error (concatenate 'string "Maxima condition. result:" (princ-to-string result) "$error:" (princ-to-string $error))))
    505             )
     498(defun maxima-eval( form )
     499    (let ((result (catch 'macsyma-quit (cons 'maxima_eval (meval form)))))
     500        ;(princ (list "result=" result))
     501        ;(terpri)
     502        ;(princ (list "$error=" $error))
     503        ;(terpri)
     504        (cond
     505            ((and (consp result) (eq (car result) 'maxima_eval)) (cdr result))
     506            ((eq result 'maxima-error)
     507                (let ((the-jig (process-error-argl (cddr $error))))
     508                    (mapc #'set (car the-jig) (cadr the-jig))
     509                    (error (concatenate 'string "Error executing code in Maxima: "
     510                       (with-output-to-string (stream)
     511                           (apply #'mformat stream (cadr $error) (caddr the-jig)))))
     512                ))
     513            (t
     514                (let ((the-jig (process-error-argl (cddr $error))))
     515                    (mapc #'set (car the-jig) (cadr the-jig))
     516                    (error (concatenate 'string "Maxima condition. result:" (princ-to-string result) "$error:"
     517                       (with-output-to-string (stream)
     518                           (apply #'mformat stream (cadr $error) (caddr the-jig)))))
     519                ))
    506520        )
    507521    )
     522)
    508523""")
    509524
    510525#ecl_eval('(defun ask-evod (x even-odd)(error "Maxima asks a question"))')
     
    527542
    528543maxprint=EclObject("$STRING")
    529544meval=EclObject("MEVAL")
     545msetq=EclObject("MSETQ")
     546mlist=EclObject("MLIST")
     547mequal=EclObject("MEQUAL")
     548cadadr=EclObject("CADADR")
     549
     550max_integrate=EclObject("$INTEGRATE")
     551max_sum=EclObject("$SUM")
     552max_simplify_sum=EclObject("$SIMPLIFY_SUM")
     553max_ratsimp=EclObject("$RATSIMP")
     554max_limit=EclObject("$LIMIT")
     555max_tlimit=EclObject("$TLIMIT")
     556max_plus=EclObject("$PLUS")
     557max_minus=EclObject("$MINUS")
     558max_use_grobner=EclObject("$USE_GROBNER")
     559max_to_poly_solve=EclObject("$TO_POLY_SOLVE")
    530560
    531561def max_to_string(s):
    532562     return meval(EclObject([[maxprint],s])).python()[1:-1]
     
    575605        for l in init_code:
    576606            ecl_eval("#$%s$"%l)
    577607        ecl_eval("(setf *standard-output* original-standard-output)")
     608 
     609    def _coerce_from_special_method(self, x):
     610        if isinstance(x, EclObject):
     611            return MaximaElement(self,self._create(x))
     612        else:
     613            return maxima_abstract.Maxima._coerce_from_special_method(self,x)
     614       
    578615       
    579616    def _function_class(self):
    580617        """
     
    598635            sage: m.is_running()
    599636            True
    600637        """
    601         ecl_eval(r"(defun tex-derivative (x l r) (tex (if $derivabbrev (tex-dabbrev x) (tex-d x '\partial)) l r lop rop ))")
    602 
     638#        ecl_eval(r"(defun tex-derivative (x l r) (tex (if $derivabbrev (tex-dabbrev x) (tex-d x '\partial)) l r lop rop ))")
     639        pass
     640       
    603641    def __reduce__(self):
    604642        """
    605643        EXAMPLES::
     
    620658            sage: integrate(1/(x^3 *(a+b*x)^(1/3)),x)
    621659            Traceback (most recent call last):
    622660            ...
    623             TypeError: Computation failed since Maxima requested additional constraints (try the command 'assume(a>0)' before integral or limit evaluation, for example):
    624             Is  a  positive or negative?
     661            RuntimeError: ECL says: Maxima asks:...
    625662            sage: assume(a>0)
    626663            sage: integrate(1/(x^3 *(a+b*x)^(1/3)),x)
    627664            2/9*sqrt(3)*b^2*arctan(1/3*(2*(b*x + a)^(1/3) + a^(1/3))*sqrt(3)/a^(1/3))/a^(7/3) + 2/9*b^2*log((b*x + a)^(1/3) - a^(1/3))/a^(7/3) - 1/9*b^2*log((b*x + a)^(2/3) + (b*x + a)^(1/3)*a^(1/3) + a^(2/3))/a^(7/3) + 1/6*(4*(b*x + a)^(5/3)*b^2 - 7*(b*x + a)^(2/3)*a*b^2)/((b*x + a)^2*a^2 - 2*(b*x + a)*a^3 + a^4)
     
    630667            sage: integral(x^n,x)
    631668            Traceback (most recent call last):
    632669            ...
    633             TypeError: Computation failed since Maxima requested additional constraints (try the command 'assume(n+1>0)' before integral or limit evaluation, for example):
    634             Is  n+1  zero or nonzero?
     670            RuntimeError: ECL says: Maxima asks:...
    635671            sage: assume(n+1>0)
    636672            sage: integral(x^n,x)
    637673            x^(n + 1)/(n + 1)
     
    683719
    684720    def _eval_line(self, line, allow_use_file=False,
    685721                   wait_for_prompt=True, reformat=True, error_check=True):
    686         return max_to_string(maxima_eval("#$%s$"%line))
    687        
     722        result = ''
     723        while line:
     724            ind_dollar=line.find("$")
     725            ind_semi=line.find(";")
     726            if ind_dollar == -1 or (ind_semi >=0 and ind_dollar > ind_semi):
     727                if ind_semi == -1:
     728                    statement = line
     729                    line = ''
     730                else:
     731                    statement = line[:ind_semi]
     732                    line = line[ind_semi+1:]
     733                if statement: result = ((result + '\n') if result else '')+ max_to_string(maxima_eval("#$%s$"%statement))
     734            else:
     735                statement = line[:ind_dollar]
     736                line = line[ind_dollar+1:]
     737                if statement: _ = max_to_string(maxima_eval("#$%s$"%statement))
     738        return result
    688739
    689740    def _synchronize(self):
    690741        """
     
    929980        """
    930981        s = self._eval_line('%s;'%var)
    931982        return s
    932    
     983 
     984    def _create(self, value, name=None):
     985        name = self._next_var_name() if name is None else name
     986        if isinstance(value,EclObject):
     987            maxima_eval([[msetq],cadadr("#$%s$#$"%name),value])
     988        else:
     989            self.set(name, value)
     990        return name
     991               
    933992    def version(self):
    934993        """
    935994        Return the version of Maxima that Sage includes.
     
    937996        EXAMPLES::
    938997       
    939998            sage: maxima.version()
    940             '5.19.1'
     999            '5.22.1'
    9411000        """
    9421001        return maxima_version()
    9431002
     1003##some helper functions to wrap tha calculus use of the maxima interface.
     1004##these routines expect arguments living in the symbolic ring and return something
     1005##that is hopefully coercible into the symbolic ring again.
     1006
     1007    def sr_integral(self,*args):
     1008        try:
     1009            return max_to_sr(maxima_eval(([max_integrate],[sr_to_max(SR(a)) for a in args])))
     1010        except RuntimeError, error:
     1011            s = str(error)
     1012            if "Divergent" in s or "divergent" in s:
     1013                raise ValueError, "Integral is divergent."
     1014            else:
     1015                raise error
     1016
     1017    def sr_sum(self,*args):
     1018        try:
     1019            return max_to_sr(maxima_eval([[max_ratsimp],[[max_simplify_sum],([max_sum],[sr_to_max(SR(a)) for a in args])]]));
     1020        except RuntimeError, error:
     1021            s = str(error)
     1022            if "divergent" in s:
     1023                raise ValueError, "Sum is divergent."
     1024            else:
     1025                raise error
     1026
     1027    def sr_limit(self,expr,v,a,dir=None):
     1028        L=[sr_to_max(SR(a)) for a in [expr,v,a]]
     1029        if dir == "plus":
     1030            L.append(max_plus)
     1031        elif dir == "minus":
     1032            L.append(max_minus)
     1033        return max_to_sr(maxima_eval(([max_limit],L)))
     1034
     1035    def sr_tlimit(self,expr,v,a,dir=None):
     1036        L=[sr_to_max(SR(a)) for a in [expr,v,a]]
     1037        if dir == "plus":
     1038            L.append(max_plus)
     1039        elif dir == "minus":
     1040            L.append(max_minus)
     1041        return max_to_sr(maxima_eval(([max_tlimit],L)))
    9441042
    9451043##     def display2d(self, flag=True):
    9461044##         """
     
    9641062##         """
    9651063##         self._display2d = bool(flag)
    9661064
     1065class MaximaElement(maxima_abstract.MaximaElement):
     1066    """
     1067    """   
     1068    def ecl(self):
     1069        try:
     1070            return self._ecl
     1071        except AttributeError:
     1072            self._ecl=maxima_eval("#$%s$"%self._name)
     1073            return self._ecl
     1074           
     1075    def to_poly_solve(self,vars,options=""):
     1076        if options.find("use_grobner=true") != -1:
     1077            cmd=EclObject([[max_to_poly_solve], self.ecl(), sr_to_max(vars),
     1078                                             [[mequal],max_use_grobner,True]])
     1079        else:
     1080            cmd=EclObject([[max_to_poly_solve], self.ecl(), sr_to_max(vars)])
     1081        return self.parent()(maxima_eval(cmd))
     1082
    9671083def is_MaximaElement(x):
    9681084    """
    9691085    Returns True if x is of type MaximaElement.
     
    9981114   
    9991115        sage: from sage.interfaces.maxima import maxima_version
    10001116        sage: maxima_version()
    1001         '5.19.1'
     1117        '5.22.1'
    10021118    """
    10031119    return os.popen('maxima --version').read().split()[-1]
    10041120
     
    10071123    sage.interfaces.quit.expect_quitall()
    10081124
    10091125
     1126import sage.symbolic.expression
     1127from sage.symbolic.ring import SR
     1128
     1129import sage.symbolic.expression
     1130import sage.functions.trig
     1131import sage.functions.log
     1132import sage.functions.other
     1133import sage.symbolic.integration.integral
     1134
     1135car=EclObject("car")
     1136cdr=EclObject("cdr")
     1137caar=EclObject("caar")
     1138cadr=EclObject("cadr")
     1139cddr=EclObject("cddr")
     1140caddr=EclObject("caddr")
     1141caaadr=EclObject("caaadr")
     1142cadadr=EclObject("cadadr")
     1143meval=EclObject("meval")
     1144NIL=EclObject("NIL")
     1145ratdisrep=EclObject("ratdisrep")
     1146
     1147sage_op_dict={}
     1148
     1149sage_op_dict = {
     1150    sage.symbolic.expression.operator.abs : "MABS",
     1151    sage.symbolic.expression.operator.add : "MPLUS",
     1152    sage.symbolic.expression.operator.div : "MQUOTIENT",
     1153    sage.symbolic.expression.operator.eq : "MEQUAL",
     1154    sage.symbolic.expression.operator.ge : "MGEQP",
     1155    sage.symbolic.expression.operator.gt : "MGREATERP",
     1156    sage.symbolic.expression.operator.le : "MLEQP",
     1157    sage.symbolic.expression.operator.lt : "MLESSP",
     1158    sage.symbolic.expression.operator.mul : "MTIMES",
     1159    sage.symbolic.expression.operator.ne : "MNOTEQUAL",
     1160    sage.symbolic.expression.operator.neg : "MMINUS",
     1161    sage.symbolic.expression.operator.pow : "MEXPT",
     1162    sage.symbolic.expression.operator.or_ : "MOR",
     1163    sage.symbolic.expression.operator.and_ : "MAND",
     1164    sage.functions.trig.acos : "%ACOS",
     1165    sage.functions.trig.acot : "%ACOT",
     1166    sage.functions.trig.acsc : "%ACSC",
     1167    sage.functions.trig.asec : "%ASEC",
     1168    sage.functions.trig.asin : "%ASIN",
     1169    sage.functions.trig.atan : "%ATAN",
     1170    sage.functions.trig.cos : "%COS",
     1171    sage.functions.trig.cot : "%COT",
     1172    sage.functions.trig.csc : "%CSC",
     1173    sage.functions.trig.sec : "%SEC",
     1174    sage.functions.trig.sin : "%SIN",
     1175    sage.functions.trig.tan : "%TAN",
     1176    sage.functions.log.exp : "%EXP",
     1177    sage.functions.log.ln : "%LOG",
     1178    sage.functions.log.log : "%LOG",
     1179    sage.functions.other.factorial : "MFACTORIAL",
     1180    sage.functions.other.erf : "%ERF",
     1181    sage.functions.other.gamma_inc : "%GAMMA_INCOMPLETE"
     1182}
     1183
     1184#we compile the dictionary
     1185sage_op_dict = dict([(k,EclObject(sage_op_dict[k])) for k in sage_op_dict])
     1186max_op_dict = dict([(sage_op_dict[k],k) for k in sage_op_dict])
     1187def add_vararg(*args):
     1188    S=0
     1189    for a in args:
     1190        S=S+a
     1191    return S
     1192
     1193def mul_vararg(*args):
     1194    P=1
     1195    for a in args:
     1196        P=P*a
     1197    return P
     1198
     1199def sage_rat(x,y):
     1200    return x/y
     1201
     1202mplus=EclObject("MPLUS")
     1203mtimes=EclObject("MTIMES")
     1204rat=EclObject("RAT")
     1205max_i=EclObject("$%I")
     1206max_op_dict[mplus]=add_vararg
     1207max_op_dict[mtimes]=mul_vararg
     1208max_op_dict[rat]=sage_rat
     1209mqapply=EclObject("MQAPPLY")
     1210max_li=EclObject("$LI")
     1211max_psi=EclObject("$PSI")
     1212max_array=EclObject("ARRAY")
     1213max_gamma_incomplete=sage_op_dict[sage.functions.other.gamma_inc]
     1214
     1215def mrat_to_sage(expr):
     1216    r"""
     1217    Convert a maxima MRAT expression to Sage SR
     1218   
     1219    Maxima has an optimised representation for multivariate rational expressions.
     1220    The easiest way to translate those to SR is by first asking maxima to give
     1221    the generic representation of the object. That is what RATDISREP does in
     1222    maxima.
     1223    """
     1224    return max_to_sr(meval(EclObject([[ratdisrep],expr])))
     1225
     1226def mqapply_to_sage(expr):
     1227    r"""
     1228    Special conversion rule for MQAPPLY expressions
     1229    """
     1230    if caaadr(expr) == max_li:
     1231        return sage.functions.log.polylog(max_to_sr(cadadr(expr)),max_to_sr(caddr(expr)))
     1232    if caaadr(expr) == max_psi:
     1233        return sage.functions.other.psi(max_to_sr(cadadr(expr)),max_to_sr(caddr(expr)))
     1234    else:
     1235        op=max_to_sr(cadr(expr))
     1236        max_args=cddr(expr)
     1237        args=[max_to_sr(a) for a in max_args]
     1238        return op(*args)
     1239
     1240def dummy_integrate(expr):
     1241    r"""
     1242    we would like to simply tie maxima's integrate to sage.calculus.calculus.dummy_integrate, but we're being imported there so to avoid circularity we define it here.
     1243    """
     1244    args=[max_to_sr(a) for a in cdr(expr)]
     1245    if len(args) == 4 :
     1246        return sage.symbolic.integration.integral.definite_integral(*args, hold=True)
     1247    else:
     1248        return sage.symbolic.integration.integral.indefinite_integral(*args, hold=True)
     1249
     1250special_max_to_sage={
     1251    EclObject("MRAT") : mrat_to_sage,
     1252    EclObject("MQAPPLY") : mqapply_to_sage,
     1253    EclObject("%INTEGRATE") : dummy_integrate
     1254}
     1255
     1256special_sage_to_max={
     1257    sage.functions.log.polylog : lambda N,X : [[mqapply],[[max_li, max_array],N],X],
     1258    sage.functions.other.psi1 : lambda X : [[mqapply],[[max_psi, max_array],0],X],
     1259    sage.functions.other.psi2 : lambda N,X : [[mqapply],[[max_psi, max_array],N],X],
     1260    sage.functions.other.Ei : lambda X : [[max_gamma_incomplete], 0, X]
     1261}
     1262
     1263sage_sym_dict={}
     1264max_sym_dict={}
     1265
     1266def pyobject_to_max(obj):
     1267    if isinstance(obj,sage.rings.rational.Rational):
     1268        return EclObject(obj) if (obj.denom().is_one()) else EclObject([[rat], obj.numer(),obj.denom()])
     1269    elif isinstance(obj,sage.rings.number_field.number_field_element_quadratic.NumberFieldElement_quadratic) and obj.parent().defining_polynomial().list() == [1,0,1]:
     1270        re, im = obj.list()
     1271        return EclObject([[mplus], pyobject_to_max(re), [[mtimes], pyobject_to_max(im), max_i]])
     1272   
     1273    return EclObject(obj)
     1274
     1275def sr_to_max(expr):
     1276    r"""
     1277    """
     1278    global sage_op_dict, max_op_dict
     1279    global sage_sym_dict, max_sym_dict
     1280    if isinstance(expr,list) or isinstance(expr,tuple):
     1281        return EclObject(([mlist],[sr_to_max(e) for e in expr]))
     1282    op = expr.operator()
     1283    if op:
     1284        if (op in special_sage_to_max):
     1285            return EclObject(special_sage_to_max[op](*[sr_to_max(o) for o in expr.operands()]))
     1286        elif not (op in sage_op_dict):
     1287            op_max=caar(maxima(expr).ecl())
     1288            sage_op_dict[op]=op_max
     1289            max_op_dict[op_max]=op
     1290        return EclObject(([sage_op_dict[op]],
     1291                     [sr_to_max(o) for o in expr.operands()]))
     1292    elif expr._is_symbol() or expr._is_constant():
     1293        if not expr in sage_sym_dict:
     1294            sym_max=maxima(expr).ecl()
     1295            sage_sym_dict[expr]=sym_max
     1296            max_sym_dict[sym_max]=expr
     1297        return sage_sym_dict[expr]
     1298    else:
     1299        try:
     1300            return pyobject_to_max(expr.pyobject())
     1301        except TypeError:
     1302            return maxima(expr).ecl()
     1303   
     1304def max_to_sr(expr):
     1305    if expr.consp():
     1306        op_max=caar(expr)
     1307        if op_max in special_max_to_sage:
     1308            return special_max_to_sage[op_max](expr)
     1309        if not(op_max in max_op_dict):
     1310            sage_expr=SR(maxima(expr))
     1311            max_op_dict[op_max]=sage_expr.operator()
     1312            sage_op_dict[sage_expr.operator()]=op_max
     1313        op=max_op_dict[op_max]
     1314        max_args=cdr(expr)
     1315        args=[ max_to_sr(a) for a in max_args]
     1316        return op(*args)
     1317    elif expr.symbolp():
     1318        if not(expr in max_sym_dict):
     1319            sage_symbol=SR(maxima(expr))
     1320            sage_sym_dict[sage_symbol]=expr
     1321            max_sym_dict[expr]=sage_symbol
     1322        return max_sym_dict[expr]
     1323    else:
     1324        return expr.python()
     1325
  • sage/symbolic/integration/external.py

    diff -r 6d5b89f947d1 -r 2aa53d20ef60 sage/symbolic/integration/external.py
    a b  
    1212        sage: maxima_integrator(f(x), x)
    1313        integrate(f(x), x)
    1414    """
     15    from sage.calculus.calculus import maxima
    1516    if not isinstance(expression, Expression):
    1617        expression = SR(expression)
    1718    if a is None:
    18         result = expression._maxima_().integrate(v)
     19        result = maxima.sr_integral(expression,v)
    1920    else:
    2021        try:
    21             result = expression._maxima_().integrate(v, a, b)
     22            result = maxima.sr_integral(expression, v, a, b)
    2223        except TypeError, error:
    2324            s = str(error)
    2425            if "divergent" in s or 'Principal Value' in s:
    2526                raise ValueError, "Integral is divergent."
    2627            else:
    2728                raise
    28     return result.sage()
     29    return result
    2930
    3031def sympy_integrator(expression, v, a=None, b=None):
    3132    """