iconEuler Reference

Maxima Functions for Euler

Content

Function for Maxima functions.

Euler extends Maxima with some useful functions. The details are explained in the documentation of the Euler core.

Usually, Maxima is used in Euler seamlessly via symbolic expressions. This file contains some other ways to exchange data with Maxima.

The file also contains some functions, which use Maxima in the background.

Maxima Constants

function overwrite mxmstart (directory:string="")
  Start Maxima in the spedified directory.
  
  The default directory is the Euler start directory. Euler can also
  start Maxima automatically.
  
  See: 
maxima (Euler Core)

Exchange Values with Maxima

function mxmeval (s:string)
  Evaluate the Maxima expression with additional parameters.
  
  The expression will go through the Maxima interpreter in direct
  mode. Thus this function should only be used for simple term
  evaulations. In the case of a Maxima error, an Euler error will
  occur. After the string is interpreted by Maxima, it is evaluated
  in Euler. At this point any additional assigned parameters and all
  global variables are visible, and can be used.
  
  The function returns an Euler value.
  
  There is the shortcut "::string"(parameters) for this function,
  
  See: 
maxima (Euler Core),
:: (Euler Core),
:: (Maxima Documentation)
function mxmget (s:string)
  Gets a value from Maxima.
  
  This is the same as mxmeval.
  
  See: 
mxmeval (Maxima Functions for Euler)
function mxmset (var, value="none", large:integer=1)
  Set a variable var to the value x in Maxima.
  
  Can be used with either a variable only, or a name and and a
  value. In the first case, the variable name in Maxima will be the
  same as the name of the Euler variable.
  
  Also, "variable::=value" sets a symbolic expression in Maxima and
  Euler.
  
  See: 
::= (Euler Core),
::= (Maxima Documentation)
function evalinmxm 
  Evaluate a Maxima expression in Maxima with values.
  
  In contrast to "mxmeval", this function evaluates the expression in
  Maxima, optionally using additional local values for parameters. To
  set such an additional parameter, add its name as a string, and its
  value as two parameter to the function.
  
  See: 
mxmeval (Maxima Functions for Euler)
function mxm2vector (s:string, large:integer=0)
  Turn a Maxima vector into an Euler vector.
  
  For large vectors (>100 elements) set large to 1. For small
  vectors, mxmget("v") or v() will work faster.
function mxm2str (s:string)
  Turn a Maxima vector of maxima expressions into a string vector.
  
  This reads a vector of expressions in Maxima, and turns it to a
  vector of strings in Euler (e.g., for plotting).
function mxm2matrix (s:string, large:integer=0)
  Turn a Maxima matrix into an Euler matrix.
  
  For large matrixed (>100 columns) set large to 1. For small
  matrices, mxmget("A") or A() will work faster.

Newton Algorithms with Maxima

function mxmnewton (expression:string,
    start:complex scalar, y:real scalar=0, eps=none)
  Solve expression=y using Newton's method.
  
  The expression must be an expression in x. Maxima is called to
  compute the derivative of the expression. The accuracy of the
  method can be controlled with eps=...
  
  See: 
mxminewton (Maxima Functions for Euler),
mxmnewtonfxy (Maxima Functions for Euler)
function mxminewton (expression:string, start:interval, ..
    yi:real scalar="", y:real scalar=0)
  Guaranteed inclusion of the solution of expression=y.
  
  The functions uses an interval version of Newton's method. The
  expression must be an expression in x. Maxima is used to find the
  derivative of the expression.
  
  See: 
inewton (Numerical Algorithms)
function newtonfxy (f1:string, f2:string, f1x:string, ..
    f1y:string, f2x:string, f2y:string, start:real vector)
  Newton's method to a solution of f1(x,y)=0, f2(x,y)=0.
  
  The derivatives must ge given as expressions or functions. All
  expressions must be expressions in x and y.
  
  This function is a special Newton method for two variables. For
  more variables, use "newton2".
  
  See: 
mxmnewtonfxy (Maxima Functions for Euler),
newton2 (Numerical Algorithms)
function mxmnewtonfxy (f1:string, f2:string, start:real vector)
  Newton's method to a solution of f1(x,y)=0, f2(x,y)=0.
  
  The expressions f1, f2 are passed to Maxima to compute the
  derivatives of f1 and f2. Both expressions must be expressions in x
  and y.
  

Differential Equations with Maxima

function mxmtaylorrest (expr:string, deg:integer=10)
  Compute the Taylor development and rest for the expression expr.
  
  The function computes a Taylor series for y, assuming y'=expr(x,y).
  The series has the form y(x+h)=y+expr(x,y)*h+f2(x,y)*h^2+...
  Moreover, the function produces a term for the error. For the
  actual error, this term must be evaulated at any point between x
  and x+h.
  
  The result is useful for mxmidgl.
  
  Returns {taylor,rest}
  
  See mxmidgl
function mxmidgl (expr:string, x:real vector, y0:interval scalar, ..
    deg:integer=10, taylor:string="", rest:string="")
  Guaranteed inclusion of the differential equation y'=expr.
  
  The function uses Maxima to compute a Taylor series of y to the given
  degree, and uses the error term to find a guaranteed solution.
  
  The series can be computed in advance using mxmtaylorrest.
  
  expr : expression in x and y. Global variables are allowed
  as long as they are not defined in Maxima.
  
  deg : degree of the method.
  x : is a vector of places, where the solutions should be found.
  
  y0 : start value at x[1].
  
  See: 
mxmiint (Maxima Functions for Euler),
mxmtaylorrest (Maxima Functions for Euler)

Exact Numerical Integration with Maxima

function mxmiint (expr:string, a:real scalar, b:real scalar, ..
    n:integer=20, deg:integer=10)
  Guaranteed inclusion for the integral of expr from a to b.
  
  This functions uses a Taylor series of high degree, and an
  estimation of the error.
  
  expr : expression (must map to arguments and work for intervals)
  Global variables are allowed, if they are not defined in
  Maxima.
  
  a,b : interval bounds
  n : number of subinervals
  deg : degree of the Taylor expansion
  
  See: 
integrate (Numerical Algorithms),
integrate (Maxima Documentation),
mxmintegrate (Maxima Functions for Euler),
mxmidgl (Maxima Functions for Euler)
function mxmisimpson (expr:string, a:number, b:number, n:index=50)
  Interval Simpson integral of f from a to b.
  
  This function uses the Simpson method and its error estimate to get
  guaranteed inclusions of integrals. The estimate involves the 4-th
  derivative, which is computed by Maxima.
  
  expr : expression (must map to arguments and work for intervals).
  Global variables are allowed, if they are not defined in
  Maxima.
  
  a,b : interval bounds
  n : number of subintervals
  
  See: 
isimpson (Numerical Algorithms)

Interval Evaluation with Maxima

function splitinterval (xi:interval scalar, n:integer)
  Split the interval into n subintervals
function mxmieval (expression:string, xi:interval scalar, n:integer=1)
  Better evaluation of the expression in x for the interval xi.
  
  The function is using the mean value theorem. Maxima is called to
  compute the derviative of the expression. The expression must be an
  expression in x. The interval can also be split into sub-intervals
  for more accuracy.
function mxmievalfxy (expression:string, ix:interval scalar, iy:interval scalar)
  Better evaluation of the expression in x and y on intervals.
  
  This function is using the mean value theorem in two variables. The
  derivatives are computed by Maxima.
  
function mxmibisectfxy (ef:string, eg:string, ..
    ix:interval scalar, iy:interval scalar, eps=0.01)
  Two dimensional bisection method
  
  Use the two dimensional bisection method to find intervals in a
  given interval, where the function could be zero. The derivatives
  are computed by Maxima. Returns a nx2 vector of intervals. The
  first column is the interval of x values, and the second the
  interval of y values.
  
  ef and eg are expressions in x and y.
  

Utility Functions for Maxima

function map mxmdiff (expr:string,x=none,n=1)
  Differentiate the expression with Maxima
  
  Differentiate the expression and optionally evaluate at x. The
  expression must be an expression in x.
  
  See: 
diff (Numerical Algorithms),
diff (Maxima Documentation)
function mxmintegrate (expr:string,a=none,b=0)
  Integrate the expression
  
  Integrate the expression (optionally with limits) using Maxima.
  Maxima is used to find an anti-derivative of the expression. Euler
  is used to evaluate the result in b and a.
  
  See: 
integrate (Numerical Algorithms),
integrate (Maxima Documentation),
mxmiint (Maxima Functions for Euler)
function mxmsolve (expr:string,n=0,y=0)
  Solve expr=y im Maxima, optionally get the n-th solution.
  
  Call Maxima to solve expr=y, and evaluate all solutions in Euler.
  If n is not zero, extract the n-th solution as a string.
function mxmdx (expr:string,x=none,y=0)
  mxmdx(expr), mxmdx(expr,x,y) Partial derivative to x.
  
  Maxima is used to compute the partial derivative to x of an
  expression in two variables. Optionally, this derivative is
  evaluated in (x,y).
  
  Note that this function is inefficient, since it calls Maxima each
  time. It is better to compute the partial derivative once, and
  evaluate it for each x and y in Euler.
  
  See: 
mxmgradient (Maxima Functions for Euler),
mxmdy (Maxima Functions for Euler),
mxmdiff (Maxima Functions for Euler)
function mxmdy (expr:string,x=none,y=0)
  mxmdy(expr), mxmdy(expr,x,y) Partial derivative to x.
  
  Maxima is used to compute the partial derivative to y of an
  expression in two variables. Optionally, this derivative is
  evaluated in (x,y).
  
  Note that this function is inefficient, since it calls Maxima each
  time. It is better to compute the partial derivative once, and
  evaluate it for each x and y in Euler.
  
  See: 
mxmgradient (Maxima Functions for Euler),
mxmdx (Maxima Functions for Euler),
mxmdiff (Maxima Functions for Euler)
function mxmgradient (expr:string,x=none,y=0)
  Gradient of the expression in x and y.
  
  Maxima is used to compute the gradient. The gradient is evaluated
  in x and y.
  
  Note that this function is inefficient, since it calls Maxima each
  time. It is better to compute the gradient once, and evaluate it
  for each x and y in Euler.
  
  See: 
mxmdx (Maxima Functions for Euler),
mxmdy (Maxima Functions for Euler),
mxmdiff (Maxima Functions for Euler),
mxmhessian (Maxima Functions for Euler)
function mxmhessian (expr:string,x=none,y=0)
  Hessian of the expression in x and y.
  
  Maxima is used to compute the Hessian. The gradient is evaluated
  in x and y.
  
  Note that this function is inefficient, since it calls Maxima each
  time. It is better to compute the Hessian once, and evaluate it
  for each x and y in Euler.
  
  See: 
mxmdx (Maxima Functions for Euler),
mxmdy (Maxima Functions for Euler),
mxmdiff (Maxima Functions for Euler)
function mxmeigenvalues (A,n=0)
  Eigenvalues of the Matrix as computed by Maxima.
  
  Returns {lambdas,multiplicities} evaluated in Euler,
  or {lambda[n],multiplicity[n]} as strings, if n>0.
  
  See: 
eigenvalues (Linear Algebra),
eigenvalues (Maxima Documentation),
mxmeigenvectors (Maxima Functions for Euler)
function mxmeigenvectors (A,n=0)
  Eigenvectors of the Matrix as computed by Maxima.
  
  Calls Maxima to compute the Eigenvectors of the Matrix, and
  evaluates the result in Euler.
  
  See: 
eigenvectors (Maxima Documentation),
mxmeigenvalues (Maxima Functions for Euler)
function mxmcharpoly (A)
  Coefficients of the characteristic polynomials by Maxima.
  
  See: 
charpoly (Linear Algebra),
charpoly (Maxima Documentation)

Tables of Values with Maxima

function mxmtable (expr,var,a,b,d=1,plot=1,points=1,print=1,frac=0)
  Generate a table of values and a plot of these values.
  
  This function uses Maxima to create a table of values in a simple
  way. The "expression" of the variable "var" is incremented from
  a to b with incrementes d. If the expression is a vector of
  strings, a matrix of values will be created.
  
  expr : any Maxima expression (string or vector of strings)
  var : the variable name (string)
  a,b,d : range of variable and increment
  plot=1 : plot values and add plot to notebook
  points=1 : plot as point plot
  print=1 : print values to the notebook
  frac=0 : print as fractional values
  
  Returns the values

Gnu PLot

function mxmsetpng (w=600,h=600)
  Setup for Gnu Plot to PNG
  
  This sets the output of Gnu Plot to a PNG file in the home
  directory of Euler ("C:\Users\Name\Euler\gnuout.png"). When Maxima
  starts a similar routine is called automatically, so that this
  function is only necessary if you need another plot size than the
  default 600x600 pixels.
  
  The produced image can be inserted into the notebook with xmmins()
  or with a colon right at the end of the line after a symbolic plot
  command.
  
  >&plot2d(x^3-x,[x,-2,2]):
  >mxmsetpng(600,400);
  >&plot3d (log (x^2*y^2), [x, -2, 2], [y, -2, 2], ...
  >         [grid, 29, 29], ...
  >         [palette, get_plot_option(palette,5)]);
  >mxmins;
  >plot3d("log(x^2*y^2)",r=2,>spectral,grid=10,zoom=3):
  
  See: 
mxmins (Maxima Functions for Euler)
function mxmins (lines=35)
  Load a Gnu Plot image into the notebook
  
  The function inserts the default output file of Gnu Plot into
  the notebook (/Users/Name/Euler/gnuout.png). The output file is set
  for &plot2d() during the start of Maxima.
  
  Instead of mxmins(), the output can be inserted with a colon after
  a symbolic command, but at the end of the command line.
  
  See: 
mxmsetpng (Maxima Functions for Euler),
mxmsetdraw (Maxima Functions for Euler)
function mxmsetdraw (w=600,h=600)
  Sets the proper output for the draw package.
  
  The package draw has different options than plot2d(). If you load
  this package, you need to set the output in each draw(), or you can
  set it globally with this function.
  
  See: 
mxmsetpng (Maxima Functions for Euler)

Documentation Homepage