From Wikibooks, open books for an open world
Jump to: navigation, search

This book shows how to use Maxima.

weaknesses of CAS/math software[edit]

  • the limit of a discontinuous function at the point of discontinuity[1]
  • branch cuts[2]
  • zero-recognition
  • keeping track of domains of validity

How to use ?[edit]

Ways to do it :

  • online , wothout installation
  • offline = after installation

How to install ?[edit]


  • gnuplot,
  • tex
    • texinfo
    • texi2html
    • texlive-latex-recommended
  • GNU autotools
    • automake 1.9
    • autoconf2.13
  • tk 8.4.
  • lisp
    • sbcl
  • libgmp3-dev
  • libreadline5-dev
  • libncurses5-dev
  • sharutils
  • libxmu-dev
  • libxaw7-dev
  • wxWidgets library for wxMaxima
    • libwxgtk3.0-dev
    • libwxbase3.0-dev
  • compiler is GNU g++ for wxWidgets library
  • build-essential
  • imagemagick
  • ibus-gtk
  • ibus-gtk3


  • Download and install ready made Maxima deb packages
    • from Ubuntu repositories ( old versions )
    • from other sites[3]
  • Compile your own maxima package[4][5]
  • compile maxima from sources ( without creating deb packages )

Now the best is a git method

from Ubuntu repositories[edit]

You can make use of :

  • Synaptic ( Graphical package manager)
  • apt-get.

In second case write in command line:[6]

sudo apt-get install maxima

This method can get old version which gets some trouble, like

 loadfile: failed to load /usr/share/maxima/5.37.2/share/draw/draw.lisp

Uninstall such Maxima version

 sudo apt-get remove maxima

from PPA[edit]


From repositiories[7] by Istvan Balhota

sudo add-apt-repository ppa:blahota/wxmaxima
sudo apt-get update
sudo apt-get install wxmaxima

From sources[edit]

Before compilation, you should have all dependent packages


cd maxima
./bootstrap    # only if you downloaded the source code from cvs
./configure --enable-clisp   # or:   --enable-sbcl
make check
sudo make install
make clean

This procedure does not create a deb package.

using git[edit]


If you have git and SBCL then : [8]

  git clone git:// maxima
  cd maxima
  ./configure --with-sbcl

Now one can run it from inside the source directory.

cd maxima

The result :

Maxima branch_5_30_base_104_ged70fb2_dirty
using Lisp SBCL
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.

Xmaxima can also be run :

cd ~/maxima

or bash file :


# save as a  in your home directory
# chmod +x m
# ./m

cd maxima

wxMaxima is not present now.

Where is Maxima after standard ( as above) installation ?

  locate maxima-local

example result :


Note that it is a different directory then after apt-get installation. One can have 2 ( or more ) versions of Maxima on the disk )


 git clone


  • Open a terminal
  • type : sudo apt-get install gdb
  • after gdb is installed type : gdb wxmaxima
  • run and wait until it crashes
  • and type : backtrace


"=" means syntactic equality. Check : is(equal(a,b))


  • atom
    • number
    • name
    • string
  • list of atoms


data types[edit]

  • Numbers
  • Strings
  • Constants
  • Lists
  • Arrays
  • Structures


Maxima recognizes certain mathematical properties of:

  • functions and variables
  • system. There is a list of non-mathematical, system-dependent features. See status.

which called features.

 declare (x, foo) /* gives the property foo to the function or variable x */
 declare (foo, feature) /* declares a new feature foo. */ 
 declare ([red, green, blue], feature) /* declares three new features, red, green, and blue. */

The predicate

 featurep (x, foo) 

returns true if x has the foo property, and false otherwise.

The infolist features is a list of known features. These are

   integer        noninteger      even
   odd            rational        irrational
   real           imaginary       complex
   analytic       increasing      decreasing
   oddfun         evenfun         posfun
   constant       commutative     lassociative
   rassociative   symmetric       antisymmetric

plus any user-defined features.

features is a list of mathematical features.


(%i1) declare (FOO, feature);
(%o1)                         done
(%i2) declare (x, FOO);
(%o2)                         done
(%i3) featurep (x, FOO);
(%o3)                         true


declare recognizes the following properties:

  • additive : Tells Maxima to simplify a_i expressions by the substitution a_i(x + y + z + ...) --> a_i(x) + a_i(y) + a_i(z) + .... The substitution is carried out on the first argument only.
  • alphabetic : Tells Maxima to recognize all characters in a_i (which must be a string) as alphabetic characters.
  • antisymmetric, commutative, symmetric : Tells Maxima to recognize a_i as a symmetric or antisymmetric function. commutative is the same as symmetric.
  • bindtest : Tells Maxima to trigger an error when a_i is evaluated unbound.
  • constant : Tells Maxima to consider a_i a symbolic constant.
  • even, odd : Tells Maxima to recognize a_i as an even or odd integer variable.
  • evenfun, oddfun : Tells Maxima to recognize a_i as an odd or even function.
  • evflag : Makes a_i known to the ev function so that a_i is bound to true during the execution of ev when a_i appears as a flag argument of ev. See evflag.
  • evfun : Makes a_i known to ev so that the function named by a_i is applied when a_i appears as a flag argument of ev. See evfun.
  • feature : Tells Maxima to recognize a_i as the name of a feature. Other atoms may then be declared to have the a_i property.
  • increasing, decreasing : Tells Maxima to recognize a_i as an increasing or decreasing function.
  • integer, noninteger : Tells Maxima to recognize a_i as an integer or noninteger variable.
  • integervalued : Tells Maxima to recognize a_i as an integer-valued function.
  • lassociative, rassociative : Tells Maxima to recognize a_i as a right-associative or left-associative function.
  • linear : Equivalent to declaring a_i both outative and additive.
  • mainvar : Tells Maxima to consider a_i a "main variable". A main variable succeeds all other constants and variables in the canonical ordering of Maxima expressions, as determined by ordergreatp.
  • multiplicative : Tells Maxima to simplify a_i expressions by the substitution a_i(x * y * z * ...) --> a_i(x) * a_i(y) * a_i(z) * .... The substitution is carried out on the first argument only.
  • nary : Tells Maxima to recognize a_i as an n-ary function. The nary declaration is not the same as calling the nary function. The sole effect of declare(foo, nary) is to instruct the Maxima simplifier to flatten nested expressions, for example, to simplify foo(x, foo(y, z)) to foo(x, y, z).
  • nonarray : Tells Maxima to consider a_i not an array. This declaration prevents multiple evaluation of a subscripted variable name.
  • nonscalar : Tells Maxima to consider a_i a nonscalar variable. The usual application is to declare a variable as a symbolic vector or matrix.
  • noun : Tells Maxima to parse a_i as a noun. The effect of this is to replace instances of a_i with 'a_i or nounify(a_i), depending on the context.
  • outative : Tells Maxima to simplify a_i expressions by pulling constant factors out of the first argument. When a_i has one argument, a factor is considered constant if it is a literal or declared constant. When a_i has two or more arguments, a factor is considered constant if the second argument is a symbol and the factor is free of the second argument.
  • posfun : Tells Maxima to recognize a_i as a positive function.
  • rational, irrational : Tells Maxima to recognize a_i as a rational or irrational real variable.
  • real, imaginary, complex : Tells Maxima to recognize a_i as a real, pure imaginary, or complex variable.
  • scalar : Tells Maxima to consider a_i a scalar variable.

Declare tells:

  • evenp()
  • oddp()
  • integerp()
  • and so on

what to return.

COmpare with:

  • mode_decalre



(%i1) load(to_poly);
(%o1)  home/a/maxima/share/to_poly_solve/to_poly.lisp
(%i2) r;
(%o2) r 
(%i3) isreal_p(r);
(%o3) true     /*  When I use unspecified variables, Maxima seems to assume that they are real */ 
(%i4) z:x+y*%i;
(%o4) %i y + x
(%i5) isreal_p(z);
(%o5) isreal_p(%i y) /* maxima can't check if it is real or not */
(%i6) isreal_p(x);
(%o6) true
(%i7) isreal_p(y);
(%o7) true
(%i8) complex_number_p(z); 
(%o8) false 
(%i9) declare(z, complex);
(%o9) done
(%i10) complex_number_p(z);
(%o10)   false /* still not complex */                                                                                                              true

Number types[edit]

binary numbers[edit]

(%i1) ibase;
(%o1) 10
(%i2) obase;
(%o2) 10
(%i3) ibase:2;
(%o3) 2
(%i4) x=1001110;
(%o4) x=78

Complex numbers[edit]


Principial value of argument of complex number in turns carg produces results in the range (-pi, pi] . It can be mapped to [0, 2*pi) by adding 2*pi to the negative values

 t:carg(z)/(2*%pi),  /* now in turns */
 if t<0 then t:t+1, /* map from (-1/2,1/2] to [0, 1) */

On can order list of complex points according to it's argument :

l2_ordered: sort(l2, lambda([z1,z2], is(carg(z1) < carg(z2))))$

Predicate functions[edit]

(%i1) is(0=0.0);
(%o1) false

Compare :

(%i1) a:0.0$
(%o2) true

List of predicate functions ( see p at the end ) :

  • abasep
  • alphacharp
  • alphanumericp
  • atom
  • bfloatp
  • blockmatrixp
  • cequal
  • cequalignore
  • cgreaterp
  • cgreaterpignore
  • charp
  • clessp
  • clesspignore
  • complex_number_p from to_poly package
  • constantp
  • constituent
  • diagmatrixp
  • digitcharp
  • disjointp
  • elementp
  • emptyp
  • evenp
  • featurep
  • floatnump ( compare : isreal_p)
  • if
  • integerp
  • intervalp
  • is
  • isreal_p from to_poly package
  • lcharp
  • listp
  • listp
  • lowercasep
  • mapatom
  • matrixp
  • matrixp
  • maybe
  • member
  • nonnegintegerp
  • nonscalarp
  • numberp
  • oddp
  • operatorp
  • ordergreatp
  • orderlessp
  • picture_equalp
  • picturep
  • poly_depends_p
  • poly_grobner_subsetp
  • polynomialp
  • prederror
  • primep
  • ratnump
  • ratp
  • scalarp
  • sequal
  • sequalignore
  • setequalp
  • setp
  • stringp
  • subsetp
  • subvarp
  • symbolp
  • symmetricp
  • taylorp
  • unknown
  • uppercasep
  • zeroequiv
  • zeromatrixp
  • zn_primroot_p

See also :

  • declare[9]
    • property:
      • rational, irrational, real, imaginary, complex,
      • even, odd,
      • decreasing, increasing
      • evenfun, oddfun

Number Theory[edit]

There are functions and operators useful with integer numbers

Elementary number theory[edit]

In Maxima there are some elementary functions like the factorial n! and the double factorial n!! defined as where is the greatest integer less than or equal to


Some of the most important functions for integer numbers have to do with divisibility:

gcd, ifactor, mod, divisors... 

all of them well documented in help. you can view it with the '?' command.

Function ifactors takes positive integer and returns a list of pairs : prime factor and its exponent. For example :


It means that :

Other Functions[edit]

Continuus fractions :

(%i6) cfdisrep([1,1,1,1]);
(%o6) 1+1/(1+1/(1+1/1))
(%i7) float(%), numer;
(%o7) 1.666666666666667



For mathematical functions use always


instead of


There is only one small difference between them:

"The function definition operator. f(x_1, ..., x_n) := expr defines a function named f with arguments x_1, …, x_n and function body expr. := never evaluates the function body (unless explicitly evaluated by quote-quote )."

"Defines a function named f with arguments x_1, …, x_n and function body expr. define always evaluates its second argument (unless explicitly quoted). "[10]


"return doesn't mean the same thing in Maxima as it does in other programming languages. It means only to return a value from a block; that's not enough for what you need here." Rbert Dodier[11]


  • "The modedeclare statement is important for compiled code
  • Compiling can greatly speed numerical code; for mostly symbolic code, the speed up is not great.
  • There are some differences between compiled and uncompiled code -- be careful." Barton Willis[12]


"mode_declare tells the compiler that the compiled code needs not to be generic enough to be able to deal with all kind of objects. If your function only takes floats, but no symbolic arguments the compiled code might run much faster." Gunter Königsmann



Start Maxima and type the command:[13]


this will tell you the directory that is being used as your user directory.


  • is a system variable
  • Default value: []
  • is a list of the names of all of the information lists in Maxima. These are
    • labels : All bound %i, %o, and %t labels.
    • values : All bound atoms which are user variables, not Maxima options or switches, created by : or :: or functional binding.
    • functions : All user-defined functions, created by := or define.
    • arrays : All declared and undeclared arrays, created by :, ::, or :=.
    • macros : All user-defined macro functions, created by ::=.
    • myoptions : All options ever reset by the user (whether or not they are later reset to their default values).
    • rules : All user-defined pattern matching and simplification rules, created by tellsimp, tellsimpafter, defmatch, or defrule.
    • aliases : All atoms which have a user-defined alias, created by the alias, ordergreat, orderless functions or by declaring the atom as a noun with declare.
    • dependencies : All atoms which have functional dependencies, created by the depends, dependencies, or gradef functions.
    • gradefs : All functions which have user-defined derivatives, created by the gradef function.
    • props : All atoms which have any property other than those mentioned above, such as properties established by atvalue or matchdeclare, etc., as well as properties established in the declare function.
    • let_rule_packages : All user-defined let rule packages plus the special package default_let_rule_package. (default_let_rule_package is the name of the rule package used when one is not explicitly set by the user.)


reset : resets many (global) system variables



example output :

 (%o1) [_, __, load_pathname, labels, %, linenum, ratprint, tr-unique, 
                                                     lispdisp, multiplicities]


In Maxima :

:lisp (setf *debugger-hook* nil)

manual debuging[edit]

print partial reults using :

  • print
  • playback



  • is a system variable
  • is a list ... which contains the names of currently assigned scalar values which have been set by:
    • the user interactively
    • by packages which have been loaded"[14]
  • initial value is []


dependencies :

  • is a system variable
  • is the list of atoms which have functional dependencies, assigned by:
    • depends
    • the function dependencies
    • gradef


 status (feature);

example output:

(%o34) [sb-bsd-sockets-addrinfo, cl, mk-defsystem, cltl2, 64-bit, 
64-bit-registers, alien-callbacks, ansi-cl, ash-right-vops, 
c-stack-is-control-stack, common-lisp, compare-and-swap-vops, 
complex-float-vops, cycle-counter, elf, float-eql-vops, 
fp-and-pc-standard-save, gencgc, ieee-floating-point, inline-constants, 
integer-eql-vop, interleaved-raw-slots, largefile, linkage-table, linux, 
little-endian, memory-barrier-vops, multiply-high-vops, os-provides-blksize-t, 
os-provides-dladdr, os-provides-dlopen, os-provides-getprotoby-r, 
os-provides-poll, os-provides-putwc, os-provides-suseconds-t, 
package-local-nicknames, precise-arg-count-error, raw-instance-init-vops, 
sb-after-xc-core, sb-core-compression, sb-doc, sb-eval, sb-futex, sb-ldb, 
sb-package-locks, sb-simd-pack, sb-source-locations, sb-test, sb-thread, 
sb-unicode, sb-xref-for-internals, sbcl, stack-allocatable-closures, 
stack-allocatable-fixed-objects, stack-allocatable-lists, 
stack-allocatable-vectors, stack-grows-downward-not-upward, symbol-info-vops, 
unix, unwind-to-frame-and-call-vop, x86-64]

Data structures[edit]

"Maxima's current array/matrix semantics are a mess, I must say, with at least four different kinds of object (hasharrays, explicit lists, explicit matrices, Lisp arrays) supporting subscripting with varying semantics. " [15]

"Maxima's concept of arrays, lists, and matrices is pretty confused, since various ideas have accreted in the many years of the project... Yes, this is a mess. Sorry about that. These are all interesting ideas, but there is no unifying framework. " [16]


Maxima has two array types :[17]

  • Undeclared arrays ( implemented as Lisp hash tables )
  • Declared arrays ( implemented as Lisp arrays )
    • created by the array function
    • created by the make_array function.

Category: Arrays :

  • array
  • arrayapply
  • arrayinfo
  • arraymake
  • arrays - global variable
  • fillarray
  • listarray
  • make_array
  • rearray
  • remarray
  • subvar
  • use_fast_arrays

See also :

  • array functions defined by := and define.

Undeclared array[edit]

Assignment creates an undeclared array.

(%i1) c[99] : 789;
(%o1)                          789
(%i2) c[99];
(%o2)                          789
(%i3) c;
(%o3)                           c
(%i4) arrayinfo (c);
(%o4)                   [hashed, 1, [99]]
(%i5) listarray (c);
(%o5)                         [789]

"If the user assigns to a subscripted variable before declaring the corresponding array, an undeclared array is created. Undeclared arrays, otherwise known as hashed arrays (because hash coding is done on the subscripts), are more general than declared arrays. The user does not declare their maximum size, and they grow dynamically by hashing as more elements are assigned values. The subscripts of undeclared arrays need not even be numbers. However, unless an array is rather sparse, it is probably more efficient to declare it when possible than to leave it undeclared. " ( from Maxima CAS doc)

"created if one does :


(and b is not already an array, a list, or a matrix - if it were one of these an error would be caused since x+1 would not be a valid subscript for an art-q array, a list or a matrix).

Its indices (also known as keys) may be any object. It only takes one key at a time (b[x+1,u]:y would ignore the u). Referencing is done by b[x+1] ==> y^2. Of course the key may be a list, e.g.


would be valid. "( from Maxima CAS doc)

Declared array[edit]

  • declare array ( give a name and allocate memmory)
  • fill array
  • process array

array function[edit]

Function: array (name, type, dim_1, …, dim_n)

Creates an n-dimensional array. Here :

  • type can be fixnum for integers of limited size or flonum for floating-point numbers
  • n may be less than or equal to 5. The subscripts for the i'th dimension are the integers running from 0 to dim_i.
(%i5) array(A,2,2);
(%o5)                                  A
(%i8) arrayinfo(A);
(%o8)                      [declared, 2, [2,2]]

Because subscripts of array A elements are goes from 0 to dim so array A has :

( dim_1 + 1) * (dim_2 + 1) = 3*3 = 9 


The array function can be used to transform an undeclared array into a declared array.

arraymake function[edit]

Function: arraymake (A, [i_1, …, i_n])

The result is an unevaluated array reference.

(%i12) arraymake(A,[3,3,3]);
(%o12)                    array_make(3, 3, 3)
                                           3, 3, 3
(%i13) arrayinfo(A);
       arrayinfo: A is not an array.

Function: make_array[edit]

Function: make_array (type, dim_1, …, dim_n)

Creates and returns a Lisp array.

Type may be :

  • any
  • flonum
  • fixnum
  • hashed
  • functional.

There are n indices, and the i'th index runs from 0 to dim_i - 1.

The advantage of make_array over array is that the return value doesn't have a name, and once a pointer to it goes away, it will also go away. For example, if y: make_array (...) then y points to an object which takes up space, but after y: false, y no longer points to that object, so the object can be garbage collected.


(%i9) A : array_make(3,3,3);
(%o9)                         array_make(3, 3, 3)
(%i10) arrayinfo(A);
(%o10)                     [declared, 3, [3, 3, 3]]


Assignment to an element of a list.

(%i1) b : [1, 2, 3];
(%o1)                       [1, 2, 3]
(%i2) b[3] : 456;
(%o2)                          456
(%i3) b;
(%o3)                      [1, 2, 456]

(%i1) mylist : [[a,b],[c,d]];
(%o1) [[a, b], [c, d]]

Intresting examples by Burkhard Bunk : [18]

lst: [el1, el2, ...];         contruct list explicitly
lst[2];                       reference to element by index starting from 1
cons(expr, alist);            prepend expr to alist
endcons(expr, alist);         append expr to alist
append(list1, list2, ..);     merge lists
makelist(expr, i, i1, i2);    create list with control variable i
makelist(expr, x, xlist);     create list with x from another list     
length(alist);                returns #elements
map(fct, list);               evaluate a function of one argument
map(fct, list1, list2);       evaluate a function of two arguments

Category: Lists :

  • [
  • ]
  • append
  • assoc
  • cons
  • copylist
  • create_list
  • delete
  • eighth
  • endcons
  • fifth
  • first
  • flatten
  • fourth
  • fullsetify
  • join
  • last
  • length
  • listarith
  • listp
  • lmax
  • lmin
  • lreduce
  • makelist
  • member
  • ninth
  • permut
  • permutations
  • pop
  • push
  • random_permutation
  • rest
  • reverse
  • rreduce
  • second
  • setify
  • seventh
  • sixth
  • some
  • sort
  • sublist
  • sublist_indices
  • tenth
  • third
  • tree_reduce
  • xreduce


"In Maxima, a matrix is implemented as a nested list (namely a list of rows of the matrix)". E.g. :[19]

(($MATRIX) ((MLIST) 1 2 3) ((MLIST) 4 5 6))

Construction of matrices from nested lists :

(%i3) M:matrix([1,2,3],[4,5,6],[0,-1,-2]);
                                [ 1   2    3  ]
                                [             ]
(%o3)                           [ 4   5    6  ]
                                [             ]
                                [ 0  - 1  - 2 ]

Intresting examples by Burkhard Bunk : [20]

A: matrix([a, b, c], [d, e, f], [g, h, i]);     /* (3x3) matrix */
u: matrix([x, y, z]);                           /* row vector */
v: transpose(matrix([r, s, t]));                /* column vector */

Reference to elements etc:

u[1,2];                 /* second element of u */
v[2,1];                 /* second element of v */
A[2,3];   or  A[2][3];  /* (2,3) element */
A[2];                         /* second row of A */
transpose(transpose(A)[2]);   /* second column of A */

Element by element operations:

A + B;     
A - B;
A * B;      
A / B;
A ^ s;      
s ^ A;

Matrix operations :

A . B;                  /* matrix multiplication */
A ^^ s;                 /* matrix exponentiation (including inverse) */

Category: Matrices :[21]

  • addcol
  • addrow
  • adjoint
  • augcoefmatrix
  • cauchy_matrix
  • charpoly
  • coefmatrix
  • col
  • columnvector
  • covect
  • copymatrix
  • determinant
  • detout
  • diag
  • diagmatrix
  • doallmxops
  • domxexpt
  • domxmxops
  • domxnctimes
  • doscmxops
  • doscmxplus
  • echelon
  • eigen
  • ematrix
  • entermatrix
  • genmatrix
  • ident
  • invert
  • list_matrix_entries
  • lmxchar
  • matrix
  • matrix_element_add
  • matrix_element_mult
  • matrix_element_transpose
  • matrixmap
  • matrixp
  • mattrace
  • minor
  • ncharpoly
  • newdet
  • nonscalar
  • nonscalarp
  • permanent
  • rank
  • ratmx
  • row
  • scalarmatrixp
  • scalarp
  • setelmx
  • sparse
  • submatrix
  • tracematrix
  • transpose
  • triangularize
  • zeromatrix

Function: matrix[edit]

Function: matrix (row_1, …, row_n)

Returns a rectangular matrix which has the rows row_1, …, row_n. Each row is a list of expressions. All rows must be the same length.

. operator[edit]

"The dot operator, for matrix (non-commutative) multiplication. When "." is used in this way, spaces should be left on both sides of it, e.g.

A . B

This distinguishes it plainly from a decimal point in a floating point number.

The operator . represents noncommutative multiplication and scalar product. When the operands are 1-column or 1-row matrices a and b, the expression a.b is equivalent to sum (a[i]*b[i], i, 1, length(a)). If a and b are not complex, this is the scalar product, also called the inner product or dot product, of a and b. The scalar product is defined as conjugate(a).b when a and b are complex; innerproduct in the eigen package provides the complex scalar product.

When the operands are more general matrices, the product is the matrix product a and b. The number of rows of b must equal the number of columns of a, and the result has number of rows equal to the number of rows of a and number of columns equal to the number of columns of b.

To distinguish . as an arithmetic operator from the decimal point in a floating point number, it may be necessary to leave spaces on either side. For example, 5.e3 is 5000.0 but 5 . e3 is 5 times e3.

There are several flags which govern the simplification of expressions involving ., namely dot0nscsimp, dot0simp, dot1simp, dotassoc, dotconstrules, dotdistrib, dotexptsimp, dotident, and dotscrules." ( from Maxima CAS doc)


Category: Vectors :

  • Vectors
  • eigen
  • express
  • nonscalar
  • nonscalarp
  • scalarp

Category: Package vect[22]

  • vect
  • scalefactors
  • vect_cross
  • vectorpotential
  • vectorsimp

Numerical methods[edit]

Newton method[edit]


  • newton for equation with function of one variable
  • mnewton is an implementation of Newton's method for solving nonlinear equations in one or more variables.


load :

(%o1)                                                                                                   /home/a/maxima/share/numeric/newton.mac
(%i2) load("newton1");
(%o2)                                                                                                   /home/a/maxima/share/numeric/newton1.mac

Code :

Maxima CAS code 
from /maxima/share/numeric/newton1.mac 
input : 
 exp  =  function of one variable, x
 var = variable 
 x0 = inital value of variable
 eps = 

The search begins with x = x_0 and proceeds until abs(expr) < eps (with expr evaluated at the current value of x). 

output : xn = an approximate solution of expr = 0 by Newton's method

    if abs(subst(xn,var,exp))<eps 
         then return(xn),


Boundaries of Components of Mandelbrot set by Newton method. Image and Maxima CAS code

One can use Newton method for solving systems of multiple nonlinear functions. It is implemented in mnewton function. See directory :


which uses linsolve_by_lu defined in :


See this image for more code.

(%i1) load("mnewton")$

(%i2) mnewton([x1+3*log(x1)-x2^2, 2*x1^2-x1*x2-5*x1+1],
              [x1, x2], [5, 5]);
(%o2) [[x1 = 3.756834008012769, x2 = 2.779849592817897]]
(%i3) mnewton([2*a^a-5],[a],[1]);
(%o3)             [[a = 1.70927556786144]]
(%i4) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
(%o4) [[u = 1.066618389595407, v = 1.552564766841786]]


Stack ( LIFO)[edit]

Stack implementation using list:

/* create stack */
/* push on stack */
  stack:delete(last(stack),stack), /* pop from stack */
  disp(stack), /* display */
  if is(not emptyp(stack)) then go(loop)


Complex Functions=[edit]

  • Visualizing Complex Functions with Conformal Mapping ( themaximalist ) [23]

Topologist's sine curve[edit]

plot2d (sin(1/x), [x, 0, 1])$

Topologist's comb :

Topologist's comb
load(draw); /* by Mario Rodríguez Riotorto  */

 title     = "Topologist\\47s comb", /* Syntax for postscript enhanced option; character 47 = '  */
 xrange        = [0.0,1.2],
 yrange        = [0,1.2],
 file_name = "comb2",
 terminal      = svg,
 points_joined = impulses, /* vertical segments are drawn from points to the x-axis  */
 color         = "blue",
 points(makelist(1/x,x,1,1000),makelist(1,y,1,1000)) )$

Output, warnings[edit]

  • ratprint : false; /* remove "rat :replaced " */
  • using $ instead of ; at the end of the line ( not inside function where , ends the line )
  • return from the function
  • "warning: encountered undefined variable ... in translation." This is warning from compile when function uses global variable without using in in tha arguments list. You have to include the variables in the function's list

Example programs[edit]

  • Iteration of complex numbers, stack and drawing a list of points
Julia set using IIM
  • Iteration of complex numbers, comparing complex numbers, finding period of cycle
critical orbit with 3-period cycle
  • Drawing Julia set and critical orbit. Computing period
Drawing Julia set and critical orbit. Computing period
  • drawing curves in 2D plane
Mandelbrot lemniscates-image and source
  • drawing points
Drawing 2D points. Image and source code

See also[edit]


  1. Stackexchange : What are well-known weaknesses of CAS/math software?
  2. R Fateman : Branch Cuts in Computer Algebra,
  3. compiled deb packages for Maxima 5.20.1-1 by Istvan Blahota
  4. help from ubuntu community about Maxima
  5. How to build your own Maxima package by Andras Somogyi
  6. Install from Ubuntu repositories by Mario Rodriguez Riotorto
  7. launchpad : blahota wxmaxima
  8. How to build Maxima by Rupert Swarbrick
  9. maxima manual : Category Declarations-and-inferences
  10. Discussion at Maxima interest list
  11. stackoverflow question : difference-between-throw-return-and-break-in-maxima
  12. maxima-discuss : compiling-files-written-in-maxima
  13. [Maxima] Phantastic Program! One bug - discussion
  14. Maxima by Example: Ch. 1, Introduction to Maxima ∗ Edwin L. Woollett August 11, 2009
  15. Maxima: Syntax improvements by Stavros Macrakis
  16. Maxima: what does Maxima call an “array”? - answer by Robert Dodier
  17. the Maxima mailing list : [Maxima] array and matrix? - answer by Robert Dodier
  18. Maxima Overview by Burkhard Bunk
  19. the Maxima mailing list : [Maxima] array and matrix? - answer by Robert Dodier
  20. Maxima Overview by Burkhard Bunk
  21. maxima manual : Category Matrices
  22. maxima manual : Package vect
  23. themaximalist visualizing-complex-functions-by-their-images-over-concentric-circles

Chaotic dynamics with Maxima A. Morante and J. A. Vallejo