Library interface to Maxima

Maxima is a free GPL’d general purpose computer algebra system whose development started in 1968 at MIT. It contains symbolic manipulation algorithms, as well as implementations of special functions, including elliptic functions and generalized hypergeometric functions. Moreover, Maxima has implementations of many functions relating to the invariant theory of the symmetric group \(S_n\). (However, the commands for group invariants, and the corresponding Maxima documentation, are in French.) For many links to Maxima documentation, see http://maxima.sourceforge.net/documentation.html.

AUTHORS:

• William Stein (2005-12): Initial version
• David Joyner: Improved documentation
• William Stein (2006-01-08): Fixed bug in parsing
• William Stein (2006-02-22): comparisons (following suggestion of David Joyner)
• William Stein (2006-02-24): greatly improved robustness by adding sequence numbers to IO bracketing in _eval_line
• Robert Bradshaw, Nils Bruin, Jean-Pierre Flori (2010,2011): Binary library interface

For this interface, Maxima is loaded into ECL which is itself loaded as a C library in Sage. Translations between Sage and Maxima objects (which are nothing but wrappers to ECL objects) is made as much as possible directly, but falls back to the string based conversion used by the classical Maxima Pexpect interface in case no new implementation has been made.

This interface is the one used for calculus by Sage and is accessible as \(maxima_calculus\):

sage: maxima_calculus
Maxima_lib

Only one instance of this interface can be instantiated, so the user should not try to instantiate another one, which is anyway set to raise an error:

sage: from sage.interfaces.maxima_lib import MaximaLib
sage: MaximaLib()
Traceback (most recent call last):
...
RuntimeError: Maxima interface in library mode can only be instantiated once

Changed besselexpand to true in init_code – automatically simplify Bessel functions to trig functions when appropriate when true. Examples:

For some infinite sums, a closed expression can be found. By default, “maxima” is used for that:

sage: x,n,k = var("x","n","k")
sage: sum((-x)^n/(factorial(n)*factorial(n+3/2)),n,0,oo)
-1/2*(2*x*cos(2*sqrt(x)) - sqrt(x)*sin(2*sqrt(x)))/(sqrt(pi)*x^2)

Maxima has some flags that affect how the result gets simplified (By default, besselexpand is false in Maxima; however in 5.39 this test does not show any difference, as, apparently, another expansion path is used):

sage: maxima_calculus("besselexpand:false")
false
sage: x,n,k = var("x","n","k")
sage: sum((-x)^n/(factorial(n)*factorial(n+3/2)),n,0,oo)
-1/2*(2*x*cos(2*sqrt(x)) - sqrt(x)*sin(2*sqrt(x)))/(sqrt(pi)*x^2)
sage: maxima_calculus("besselexpand:true")
true

class sage.interfaces.maxima_lib.MaximaLib

Bases: sage.interfaces.maxima_abstract.MaximaAbstract

Interface to Maxima as a Library.

INPUT: none

OUTPUT: Maxima interface as a Library

EXAMPLES:

sage: from sage.interfaces.maxima_lib import MaximaLib, maxima_lib
sage: isinstance(maxima_lib,MaximaLib)
True

Only one such interface can be instantiated:

sage: MaximaLib()
Traceback (most recent call last):
...
RuntimeError: Maxima interface in library mode can only
be instantiated once

clear(var)

Clear the variable named var.

INPUT:

• var - string

OUTPUT: none

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib.set('xxxxx', '2')
sage: maxima_lib.get('xxxxx')
'2'
sage: maxima_lib.clear('xxxxx')
sage: maxima_lib.get('xxxxx')
'xxxxx'

eval(line, locals=None, reformat=True, **kwds)

Evaluate the line in Maxima.

INPUT:

• line - string; text to evaluate
• locals - None (ignored); this is used for compatibility with the Sage notebook’s generic system interface.
• reformat - boolean; whether to strip output or not
• **kwds - All other arguments are currently ignored.

OUTPUT: string representing Maxima output

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib._eval_line('1+1')
'2'
sage: maxima_lib._eval_line('1+1;')
'2'
sage: maxima_lib._eval_line('1+1$')
''
sage: maxima_lib._eval_line('randvar : cos(x)+sin(y)$')
''
sage: maxima_lib._eval_line('randvar')
'sin(y)+cos(x)'

get(var)

Get the string value of the variable var.

INPUT:

• var - string

OUTPUT: string

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib.set('xxxxx', '2')
sage: maxima_lib.get('xxxxx')
'2'

lisp(cmd)

Send a lisp command to maxima.

INPUT:

• cmd - string

OUTPUT: ECL object

Note

The output of this command is very raw - not pretty.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib.lisp("(+ 2 17)")
<ECL: 19>

set(var, value)

Set the variable var to the given value.

INPUT:

• var - string
• value - string

OUTPUT: none

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib.set('xxxxx', '2')
sage: maxima_lib.get('xxxxx')
'2'

sr_integral(*args)

Helper function to wrap calculus use of Maxima’s integration.

sr_limit(expr, v, a, dir=None)

Helper function to wrap calculus use of Maxima’s limits.

sr_prod(*args)

Helper function to wrap calculus use of Maxima’s product.

sr_sum(*args)

Helper function to wrap calculus use of Maxima’s summation.

sr_tlimit(expr, v, a, dir=None)

Helper function to wrap calculus use of Maxima’s Taylor series limits.

class sage.interfaces.maxima_lib.MaximaLibElement(parent, value, is_name=False, name=None)

Bases: sage.interfaces.maxima_abstract.MaximaAbstractElement

Element of Maxima through library interface.

EXAMPLES:

Elements of this class should not be created directly. The targeted parent should be used instead:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib(4)
4
sage: maxima_lib(log(x))
log(_SAGE_VAR_x)

display2d(onscreen=True)

Return the 2d representation of this Maxima object.

INPUT:

• onscreen - boolean (default: True); whether to print or return

OUTPUT:

The representation is printed if onscreen is set to True and returned as a string otherwise.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: F = maxima_lib('x^5 - y^5').factor()
sage: F.display2d()
                       4      3    2  2    3      4
           - (y - x) (y  + x y  + x  y  + x  y + x )

ecl()

Return the underlying ECL object of this MaximaLib object.

INPUT: none

OUTPUT: ECL object

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: maxima_lib(x+cos(19)).ecl()
<ECL: ((MPLUS SIMP) ((%COS SIMP) 19) |$_SAGE_VAR_x|)>

to_poly_solve(vars, options='')

Use Maxima’s to_poly_solver package.

INPUT:

• vars - symbolic expressions
• options - string (default=”“)

OUTPUT: Maxima object

EXAMPLES:

The zXXX below are names for arbitrary integers and subject to change:

sage: from sage.interfaces.maxima_lib import maxima_lib
sage: sol = maxima_lib(sin(x) == 0).to_poly_solve(x)
sage: sol.sage()
[[x == pi*z...]]

class sage.interfaces.maxima_lib.MaximaLibElementFunction(parent, name, defn, args, latex)

Bases: sage.interfaces.maxima_lib.MaximaLibElement, sage.interfaces.maxima_abstract.MaximaAbstractElementFunction

sage.interfaces.maxima_lib.dummy_integrate(expr)

We would like to simply tie Maxima’s integrate to sage.calculus.calculus.dummy_integrate, but we’re being imported there so to avoid circularity we define it here.

INPUT:

• expr - ECL object; a Maxima %INTEGRATE expression

OUTPUT: symbolic expression

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, dummy_integrate
sage: f = maxima_lib('f(x)').integrate('x')
sage: f.ecl()
<ECL: ((%INTEGRATE SIMP) (($F SIMP) $X) $X)>
sage: dummy_integrate(f.ecl())
integrate(f(x), x)

sage: f = maxima_lib('f(x)').integrate('x',0,10)
sage: f.ecl()
<ECL: ((%INTEGRATE SIMP) (($F SIMP) $X) $X 0 10)>
sage: dummy_integrate(f.ecl())
integrate(f(x), x, 0, 10)

sage.interfaces.maxima_lib.is_MaximaLibElement(x)

Returns True if x is of type MaximaLibElement.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, is_MaximaLibElement
sage: m = maxima_lib(1)
sage: is_MaximaLibElement(m)
True
sage: is_MaximaLibElement(1)
False

sage.interfaces.maxima_lib.max_at_to_sage(expr)

Special conversion rule for AT expressions.

INPUT:

• expr - ECL object; a Maxima AT expression

OUTPUT: symbolic expression

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, max_at_to_sage
sage: a=maxima_lib("'at(f(x,y,z),[x=1,y=2,z=3])")
sage: a
'at(f(x,y,z),[x=1,y=2,z=3])
sage: max_at_to_sage(a.ecl())
f(1, 2, 3)
sage: a=maxima_lib("'at(f(x,y,z),x=1)")
sage: a
'at(f(x,y,z),x=1)
sage: max_at_to_sage(a.ecl())
f(1, y, z)

sage.interfaces.maxima_lib.max_harmonic_to_sage(expr)

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, max_to_sr
sage: c=maxima_lib(harmonic_number(x,2))
sage: c.ecl()
<ECL: (($GEN_HARMONIC_NUMBER SIMP) 2 |$_SAGE_VAR_x|)>
sage: max_to_sr(c.ecl())
harmonic_number(x, 2)

sage.interfaces.maxima_lib.max_to_sr(expr)

Convert a Maxima object into a symbolic expression.

INPUT:

• expr - ECL object

OUTPUT: symbolic expression

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, max_to_sr
sage: f = maxima_lib('f(x)')
sage: f.ecl()
<ECL: (($F SIMP) $X)>
sage: max_to_sr(f.ecl())
f(x)

sage.interfaces.maxima_lib.max_to_string(s)

Return the Maxima string corresponding to this ECL object.

INPUT:

• s - ECL object

OUTPUT: string

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, max_to_string
sage: ecl = maxima_lib(cos(x)).ecl()
sage: max_to_string(ecl)
'cos(_SAGE_VAR_x)'

sage.interfaces.maxima_lib.mdiff_to_sage(expr)

Special conversion rule for %DERIVATIVE expressions.

INPUT:

• expr - ECL object; a Maxima %DERIVATIVE expression

OUTPUT: symbolic expression

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, mdiff_to_sage
sage: f = maxima_lib('f(x)').diff('x',4)
sage: f.ecl()
<ECL: ((%DERIVATIVE SIMP) (($F SIMP) $X) $X 4)>
sage: mdiff_to_sage(f.ecl())
diff(f(x), x, x, x, x)

sage.interfaces.maxima_lib.mlist_to_sage(expr)

Special conversion rule for MLIST expressions.

INPUT:

• expr - ECL object; a Maxima MLIST expression (i.e., a list)

OUTPUT: a Python list of converted expressions.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, mlist_to_sage
sage: L=maxima_lib("[1,2,3]")
sage: L.ecl()
<ECL: ((MLIST SIMP) 1 2 3)>
sage: mlist_to_sage(L.ecl())
[1, 2, 3]

sage.interfaces.maxima_lib.mqapply_to_sage(expr)

Special conversion rule for MQAPPLY expressions.

INPUT:

• expr - ECL object; a Maxima MQAPPLY expression

OUTPUT: symbolic expression

MQAPPLY is used for function as li[x](y) and psi[x](y).

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, mqapply_to_sage
sage: c = maxima_lib('li[2](3)')
sage: c.ecl()
<ECL: ((MQAPPLY SIMP) (($LI SIMP ARRAY) 2) 3)>
sage: mqapply_to_sage(c.ecl())
dilog(3)

sage.interfaces.maxima_lib.mrat_to_sage(expr)

Convert a Maxima MRAT expression to Sage SR.

INPUT:

• expr - ECL object; a Maxima MRAT expression

OUTPUT: symbolic expression

Maxima has an optimised representation for multivariate rational expressions. The easiest way to translate those to SR is by first asking Maxima to give the generic representation of the object. That is what RATDISREP does in Maxima.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import maxima_lib, mrat_to_sage
sage: var('x y z')
(x, y, z)
sage: c = maxima_lib((x+y^2+z^9)/x^6+z^8/y).rat()
sage: c
(_SAGE_VAR_y*_SAGE_VAR_z^9+_SAGE_VAR_x^6*_SAGE_VAR_z^8+_SAGE_VAR_y^3+_SAGE_VAR_x*_SAGE_VAR_y)/(_SAGE_VAR_x^6*_SAGE_VAR_y)
sage: c.ecl()
<ECL: ((MRAT SIMP (|$_SAGE_VAR_x| |$_SAGE_VAR_y| |$_SAGE_VAR_z|)
...>
sage: mrat_to_sage(c.ecl())
(x^6*z^8 + y*z^9 + y^3 + x*y)/(x^6*y)

sage.interfaces.maxima_lib.parse_max_string(s)

Evaluate string in Maxima without any further simplification.

INPUT:

• s - string

OUTPUT: ECL object

EXAMPLES:

sage: from sage.interfaces.maxima_lib import parse_max_string
sage: parse_max_string('1+1')
<ECL: ((MPLUS) 1 1)>

sage.interfaces.maxima_lib.pyobject_to_max(obj)

Convert a (simple) Python object into a Maxima object.

INPUT:

• expr - Python object

OUTPUT: ECL object

Note

This uses functions defined in sage.libs.ecl.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import pyobject_to_max
sage: pyobject_to_max(4)
<ECL: 4>
sage: pyobject_to_max('z')
<ECL: Z>
sage: var('x')
x
sage: pyobject_to_max(x)
Traceback (most recent call last):
...
TypeError: Unimplemented type for python_to_ecl

sage.interfaces.maxima_lib.reduce_load_MaximaLib()

Unpickle the (unique) Maxima library interface.

EXAMPLES:

sage: from sage.interfaces.maxima_lib import reduce_load_MaximaLib
sage: reduce_load_MaximaLib()
Maxima_lib

sage.interfaces.maxima_lib.sage_rat(x, y)

Return quotient x/y.

INPUT:

• x - integer
• y - integer

OUTPUT: rational

EXAMPLES:

sage: from sage.interfaces.maxima_lib import sage_rat
sage: sage_rat(1,7)
1/7

sage.interfaces.maxima_lib.sr_to_max(expr)

Convert a symbolic expression into a Maxima object.

INPUT:

• expr - symbolic expression

OUTPUT: ECL object

EXAMPLES:

sage: from sage.interfaces.maxima_lib import sr_to_max
sage: var('x')
x
sage: sr_to_max(x)
<ECL: $X>
sage: sr_to_max(cos(x))
<ECL: ((%COS) $X)>
sage: f = function('f')(x)
sage: sr_to_max(f.diff())
<ECL: ((%DERIVATIVE) (($F) $X) $X 1)>

sage.interfaces.maxima_lib.stdout_to_string(s)

Evaluate command s and catch Maxima stdout (not the result of the command!) into a string.

INPUT:

• s - string; command to evaluate

OUTPUT: string

This is currently used to implement display2d().

EXAMPLES:

sage: from sage.interfaces.maxima_lib import stdout_to_string
sage: stdout_to_string('1+1')
''
sage: stdout_to_string('disp(1+1)')
'2\n\n'