iconEuler Reference


This file contains main topics for the help window in Euler Math Toolbox (EMT). The list of topics opens when the help window is opened for the first time or if the search string is empty.

If you are reading this file in the browser you see an export to HTML. Use the links to find a specific topic.



Double click on any of the topics below. In the help window, you can double click on any item in the text output. Double click the breadcrumbs in the first line to go back to a previous topic.

Help - Help for the Help Window
Keyboard - Keys for the Command line Comments - Syntax for Comment Sections in Notebooks

Variables - Variables and Data Types in Euler
Data Types - Syntax for data types in EMT
Formats - Formatting the output numbers in Euler

Calculus - Derivatives, Integrals, Differential Equations
Solve Equations - Solve Equations and Systems of Equations
Plots - Plots in 2D and 3D
Algebra - Symbolic Manipulation of Expressions
Linear Algebra - Vectors and Matrices in Linear Algebra
Statistics - Statistics in EMT
Optimization - Linear and non-linear Optimization
Regression - Linear Regression
Polynomials and Splines - Polynomials and Splines in EMT

Programming Language - Functions in EMT
Scripts - External *.e files for EMT


You can open the help window at any time with F1. By default, EMT will display the topic explaining the most recent command. Press escape to clear the input line. While you type, the window will display all available topics. To select the first topic, press return. To select any other topic, double click on it.

The following wildcard characters and commands are supported in the search line.

  - text topic starting with the text
  - *text topics containing "text"
  - ?text full text search for the text in help topics
  - &topic (or " topic") topics in the Maxima help
  - &*text commands containing "text" in the Maxima help
  - _function built-in functions
  - function( (or "function ") specific function
  - filename.e lists the content of this EMT file
  - list ... lists all functions containing the string
  - listvar ... lists all variables containing the string
  - type ... types the definition of a function

The following key strokes are useful in the help window.

  - return key select the first topic
  - escape key clears selection or closes dialog
  - F1 key switches back to the EMT window
  - F2 key opens the current selection in the browser

Double click on an topic in the output of the help window to open that topic.


EMT tries to associate the keys in the same way as other programs. But there are some special keys.

  - escape: stop current computation, escape from function edit

  - TAB: toggle showing the graphics
  - ctrl+g: toggle extra graphics window

  - up, down: go to previous or next command line
  - left, right: go to previous or next character
  - ctrl+left, ctrl+right: go to previous or next space
  - start, end: go to start or end of line
  - page+up, page+down: go to previous or next page
  - ctrl+page+up, ctrl+page+down: go to previous or next heading

  - ctrl+return: split current line (or start function editor)
  - ctrl+backspace: join current lines

  - F1: toggles between the help window and the notebook
  - F3: search next position of the current search (Ctrl-F)
  - F5: opens the comment editor
  - F7: degree symbol
  - F8: plus/minus key
  - F9: opens the internal editor
  - F10: opens the external editor
  - F11: full screen mode
  - ctrl+F11: magnification mode
  - F12: toggle spelling
  - ctrl+F12: add errors in marked line to spelling

  - return: run the command, or redefine the function
  - alt+return: run the command and update the comment
  - ctrl+return: splits the line, or go into function edit mode
  - shift+ctrl+return: splits the line without adding "..."
  - shift+return: run the current block of commands
  - ctlr+r: run all subsequent commands

  - alt+backspace: delete the command or function line
  - alt+insert: insert a command or function line
  - alt+u: insert all deleted lines
  - alt+delete: forget the deleted lines permanently

  - ctrl+c: copy marked Euler text or the marked image
  - ctrl+v: insert Euler text
  - ctrl+x: cut marked Euler text
  - ctrl+alt+f: copy marked text in formatted form
  - ctrl+alt+c: copy commands only
  - ctrl+alt+v: paste text as commands

  - ctrl+f: search a text (F3 searches next)
+ ctrl+n: restart euler   - ctrl+o: open a notebook
  - ctrl+u: open in the Euler directory in the documents folder
  - ctrl+s: save the notebook
+ shift+ctrl+s: save as a new name, optionally delete old notebook   - ctrl+e: export notebook to HTML and save notebook
  - ctrl+p: export notebook as PDF file
  - ctrl+l: fold all multi-lines and function bodies
  - ctrl+h: open help in the browser

function (Euler Core),
python (Euler Core)


From the viewpoint of the user, Euler has the following data types.

  - real numbers and real matrices,
  - complex numbers and complex matrices,
  - intervals and interval matrices,
  - strings and string vectors,
  - symbolic strings,
  - compressed matrices,
  - binary data.

To store a value into a numerical variable, use := or =.

  >a := 3.5
  >b = 5 // alternative
  >v = 1:5 // variable containing a vector

For symbolic variables, see

Symbolic Variables - Variables in Maxima

Names of variable can contain $ (should be reserved for units), hard spaces (enter with ctrl-space), or an underscore (enter as double underscore __) They can start with %. The special variable % refers to the previous result (only outside of functions).

Here are some typical examples of values in Euler.

  >-1.234 // decimal dot, not comma!
  >1.45e22 // 1.45*10^22
  >[1,2,-5,6] // 1x4 vector
  >[1,0;0,1] // identity matrix id(2)
  >5+6i // complex number 5+6*I
  >[I,2*I,3+4*I] // complex vector
  >Pi, E, I // constant functions
  >"This is a string"
  >''Say "Hello!"'' // string containing "
  >~1.5,1.7~ // interval
  >1±0.1 // interval, use F8 for the plus/minus
  >~Pi~ // small interval around pi

For more Information see

Variables in Functions - about local and global Variables
Matrices - about matrices and sub-matrices
Symbolic Variables - Variables in Maxima

Variables in Functions

There are local and global variables. Inside a function, only local variables and parameters are visible. To access global variables, "useglobal" or "global var" must be present.

  >function changeA () ...
  $  global A;
  $  A=random(4,4);
  $  endfunction
  >changeA(); A,

To generate a global variable with a given value use "global var=value".

>function newvar (x) ...
$global nv=x;
>newvar(4); nv,

Variables ending with $$ are automatically global variables.

  >a$$ = 1:4 // assign to a global variable a$$
  >v = a$$ // retrieve value of global variable a$$

Moreover, variables can be set as global.

  >setglobal v;
  >function changev () ...
  $  v[2]=5;
  $  endfunction
  >changev(); v,

Note that one-line functions set "useglobal" automatically. So all global variables can be used. But parameters have precedence.

  >function f(x) := a*x
  >a=6; f(5)

Note that it is not a good style to use global variables to return values from functions. Instead, multiple returns should be used. Moreover, it is not a good style to access a global variable in a function (with the exception of units). Instead, pass the variable as an argument to the function. But for efficiency and simplicity, it is often nicer to use global variables.

The evaluation of an expression can also see global variables, in fact only global variables and variables given as arguments to the evaluation.

  >function ev(fx,x) := fx(x)
  >a=6; ev("a*x",2)

Arguments take precedence over global variables.

  >a=5; f(2,3)

Furthermore, there is a global list type. Lists can grow as long as needed.

  >for i=1 to 1000; glistadd("v",i^2); end;
  >s=0; for i=1 to 1000; s=s+glistvar("v",i); end; s,
  >sum((1:1000)^2) // check

global (Euler Core),
gvar (Euler Core),
glist (Euler Core)

Symbolic Variables

Symbolic variables are created with &=. These variables are defined in the Maxima subsystem, and copied to EMT as strings marked as symbolic. Symbolic strings print via Maxima as 2D display formulas.

  >f &= x^3-x
  >df &= diff(f,x) // evaluates, then assigns to df
  >df // prints as display formula
  >df(5) // evaluates with x=5 like a string expression

Symbolic variables can be used in EMT as expressions for numerical algorithms, since there is a symbolic string variable with the same name.

  >f &= exp(x)*(x^2+1);
  >df &= diff(f,x);
  >solve(df,1,y=2) // solve f'(x)=2 numerically
  >plot2d(df,-3,1): // plot f'(x)

If you need a value in Euler and Maxima, use &:=. Then you do not need to evaluate the symbolic value to get a numerical value. Of course, those variables are numerical in EMT and thus cannot contain symbolic variables.

  >A &:= [1,2;3,4] // A in both worlds
  >eigenvalues(A) // can be used numerically
  >&eigenvalues(A) // can be used symbolically
  >A.A // numerical result
  >&A.A // symbolic result

Elements of symbolic matrices can be changed in Maxima as usual.

  >A &= [x,1;2,3]
  >&A[1,1] := y // A[1,1] &= y does not work !!!

In Euler, a symbolic variable is simply a string.

  >f &= x^3-x;
  >"String: "+f

A variable can also be defined just for Maxima with &&= (purely symbolic variable). There will be no symbolic string variable in the numerical side of EMT. You can still access the expression in the variable with &variable.

  >expr &&= integrate(x^3,x);

For more information, see

Symbolic Functions - programming Maxima
Maxima at Compile Time - create advanced functions


The -> operator converts units. If the conversion goes to a string, the units in this string will be used, and the units will be printed after the result.

>2km/h->" m/s"

For a list of all units see the file units.e.

units (Euler Core),
units (Maxima Documentation)


Euler has vectors and matrices. Vectors are just 1xn (row vectors) or nx1 (column vector) matrices. To enter a matrix, separate the elements by a comma and the rows by a semicolon.

  >A = [1,2;3,4]
  >v = [5,6] // row vector
  >w = [5;6] // column vector
  >v.A // A.v does not work !!!
  >A.v' // v' is the transpose of v
  >w'.w // scalar product

Note that . is the matrix product. The usual operators and functions work element for element. This is the matrix language of EMT.

  >sqrt(A) // takes the square root of all elements of A
  >A*A // squares all elements of A

Matrices can also be formed of vectors and other matrices.

  >A=[1,2;3,4]; // 2x2 matrix
  >b=[1;2]; // column vector
  >A|b // horizontal concatenation
  >A_b' // vertical concatenation
  >[b,b^2,b^3] // matrix of columns
  >[b';b'^2] // matrix of rows

Matrix elements or sub-matrices are referred to with square brackets. For vectors, only one index is necessary, of course. For matrices, one index refers to the complete line.

  >A[1] // first row
  >A[,2] // second column
  >A[1:2,1:2] // 2x2 sub-matrix
  >A[-1] // last row
  >A[[2,1]] // rows 2 and 1

Matrices can be assigned to sub-matrices, if they fit. Values can be assigned to sub-matrices.


There are numerous functions to generate or handle matrices and vectors. Here are just a few examples.

  >setdiag(setdiag(2*id(5),-1,1),1,1) // tri-diagonal matrix
  >A=normal(3,3); A=A/getdiag(A) // normalize diagonal to 1
  >nonzeros(isprime(1:20)) // nonzero indices of vector
  >A=random(3,3); k=mnonzeros(A>0.5) // nonzero indices of matrix
  >mset(A,k,-A) // set indices to value or matrix

Matrix Language (Overview)

Matrix Language

Basic Rule

Operators and functions are applied element-wise to their operands, and the result is a matrix of the same size.

In case, the operands or parameters do not fit in size, Euler tries to expand the smaller one to the size of the larger one by duplication.

    [ 1  1.41421356237  1.73205080757  2  2.2360679775 ]]
    [ 4  8  12  16  20 ]]
    [ 1  4  9  16  25 ]]
  >short (1:5)*(2:6)'
    2           4           6           8          10  
    3           6           9          12          15  
    4           8          12          16          20  
    5          10          15          20          25  
    6          12          18          24          30  

If one of the operands is only a vector, the other a matrix, the

operators work, as if the vector was duplicated to the size of the matrix. E.g., if a column vector v and a matrix A are combined, the result is a matrix R[i,j], applying the operator to v[i] and A[i,j]. If a row vector v and a column vector w are combined the result combines v[i] with v[j].

All matrices must have the same size. Row vectors must have the same number of rows as any parameter matrix, and column vectors the same number of columns. If the operands do not fit together, there will be an error message.

Scalar values can be combined with any matrix or vector. In this case, the scalar is combined with all elements of the matrix or vector.


EMT can do calculus symbolically and numerically. Have a look at the following sections to learn more.

Derivatives - Compute Derivatives 
Integrals - Compute Integrals
Differential Equations - Solve Differential Equations

For symbolic methods, you can also refer to

For general information about numerical methods in EMT, there are tutorials, examples and references.


Symbolic differentiation is done with &diff by Maxima. Here are some examples.

  >&diff(expr,x) // derivative at s
  >&diff(expr,x,n) // n-th derivative at x
  >&diff(expr,x,1,y,1) // derivative to x and y
  >&diffat(expr,x=pi) // derivative to x at a
  >&diff(expr,x) with [x=pi,y=5] // alternative
  >&diffat(expr,x=pi,5) // n-th derivative to x at a

There are functions for the gradient, the Jacobian and the Hessian matrix.

  >expr &= x^2-x*y+y
  >sol &= solve(gradient(expr,[x,y]))
  >&hessian(expr,[x,y]) with sol[1]

Numerical differentiation is done with diff(). Note that numerical differentiation is numerically inaccurate or very expensive.

  >diff(expr,a) // derivative at a
  >diff("x^x",1) // e.g.
  >function f(x,a) := x^x*sin(a*x)
  >diff("f",1;5) // e.g. with a=5
  >diff(expr,a,n) // n-th derivative at a


Integration is available symbolically and numerically with a variety of methods.

For symbolic integration, use &integrate.

  >&integrate(expr,x) // anti-derivative
  >&integrate(expr,x,a,b) // definite integral
  >&assume(y>0); &integrate(x^y,x) // necessary sometimes

Or define an integral first, then evaluate it.

  >function F(x) &= integrate(f(x),x)
  >F(b)-F(a) // works better sometimes
  >F &= integrate(f(x),x) // alternative way using an expression
  >(F with x=b)-(F with x=a) // evaluate expressions

For numerical integration, the default integrate() uses an adaptive Gauss scheme.

  >integrate(expr,a,b) // adaptive Gauss
  >integrate("exp(-x^2)",0,1) // e.g.
  >function f(x,a) := exp(-x^2*a)
  >integrate("f",0,1;5) // e.g. with a=5

Some more methods for integration are available. (gauss, gauss5, romberg, simpson, adaptiveint). Some are from the AlgLib library (alintegrate, alsingular). The fastest method is gauss5.

  >gauss5("exp(-x^2)",0,1) // 5 evaluations of the function
  >gauss5("exp(-x^2)",0,1,20) // 20 subintervals, 100 evaluations

There are also advanced methods using intervals for guaranteed inclusions.


The results are very narrow intervals. But the effort is big. igauss() is another function which gets guaranteed bounds.

  >expr &= exp(-x^2);
  >igauss(expr,0,1,10,&diff(expr,x,20)) // compute 20-th derivative
  >igauss(expr,0,1,10,dexpr20est=1e12) // provide estimate

Differential Equations

Differential Equations can be solved by Maxima symbolically up to degree 2 with ode2.


To solve for initial values, there are ic1 (for one initial value) and ic2 (for two).

  >sol &= ode2('diff(y,x,2)+y=x^2,y,x) // general solution
  >ysol &= ic2(sol,x=0,y=0,'diff(y,x)=1) // set initial values
  >function f(x) &= y with ysol; // define a function from ysol

Maxima has some more advanced functions for differential equations, including systems of differential equations (&desolve, &ode2, &ic1, &ic2, &bc2).

  >eq1 &= 'diff(f(x),x) = g(x) // first equation
  >eq2 &= 'diff(g(x),x)+x^2 = -f(x) // second equation
  >&atvalue(f(x),x=0,0); // fix f(0)=0
  >&atvalue(diff(g(x),x),x=0,1); // fix g'(0)=1
  >sol &= desolve([eq1,eq2],[f(x),g(x)]) // solve
  >function fsol(x) &= f(x) with sol[1] // make it a function

Numerical solutions can be obtained with many functions in EMT. One is ode(), which uses the LSODA algorithm.

  >t=0:0.01:5; plot2d(t,ode("-x*y",t,1)): // e.g.

Second order differential equations need to be translated to systems of equations.

  >function f(x,y) := [y[2],sin(y[1])*x]
  >t=0:0.01:5; y=ode("f",t,[1,0]); 

EMT has more functions for differential equations, including interval functions with guaranteed inclusions (runge, adaptiverunge, heun, lsoda, mxmidgl). For the adaptive versions, you do not need intermediate points.

  >lsoda("-x*y",[0,1],1)[-1] // last value of solution, i.e. y(1)
  >adaptiverunge("-x*y",[0,1],1)[-1] // adaptive Runge method

The function mxmidgl() calls Maxima for a Taylor development of high degree.


For more information about differential equations refer to the tutorials or the reference.


EMT Math Toolbox has plots in 2D and 3D, both for data and functions. Click on the sections below.

Plots in 2D - Plots in the 2D plane
Plots in 3D - Plots in the 3D space
Logarithmic Plots - Plots with logarithmic scales
Styles of 2D Plots - Setting own plot labels, grid styles or axis ticks
Statistical Plots - Plots for statistical data
Plot Aspect - Aspect Ratio of the plot window
Basic Plots - Very basic functions for plots

It is possible to plot in Maxima using Gnuplot. But we do not cover this subject here.

For more information on plots, refer to

Plots in 2D

For planar plots, EMT uses the function plot2d. This function can plot functions and data. It can produce simple graphs, filled polygons, points and bar plots. Moreover, it can compute level lines, level sets and contour plots.

  >a:=5.6; expr &= exp(-a*x^2)/a // define expression
  >plot2d(expr,-2,2): // plot from -2 to 2
  >plot2d(expr,r=1,thickness=2): // plot in a square around (0,0)
  >plot2d(&diff(expr,x),>add,style="--",color=red): // add another plot
  >plot2d(&diff(expr,x,2),a=-2,b=2,c=-2,d=1): // plot in rectangle
  >plot2d(&diff(expr,x),a=-2,b=2,>square): // keep plot square

This works for numerical expressions too.

  >p=chebpoly(10); plot2d("polyval(p,x)",-1,1): // plot polynomial
  >plot2d(''integrate("sin(x)*exp(-x^2)",0,x)'',0,2): // plot integral

And it works for functions. As usual, you can pass additional parameters (besides x) to the function with semicolon parameters.

  >function f(x,a) := x^2/a+a*x^2-x; // define a function
  >plot2d("f",0,1;0.4): // plot with a=0.4

For data plots, you need one or more rows of x-values, and one or more rows of y-values.

  >xdata=[1,1.5,2.5,3,4]; ydata=[3,3.1,2.8,2.9,2.7]; // data
  >plot2d(xdata,ydata,a=0.5,b=4.5,c=2.5,d=3.5,style="."); // lines
  >plot2d(xdata,ydata,>points,>add,style="o"): // add points
  >p=polyfit(xdata,ydata,1); // get regression line
  >plot2d("polyval(p,x)",>add,color=red): // add plot of line

Thus, we can also plot curves or filled curves.

  >t=linspace(0,2pi,1000); // parameter for curve
  >x=sin(t)*exp(t/pi); y=cos(t)*exp(t/pi); // x(t) and y(t)
  >plot2d(x,y,r=10): // plot curve
  >plot2d(x,y,r=10,>filled,style="/",fillcolor=red): // fill curve

The plot of multiple functions can be done with >add, possible using a loop.

  >plot2d("(1-x)^10",0,1); // plot first function
  >for i=1 to 10; plot2d("bin(10,i)*x^i*(1-x)^(10-i)",>add); end;

But it can also be done with a matrix of x-values, and a matrix of y-values.

  >n=10; k=(0:n)'; // n is row vector, k is column vector
  >y=bin(n,k)*x^k*(1-x)^(n-k); // y is a matrix then

Another method is a vector of expressions. We can get such a vector from Maxima using makelist() and mxm2str().

  >plot2d(["sin(x)","cos(x)"],0,2pi): // plot vector of expressions
  >v &= makelist(binomial(10,i)*x^i*(1-x)^(10-i),i,0,10) // make list
  >mxm2str(v) // get a vector of strings from the symbolic vector
  >plot2d(mxm2str(v),0,1): // plot functions

For more information, refer to the tutorial about 2D plots, or the documentation about plot2d

plot2d - Reference to the main function for 2D Plots
Plot Aspect - Change the aspect ratio of the plot window
Plots - Overview of Plots

Logarithmic Plots

EMT uses the "logplot" parameter for logarithmic scales. 1 is for the x-axis, 2 for both axes, and 3 for the x-axis only.


This does also work with data plots.

  >x=10^(1:20); y=x^2-x;

Plots - Overview of Plots

Styles of 2D Plots

By default, EMT computes automatic axis ticks and adds labels to each tick. This can be changed with the grid parameter.

  >plot2d("x^3-x",grid=0) // no grid, frame or axis
  >plot2d("x^3-x",grid=1) // x-y-axis
  >plot2d("x^3-x",grid=2) // default ticks
  >plot2d("x^3-x",grid=3) // x-y- axis with labels inside
  >plot2d("x^3-x",grid=4) // no ticks, only labels
  >plot2d("x^3-x",grid=5) // default, but no margin
  >plot2d("x^3-x",grid=6) // axes only
  >plot2d("x^3-x",grid=7) // axes only, ticks at axis
  >plot2d("x^3-x",grid=8) // axes only, finer ticks at axis
  >plot2d("x^3-x",grid=9) // default, small ticks inside
  >plot2d("x^3-x",grid=10) // no ticks, axes only

The parameter <frame switches off the frame, and framecolor=blue sets the frame to a blue color.

If you want your own ticks, you can use style=0, and add everything later.

  >plot2d("x^3-x",grid=0); // plot
  >frame; xgrid([-1,0,1]); ygrid(0): // add frame and grid

For the plot title and labels of the axes, see the following example.

  >textcolor(black); // set the text color to black
  >title("y=exp(x)"); // title above the plot
  >xlabel("x"); // "x" for x-axis
  >ylabel("y",>vertical); // vertical "y" for y-axis
  >label("(0,1)",0,1,color=blue); // label a point
  >reset: // to revert the text color

The axis can be drawn separately with xaxis() and yaxis().

  >xaxis(0,xx=-2:1,style="->"); yaxis(0,yy=-5:5,style="->"):

Text on the plot can be set with label(). In the following example, "lc" means lower center. It sets the position of the label relative to the plot coordinates.

  >function f(x) &= x^3-x
  >x0=fmin(f,0,1); // compute point of minimum
  >label("Rel. Min.",x0,f(x0),pos="lc"): // add a label there

There are also text boxes.

  >plot2d(&f(x),-1,1,-2,2); // function
  >plot2d(&diff(f(x),x),>add,style="--",color=red): // derivative
  >labelbox(["f","f'"],["-","--"],[black,red]): // label box

There are interactive sliders, which can set values by the user. The function dragvalues() provides this.

  >function plotf([a,b]) := plot2d("exp(a*x)*cos(2pi*b*x)",0,2pi;a,b);
  >dragvalues("plotf",["a","b"],[-1,2],[[-2,2];[1,10]], ...
  >  heading="Drag these values:",hcolor=black):

Plots - Overview of Plots

Plots in 3D

3D Plots in EMT are done in central projection. The algorithm used is very quick and usually produces very nice plots. For photo-realistic output, you can install Povray and use it from EMT. EMT can also do anaglyph plots for red/cyan glasses.

The most elementary form shows the graph of a function in x and y and uses an expression in x and y or a function.

  >plot3d("x*abs(y)^1.4", ...
  >    contour,>spectral,angle=-60°,height=20°,scale=1.1):
  >function f(x,y,a) := x^2+y^a
  >plot3d("f";4.5,a=0,b=1,c=0,d=1,>contour,angle=20°): // with a=4.5

For general surfaces, three functions can be used. Then, no scaling takes place and the default view and zoom is used.

  >plot3d("x","y","x*y",xmin=-2,xmax=2,ymin=-2,ymax=2, ...
  >    scale=[2,2,1],n=10):

Matrices of x-, y-, and z-coordinates can be used to represent the surface. The matrix language of EMT allows that x can be row vector and y a column vector only.

  >x=-2:0.05:2; y=x'; plot3d(x,y,x*y,scale=[2,2,1]; grid=10):

For an example with shading, we plot a ball.

  >s=linspace(0,2pi,180); t=linspace(-pi/2,pi/2,90)'; 
  >plot3d(cos(s)*cos(t),sin(s)*cos(t),sin(t), ...
  >   >hue,grid=[6,4],<frame,color=blue,scale=1.5,height=45°,angle=45°):

For clouds of points or lines, use >points or >wire.

  >A=normal(3,500); plot3d(A[1],A[2],A[3],>points): // cloud of points
  >W=cumsum(A); plot3d(W[1],W[2],W[3],>wire): // path in 3D

For more information, refer to the tutorial for 3D plots or the documentation of plot3d.

Plot Aspect - Change the aspect ratio of the plot window
plot3d - Main function for 3D plots
Plots - Overview of Plots

Plot Aspect

The default plot uses a square plot window. You can change this with the function aspect(). Do not forget to reset the aspect later.


In 3D Plots, we can change the scaling of the z-values. The following is a polar plot, which graphs the function on a disk.


The reset() function restores plot defaults including the aspect ratio.

Statistical Plots

There are many functions which are specialized on statistical plots. For a demonstration, refer to the tutorial on statistics.

One of the often used plots is a column plot.


It can also show strings as labels.

  >months=["Jan","Feb","Mar","Apr","May","Jun", ...
  >  "Jul","Aug","Sep","Oct","Nov","Dec"];

To plot an experimental statistical distribution, you can use distribution=n with plot2d.

  >w=randexponential(1,1000); // exponential distribution
  >plot2d(w,>distribution): // or distribution=n with n intervals

Or you can compute the distribution from the data and plot the result with >bar in plot3d, or with a column plot.

  >w=normal(1000); // 0-1-normal distribution
  >{x,y}=histo(w,10,v=[-6,-4,-2,-1,0,1,2,4,6]); // interval bounds v

The statplot() function sets the style with a simple string.


For more statistical plots, refer to the tutorial on statistics, or the following introduction.

Statistics - Introduction to Statistics in EMT

Basic Plots

There are also very basic functions of plots. The following is just a brief introduction into these elementary functions.

plots - Core functions for elementary Plots.

There are screen coordinates, which always range from 0 to 1024 in each axis, no matter if the screen is square or not. Ant there are plot coordinates, which can be set with setplot(). The mapping between the coordinates depends on the current plot window. E.g., the default shrinkwindow() leaves space for axis labels and a plot title.

In the example, we just draw a few random lines in various colors. For details on these functions, study the core functions of EMT.

  >clg; // clear screen
  >window(0,0,1024,1024); // use all of the window
  >setplot(0,1,0,1); // set plot coordinates
  >hold on; // start overwrite mode
  >n=100; X=random(n,2); Y=random(n,2);  // get random points
  >colors=rgb(random(n),random(n),random(n)); // get random colors
  >loop 1 to n; color(colors[#]); plot(X[#],Y[#]); end; // plot
  >hold off; // end overwrite mode
  >insimg; // insert to notebook

It is necessary to hold the graphics, since the plot() command would clear the plot window.

To clear everything we did, we use


For another example, we draw a plot as an inset in another plot. This is done by defining a smaller plot window. Note that this window does not provide room for the axis labels outside the plot window. We have to add some margin for this as needed. Note that we save and restore the full window, and hold the current plot while we plot the inset.

  >xw=200; yw=100; ww=300; hw=300;
  >hold on;
  >hold off;

A plot with multiple figures is achieved in the same way. There is the utility figure() function for this.

The Tutorial about plots contains another example of a function made of basic plot routines.

window (Plot Functions),
figure (Plot Functions)


EMT can generate random numbers for various distributions. They are usually named rand... with a few exceptions. E.g.

  >mean(normal(100000)) // 0-1-normal distributed values
  >dev(random(100000)) // uniformly distributed values in ]0,1[
  >  // 1x100000 matrix of 1000-10-norm. values
  >plot2d(w,>distribution): // plot the distribution
  >w=intrandom(1,600,6); // 1x600 matrix of dice throws
  >getmultiplicities(1:6,w) // count multiplicities
  >mean(randexponential(1,100000,2)) // exponential distribution

EMT has many distribution functions and their inverses.

  >normaldis(3) // 0-1-normal distribution function
  >  // 90% confidence interval of 1000-10-normal distribution
  >invcchidis(chicdis(30,10),10) // inverse complimentary chi-square

Most density functions are also present. They are named like qnormal().

  >plot2d(normal(1000),>distribution); // plot empirical data
  >  // add expected density

Here are some examples of statistical indicators, derived from empirical data.

  >mean(x), dev(x)
  >getfrequencies(x,-4:4) // count number of items in intervals
  >covar(x[1:2:999],x[2:2:1000]) // empirical covariance
  >quartiles(x) // quartiles, neglecting outliers
  >quantile(x,10%) // 10% quantile
  >plot2d(-4:4,empdist(-4:4,sort(x))): // empirical distribution

There are statistical tests too.

  >X=normal(3,10); // get 3 rows of data to test for same mean
  >varanalysis(X[1],X[2],X[3]+2) // will be rejected
  >mediantest(X[1],X[2]+2) // will be rejected
  >signtest(X[1],X[2]+2) // will be rejected
  >x=getfrequencies(v,0:0.1:1) // frequencies of exponential data
  >y=ones(1,10)*sum(x)/10 // assumed uniform distribution
  >chitest(x,y) // will be rejected

For statistical plots refer to

Statistical Plots - Special plots for statistics

For more information about statistics in EMT, refer to

Solve Equations

To solve a an equation or a system of equations symbolically, use &solve(). The function returns a vector of solutions. To insert one of the solutions into an expression, use with.

  >&solve(diff(x^3-x,x)) // all critical values (assume expr=0)
  >expr &= x^3-x
  >&solve(diff(expr,x)=0,x), &expr with %[1] // value at maximum

Systems are solved in a similar way. The solution is a vector of solutions, which are in turn vector of equations [x=3,y=4] etc.

  >sol &= solve([x^2+y=4,x-2*y=a],[x,y]) // system of 2 equations
  >&[x,y] with sol[1] with a=4 // get first solution with a=4

To solve an equation numerically, the default function is solve(), which uses a secant algorithm.

  >solve("x^x-3",1) // solve near 1
  >solve(&diff(x^x,x),0.5) // with symbolic expression
  >solve(&diff(x^x,x),1,y=2) // target value y=2 near 1
  >function f(x,a) := x^x-a*x
  >x1 := solve("f",1,2;0.2,y=1) // with a=0.2 between 1 and 2

There are more algorithms, some of them with guaranteed inclusions.

  >bisect("x^3",1,2,y=2,eps=0.01) // reduced accuracy
  >ibisect("x^3",1,2,y=2) // guaranteed inclusion
  >secantin("x^x",0,0.2,y=0.9) // keep solution in interval
  >expr &= diff(x^x,x)
  >newton(expr,&diff(expr,x),0.5) // Newton for expr=0
  >inewton(expr,&diff(expr,x),0.5) // guaranteed and fast solution

To solve a system of equations, Broyden's algorithm is fast and converges for close starting points.

  >function f(x) := [x[1]^2+x[2]^2-10,x[1]+2*x[2]-4]
  >broyden("f",[0,3]), f(%) // solve and test result
  >function f([x,y]) := [x^2+y^2-10,x+2*y-4] // easier definition of f

For the Newton algorithm, we need the Jacobian.

  >function f([x,y]) &= [x^2+y^2-10,x+2*y-4] // f
  >function Df([x,y]) &= jacobian(f(x,y),[x,y]) // Jacobian of f
  >newton2("f","Df",[0,3]) // Newton algorithm
  >inewton2("f","Df",[0,3]) // guaranteed inclusion

Optimization (Overview)


Expanding and factoring of symbolic expressions can be done with very large expressions.

  >&factor(x^6+x^2+1) | modulus:=13 // factor in Z modulo 13
  >&expand((1+x)^4+(1+x)^2+1/(1+x)^2+1/(1+x)^4,2,2) // limit expansion

To factor numbers, use a direct mode.

  >:: factor(100!)

There are various to extract parts of an expression.

  >expr &= expand((a*x^3+a^2*x+b*x+y)*(a*x+y))
  >&part(expr,2) // second term in expression
  >&collectterms(expr,x) // make a polynomial of x
  >&coeff(expr,x,2) // coefficient of x^2
  >&combine(a/b+c/d+e/b) // combine fractions

For simplification, there are many methods.

  >&ratsimp(1/x+1/x^2+(x+1)/x) // try to simplify a fraction
  >&partfrac((x^2+1)/(x^2-1),x) // sum as partial fractions
  >&trigsimp((sin(x)+cos(x))*(2*sin(x)+cos(x))) // apply rules for trig
  >&radcan((log(1+2*a^x+a^(2*x))/log(1+a^x))) // apply rules for radicals

There are many options for expansions and reductions.

  >&trigexpand(sin(5*x),x) // make it a polynomial in sin(x), cos(x)
  >&trigreduce(sin(x)^5,x) // make it a trigonometric series
  >&log(a*b) | logexpand:=all // apply rules of log
  >&logcontract(log(x)+log(y)) // collect sums of log
  >&sqrt(x^y) | radexpand:=all // apply rules for sqrt
  >&multthru(a*x+1,b+c) // multiply into sum
  >&distrib((1+x*(2+x))*(1+y)) // apply distrib. rule
  >&rootscontract(sqrt(x)*sqrt(y)) // contract roots
  >&scsimp(a*b+b*c,a*b+d=1,b*c=d) // simplify with rules

Do not forget, that you can map a function to each argument.


You can get examples for manipulations.

  >:: example(radcan)


Functions of one variable are minimizes with fmin(). With several variables, use the Nelder Mead algorithm or Powell's algorithm

  >fmin("x^3-x",0,1), "x^3-x"(%)
  >function f([x,y,z]) &= x^2+y^2+z^2+exp(-x*y*z)+x
  >nelder("f",[0,0,0]) // start from x=y=z=0
  >powellmin("f",[0,0,0]) // start from x=y=z=0
  >&grad(x^2+y^2+z^2+exp(-x*y*z)+x) with [x=-1/2,y=0,z=0]

Alternatively, the Broyden algorithm could be used for grad f=0.

  >function f([x,y,z]) &= x^2+y^2+z^2+exp(-x*y*z)+x
  >function df([x,y,z]) &= grad(f(x,y,z))

The simplex algorithm can be called via simplex() or the LPSOLVE library.

  >A=[1,2;3,4;4,2] // mxn matrix A
  >b=[10,8,7]' // column vector b
  >c=[1,1] // row vector c
  >simplex(A,b,c,>max) // solve cx->max with Ax<=b, x>=0

Here is an example with equalities

  >A=random(5,10); b=sum(A);

Another example with a mix of >= and <=.

  >A=[1,1;1,1;1,-1;1,-1] // 4 inequalities -1<=x+y<=1, -1<=x-y<=1
  >b=[-1,1,-1,1]' // right hand side
  >eq=[1,-1,1,-1]' // equations >=, <=, >=, <=
  >restr=[0,0] // no restriction x>=0
  >c=[1,1.2]; // target function
  >simplex(A,b,c,eq,restr,>max) // solve

For integer problems, use intsimplex() or the efficient LPSOLVE.

  >A=random(10,2); b=ones(10,1)*100;

For non-linear problems, you can use the Newton-Barrier method.

  >A=1+random(1000,2); // 1000 linear conditions
  >b=100+random(1000,1)*100; // right hand side
  >A=A_-id(2); b=b_zeros(2,1); // add x>=0
  >function f([x,y]) &= 1/(x*y); // target function
  >function df([x,y]) &= gradient(f(x,y),[x,y]); // gradient
  >function Hf([x,y]) &= hessian(f(x,y),[x,y]); // Hessian

Here is an example with a linear target function.

  >A=random(40,5)_-id(5); b=ones(40,1)*10_zeros(5,1);
  >simplex(A,b,c,>max) // for comparison
  >function f(x) := -c.x'; // x is a row vector here
  >function df(x) := -c;
  >function Hf(x) := 0;

simplex (Linear Programming)

For more examples and the reference see


Linear regression with polynomials can be done with polyfit().

  >function f(x) := 0.8*x+0.1; // correct function
  >x=0:0.1:1; y=f(x)+random(cols(x))*0.4; // random values
  >plot2d(x,y,>points); // plot values
  >p=polyfit(x,y,1) // fit with polynomial of degree 1
  >plot2d("polyval(p,x)",>add,color=red): // add fit to plot

General linear fits can be done with fit(A,y). This minimizes |Ax-y|.

  >function f(x) := exp(-0.2*x)+0.5*exp(-0.4*x)+0.3
  >  // of type a*exp(-0.2*x)+b*exp(-0.4*x)+c
  >x=0:5; y=f(x)+random(cols(x))*0.4;
  >plot2d(x,y,>points); // plot random data
  >function ff(x) := a[1]*exp(-0.2*x)+a[2]*exp(-0.4*x)+a[3]
  >mean(ff(x)-y), dev(ff(x)-y) // 0 and norm of difference

For non-linear fits of all kinds, one choice is Nelder-Mead.

  >function f(x) := exp(-0.2*x)+0.5*exp(-0.4*x)
  >  // of type exp(c*x)+0.5*exp(d*x)
  >x=0:5; y=f(x)+random(cols(x))*0.1;
  >plot2d(x,y,>points); // plot random data
  >function ff(x,[c,d]) := exp(c*x)+0.5*exp(d*x);
  >function ferr(v) := sqrt(sum(ff(x,v)-y)^2)

Data Types

The numerical data types of EMT are based on the IEEE standard with an accuracy of 16 decimal digits. The default output does not show all significant places.

  >1/3 // default output of a single number
  >longest 1/3 // all digits
  >fraction 1/3 // output as fraction
  >shortest pi // very short output
  >long exp(1+2*I) // complex number, long output
  >sin(pi), longest sin(pi) // rounding towards 0

There are more formats for the output and input.

  >print(1000*1.03^5,2,15," Euro") // print function

To enter vectors and matrices use [].

  >A=[1,2,3;4,5,6] // 2x3 matrix
  >A[1] // first row
  >A[,2] // second column
  >A[1,2:3] // first row, column 2 to 3
  >[1,2,3;4] // second row auto-filled with 0
  >[1,2;3,I] // complex matrix
  >v=1:10 // row vector 1 to 10
  >v[5:7] // elements 5 to 7

Matrix Language - Matrix Language of EMT

EMT can also use strings and vectors of string.

  >"Just a string!"
  >"Strange character: "+char(156) // number to character
  >strtochar("Help") // get numbers
  >r=6.7; "Area of circle with radius "+r+" = "+(pi*r^2)

Expressions - Expressions in EMT

There are also intervals. The rule of operators and functions is that all possible points in the intervals are used.

  >~-1,2~*~-1,2~ // all x*y with -1 <= x,y <=2
  >~-1,1~^2 // all x^2 with -1 <= x <= 1
  >exp(~-1,1~) // all exp(x) with -1 <= x <= 1

Interval Arithmetic - Guaranteed Inclusions

Linear Algebra

There are many methods to solve a linear system in Euler.

  >A\b // Gauss algorithm
  >A=redim(1:9,3,3) // singular matrix !
  >fit(A+normal(size(A)),b) // fit with orthogonal methods
  >svdsolve(A,b) // fit using singular values

For hand work there is a pivotize() function.

  >A=[0,1,2;3,4,5;1,2,0]; b=sum(A);
  >M=A|b // produce the Gauss scheme
  >fraction pivotize(M,2,1)
  >fraction pivotize(M,1,2)
  >fraction pivotize(M,3,3)
  >A=[0,1,2;3,4,5;1,2,0]; M=A|sum(A)
  >echelon(M) // all in one step

There are also function to handle a Gauss-Jordan scheme. See the tutorial on Linear Algebra for an example.

There are a lot more algorithms for Linear algebra.

  >svdkernel(A) // orthogonal basis of kernel
  >eigenvalues(A), real(%)
  >{v,X}=eigen(A); v, // LAPACK algorithm for eigenvalues
  >v // singular values
  >{R,Q,c}=qrdecomp(A); // QR decomposition
  >Q'.R // is A

For symbolic linear algebra, you can define symbolic matrices or transport a numerical matrix to Maxima.

  >A &= [1,2,3;4,5,6;7,8,x]
  >&determinant(A), &solve(%=0)
  >A=[1,2;3,4]; // numerical matrix
  >&invert(@A) // use direct in symbolic expression
  >mxmset("A",random(2,2)) // define a matrix A in Maxima

Matrix Language

All operators and functions in EMT should obey the matrix language. I.e., they vectorize (map) to all elements of matrix operands.

  >v*v, sum(%) // vector of v[i]*v[i] and sum of it
  >v^3 // vector of v[i]^3
  >3*v // vector of 3*v[i]
  >[1;2]*v // column vector and row vector combine to matrix
  >v.v' // for the matrix product, use "."!

Row and column vectors combine to matrix. Matrices and vectors combine to matrices.

  >A*[4,5] // multiply columns with 4 and 5
  >A*[4,5]' // multiply rows with 4 and 5

You can vectorize own functions using the map keyword.

  >function map f(x) := integrate("sinc(x)",0,x)

- Program Language of EMT


In the numerical kernel of EMT, expressions are strings, which may be marked as symbolic. Then they print va Maxima.

  >expr := "x^3-x" // expression in string
  >plot2d(expr,-1,1): // plot expression
  >expr &= x^3-x // symbolic expression
  >expr // prints via Maxima
  >plot2d(expr,-1,1): // plot it

Expressions can be evaluated numerically. The variables x,y,z are assigned automatically. Other variables can be assigned by assigned parameters or via global variables.

  >expr &= a*x^2
  >a=4; expr(2.5) // use global variable
  >expr(2.5,a=5) // use assigned variable
  >"x*y^2"(3,4) // direct evaluation

Thus many algorithms of EMT can use expressions in x or functions. But as soon as additional parameters are involved, which are not global, functions should be preferred.

  >a=5; plot2d("a*x^3-x",0,1): // use global a
  >function f(x,a) := a*x^3-x
  >plot2d("f",0,1;4): // use a=4 as semicolon parameter
  >plot2d("f(x,4)",0,1): // alternative

Symbolic expression can be evaluated by Maxima with "with". This is a nice way in EMT to use "at".

  >expr &= exp(-x^2)
  >&expr with x=a
  >&expr with x=5.67
  >&expr with x=sqrt(log(y))
  >&x^2+y^2 with [x=5,y=4]
  >&at(x^2+y^2,[x=5,y=4]) // original Maxima syntax

"with" is a simple way to use results of "solve".

  >&solve(x^3-2*x+1,x), &x with %[1]
  >&solve([x+y=5,x-2*y=4]); &[x,y] with %[1]

A special problem worth mentioning here is the conflict between an expression and a function with the same name. To avoid this, use names like fx, fxy or expr, which are not used for functions. If a function and an expression with the same name exists, the expression will be used.

Interval Arithmetic

The rule for interval arithmetic is that operators combine all elements of the parameter intervals and return an interval containing all these results. Functions are applied to all elements of the parameter interval similarly.

  >~1,2~ * ~7,8~ // result: ~1*7,2*8~
  >~-1,1~ * ~1,1~ // result: ~-1,1~ !!!
  >~-1,1~^2 // result: ~0,1~ !!!
  >sin(~-1,1~) // result: ~sin(-1),sin(1)~

Often, we express a function in terms of an expression. Then the rules for expressions overestimate the result of the function. There are clever methods to get closer inclusions.

  >expr &= x^4-x^3+x^2+x-1
  >x=1±0.02 // another way to enter an interval, use F8
  >expr(x) // simple evaluation
  >expr(fmin(expr,left(x),right(x))) // best lower estimate
  >expr(fmax(expr,left(x),right(x))) // best upper estimate
  >ieval(expr,x) // using sub-division of interval

Integrals are good for obtaining guaranteed solutions.

  >ibisect("x^3-x",1,2,y=1.4) // interval bisection
  >expr &= x^x
  >inewton(expr,&diff(expr,x),1,y=1.4) // interval Newton
  >mxminewton(expr,1,2,y=1.4) // automatic call of Maxima
  >mxmiint("x^x",1,2) // elaborate inclusion of integral
  >  // estimate of 20-th derivative
  >igauss("exp(-x^2)",0,2,dexpr20est=est20) // close approximation
  >longest integrate("exp(-x^2)",0,2) // for comparison

There are also interval methods for linear system and for non-linear systems of equations.

Polynomials and Splines

Numerical polynomials are stored as vectors v of coefficients with the constant coefficient in v[1]. They can be evaluated and manipulated to some degree.

  >p=[1,2,3]; // 1+2x+3x^2
  >plot2d("evalpoly",-1,1;polydif(p)): // derivative of p
  >polymult(p,p) // coefficients of p^2

There are some special polynomials.

  >chebpoly(10) // coefficients of 10-th Chebychev polynomial
  >cheb(0.6,10) // evaluate it in 0.6
  >legendre(8) // Legendre polynomial

Interpolation can be done with the Newton scheme.

  >p=[1,-1,2,-1] // a polynomial
  >xdata=1:4; ydata=evalpoly(xdata,p) // evaluated in 1,2,3,4
  >dd=divdif(xdata,ydata) // divided differences
  >plot2d(xdata,ydata,>points); // plot points
  >plot2d("evaldivdif(x,dd,xdata)",>add): // plot interpolation
  >polytrans(xdata,dd) // get back the polynomial
  >q=polyfit(xdata,ydata,2) // fit polynomial of degree 2
  >plot2d("evalpoly(x,q)",color=green,>add): // add to plot

Symbolic Polynomials can be derived from the vector with "sum". The converse can be done with "makelist".

  >p &:= chebpoly(10) // vector of coefficients in Maxima and EMT
  >pol &= sum(p[k]*x^(k-1),k,1,11) // make it a polynomial
  >&makelist(coeff(pol,x,k),k,0,10), vpol = %() // get the vector back

Furthermore, EMT can compute the zeros of polynomials numerically.

  >p=1|zeros(1,10)|1 // z^11 + 1
  >plot2d(polysolve(p),>points): // Baurhuber iteration, plot zeros
  >polysolve(p,>usematrix) // eigenvalues of companion matrix

Interpolation with cubic splines are can be done with "spline".

  >xdata=-5:5; ydata=zeros(size(xdata)); ydata[6]=1; // data points
  >s=spline(xdata,ydata); // compute spline
  >plot2d("evalspline(x,xdata,ydata,s)",>add): // evaluate
  >  // maximal distance between lineare and cubic spline

For B-Splines, use nspline().



The internal accuracy of Euler number is the IEEE standard of about 16 decimal digits. Euler does not print all digits by default. This saves space and looks better. For one number, the following operators can be used.

  >longest pi
  >long pi
  >short pi
  >shortest pi
  >fraction 1/3+1/7

To format a number, there are many more functions. The result is always a string. Note that you can append strings with +.

  >print(pi,5,10) // with number of digits and total length
  >K=1012.56; i=3.75%;
  >"E = "+print(K*(1+i),2,unit="$") // with additional unit
  >printdollar(K*(1+i)^4) // shortcut
  >degprint(0.56,<dms) // not with minutes and seconds
  >"polar: "+polarprint(1+I)
  >frac(1/3)+" + "+frac(1/7)+" = "+frac(1/3+1/7) // convert to frac
  >printf("pi = %10.2f",pi) // C style printf
  >"x = "+(pi*4+1) // string plus number in default format

You can also set the output format permanently.

  >format(5,2); // 5 places with 2 digits after decimal dot
  >format(10); // nice format with 10 digits of accuracy

By default, Euler makes a difference between the output of scalars, vectors and matrices. By default, scalars use a longer format, and vectors use a denser format. The function format(n,m) applies to all output, however.

  >reset; // reset output
  >pi // uses the longer scalar format
  >1:10 // uses a dense vector output
  >random(3,3) // uses the default matrix format
  >denseoutput(0); 1:5 // turn off dense output
  >denseoutput(2); 1:5 // default
  >setscalarformat(5); pi // use 5 digits of accuracy for scalars

Some commands change the format for the subsequent output.

  >shortestformat; random(2,8), pi // only for matrices
  >shortformat(>all); pi // for all output
  >longestformat; pi // always for all output
  >goodformat(12); pi
  >format(8,5); random(4,4) // for all output
  >goodformat(8,4); random(4,4), pi // for matrices only
  >goodformat(4,>all); random(4,4), pi
  >fracformat(10); intrandom(6,6,6)/intrandom(6,6,6) // fractions
  >defformat; // reset the default

Large matrices are eclipsed by default. There are several ways to see the full matrix.

  >largematrices on; // or off - toggles the eclipsed output
  >showlarge A // shows A without eclipses
  >shortest A // may help to see the full matrix A

Programming Language

There are one-line and multi-line programs.

  >function f(x) := x^3-x; // one-line function
  >function map f(x) // multi-line function ...
  $  if x>0 then return x^2 // if x>0 would not work for vectors x
  $  else return x^3
  $  endif;

To start a multi-line function type "function f(x)" and press Ctrl-Return. To edit a multi-line function click into its body. Use Ctrl-Return for line breaks, and Ctrl-Back for joining lines. Alternatively, you can press F9 and edit in a separate editor.

A variety of control structures are available, which work in one-line commands too, but usually spread several lines in programs. The loop with "repeat" is eternal, but can be left with until, while, or break;

  >function f(x) ...
  $  xnew=(x+2/x)/2;
  $  until x~=xnew;
  $  x=xnew;
  $return x;

Other loops start with "for" and "loop". The for loop can loop over a vector.

  >s=0; loop 1 to 10; s=s+#; end; s,
  >s=0; for i=1 to 10; s=s+i; end; s,
  >s=0; for i=10 to 1 step -1; s=s+i; end; s,
  >v=1:10; s=0; for i=v; s=s+i; end; s,

The "if" structure can have "else" and "elseif" branches. It needs an "endif". The condition does not work for vectors. So we need to vectorize with "map".

  >function map f(x) ...
  $  if x<0 then return -1;
  $  elseif x==0 then return 0;
  $  else return 1
  $  endif;

Multiple return values are possible. Only the first return value will be used as an argument to another function, unless the modifier "args" is set.

  >function f(a,b) := {b,a}
  >{x,y}=f(1,2); x, y,
  >function args f(a,b) := {b,a}
  >{x,y}=f(f(1,2)); x, y, // would not work without "args"

Parameters can be restricted to specific data types.

  >function map f(a:real) := integrate("sinc(x)",0,a)

For details on this, see the reference.

parameters - Reference for parameters
function - Reference for functions
trace - How to find errors in functions alias - Define an alias for a function

Symbolic Functions

Symbolic functions are functions which are defined for Maxima and for the numerical kernel of EMT. These functions must be one-line functions defined with &=. The definition can spread over several lines nevertheless.

  >function f(x) &= x^x
  >function df(x) &= diff(f(x),x)
  >function h(x) &= diff(f(x),x) +  ...
  >    diff(f(x),x,2)

The body of the function is evaluated symbolically before it is defined. Thus df() in the example above is a valid function for EMT which can be evaluated numerically quickly and efficiently. Moreover, it can be used in other symbolic functions.



Maxima at Compile Time

Using a symbolic function inserts a Maxima result at compile time into the numerical EMT function.

  >function f(x) &= integrate(x^3*cos(x),x)
  >type f // inspect the function

Symbolic expressions can also be inserted into multi-line functions. Again, the expression is evaluated at compile time, and the result is inserted into a normal EMT function. Take care to set brackets, since the result of the symbolic evaluation is inserted verbatim.

  >expr &= x^x-2;
  >function newtoniterator (x)
  $  return x-(&:"expr")/(&:"diff(expr,x)");
  $  endfunction
  >type newtoniterator // look at the definition
  >x=2; newtoniterator(x)


Comments can contain some markups.

* Heading ** Sub-Heading --- latex: F(x) = \int_a^x f(t) \, dt mathjax: \frac{x^2-1}{x-1} = x+1 maxima: 'integrate(x^3,x) = integrate(x^3,x)+C http://www.euler-math-toolbox.de See: http://www.google.de | Google image: test.png

Images cannot be read from the Web. For "See:", local web links are possible.


Most of the functions of EMT are not in the C core, but written in the programming language of EMT and loaded from Euler files (*.e) when the program starts. Euler files can be edited with any editor. To start the editing, enter

  >load file

into the notebook and press F9 (internal editor) or F10 (external editor, by default JE). The file will be saved in the directory of the current notebook. In the case of the internal editor, EMT will wait for the editing to finish.

Scripts can contain

  - definitions of functions (function ...)
  - EMT commands (>...)
  - calls to Maxima (>:: ...)
  - comment functions (function comment name ...)
  - maxima comment functions (maximafunction name ...)
  - entries for the user menu (addmenu ...)
  - comment sections (comment ... endcomment)
  - single line comments (// ...)
  - load commands for other Euler files (load filename)

Make sure, functions have proper comment lines. For core functions or functions in C loaded by a DLL, there are comment functions. For functions defined in Maxima in EMT, there is the maximafunction definition.

:: h(x) := x^3;

maximafunction h (x) ## Computes x^3 endfunction


  >help &h

will work. And &h will be known in the help window.

Help for Euler files is available by entering filename.e in the help window, or by double clicking on the line consisting of the load command.

Scripts can be run on the command line. Output will be lost however unless files are used. Use the parameter "-script script.e" to start EMT for a script. Details are explained in the web documentation.

Documentation Homepage