Ticket #7377: trac_7377-abstract-maxima-rebased.patch

File trac_7377-abstract-maxima-rebased.patch, 131.9 KB (added by jpflori, 8 years ago)

Rebased on Sage 4.6.1

  • sage/interfaces/maxima.py

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

    diff -r 1e19f04584b5 -r c625f7bb90f4 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='above')
     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        if not os.path.exists(STARTUP):
     502            raise RuntimeError, 'You must get the file local/bin/sage-maxima.lisp'
     503        if init_code is None:
     504            # display2d -- no ascii art output
     505            # keepfloat -- don't automatically convert floats to rationals
     506            init_code = ['display2d : false', 'keepfloat : true']
     507           
     508        # Turn off the prompt labels, since computing them *very
     509        # dramatically* slows down the maxima interpret after a while.
     510        # See the function makelabel in suprv1.lisp.
     511        # Many thanks to andrej.vodopivec@gmail.com and also
     512        # Robert Dodier for figuring this out!
     513        # See trac # 6818. 
     514        init_code.append('nolabels:true')
     515       
     516        Expect.__init__(self,
     517                        name = 'maxima',
     518                        prompt = '\(\%i[0-9]+\)',
     519                        command = 'maxima-noreadline -p "%s"'%STARTUP,
     520                        maxread = 10000,
     521                        script_subdirectory = script_subdirectory,
     522                        restart_on_ctrlc = False,
     523                        verbose_start = False,
     524                        init_code = init_code,
     525                        logfile = logfile,
     526                        eval_using_file_cutoff=eval_using_file_cutoff)
     527        self._display_prompt = '<sage-display>'  # must match what is in the file local/ibn/sage-maxima.lisp!!
     528        self._output_prompt_re = re.compile('\(\%o[0-9]+\)')
     529        self._ask = ['zero or nonzero?', 'an integer?', 'positive, negative, or zero?',
     530                     'positive or negative?', 'positive or zero?']
     531        self._prompt_wait = [self._prompt] + [re.compile(x) for x in self._ask] + \
     532                            ['Break [0-9]+'] #note that you might need to change _expect_expr if you
     533                                             #change this
     534        self._error_re = re.compile('(Principal Value|debugmode|Incorrect syntax|Maxima encountered a Lisp error)')
     535        self._display2d = False
     536
     537    def _quit_string(self):
     538        """
     539        EXAMPLES::
     540       
     541            sage: maxima._quit_string()
     542            'quit();'
     543        """
     544        return 'quit();'
     545
     546    def _crash_msg(self):
     547        """
     548        EXAMPLES::
     549       
     550            sage: maxima._crash_msg()
     551            Maxima crashed -- automatically restarting.
     552        """
     553        print "Maxima crashed -- automatically restarting."
     554
     555
     556    def _batch(self, s, batchload=True):
     557        filename = '%s-%s'%(self._local_tmpfile(),randrange(2147483647))
     558        F = open(filename, 'w')
     559        F.write(s)
     560        F.close()
     561        if self.is_remote():
     562            self._send_tmpfile_to_server(local_file=filename)
     563            tmp_to_use = self._remote_tmpfile()
     564        tmp_to_use = filename
     565       
     566        if batchload:
     567            cmd = 'batchload("%s");'%tmp_to_use
     568        else:
     569            cmd = 'batch("%s");'%tmp_to_use
     570
     571        r = randrange(2147483647)
     572        s = str(r+1)
     573        cmd = "%s1+%s;\n"%(cmd,r)
     574
     575        self._sendline(cmd)
     576        self._expect_expr(s)
     577        out = self._before()
     578        self._error_check(str, out)
     579        os.unlink(filename)
     580        return out
     581
     582    def _error_check(self, str, out):
     583        r = self._error_re
     584        m = r.search(out)
     585        if not m is None:
     586            self._error_msg(str, out)
     587           
     588    def _error_msg(self, str, out):
     589        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);',''))
     590
     591
     592    ###########################################
     593    # System -- change directory, etc
     594    ###########################################
     595    def chdir(self, dir):
     596        """
     597        Change Maxima's current working directory.
     598       
     599        EXAMPLES::
     600       
     601            sage: maxima.chdir('/')
     602        """
     603        self.lisp('(ext::cd "%s")'%dir)
     604       
     605    ###########################################
     606    # Interactive help
     607    ###########################################
     608
     609
     610    def help(self, s):
     611        """
     612        EXAMPLES::
     613       
     614            sage: maxima.help('gcd')
     615            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     616            ...
     617        """
     618        return self._command_runner("describe", s)
     619
     620    def example(self, s):
     621        """
     622        EXAMPLES::
     623       
     624            sage: maxima.example('arrays')
     625            a[n]:=n*a[n-1]
     626                                            a  := n a
     627                                             n       n - 1
     628            a[0]:1
     629            a[5]
     630                                                  120
     631            a[n]:=n
     632            a[6]
     633                                                   6
     634            a[4]
     635                                                  24
     636                                                 done
     637        """
     638        return self._command_runner("example", s)
     639
     640    describe = help
     641
     642    def demo(self, s):
     643        """
     644        EXAMPLES::
     645       
     646            sage: maxima.demo('array') # not tested
     647            batching /opt/sage/local/share/maxima/5.16.3/demo/array.dem
     648       
     649        At the _ prompt, type ';' followed by enter to get next demo
     650        subscrmap : true _
     651        """
     652        return self._command_runner("demo", s, redirect=False)
     653
     654    def completions(self, s, verbose=True):
     655        """
     656        Return all commands that complete the command starting with the
     657        string s. This is like typing s[tab] in the Maxima interpreter.
     658       
     659        EXAMPLES::
     660       
     661            sage: sorted(maxima.completions('gc', verbose=False))
     662            ['gcd', 'gcdex', 'gcfactor', 'gcprint', 'gctime']
     663        """
     664        if verbose:
     665            print s,
     666            sys.stdout.flush()
     667        # in Maxima 5.19.1, apropos returns all commands that contain
     668        # the given string, instead of all commands that start with
     669        # the given string
     670        cmd_list = self._eval_line('apropos("%s")'%s, error_check=False).replace('\\ - ','-')
     671        cmd_list = [x for x in cmd_list[1:-1].split(',') if x[0] != '?']
     672        return [x for x in cmd_list if x.find(s) == 0]
     673
     674    def _commands(self, verbose=True):
     675        """
     676        Return list of all commands defined in Maxima.
     677       
     678        EXAMPLES::
     679       
     680            sage: sorted(maxima._commands(verbose=False))
     681            ['Alpha',
     682             'Beta',
     683             ...
     684             'zunderflow']
     685        """
     686        try:
     687            return self.__commands
     688        except AttributeError:
     689            self.__commands = sum(
     690                [self.completions(chr(65+n), verbose=verbose)+
     691                 self.completions(chr(97+n), verbose=verbose)
     692                 for n in range(26)], [])
     693        return self.__commands
     694
     695    def trait_names(self, verbose=True, use_disk_cache=True):
     696        """
     697        Return all Maxima commands, which is useful for tab completion.
     698       
     699        EXAMPLES::
     700       
     701            sage: t = maxima.trait_names(verbose=False)
     702            sage: 'gcd' in t
     703            True
     704            sage: len(t)    # random output
     705            1840
     706        """
     707        try:
     708            return self.__trait_names
     709        except AttributeError:
     710            import sage.misc.persist
     711            if use_disk_cache:
     712                try:
     713                    self.__trait_names = sage.misc.persist.load(COMMANDS_CACHE)
     714                    return self.__trait_names
     715                except IOError:
     716                    pass
     717            if verbose:
     718                print "\nBuilding Maxima command completion list (this takes"
     719                print "a few seconds only the first time you do it)."
     720                print "To force rebuild later, delete %s."%COMMANDS_CACHE
     721            v = self._commands(verbose=verbose)
     722            if verbose:
     723                print "\nDone!"
     724            self.__trait_names = v
     725            sage.misc.persist.save(v, COMMANDS_CACHE)
     726            return v
     727
     728    def _true_symbol(self):
     729        """
     730        Return the true symbol in Maxima.
     731       
     732        EXAMPLES::
     733       
     734            sage: maxima._true_symbol()
     735            'true'
     736            sage: maxima.eval('is(2 = 2)')
     737            'true'
     738        """
     739        return 'true'
     740
     741    def _false_symbol(self):
     742        """
     743        Return the false symbol in Maxima.
     744       
     745        EXAMPLES::
     746       
     747            sage: maxima._false_symbol()
     748            'false'
     749            sage: maxima.eval('is(2 = 4)')
     750            'false'
     751        """
     752        return 'false'
     753
     754    def _equality_symbol(self):
     755        """
     756        Returns the equality symbol in Maxima.
     757
     758        EXAMPLES::
     759
     760             sage: maxima._equality_symbol()
     761             '='
     762        """
     763        return '='
     764
     765    def _inequality_symbol(self):
     766        """
     767        Returns the equality symbol in Maxima.
     768
     769        EXAMPLES::
     770
     771             sage: maxima._inequality_symbol()
     772             '#'
     773             sage: maxima((x != 1))
     774             x#1
     775        """
     776        return '#'
     777           
     778    def console(self):
     779        r"""
     780        Start the interactive Maxima console. This is a completely separate
     781        maxima session from this interface. To interact with this session,
     782        you should instead use ``maxima.interact()``.
     783       
     784        EXAMPLES::
     785       
     786            sage: maxima.console()             # not tested (since we can't)
     787            Maxima 5.13.0 http://maxima.sourceforge.net
     788            Using Lisp CLISP 2.41 (2006-10-13)
     789            Distributed under the GNU Public License. See the file COPYING.
     790            Dedicated to the memory of William Schelter.
     791            This is a development version of Maxima. The function bug_report()
     792            provides bug reporting information.
     793            (%i1)
     794       
     795        ::
     796       
     797            sage: maxima.interact()     # this is not tested either
     798              --> Switching to Maxima <--
     799            maxima: 2+2
     800            4
     801            maxima:
     802              --> Exiting back to Sage <--
     803        """
     804        maxima_console()
     805
     806    def cputime(self, t=None):
     807        r"""
     808        Returns the amount of CPU time that this Maxima session has used.
     809        If \var{t} is not None, then it returns the difference between
     810        the current CPU time and \var{t}.
     811       
     812        EXAMPLES:
     813            sage: t = maxima.cputime()
     814            sage: _ = maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
     815            sage: maxima.cputime(t) # output random
     816            0.568913
     817        """
     818        if t:
     819            return float(self.eval('elapsed_run_time()')) - t
     820        else:
     821            return float(self.eval('elapsed_run_time()'))
     822
     823
     824##     def display2d(self, flag=True):
     825##         """
     826##         Set the flag that determines whether Maxima objects are
     827##         printed using their 2-d ASCII art representation.  When the
     828##         maxima interface starts the default is that objects are not
     829##         represented in 2-d.
     830
     831##         INPUT:
     832##             flag -- bool (default: True)
     833
     834##         EXAMPLES
     835##             sage: maxima('1/2')
     836##             1/2
     837##             sage: maxima.display2d(True)
     838##             sage: maxima('1/2')
     839##                                            1
     840##                                            -
     841##                                            2
     842##             sage: maxima.display2d(False)
     843##         """
     844##         self._display2d = bool(flag)
     845
     846    def plot2d(self, *args):
     847        r"""
     848        Plot a 2d graph using Maxima / gnuplot.
     849       
     850        maxima.plot2d(f, '[var, min, max]', options)
     851       
     852        INPUT:
     853       
     854       
     855        -  ``f`` - a string representing a function (such as
     856           f="sin(x)") [var, xmin, xmax]
     857       
     858        -  ``options`` - an optional string representing plot2d
     859           options in gnuplot format
     860       
     861       
     862        EXAMPLES::
     863       
     864            sage: maxima.plot2d('sin(x)','[x,-5,5]')   # not tested
     865            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
     866            sage: maxima.plot2d('sin(x)','[x,-5,5]',opts)    # not tested
     867       
     868        The eps file is saved in the current directory.
     869        """
     870        self('plot2d(%s)'%(','.join([str(x) for x in args])))
     871
     872    def plot2d_parametric(self, r, var, trange, nticks=50, options=None):
     873        r"""
     874        Plots r = [x(t), y(t)] for t = tmin...tmax using gnuplot with
     875        options
     876       
     877        INPUT:
     878       
     879       
     880        -  ``r`` - a string representing a function (such as
     881           r="[x(t),y(t)]")
     882       
     883        -  ``var`` - a string representing the variable (such
     884           as var = "t")
     885       
     886        -  ``trange`` - [tmin, tmax] are numbers with tmintmax
     887       
     888        -  ``nticks`` - int (default: 50)
     889       
     890        -  ``options`` - an optional string representing plot2d
     891           options in gnuplot format
     892       
     893       
     894        EXAMPLES::
     895       
     896            sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t",[-3.1,3.1])   # not tested
     897       
     898        ::
     899       
     900            sage: opts = '[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "circle-plot.eps"]'
     901            sage: maxima.plot2d_parametric(["sin(t)","cos(t)"], "t", [-3.1,3.1], options=opts)   # not tested
     902       
     903        The eps file is saved to the current working directory.
     904       
     905        Here is another fun plot::
     906       
     907            sage: maxima.plot2d_parametric(["sin(5*t)","cos(11*t)"], "t", [0,2*pi()], nticks=400)    # not tested
     908        """
     909        tmin = trange[0]
     910        tmax = trange[1]
     911        cmd = "plot2d([parametric, %s, %s, [%s, %s, %s], [nticks, %s]]"%( \
     912                   r[0], r[1], var, tmin, tmax, nticks)
     913        if options is None:
     914            cmd += ")"
     915        else:
     916            cmd += ", %s)"%options
     917        self(cmd)
     918
     919    def plot3d(self, *args):
     920        r"""
     921        Plot a 3d graph using Maxima / gnuplot.
     922       
     923        maxima.plot3d(f, '[x, xmin, xmax]', '[y, ymin, ymax]', '[grid, nx,
     924        ny]', options)
     925       
     926        INPUT:
     927       
     928       
     929        -  ``f`` - a string representing a function (such as
     930           f="sin(x)") [var, min, max]
     931       
     932       
     933        EXAMPLES::
     934       
     935            sage: maxima.plot3d('1 + x^3 - y^2', '[x,-2,2]', '[y,-2,2]', '[grid,12,12]')    # not tested
     936            sage: maxima.plot3d('sin(x)*cos(y)', '[x,-2,2]', '[y,-2,2]', '[grid,30,30]')   # not tested
     937            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-plot.eps"]'
     938            sage: maxima.plot3d('sin(x+y)', '[x,-5,5]', '[y,-1,1]', opts)    # not tested
     939       
     940        The eps file is saved in the current working directory.
     941        """
     942        self('plot3d(%s)'%(','.join([str(x) for x in args])))
     943
     944    def plot3d_parametric(self, r, vars, urange, vrange, options=None):
     945        r"""
     946        Plot a 3d parametric graph with r=(x,y,z), x = x(u,v), y = y(u,v),
     947        z = z(u,v), for u = umin...umax, v = vmin...vmax using gnuplot with
     948        options.
     949       
     950        INPUT:
     951       
     952       
     953        -  ``x, y, z`` - a string representing a function (such
     954           as ``x="u2+v2"``, ...) vars is a list or two strings
     955           representing variables (such as vars = ["u","v"])
     956       
     957        -  ``urange`` - [umin, umax]
     958       
     959        -  ``vrange`` - [vmin, vmax] are lists of numbers with
     960           umin umax, vmin vmax
     961       
     962        -  ``options`` - optional string representing plot2d
     963           options in gnuplot format
     964       
     965       
     966        OUTPUT: displays a plot on screen or saves to a file
     967       
     968        EXAMPLES::
     969       
     970            sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3])     # not tested
     971            sage: opts = '[gnuplot_term, ps], [gnuplot_out_file, "sin-cos-plot.eps"]'
     972            sage: maxima.plot3d_parametric(["v*sin(u)","v*cos(u)","v"], ["u","v"],[-3.2,3.2],[0,3],opts)      # not tested
     973       
     974        The eps file is saved in the current working directory.
     975       
     976        Here is a torus::
     977       
     978            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
     979            sage: maxima.plot3d_parametric(["expr_1","expr_2","expr_3"], ["x","y"],[0,6],[0,6])   # not tested
     980       
     981        Here is a Mobius strip::
     982       
     983            sage: x = "cos(u)*(3 + v*cos(u/2))"
     984            sage: y = "sin(u)*(3 + v*cos(u/2))"
     985            sage: z = "v*sin(u/2)"
     986            sage: maxima.plot3d_parametric([x,y,z],["u","v"],[-3.1,3.2],[-1/10,1/10])   # not tested
     987        """
     988        umin = urange[0]
     989        umax = urange[1]
     990        vmin = vrange[0]
     991        vmax = vrange[1]
     992        cmd = 'plot3d([%s, %s, %s], [%s, %s, %s], [%s, %s, %s]'%(
     993            r[0], r[1], r[2], vars[0], umin, umax, vars[1], vmin, vmax)
     994        if options is None:
     995            cmd += ')'
     996        else:
     997            cmd += ', %s)'%options
     998        self(cmd)
     999
     1000    def de_solve(self, de, vars, ics=None):
     1001        """
     1002        Solves a 1st or 2nd order ordinary differential equation (ODE) in
     1003        two variables, possibly with initial conditions.
     1004       
     1005        INPUT:
     1006       
     1007       
     1008        -  ``de`` - a string representing the ODE
     1009       
     1010        -  ``vars`` - a list of strings representing the two
     1011           variables.
     1012       
     1013        -  ``ics`` - a triple of numbers [a,b1,b2] representing
     1014           y(a)=b1, y'(a)=b2
     1015       
     1016       
     1017        EXAMPLES::
     1018       
     1019            sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'], [1,1,1])
     1020            y=3*x-2*%e^(x-1)
     1021            sage: maxima.de_solve('diff(y,x,2) + 3*x = y', ['x','y'])
     1022            y=%k1*%e^x+%k2*%e^-x+3*x
     1023            sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'])
     1024            y=(%c-3*(-x-1)*%e^-x)*%e^x
     1025            sage: maxima.de_solve('diff(y,x) + 3*x = y', ['x','y'],[1,1])
     1026            y=-%e^-1*(5*%e^x-3*%e*x-3*%e)
     1027        """
     1028        if not isinstance(vars, str):
     1029            str_vars = '%s, %s'%(vars[1], vars[0])
     1030        else:
     1031            str_vars = vars
     1032        self.eval('depends(%s)'%str_vars)
     1033        m = self(de)
     1034        a = 'ode2(%s, %s)'%(m.name(), str_vars)
     1035        if ics != None:
     1036            if len(ics) == 3:
     1037                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])
     1038                return self(cmd)
     1039            if len(ics) == 2:
     1040                return self("ic1("+a+",%s=%s,%s=%s);"%(vars[0],ics[0], vars[1],ics[1]))
     1041        return self(a+";")
     1042
     1043    def de_solve_laplace(self, de, vars, ics=None):
     1044        """
     1045        Solves an ordinary differential equation (ODE) using Laplace
     1046        transforms.
     1047       
     1048        INPUT:
     1049       
     1050       
     1051        -  ``de`` - a string representing the ODE (e.g., de =
     1052           "diff(f(x),x,2)=diff(f(x),x)+sin(x)")
     1053       
     1054        -  ``vars`` - a list of strings representing the
     1055           variables (e.g., vars = ["x","f"])
     1056       
     1057        -  ``ics`` - a list of numbers representing initial
     1058           conditions, with symbols allowed which are represented by strings
     1059           (eg, f(0)=1, f'(0)=2 is ics = [0,1,2])
     1060       
     1061       
     1062        EXAMPLES::
     1063       
     1064            sage: maxima.clear('x'); maxima.clear('f')
     1065            sage: maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"], [0,1,2])
     1066            f(x)=x*%e^x+%e^x
     1067       
     1068        ::
     1069       
     1070            sage: maxima.clear('x'); maxima.clear('f')           
     1071            sage: f = maxima.de_solve_laplace("diff(f(x),x,2) = 2*diff(f(x),x)-f(x)", ["x","f"])
     1072            sage: f
     1073            f(x)=x*%e^x*('at('diff(f(x),x,1),x=0))-f(0)*x*%e^x+f(0)*%e^x
     1074            sage: print f
     1075                                               !
     1076                                   x  d        !                  x          x
     1077                        f(x) = x %e  (-- (f(x))!     ) - f(0) x %e  + f(0) %e
     1078                                      dx       !
     1079                                               !x = 0
     1080       
     1081        .. note::
     1082
     1083           The second equation sets the values of `f(0)` and
     1084           `f'(0)` in Maxima, so subsequent ODEs involving these
     1085           variables will have these initial conditions automatically
     1086           imposed.
     1087        """
     1088        if not (ics is None):
     1089            d = len(ics)
     1090            for i in range(0,d-1):
     1091                ic = 'atvalue(diff(%s(%s), %s, %s), %s = %s, %s)'%(
     1092                    vars[1], vars[0], vars[0], i, vars[0], ics[0], ics[1+i])
     1093                self.eval(ic)
     1094        return self('desolve(%s, %s(%s))'%(de, vars[1], vars[0]))
     1095
     1096    def solve_linear(self, eqns,vars):
     1097        """
     1098        Wraps maxima's linsolve.
     1099       
     1100        INPUT: eqns is a list of m strings, each representing a linear
     1101        question in m = n variables vars is a list of n strings, each
     1102        representing a variable
     1103       
     1104        EXAMPLES::
     1105       
     1106            sage: eqns = ["x + z = y","2*a*x - y = 2*a^2","y - 2*z = 2"]   
     1107            sage: vars = ["x","y","z"]                                     
     1108            sage: maxima.solve_linear(eqns, vars)
     1109            [x=a+1,y=2*a,z=a-1]
     1110        """
     1111        eqs = "["
     1112        for i in range(len(eqns)):
     1113            if i<len(eqns)-1:
     1114                eqs = eqs + eqns[i]+","
     1115            if  i==len(eqns)-1:
     1116                eqs = eqs + eqns[i]+"]"
     1117        vrs = "["
     1118        for i in range(len(vars)):
     1119            if i<len(vars)-1:
     1120                vrs = vrs + vars[i]+","
     1121            if  i==len(vars)-1:
     1122                vrs = vrs + vars[i]+"]"
     1123        return self('linsolve(%s, %s)'%(eqs, vrs))
     1124
     1125    def unit_quadratic_integer(self, n):
     1126        r"""
     1127        Finds a unit of the ring of integers of the quadratic number field
     1128        `\QQ(\sqrt{n})`, `n>1`, using the qunit maxima
     1129        command.
     1130       
     1131        EXAMPLES::
     1132       
     1133            sage: u = maxima.unit_quadratic_integer(101); u     
     1134            a + 10
     1135            sage: u.parent()                                       
     1136            Number Field in a with defining polynomial x^2 - 101
     1137            sage: u = maxima.unit_quadratic_integer(13)           
     1138            sage: u                                               
     1139            5*a + 18
     1140            sage: u.parent()                                       
     1141            Number Field in a with defining polynomial x^2 - 13
     1142        """
     1143        from sage.rings.all import QuadraticField, Integer
     1144        # Take square-free part so sqrt(n) doesn't get simplified further by maxima
     1145        # (The original version of this function would yield wrong answers if
     1146        # n is not squarefree.)
     1147        n = Integer(n).squarefree_part() 
     1148        if n < 1:
     1149            raise ValueError, "n (=%s) must be >= 1"%n
     1150        s = repr(self('qunit(%s)'%n)).lower()
     1151        r = re.compile('sqrt\(.*\)')
     1152        s = r.sub('a', s)
     1153        a = QuadraticField(n, 'a').gen()
     1154        return eval(s)
     1155
     1156    def plot_list(self, ptsx, ptsy, options=None):
     1157        r"""
     1158        Plots a curve determined by a sequence of points.
     1159       
     1160        INPUT:
     1161       
     1162       
     1163        -  ``ptsx`` - [x1,...,xn], where the xi and yi are
     1164           real,
     1165       
     1166        -  ``ptsy`` - [y1,...,yn]
     1167       
     1168        -  ``options`` - a string representing maxima plot2d
     1169           options.
     1170       
     1171       
     1172        The points are (x1,y1), (x2,y2), etc.
     1173       
     1174        This function requires maxima 5.9.2 or newer.
     1175       
     1176        .. note::
     1177
     1178           More that 150 points can sometimes lead to the program
     1179           hanging. Why?
     1180       
     1181        EXAMPLES::
     1182       
     1183            sage: zeta_ptsx = [ (pari(1/2 + i*I/10).zeta().real()).precision(1) for i in range (70,150)] 
     1184            sage: zeta_ptsy = [ (pari(1/2 + i*I/10).zeta().imag()).precision(1) for i in range (70,150)] 
     1185            sage: maxima.plot_list(zeta_ptsx, zeta_ptsy)         # not tested
     1186            sage: opts='[gnuplot_preamble, "set nokey"], [gnuplot_term, ps], [gnuplot_out_file, "zeta.eps"]'
     1187            sage: maxima.plot_list(zeta_ptsx, zeta_ptsy, opts)      # not tested
     1188        """
     1189        cmd = 'plot2d([discrete,%s, %s]'%(ptsx, ptsy)
     1190        if options is None:
     1191            cmd += ')'
     1192        else:
     1193            cmd += ', %s)'%options
     1194        self(cmd)
     1195       
     1196
     1197    def plot_multilist(self, pts_list, options=None):
     1198        r"""
     1199        Plots a list of list of points pts_list=[pts1,pts2,...,ptsn],
     1200        where each ptsi is of the form [[x1,y1],...,[xn,yn]] x's must be
     1201        integers and y's reals options is a string representing maxima
     1202        plot2d options.
     1203       
     1204        Requires maxima 5.9.2 at least.
     1205
     1206        .. note::
     1207
     1208           More that 150 points can sometimes lead to the program
     1209           hanging.
     1210       
     1211        EXAMPLES::
     1212       
     1213            sage: xx = [ i/10.0 for i in range (-10,10)]
     1214            sage: yy = [ i/10.0 for i in range (-10,10)]
     1215            sage: x0 = [ 0 for i in range (-10,10)]
     1216            sage: y0 = [ 0 for i in range (-10,10)]
     1217            sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10)]
     1218            sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10)]
     1219            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])       # not tested
     1220            sage: zeta_ptsx1 = [ (pari(1/2+i*I/10).zeta().real()).precision(1) for i in range (10,150)]
     1221            sage: zeta_ptsy1 = [ (pari(1/2+i*I/10).zeta().imag()).precision(1) for i in range (10,150)]
     1222            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]])      # not tested
     1223            sage: opts='[gnuplot_preamble, "set nokey"]'                 
     1224            sage: maxima.plot_multilist([[zeta_ptsx1,zeta_ptsy1],[xx,y0],[x0,yy]],opts)    # not tested
     1225        """
     1226        n = len(pts_list)
     1227        cmd = '['
     1228        for i in range(n):
     1229            if i < n-1:
     1230                cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+'],'
     1231            if i==n-1:
     1232                cmd = cmd+'[discrete,'+str(pts_list[i][0])+','+str(pts_list[i][1])+']]'
     1233        #print cmd
     1234        if options is None:
     1235            self('plot2d('+cmd+')')
     1236        else:
     1237            self('plot2d('+cmd+','+options+')')
     1238   
     1239
     1240class MaximaElement(ExpectElement):
     1241    def __str__(self):
     1242        """
     1243        Printing an object explicitly gives ASCII art:
     1244       
     1245        EXAMPLES::
     1246       
     1247            sage: f = maxima('1/(x-1)^3'); f
     1248            1/(x-1)^3
     1249            sage: print f
     1250                                                  1
     1251                                               --------
     1252                                                      3
     1253                                               (x - 1)
     1254        """
     1255        return self.display2d(onscreen=False)
     1256
     1257    def bool(self):
     1258        """
     1259        EXAMPLES::
     1260       
     1261            sage: maxima(0).bool()
     1262            False
     1263            sage: maxima(1).bool()
     1264            True
     1265        """
     1266        P = self._check_valid()
     1267        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
     1268
     1269    def __cmp__(self, other):
     1270        """
     1271        EXAMPLES::
     1272       
     1273            sage: a = maxima(1); b = maxima(2)
     1274            sage: a == b
     1275            False
     1276            sage: a < b
     1277            True
     1278            sage: a > b
     1279            False
     1280            sage: b < a
     1281            False
     1282            sage: b > a
     1283            True
     1284       
     1285        We can also compare more complicated object such as functions::
     1286       
     1287            sage: f = maxima('sin(x)'); g = maxima('cos(x)')
     1288            sage: -f == g.diff('x')
     1289            True
     1290        """
     1291
     1292        # thanks to David Joyner for telling me about using "is".
     1293        # but be careful, since for relations things like is(equal(a,b)) are what Maxima needs
     1294        P = self.parent()
     1295        try:
     1296            if P.eval("is (%s < %s)"%(self.name(), other.name())) == P._true_symbol():
     1297                return -1
     1298            elif P.eval("is (%s > %s)"%(self.name(), other.name())) == P._true_symbol():
     1299                return 1
     1300            elif P.eval("is (%s = %s)"%(self.name(), other.name())) == P._true_symbol():
     1301                return 0
     1302        except TypeError:
     1303            pass
     1304        return cmp(repr(self),repr(other))
     1305                   # everything is supposed to be comparable in Python, so we define
     1306                   # the comparison thus when no comparable in interfaced system.
     1307
     1308    def _sage_(self):
     1309        """
     1310        Attempt to make a native Sage object out of this maxima object.
     1311        This is useful for automatic coercions in addition to other
     1312        things.
     1313       
     1314        EXAMPLES::
     1315       
     1316            sage: a = maxima('sqrt(2) + 2.5'); a
     1317            sqrt(2)+2.5
     1318            sage: b = a._sage_(); b
     1319            sqrt(2) + 2.5
     1320            sage: type(b)
     1321            <type 'sage.symbolic.expression.Expression'>
     1322       
     1323        We illustrate an automatic coercion::
     1324       
     1325            sage: c = b + sqrt(3); c
     1326            sqrt(2) + sqrt(3) + 2.5
     1327            sage: type(c)
     1328            <type 'sage.symbolic.expression.Expression'>
     1329            sage: d = sqrt(3) + b; d
     1330            sqrt(2) + sqrt(3) + 2.5
     1331            sage: type(d)
     1332            <type 'sage.symbolic.expression.Expression'>
     1333       
     1334            sage: a = sage.calculus.calculus.maxima('x^(sqrt(y)+%pi) + sin(%e + %pi)')
     1335            sage: a._sage_()
     1336            x^(pi + sqrt(y)) - sin(e)
     1337            sage: var('x, y')
     1338            (x, y)
     1339            sage: v = sage.calculus.calculus.maxima.vandermonde_matrix([x, y, 1/2])
     1340            sage: v._sage_()
     1341            [  1   x x^2]
     1342            [  1   y y^2]
     1343            [  1 1/2 1/4]
     1344
     1345        Check if #7661 is fixed::
     1346
     1347            sage: var('delta')
     1348            delta
     1349            sage: (2*delta).simplify()
     1350            2*delta
     1351        """
     1352        import sage.calculus.calculus as calculus
     1353        return calculus.symbolic_expression_from_maxima_string(self.name(),
     1354                maxima=self.parent())
     1355
     1356    def _symbolic_(self, R):
     1357        """
     1358        Return a symbolic expression equivalent to this maxima object.
     1359
     1360        EXAMPLES::
     1361
     1362            sage: t = sqrt(2)._maxima_()
     1363            sage: u = t._symbolic_(SR); u
     1364            sqrt(2)
     1365            sage: u.parent()
     1366            Symbolic Ring
     1367
     1368        This is used when converting maxima objects to the Symbolic Ring::
     1369
     1370            sage: SR(t)
     1371            sqrt(2)
     1372        """
     1373        return R(self._sage_())
     1374
     1375    def __complex__(self):
     1376        """
     1377        EXAMPLES::
     1378       
     1379            sage: complex(maxima('sqrt(-2)+1'))
     1380            (1+1.4142135623730951j)
     1381        """
     1382        return complex(self._sage_())
     1383
     1384    def _complex_mpfr_field_(self, C):
     1385        """
     1386        EXAMPLES::
     1387       
     1388            sage: CC(maxima('1+%i'))
     1389             1.00000000000000 + 1.00000000000000*I
     1390            sage: CC(maxima('2342.23482943872+234*%i'))
     1391             2342.23482943872 + 234.000000000000*I
     1392            sage: ComplexField(10)(maxima('2342.23482943872+234*%i'))
     1393             2300. + 230.*I
     1394            sage: ComplexField(200)(maxima('1+%i'))
     1395            1.0000000000000000000000000000000000000000000000000000000000 + 1.0000000000000000000000000000000000000000000000000000000000*I
     1396            sage: ComplexField(200)(maxima('sqrt(-2)'))
     1397            1.4142135623730950488016887242096980785696718753769480731767*I
     1398            sage: N(sqrt(-2), 200)
     1399            8.0751148893563733350506651837615871941533119425962889089783e-62 + 1.4142135623730950488016887242096980785696718753769480731767*I
     1400        """
     1401        return C(self._sage_())
     1402
     1403    def _mpfr_(self, R):
     1404        """
     1405        EXAMPLES::
     1406       
     1407            sage: RealField(100)(maxima('sqrt(2)+1'))
     1408            2.4142135623730950488016887242
     1409        """
     1410        return R(self._sage_())
     1411
     1412    def _complex_double_(self, C):
     1413        """
     1414        EXAMPLES::
     1415       
     1416            sage: CDF(maxima('sqrt(2)+1'))
     1417            2.41421356237
     1418        """
     1419        return C(self._sage_())
     1420
     1421    def _real_double_(self, R):
     1422        """
     1423        EXAMPLES::
     1424       
     1425            sage: RDF(maxima('sqrt(2)+1'))
     1426            2.41421356237
     1427        """
     1428        return R(self._sage_())
     1429
     1430    def real(self):
     1431        """
     1432        Return the real part of this maxima element.
     1433       
     1434        EXAMPLES::
     1435       
     1436            sage: maxima('2 + (2/3)*%i').real()
     1437            2
     1438        """
     1439        return self.realpart()
     1440
     1441    def imag(self):
     1442        """
     1443        Return the imaginary part of this maxima element.
     1444       
     1445        EXAMPLES::
     1446       
     1447            sage: maxima('2 + (2/3)*%i').imag()
     1448            2/3
     1449        """
     1450        return self.imagpart()
     1451
     1452    def numer(self):
     1453        """
     1454        Return numerical approximation to self as a Maxima object.
     1455       
     1456        EXAMPLES::
     1457       
     1458            sage: a = maxima('sqrt(2)').numer(); a
     1459            1.414213562373095
     1460            sage: type(a)
     1461            <class 'sage.interfaces.maxima_abstract.MaximaElement'>
     1462        """
     1463        return self.comma('numer')
     1464
     1465    def str(self):
     1466        """
     1467        Return string representation of this maxima object.
     1468       
     1469        EXAMPLES::
     1470       
     1471            sage: maxima('sqrt(2) + 1/3').str()
     1472            'sqrt(2)+1/3'
     1473        """
     1474        P = self._check_valid()
     1475        return P.get(self._name)
     1476
     1477    def __repr__(self):
     1478        """
     1479        Return print representation of this object.
     1480       
     1481        EXAMPLES::
     1482       
     1483            sage: maxima('sqrt(2) + 1/3').__repr__()
     1484            'sqrt(2)+1/3'
     1485        """
     1486        P = self._check_valid()
     1487        try:
     1488            return self.__repr
     1489        except AttributeError:
     1490            pass
     1491        r = P.get(self._name)
     1492        self.__repr = r
     1493        return r
     1494
     1495    def display2d(self, onscreen=True):
     1496        """
     1497        EXAMPLES::
     1498       
     1499            sage: F = maxima('x^5 - y^5').factor() 
     1500            sage: F.display2d ()             
     1501                                   4      3    2  2    3      4
     1502                       - (y - x) (y  + x y  + x  y  + x  y + x )
     1503        """
     1504        self._check_valid()
     1505        P = self.parent()
     1506        with gc_disabled():
     1507            P._eval_line('display2d : true$')
     1508            s = P._eval_line('disp(%s)$'%self.name(), reformat=False)
     1509            P._eval_line('display2d: false$')
     1510           
     1511        s = s.strip('\r\n')
     1512
     1513        # if ever want to dedent, see
     1514        # http://mail.python.org/pipermail/python-list/2006-December/420033.html
     1515        if onscreen:
     1516            print s
     1517        else:
     1518            return s
     1519
     1520    def diff(self, var='x', n=1):
     1521        """
     1522        Return the n-th derivative of self.
     1523       
     1524        INPUT:
     1525       
     1526       
     1527        -  ``var`` - variable (default: 'x')
     1528       
     1529        -  ``n`` - integer (default: 1)
     1530       
     1531       
     1532        OUTPUT: n-th derivative of self with respect to the variable var
     1533       
     1534        EXAMPLES::
     1535       
     1536            sage: f = maxima('x^2')                         
     1537            sage: f.diff()                                   
     1538            2*x
     1539            sage: f.diff('x')                               
     1540            2*x
     1541            sage: f.diff('x', 2)                             
     1542            2
     1543            sage: maxima('sin(x^2)').diff('x',4)
     1544            16*x^4*sin(x^2)-12*sin(x^2)-48*x^2*cos(x^2)
     1545       
     1546        ::
     1547       
     1548            sage: f = maxima('x^2 + 17*y^2')                 
     1549            sage: f.diff('x')
     1550            34*y*'diff(y,x,1)+2*x
     1551            sage: f.diff('y')                               
     1552            34*y
     1553        """
     1554        return ExpectElement.__getattr__(self, 'diff')(var, n)
     1555
     1556    derivative = diff
     1557
     1558    def nintegral(self, var='x', a=0, b=1,
     1559                  desired_relative_error='1e-8',
     1560                  maximum_num_subintervals=200):
     1561        r"""
     1562        Return a numerical approximation to the integral of self from a to
     1563        b.
     1564       
     1565        INPUT:
     1566       
     1567       
     1568        -  ``var`` - variable to integrate with respect to
     1569       
     1570        -  ``a`` - lower endpoint of integration
     1571       
     1572        -  ``b`` - upper endpoint of integration
     1573       
     1574        -  ``desired_relative_error`` - (default: '1e-8') the
     1575           desired relative error
     1576       
     1577        -  ``maximum_num_subintervals`` - (default: 200)
     1578           maxima number of subintervals
     1579       
     1580       
     1581        OUTPUT:
     1582       
     1583       
     1584        -  approximation to the integral
     1585       
     1586        -  estimated absolute error of the
     1587           approximation
     1588       
     1589        -  the number of integrand evaluations
     1590       
     1591        -  an error code:
     1592       
     1593            -  ``0`` - no problems were encountered
     1594
     1595            -  ``1`` - too many subintervals were done
     1596
     1597            -  ``2`` - excessive roundoff error
     1598
     1599            -  ``3`` - extremely bad integrand behavior
     1600
     1601            -  ``4`` - failed to converge
     1602
     1603            -  ``5`` - integral is probably divergent or slowly convergent
     1604
     1605            -  ``6`` - the input is invalid
     1606       
     1607       
     1608        EXAMPLES::
     1609       
     1610            sage: maxima('exp(-sqrt(x))').nintegral('x',0,1)
     1611            (.5284822353142306, 4.163314137883845e-11, 231, 0)
     1612       
     1613        Note that GP also does numerical integration, and can do so to very
     1614        high precision very quickly::
     1615       
     1616            sage: gp('intnum(x=0,1,exp(-sqrt(x)))')           
     1617            0.5284822353142307136179049194             # 32-bit
     1618            0.52848223531423071361790491935415653021   # 64-bit
     1619            sage: _ = gp.set_precision(80)
     1620            sage: gp('intnum(x=0,1,exp(-sqrt(x)))')
     1621            0.52848223531423071361790491935415653021675547587292866196865279321015401702040079
     1622        """
     1623        from sage.rings.all import Integer
     1624        v = self.quad_qags(var, a, b, epsrel=desired_relative_error,
     1625                           limit=maximum_num_subintervals)
     1626        return v[0], v[1], Integer(v[2]), Integer(v[3])
     1627
     1628    def integral(self, var='x', min=None, max=None):
     1629        r"""
     1630        Return the integral of self with respect to the variable x.
     1631       
     1632        INPUT:
     1633       
     1634       
     1635        -  ``var`` - variable
     1636       
     1637        -  ``min`` - default: None
     1638       
     1639        -  ``max`` - default: None
     1640       
     1641       
     1642        Returns the definite integral if xmin is not None, otherwise
     1643        returns an indefinite integral.
     1644       
     1645        EXAMPLES::
     1646       
     1647            sage: maxima('x^2+1').integral()                   
     1648            x^3/3+x
     1649            sage: maxima('x^2+ 1 + y^2').integral('y')         
     1650            y^3/3+x^2*y+y
     1651            sage: maxima('x / (x^2+1)').integral()             
     1652            log(x^2+1)/2
     1653            sage: maxima('1/(x^2+1)').integral()               
     1654            atan(x)
     1655            sage: maxima('1/(x^2+1)').integral('x', 0, infinity)
     1656            %pi/2
     1657            sage: maxima('x/(x^2+1)').integral('x', -1, 1)     
     1658            0
     1659       
     1660        ::
     1661       
     1662            sage: f = maxima('exp(x^2)').integral('x',0,1); f   
     1663            -sqrt(%pi)*%i*erf(%i)/2
     1664            sage: f.numer()
     1665            1.462651745907182
     1666        """
     1667        I = ExpectElement.__getattr__(self, 'integrate')
     1668        if min is None:
     1669            return I(var)
     1670        else:
     1671            if max is None:
     1672                raise ValueError, "neither or both of min/max must be specified."
     1673            return I(var, min, max)
     1674
     1675    integrate = integral
     1676
     1677    def __float__(self):
     1678        """
     1679        Return floating point version of this maxima element.
     1680       
     1681        EXAMPLES::
     1682       
     1683            sage: float(maxima("3.14"))
     1684            3.1400000000000001
     1685            sage: float(maxima("1.7e+17"))
     1686            1.7e+17
     1687            sage: float(maxima("1.7e-17"))
     1688            1.6999999999999999e-17
     1689        """
     1690        try:
     1691            return float(repr(self.numer()))
     1692        except ValueError:
     1693            raise TypeError, "unable to coerce '%s' to float"%repr(self)
     1694
     1695    def __len__(self):
     1696        """
     1697        Return the length of a list.
     1698       
     1699        EXAMPLES::
     1700       
     1701            sage: v = maxima('create_list(x^i,i,0,5)')         
     1702            sage: len(v)                                       
     1703            6
     1704        """
     1705        P = self._check_valid()       
     1706        return int(P.eval('length(%s)'%self.name()))
     1707
     1708    def dot(self, other):
     1709        """
     1710        Implements the notation self . other.
     1711       
     1712        EXAMPLES::
     1713       
     1714            sage: A = maxima('matrix ([a1],[a2])')
     1715            sage: B = maxima('matrix ([b1, b2])')
     1716            sage: A.dot(B)
     1717            matrix([a1*b1,a1*b2],[a2*b1,a2*b2])
     1718        """
     1719        P = self._check_valid()
     1720        Q = P(other)
     1721        return P('%s . %s'%(self.name(), Q.name()))
     1722
     1723    def __getitem__(self, n):
     1724        r"""
     1725        Return the n-th element of this list.
     1726       
     1727        .. note::
     1728
     1729           Lists are 0-based when accessed via the Sage interface, not
     1730           1-based as they are in the Maxima interpreter.
     1731       
     1732        EXAMPLES::
     1733       
     1734            sage: v = maxima('create_list(i*x^i,i,0,5)'); v   
     1735            [0,x,2*x^2,3*x^3,4*x^4,5*x^5]
     1736            sage: v[3]                                         
     1737            3*x^3
     1738            sage: v[0]                                           
     1739            0
     1740            sage: v[10]                                         
     1741            Traceback (most recent call last):
     1742            ...
     1743            IndexError: n = (10) must be between 0 and 5
     1744        """
     1745        n = int(n)
     1746        if n < 0 or n >= len(self):
     1747            raise IndexError, "n = (%s) must be between %s and %s"%(n, 0, len(self)-1)
     1748        # If you change the n+1 to n below, better change __iter__ as well.
     1749        return ExpectElement.__getitem__(self, n+1)
     1750
     1751    def __iter__(self):
     1752        """
     1753        EXAMPLE::
     1754       
     1755            sage: v = maxima('create_list(i*x^i,i,0,5)')
     1756            sage: L = list(v)
     1757            sage: [e._sage_() for e in L]
     1758            [0, x, 2*x^2, 3*x^3, 4*x^4, 5*x^5]
     1759        """
     1760        for i in range(len(self)):
     1761            yield self[i]
     1762
     1763    def subst(self, val):
     1764        """
     1765        Substitute a value or several values into this Maxima object.
     1766       
     1767        EXAMPLES::
     1768       
     1769            sage: maxima('a^2 + 3*a + b').subst('b=2')
     1770            a^2+3*a+2
     1771            sage: maxima('a^2 + 3*a + b').subst('a=17')
     1772            b+340
     1773            sage: maxima('a^2 + 3*a + b').subst('a=17, b=2')
     1774            342
     1775        """
     1776        return self.comma(val)
     1777
     1778    def comma(self, args):
     1779        """
     1780        Form the expression that would be written 'self, args' in Maxima.
     1781       
     1782        EXAMPLES::
     1783       
     1784            sage: maxima('sqrt(2) + I').comma('numer')
     1785            I+1.414213562373095
     1786            sage: maxima('sqrt(2) + I*a').comma('a=5')
     1787            5*I+sqrt(2)
     1788        """
     1789        self._check_valid()
     1790        P = self.parent()
     1791        return P('%s, %s'%(self.name(), args))
     1792
     1793    def _latex_(self):
     1794        """
     1795        Return Latex representation of this Maxima object.
     1796       
     1797        This calls the tex command in Maxima, then does a little
     1798        post-processing to fix bugs in the resulting Maxima output.
     1799       
     1800        EXAMPLES::
     1801       
     1802            sage: maxima('sqrt(2) + 1/3 + asin(5)')._latex_()
     1803            '\\sin^{-1}\\cdot5+\\sqrt{2}+{{1}\\over{3}}'
     1804
     1805            sage: y,d = var('y,d')
     1806            sage: latex(maxima(derivative(ceil(x*y*d), d,x,x,y)))
     1807            d^3\,\left({{{\it \partial}^4}\over{{\it \partial}\,d^4}}\,  {\it ceil}\left(d , x , y\right)\right)\,x^2\,y^3+5\,d^2\,\left({{  {\it \partial}^3}\over{{\it \partial}\,d^3}}\,{\it ceil}\left(d , x   , y\right)\right)\,x\,y^2+4\,d\,\left({{{\it \partial}^2}\over{  {\it \partial}\,d^2}}\,{\it ceil}\left(d , x , y\right)\right)\,y
     1808
     1809
     1810            sage: latex(maxima(d/(d-2)))
     1811            {{d}\over{d-2}}
     1812        """
     1813        self._check_valid()
     1814        P = self.parent()
     1815        s = P._eval_line('tex(%s);'%self.name(), reformat=False)
     1816        if not '$$' in s:
     1817            raise RuntimeError, "Error texing maxima object."
     1818        i = s.find('$$')
     1819        j = s.rfind('$$')
     1820        s = s[i+2:j]
     1821        s = multiple_replace({'\r\n':' ',
     1822                              '\\%':'',
     1823                              '\\arcsin ':'\\sin^{-1} ',
     1824                              '\\arccos ':'\\cos^{-1} ',
     1825                              '\\arctan ':'\\tan^{-1} '}, s)
     1826
     1827        # Fix a maxima bug, which gives a latex representation of multiplying
     1828        # two numbers as a single space. This was really bad when 2*17^(1/3)
     1829        # gets TeXed as '2 17^{\frac{1}{3}}'
     1830        #
     1831        # This regex matches a string of spaces preceded by either a '}', a
     1832        # decimal digit, or a ')', and followed by a decimal digit. The spaces
     1833        # get replaced by a '\cdot'.
     1834        s = re.sub(r'(?<=[})\d]) +(?=\d)', '\cdot', s)
     1835
     1836        return s
     1837
     1838    def trait_names(self, verbose=False):
     1839        """
     1840        Return all Maxima commands, which is useful for tab completion.
     1841       
     1842        EXAMPLES::
     1843       
     1844            sage: m = maxima(2)
     1845            sage: 'gcd' in m.trait_names()
     1846            True
     1847        """
     1848        return self.parent().trait_names(verbose=False)
     1849
     1850    def _matrix_(self, R):
     1851        r"""
     1852        If self is a Maxima matrix, return the corresponding Sage matrix
     1853        over the Sage ring `R`.
     1854       
     1855        This may or may not work depending in how complicated the entries
     1856        of self are! It only works if the entries of self can be coerced as
     1857        strings to produce meaningful elements of `R`.
     1858       
     1859        EXAMPLES::
     1860       
     1861            sage: _ = maxima.eval("f[i,j] := i/j")             
     1862            sage: A = maxima('genmatrix(f,4,4)'); A             
     1863            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])
     1864            sage: A._matrix_(QQ)                               
     1865            [  1 1/2 1/3 1/4]
     1866            [  2   1 2/3 1/2]
     1867            [  3 3/2   1 3/4]
     1868            [  4   2 4/3   1]
     1869       
     1870        You can also use the ``matrix`` command (which is
     1871        defined in ``sage.misc.functional``)::
     1872       
     1873            sage: matrix(QQ, A)
     1874            [  1 1/2 1/3 1/4]
     1875            [  2   1 2/3 1/2]
     1876            [  3 3/2   1 3/4]
     1877            [  4   2 4/3   1]
     1878        """
     1879        from sage.matrix.all import MatrixSpace
     1880        self._check_valid()
     1881        P = self.parent()
     1882        nrows = int(P.eval('length(%s)'%self.name()))
     1883        if nrows == 0:
     1884            return MatrixSpace(R, 0, 0)(0)
     1885        ncols = int(P.eval('length(%s[1])'%self.name()))
     1886        M = MatrixSpace(R, nrows, ncols)
     1887        s = self.str().replace('matrix','').replace(',',"','").\
     1888            replace("]','[","','").replace('([',"['").replace('])',"']")
     1889        s = eval(s)
     1890        return M([R(x) for x in s])
     1891       
     1892    def partial_fraction_decomposition(self, var='x'):
     1893        """
     1894        Return the partial fraction decomposition of self with respect to
     1895        the variable var.
     1896       
     1897        EXAMPLES::
     1898       
     1899            sage: f = maxima('1/((1+x)*(x-1))')           
     1900            sage: f.partial_fraction_decomposition('x')   
     1901            1/(2*(x-1))-1/(2*(x+1))
     1902            sage: print f.partial_fraction_decomposition('x')
     1903                                 1           1
     1904                             --------- - ---------
     1905                             2 (x - 1)   2 (x + 1)
     1906        """
     1907        return self.partfrac(var)
     1908
     1909    def _operation(self, operation, right):
     1910        r"""
     1911        Note that right's parent should already be Maxima since this should
     1912        be called after coercion has been performed.
     1913       
     1914        If right is a ``MaximaFunction``, then we convert
     1915        ``self`` to a ``MaximaFunction`` that takes
     1916        no arguments, and let the
     1917        ``MaximaFunction._operation`` code handle everything
     1918        from there.
     1919       
     1920        EXAMPLES::
     1921       
     1922            sage: f = maxima.cos(x)
     1923            sage: f._operation("+", f)
     1924            2*cos(x)
     1925        """
     1926        P = self._check_valid()
     1927
     1928        if isinstance(right, MaximaFunction):
     1929            fself = P.function('', repr(self))
     1930            return fself._operation(operation, right)
     1931
     1932        try:
     1933            return P.new('%s %s %s'%(self._name, operation, right._name))
     1934        except Exception, msg:
     1935            raise TypeError, msg
     1936
     1937
     1938       
     1939class MaximaFunctionElement(FunctionElement):
     1940    def _sage_doc_(self):
     1941        """
     1942        EXAMPLES::
     1943       
     1944            sage: m = maxima(4)
     1945            sage: m.gcd._sage_doc_()
     1946            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     1947            ...
     1948        """
     1949        return self._obj.parent().help(self._name)
     1950
     1951class MaximaExpectFunction(ExpectFunction):
     1952    def _sage_doc_(self):
     1953        """
     1954        EXAMPLES::
     1955       
     1956            sage: maxima.gcd._sage_doc_()
     1957            -- Function: gcd (<p_1>, <p_2>, <x_1>, ...)
     1958            ...
     1959        """
     1960        M = self._parent
     1961        return M.help(self._name)
     1962
     1963
     1964class MaximaFunction(MaximaElement):
     1965    def __init__(self, parent, name, defn, args, latex):
     1966        """
     1967        EXAMPLES::
     1968       
     1969            sage: f = maxima.function('x,y','sin(x+y)')
     1970            sage: f == loads(dumps(f))
     1971            True
     1972        """
     1973        MaximaElement.__init__(self, parent, name, is_name=True)
     1974        self.__defn = defn
     1975        self.__args = args
     1976        self.__latex = latex
     1977
     1978    def __reduce__(self):
     1979        """
     1980        EXAMPLES::
     1981       
     1982            sage: f = maxima.function('x,y','sin(x+y)')
     1983            sage: f.__reduce__()
     1984            (<function reduce_load_Maxima_function at 0x...>,
     1985             (Maxima, 'sin(x+y)', 'x,y', None))
     1986        """
     1987        return reduce_load_Maxima_function, (self.parent(), self.__defn, self.__args, self.__latex)
     1988       
     1989    def __call__(self, *x):
     1990        """
     1991        EXAMPLES::
     1992       
     1993            sage: f = maxima.function('x,y','sin(x+y)')
     1994            sage: f(1,2)
     1995            sin(3)
     1996            sage: f(x,x)
     1997            sin(2*x)
     1998        """
     1999        P = self._check_valid()
     2000        if len(x) == 1:
     2001            x = '(%s)'%x
     2002        return P('%s%s'%(self.name(), x))
     2003
     2004    def __repr__(self):
     2005        """
     2006        EXAMPLES::
     2007       
     2008            sage: f = maxima.function('x,y','sin(x+y)')
     2009            sage: repr(f)
     2010            'sin(x+y)'
     2011        """
     2012        return self.definition()
     2013
     2014    def _latex_(self):
     2015        """
     2016        EXAMPLES::
     2017       
     2018            sage: f = maxima.function('x,y','sin(x+y)')
     2019            sage: latex(f)
     2020            \mathrm{sin(x+y)}
     2021        """
     2022        if self.__latex is None:
     2023            return r'\mathrm{%s}'%self.__defn
     2024        else:
     2025            return self.__latex
     2026
     2027    def arguments(self, split=True):
     2028        r"""
     2029        Returns the arguments of this Maxima function.
     2030       
     2031        EXAMPLES::
     2032       
     2033            sage: f = maxima.function('x,y','sin(x+y)')
     2034            sage: f.arguments()
     2035            ['x', 'y']
     2036            sage: f.arguments(split=False)
     2037            'x,y'
     2038            sage: f = maxima.function('', 'sin(x)')
     2039            sage: f.arguments()
     2040            []
     2041        """
     2042        if split:
     2043            return self.__args.split(',') if self.__args != '' else []
     2044        else:
     2045            return self.__args
     2046
     2047    def definition(self):
     2048        """
     2049        Returns the definition of this Maxima function as a string.
     2050       
     2051        EXAMPLES::
     2052       
     2053            sage: f = maxima.function('x,y','sin(x+y)')
     2054            sage: f.definition()
     2055            'sin(x+y)'
     2056        """
     2057        return self.__defn
     2058
     2059    def integral(self, var):
     2060        """
     2061        Returns the integral of self with respect to the variable var.
     2062       
     2063        Note that integrate is an alias of integral.
     2064       
     2065        EXAMPLES::
     2066       
     2067            sage: x,y = var('x,y')
     2068            sage: f = maxima.function('x','sin(x)')
     2069            sage: f.integral(x)
     2070            -cos(x)
     2071            sage: f.integral(y)
     2072            sin(x)*y
     2073        """
     2074        var = str(var)
     2075        P = self._check_valid()
     2076        f = P('integrate(%s(%s), %s)'%(self.name(), self.arguments(split=False), var))
     2077
     2078        args = self.arguments()
     2079        if var not in args:
     2080            args.append(var)
     2081        return P.function(",".join(args), repr(f))
     2082
     2083    integrate = integral
     2084
     2085    def _operation(self, operation, f=None):
     2086        r"""
     2087        This is a utility function which factors out much of the
     2088        commonality used in the arithmetic operations for
     2089        ``MaximaFunctions``.
     2090       
     2091        INPUT:
     2092       
     2093       
     2094        -  ``operation`` - A string representing the operation
     2095           being performed. For example, '\*', or '1/'.
     2096       
     2097        -  ``f`` - The other operand. If f is
     2098           ``None``, than the operation is assumed to be unary
     2099           rather than binary.
     2100       
     2101       
     2102        EXAMPLES::
     2103       
     2104            sage: f = maxima.function('x,y','sin(x+y)')
     2105            sage: f._operation("+", f)
     2106            2*sin(y+x)
     2107            sage: f._operation("+", 2)
     2108            sin(y+x)+2
     2109            sage: f._operation('-')
     2110            -sin(y+x)
     2111            sage: f._operation('1/')
     2112            1/sin(y+x)
     2113        """
     2114        P = self._check_valid()
     2115        if isinstance(f, MaximaFunction):
     2116            tmp = list(sorted(set(self.arguments() + f.arguments())))
     2117            args = ','.join(tmp)
     2118            defn = "(%s)%s(%s)"%(self.definition(), operation, f.definition())
     2119        elif f is None:
     2120            args = self.arguments(split=False)
     2121            defn = "%s(%s)"%(operation, self.definition())
     2122        else:
     2123            args = self.arguments(split=False)
     2124            defn = "(%s)%s(%s)"%(self.definition(), operation, repr(f))
     2125
     2126        return P.function(args,P.eval(defn))
     2127
     2128    def _add_(self, f):
     2129        """
     2130        MaximaFunction as left summand.
     2131       
     2132        EXAMPLES::
     2133       
     2134            sage: x,y = var('x,y')
     2135            sage: f = maxima.function('x','sin(x)')
     2136            sage: g = maxima.function('x','-cos(x)')
     2137            sage: f+g
     2138            sin(x)-cos(x)
     2139            sage: f+3
     2140            sin(x)+3
     2141       
     2142        ::
     2143       
     2144            sage: (f+maxima.cos(x))(2)
     2145            sin(2)+cos(2)
     2146            sage: (f+maxima.cos(y)) # This is a function with only ONE argument!
     2147            cos(y)+sin(x) 
     2148            sage: (f+maxima.cos(y))(2)
     2149            cos(y)+sin(2)
     2150       
     2151        ::
     2152       
     2153            sage: f = maxima.function('x','sin(x)')
     2154            sage: g = -maxima.cos(x)
     2155            sage: g+f
     2156            sin(x)-cos(x)
     2157            sage: (g+f)(2) # The sum IS a function
     2158            sin(2)-cos(2) 
     2159            sage: 2+f
     2160            sin(x)+2
     2161        """
     2162        return self._operation("+", f)
     2163
     2164    def _sub_(self, f):
     2165        r"""
     2166        ``MaximaFunction`` as minuend.
     2167       
     2168        EXAMPLES::
     2169       
     2170            sage: x,y = var('x,y')
     2171            sage: f = maxima.function('x','sin(x)')
     2172            sage: g = -maxima.cos(x) # not a function
     2173            sage: f-g
     2174            sin(x)+cos(x)
     2175            sage: (f-g)(2)
     2176            sin(2)+cos(2)
     2177            sage: (f-maxima.cos(y)) # This function only has the argument x!
     2178            sin(x)-cos(y)
     2179            sage: _(2)
     2180            sin(2)-cos(y)
     2181       
     2182        ::
     2183       
     2184            sage: g-f
     2185            -sin(x)-cos(x)
     2186        """
     2187        return self._operation("-", f)
     2188       
     2189    def _mul_(self, f):
     2190        r"""
     2191        ``MaximaFunction`` as left factor.
     2192       
     2193        EXAMPLES::
     2194       
     2195            sage: f = maxima.function('x','sin(x)')
     2196            sage: g = maxima('-cos(x)') # not a function!
     2197            sage: f*g
     2198            -cos(x)*sin(x)
     2199            sage: _(2)
     2200            -cos(2)*sin(2)
     2201       
     2202        ::
     2203       
     2204            sage: f = maxima.function('x','sin(x)')
     2205            sage: g = maxima('-cos(x)')
     2206            sage: g*f
     2207            -cos(x)*sin(x)
     2208            sage: _(2)
     2209            -cos(2)*sin(2)
     2210            sage: 2*f
     2211            2*sin(x)
     2212        """
     2213        return self._operation("*", f)
     2214
     2215    def _div_(self, f):
     2216        r"""
     2217        ``MaximaFunction`` as dividend.
     2218       
     2219        EXAMPLES::
     2220       
     2221            sage: f=maxima.function('x','sin(x)')
     2222            sage: g=maxima('-cos(x)')
     2223            sage: f/g
     2224            -sin(x)/cos(x)
     2225            sage: _(2)
     2226            -sin(2)/cos(2)
     2227       
     2228        ::
     2229       
     2230            sage: f=maxima.function('x','sin(x)')
     2231            sage: g=maxima('-cos(x)')
     2232            sage: g/f
     2233            -cos(x)/sin(x)
     2234            sage: _(2)
     2235            -cos(2)/sin(2)
     2236            sage: 2/f
     2237            2/sin(x)
     2238        """
     2239        return self._operation("/", f)
     2240
     2241    def __neg__(self):
     2242        r"""
     2243        Additive inverse of a ``MaximaFunction``.
     2244       
     2245        EXAMPLES::
     2246       
     2247            sage: f=maxima.function('x','sin(x)')
     2248            sage: -f
     2249            -sin(x)
     2250        """
     2251        return self._operation('-')
     2252
     2253    def __inv__(self):
     2254        r"""
     2255        Multiplicative inverse of a ``MaximaFunction``.
     2256       
     2257        EXAMPLES::
     2258       
     2259            sage: f = maxima.function('x','sin(x)')
     2260            sage: ~f
     2261            1/sin(x)
     2262        """
     2263        return self._operation('1/')
     2264
     2265    def __pow__(self,f):
     2266        r"""
     2267        ``MaximaFunction`` raised to some power.
     2268       
     2269        EXAMPLES::
     2270       
     2271            sage: f=maxima.function('x','sin(x)')
     2272            sage: g=maxima('-cos(x)')
     2273            sage: f^g
     2274            1/sin(x)^cos(x)
     2275       
     2276        ::
     2277       
     2278            sage: f=maxima.function('x','sin(x)')
     2279            sage: g=maxima('-cos(x)') # not a function
     2280            sage: g^f
     2281            (-cos(x))^sin(x)
     2282        """
     2283        return self._operation("^", f)
     2284
     2285
     2286def reduce_load_Maxima_function(parent, defn, args, latex):
     2287    return parent.function(args, defn, defn, latex)
     2288   
     2289
     2290import os
     2291def maxima_console():
     2292    """
     2293    Spawn a new Maxima command-line session.
     2294   
     2295    EXAMPLES::
     2296   
     2297        sage: from sage.interfaces.maxima import maxima_console
     2298        sage: maxima_console()                    # not tested
     2299        Maxima 5.22.1 http://maxima.sourceforge.net
     2300        ...
     2301    """
     2302    os.system('maxima')