Ticket #7377: trac_7377-abstract-maxima_p2.patch

File trac_7377-abstract-maxima_p2.patch, 132.5 KB (added by jpflori, 8 years ago)

Patch based on Sage 4.6.2.alpha4, ECL 11.1.1 and Maxima 5.23.1, apply 1

  • sage/interfaces/maxima.py

    # HG changeset patch
    # User Jean-Pierre Flori <flori@enst.fr>
    # Date 1297784921 -3600
    # Node ID fee8c73d93a27081c5ae1e56125202426bbfa1e5
    # Parent  c34921fb270beb0d54ee2ade3c6db78880b61d0b
    # Parent  41ee4838d21bf6fe2438de433690bb2cfa60e7a4
    Split maxima interface up into abstract and concrete methods.
    
    diff -r c34921fb270b -r fee8c73d93a2 sage/interfaces/maxima.py
    a b  
    4545    sage: F
    4646    -(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)
    4747    sage: type(F)
    48     <class 'sage.interfaces.maxima.MaximaElement'>
     48    <class 'sage.interfaces.maxima_abstract.MaximaElement'>
    4949
    5050Note that Maxima objects can also be displayed using "ASCII art";
    5151to see a normal linear representation of any Maxima object x. Just
     
    469469
    470470import sage.server.support
    471471
     472import maxima_abstract
     473from maxima_abstract import MaximaFunctionElement, MaximaExpectFunction, MaximaElement, MaximaFunction, maxima_console
     474
    472475# The Maxima "apropos" command, e.g., apropos(det) gives a list
    473476# of all identifiers that begin in a certain way.  This could
    474477# maybe be useful somehow... (?)  Also maxima has a lot for getting
    475478# documentation from the system -- this could also be useful.
    476479
    477 class Maxima(Expect):
     480class Maxima(maxima_abstract.Maxima):
    478481    """
    479482    Interface to the Maxima interpreter.
    480483    """
     
    554557        EXAMPLES::
    555558       
    556559            sage: maxima._function_class()
    557             <class 'sage.interfaces.maxima.MaximaExpectFunction'>
     560            <class 'sage.interfaces.maxima_abstract.MaximaExpectFunction'>
    558561        """
    559562        return MaximaExpectFunction
    560563
     
    594597        """
    595598        return reduce_load_Maxima, tuple([])
    596599
    597     def _quit_string(self):
    598         """
    599         EXAMPLES::
    600        
    601             sage: maxima._quit_string()
    602             'quit();'
    603         """
    604         return 'quit();'
    605 
    606600    def _sendline(self, str):
    607601        self._sendstr(str)
    608602        os.write(self._expect.child_fd, os.linesep)
    609603
    610     def _crash_msg(self):
    611         """
    612         EXAMPLES::
    613        
    614             sage: maxima._crash_msg()
    615             Maxima crashed -- automatically restarting.
    616         """
    617         print "Maxima crashed -- automatically restarting."
    618 
    619604    def _expect_expr(self, expr=None, timeout=None):
    620605        """
    621606        EXAMPLES:
     
    684669                    break
    685670            raise KeyboardInterrupt, msg
    686671
    687 
    688     def _batch(self, s, batchload=True):
    689         filename = '%s-%s'%(self._local_tmpfile(),randrange(2147483647))
    690         F = open(filename, 'w')
    691         F.write(s)
    692         F.close()
    693         if self.is_remote():
    694             self._send_tmpfile_to_server(local_file=filename)
    695             tmp_to_use = self._remote_tmpfile()
    696         tmp_to_use = filename
    697        
    698         if batchload:
    699             cmd = 'batchload("%s");'%tmp_to_use
    700         else:
    701             cmd = 'batch("%s");'%tmp_to_use
    702 
    703         r = randrange(2147483647)
    704         s = str(r+1)
    705         cmd = "%s1+%s;\n"%(cmd,r)
    706 
    707         self._sendline(cmd)
    708         self._expect_expr(s)
    709         out = self._before()
    710         self._error_check(str, out)
    711         os.unlink(filename)
    712         return out
    713 
    714     def _error_check(self, str, out):
    715         r = self._error_re
    716         m = r.search(out)
    717         if not m is None:
    718             self._error_msg(str, out)
    719            
    720     def _error_msg(self, str, out):
    721         raise TypeError, "Error executing code in Maxima\nCODE:\n\t%s\nMaxima ERROR:\n\t%s"%(str, out.replace('-- an error.  To debug this try debugmode(true);',''))
    722 
    723672    def _eval_line(self, line, allow_use_file=False,
    724673                   wait_for_prompt=True, reformat=True, error_check=True):
    725674        """
     
    846795            self._crash_msg()
    847796            self.quit()
    848797
    849 
    850     ###########################################
    851     # System -- change directory, etc
    852     ###########################################
    853     def chdir(self, dir):
    854         """
    855         Change Maxima's current working directory.
    856        
    857         EXAMPLES::
    858        
    859             sage: maxima.chdir('/')
    860         """
    861         self.lisp('(ext::cd "%s")'%dir)
    862 
    863798    ###########################################
    864799    # Direct access to underlying lisp interpreter.
    865800    ###########################################
     
    919854        else:
    920855            subprocess.Popen(cmd, shell=True)
    921856
    922 
    923     def help(self, s):
    924         """
    925         EXAMPLES::
    926        
    927             sage: maxima.help('gcd')
    928             -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
    929             ...
    930         """
    931         return self._command_runner("describe", s)
    932 
    933     def example(self, s):
    934         """
    935         EXAMPLES::
    936        
    937             sage: maxima.example('arrays')
    938             a[n]:=n*a[n-1]
    939                                             a  := n a
    940                                              n       n - 1
    941             a[0]:1
    942             a[5]
    943                                                   120
    944             a[n]:=n
    945             a[6]
    946                                                    6
    947             a[4]
    948                                                   24
    949                                                  done
    950         """
    951         return self._command_runner("example", s)
    952 
    953     describe = help
    954 
    955     def demo(self, s):
    956         """
    957         EXAMPLES::
    958        
    959             sage: maxima.demo('array') # not tested
    960             batching /opt/sage/local/share/maxima/5.16.3/demo/array.dem
    961        
    962         At the _ prompt, type ';' followed by enter to get next demo
    963         subscrmap : true _
    964         """
    965         return self._command_runner("demo", s, redirect=False)
    966 
    967     def completions(self, s, verbose=True):
    968         """
    969         Return all commands that complete the command starting with the
    970         string s. This is like typing s[tab] in the Maxima interpreter.
    971        
    972         EXAMPLES::
    973        
    974             sage: sorted(maxima.completions('gc', verbose=False))
    975             ['gcd', 'gcdex', 'gcfactor', 'gcprint', 'gctime']
    976         """
    977         if verbose:
    978             print s,
    979             sys.stdout.flush()
    980         # in Maxima 5.19.1, apropos returns all commands that contain
    981         # the given string, instead of all commands that start with
    982         # the given string
    983         cmd_list = self._eval_line('apropos("%s")'%s, error_check=False).replace('\\ - ','-')
    984         cmd_list = [x for x in cmd_list[1:-1].split(',') if x[0] != '?']
    985         return [x for x in cmd_list if x.find(s) == 0]
    986 
    987     def _commands(self, verbose=True):
    988         """
    989         Return list of all commands defined in Maxima.
    990        
    991         EXAMPLES::
    992        
    993             sage: sorted(maxima._commands(verbose=False))
    994             ['Alpha',
    995              'Beta',
    996              ...
    997              'zunderflow']
    998         """
    999         try:
    1000             return self.__commands
    1001         except AttributeError:
    1002             self.__commands = sum(
    1003                 [self.completions(chr(65+n), verbose=verbose)+
    1004                  self.completions(chr(97+n), verbose=verbose)
    1005                  for n in range(26)], [])
    1006         return self.__commands
    1007 
    1008     def trait_names(self, verbose=True, use_disk_cache=True):
    1009         """
    1010         Return all Maxima commands, which is useful for tab completion.
    1011        
    1012         EXAMPLES::
    1013        
    1014             sage: t = maxima.trait_names(verbose=False)
    1015             sage: 'gcd' in t
    1016             True
    1017             sage: len(t)    # random output
    1018             1840
    1019         """
    1020         try:
    1021             return self.__trait_names
    1022         except AttributeError:
    1023             import sage.misc.persist
    1024             if use_disk_cache:
    1025                 try:
    1026                     self.__trait_names = sage.misc.persist.load(COMMANDS_CACHE)
    1027                     return self.__trait_names
    1028                 except IOError:
    1029                     pass
    1030             if verbose:
    1031                 print "\nBuilding Maxima command completion list (this takes"
    1032                 print "a few seconds only the first time you do it)."
    1033                 print "To force rebuild later, delete %s."%COMMANDS_CACHE
    1034             v = self._commands(verbose=verbose)
    1035             if verbose:
    1036                 print "\nDone!"
    1037             self.__trait_names = v
    1038             sage.misc.persist.save(v, COMMANDS_CACHE)
    1039             return v
    1040 
    1041857    def _object_class(self):
    1042858        """
    1043859        Return the Python class of Maxima elements.
     
    1045861        EXAMPLES::
    1046862       
    1047863            sage: maxima._object_class()
    1048             <class 'sage.interfaces.maxima.MaximaElement'>
     864            <class 'sage.interfaces.maxima_abstract.MaximaElement'>
    1049865        """
    1050866        return MaximaElement
    1051867
     
    1054870        EXAMPLES::
    1055871       
    1056872            sage: maxima._function_element_class()
    1057             <class 'sage.interfaces.maxima.MaximaFunctionElement'>
     873            <class 'sage.interfaces.maxima_abstract.MaximaFunctionElement'>
    1058874        """
    1059875        return MaximaFunctionElement
    1060876
    1061     def _true_symbol(self):
    1062         """
    1063         Return the true symbol in Maxima.
    1064        
    1065         EXAMPLES::
    1066        
    1067             sage: maxima._true_symbol()
    1068             'true'
    1069             sage: maxima.eval('is(2 = 2)')
    1070             'true'
    1071         """
    1072         return 'true'
    1073 
    1074     def _false_symbol(self):
    1075         """
    1076         Return the false symbol in Maxima.
    1077        
    1078         EXAMPLES::
    1079        
    1080             sage: maxima._false_symbol()
    1081             'false'
    1082             sage: maxima.eval('is(2 = 4)')
    1083             'false'
    1084         """
    1085         return 'false'
    1086 
    1087     def _equality_symbol(self):
    1088         """
    1089         Returns the equality symbol in Maxima.
    1090 
    1091         EXAMPLES::
    1092 
    1093              sage: maxima._equality_symbol()
    1094              '='
    1095         """
    1096         return '='
    1097 
    1098     def _inequality_symbol(self):
    1099         """
    1100         Returns the equality symbol in Maxima.
    1101 
    1102         EXAMPLES::
    1103 
    1104              sage: maxima._inequality_symbol()
    1105              '#'
    1106              sage: maxima((x != 1))
    1107              x#1
    1108         """
    1109         return '#'
    1110 
    1111877    def function(self, args, defn, rep=None, latex=None):
    1112878        """
    1113879        Return the Maxima function with given arguments and definition.
     
    1233999        """
    12341000        s = self._eval_line('%s;'%var)
    12351001        return s
    1236        
    1237     def console(self):
    1238         r"""
    1239         Start the interactive Maxima console. This is a completely separate
    1240         maxima session from this interface. To interact with this session,
    1241         you should instead use ``maxima.interact()``.
    1242        
    1243         EXAMPLES::
    1244        
    1245             sage: maxima.console()             # not tested (since we can't)
    1246             Maxima 5.13.0 http://maxima.sourceforge.net
    1247             Using Lisp CLISP 2.41 (2006-10-13)
    1248             Distributed under the GNU Public License. See the file COPYING.
    1249             Dedicated to the memory of William Schelter.
    1250             This is a development version of Maxima. The function bug_report()
    1251             provides bug reporting information.
    1252             (%i1)
    1253        
    1254         ::
    1255        
    1256             sage: maxima.interact()     # this is not tested either
    1257               --> Switching to Maxima <--
    1258             maxima: 2+2
    1259             4
    1260             maxima:
    1261               --> Exiting back to Sage <--
    1262         """
    1263         maxima_console()
    12641002   
    12651003    def version(self):
    12661004        """
     
    12731011        """
    12741012        return maxima_version()
    12751013
    1276     def cputime(self, t=None):
    1277         r"""
    1278         Returns the amount of CPU time that this Maxima session has used.
    1279         If \var{t} is not None, then it returns the difference between
    1280         the current CPU time and \var{t}.
    1281        
    1282         EXAMPLES:
    1283             sage: t = maxima.cputime()
    1284             sage: _ = maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
    1285             sage: maxima.cputime(t) # output random
    1286             0.568913
    1287         """
    1288         if t:
    1289             return float(self.eval('elapsed_run_time()')) - t
    1290         else:
    1291             return float(self.eval('elapsed_run_time()'))
    1292 
    12931014
    12941015##     def display2d(self, flag=True):
    12951016##         """
     
    13131034##         """
    13141035##         self._display2d = bool(flag)
    13151036
    1316     def plot2d(self, *args):
    1317         r"""
    1318         Plot a 2d graph using Maxima / gnuplot.
    1319        
    1320         maxima.plot2d(f, '[var, min, max]', options)
    1321        
    1322         INPUT:
    1323        
    1324        
    1325         -  ``f`` - a string representing a function (such as
    1326            f="sin(x)") [var, xmin, xmax]
    1327        
    1328         -  ``options`` - an optional string representing plot2d
    1329            options in gnuplot format
    1330        
    1331        
    1332         EXAMPLES::
    1333        
    1334             sage: maxima.plot2d('sin(x)','[x,-5,5]')   # not tested
    1335             sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
    1336             sage: maxima.plot2d('sin(x)','[x,-5,5]',opts)    # not tested
    1337        
    1338         The eps file is saved in the current directory.
    1339         """
    1340         self('plot2d(%s)'%(','.join([str(x) for x in args])))
    1341 
    1342     def plot2d_parametric(self, r, var, trange, nticks=50, options=None):
    1343         r"""
    1344         Plots r = [x(t), y(t)] for t = tmin...tmax using gnuplot with
    1345         options
    1346        
    1347         INPUT:
    1348        
    1349        
    1350         -  ``r`` - a string representing a function (such as
    1351            r="[x(t),y(t)]")
    1352        
    1353         -  ``var`` - a string representing the variable (such
    1354            as var = "t")
    1355        
    1356         -  ``trange`` - [tmin, tmax] are numbers with tmintmax
    1357        
    1358         -  ``nticks`` - int (default: 50)
    1359        
    1360         -  ``options`` - an optional string representing plot2d
    1361            options in gnuplot format
    1362        
    1363        
    1364         EXAMPLES::
    1365        
    1366             sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t",[-3.1,3.1])   # not tested
    1367        
    1368         ::
    1369        
    1370             sage: opts = '[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "circle-plot.eps"]'
    1371             sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t", [-3.1,3.1], options=opts)   # not tested
    1372        
    1373         The eps file is saved to the current working directory.
    1374        
    1375         Here is another fun plot::
    1376        
    1377             sage: maxima.plot2d_parametric(["sin(5*t)","cos(11*t)"], "t", [0,2*pi()], nticks=400)    # not tested
    1378         """
    1379         tmin = trange[0]
    1380         tmax = trange[1]
    1381         cmd = "plot2d([parametric, %s, %s, [%s, %s, %s], [nticks, %s]]"%( \
    1382                    r[0], r[1], var, tmin, tmax, nticks)
    1383         if options is None:
    1384             cmd += ")"
    1385         else:
    1386             cmd += ", %s)"%options
    1387         self(cmd)
    1388 
    1389     def plot3d(self, *args):
    1390         r"""
    1391         Plot a 3d graph using Maxima / gnuplot.
    1392        
    1393         maxima.plot3d(f, '[x, xmin, xmax]', '[y, ymin, ymax]', '[grid, nx,
    1394         ny]', options)
    1395        
    1396         INPUT:
    1397        
    1398        
    1399         -  ``f`` - a string representing a function (such as
    1400            f="sin(x)") [var, min, max]
    1401        
    1402        
    1403         EXAMPLES::
    1404        
    1405             sage: maxima.plot3d('1 + x^3 - y^2', '[x,-2,2]', '[y,-2,2]', '[grid,12,12]')    # not tested
    1406             sage: maxima.plot3d('sin(x)*cos(y)', '[x,-2,2]', '[y,-2,2]', '[grid,30,30]')   # not tested
    1407             sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
    1408             sage: maxima.plot3d('sin(x+y)', '[x,-5,5]', '[y,-1,1]', opts)    # not tested
    1409        
    1410         The eps file is saved in the current working directory.
    1411         """
    1412         self('plot3d(%s)'%(','.join([str(x) for x in args])))
    1413 
    1414     def plot3d_parametric(self, r, vars, urange, vrange, options=None):
    1415         r"""
    1416         Plot a 3d parametric graph with r=(x,y,z), x = x(u,v), y = y(u,v),
    1417         z = z(u,v), for u = umin...umax, v = vmin...vmax using gnuplot with
    1418         options.
    1419        
    1420         INPUT:
    1421        
    1422        
    1423         -  ``x, y, z`` - a string representing a function (such
    1424            as ``x="u2+v2"``, ...) vars is a list or two strings
    1425            representing variables (such as vars = ["u","v"])
    1426        
    1427         -  ``urange`` - [umin, umax]
    1428        
    1429         -  ``vrange`` - [vmin, vmax] are lists of numbers with
    1430            umin umax, vmin vmax
    1431        
    1432         -  ``options`` - optional string representing plot2d
    1433            options in gnuplot format
    1434        
    1435        
    1436         OUTPUT: displays a plot on screen or saves to a file
    1437        
    1438         EXAMPLES::
    1439        
    1440             sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3])     # not tested
    1441             sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-cos-plot.eps"]'
    1442             sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3],opts)      # not tested
    1443        
    1444         The eps file is saved in the current working directory.
    1445        
    1446         Here is a torus::
    1447        
    1448             sage: _ = maxima.eval("expr_1: cos(y)*(10.0+6*cos(x)); expr_2: sin(y)*(10.0+6*cos(x)); expr_3: -6*sin(x);")  # optional
    1449             sage: maxima.plot3d_parametric(["expr_1","expr_2","expr_3"], ["x","y"],[0,6],[0,6])   # not tested
    1450        
    1451         Here is a Mobius strip::
    1452        
    1453             sage: x = "cos(u)*(3 + v*cos(u/2))"
    1454             sage: y = "sin(u)*(3 + v*cos(u/2))"
    1455             sage: z = "v*sin(u/2)"
    1456             sage: maxima.plot3d_parametric([x,y,z],["u","v"],[-3.1,3.2],[-1/10,1/10])   # not tested
    1457         """
    1458         umin = urange[0]
    1459         umax = urange[1]
    1460         vmin = vrange[0]
    1461         vmax = vrange[1]
    1462         cmd = 'plot3d([%s, %s, %s], [%s, %s, %s], [%s, %s, %s]'%(
    1463             r[0], r[1], r[2], vars[0], umin, umax, vars[1], vmin, vmax)
    1464         if options is None:
    1465             cmd += ')'
    1466         else:
    1467             cmd += ', %s)'%options
    1468         maxima(cmd)
    1469 
    1470     def de_solve(maxima, de, vars, ics=None):
    1471         """
    1472         Solves a 1st or 2nd order ordinary differential equation (ODE) in
    1473         two variables, possibly with initial conditions.
    1474        
    1475         INPUT:
    1476        
    1477        
    1478         -  ``de`` - a string representing the ODE
    1479        
    1480         -  ``vars`` - a list of strings representing the two
    1481            variables.
    1482        
    1483         -  ``ics`` - a triple of numbers [a,b1,b2] representing
    1484            y(a)=b1, y'(a)=b2
    1485        
    1486        
    1487         EXAMPLES::
    1488        
    1489             sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
    1490             y=3*x-2*%e^(x-1)
    1491             sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'])
    1492             y=%k1*%e^x+%k2*%e^-x+3*x
    1493             sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'])
    1494             y=(%c-3*(-x-1)*%e^-x)*%e^x
    1495             sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'],[1,1])
    1496             y=-%e^-1*(5*%e^x-3*%e*x-3*%e)
    1497         """
    1498         if not isinstance(vars, str):
    1499             str_vars = '%s, %s'%(vars[1], vars[0])
    1500         else:
    1501             str_vars = vars
    1502         maxima.eval('depends(%s)'%str_vars)
    1503         m = maxima(de)
    1504         a = 'ode2(%s, %s)'%(m.name(), str_vars)
    1505         if ics != None:
    1506             if len(ics) == 3:
    1507                 cmd = "ic2("+a+",%s=%s,%s=%s,diff(%s,%s)=%s);"%(vars[0],ics[0], vars[1],ics[1], vars[1], vars[0], ics[2])
    1508                 return maxima(cmd)
    1509             if len(ics) == 2:
    1510                 return maxima("ic1("+a+",%s=%s,%s=%s);"%(vars[0],ics[0], vars[1],ics[1]))
    1511         return maxima(a+";")
    1512 
    1513     def de_solve_laplace(self, de, vars, ics=None):
    1514         """
    1515         Solves an ordinary differential equation (ODE) using Laplace
    1516         transforms.
    1517        
    1518         INPUT:
    1519        
    1520        
    1521         -  ``de`` - a string representing the ODE (e.g., de =
    1522            "diff(f(x),x,2)=diff(f(x),x)+sin(x)")
    1523        
    1524         -  ``vars`` - a list of strings representing the
    1525            variables (e.g., vars = ["x","f"])
    1526        
    1527         -  ``ics`` - a list of numbers representing initial
    1528            conditions, with symbols allowed which are represented by strings
    1529            (eg, f(0)=1, f'(0)=2 is ics = [0,1,2])
    1530        
    1531        
    1532         EXAMPLES::
    1533        
    1534             sage: maxima.clear('x'); maxima.clear('f')
    1535             sage: maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"], [0,1,2])
    1536             f(x)=x*%e^x+%e^x
    1537        
    1538         ::
    1539        
    1540             sage: maxima.clear('x'); maxima.clear('f')           
    1541             sage: f = maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"])
    1542             sage: f
    1543             f(x)=x*%e^x*('at('diff(f(x),x,1),x=0))-f(0)*x*%e^x+f(0)*%e^x
    1544             sage: print f
    1545                                                !
    1546                                    x  d        !                  x          x
    1547                         f(x) = x %e  (-- (f(x))!     ) - f(0) x %e  + f(0) %e
    1548                                       dx       !
    1549                                                !x = 0
    1550        
    1551         .. note::
    1552 
    1553            The second equation sets the values of `f(0)` and
    1554            `f'(0)` in Maxima, so subsequent ODEs involving these
    1555            variables will have these initial conditions automatically
    1556            imposed.
    1557         """
    1558         if not (ics is None):
    1559             d = len(ics)
    1560             for i in range(0,d-1):
    1561                 ic = 'atvalue(diff(%s(%s), %s, %s), %s = %s, %s)'%(
    1562                     vars[1], vars[0], vars[0], i, vars[0], ics[0], ics[1+i])
    1563                 maxima.eval(ic)
    1564         return maxima('desolve(%s, %s(%s))'%(de, vars[1], vars[0]))
    1565 
    1566     def solve_linear(self, eqns,vars):
    1567         """
    1568         Wraps maxima's linsolve.
    1569        
    1570         INPUT: eqns is a list of m strings, each representing a linear
    1571         question in m = n variables vars is a list of n strings, each
    1572         representing a variable
    1573        
    1574         EXAMPLES::
    1575        
    1576             sage: eqns = ["x + z = y","2*a*x - y = 2*a^2","y - 2*z = 2"]   
    1577             sage: vars = ["x","y","z"]                                     
    1578             sage: maxima.solve_linear(eqns, vars)
    1579             [x=a+1,y=2*a,z=a-1]
    1580         """
    1581         eqs = "["
    1582         for i in range(len(eqns)):
    1583             if i<len(eqns)-1:
    1584                 eqs = eqs + eqns[i]+","
    1585             if  i==len(eqns)-1:
    1586                 eqs = eqs + eqns[i]+"]"
    1587         vrs = "["
    1588         for i in range(len(vars)):
    1589             if i<len(vars)-1:
    1590                 vrs = vrs + vars[i]+","
    1591             if  i==len(vars)-1:
    1592                 vrs = vrs + vars[i]+"]"
    1593         return self('linsolve(%s, %s)'%(eqs, vrs))
    1594 
    1595     def unit_quadratic_integer(self, n):
    1596         r"""
    1597         Finds a unit of the ring of integers of the quadratic number field
    1598         `\QQ(\sqrt{n})`, `n>1`, using the qunit maxima
    1599         command.
    1600        
    1601         EXAMPLES::
    1602        
    1603             sage: u = maxima.unit_quadratic_integer(101); u     
    1604             a + 10
    1605             sage: u.parent()                                       
    1606             Number Field in a with defining polynomial x^2 - 101
    1607             sage: u = maxima.unit_quadratic_integer(13)           
    1608             sage: u                                               
    1609             5*a + 18
    1610             sage: u.parent()                                       
    1611             Number Field in a with defining polynomial x^2 - 13
    1612         """
    1613         from sage.rings.all import QuadraticField, Integer
    1614         # Take square-free part so sqrt(n) doesn't get simplified further by maxima
    1615         # (The original version of this function would yield wrong answers if
    1616         # n is not squarefree.)
    1617         n = Integer(n).squarefree_part() 
    1618         if n < 1:
    1619             raise ValueError, "n (=%s) must be >= 1"%n
    1620         s = repr(self('qunit(%s)'%n)).lower()
    1621         r = re.compile('sqrt\(.*\)')
    1622         s = r.sub('a', s)
    1623         a = QuadraticField(n, 'a').gen()
    1624         return eval(s)
    1625 
    1626     def plot_list(self, ptsx, ptsy, options=None):
    1627         r"""
    1628         Plots a curve determined by a sequence of points.
    1629        
    1630         INPUT:
    1631        
    1632        
    1633         -  ``ptsx`` - [x1,...,xn], where the xi and yi are
    1634            real,
    1635        
    1636         -  ``ptsy`` - [y1,...,yn]
    1637        
    1638         -  ``options`` - a string representing maxima plot2d
    1639            options.
    1640        
    1641        
    1642         The points are (x1,y1), (x2,y2), etc.
    1643        
    1644         This function requires maxima 5.9.2 or newer.
    1645        
    1646         .. note::
    1647 
    1648            More that 150 points can sometimes lead to the program
    1649            hanging. Why?
    1650        
    1651         EXAMPLES::
    1652        
    1653             sage: zeta_ptsx = [ (pari(1/2 + i*I/10).zeta().real()).precision(1) for i in range (70,150)] 
    1654             sage: zeta_ptsy = [ (pari(1/2 + i*I/10).zeta().imag()).precision(1) for i in range (70,150)] 
    1655             sage: maxima.plot_list(zeta_ptsx, zeta_ptsy)         # not tested
    1656             sage: opts='[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "zeta.eps"]'
    1657             sage: maxima.plot_list(zeta_ptsx, zeta_ptsy, opts)      # not tested
    1658         """
    1659         cmd = 'plot2d([discrete,%s, %s]'%(ptsx, ptsy)
    1660         if options is None:
    1661             cmd += ')'
    1662         else:
    1663             cmd += ', %s)'%options
    1664         self(cmd)
    1665        
    1666 
    1667     def plot_multilist(self, pts_list, options=None):
    1668         r"""
    1669         Plots a list of list of points pts_list=[pts1,pts2,...,ptsn],
    1670         where each ptsi is of the form [[x1,y1],...,[xn,yn]] x's must be
    1671         integers and y's reals options is a string representing maxima
    1672         plot2d options.
    1673        
    1674         Requires maxima 5.9.2 at least.
    1675 
    1676         .. note::
    1677 
    1678            More that 150 points can sometimes lead to the program
    1679            hanging.
    1680        
    1681         EXAMPLES::
    1682        
    1683             sage: xx = [ i/10.0 for i in range (-10,10)]
    1684             sage: yy = [ i/10.0 for i in range (-10,10)]
    1685             sage: x0 = [ 0 for i in range (-10,10)]
    1686             sage: y0 = [ 0 for i in range (-10,10)]
    1687             sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10)]
    1688             sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10)]
    1689             sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])       # not tested
    1690             sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10,150)]
    1691             sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10,150)]
    1692             sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])      # not tested
    1693             sage: opts='[gnuplot_preamble, "set nokey"]'                 
    1694             sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]],opts)    # not tested
    1695         """
    1696         n = len(pts_list)
    1697         cmd = '['
    1698         for i in range(n):
    1699             if i < n-1:
    1700                 cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+'],'
    1701             if i==n-1:
    1702                 cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+']]'
    1703         #print cmd
    1704         if options is None:
    1705             self('plot2d('+cmd+')')
    1706         else:
    1707             self('plot2d('+cmd+','+options+')')
    1708    
    1709 
    1710 class MaximaElement(ExpectElement):
    1711     def __str__(self):
    1712         """
    1713         Printing an object explicitly gives ASCII art:
    1714        
    1715         EXAMPLES::
    1716        
    1717             sage: f = maxima('1/(x-1)^3'); f
    1718             1/(x-1)^3
    1719             sage: print f
    1720                                                   1
    1721                                                --------
    1722                                                       3
    1723                                                (x - 1)
    1724         """
    1725         return self.display2d(onscreen=False)
    1726 
    1727     def bool(self):
    1728         """
    1729         EXAMPLES::
    1730        
    1731             sage: maxima(0).bool()
    1732             False
    1733             sage: maxima(1).bool()
    1734             True
    1735         """
    1736         P = self._check_valid()
    1737         return P.eval('is(%s = 0);'%self.name()) == P._false_symbol() # but be careful, since for relations things like is(equal(a,b)) are what Maxima needs
    1738 
    1739     def __cmp__(self, other):
    1740         """
    1741         EXAMPLES::
    1742        
    1743             sage: a = maxima(1); b = maxima(2)
    1744             sage: a == b
    1745             False
    1746             sage: a < b
    1747             True
    1748             sage: a > b
    1749             False
    1750             sage: b < a
    1751             False
    1752             sage: b > a
    1753             True
    1754        
    1755         We can also compare more complicated object such as functions::
    1756        
    1757             sage: f = maxima('sin(x)'); g = maxima('cos(x)')
    1758             sage: -f == g.diff('x')
    1759             True
    1760         """
    1761 
    1762         # thanks to David Joyner for telling me about using "is".
    1763         # but be careful, since for relations things like is(equal(a,b)) are what Maxima needs
    1764         P = self.parent()
    1765         try:
    1766             if P.eval("is (%s < %s)"%(self.name(), other.name())) == P._true_symbol():
    1767                 return -1
    1768             elif P.eval("is (%s > %s)"%(self.name(), other.name())) == P._true_symbol():
    1769                 return 1
    1770             elif P.eval("is (%s = %s)"%(self.name(), other.name())) == P._true_symbol():
    1771                 return 0
    1772         except TypeError:
    1773             pass
    1774         return cmp(repr(self),repr(other))
    1775                    # everything is supposed to be comparable in Python, so we define
    1776                    # the comparison thus when no comparable in interfaced system.
    1777 
    1778     def _sage_(self):
    1779         """
    1780         Attempt to make a native Sage object out of this maxima object.
    1781         This is useful for automatic coercions in addition to other
    1782         things.
    1783        
    1784         EXAMPLES::
    1785        
    1786             sage: a = maxima('sqrt(2) + 2.5'); a
    1787             sqrt(2)+2.5
    1788             sage: b = a._sage_(); b
    1789             sqrt(2) + 2.5
    1790             sage: type(b)
    1791             <type 'sage.symbolic.expression.Expression'>
    1792        
    1793         We illustrate an automatic coercion::
    1794        
    1795             sage: c = b + sqrt(3); c
    1796             sqrt(2) + sqrt(3) + 2.5
    1797             sage: type(c)
    1798             <type 'sage.symbolic.expression.Expression'>
    1799             sage: d = sqrt(3) + b; d
    1800             sqrt(2) + sqrt(3) + 2.5
    1801             sage: type(d)
    1802             <type 'sage.symbolic.expression.Expression'>           
    1803 
    1804             sage: a = sage.calculus.calculus.maxima('x^(sqrt(y)+%pi) + sin(%e + %pi)')
    1805             sage: a._sage_()
    1806             x^(pi + sqrt(y)) - sin(e)
    1807             sage: var('x, y')
    1808             (x, y)
    1809             sage: v = sage.calculus.calculus.maxima.vandermonde_matrix([x, y, 1/2])
    1810             sage: v._sage_()
    1811             [  1   x x^2]
    1812             [  1   y y^2]
    1813             [  1 1/2 1/4]
    1814 
    1815         Check if #7661 is fixed::
    1816 
    1817             sage: var('delta')
    1818             delta
    1819             sage: (2*delta).simplify()
    1820             2*delta
    1821         """
    1822         import sage.calculus.calculus as calculus
    1823         return calculus.symbolic_expression_from_maxima_string(self.name(),
    1824                 maxima=self.parent())
    1825 
    1826     def _symbolic_(self, R):
    1827         """
    1828         Return a symbolic expression equivalent to this maxima object.
    1829 
    1830         EXAMPLES::
    1831 
    1832             sage: t = sqrt(2)._maxima_()
    1833             sage: u = t._symbolic_(SR); u
    1834             sqrt(2)
    1835             sage: u.parent()
    1836             Symbolic Ring
    1837 
    1838         This is used when converting maxima objects to the Symbolic Ring::
    1839 
    1840             sage: SR(t)
    1841             sqrt(2)
    1842         """
    1843         return R(self._sage_())
    1844 
    1845     def __complex__(self):
    1846         """
    1847         EXAMPLES::
    1848        
    1849             sage: complex(maxima('sqrt(-2)+1'))
    1850             (1+1.4142135623730951j)
    1851         """
    1852         return complex(self._sage_())
    1853 
    1854     def _complex_mpfr_field_(self, C):
    1855         """
    1856         EXAMPLES::
    1857        
    1858             sage: CC(maxima('1+%i'))
    1859              1.00000000000000 + 1.00000000000000*I
    1860             sage: CC(maxima('2342.23482943872+234*%i'))
    1861              2342.23482943872 + 234.000000000000*I
    1862             sage: ComplexField(10)(maxima('2342.23482943872+234*%i'))
    1863              2300. + 230.*I
    1864             sage: ComplexField(200)(maxima('1+%i'))
    1865             1.0000000000000000000000000000000000000000000000000000000000 + 1.0000000000000000000000000000000000000000000000000000000000*I
    1866             sage: ComplexField(200)(maxima('sqrt(-2)'))
    1867             1.4142135623730950488016887242096980785696718753769480731767*I
    1868             sage: N(sqrt(-2), 200)
    1869             8.0751148893563733350506651837615871941533119425962889089783e-62 + 1.4142135623730950488016887242096980785696718753769480731767*I
    1870         """
    1871         return C(self._sage_())
    1872 
    1873     def _mpfr_(self, R):
    1874         """
    1875         EXAMPLES::
    1876        
    1877             sage: RealField(100)(maxima('sqrt(2)+1'))
    1878             2.4142135623730950488016887242
    1879         """
    1880         return R(self._sage_())
    1881 
    1882     def _complex_double_(self, C):
    1883         """
    1884         EXAMPLES::
    1885        
    1886             sage: CDF(maxima('sqrt(2)+1'))
    1887             2.41421356237
    1888         """
    1889         return C(self._sage_())
    1890 
    1891     def _real_double_(self, R):
    1892         """
    1893         EXAMPLES::
    1894        
    1895             sage: RDF(maxima('sqrt(2)+1'))
    1896             2.41421356237
    1897         """
    1898         return R(self._sage_())
    1899 
    1900     def real(self):
    1901         """
    1902         Return the real part of this maxima element.
    1903        
    1904         EXAMPLES::
    1905        
    1906             sage: maxima('2 + (2/3)*%i').real()
    1907             2
    1908         """
    1909         return self.realpart()
    1910 
    1911     def imag(self):
    1912         """
    1913         Return the imaginary part of this maxima element.
    1914        
    1915         EXAMPLES::
    1916        
    1917             sage: maxima('2 + (2/3)*%i').imag()
    1918             2/3
    1919         """
    1920         return self.imagpart()
    1921 
    1922     def numer(self):
    1923         """
    1924         Return numerical approximation to self as a Maxima object.
    1925        
    1926         EXAMPLES::
    1927        
    1928             sage: a = maxima('sqrt(2)').numer(); a
    1929             1.41421356237309...
    1930             sage: type(a)
    1931             <class 'sage.interfaces.maxima.MaximaElement'>
    1932         """
    1933         return self.comma('numer')
    1934 
    1935     def str(self):
    1936         """
    1937         Return string representation of this maxima object.
    1938        
    1939         EXAMPLES::
    1940        
    1941             sage: maxima('sqrt(2) + 1/3').str()
    1942             'sqrt(2)+1/3'
    1943         """
    1944         P = self._check_valid()
    1945         return P.get(self._name)
    1946 
    1947     def __repr__(self):
    1948         """
    1949         Return print representation of this object.
    1950        
    1951         EXAMPLES::
    1952        
    1953             sage: maxima('sqrt(2) + 1/3').__repr__()
    1954             'sqrt(2)+1/3'
    1955         """
    1956         P = self._check_valid()
    1957         try:
    1958             return self.__repr
    1959         except AttributeError:
    1960             pass
    1961         r = P.get(self._name)
    1962         self.__repr = r
    1963         return r
    1964 
    1965     def display2d(self, onscreen=True):
    1966         """
    1967         EXAMPLES::
    1968        
    1969             sage: F = maxima('x^5 - y^5').factor() 
    1970             sage: F.display2d ()             
    1971                                    4      3    2  2    3      4
    1972                        - (y - x) (y  + x y  + x  y  + x  y + x )
    1973         """
    1974         self._check_valid()
    1975         P = self.parent()
    1976         with gc_disabled():
    1977             P._eval_line('display2d : true$')
    1978             s = P._eval_line('disp(%s)$'%self.name(), reformat=False)
    1979             P._eval_line('display2d: false$')
    1980            
    1981         s = s.strip('\r\n')
    1982 
    1983         # if ever want to dedent, see
    1984         # http://mail.python.org/pipermail/python-list/2006-December/420033.html
    1985         if onscreen:
    1986             print s
    1987         else:
    1988             return s
    1989 
    1990     def diff(self, var='x', n=1):
    1991         """
    1992         Return the n-th derivative of self.
    1993        
    1994         INPUT:
    1995        
    1996        
    1997         -  ``var`` - variable (default: 'x')
    1998        
    1999         -  ``n`` - integer (default: 1)
    2000        
    2001        
    2002         OUTPUT: n-th derivative of self with respect to the variable var
    2003        
    2004         EXAMPLES::
    2005        
    2006             sage: f = maxima('x^2')                         
    2007             sage: f.diff()                                   
    2008             2*x
    2009             sage: f.diff('x')                               
    2010             2*x
    2011             sage: f.diff('x', 2)                             
    2012             2
    2013             sage: maxima('sin(x^2)').diff('x',4)
    2014             16*x^4*sin(x^2)-12*sin(x^2)-48*x^2*cos(x^2)
    2015        
    2016         ::
    2017        
    2018             sage: f = maxima('x^2 + 17*y^2')                 
    2019             sage: f.diff('x')
    2020             34*y*'diff(y,x,1)+2*x
    2021             sage: f.diff('y')                               
    2022             34*y
    2023         """
    2024         return ExpectElement.__getattr__(self, 'diff')(var, n)
    2025 
    2026     derivative = diff
    2027 
    2028     def nintegral(self, var='x', a=0, b=1,
    2029                   desired_relative_error='1e-8',
    2030                   maximum_num_subintervals=200):
    2031         r"""
    2032         Return a numerical approximation to the integral of self from a to
    2033         b.
    2034        
    2035         INPUT:
    2036        
    2037        
    2038         -  ``var`` - variable to integrate with respect to
    2039        
    2040         -  ``a`` - lower endpoint of integration
    2041        
    2042         -  ``b`` - upper endpoint of integration
    2043        
    2044         -  ``desired_relative_error`` - (default: '1e-8') the
    2045            desired relative error
    2046        
    2047         -  ``maximum_num_subintervals`` - (default: 200)
    2048            maxima number of subintervals
    2049        
    2050        
    2051         OUTPUT:
    2052        
    2053        
    2054         -  approximation to the integral
    2055        
    2056         -  estimated absolute error of the
    2057            approximation
    2058        
    2059         -  the number of integrand evaluations
    2060        
    2061         -  an error code:
    2062        
    2063             -  ``0`` - no problems were encountered
    2064 
    2065             -  ``1`` - too many subintervals were done
    2066 
    2067             -  ``2`` - excessive roundoff error
    2068 
    2069             -  ``3`` - extremely bad integrand behavior
    2070 
    2071             -  ``4`` - failed to converge
    2072 
    2073             -  ``5`` - integral is probably divergent or slowly convergent
    2074 
    2075             -  ``6`` - the input is invalid
    2076        
    2077        
    2078         EXAMPLES::
    2079        
    2080             sage: maxima('exp(-sqrt(x))').nintegral('x',0,1)
    2081             (.5284822353142306, 4.16331413788384...e-11, 231, 0)
    2082        
    2083         Note that GP also does numerical integration, and can do so to very
    2084         high precision very quickly::
    2085        
    2086             sage: gp('intnum(x=0,1,exp(-sqrt(x)))')           
    2087             0.5284822353142307136179049194             # 32-bit
    2088             0.52848223531423071361790491935415653022   # 64-bit
    2089             sage: _ = gp.set_precision(80)
    2090             sage: gp('intnum(x=0,1,exp(-sqrt(x)))')
    2091             0.52848223531423071361790491935415653021675547587292866196865279321015401702040079
    2092         """
    2093         from sage.rings.all import Integer
    2094         v = self.quad_qags(var, a, b, epsrel=desired_relative_error,
    2095                            limit=maximum_num_subintervals)
    2096         return v[0], v[1], Integer(v[2]), Integer(v[3])
    2097 
    2098     def integral(self, var='x', min=None, max=None):
    2099         r"""
    2100         Return the integral of self with respect to the variable x.
    2101        
    2102         INPUT:
    2103        
    2104        
    2105         -  ``var`` - variable
    2106        
    2107         -  ``min`` - default: None
    2108        
    2109         -  ``max`` - default: None
    2110        
    2111        
    2112         Returns the definite integral if xmin is not None, otherwise
    2113         returns an indefinite integral.
    2114        
    2115         EXAMPLES::
    2116        
    2117             sage: maxima('x^2+1').integral()                   
    2118             x^3/3+x
    2119             sage: maxima('x^2+ 1 + y^2').integral('y')         
    2120             y^3/3+x^2*y+y
    2121             sage: maxima('x / (x^2+1)').integral()             
    2122             log(x^2+1)/2
    2123             sage: maxima('1/(x^2+1)').integral()               
    2124             atan(x)
    2125             sage: maxima('1/(x^2+1)').integral('x', 0, infinity)
    2126             %pi/2
    2127             sage: maxima('x/(x^2+1)').integral('x', -1, 1)     
    2128             0
    2129        
    2130         ::
    2131        
    2132             sage: f = maxima('exp(x^2)').integral('x',0,1); f   
    2133             -sqrt(%pi)*%i*erf(%i)/2
    2134             sage: f.numer()
    2135             1.46265174590718...
    2136         """
    2137         I = ExpectElement.__getattr__(self, 'integrate')
    2138         if min is None:
    2139             return I(var)
    2140         else:
    2141             if max is None:
    2142                 raise ValueError, "neither or both of min/max must be specified."
    2143             return I(var, min, max)
    2144 
    2145     integrate = integral
    2146 
    2147     def __float__(self):
    2148         """
    2149         Return floating point version of this maxima element.
    2150        
    2151         EXAMPLES::
    2152        
    2153             sage: float(maxima("3.14"))
    2154             3.1400000000000001
    2155             sage: float(maxima("1.7e+17"))
    2156             1.7e+17
    2157             sage: float(maxima("1.7e-17"))
    2158             1.6999999999999999e-17
    2159         """
    2160         try:
    2161             return float(repr(self.numer()))
    2162         except ValueError:
    2163             raise TypeError, "unable to coerce '%s' to float"%repr(self)
    2164 
    2165     def __len__(self):
    2166         """
    2167         Return the length of a list.
    2168        
    2169         EXAMPLES::
    2170        
    2171             sage: v = maxima('create_list(x^i,i,0,5)')         
    2172             sage: len(v)                                       
    2173             6
    2174         """
    2175         P = self._check_valid()       
    2176         return int(P.eval('length(%s)'%self.name()))
    2177 
    2178     def dot(self, other):
    2179         """
    2180         Implements the notation self . other.
    2181        
    2182         EXAMPLES::
    2183        
    2184             sage: A = maxima('matrix ([a1],[a2])')
    2185             sage: B = maxima('matrix ([b1, b2])')
    2186             sage: A.dot(B)
    2187             matrix([a1*b1,a1*b2],[a2*b1,a2*b2])
    2188         """
    2189         P = self._check_valid()
    2190         Q = P(other)
    2191         return P('%s . %s'%(self.name(), Q.name()))
    2192 
    2193     def __getitem__(self, n):
    2194         r"""
    2195         Return the n-th element of this list.
    2196        
    2197         .. note::
    2198 
    2199            Lists are 0-based when accessed via the Sage interface, not
    2200            1-based as they are in the Maxima interpreter.
    2201        
    2202         EXAMPLES::
    2203        
    2204             sage: v = maxima('create_list(i*x^i,i,0,5)'); v   
    2205             [0,x,2*x^2,3*x^3,4*x^4,5*x^5]
    2206             sage: v[3]                                         
    2207             3*x^3
    2208             sage: v[0]                                           
    2209             0
    2210             sage: v[10]                                         
    2211             Traceback (most recent call last):
    2212             ...
    2213             IndexError: n = (10) must be between 0 and 5
    2214         """
    2215         n = int(n)
    2216         if n < 0 or n >= len(self):
    2217             raise IndexError, "n = (%s) must be between %s and %s"%(n, 0, len(self)-1)
    2218         # If you change the n+1 to n below, better change __iter__ as well.
    2219         return ExpectElement.__getitem__(self, n+1)
    2220 
    2221     def __iter__(self):
    2222         """
    2223         EXAMPLE::
    2224        
    2225             sage: v = maxima('create_list(i*x^i,i,0,5)')
    2226             sage: L = list(v)
    2227             sage: [e._sage_() for e in L]
    2228             [0, x, 2*x^2, 3*x^3, 4*x^4, 5*x^5]
    2229         """
    2230         for i in range(len(self)):
    2231             yield self[i]
    2232 
    2233     def subst(self, val):
    2234         """
    2235         Substitute a value or several values into this Maxima object.
    2236        
    2237         EXAMPLES::
    2238        
    2239             sage: maxima('a^2 + 3*a + b').subst('b=2')
    2240             a^2+3*a+2
    2241             sage: maxima('a^2 + 3*a + b').subst('a=17')
    2242             b+340
    2243             sage: maxima('a^2 + 3*a + b').subst('a=17, b=2')
    2244             342
    2245         """
    2246         return self.comma(val)
    2247 
    2248     def comma(self, args):
    2249         """
    2250         Form the expression that would be written 'self, args' in Maxima.
    2251        
    2252         EXAMPLES::
    2253        
    2254             sage: maxima('sqrt(2) + I').comma('numer')
    2255             I+1.41421356237309...
    2256             sage: maxima('sqrt(2) + I*a').comma('a=5')
    2257             5*I+sqrt(2)
    2258         """
    2259         self._check_valid()
    2260         P = self.parent()
    2261         return P('%s, %s'%(self.name(), args))
    2262 
    2263     def _latex_(self):
    2264         """
    2265         Return Latex representation of this Maxima object.
    2266        
    2267         This calls the tex command in Maxima, then does a little
    2268         post-processing to fix bugs in the resulting Maxima output.
    2269        
    2270         EXAMPLES::
    2271        
    2272             sage: maxima('sqrt(2) + 1/3 + asin(5)')._latex_()
    2273             '\\sin^{-1}\\cdot5+\\sqrt{2}+{{1}\\over{3}}'
    2274 
    2275             sage: y,d = var('y,d')
    2276             sage: f = function('f')
    2277             sage: latex(maxima(derivative(f(x*y*d), d,x,x,y)))
    2278             Traceback (most recent call last):
    2279             ...
    2280             NotImplementedError: arguments must be distinct variables
    2281             sage: latex(maxima(derivative(f(x,y,d), d,x,x,y)))
    2282             {{{\it \partial}^4}\over{{\it \partial}\,d\,{\it \partial}\,x^2\,  {\it \partial}\,y}}\,f\left(x , y , d\right)
    2283 
    2284             sage: latex(maxima(d/(d-2)))
    2285             {{d}\over{d-2}}
    2286         """
    2287         self._check_valid()
    2288         P = self.parent()
    2289         s = P._eval_line('tex(%s);'%self.name(), reformat=False)
    2290         if not '$$' in s:
    2291             raise RuntimeError, "Error texing maxima object."
    2292         i = s.find('$$')
    2293         j = s.rfind('$$')
    2294         s = s[i+2:j]
    2295         s = multiple_replace({'\r\n':' ',
    2296                               '\\%':'',
    2297                               '\\arcsin ':'\\sin^{-1} ',
    2298                               '\\arccos ':'\\cos^{-1} ',
    2299                               '\\arctan ':'\\tan^{-1} '}, s)
    2300 
    2301         # Fix a maxima bug, which gives a latex representation of multiplying
    2302         # two numbers as a single space. This was really bad when 2*17^(1/3)
    2303         # gets TeXed as '2 17^{\frac{1}{3}}'
    2304         #
    2305         # This regex matches a string of spaces preceded by either a '}', a
    2306         # decimal digit, or a ')', and followed by a decimal digit. The spaces
    2307         # get replaced by a '\cdot'.
    2308         s = re.sub(r'(?<=[})\d]) +(?=\d)', '\cdot', s)
    2309 
    2310         return s
    2311 
    2312     def trait_names(self, verbose=False):
    2313         """
    2314         Return all Maxima commands, which is useful for tab completion.
    2315        
    2316         EXAMPLES::
    2317        
    2318             sage: m = maxima(2)
    2319             sage: 'gcd' in m.trait_names()
    2320             True
    2321         """
    2322         return self.parent().trait_names(verbose=False)
    2323 
    2324     def _matrix_(self, R):
    2325         r"""
    2326         If self is a Maxima matrix, return the corresponding Sage matrix
    2327         over the Sage ring `R`.
    2328        
    2329         This may or may not work depending in how complicated the entries
    2330         of self are! It only works if the entries of self can be coerced as
    2331         strings to produce meaningful elements of `R`.
    2332        
    2333         EXAMPLES::
    2334        
    2335             sage: _ = maxima.eval("f[i,j] := i/j")             
    2336             sage: A = maxima('genmatrix(f,4,4)'); A             
    2337             matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
    2338             sage: A._matrix_(QQ)                               
    2339             [  1 1/2 1/3 1/4]
    2340             [  2   1 2/3 1/2]
    2341             [  3 3/2   1 3/4]
    2342             [  4   2 4/3   1]
    2343        
    2344         You can also use the ``matrix`` command (which is
    2345         defined in ``sage.misc.functional``)::
    2346        
    2347             sage: matrix(QQ, A)
    2348             [  1 1/2 1/3 1/4]
    2349             [  2   1 2/3 1/2]
    2350             [  3 3/2   1 3/4]
    2351             [  4   2 4/3   1]
    2352         """
    2353         from sage.matrix.all import MatrixSpace
    2354         self._check_valid()
    2355         P = self.parent()
    2356         nrows = int(P.eval('length(%s)'%self.name()))
    2357         if nrows == 0:
    2358             return MatrixSpace(R, 0, 0)(0)
    2359         ncols = int(P.eval('length(%s[1])'%self.name()))
    2360         M = MatrixSpace(R, nrows, ncols)
    2361         s = self.str().replace('matrix','').replace(',',"','").\
    2362             replace("]','[","','").replace('([',"['").replace('])',"']")
    2363         s = eval(s)
    2364         return M([R(x) for x in s])
    2365        
    2366     def partial_fraction_decomposition(self, var='x'):
    2367         """
    2368         Return the partial fraction decomposition of self with respect to
    2369         the variable var.
    2370        
    2371         EXAMPLES::
    2372        
    2373             sage: f = maxima('1/((1+x)*(x-1))')           
    2374             sage: f.partial_fraction_decomposition('x')   
    2375             1/(2*(x-1))-1/(2*(x+1))
    2376             sage: print f.partial_fraction_decomposition('x')
    2377                                  1           1
    2378                              --------- - ---------
    2379                              2 (x - 1)   2 (x + 1)
    2380         """
    2381         return self.partfrac(var)
    2382 
    2383     def _operation(self, operation, right):
    2384         r"""
    2385         Note that right's parent should already be Maxima since this should
    2386         be called after coercion has been performed.
    2387        
    2388         If right is a ``MaximaFunction``, then we convert
    2389         ``self`` to a ``MaximaFunction`` that takes
    2390         no arguments, and let the
    2391         ``MaximaFunction._operation`` code handle everything
    2392         from there.
    2393        
    2394         EXAMPLES::
    2395        
    2396             sage: f = maxima.cos(x)
    2397             sage: f._operation("+", f)
    2398             2*cos(x)
    2399         """
    2400         P = self._check_valid()
    2401 
    2402         if isinstance(right, MaximaFunction):
    2403             fself = P.function('', repr(self))
    2404             return fself._operation(operation, right)
    2405 
    2406         try:
    2407             return P.new('%s %s %s'%(self._name, operation, right._name))
    2408         except Exception, msg:
    2409             raise TypeError, msg
    2410 
    2411 
    2412        
    2413 class MaximaFunctionElement(FunctionElement):
    2414     def _sage_doc_(self):
    2415         """
    2416         EXAMPLES::
    2417        
    2418             sage: m = maxima(4)
    2419             sage: m.gcd._sage_doc_()
    2420             -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
    2421             ...
    2422         """
    2423         return self._obj.parent().help(self._name)
    2424 
    2425 class MaximaExpectFunction(ExpectFunction):
    2426     def _sage_doc_(self):
    2427         """
    2428         EXAMPLES::
    2429        
    2430             sage: maxima.gcd._sage_doc_()
    2431             -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
    2432             ...
    2433         """
    2434         M = self._parent
    2435         return M.help(self._name)
    2436 
    2437 
    2438 class MaximaFunction(MaximaElement):
    2439     def __init__(self, parent, name, defn, args, latex):
    2440         """
    2441         EXAMPLES::
    2442        
    2443             sage: f = maxima.function('x,y','sin(x+y)')
    2444             sage: f == loads(dumps(f))
    2445             True
    2446         """
    2447         MaximaElement.__init__(self, parent, name, is_name=True)
    2448         self.__defn = defn
    2449         self.__args = args
    2450         self.__latex = latex
    2451 
    2452     def __reduce__(self):
    2453         """
    2454         EXAMPLES::
    2455        
    2456             sage: f = maxima.function('x,y','sin(x+y)')
    2457             sage: f.__reduce__()
    2458             (<function reduce_load_Maxima_function at 0x...>,
    2459              (Maxima, 'sin(x+y)', 'x,y', None))
    2460         """
    2461         return reduce_load_Maxima_function, (self.parent(), self.__defn, self.__args, self.__latex)
    2462        
    2463     def __call__(self, *x):
    2464         """
    2465         EXAMPLES::
    2466        
    2467             sage: f = maxima.function('x,y','sin(x+y)')
    2468             sage: f(1,2)
    2469             sin(3)
    2470             sage: f(x,x)
    2471             sin(2*x)
    2472         """
    2473         P = self._check_valid()
    2474         if len(x) == 1:
    2475             x = '(%s)'%x
    2476         return P('%s%s'%(self.name(), x))
    2477 
    2478     def __repr__(self):
    2479         """
    2480         EXAMPLES::
    2481        
    2482             sage: f = maxima.function('x,y','sin(x+y)')
    2483             sage: repr(f)
    2484             'sin(x+y)'
    2485         """
    2486         return self.definition()
    2487 
    2488     def _latex_(self):
    2489         """
    2490         EXAMPLES::
    2491        
    2492             sage: f = maxima.function('x,y','sin(x+y)')
    2493             sage: latex(f)
    2494             \mathrm{sin(x+y)}
    2495         """
    2496         if self.__latex is None:
    2497             return r'\mathrm{%s}'%self.__defn
    2498         else:
    2499             return self.__latex
    2500 
    2501     def arguments(self, split=True):
    2502         r"""
    2503         Returns the arguments of this Maxima function.
    2504        
    2505         EXAMPLES::
    2506        
    2507             sage: f = maxima.function('x,y','sin(x+y)')
    2508             sage: f.arguments()
    2509             ['x', 'y']
    2510             sage: f.arguments(split=False)
    2511             'x,y'
    2512             sage: f = maxima.function('', 'sin(x)')
    2513             sage: f.arguments()
    2514             []
    2515         """
    2516         if split:
    2517             return self.__args.split(',') if self.__args != '' else []
    2518         else:
    2519             return self.__args
    2520 
    2521     def definition(self):
    2522         """
    2523         Returns the definition of this Maxima function as a string.
    2524        
    2525         EXAMPLES::
    2526        
    2527             sage: f = maxima.function('x,y','sin(x+y)')
    2528             sage: f.definition()
    2529             'sin(x+y)'
    2530         """
    2531         return self.__defn
    2532 
    2533     def integral(self, var):
    2534         """
    2535         Returns the integral of self with respect to the variable var.
    2536        
    2537         Note that integrate is an alias of integral.
    2538        
    2539         EXAMPLES::
    2540        
    2541             sage: x,y = var('x,y')
    2542             sage: f = maxima.function('x','sin(x)')
    2543             sage: f.integral(x)
    2544             -cos(x)
    2545             sage: f.integral(y)
    2546             sin(x)*y
    2547         """
    2548         var = str(var)
    2549         P = self._check_valid()
    2550         f = P('integrate(%s(%s), %s)'%(self.name(), self.arguments(split=False), var))
    2551 
    2552         args = self.arguments()
    2553         if var not in args:
    2554             args.append(var)
    2555         return P.function(",".join(args), repr(f))
    2556 
    2557     integrate = integral
    2558 
    2559     def _operation(self, operation, f=None):
    2560         r"""
    2561         This is a utility function which factors out much of the
    2562         commonality used in the arithmetic operations for
    2563         ``MaximaFunctions``.
    2564        
    2565         INPUT:
    2566        
    2567        
    2568         -  ``operation`` - A string representing the operation
    2569            being performed. For example, '\*', or '1/'.
    2570        
    2571         -  ``f`` - The other operand. If f is
    2572            ``None``, than the operation is assumed to be unary
    2573            rather than binary.
    2574        
    2575        
    2576         EXAMPLES::
    2577        
    2578             sage: f = maxima.function('x,y','sin(x+y)')
    2579             sage: f._operation("+", f)
    2580             2*sin(y+x)
    2581             sage: f._operation("+", 2)
    2582             sin(y+x)+2
    2583             sage: f._operation('-')
    2584             -sin(y+x)
    2585             sage: f._operation('1/')
    2586             1/sin(y+x)
    2587         """
    2588         P = self._check_valid()
    2589         if isinstance(f, MaximaFunction):
    2590             tmp = list(sorted(set(self.arguments() + f.arguments())))
    2591             args = ','.join(tmp)
    2592             defn = "(%s)%s(%s)"%(self.definition(), operation, f.definition())
    2593         elif f is None:
    2594             args = self.arguments(split=False)
    2595             defn = "%s(%s)"%(operation, self.definition())
    2596         else:
    2597             args = self.arguments(split=False)
    2598             defn = "(%s)%s(%s)"%(self.definition(), operation, repr(f))
    2599 
    2600         return P.function(args,P.eval(defn))
    2601 
    2602     def _add_(self, f):
    2603         """
    2604         MaximaFunction as left summand.
    2605        
    2606         EXAMPLES::
    2607        
    2608             sage: x,y = var('x,y')
    2609             sage: f = maxima.function('x','sin(x)')
    2610             sage: g = maxima.function('x','-cos(x)')
    2611             sage: f+g
    2612             sin(x)-cos(x)
    2613             sage: f+3
    2614             sin(x)+3
    2615        
    2616         ::
    2617        
    2618             sage: (f+maxima.cos(x))(2)
    2619             sin(2)+cos(2)
    2620             sage: (f+maxima.cos(y)) # This is a function with only ONE argument!
    2621             cos(y)+sin(x) 
    2622             sage: (f+maxima.cos(y))(2)
    2623             cos(y)+sin(2)
    2624        
    2625         ::
    2626        
    2627             sage: f = maxima.function('x','sin(x)')
    2628             sage: g = -maxima.cos(x)
    2629             sage: g+f
    2630             sin(x)-cos(x)
    2631             sage: (g+f)(2) # The sum IS a function
    2632             sin(2)-cos(2) 
    2633             sage: 2+f
    2634             sin(x)+2
    2635         """
    2636         return self._operation("+", f)
    2637 
    2638     def _sub_(self, f):
    2639         r"""
    2640         ``MaximaFunction`` as minuend.
    2641        
    2642         EXAMPLES::
    2643        
    2644             sage: x,y = var('x,y')
    2645             sage: f = maxima.function('x','sin(x)')
    2646             sage: g = -maxima.cos(x) # not a function
    2647             sage: f-g
    2648             sin(x)+cos(x)
    2649             sage: (f-g)(2)
    2650             sin(2)+cos(2)
    2651             sage: (f-maxima.cos(y)) # This function only has the argument x!
    2652             sin(x)-cos(y)
    2653             sage: _(2)
    2654             sin(2)-cos(y)
    2655        
    2656         ::
    2657        
    2658             sage: g-f
    2659             -sin(x)-cos(x)
    2660         """
    2661         return self._operation("-", f)
    2662        
    2663     def _mul_(self, f):
    2664         r"""
    2665         ``MaximaFunction`` as left factor.
    2666        
    2667         EXAMPLES::
    2668        
    2669             sage: f = maxima.function('x','sin(x)')
    2670             sage: g = maxima('-cos(x)') # not a function!
    2671             sage: f*g
    2672             -cos(x)*sin(x)
    2673             sage: _(2)
    2674             -cos(2)*sin(2)
    2675        
    2676         ::
    2677        
    2678             sage: f = maxima.function('x','sin(x)')
    2679             sage: g = maxima('-cos(x)')
    2680             sage: g*f
    2681             -cos(x)*sin(x)
    2682             sage: _(2)
    2683             -cos(2)*sin(2)
    2684             sage: 2*f
    2685             2*sin(x)
    2686         """
    2687         return self._operation("*", f)
    2688 
    2689     def _div_(self, f):
    2690         r"""
    2691         ``MaximaFunction`` as dividend.
    2692        
    2693         EXAMPLES::
    2694        
    2695             sage: f=maxima.function('x','sin(x)')
    2696             sage: g=maxima('-cos(x)')
    2697             sage: f/g
    2698             -sin(x)/cos(x)
    2699             sage: _(2)
    2700             -sin(2)/cos(2)
    2701        
    2702         ::
    2703        
    2704             sage: f=maxima.function('x','sin(x)')
    2705             sage: g=maxima('-cos(x)')
    2706             sage: g/f
    2707             -cos(x)/sin(x)
    2708             sage: _(2)
    2709             -cos(2)/sin(2)
    2710             sage: 2/f
    2711             2/sin(x)
    2712         """
    2713         return self._operation("/", f)
    2714 
    2715     def __neg__(self):
    2716         r"""
    2717         Additive inverse of a ``MaximaFunction``.
    2718        
    2719         EXAMPLES::
    2720        
    2721             sage: f=maxima.function('x','sin(x)')
    2722             sage: -f
    2723             -sin(x)
    2724         """
    2725         return self._operation('-')
    2726 
    2727     def __inv__(self):
    2728         r"""
    2729         Multiplicative inverse of a ``MaximaFunction``.
    2730        
    2731         EXAMPLES::
    2732        
    2733             sage: f = maxima.function('x','sin(x)')
    2734             sage: ~f
    2735             1/sin(x)
    2736         """
    2737         return self._operation('1/')
    2738 
    2739     def __pow__(self,f):
    2740         r"""
    2741         ``MaximaFunction`` raised to some power.
    2742        
    2743         EXAMPLES::
    2744        
    2745             sage: f=maxima.function('x','sin(x)')
    2746             sage: g=maxima('-cos(x)')
    2747             sage: f^g
    2748             1/sin(x)^cos(x)
    2749        
    2750         ::
    2751        
    2752             sage: f=maxima.function('x','sin(x)')
    2753             sage: g=maxima('-cos(x)') # not a function
    2754             sage: g^f
    2755             (-cos(x))^sin(x)
    2756         """
    2757         return self._operation("^", f)
    2758 
    2759 
    27601037def is_MaximaElement(x):
    27611038    """
    27621039    Returns True if x is of type MaximaElement.
     
    27861063    """
    27871064    return maxima
    27881065
    2789 def reduce_load_Maxima_function(parent, defn, args, latex):
    2790     return parent.function(args, defn, defn, latex)
    2791    
    2792 
    2793 import os
    2794 def maxima_console():
    2795     """
    2796     Spawn a new Maxima command-line session.
    2797    
    2798     EXAMPLES::
    2799    
    2800         sage: from sage.interfaces.maxima import maxima_console
    2801         sage: maxima_console()                    # not tested
    2802         Maxima 5.23.2 http://maxima.sourceforge.net
    2803         ...
    2804     """
    2805     os.system('maxima')
    28061066
    28071067def maxima_version():
    28081068    """
  • new file sage/interfaces/maxima_abstract.py

    diff -r c34921fb270b -r fee8c73d93a2 sage/interfaces/maxima_abstract.py
    - +  
     1r"""
     2Interface to Maxima
     3
     4Maxima is a free GPL'd general purpose computer algebra system
     5whose development started in 1968 at MIT. It contains symbolic
     6manipulation algorithms, as well as implementations of special
     7functions, including elliptic functions and generalized
     8hypergeometric functions. Moreover, Maxima has implementations of
     9many functions relating to the invariant theory of the symmetric
     10group `S_n`. (However, the commands for group invariants,
     11and the corresponding Maxima documentation, are in French.) For many
     12links to Maxima documentation see
     13http://maxima.sourceforge.net/docs.shtml/.
     14
     15AUTHORS:
     16
     17- William Stein (2005-12): Initial version
     18
     19- David Joyner: Improved documentation
     20
     21- William Stein (2006-01-08): Fixed bug in parsing
     22
     23- William Stein (2006-02-22): comparisons (following suggestion of
     24  David Joyner)
     25
     26- William Stein (2006-02-24): *greatly* improved robustness by adding
     27  sequence numbers to IO bracketing in _eval_line
     28
     29If the string "error" (case insensitive) occurs in the output of
     30anything from Maxima, a RuntimeError exception is raised.
     31
     32EXAMPLES: We evaluate a very simple expression in Maxima.
     33
     34::
     35
     36    sage: maxima('3 * 5')
     37    15
     38
     39We factor `x^5 - y^5` in Maxima in several different ways.
     40The first way yields a Maxima object.
     41
     42::
     43
     44    sage: F = maxima.factor('x^5 - y^5')
     45    sage: F
     46    -(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)
     47    sage: type(F)
     48    <class 'sage.interfaces.maxima_abstract.MaximaElement'>
     49
     50Note that Maxima objects can also be displayed using "ASCII art";
     51to see a normal linear representation of any Maxima object x. Just
     52use the print command: use ``str(x)``.
     53
     54::
     55
     56    sage: print F
     57                               4      3    2  2    3      4
     58                   - (y - x) (y  + x y  + x  y  + x  y + x )
     59
     60You can always use ``repr(x)`` to obtain the linear
     61representation of an object. This can be useful for moving maxima
     62data to other systems.
     63
     64::
     65
     66    sage: repr(F)
     67    '-(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)'
     68    sage: F.str()
     69    '-(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)'
     70
     71The ``maxima.eval`` command evaluates an expression in
     72maxima and returns the result as a *string* not a maxima object.
     73
     74::
     75
     76    sage: print maxima.eval('factor(x^5 - y^5)')
     77    -(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)
     78
     79We can create the polynomial `f` as a Maxima polynomial,
     80then call the factor method on it. Notice that the notation
     81``f.factor()`` is consistent with how the rest of Sage
     82works.
     83
     84::
     85
     86    sage: f = maxima('x^5 - y^5')
     87    sage: f^2
     88    (x^5-y^5)^2
     89    sage: f.factor()
     90    -(y-x)*(y^4+x*y^3+x^2*y^2+x^3*y+x^4)
     91
     92Control-C interruption works well with the maxima interface,
     93because of the excellent implementation of maxima. For example, try
     94the following sum but with a much bigger range, and hit control-C.
     95
     96::
     97
     98    sage: maxima('sum(1/x^2, x, 1, 10)')
     99    1968329/1270080
     100
     101Tutorial
     102--------
     103
     104We follow the tutorial at
     105http://maxima.sourceforge.net/docs/intromax/.
     106
     107::
     108
     109    sage: maxima('1/100 + 1/101')
     110    201/10100
     111
     112::
     113
     114    sage: a = maxima('(1 + sqrt(2))^5'); a
     115    (sqrt(2)+1)^5
     116    sage: a.expand()
     117    3*2^(7/2)+5*sqrt(2)+41
     118
     119::
     120
     121    sage: a = maxima('(1 + sqrt(2))^5')
     122    sage: float(a)               
     123    82.012193308819747
     124    sage: a.numer()
     125    82.01219330881975
     126
     127::
     128
     129    sage: maxima.eval('fpprec : 100')
     130    '100'
     131    sage: a.bfloat()
     132    8.20121933088197564152489730020812442785204843859314941221237124017312418754011041266612384955016056b1
     133
     134::
     135
     136    sage: maxima('100!')
     137    93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
     138
     139::
     140
     141    sage: f = maxima('(x + 3*y + x^2*y)^3')
     142    sage: f.expand()
     143    x^6*y^3+9*x^4*y^3+27*x^2*y^3+27*y^3+3*x^5*y^2+18*x^3*y^2+27*x*y^2+3*x^4*y+9*x^2*y+x^3
     144    sage: f.subst('x=5/z')
     145    (5/z+25*y/z^2+3*y)^3
     146    sage: g = f.subst('x=5/z')
     147    sage: h = g.ratsimp(); h
     148    (27*y^3*z^6+135*y^2*z^5+(675*y^3+225*y)*z^4+(2250*y^2+125)*z^3+(5625*y^3+1875*y)*z^2+9375*y^2*z+15625*y^3)/z^6
     149    sage: h.factor()
     150    (3*y*z^2+5*z+25*y)^3/z^6
     151
     152::
     153
     154    sage: eqn = maxima(['a+b*c=1', 'b-a*c=0', 'a+b=5'])
     155    sage: s = eqn.solve('[a,b,c]'); s
     156    [[a=(25*sqrt(79)*%i+25)/(6*sqrt(79)*%i-34),b=(5*sqrt(79)*%i+5)/(sqrt(79)*%i+11),c=(sqrt(79)*%i+1)/10],[a=(25*sqrt(79)*%i-25)/(6*sqrt(79)*%i+34),b=(5*sqrt(79)*%i-5)/(sqrt(79)*%i-11),c=-(sqrt(79)*%i-1)/10]]
     157
     158Here is an example of solving an algebraic equation::
     159
     160    sage: maxima('x^2+y^2=1').solve('y')
     161    [y=-sqrt(1-x^2),y=sqrt(1-x^2)]
     162    sage: maxima('x^2 + y^2 = (x^2 - y^2)/sqrt(x^2 + y^2)').solve('y')
     163    [y=-sqrt((-y^2-x^2)*sqrt(y^2+x^2)+x^2),y=sqrt((-y^2-x^2)*sqrt(y^2+x^2)+x^2)]
     164
     165You can even nicely typeset the solution in latex::
     166
     167    sage: latex(s)
     168    \left[ \left[ a={{25\,\sqrt{79}\,i+25}\over{6\,\sqrt{79}\,i-34}} ,   b={{5\,\sqrt{79}\,i+5}\over{\sqrt{79}\,i+11}} , c={{\sqrt{79}\,i+1  }\over{10}} \right]  , \left[ a={{25\,\sqrt{79}\,i-25}\over{6\,  \sqrt{79}\,i+34}} , b={{5\,\sqrt{79}\,i-5}\over{\sqrt{79}\,i-11}} ,   c=-{{\sqrt{79}\,i-1}\over{10}} \right]  \right]
     169
     170To have the above appear onscreen via ``xdvi``, type
     171``view(s)``. (TODO: For OS X should create pdf output
     172and use preview instead?)
     173
     174::
     175
     176    sage: e = maxima('sin(u + v) * cos(u)^3'); e
     177    cos(u)^3*sin(v+u)
     178    sage: f = e.trigexpand(); f
     179    cos(u)^3*(cos(u)*sin(v)+sin(u)*cos(v))
     180    sage: f.trigreduce()
     181    (sin(v+4*u)+sin(v-2*u))/8+(3*sin(v+2*u)+3*sin(v))/8
     182    sage: w = maxima('3 + k*%i')
     183    sage: f = w^2 + maxima('%e')^w
     184    sage: f.realpart()
     185    %e^3*cos(k)-k^2+9
     186
     187::
     188
     189    sage: f = maxima('x^3 * %e^(k*x) * sin(w*x)'); f
     190    x^3*%e^(k*x)*sin(w*x)
     191    sage: f.diff('x')
     192    k*x^3*%e^(k*x)*sin(w*x)+3*x^2*%e^(k*x)*sin(w*x)+w*x^3*%e^(k*x)*cos(w*x)
     193    sage: f.integrate('x')
     194    (((k*w^6+3*k^3*w^4+3*k^5*w^2+k^7)*x^3+(3*w^6+3*k^2*w^4-3*k^4*w^2-3*k^6)*x^2+(-18*k*w^4-12*k^3*w^2+6*k^5)*x-6*w^4+36*k^2*w^2-6*k^4)*%e^(k*x)*sin(w*x)+((-w^7-3*k^2*w^5-3*k^4*w^3-k^6*w)*x^3+(6*k*w^5+12*k^3*w^3+6*k^5*w)*x^2+(6*w^5-12*k^2*w^3-18*k^4*w)*x-24*k*w^3+24*k^3*w)*%e^(k*x)*cos(w*x))/(w^8+4*k^2*w^6+6*k^4*w^4+4*k^6*w^2+k^8)
     195
     196::
     197
     198    sage: f = maxima('1/x^2')
     199    sage: f.integrate('x', 1, 'inf')
     200    1
     201    sage: g = maxima('f/sinh(k*x)^4')
     202    sage: g.taylor('x', 0, 3)
     203    f/(k^4*x^4)-2*f/(3*k^2*x^2)+11*f/45-62*k^2*f*x^2/945
     204
     205::
     206
     207    sage: maxima.taylor('asin(x)','x',0, 10)
     208    x+x^3/6+3*x^5/40+5*x^7/112+35*x^9/1152
     209
     210Examples involving matrices
     211---------------------------
     212
     213We illustrate computing with the matrix whose `i,j` entry
     214is `i/j`, for `i,j=1,\ldots,4`.
     215
     216::
     217
     218    sage: f = maxima.eval('f[i,j] := i/j')
     219    sage: A = maxima('genmatrix(f,4,4)'); A
     220    matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
     221    sage: A.determinant()
     222    0
     223    sage: A.echelon()
     224    matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0])
     225    sage: A.eigenvalues()
     226    [[0,4],[3,1]]
     227    sage: A.eigenvectors()
     228    [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]]
     229
     230We can also compute the echelon form in Sage::
     231
     232    sage: B = matrix(QQ, A)
     233    sage: B.echelon_form()
     234    [  1 1/2 1/3 1/4]
     235    [  0   0   0   0]
     236    [  0   0   0   0]
     237    [  0   0   0   0]
     238    sage: B.charpoly('x').factor()
     239    (x - 4) * x^3
     240
     241Laplace Transforms
     242------------------
     243
     244We illustrate Laplace transforms::
     245
     246    sage: _ = maxima.eval("f(t) := t*sin(t)")
     247    sage: maxima("laplace(f(t),t,s)")
     248    2*s/(s^2+1)^2
     249
     250::
     251
     252    sage: maxima("laplace(delta(t-3),t,s)") #Dirac delta function
     253    %e^-(3*s)
     254
     255::
     256
     257    sage: _ = maxima.eval("f(t) := exp(t)*sin(t)")
     258    sage: maxima("laplace(f(t),t,s)")
     259    1/(s^2-2*s+2)
     260
     261::
     262
     263    sage: _ = maxima.eval("f(t) := t^5*exp(t)*sin(t)")
     264    sage: maxima("laplace(f(t),t,s)")
     265    360*(2*s-2)/(s^2-2*s+2)^4-480*(2*s-2)^3/(s^2-2*s+2)^5+120*(2*s-2)^5/(s^2-2*s+2)^6
     266    sage: print maxima("laplace(f(t),t,s)")
     267                                             3                 5
     268               360 (2 s - 2)    480 (2 s - 2)     120 (2 s - 2)
     269              --------------- - --------------- + ---------------
     270                2           4     2           5     2           6
     271              (s  - 2 s + 2)    (s  - 2 s + 2)    (s  - 2 s + 2)
     272
     273::
     274
     275    sage: maxima("laplace(diff(x(t),t),t,s)")
     276    s*'laplace(x(t),t,s)-x(0)
     277
     278::
     279
     280    sage: maxima("laplace(diff(x(t),t,2),t,s)")
     281    -?%at('diff(x(t),t,1),t=0)+s^2*'laplace(x(t),t,s)-x(0)*s
     282
     283It is difficult to read some of these without the 2d
     284representation::
     285
     286    sage: print maxima("laplace(diff(x(t),t,2),t,s)")
     287                         !
     288                d        !         2
     289              - -- (x(t))!      + s  laplace(x(t), t, s) - x(0) s
     290                dt       !
     291                         !t = 0
     292
     293Even better, use
     294``view(maxima("laplace(diff(x(t),t,2),t,s)"))`` to see
     295a typeset version.
     296
     297Continued Fractions
     298-------------------
     299
     300A continued fraction `a + 1/(b + 1/(c + \cdots))` is
     301represented in maxima by the list `[a, b, c, \ldots]`.
     302
     303::
     304
     305    sage: maxima("cf((1 + sqrt(5))/2)")
     306    [1,1,1,1,2]
     307    sage: maxima("cf ((1 + sqrt(341))/2)")
     308    [9,1,2,1,2,1,17,1,2,1,2,1,17,1,2,1,2,1,17,2]
     309
     310Special examples
     311----------------
     312
     313In this section we illustrate calculations that would be awkward to
     314do (as far as I know) in non-symbolic computer algebra systems like
     315MAGMA or GAP.
     316
     317We compute the gcd of `2x^{n+4} - x^{n+2}` and
     318`4x^{n+1} + 3x^n` for arbitrary `n`.
     319
     320::
     321
     322    sage: f = maxima('2*x^(n+4) - x^(n+2)')
     323    sage: g = maxima('4*x^(n+1) + 3*x^n')
     324    sage: f.gcd(g)
     325    x^n
     326
     327You can plot 3d graphs (via gnuplot)::
     328
     329    sage: maxima('plot3d(x^2-y^2, [x,-2,2], [y,-2,2], [grid,12,12])')  # not tested
     330    [displays a 3 dimensional graph]
     331
     332You can formally evaluate sums (note the ``nusum``
     333command)::
     334
     335    sage: S = maxima('nusum(exp(1+2*i/n),i,1,n)')
     336    sage: print S
     337                            2/n + 3                   2/n + 1
     338                          %e                        %e
     339                   ----------------------- - -----------------------
     340                      1/n         1/n           1/n         1/n
     341                   (%e    - 1) (%e    + 1)   (%e    - 1) (%e    + 1)
     342
     343We formally compute the limit as `n\to\infty` of
     344`2S/n` as follows::
     345
     346    sage: T = S*maxima('2/n')
     347    sage: T.tlimit('n','inf')
     348    %e^3-%e
     349
     350Miscellaneous
     351-------------
     352
     353Obtaining digits of `\pi`::
     354
     355    sage: maxima.eval('fpprec : 100')
     356    '100'
     357    sage: maxima(pi).bfloat()
     358    3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068b0
     359
     360Defining functions in maxima::
     361
     362    sage: maxima.eval('fun[a] := a^2')
     363    'fun[a]:=a^2'
     364    sage: maxima('fun[10]')
     365    100
     366
     367Interactivity
     368-------------
     369
     370Unfortunately maxima doesn't seem to have a non-interactive mode,
     371which is needed for the Sage interface. If any Sage call leads to
     372maxima interactively answering questions, then the questions can't be
     373answered and the maxima session may hang. See the discussion at
     374http://www.ma.utexas.edu/pipermail/maxima/2005/011061.html for some
     375ideas about how to fix this problem. An example that illustrates this
     376problem is ``maxima.eval('integrate (exp(a*x), x, 0, inf)')``.
     377
     378Latex Output
     379------------
     380
     381To TeX a maxima object do this::
     382
     383    sage: latex(maxima('sin(u) + sinh(v^2)'))
     384    \sinh v^2+\sin u
     385
     386Here's another example::
     387
     388    sage: g = maxima('exp(3*%i*x)/(6*%i) + exp(%i*x)/(2*%i) + c')
     389    sage: latex(g)
     390    -{{i\,e^{3\,i\,x}}\over{6}}-{{i\,e^{i\,x}}\over{2}}+c
     391
     392Long Input
     393----------
     394
     395The MAXIMA interface reads in even very long input (using files) in
     396a robust manner, as long as you are creating a new object.
     397
     398.. note::
     399
     400   Using ``maxima.eval`` for long input is much less robust, and is
     401   not recommended.
     402
     403::
     404
     405    sage: t = '"%s"'%10^10000   # ten thousand character string.
     406    sage: a = maxima(t)
     407
     408TESTS: This working tests that a subtle bug has been fixed::
     409
     410    sage: f = maxima.function('x','gamma(x)')
     411    sage: g = f(1/7)
     412    sage: g
     413    gamma(1/7)
     414    sage: del f
     415    sage: maxima(sin(x))
     416    sin(x)
     417
     418This tests to make sure we handle the case where Maxima asks if an
     419expression is positive or zero.
     420
     421::
     422
     423    sage: var('Ax,Bx,By')
     424    (Ax, Bx, By)
     425    sage: t = -Ax*sin(sqrt(Ax^2)/2)/(sqrt(Ax^2)*sqrt(By^2 + Bx^2))
     426    sage: t.limit(Ax=0, dir='+')
     427    0
     428
     429A long complicated input expression::
     430
     431    sage: maxima._eval_line('((((((((((0) + ((1) / ((n0) ^ (0)))) + ((1) / ((n1) ^ (1)))) + ((1) / ((n2) ^ (2)))) + ((1) / ((n3) ^ (3)))) + ((1) / ((n4) ^ (4)))) + ((1) / ((n5) ^ (5)))) + ((1) / ((n6) ^ (6)))) + ((1) / ((n7) ^ (7)))) + ((1) / ((n8) ^ (8)))) + ((1) / ((n9) ^ (9)));')
     432    '1/n9^9+1/n8^8+1/n7^7+1/n6^6+1/n5^5+1/n4^4+1/n3^3+1/n2^2+1/n1+1'
     433"""
     434
     435#*****************************************************************************
     436#       Copyright (C) 2005 William Stein <wstein@gmail.com>
     437#
     438#  Distributed under the terms of the GNU General Public License (GPL)
     439#
     440#    This code is distributed in the hope that it will be useful,
     441#    but WITHOUT ANY WARRANTY; without even the implied warranty of
     442#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     443#    General Public License for more details.
     444#
     445#  The full text of the GPL is available at:
     446#
     447#                  http://www.gnu.org/licenses/
     448#*****************************************************************************
     449
     450from __future__ import with_statement
     451
     452import os, re, sys, subprocess
     453import pexpect
     454cygwin = os.uname()[0][:6]=="CYGWIN"
     455
     456from expect import Expect, ExpectElement, FunctionElement, ExpectFunction, gc_disabled, AsciiArtString
     457from pexpect import EOF
     458
     459from random import randrange
     460
     461##import sage.rings.all
     462import sage.rings.complex_number
     463
     464from sage.misc.misc import verbose, DOT_SAGE, SAGE_ROOT
     465
     466from sage.misc.multireplace import multiple_replace
     467
     468COMMANDS_CACHE = '%s/maxima_commandlist_cache.sobj'%DOT_SAGE
     469
     470import sage.server.support
     471
     472# The Maxima "apropos" command, e.g., apropos(det) gives a list
     473# of all identifiers that begin in a certain way.  This could
     474# maybe be useful somehow... (?)  Also maxima has a lot for getting
     475# documentation from the system -- this could also be useful.
     476
     477class Maxima(Expect):
     478    """
     479    Interface to the Maxima interpreter.
     480    """
     481    def __init__(self, script_subdirectory=None, logfile=None, server=None,
     482                 init_code = None):
     483        """
     484        Create an instance of the Maxima interpreter.
     485
     486        TESTS::
     487       
     488            sage: maxima == loads(dumps(maxima))
     489            True
     490
     491        We make sure labels are turned off (see trac 6816)::
     492       
     493            sage: 'nolabels:true' in maxima._Expect__init_code
     494            True
     495        """
     496        # TODO: Input and output prompts in maxima can be changed by
     497        # setting inchar and outchar..
     498        eval_using_file_cutoff = 256
     499        self.__eval_using_file_cutoff = eval_using_file_cutoff
     500        STARTUP = '%s/local/bin/sage-maxima.lisp'%SAGE_ROOT
     501       
     502        # We set maxima's configuration directory to $DOT_SAGE/maxima
     503        # This avoids that sage's maxima inadvertently loads
     504        # ~/.maxima/maxima-init.mac
     505        # If you absolutely want maxima instances that are started by
     506        # this interface to preload commands, put them in
     507        # $DOT_SAGE/maxima/maxima-init.mac
     508        # (we use the "--userdir" option in maxima for this)
     509        import sage.misc.misc
     510        SAGE_MAXIMA_DIR = os.path.join(sage.misc.misc.DOT_SAGE,"maxima")
     511       
     512        if not os.path.exists(STARTUP):
     513            raise RuntimeError, 'You must get the file local/bin/sage-maxima.lisp'
     514        if init_code is None:
     515            # display2d -- no ascii art output
     516            # keepfloat -- don't automatically convert floats to rationals
     517            init_code = ['display2d : false', 'keepfloat : true']
     518           
     519        # Turn off the prompt labels, since computing them *very
     520        # dramatically* slows down the maxima interpret after a while.
     521        # See the function makelabel in suprv1.lisp.
     522        # Many thanks to andrej.vodopivec@gmail.com and also
     523        # Robert Dodier for figuring this out!
     524        # See trac # 6818. 
     525        init_code.append('nolabels:true')
     526       
     527        Expect.__init__(self,
     528                        name = 'maxima',
     529                        prompt = '\(\%i[0-9]+\)',
     530                        command = 'maxima-noreadline --userdir="%s" -p "%s"'%(SAGE_MAXIMA_DIR,STARTUP),
     531                        maxread = 10000,
     532                        script_subdirectory = script_subdirectory,
     533                        restart_on_ctrlc = False,
     534                        verbose_start = False,
     535                        init_code = init_code,
     536                        logfile = logfile,
     537                        eval_using_file_cutoff=eval_using_file_cutoff)
     538        self._display_prompt = '<sage-display>'  # must match what is in the file local/bin/sage-maxima.lisp!!
     539        self._output_prompt_re = re.compile('\(\%o[0-9]+\)')
     540        self._ask = ['zero or nonzero?', 'an integer?', 'positive, negative, or zero?',
     541                     'positive or negative?', 'positive or zero?']
     542        self._prompt_wait = [self._prompt] + [re.compile(x) for x in self._ask] + \
     543                            ['Break [0-9]+'] #note that you might need to change _expect_expr if you
     544                                             #change this
     545        self._error_re = re.compile('(Principal Value|debugmode|incorrect syntax|Maxima encountered a Lisp error)')
     546        self._display2d = False
     547
     548    def _quit_string(self):
     549        """
     550        EXAMPLES::
     551       
     552            sage: maxima._quit_string()
     553            'quit();'
     554        """
     555        return 'quit();'
     556
     557    def _crash_msg(self):
     558        """
     559        EXAMPLES::
     560       
     561            sage: maxima._crash_msg()
     562            Maxima crashed -- automatically restarting.
     563        """
     564        print "Maxima crashed -- automatically restarting."
     565
     566
     567    def _batch(self, s, batchload=True):
     568        filename = '%s-%s'%(self._local_tmpfile(),randrange(2147483647))
     569        F = open(filename, 'w')
     570        F.write(s)
     571        F.close()
     572        if self.is_remote():
     573            self._send_tmpfile_to_server(local_file=filename)
     574            tmp_to_use = self._remote_tmpfile()
     575        tmp_to_use = filename
     576       
     577        if batchload:
     578            cmd = 'batchload("%s");'%tmp_to_use
     579        else:
     580            cmd = 'batch("%s");'%tmp_to_use
     581
     582        r = randrange(2147483647)
     583        s = str(r+1)
     584        cmd = "%s1+%s;\n"%(cmd,r)
     585
     586        self._sendline(cmd)
     587        self._expect_expr(s)
     588        out = self._before()
     589        self._error_check(str, out)
     590        os.unlink(filename)
     591        return out
     592
     593    def _error_check(self, str, out):
     594        r = self._error_re
     595        m = r.search(out)
     596        if not m is None:
     597            self._error_msg(str, out)
     598           
     599    def _error_msg(self, str, out):
     600        raise TypeError, "Error executing code in Maxima\nCODE:\n\t%s\nMaxima ERROR:\n\t%s"%(str, out.replace('-- an error.  To debug this try debugmode(true);',''))
     601
     602
     603    ###########################################
     604    # System -- change directory, etc
     605    ###########################################
     606    def chdir(self, dir):
     607        """
     608        Change Maxima's current working directory.
     609       
     610        EXAMPLES::
     611       
     612            sage: maxima.chdir('/')
     613        """
     614        self.lisp('(ext::cd "%s")'%dir)
     615
     616    ###########################################
     617    # Interactive help
     618    ###########################################
     619
     620
     621    def help(self, s):
     622        """
     623        EXAMPLES::
     624       
     625            sage: maxima.help('gcd')
     626            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     627            ...
     628        """
     629        return self._command_runner("describe", s)
     630
     631    def example(self, s):
     632        """
     633        EXAMPLES::
     634       
     635            sage: maxima.example('arrays')
     636            a[n]:=n*a[n-1]
     637                                            a  := n a
     638                                             n       n - 1
     639            a[0]:1
     640            a[5]
     641                                                  120
     642            a[n]:=n
     643            a[6]
     644                                                   6
     645            a[4]
     646                                                  24
     647                                                 done
     648        """
     649        return self._command_runner("example", s)
     650
     651    describe = help
     652
     653    def demo(self, s):
     654        """
     655        EXAMPLES::
     656       
     657            sage: maxima.demo('array') # not tested
     658            batching /opt/sage/local/share/maxima/5.16.3/demo/array.dem
     659       
     660        At the _ prompt, type ';' followed by enter to get next demo
     661        subscrmap : true _
     662        """
     663        return self._command_runner("demo", s, redirect=False)
     664
     665    def completions(self, s, verbose=True):
     666        """
     667        Return all commands that complete the command starting with the
     668        string s. This is like typing s[tab] in the Maxima interpreter.
     669       
     670        EXAMPLES::
     671       
     672            sage: sorted(maxima.completions('gc', verbose=False))
     673            ['gcd', 'gcdex', 'gcfactor', 'gcprint', 'gctime']
     674        """
     675        if verbose:
     676            print s,
     677            sys.stdout.flush()
     678        # in Maxima 5.19.1, apropos returns all commands that contain
     679        # the given string, instead of all commands that start with
     680        # the given string
     681        cmd_list = self._eval_line('apropos("%s")'%s, error_check=False).replace('\\ - ','-')
     682        cmd_list = [x for x in cmd_list[1:-1].split(',') if x[0] != '?']
     683        return [x for x in cmd_list if x.find(s) == 0]
     684
     685    def _commands(self, verbose=True):
     686        """
     687        Return list of all commands defined in Maxima.
     688       
     689        EXAMPLES::
     690       
     691            sage: sorted(maxima._commands(verbose=False))
     692            ['Alpha',
     693             'Beta',
     694             ...
     695             'zunderflow']
     696        """
     697        try:
     698            return self.__commands
     699        except AttributeError:
     700            self.__commands = sum(
     701                [self.completions(chr(65+n), verbose=verbose)+
     702                 self.completions(chr(97+n), verbose=verbose)
     703                 for n in range(26)], [])
     704        return self.__commands
     705
     706    def trait_names(self, verbose=True, use_disk_cache=True):
     707        """
     708        Return all Maxima commands, which is useful for tab completion.
     709       
     710        EXAMPLES::
     711       
     712            sage: t = maxima.trait_names(verbose=False)
     713            sage: 'gcd' in t
     714            True
     715            sage: len(t)    # random output
     716            1840
     717        """
     718        try:
     719            return self.__trait_names
     720        except AttributeError:
     721            import sage.misc.persist
     722            if use_disk_cache:
     723                try:
     724                    self.__trait_names = sage.misc.persist.load(COMMANDS_CACHE)
     725                    return self.__trait_names
     726                except IOError:
     727                    pass
     728            if verbose:
     729                print "\nBuilding Maxima command completion list (this takes"
     730                print "a few seconds only the first time you do it)."
     731                print "To force rebuild later, delete %s."%COMMANDS_CACHE
     732            v = self._commands(verbose=verbose)
     733            if verbose:
     734                print "\nDone!"
     735            self.__trait_names = v
     736            sage.misc.persist.save(v, COMMANDS_CACHE)
     737            return v
     738
     739    def _true_symbol(self):
     740        """
     741        Return the true symbol in Maxima.
     742       
     743        EXAMPLES::
     744       
     745            sage: maxima._true_symbol()
     746            'true'
     747            sage: maxima.eval('is(2 = 2)')
     748            'true'
     749        """
     750        return 'true'
     751
     752    def _false_symbol(self):
     753        """
     754        Return the false symbol in Maxima.
     755       
     756        EXAMPLES::
     757       
     758            sage: maxima._false_symbol()
     759            'false'
     760            sage: maxima.eval('is(2 = 4)')
     761            'false'
     762        """
     763        return 'false'
     764
     765    def _equality_symbol(self):
     766        """
     767        Returns the equality symbol in Maxima.
     768
     769        EXAMPLES::
     770
     771             sage: maxima._equality_symbol()
     772             '='
     773        """
     774        return '='
     775
     776    def _inequality_symbol(self):
     777        """
     778        Returns the equality symbol in Maxima.
     779
     780        EXAMPLES::
     781
     782             sage: maxima._inequality_symbol()
     783             '#'
     784             sage: maxima((x != 1))
     785             x#1
     786        """
     787        return '#'
     788
     789    def console(self):
     790        r"""
     791        Start the interactive Maxima console. This is a completely separate
     792        maxima session from this interface. To interact with this session,
     793        you should instead use ``maxima.interact()``.
     794       
     795        EXAMPLES::
     796       
     797            sage: maxima.console()             # not tested (since we can't)
     798            Maxima 5.13.0 http://maxima.sourceforge.net
     799            Using Lisp CLISP 2.41 (2006-10-13)
     800            Distributed under the GNU Public License. See the file COPYING.
     801            Dedicated to the memory of William Schelter.
     802            This is a development version of Maxima. The function bug_report()
     803            provides bug reporting information.
     804            (%i1)
     805       
     806        ::
     807       
     808            sage: maxima.interact()     # this is not tested either
     809              --> Switching to Maxima <--
     810            maxima: 2+2
     811            4
     812            maxima:
     813              --> Exiting back to Sage <--
     814        """
     815        maxima_console()
     816
     817    def cputime(self, t=None):
     818        r"""
     819        Returns the amount of CPU time that this Maxima session has used.
     820        If \var{t} is not None, then it returns the difference between
     821        the current CPU time and \var{t}.
     822       
     823        EXAMPLES:
     824            sage: t = maxima.cputime()
     825            sage: _ = maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
     826            sage: maxima.cputime(t) # output random
     827            0.568913
     828        """
     829        if t:
     830            return float(self.eval('elapsed_run_time()')) - t
     831        else:
     832            return float(self.eval('elapsed_run_time()'))
     833
     834
     835##     def display2d(self, flag=True):
     836##         """
     837##         Set the flag that determines whether Maxima objects are
     838##         printed using their 2-d ASCII art representation.  When the
     839##         maxima interface starts the default is that objects are not
     840##         represented in 2-d.
     841
     842##         INPUT:
     843##             flag -- bool (default: True)
     844
     845##         EXAMPLES
     846##             sage: maxima('1/2')
     847##             1/2
     848##             sage: maxima.display2d(True)
     849##             sage: maxima('1/2')
     850##                                            1
     851##                                            -
     852##                                            2
     853##             sage: maxima.display2d(False)
     854##         """
     855##         self._display2d = bool(flag)
     856
     857    def plot2d(self, *args):
     858        r"""
     859        Plot a 2d graph using Maxima / gnuplot.
     860       
     861        maxima.plot2d(f, '[var, min, max]', options)
     862       
     863        INPUT:
     864       
     865       
     866        -  ``f`` - a string representing a function (such as
     867           f="sin(x)") [var, xmin, xmax]
     868       
     869        -  ``options`` - an optional string representing plot2d
     870           options in gnuplot format
     871       
     872       
     873        EXAMPLES::
     874       
     875            sage: maxima.plot2d('sin(x)','[x,-5,5]')   # not tested
     876            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
     877            sage: maxima.plot2d('sin(x)','[x,-5,5]',opts)    # not tested
     878       
     879        The eps file is saved in the current directory.
     880        """
     881        self('plot2d(%s)'%(','.join([str(x) for x in args])))
     882
     883    def plot2d_parametric(self, r, var, trange, nticks=50, options=None):
     884        r"""
     885        Plots r = [x(t), y(t)] for t = tmin...tmax using gnuplot with
     886        options
     887       
     888        INPUT:
     889       
     890       
     891        -  ``r`` - a string representing a function (such as
     892           r="[x(t),y(t)]")
     893       
     894        -  ``var`` - a string representing the variable (such
     895           as var = "t")
     896       
     897        -  ``trange`` - [tmin, tmax] are numbers with tmintmax
     898       
     899        -  ``nticks`` - int (default: 50)
     900       
     901        -  ``options`` - an optional string representing plot2d
     902           options in gnuplot format
     903       
     904       
     905        EXAMPLES::
     906       
     907            sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t",[-3.1,3.1])   # not tested
     908       
     909        ::
     910       
     911            sage: opts = '[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "circle-plot.eps"]'
     912            sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t", [-3.1,3.1], options=opts)   # not tested
     913       
     914        The eps file is saved to the current working directory.
     915       
     916        Here is another fun plot::
     917       
     918            sage: maxima.plot2d_parametric(["sin(5*t)","cos(11*t)"], "t", [0,2*pi()], nticks=400)    # not tested
     919        """
     920        tmin = trange[0]
     921        tmax = trange[1]
     922        cmd = "plot2d([parametric, %s, %s, [%s, %s, %s], [nticks, %s]]"%( \
     923                   r[0], r[1], var, tmin, tmax, nticks)
     924        if options is None:
     925            cmd += ")"
     926        else:
     927            cmd += ", %s)"%options
     928        self(cmd)
     929
     930    def plot3d(self, *args):
     931        r"""
     932        Plot a 3d graph using Maxima / gnuplot.
     933       
     934        maxima.plot3d(f, '[x, xmin, xmax]', '[y, ymin, ymax]', '[grid, nx,
     935        ny]', options)
     936       
     937        INPUT:
     938       
     939       
     940        -  ``f`` - a string representing a function (such as
     941           f="sin(x)") [var, min, max]
     942       
     943       
     944        EXAMPLES::
     945       
     946            sage: maxima.plot3d('1 + x^3 - y^2', '[x,-2,2]', '[y,-2,2]', '[grid,12,12]')    # not tested
     947            sage: maxima.plot3d('sin(x)*cos(y)', '[x,-2,2]', '[y,-2,2]', '[grid,30,30]')   # not tested
     948            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
     949            sage: maxima.plot3d('sin(x+y)', '[x,-5,5]', '[y,-1,1]', opts)    # not tested
     950       
     951        The eps file is saved in the current working directory.
     952        """
     953        self('plot3d(%s)'%(','.join([str(x) for x in args])))
     954
     955    def plot3d_parametric(self, r, vars, urange, vrange, options=None):
     956        r"""
     957        Plot a 3d parametric graph with r=(x,y,z), x = x(u,v), y = y(u,v),
     958        z = z(u,v), for u = umin...umax, v = vmin...vmax using gnuplot with
     959        options.
     960       
     961        INPUT:
     962       
     963       
     964        -  ``x, y, z`` - a string representing a function (such
     965           as ``x="u2+v2"``, ...) vars is a list or two strings
     966           representing variables (such as vars = ["u","v"])
     967       
     968        -  ``urange`` - [umin, umax]
     969       
     970        -  ``vrange`` - [vmin, vmax] are lists of numbers with
     971           umin umax, vmin vmax
     972       
     973        -  ``options`` - optional string representing plot2d
     974           options in gnuplot format
     975       
     976       
     977        OUTPUT: displays a plot on screen or saves to a file
     978       
     979        EXAMPLES::
     980       
     981            sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3])     # not tested
     982            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-cos-plot.eps"]'
     983            sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3],opts)      # not tested
     984       
     985        The eps file is saved in the current working directory.
     986       
     987        Here is a torus::
     988       
     989            sage: _ = maxima.eval("expr_1: cos(y)*(10.0+6*cos(x)); expr_2: sin(y)*(10.0+6*cos(x)); expr_3: -6*sin(x);")  # optional
     990            sage: maxima.plot3d_parametric(["expr_1","expr_2","expr_3"], ["x","y"],[0,6],[0,6])   # not tested
     991       
     992        Here is a Mobius strip::
     993       
     994            sage: x = "cos(u)*(3 + v*cos(u/2))"
     995            sage: y = "sin(u)*(3 + v*cos(u/2))"
     996            sage: z = "v*sin(u/2)"
     997            sage: maxima.plot3d_parametric([x,y,z],["u","v"],[-3.1,3.2],[-1/10,1/10])   # not tested
     998        """
     999        umin = urange[0]
     1000        umax = urange[1]
     1001        vmin = vrange[0]
     1002        vmax = vrange[1]
     1003        cmd = 'plot3d([%s, %s, %s], [%s, %s, %s], [%s, %s, %s]'%(
     1004            r[0], r[1], r[2], vars[0], umin, umax, vars[1], vmin, vmax)
     1005        if options is None:
     1006            cmd += ')'
     1007        else:
     1008            cmd += ', %s)'%options
     1009        self(cmd)
     1010
     1011    def de_solve(self, de, vars, ics=None):
     1012        """
     1013        Solves a 1st or 2nd order ordinary differential equation (ODE) in
     1014        two variables, possibly with initial conditions.
     1015       
     1016        INPUT:
     1017       
     1018       
     1019        -  ``de`` - a string representing the ODE
     1020       
     1021        -  ``vars`` - a list of strings representing the two
     1022           variables.
     1023       
     1024        -  ``ics`` - a triple of numbers [a,b1,b2] representing
     1025           y(a)=b1, y'(a)=b2
     1026       
     1027       
     1028        EXAMPLES::
     1029       
     1030            sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
     1031            y=3*x-2*%e^(x-1)
     1032            sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'])
     1033            y=%k1*%e^x+%k2*%e^-x+3*x
     1034            sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'])
     1035            y=(%c-3*(-x-1)*%e^-x)*%e^x
     1036            sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'],[1,1])
     1037            y=-%e^-1*(5*%e^x-3*%e*x-3*%e)
     1038        """
     1039        if not isinstance(vars, str):
     1040            str_vars = '%s, %s'%(vars[1], vars[0])
     1041        else:
     1042            str_vars = vars
     1043        self.eval('depends(%s)'%str_vars)
     1044        m = self(de)
     1045        a = 'ode2(%s, %s)'%(m.name(), str_vars)
     1046        if ics != None:
     1047            if len(ics) == 3:
     1048                cmd = "ic2("+a+",%s=%s,%s=%s,diff(%s,%s)=%s);"%(vars[0],ics[0], vars[1],ics[1], vars[1], vars[0], ics[2])
     1049                return self(cmd)
     1050            if len(ics) == 2:
     1051                return self("ic1("+a+",%s=%s,%s=%s);"%(vars[0],ics[0], vars[1],ics[1]))
     1052        return self(a+";")
     1053
     1054    def de_solve_laplace(self, de, vars, ics=None):
     1055        """
     1056        Solves an ordinary differential equation (ODE) using Laplace
     1057        transforms.
     1058       
     1059        INPUT:
     1060       
     1061       
     1062        -  ``de`` - a string representing the ODE (e.g., de =
     1063           "diff(f(x),x,2)=diff(f(x),x)+sin(x)")
     1064       
     1065        -  ``vars`` - a list of strings representing the
     1066           variables (e.g., vars = ["x","f"])
     1067       
     1068        -  ``ics`` - a list of numbers representing initial
     1069           conditions, with symbols allowed which are represented by strings
     1070           (eg, f(0)=1, f'(0)=2 is ics = [0,1,2])
     1071       
     1072       
     1073        EXAMPLES::
     1074       
     1075            sage: maxima.clear('x'); maxima.clear('f')
     1076            sage: maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"], [0,1,2])
     1077            f(x)=x*%e^x+%e^x
     1078       
     1079        ::
     1080       
     1081            sage: maxima.clear('x'); maxima.clear('f')           
     1082            sage: f = maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"])
     1083            sage: f
     1084            f(x)=x*%e^x*('at('diff(f(x),x,1),x=0))-f(0)*x*%e^x+f(0)*%e^x
     1085            sage: print f
     1086                                               !
     1087                                   x  d        !                  x          x
     1088                        f(x) = x %e  (-- (f(x))!     ) - f(0) x %e  + f(0) %e
     1089                                      dx       !
     1090                                               !x = 0
     1091       
     1092        .. note::
     1093
     1094           The second equation sets the values of `f(0)` and
     1095           `f'(0)` in Maxima, so subsequent ODEs involving these
     1096           variables will have these initial conditions automatically
     1097           imposed.
     1098        """
     1099        if not (ics is None):
     1100            d = len(ics)
     1101            for i in range(0,d-1):
     1102                ic = 'atvalue(diff(%s(%s), %s, %s), %s = %s, %s)'%(
     1103                    vars[1], vars[0], vars[0], i, vars[0], ics[0], ics[1+i])
     1104                self.eval(ic)
     1105        return self('desolve(%s, %s(%s))'%(de, vars[1], vars[0]))
     1106
     1107    def solve_linear(self, eqns,vars):
     1108        """
     1109        Wraps maxima's linsolve.
     1110       
     1111        INPUT: eqns is a list of m strings, each representing a linear
     1112        question in m = n variables vars is a list of n strings, each
     1113        representing a variable
     1114       
     1115        EXAMPLES::
     1116       
     1117            sage: eqns = ["x + z = y","2*a*x - y = 2*a^2","y - 2*z = 2"]   
     1118            sage: vars = ["x","y","z"]                                     
     1119            sage: maxima.solve_linear(eqns, vars)
     1120            [x=a+1,y=2*a,z=a-1]
     1121        """
     1122        eqs = "["
     1123        for i in range(len(eqns)):
     1124            if i<len(eqns)-1:
     1125                eqs = eqs + eqns[i]+","
     1126            if  i==len(eqns)-1:
     1127                eqs = eqs + eqns[i]+"]"
     1128        vrs = "["
     1129        for i in range(len(vars)):
     1130            if i<len(vars)-1:
     1131                vrs = vrs + vars[i]+","
     1132            if  i==len(vars)-1:
     1133                vrs = vrs + vars[i]+"]"
     1134        return self('linsolve(%s, %s)'%(eqs, vrs))
     1135
     1136    def unit_quadratic_integer(self, n):
     1137        r"""
     1138        Finds a unit of the ring of integers of the quadratic number field
     1139        `\QQ(\sqrt{n})`, `n>1`, using the qunit maxima
     1140        command.
     1141       
     1142        EXAMPLES::
     1143       
     1144            sage: u = maxima.unit_quadratic_integer(101); u     
     1145            a + 10
     1146            sage: u.parent()                                       
     1147            Number Field in a with defining polynomial x^2 - 101
     1148            sage: u = maxima.unit_quadratic_integer(13)           
     1149            sage: u                                               
     1150            5*a + 18
     1151            sage: u.parent()                                       
     1152            Number Field in a with defining polynomial x^2 - 13
     1153        """
     1154        from sage.rings.all import QuadraticField, Integer
     1155        # Take square-free part so sqrt(n) doesn't get simplified further by maxima
     1156        # (The original version of this function would yield wrong answers if
     1157        # n is not squarefree.)
     1158        n = Integer(n).squarefree_part() 
     1159        if n < 1:
     1160            raise ValueError, "n (=%s) must be >= 1"%n
     1161        s = repr(self('qunit(%s)'%n)).lower()
     1162        r = re.compile('sqrt\(.*\)')
     1163        s = r.sub('a', s)
     1164        a = QuadraticField(n, 'a').gen()
     1165        return eval(s)
     1166
     1167    def plot_list(self, ptsx, ptsy, options=None):
     1168        r"""
     1169        Plots a curve determined by a sequence of points.
     1170       
     1171        INPUT:
     1172       
     1173       
     1174        -  ``ptsx`` - [x1,...,xn], where the xi and yi are
     1175           real,
     1176       
     1177        -  ``ptsy`` - [y1,...,yn]
     1178       
     1179        -  ``options`` - a string representing maxima plot2d
     1180           options.
     1181       
     1182       
     1183        The points are (x1,y1), (x2,y2), etc.
     1184       
     1185        This function requires maxima 5.9.2 or newer.
     1186       
     1187        .. note::
     1188
     1189           More that 150 points can sometimes lead to the program
     1190           hanging. Why?
     1191       
     1192        EXAMPLES::
     1193       
     1194            sage: zeta_ptsx = [ (pari(1/2 + i*I/10).zeta().real()).precision(1) for i in range (70,150)] 
     1195            sage: zeta_ptsy = [ (pari(1/2 + i*I/10).zeta().imag()).precision(1) for i in range (70,150)] 
     1196            sage: maxima.plot_list(zeta_ptsx, zeta_ptsy)         # not tested
     1197            sage: opts='[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "zeta.eps"]'
     1198            sage: maxima.plot_list(zeta_ptsx, zeta_ptsy, opts)      # not tested
     1199        """
     1200        cmd = 'plot2d([discrete,%s, %s]'%(ptsx, ptsy)
     1201        if options is None:
     1202            cmd += ')'
     1203        else:
     1204            cmd += ', %s)'%options
     1205        self(cmd)
     1206       
     1207
     1208    def plot_multilist(self, pts_list, options=None):
     1209        r"""
     1210        Plots a list of list of points pts_list=[pts1,pts2,...,ptsn],
     1211        where each ptsi is of the form [[x1,y1],...,[xn,yn]] x's must be
     1212        integers and y's reals options is a string representing maxima
     1213        plot2d options.
     1214       
     1215        Requires maxima 5.9.2 at least.
     1216
     1217        .. note::
     1218
     1219           More that 150 points can sometimes lead to the program
     1220           hanging.
     1221       
     1222        EXAMPLES::
     1223       
     1224            sage: xx = [ i/10.0 for i in range (-10,10)]
     1225            sage: yy = [ i/10.0 for i in range (-10,10)]
     1226            sage: x0 = [ 0 for i in range (-10,10)]
     1227            sage: y0 = [ 0 for i in range (-10,10)]
     1228            sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10)]
     1229            sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10)]
     1230            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])       # not tested
     1231            sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10,150)]
     1232            sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10,150)]
     1233            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])      # not tested
     1234            sage: opts='[gnuplot_preamble, "set nokey"]'                 
     1235            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]],opts)    # not tested
     1236        """
     1237        n = len(pts_list)
     1238        cmd = '['
     1239        for i in range(n):
     1240            if i < n-1:
     1241                cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+'],'
     1242            if i==n-1:
     1243                cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+']]'
     1244        #print cmd
     1245        if options is None:
     1246            self('plot2d('+cmd+')')
     1247        else:
     1248            self('plot2d('+cmd+','+options+')')
     1249   
     1250
     1251class MaximaElement(ExpectElement):
     1252    def __str__(self):
     1253        """
     1254        Printing an object explicitly gives ASCII art:
     1255       
     1256        EXAMPLES::
     1257       
     1258            sage: f = maxima('1/(x-1)^3'); f
     1259            1/(x-1)^3
     1260            sage: print f
     1261                                                  1
     1262                                               --------
     1263                                                      3
     1264                                               (x - 1)
     1265        """
     1266        return self.display2d(onscreen=False)
     1267
     1268    def bool(self):
     1269        """
     1270        EXAMPLES::
     1271       
     1272            sage: maxima(0).bool()
     1273            False
     1274            sage: maxima(1).bool()
     1275            True
     1276        """
     1277        P = self._check_valid()
     1278        return P.eval('is(%s = 0);'%self.name()) == P._false_symbol() # but be careful, since for relations things like is(equal(a,b)) are what Maxima needs
     1279
     1280    def __cmp__(self, other):
     1281        """
     1282        EXAMPLES::
     1283       
     1284            sage: a = maxima(1); b = maxima(2)
     1285            sage: a == b
     1286            False
     1287            sage: a < b
     1288            True
     1289            sage: a > b
     1290            False
     1291            sage: b < a
     1292            False
     1293            sage: b > a
     1294            True
     1295       
     1296        We can also compare more complicated object such as functions::
     1297       
     1298            sage: f = maxima('sin(x)'); g = maxima('cos(x)')
     1299            sage: -f == g.diff('x')
     1300            True
     1301        """
     1302
     1303        # thanks to David Joyner for telling me about using "is".
     1304        # but be careful, since for relations things like is(equal(a,b)) are what Maxima needs
     1305        P = self.parent()
     1306        try:
     1307            if P.eval("is (%s < %s)"%(self.name(), other.name())) == P._true_symbol():
     1308                return -1
     1309            elif P.eval("is (%s > %s)"%(self.name(), other.name())) == P._true_symbol():
     1310                return 1
     1311            elif P.eval("is (%s = %s)"%(self.name(), other.name())) == P._true_symbol():
     1312                return 0
     1313        except TypeError:
     1314            pass
     1315        return cmp(repr(self),repr(other))
     1316                   # everything is supposed to be comparable in Python, so we define
     1317                   # the comparison thus when no comparable in interfaced system.
     1318
     1319    def _sage_(self):
     1320        """
     1321        Attempt to make a native Sage object out of this maxima object.
     1322        This is useful for automatic coercions in addition to other
     1323        things.
     1324       
     1325        EXAMPLES::
     1326       
     1327            sage: a = maxima('sqrt(2) + 2.5'); a
     1328            sqrt(2)+2.5
     1329            sage: b = a._sage_(); b
     1330            sqrt(2) + 2.5
     1331            sage: type(b)
     1332            <type 'sage.symbolic.expression.Expression'>
     1333       
     1334        We illustrate an automatic coercion::
     1335       
     1336            sage: c = b + sqrt(3); c
     1337            sqrt(2) + sqrt(3) + 2.5
     1338            sage: type(c)
     1339            <type 'sage.symbolic.expression.Expression'>
     1340            sage: d = sqrt(3) + b; d
     1341            sqrt(2) + sqrt(3) + 2.5
     1342            sage: type(d)
     1343            <type 'sage.symbolic.expression.Expression'>
     1344       
     1345            sage: a = sage.calculus.calculus.maxima('x^(sqrt(y)+%pi) + sin(%e + %pi)')
     1346            sage: a._sage_()
     1347            x^(pi + sqrt(y)) - sin(e)
     1348            sage: var('x, y')
     1349            (x, y)
     1350            sage: v = sage.calculus.calculus.maxima.vandermonde_matrix([x, y, 1/2])
     1351            sage: v._sage_()
     1352            [  1   x x^2]
     1353            [  1   y y^2]
     1354            [  1 1/2 1/4]
     1355
     1356        Check if #7661 is fixed::
     1357
     1358            sage: var('delta')
     1359            delta
     1360            sage: (2*delta).simplify()
     1361            2*delta
     1362        """
     1363        import sage.calculus.calculus as calculus
     1364        return calculus.symbolic_expression_from_maxima_string(self.name(),
     1365                maxima=self.parent())
     1366
     1367    def _symbolic_(self, R):
     1368        """
     1369        Return a symbolic expression equivalent to this maxima object.
     1370
     1371        EXAMPLES::
     1372
     1373            sage: t = sqrt(2)._maxima_()
     1374            sage: u = t._symbolic_(SR); u
     1375            sqrt(2)
     1376            sage: u.parent()
     1377            Symbolic Ring
     1378
     1379        This is used when converting maxima objects to the Symbolic Ring::
     1380
     1381            sage: SR(t)
     1382            sqrt(2)
     1383        """
     1384        return R(self._sage_())
     1385
     1386    def __complex__(self):
     1387        """
     1388        EXAMPLES::
     1389       
     1390            sage: complex(maxima('sqrt(-2)+1'))
     1391            (1+1.4142135623730951j)
     1392        """
     1393        return complex(self._sage_())
     1394
     1395    def _complex_mpfr_field_(self, C):
     1396        """
     1397        EXAMPLES::
     1398       
     1399            sage: CC(maxima('1+%i'))
     1400             1.00000000000000 + 1.00000000000000*I
     1401            sage: CC(maxima('2342.23482943872+234*%i'))
     1402             2342.23482943872 + 234.000000000000*I
     1403            sage: ComplexField(10)(maxima('2342.23482943872+234*%i'))
     1404             2300. + 230.*I
     1405            sage: ComplexField(200)(maxima('1+%i'))
     1406            1.0000000000000000000000000000000000000000000000000000000000 + 1.0000000000000000000000000000000000000000000000000000000000*I
     1407            sage: ComplexField(200)(maxima('sqrt(-2)'))
     1408            1.4142135623730950488016887242096980785696718753769480731767*I
     1409            sage: N(sqrt(-2), 200)
     1410            8.0751148893563733350506651837615871941533119425962889089783e-62 + 1.4142135623730950488016887242096980785696718753769480731767*I
     1411        """
     1412        return C(self._sage_())
     1413
     1414    def _mpfr_(self, R):
     1415        """
     1416        EXAMPLES::
     1417       
     1418            sage: RealField(100)(maxima('sqrt(2)+1'))
     1419            2.4142135623730950488016887242
     1420        """
     1421        return R(self._sage_())
     1422
     1423    def _complex_double_(self, C):
     1424        """
     1425        EXAMPLES::
     1426       
     1427            sage: CDF(maxima('sqrt(2)+1'))
     1428            2.41421356237
     1429        """
     1430        return C(self._sage_())
     1431
     1432    def _real_double_(self, R):
     1433        """
     1434        EXAMPLES::
     1435       
     1436            sage: RDF(maxima('sqrt(2)+1'))
     1437            2.41421356237
     1438        """
     1439        return R(self._sage_())
     1440
     1441    def real(self):
     1442        """
     1443        Return the real part of this maxima element.
     1444       
     1445        EXAMPLES::
     1446       
     1447            sage: maxima('2 + (2/3)*%i').real()
     1448            2
     1449        """
     1450        return self.realpart()
     1451
     1452    def imag(self):
     1453        """
     1454        Return the imaginary part of this maxima element.
     1455       
     1456        EXAMPLES::
     1457       
     1458            sage: maxima('2 + (2/3)*%i').imag()
     1459            2/3
     1460        """
     1461        return self.imagpart()
     1462
     1463    def numer(self):
     1464        """
     1465        Return numerical approximation to self as a Maxima object.
     1466       
     1467        EXAMPLES::
     1468       
     1469            sage: a = maxima('sqrt(2)').numer(); a
     1470            1.41421356237309...
     1471            sage: type(a)
     1472            <class 'sage.interfaces.maxima_abstract.MaximaElement'>
     1473        """
     1474        return self.comma('numer')
     1475
     1476    def str(self):
     1477        """
     1478        Return string representation of this maxima object.
     1479       
     1480        EXAMPLES::
     1481       
     1482            sage: maxima('sqrt(2) + 1/3').str()
     1483            'sqrt(2)+1/3'
     1484        """
     1485        P = self._check_valid()
     1486        return P.get(self._name)
     1487
     1488    def __repr__(self):
     1489        """
     1490        Return print representation of this object.
     1491       
     1492        EXAMPLES::
     1493       
     1494            sage: maxima('sqrt(2) + 1/3').__repr__()
     1495            'sqrt(2)+1/3'
     1496        """
     1497        P = self._check_valid()
     1498        try:
     1499            return self.__repr
     1500        except AttributeError:
     1501            pass
     1502        r = P.get(self._name)
     1503        self.__repr = r
     1504        return r
     1505
     1506    def display2d(self, onscreen=True):
     1507        """
     1508        EXAMPLES::
     1509       
     1510            sage: F = maxima('x^5 - y^5').factor() 
     1511            sage: F.display2d ()             
     1512                                   4      3    2  2    3      4
     1513                       - (y - x) (y  + x y  + x  y  + x  y + x )
     1514        """
     1515        self._check_valid()
     1516        P = self.parent()
     1517        with gc_disabled():
     1518            P._eval_line('display2d : true$')
     1519            s = P._eval_line('disp(%s)$'%self.name(), reformat=False)
     1520            P._eval_line('display2d: false$')
     1521           
     1522        s = s.strip('\r\n')
     1523
     1524        # if ever want to dedent, see
     1525        # http://mail.python.org/pipermail/python-list/2006-December/420033.html
     1526        if onscreen:
     1527            print s
     1528        else:
     1529            return s
     1530
     1531    def diff(self, var='x', n=1):
     1532        """
     1533        Return the n-th derivative of self.
     1534       
     1535        INPUT:
     1536       
     1537       
     1538        -  ``var`` - variable (default: 'x')
     1539       
     1540        -  ``n`` - integer (default: 1)
     1541       
     1542       
     1543        OUTPUT: n-th derivative of self with respect to the variable var
     1544       
     1545        EXAMPLES::
     1546       
     1547            sage: f = maxima('x^2')                         
     1548            sage: f.diff()                                   
     1549            2*x
     1550            sage: f.diff('x')                               
     1551            2*x
     1552            sage: f.diff('x', 2)                             
     1553            2
     1554            sage: maxima('sin(x^2)').diff('x',4)
     1555            16*x^4*sin(x^2)-12*sin(x^2)-48*x^2*cos(x^2)
     1556       
     1557        ::
     1558       
     1559            sage: f = maxima('x^2 + 17*y^2')                 
     1560            sage: f.diff('x')
     1561            34*y*'diff(y,x,1)+2*x
     1562            sage: f.diff('y')                               
     1563            34*y
     1564        """
     1565        return ExpectElement.__getattr__(self, 'diff')(var, n)
     1566
     1567    derivative = diff
     1568
     1569    def nintegral(self, var='x', a=0, b=1,
     1570                  desired_relative_error='1e-8',
     1571                  maximum_num_subintervals=200):
     1572        r"""
     1573        Return a numerical approximation to the integral of self from a to
     1574        b.
     1575       
     1576        INPUT:
     1577       
     1578       
     1579        -  ``var`` - variable to integrate with respect to
     1580       
     1581        -  ``a`` - lower endpoint of integration
     1582       
     1583        -  ``b`` - upper endpoint of integration
     1584       
     1585        -  ``desired_relative_error`` - (default: '1e-8') the
     1586           desired relative error
     1587       
     1588        -  ``maximum_num_subintervals`` - (default: 200)
     1589           maxima number of subintervals
     1590       
     1591       
     1592        OUTPUT:
     1593       
     1594       
     1595        -  approximation to the integral
     1596       
     1597        -  estimated absolute error of the
     1598           approximation
     1599       
     1600        -  the number of integrand evaluations
     1601       
     1602        -  an error code:
     1603       
     1604            -  ``0`` - no problems were encountered
     1605
     1606            -  ``1`` - too many subintervals were done
     1607
     1608            -  ``2`` - excessive roundoff error
     1609
     1610            -  ``3`` - extremely bad integrand behavior
     1611
     1612            -  ``4`` - failed to converge
     1613
     1614            -  ``5`` - integral is probably divergent or slowly convergent
     1615
     1616            -  ``6`` - the input is invalid
     1617       
     1618       
     1619        EXAMPLES::
     1620       
     1621            sage: maxima('exp(-sqrt(x))').nintegral('x',0,1)
     1622            (.5284822353142306, 4.16331413788384...e-11, 231, 0)
     1623       
     1624        Note that GP also does numerical integration, and can do so to very
     1625        high precision very quickly::
     1626       
     1627            sage: gp('intnum(x=0,1,exp(-sqrt(x)))')           
     1628            0.5284822353142307136179049194             # 32-bit
     1629            0.52848223531423071361790491935415653022   # 64-bit
     1630            sage: _ = gp.set_precision(80)
     1631            sage: gp('intnum(x=0,1,exp(-sqrt(x)))')
     1632            0.52848223531423071361790491935415653021675547587292866196865279321015401702040079
     1633        """
     1634        from sage.rings.all import Integer
     1635        v = self.quad_qags(var, a, b, epsrel=desired_relative_error,
     1636                           limit=maximum_num_subintervals)
     1637        return v[0], v[1], Integer(v[2]), Integer(v[3])
     1638
     1639    def integral(self, var='x', min=None, max=None):
     1640        r"""
     1641        Return the integral of self with respect to the variable x.
     1642       
     1643        INPUT:
     1644       
     1645       
     1646        -  ``var`` - variable
     1647       
     1648        -  ``min`` - default: None
     1649       
     1650        -  ``max`` - default: None
     1651       
     1652       
     1653        Returns the definite integral if xmin is not None, otherwise
     1654        returns an indefinite integral.
     1655       
     1656        EXAMPLES::
     1657       
     1658            sage: maxima('x^2+1').integral()                   
     1659            x^3/3+x
     1660            sage: maxima('x^2+ 1 + y^2').integral('y')         
     1661            y^3/3+x^2*y+y
     1662            sage: maxima('x / (x^2+1)').integral()             
     1663            log(x^2+1)/2
     1664            sage: maxima('1/(x^2+1)').integral()               
     1665            atan(x)
     1666            sage: maxima('1/(x^2+1)').integral('x', 0, infinity)
     1667            %pi/2
     1668            sage: maxima('x/(x^2+1)').integral('x', -1, 1)     
     1669            0
     1670       
     1671        ::
     1672       
     1673            sage: f = maxima('exp(x^2)').integral('x',0,1); f   
     1674            -sqrt(%pi)*%i*erf(%i)/2
     1675            sage: f.numer()
     1676            1.46265174590718...
     1677        """
     1678        I = ExpectElement.__getattr__(self, 'integrate')
     1679        if min is None:
     1680            return I(var)
     1681        else:
     1682            if max is None:
     1683                raise ValueError, "neither or both of min/max must be specified."
     1684            return I(var, min, max)
     1685
     1686    integrate = integral
     1687
     1688    def __float__(self):
     1689        """
     1690        Return floating point version of this maxima element.
     1691       
     1692        EXAMPLES::
     1693       
     1694            sage: float(maxima("3.14"))
     1695            3.1400000000000001
     1696            sage: float(maxima("1.7e+17"))
     1697            1.7e+17
     1698            sage: float(maxima("1.7e-17"))
     1699            1.6999999999999999e-17
     1700        """
     1701        try:
     1702            return float(repr(self.numer()))
     1703        except ValueError:
     1704            raise TypeError, "unable to coerce '%s' to float"%repr(self)
     1705
     1706    def __len__(self):
     1707        """
     1708        Return the length of a list.
     1709       
     1710        EXAMPLES::
     1711       
     1712            sage: v = maxima('create_list(x^i,i,0,5)')         
     1713            sage: len(v)                                       
     1714            6
     1715        """
     1716        P = self._check_valid()       
     1717        return int(P.eval('length(%s)'%self.name()))
     1718
     1719    def dot(self, other):
     1720        """
     1721        Implements the notation self . other.
     1722       
     1723        EXAMPLES::
     1724       
     1725            sage: A = maxima('matrix ([a1],[a2])')
     1726            sage: B = maxima('matrix ([b1, b2])')
     1727            sage: A.dot(B)
     1728            matrix([a1*b1,a1*b2],[a2*b1,a2*b2])
     1729        """
     1730        P = self._check_valid()
     1731        Q = P(other)
     1732        return P('%s . %s'%(self.name(), Q.name()))
     1733
     1734    def __getitem__(self, n):
     1735        r"""
     1736        Return the n-th element of this list.
     1737       
     1738        .. note::
     1739
     1740           Lists are 0-based when accessed via the Sage interface, not
     1741           1-based as they are in the Maxima interpreter.
     1742       
     1743        EXAMPLES::
     1744       
     1745            sage: v = maxima('create_list(i*x^i,i,0,5)'); v   
     1746            [0,x,2*x^2,3*x^3,4*x^4,5*x^5]
     1747            sage: v[3]                                         
     1748            3*x^3
     1749            sage: v[0]                                           
     1750            0
     1751            sage: v[10]                                         
     1752            Traceback (most recent call last):
     1753            ...
     1754            IndexError: n = (10) must be between 0 and 5
     1755        """
     1756        n = int(n)
     1757        if n < 0 or n >= len(self):
     1758            raise IndexError, "n = (%s) must be between %s and %s"%(n, 0, len(self)-1)
     1759        # If you change the n+1 to n below, better change __iter__ as well.
     1760        return ExpectElement.__getitem__(self, n+1)
     1761
     1762    def __iter__(self):
     1763        """
     1764        EXAMPLE::
     1765       
     1766            sage: v = maxima('create_list(i*x^i,i,0,5)')
     1767            sage: L = list(v)
     1768            sage: [e._sage_() for e in L]
     1769            [0, x, 2*x^2, 3*x^3, 4*x^4, 5*x^5]
     1770        """
     1771        for i in range(len(self)):
     1772            yield self[i]
     1773
     1774    def subst(self, val):
     1775        """
     1776        Substitute a value or several values into this Maxima object.
     1777       
     1778        EXAMPLES::
     1779       
     1780            sage: maxima('a^2 + 3*a + b').subst('b=2')
     1781            a^2+3*a+2
     1782            sage: maxima('a^2 + 3*a + b').subst('a=17')
     1783            b+340
     1784            sage: maxima('a^2 + 3*a + b').subst('a=17, b=2')
     1785            342
     1786        """
     1787        return self.comma(val)
     1788
     1789    def comma(self, args):
     1790        """
     1791        Form the expression that would be written 'self, args' in Maxima.
     1792       
     1793        EXAMPLES::
     1794       
     1795            sage: maxima('sqrt(2) + I').comma('numer')
     1796            I+1.41421356237309...
     1797            sage: maxima('sqrt(2) + I*a').comma('a=5')
     1798            5*I+sqrt(2)
     1799        """
     1800        self._check_valid()
     1801        P = self.parent()
     1802        return P('%s, %s'%(self.name(), args))
     1803
     1804    def _latex_(self):
     1805        """
     1806        Return Latex representation of this Maxima object.
     1807       
     1808        This calls the tex command in Maxima, then does a little
     1809        post-processing to fix bugs in the resulting Maxima output.
     1810       
     1811        EXAMPLES::
     1812       
     1813            sage: maxima('sqrt(2) + 1/3 + asin(5)')._latex_()
     1814            '\\sin^{-1}\\cdot5+\\sqrt{2}+{{1}\\over{3}}'
     1815
     1816            sage: y,d = var('y,d')
     1817            sage: f = function('f')
     1818            sage: latex(maxima(derivative(f(x*y*d), d,x,x,y)))
     1819            Traceback (most recent call last):
     1820            ...
     1821            NotImplementedError: arguments must be distinct variables
     1822            sage: latex(maxima(derivative(f(x,y,d), d,x,x,y)))
     1823            {{{\it \partial}^4}\over{{\it \partial}\,d\,{\it \partial}\,x^2\,  {\it \partial}\,y}}\,f\left(x , y , d\right)
     1824
     1825            sage: latex(maxima(d/(d-2)))
     1826            {{d}\over{d-2}}
     1827        """
     1828        self._check_valid()
     1829        P = self.parent()
     1830        s = P._eval_line('tex(%s);'%self.name(), reformat=False)
     1831        if not '$$' in s:
     1832            raise RuntimeError, "Error texing maxima object."
     1833        i = s.find('$$')
     1834        j = s.rfind('$$')
     1835        s = s[i+2:j]
     1836        s = multiple_replace({'\r\n':' ',
     1837                              '\\%':'',
     1838                              '\\arcsin ':'\\sin^{-1} ',
     1839                              '\\arccos ':'\\cos^{-1} ',
     1840                              '\\arctan ':'\\tan^{-1} '}, s)
     1841
     1842        # Fix a maxima bug, which gives a latex representation of multiplying
     1843        # two numbers as a single space. This was really bad when 2*17^(1/3)
     1844        # gets TeXed as '2 17^{\frac{1}{3}}'
     1845        #
     1846        # This regex matches a string of spaces preceded by either a '}', a
     1847        # decimal digit, or a ')', and followed by a decimal digit. The spaces
     1848        # get replaced by a '\cdot'.
     1849        s = re.sub(r'(?<=[})\d]) +(?=\d)', '\cdot', s)
     1850
     1851        return s
     1852
     1853    def trait_names(self, verbose=False):
     1854        """
     1855        Return all Maxima commands, which is useful for tab completion.
     1856       
     1857        EXAMPLES::
     1858       
     1859            sage: m = maxima(2)
     1860            sage: 'gcd' in m.trait_names()
     1861            True
     1862        """
     1863        return self.parent().trait_names(verbose=False)
     1864
     1865    def _matrix_(self, R):
     1866        r"""
     1867        If self is a Maxima matrix, return the corresponding Sage matrix
     1868        over the Sage ring `R`.
     1869       
     1870        This may or may not work depending in how complicated the entries
     1871        of self are! It only works if the entries of self can be coerced as
     1872        strings to produce meaningful elements of `R`.
     1873       
     1874        EXAMPLES::
     1875       
     1876            sage: _ = maxima.eval("f[i,j] := i/j")             
     1877            sage: A = maxima('genmatrix(f,4,4)'); A             
     1878            matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
     1879            sage: A._matrix_(QQ)                               
     1880            [  1 1/2 1/3 1/4]
     1881            [  2   1 2/3 1/2]
     1882            [  3 3/2   1 3/4]
     1883            [  4   2 4/3   1]
     1884       
     1885        You can also use the ``matrix`` command (which is
     1886        defined in ``sage.misc.functional``)::
     1887       
     1888            sage: matrix(QQ, A)
     1889            [  1 1/2 1/3 1/4]
     1890            [  2   1 2/3 1/2]
     1891            [  3 3/2   1 3/4]
     1892            [  4   2 4/3   1]
     1893        """
     1894        from sage.matrix.all import MatrixSpace
     1895        self._check_valid()
     1896        P = self.parent()
     1897        nrows = int(P.eval('length(%s)'%self.name()))
     1898        if nrows == 0:
     1899            return MatrixSpace(R, 0, 0)(0)
     1900        ncols = int(P.eval('length(%s[1])'%self.name()))
     1901        M = MatrixSpace(R, nrows, ncols)
     1902        s = self.str().replace('matrix','').replace(',',"','").\
     1903            replace("]','[","','").replace('([',"['").replace('])',"']")
     1904        s = eval(s)
     1905        return M([R(x) for x in s])
     1906       
     1907    def partial_fraction_decomposition(self, var='x'):
     1908        """
     1909        Return the partial fraction decomposition of self with respect to
     1910        the variable var.
     1911       
     1912        EXAMPLES::
     1913       
     1914            sage: f = maxima('1/((1+x)*(x-1))')           
     1915            sage: f.partial_fraction_decomposition('x')   
     1916            1/(2*(x-1))-1/(2*(x+1))
     1917            sage: print f.partial_fraction_decomposition('x')
     1918                                 1           1
     1919                             --------- - ---------
     1920                             2 (x - 1)   2 (x + 1)
     1921        """
     1922        return self.partfrac(var)
     1923
     1924    def _operation(self, operation, right):
     1925        r"""
     1926        Note that right's parent should already be Maxima since this should
     1927        be called after coercion has been performed.
     1928       
     1929        If right is a ``MaximaFunction``, then we convert
     1930        ``self`` to a ``MaximaFunction`` that takes
     1931        no arguments, and let the
     1932        ``MaximaFunction._operation`` code handle everything
     1933        from there.
     1934       
     1935        EXAMPLES::
     1936       
     1937            sage: f = maxima.cos(x)
     1938            sage: f._operation("+", f)
     1939            2*cos(x)
     1940        """
     1941        P = self._check_valid()
     1942
     1943        if isinstance(right, MaximaFunction):
     1944            fself = P.function('', repr(self))
     1945            return fself._operation(operation, right)
     1946
     1947        try:
     1948            return P.new('%s %s %s'%(self._name, operation, right._name))
     1949        except Exception, msg:
     1950            raise TypeError, msg
     1951
     1952
     1953       
     1954class MaximaFunctionElement(FunctionElement):
     1955    def _sage_doc_(self):
     1956        """
     1957        EXAMPLES::
     1958       
     1959            sage: m = maxima(4)
     1960            sage: m.gcd._sage_doc_()
     1961            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     1962            ...
     1963        """
     1964        return self._obj.parent().help(self._name)
     1965
     1966class MaximaExpectFunction(ExpectFunction):
     1967    def _sage_doc_(self):
     1968        """
     1969        EXAMPLES::
     1970       
     1971            sage: maxima.gcd._sage_doc_()
     1972            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     1973            ...
     1974        """
     1975        M = self._parent
     1976        return M.help(self._name)
     1977
     1978
     1979class MaximaFunction(MaximaElement):
     1980    def __init__(self, parent, name, defn, args, latex):
     1981        """
     1982        EXAMPLES::
     1983       
     1984            sage: f = maxima.function('x,y','sin(x+y)')
     1985            sage: f == loads(dumps(f))
     1986            True
     1987        """
     1988        MaximaElement.__init__(self, parent, name, is_name=True)
     1989        self.__defn = defn
     1990        self.__args = args
     1991        self.__latex = latex
     1992
     1993    def __reduce__(self):
     1994        """
     1995        EXAMPLES::
     1996       
     1997            sage: f = maxima.function('x,y','sin(x+y)')
     1998            sage: f.__reduce__()
     1999            (<function reduce_load_Maxima_function at 0x...>,
     2000             (Maxima, 'sin(x+y)', 'x,y', None))
     2001        """
     2002        return reduce_load_Maxima_function, (self.parent(), self.__defn, self.__args, self.__latex)
     2003       
     2004    def __call__(self, *x):
     2005        """
     2006        EXAMPLES::
     2007       
     2008            sage: f = maxima.function('x,y','sin(x+y)')
     2009            sage: f(1,2)
     2010            sin(3)
     2011            sage: f(x,x)
     2012            sin(2*x)
     2013        """
     2014        P = self._check_valid()
     2015        if len(x) == 1:
     2016            x = '(%s)'%x
     2017        return P('%s%s'%(self.name(), x))
     2018
     2019    def __repr__(self):
     2020        """
     2021        EXAMPLES::
     2022       
     2023            sage: f = maxima.function('x,y','sin(x+y)')
     2024            sage: repr(f)
     2025            'sin(x+y)'
     2026        """
     2027        return self.definition()
     2028
     2029    def _latex_(self):
     2030        """
     2031        EXAMPLES::
     2032       
     2033            sage: f = maxima.function('x,y','sin(x+y)')
     2034            sage: latex(f)
     2035            \mathrm{sin(x+y)}
     2036        """
     2037        if self.__latex is None:
     2038            return r'\mathrm{%s}'%self.__defn
     2039        else:
     2040            return self.__latex
     2041
     2042    def arguments(self, split=True):
     2043        r"""
     2044        Returns the arguments of this Maxima function.
     2045       
     2046        EXAMPLES::
     2047       
     2048            sage: f = maxima.function('x,y','sin(x+y)')
     2049            sage: f.arguments()
     2050            ['x', 'y']
     2051            sage: f.arguments(split=False)
     2052            'x,y'
     2053            sage: f = maxima.function('', 'sin(x)')
     2054            sage: f.arguments()
     2055            []
     2056        """
     2057        if split:
     2058            return self.__args.split(',') if self.__args != '' else []
     2059        else:
     2060            return self.__args
     2061
     2062    def definition(self):
     2063        """
     2064        Returns the definition of this Maxima function as a string.
     2065       
     2066        EXAMPLES::
     2067       
     2068            sage: f = maxima.function('x,y','sin(x+y)')
     2069            sage: f.definition()
     2070            'sin(x+y)'
     2071        """
     2072        return self.__defn
     2073
     2074    def integral(self, var):
     2075        """
     2076        Returns the integral of self with respect to the variable var.
     2077       
     2078        Note that integrate is an alias of integral.
     2079       
     2080        EXAMPLES::
     2081       
     2082            sage: x,y = var('x,y')
     2083            sage: f = maxima.function('x','sin(x)')
     2084            sage: f.integral(x)
     2085            -cos(x)
     2086            sage: f.integral(y)
     2087            sin(x)*y
     2088        """
     2089        var = str(var)
     2090        P = self._check_valid()
     2091        f = P('integrate(%s(%s), %s)'%(self.name(), self.arguments(split=False), var))
     2092
     2093        args = self.arguments()
     2094        if var not in args:
     2095            args.append(var)
     2096        return P.function(",".join(args), repr(f))
     2097
     2098    integrate = integral
     2099
     2100    def _operation(self, operation, f=None):
     2101        r"""
     2102        This is a utility function which factors out much of the
     2103        commonality used in the arithmetic operations for
     2104        ``MaximaFunctions``.
     2105       
     2106        INPUT:
     2107       
     2108       
     2109        -  ``operation`` - A string representing the operation
     2110           being performed. For example, '\*', or '1/'.
     2111       
     2112        -  ``f`` - The other operand. If f is
     2113           ``None``, than the operation is assumed to be unary
     2114           rather than binary.
     2115       
     2116       
     2117        EXAMPLES::
     2118       
     2119            sage: f = maxima.function('x,y','sin(x+y)')
     2120            sage: f._operation("+", f)
     2121            2*sin(y+x)
     2122            sage: f._operation("+", 2)
     2123            sin(y+x)+2
     2124            sage: f._operation('-')
     2125            -sin(y+x)
     2126            sage: f._operation('1/')
     2127            1/sin(y+x)
     2128        """
     2129        P = self._check_valid()
     2130        if isinstance(f, MaximaFunction):
     2131            tmp = list(sorted(set(self.arguments() + f.arguments())))
     2132            args = ','.join(tmp)
     2133            defn = "(%s)%s(%s)"%(self.definition(), operation, f.definition())
     2134        elif f is None:
     2135            args = self.arguments(split=False)
     2136            defn = "%s(%s)"%(operation, self.definition())
     2137        else:
     2138            args = self.arguments(split=False)
     2139            defn = "(%s)%s(%s)"%(self.definition(), operation, repr(f))
     2140
     2141        return P.function(args,P.eval(defn))
     2142
     2143    def _add_(self, f):
     2144        """
     2145        MaximaFunction as left summand.
     2146       
     2147        EXAMPLES::
     2148       
     2149            sage: x,y = var('x,y')
     2150            sage: f = maxima.function('x','sin(x)')
     2151            sage: g = maxima.function('x','-cos(x)')
     2152            sage: f+g
     2153            sin(x)-cos(x)
     2154            sage: f+3
     2155            sin(x)+3
     2156       
     2157        ::
     2158       
     2159            sage: (f+maxima.cos(x))(2)
     2160            sin(2)+cos(2)
     2161            sage: (f+maxima.cos(y)) # This is a function with only ONE argument!
     2162            cos(y)+sin(x) 
     2163            sage: (f+maxima.cos(y))(2)
     2164            cos(y)+sin(2)
     2165       
     2166        ::
     2167       
     2168            sage: f = maxima.function('x','sin(x)')
     2169            sage: g = -maxima.cos(x)
     2170            sage: g+f
     2171            sin(x)-cos(x)
     2172            sage: (g+f)(2) # The sum IS a function
     2173            sin(2)-cos(2) 
     2174            sage: 2+f
     2175            sin(x)+2
     2176        """
     2177        return self._operation("+", f)
     2178
     2179    def _sub_(self, f):
     2180        r"""
     2181        ``MaximaFunction`` as minuend.
     2182       
     2183        EXAMPLES::
     2184       
     2185            sage: x,y = var('x,y')
     2186            sage: f = maxima.function('x','sin(x)')
     2187            sage: g = -maxima.cos(x) # not a function
     2188            sage: f-g
     2189            sin(x)+cos(x)
     2190            sage: (f-g)(2)
     2191            sin(2)+cos(2)
     2192            sage: (f-maxima.cos(y)) # This function only has the argument x!
     2193            sin(x)-cos(y)
     2194            sage: _(2)
     2195            sin(2)-cos(y)
     2196       
     2197        ::
     2198       
     2199            sage: g-f
     2200            -sin(x)-cos(x)
     2201        """
     2202        return self._operation("-", f)
     2203       
     2204    def _mul_(self, f):
     2205        r"""
     2206        ``MaximaFunction`` as left factor.
     2207       
     2208        EXAMPLES::
     2209       
     2210            sage: f = maxima.function('x','sin(x)')
     2211            sage: g = maxima('-cos(x)') # not a function!
     2212            sage: f*g
     2213            -cos(x)*sin(x)
     2214            sage: _(2)
     2215            -cos(2)*sin(2)
     2216       
     2217        ::
     2218       
     2219            sage: f = maxima.function('x','sin(x)')
     2220            sage: g = maxima('-cos(x)')
     2221            sage: g*f
     2222            -cos(x)*sin(x)
     2223            sage: _(2)
     2224            -cos(2)*sin(2)
     2225            sage: 2*f
     2226            2*sin(x)
     2227        """
     2228        return self._operation("*", f)
     2229
     2230    def _div_(self, f):
     2231        r"""
     2232        ``MaximaFunction`` as dividend.
     2233       
     2234        EXAMPLES::
     2235       
     2236            sage: f=maxima.function('x','sin(x)')
     2237            sage: g=maxima('-cos(x)')
     2238            sage: f/g
     2239            -sin(x)/cos(x)
     2240            sage: _(2)
     2241            -sin(2)/cos(2)
     2242       
     2243        ::
     2244       
     2245            sage: f=maxima.function('x','sin(x)')
     2246            sage: g=maxima('-cos(x)')
     2247            sage: g/f
     2248            -cos(x)/sin(x)
     2249            sage: _(2)
     2250            -cos(2)/sin(2)
     2251            sage: 2/f
     2252            2/sin(x)
     2253        """
     2254        return self._operation("/", f)
     2255
     2256    def __neg__(self):
     2257        r"""
     2258        Additive inverse of a ``MaximaFunction``.
     2259       
     2260        EXAMPLES::
     2261       
     2262            sage: f=maxima.function('x','sin(x)')
     2263            sage: -f
     2264            -sin(x)
     2265        """
     2266        return self._operation('-')
     2267
     2268    def __inv__(self):
     2269        r"""
     2270        Multiplicative inverse of a ``MaximaFunction``.
     2271       
     2272        EXAMPLES::
     2273       
     2274            sage: f = maxima.function('x','sin(x)')
     2275            sage: ~f
     2276            1/sin(x)
     2277        """
     2278        return self._operation('1/')
     2279
     2280    def __pow__(self,f):
     2281        r"""
     2282        ``MaximaFunction`` raised to some power.
     2283       
     2284        EXAMPLES::
     2285       
     2286            sage: f=maxima.function('x','sin(x)')
     2287            sage: g=maxima('-cos(x)')
     2288            sage: f^g
     2289            1/sin(x)^cos(x)
     2290       
     2291        ::
     2292       
     2293            sage: f=maxima.function('x','sin(x)')
     2294            sage: g=maxima('-cos(x)') # not a function
     2295            sage: g^f
     2296            (-cos(x))^sin(x)
     2297        """
     2298        return self._operation("^", f)
     2299
     2300
     2301def reduce_load_Maxima_function(parent, defn, args, latex):
     2302    return parent.function(args, defn, defn, latex)
     2303   
     2304
     2305import os
     2306def maxima_console():
     2307    """
     2308    Spawn a new Maxima command-line session.
     2309   
     2310    EXAMPLES::
     2311   
     2312        sage: from sage.interfaces.maxima import maxima_console
     2313        sage: maxima_console()                    # not tested
     2314        Maxima 5.23.2 http://maxima.sourceforge.net
     2315        ...
     2316    """
     2317    os.system('maxima')