Man Linux: Main Page and Category List


       Maxima  -  Common  Lisp version of MACSYMA symbolic mathematics package
       released under the GNU Public License

       Xmaxima - A graphical version of Maxima


       maxima [options]

       xmaxima [options]


       Maxima is a version of the MIT-developed MACSYMA  system,  modified  to
       run  under  Common  Lisp.   It  is  an  interactive  expert  system and
       programming  environment  for  symbolic  and   numerical   mathematical
       manipulation.  Written in Lisp, it allows differentiation, integration,
       solution of linear or polynomial equations, factoring  of  polynomials,
       expansion  of  functions  in  Laurent  or Taylor series, computation of
       Poisson series, matrix and tensor manipulations, and  two-  and  three-
       dimensional  graphics.   Procedures  may be written using an ALGOL-like
       syntax, and both Lisp-like functions and  pattern  matching  facilities
       are  provided.   Files  containing  Maxima objects may be read from and
       written to disk files. Pre-written Maxima commands may be read  from  a
       file and executed, allowing batch-mode use.


       -b file, --batch=file
              Process file in noninteractive mode.

              Process Lisp file file in noninteractive mode.

              Process string in noninteractive mode.

       -d, --directories
              Display Maxima directory information.

              Disable readline support.

       -g, --enable-lisp-debugger
              Enable Lisp debugger.

       -h, --help
              Display a brief usage summary.

              Load  the  Maxima  and  Lisp initialization files string.mac and
              string.lisp at startup.

              Load the Maxima initialization file file at startup.

              Load the Lisp initialization file file at startup.

       -l lisp, --lisp=lisp
              Use Lisp implementation lisp. Use --list-avail to see  the  list
              of possible values.

              List the available Lisp and Maxima versions.

       -p lisp_file, --preload-lisp=lisp_file
              Preload lisp_file.

       -q, --quiet
              Suppress Maxima start-up message.

       -r string, --run-string=string
              Process string in interactive mode.

       -s port, --server=port
              Connect  Maxima  to  server  on  port.   Note that this does not
              create a Maxima server; Maxima is the client.

       -u version, --use-version=version
              Launch Maxima version version. Use --list-avail to see the  list
              of possible values.

              Use  directory  for  user directory (default is $HOME/maxima for
              Windows, $HOME/.maxima for others)

       -v, --verbose
              Print extra information from the Maxima wrapper script.

              Print the (default) installed version.

              Suppress expression labels and the Maxima start-up message.

       -X Lisp options, --lisp-options=Lisp options
              Options to be given to the underlying Lisp.


       Upon initialization, maxima prints a startup message,  then  a  command
       line prompt:


       All Maxima commands must be concluded with either:

       1)     a  semicolon  (in which case the result of the command is echoed
              on a display line, prefaced by  %o  with  an  appended  sequence
              number), or

       2)     a dollar sign (which suppresses printing of a display line).


       (%i1) diff(sin(x),x);

       (%o1)                         cos(x)

       (%i2) integrate(%o1,x);

       (%o2)                         sin(x)

       The  user  types  in  commands  which  create  Maxima  objects (such as
       functions and system variables) and which manipulate these objects.

       On UNIX it may be preferable to run Maxima under Gnu Emacs  or  XEmacs.
       You  can  do  this  by  invoking shell mode in emacs, and then invoking
       maxima.  Preferably, install maxima.el from the  distribution  and  use
       the command:

              M-x maxima

       The  main  advantage  of  working  inside  emacs  is that it provides a
       complete history of input/output.  If you execute the command

              display2d: false

       you will be able to use your output as input,  by  simply  killing  and

       Lisp  is  built  into  Maxima.   The function to_lisp() enters the Lisp
       read-eval-print loop. The Lisp function (run) may be used to return  to
       Maxima.  Alternatively, single Lisp commands may be invoked by starting
       a command line with :lisp.


       The reference manual can be accessed from the Maxima input  prompt.   A
       description of a given command can be obtained by typing the command


       or, simply,

        ? command

       searches  the  list of functions for the string command.  Demonstration
       files provide complete examples of problems solved with Maxima, and may
       be  accessed  with  the  command  demo(command);.   A  library of user-
       contributed  command  files  is  also  provided  (the  share  library),
       directed toward a variety of problems.


       The reference manual is provided in both info and html formats.


       This  list  includes only commands which the beginner might find useful
       to know about prior to studying the reference manual and other texts.

              Execute the contents of file myfile, which is assumed to contain
              Maxima commands.

              Close session file opened by a writefile command (see below).

              Execute the contents of file myfile, which is assumed to contain
              Maxima commands, one line at a time.

              Print the contents of all of the available information lists.

              Print a list of the names of currently defined functions.

              Print a list of the various available information lists.

              Eliminate the object(s) contained within parentheses;  kill(all)
              Delete  all objects created by the user, restoring Maxima to its
              initial state.

              Leave Maxima.

              Reset all Maxima control parameters to their default states.

              Print a list of the names of currently assigned scalar values.

              Write record of session to file myfile; only one file at a  time
              can  be open, and the closefile command must be invoked prior to
              leaving Maxima to flush the buffer.


       Maxima is capable of producing 2- and 3-dimensional plots.  Here  is  a
       simple 2-dimensional example

       plot2d (sin(x), [x, -2*%pi, 2*%pi]);

       and a simple 3-dimensional example

       plot3d (2^(-u^2 + v^2), [u, -5, 5], [v, -7, 7]);

       By  default  plots are made by the gnuplot plotting package.  Plots can
       be made by other means; see "?  plot_options".   For  more  information
       about plotting, see "? plot".


                 Compiled files for lisp implementation lisp

       /usr/info primary  documentation directory, containing info files which
                 are used for the ’describe’ command,  and  also  for  viewing
                 under emacs or other info viewer.

                 HTML version of info documentation.

                 Maxima demo files.

                 Elisp files for use with Emacs or XEmacs.

                 Contributed external packages.

                 Documentation for contributed external packages.

                 Complete Maxima source.

                 Test suite.

                 Xmaxima support files.

                 Maxima utility scripts.


              Points  to  a  directory  for user customization files. Maxima’s
              default search  paths  include  MAXIMA_USERDIR.  Default  value:

              Maxima  looks for its input files in the directory configured at
              compile time, /usr. Maxima  can  be  relocated  to  a  different
              directory  as  long  as  the  maxima  script  maintains the same
              relative position with respect to the Maxima  input  files.  If,
              for  some  reason,  the  maxima  script  needs  to  be relocated
              independently, MAXIMA_PREFIX needs to be set to point to the top
              of the tree holding the input files.

              MAXIMA_DIRECTORY  is equivalent to MAXIMA_PREFIX. It is included
              only for backward compatibility with older versions of Maxima.

       Maxima uses  several  other  environment  variables  for  communication
       between  the maxima script and the lisp image. All such variables start
       with MAXIMA_. They should not need to be modified by the user.


              maximarc is sourced by the maxima script at startup.  It  should
              be located in $MAXIMA_USERDIR (see above). maximarc can be used,
              e.g., to change the user’s default lisp implementation choice to
              CMUCL by including the line "MAXIMA_LISP=cmucl".

              At  startup,  Maxima will load the lisp file maxima-init.lisp if
              it is found in the search path. For user customization,  maxima-
              init.lisp  should  be placed in the $MAXIMA_USERDIR (see above).
              Since Maxima typically has  a  system  maxima-init.lisp  in  the
              Maxima  share  directory, the user may want to copy the contents
              of  the  system  maxima-init.lisp  into  his/her  custom   file.
              Alternatively, the user can load a Lisp initialization file with
              another name or location by means of the --init-lisp  or  --init
              command-line options.

              At  startup,  Maxima will load the file maxima-init.mac if it is
              found in the  search  path.   For  user  customization,  maxima-
              init.mac  should  be  placed in the $MAXIMA_USERDIR (see above).
              Alternatively, the user can load a  Maxima  initialization  file
              with  another  name  or  location  by means of the --init-mac or
              --init command-line options.


       Old Reference: MACSYMA Reference Manual (volumes 1 and 2).  The Mathlab
       Group,  Laboratory  for  Computer  Science,  MIT.  Version 10.  January

       Newer references:


       Maxima is a complex system. It includes both known  and  unknown  bugs.
       Use at your own risk. The Maxima bug database is available at

       New  bug  reports  are always appreciated. Please include the output of
       the Maxima function "build_info()" with the report.


       MACSYMA (Project MAC’s SYmbolic MAnipulation System) was  developed  by
       the   Mathlab   group  of  the  MIT  Laboratory  for  Computer  Science
       (originally known as Project MAC), during the years  1969-1972.   Their
       work  was  supported by grants NSG 1323 of the National Aeronautics and
       Space Administration, N00014-77-C-0641 of the Office of Naval Research,
       ET-78-C-02-4687  of  the U.S. Department of Energy, and F49620-79-C-020
       of the U.S. Air Force.  MACSYMA was further modified for use under  the
       UNIX   operating   system  (for  use  on  DEC  VAX  computers  and  Sun
       workstations), by Richard Fateman and colleagues at the  University  of
       California  at  Berkeley;  this  version of MACSYMA is known as VAXIMA.
       The present version stems from a re-working of the  public  domain  MIT
       MACSYMA  for  GNU Common Lisp, prepared by William Schelter, University
       of Texas at Austin  until  his  passing  away  in  2001.   It  contains
       numerous  additions,  extensions and enhancements of the original.  The
       original version of this manual page was written by R. P.  C.  Rodgers,
       UCSF     School     of    Pharmacy,    San    Francisco,    CA    94143
       ( in 1989. It was extensively revised  by
       James Amundson in 2002.

       Maxima  is  now  developed  and  maintained  by  the  Maxima project at

                              September 10, 2005