iconEuler Reference

Maxima Functions for Euler

Function for Maxima functions.

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.

Constants

function expt (a,b)

  Maxima expression for a^b.
function 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

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") will work faster.
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") will work faster.

Newton Algorithm

function mxmnewton (expression:string, start:complex scalar, y:real scalar=0)

  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 (Interval Solvers and Guaranteed Solutions)
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

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)

Integration

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 (Differential Equations),
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 (Interval Solvers and Guaranteed Solutions)

Interval Evaluation

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

function 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 (Differential Equations),
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 (Euler Core),
charpoly (Maxima Documentation)

Tables

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

Documentation Homepage