File: maxima_5.html

package info (click to toggle)
maxima 5.10.0-6
links: PTS
area: main
in suites: etch, etch-m68k
size: 44,268 kB
ctags: 17,987
sloc: lisp: 152,894; fortran: 14,667; perl: 14,204; tcl: 10,103; sh: 3,376; makefile: 2,202; ansic: 471; awk: 7
file content (2027 lines) | stat: -rw-r--r-- 82,695 bytes
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html401/loose.dtd">
<html>
<!-- Created on September, 20 2006 by texi2html 1.76 -->
<!--
Written by: Lionel Cons <Lionel.Cons@cern.ch> (original author)
            Karl Berry  <karl@freefriends.org>
            Olaf Bachmann <obachman@mathematik.uni-kl.de>
            and many others.
Maintained by: Many creative people <dev@texi2html.cvshome.org>
Send bugs and suggestions to <users@texi2html.cvshome.org>

-->
<head>
<title>Maxima Manual: 5. Operators</title>

<meta name="description" content="Maxima Manual: 5. Operators">
<meta name="keywords" content="Maxima Manual: 5. Operators">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="texi2html 1.76">
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
pre.display {font-family: serif}
pre.format {font-family: serif}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: serif; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: serif; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.sansserif {font-family:sans-serif; font-weight:normal;}
ul.toc {list-style: none}
body
{
    color: black;
    background: white; 
    margin-left: 8%;
    margin-right: 13%;
}

h1
{
    margin-left: +8%;
    font-size: 150%;
    font-family: sans-serif
}

h2
{
    font-size: 125%;
    font-family: sans-serif
}

h3
{
    font-size: 100%;
    font-family: sans-serif
}

h2,h3,h4,h5,h6 { margin-left: +4%; }

div.textbox
{
    border: solid;
    border-width: thin;
    /* width: 100%; */
    padding-top: 1em;
    padding-bottom: 1em;
    padding-left: 2em;
    padding-right: 2em
}

div.titlebox
{
    border: none;
    padding-top: 1em;
    padding-bottom: 1em;
    padding-left: 2em;
    padding-right: 2em;
    background: rgb(200,255,255);
    font-family: sans-serif
}

div.synopsisbox
{
    border: none;
    padding-top: 1em;
    padding-bottom: 1em;
    padding-left: 2em;
    padding-right: 2em;
     background: rgb(255,220,255);
    /*background: rgb(200,255,255); */
    /* font-family: fixed */
}

pre.example
{
    border: none;
    padding-top: 1em;
    padding-bottom: 1em;
    padding-left: 1em;
    padding-right: 1em;
    background: rgb(247,242,180); /* kind of sandy */
    /* background: rgb(200,255,255); */ /* sky blue */
    font-family: "Lucida Console", monospace
}

div.spacerbox
{
    border: none;
    padding-top: 2em;
    padding-bottom: 2em
}

div.image
{
    margin: 0;
    padding: 1em;
    text-align: center;
}
-->
</style>

<link rel="icon" href="http://maxima.sourceforge.net/favicon.ico"/>
</head>

<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">

<a name="Operators"></a>
<a name="SEC14"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="maxima_4.html#SEC13" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC15" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima_4.html#SEC11" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h1 class="chapter"> 5. Operators </h1>

<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top"><a href="#SEC15">5.1 nary</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">                        
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC16">5.2 nofix</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">                       
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC17">5.3 operator</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">                    
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC18">5.4 postfix</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">                     
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC19">5.5 prefix</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">                      
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC20">5.6 Definitions for Operators</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">   
</td></tr>
</table>


<hr size="6">
<a name="nary"></a>
<a name="SEC15"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC14" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC16" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.1 nary </h2>
<p>An <code>nary</code> operator is used to denote a function of any number of
arguments, each of which is separated by an occurrence of the
operator, e.g. A+B or A+B+C.  The <code>nary(&quot;x&quot;)</code> function is a syntax
extension function to declare x to be an <code>nary</code> operator.
Functions may be declared to be
<code>nary</code>.  If <code>declare(j,nary);</code> is done, this tells the simplifier to
simplify, e.g. <code>j(j(a,b),j(c,d))</code> to <code>j(a, b, c, d)</code>.
</p>
<p>See also <code>syntax</code>.
</p>
<hr size="6">
<a name="nofix"></a>
<a name="SEC16"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC15" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC17" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.2 nofix </h2>
<p><code>nofix</code> operators are used to denote functions of no arguments.
The mere presence of such an operator in a command will cause the
corresponding function to be evaluated.  For example, when one types
&quot;exit;&quot; to exit from a Maxima break, &quot;exit&quot; is behaving similar to a
<code>nofix</code> operator.  The function <code>nofix(&quot;x&quot;)</code> is a syntax extension
function which declares x to be a <code>nofix</code> operator. 
</p>
<p>See also <code>syntax</code>.
</p>
<hr size="6">
<a name="operator"></a>
<a name="SEC17"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC16" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC18" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.3 operator </h2>
<p>See <code>operators</code>.
</p>
<hr size="6">
<a name="postfix"></a>
<a name="SEC18"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC17" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC19" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.4 postfix </h2>
<p><code>postfix</code> operators like the <code>prefix</code> variety denote functions
of a single argument, but in this case the argument immediately
precedes an occurrence of the operator in the input string, e.g. 3! .
The <code>postfix(&quot;x&quot;)</code> function is a syntax extension function to declare x
to be a <code>postfix</code> operator.
</p>
<p>See also <code>syntax</code>.
</p>
<hr size="6">
<a name="prefix"></a>
<a name="SEC19"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC18" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC20" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.5 prefix </h2>
<p>A <code>prefix</code> operator is one which signifies a function of one
argument, which argument immediately follows an occurrence of the
operator.  <code>prefix(&quot;x&quot;)</code> is a syntax extension function to declare x to
be a <code>prefix</code> operator.
</p>
<p>See also <code>syntax</code>.
</p>
<hr size="6">
<a name="Definitions-for-Operators"></a>
<a name="SEC20"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC19" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC14" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<h2 class="section"> 5.6 Definitions for Operators </h2>

<dl>
<dt><u>Operator:</u> <b>!</b>
<a name="IDX54"></a>
</dt>
<dd><p>The factorial operator.
For any complex number <code>x</code> (including integer, rational, and real numbers) except for
negative integers, <code>x!</code> is defined as <code>gamma(x+1)</code>.
</p>
<p>For an integer <code>x</code>, <code>x!</code> simplifies to the product of the integers from 1 to <code>x</code> inclusive.
<code>0!</code> simplifies to 1.
For a floating point number <code>x</code>, <code>x!</code> simplifies to the value of <code>gamma (x+1)</code>.
For <code>x</code> equal to <code>n/2</code> where <code>n</code> is an odd integer,
<code>x!</code> simplifies to a rational factor times <code>sqrt (%pi)</code>
(since <code>gamma (1/2)</code> is equal to <code>sqrt (%pi)</code>).
If <code>x</code> is anything else,
<code>x!</code> is not simplified.
</p>
<p>The variables
<code>factlim</code>, <code>minfactorial</code>, and <code>factcomb</code> control the simplification
of expressions containing factorials.
</p>
<p>The functions <code>gamma</code>, <code>bffac</code>, and <code>cbffac</code>
are varieties of the gamma function.
<code>makegamma</code> substitutes <code>gamma</code> for factorials and related functions.
</p>
<p>See also <code>binomial</code>.
</p>
<p>The factorial of an integer, half-integer, or floating point argument is simplified
unless the operand is greater than <code>factlim</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) factlim : 10;
(%o1)                          10
(%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
            105 sqrt(%pi)
(%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
                 16
</pre></td></tr></table>
<p>The factorial of a complex number, known constant, or general expression is not simplified.
Even so it may be possible simplify the factorial after evaluating the operand.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
(%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
(%i2) ev (%, numer, %enumer);
(%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357, 
                                               1.227580202486819]
</pre></td></tr></table>
<p>The factorial of an unbound symbol is not simplified.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) kill (foo);
(%o1)                         done
(%i2) foo!;
(%o2)                         foo!
</pre></td></tr></table>
<p>Factorials are simplified, not evaluated.
Thus <code>x!</code> may be replaced even in a quoted expression.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
          105 sqrt(%pi)
(%o1) [1, -------------, 81.44668037931199, 40320, 
               16
                                             2432902008176640000]
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>!!</b>
<a name="IDX55"></a>
</dt>
<dd><p>The double factorial operator.
</p>
<p>For an integer, float, or rational number <code>n</code>,
<code>n!!</code> evaluates to the product <code>n (n-2) (n-4) (n-6) ... (n - 2 (k-1))</code>
where <code>k</code> is equal to <code>entier (n/2)</code>,
that is, the largest integer less than or equal to <code>n/2</code>.
Note that this definition does not coincide with other published definitions
for arguments which are not integers.
</p>
<p>For an even (or odd) integer <code>n</code>, <code>n!!</code> evaluates to the product of
all the consecutive even (or odd) integers from 2 (or 1) through <code>n</code> inclusive.
</p>
<p>For an argument <code>n</code> which is not an integer, float, or rational,
<code>n!!</code> yields a noun form <code>genfact (n, n/2, 2)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>#</b>
<a name="IDX56"></a>
</dt>
<dd><p>Represents the negation of syntactic equality <code>=</code>.
</p>
<p>Note that because of the rules for evaluation of predicate expressions
(in particular because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>),
<code>not <var>a</var> = <var>b</var></code> is equivalent to <code>is(<var>a</var> # <var>b</var>)</code>,
instead of <code><var>a</var> # <var>b</var></code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) a = b;
(%o1)                         a = b
(%i2) is (a = b);
(%o2)                         false
(%i3) a # b;
(%o3)                         a # b
(%i4) not a = b;
(%o4)                         true
(%i5) is (a # b);
(%o5)                         true
(%i6) is (not a = b);
(%o6)                         true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>.</b>
<a name="IDX57"></a>
</dt>
<dd><p>The dot operator, for matrix (non-commutative) multiplication.
When &quot;.&quot; 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.
</p>
<p>See also
<code>dot</code>,
<code>dot0nscsimp</code>,
<code>dot0simp</code>,
<code>dot1simp</code>,
<code>dotassoc</code>,
<code>dotconstrules</code>,
<code>dotdistrib</code>,
<code>dotexptsimp</code>,
<code>dotident</code>,
and
<code>dotscrules</code>.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>:</b>
<a name="IDX58"></a>
</dt>
<dd><p>The assignment operator.  E.g. A:3 sets the variable A to 3.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>::</b>
<a name="IDX59"></a>
</dt>
<dd><p>Assignment operator.  :: assigns the value of the expression
on its right to the value of the quantity on its left, which must
evaluate to an atomic variable or subscripted variable.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>::=</b>
<a name="IDX60"></a>
</dt>
<dd><p>Macro function definition operator.
<code>::=</code> defines a function (called a &quot;macro&quot; for historical reasons)
which quotes its arguments,
and the expression which it returns (called the &quot;macro expansion&quot;)
is evaluated in the context from which the macro was called.
A macro function is otherwise the same as an ordinary function.
</p>
<p><code>macroexpand</code> returns a macro expansion (without evaluating it).
<code>macroexpand (foo (x))</code> followed by <code>''%</code> is equivalent to <code>foo (x)</code>
when <code>foo</code> is a macro function.
</p>
<p><code>::=</code> puts the name of the new macro function onto the global list <code>macros</code>.
<code>kill</code>, <code>remove</code>, and <code>remfunction</code> unbind macro function definitions
and remove names from <code>macros</code>.
</p>
<p><code>fundef</code> or <code>dispfun</code> return a macro function definition
or assign it to a label, respectively.
</p>
<p>Macro functions commonly contain <code>buildq</code> and <code>splice</code>
expressions to construct an expression,
which is then evaluated.
</p>
<p>Examples
</p>
<p>A macro function quotes its arguments,
so message (1) shows <code>y - z</code>, not the value of <code>y - z</code>.
The macro expansion (the quoted expression <code>'(print (&quot;(2) x is equal to&quot;, x))</code>
is evaluated in the context from which the macro was called,
printing message (2).
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x: %pi;
(%o1)                          %pi
(%i2) y: 1234;
(%o2)                         1234
(%i3) z: 1729 * w;
(%o3)                        1729 w
(%i4) printq1 (x) ::= block (print (&quot;(1) x is equal to&quot;, x), '(print (&quot;(2) x is equal to&quot;, x)));
(%o4) printq1(x) ::= block(print(&quot;(1) x is equal to&quot;, x), 
                                '(print(&quot;(2) x is equal to&quot;, x)))
(%i5) printq1 (y - z);
(1) x is equal to y - z 
(2) x is equal to %pi 
(%o5)                          %pi
</pre></td></tr></table>
<p>An ordinary function evaluates is arguments, so message (1) shows the value of <code>y - z</code>.
The return value is not evaluated, so message (2) is not printed
until the explicit evaluation <code>''%</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x: %pi;
(%o1)                          %pi
(%i2) y: 1234;
(%o2)                         1234
(%i3) z: 1729 * w;
(%o3)                        1729 w
(%i4) printe1 (x) := block (print (&quot;(1) x is equal to&quot;, x), '(print (&quot;(2) x is equal to&quot;, x)));
(%o4) printe1(x) := block(print(&quot;(1) x is equal to&quot;, x), 
                                '(print(&quot;(2) x is equal to&quot;, x)))
(%i5) printe1 (y - z);
(1) x is equal to 1234 - 1729 w 
(%o5)              print((2) x is equal to, x)
(%i6) ''%;
(2) x is equal to %pi 
(%o6)                          %pi
</pre></td></tr></table>
<p><code>macroexpand</code> returns a macro expansion.
<code>macroexpand (foo (x))</code> followed by <code>''%</code> is equivalent to <code>foo (x)</code>
when <code>foo</code> is a macro function.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x: %pi;
(%o1)                          %pi
(%i2) y: 1234;
(%o2)                         1234
(%i3) z: 1729 * w;
(%o3)                        1729 w
(%i4) g (x) ::= buildq ([x], print (&quot;x is equal to&quot;, x));
(%o4)    g(x) ::= buildq([x], print(&quot;x is equal to&quot;, x))
(%i5) macroexpand (g (y - z));
(%o5)              print(x is equal to, y - z)
(%i6) ''%;
x is equal to 1234 - 1729 w 
(%o6)                     1234 - 1729 w
(%i7) g (y - z);
x is equal to 1234 - 1729 w 
(%o7)                     1234 - 1729 w
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>:=</b>
<a name="IDX61"></a>
</dt>
<dd><p>The function definition operator.  E.g. <code>f(x):=sin(x)</code> defines
a function <code>f</code>.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>=</b>
<a name="IDX62"></a>
</dt>
<dd><p>The equation operator.
</p>
<p>An expression <code><var>a</var> = <var>b</var></code>, by itself, represents
an unevaluated equation, which might or might not hold.
Unevaluated equations may appear as arguments to <code>solve</code> and <code>algsys</code>
or some other functions.
</p>
<p>The function <code>is</code> evaluates <code>=</code> to a Boolean value.
<code>is(<var>a</var> = <var>b</var>)</code> evaluates <code><var>a</var> = <var>b</var></code> to <code>true</code> when <var>a</var> and <var>b</var>
are identical. That is, <var>a</var> and <var>b</var> are atoms which are identical,
or they are not atoms and their operators are identical and their arguments are identical.
Otherwise, <code>is(<var>a</var> = <var>b</var>)</code> evaluates to <code>false</code>;
it never evaluates to <code>unknown</code>.
When <code>is(<var>a</var> = <var>b</var>)</code> is <code>true</code>, <var>a</var> and <var>b</var> are said to be syntactically equal,
in contrast to equivalent expressions, for which <code>is(equal(<var>a</var>, <var>b</var>))</code> is <code>true</code>.
Expressions can be equivalent and not syntactically equal.
</p>
<p>The negation of <code>=</code> is represented by <code>#</code>.
As with <code>=</code>, an expression <code><var>a</var> # <var>b</var></code>, by itself, is not evaluated.
<code>is(<var>a</var> # <var>b</var>)</code> evaluates <code><var>a</var> # <var>b</var></code> to
<code>true</code> or <code>false</code>.
</p>
<p>In addition to <code>is</code>,
some other operators evaluate <code>=</code> and <code>#</code> to <code>true</code> or <code>false</code>,
namely <code>if</code>, <code>and</code>, <code>or</code>, and <code>not</code>.
</p>
<p>Note that because of the rules for evaluation of predicate expressions
(in particular because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>),
<code>not <var>a</var> = <var>b</var></code> is equivalent to <code>is(<var>a</var> # <var>b</var>)</code>,
instead of <code><var>a</var> # <var>b</var></code>.
</p>
<p><code>rhs</code> and <code>lhs</code> return the right-hand and left-hand sides,
respectively, of an equation or inequation.
</p>
<p>See also <code>equal</code> and <code>notequal</code>.
</p>
<p>Examples:
</p>
<p>An expression <code><var>a</var> = <var>b</var></code>, by itself, represents
an unevaluated equation, which might or might not hold.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) eq_1 : a * x - 5 * y = 17;
(%o1)                    a x - 5 y = 17
(%i2) eq_2 : b * x + 3 * y = 29;
(%o2)                    3 y + b x = 29
(%i3) solve ([eq_1, eq_2], [x, y]);
                        196         29 a - 17 b
(%o3)          [[x = ---------, y = -----------]]
                     5 b + 3 a       5 b + 3 a
(%i4) subst (%, [eq_1, eq_2]);
         196 a     5 (29 a - 17 b)
(%o4) [--------- - --------------- = 17, 
       5 b + 3 a      5 b + 3 a
                                  196 b     3 (29 a - 17 b)
                                --------- + --------------- = 29]
                                5 b + 3 a      5 b + 3 a
(%i5) ratsimp (%);
(%o5)                  [17 = 17, 29 = 29]
</pre></td></tr></table>
<p><code>is(<var>a</var> = <var>b</var>)</code> evaluates <code><var>a</var> = <var>b</var></code> to <code>true</code> when <var>a</var> and <var>b</var>
are syntactically equal (that is, identical).
Expressions can be equivalent and not syntactically equal.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) a : (x + 1) * (x - 1);
(%o1)                    (x - 1) (x + 1)
(%i2) b : x^2 - 1;
                              2
(%o2)                        x  - 1
(%i3) [is (a = b), is (a # b)];
(%o3)                     [false, true]
(%i4) [is (equal (a, b)), is (notequal (a, b))];
(%o4)                     [true, false]
</pre></td></tr></table>
<p>Some operators evaluate <code>=</code> and <code>#</code> to <code>true</code> or <code>false</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
(%o1)                          FOO
(%i2) eq_3 : 2 * x = 3 * x;
(%o2)                       2 x = 3 x
(%i3) eq_4 : exp (2) = %e^2;
                              2     2
(%o3)                       %e  = %e
(%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
(%o4)                  [false, true, true]
</pre></td></tr></table>
<p>Because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>,
<code>not <var>a</var> = <var>b</var></code> is equivalent to <code>is(<var>a</var> # <var>b</var>)</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
(%o1)                   [2 x # 3 x, true]
(%i2) is (2 * x # 3 * x);
(%o2)                         true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>and</b>
<a name="IDX63"></a>
</dt>
<dd><p>The logical conjunction operator.
<code>and</code> is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
</p>
<p><code>and</code> forces evaluation (like <code>is</code>) of one or more operands,
and may force evaluation of all operands.
</p>
<p>Operands are evaluated in the order in which they appear.
<code>and</code> evaluates only as many of its operands as necessary to determine the result.
If any operand is <code>false</code>,
the result is <code>false</code> and no further operands are evaluated.
</p>
<p>The global flag <code>prederror</code> governs the behavior of <code>and</code>
when an evaluated operand cannot be determined to be <code>true</code> or <code>false</code>.
<code>and</code> prints an error message when <code>prederror</code> is <code>true</code>.
Otherwise, <code>and</code> returns <code>unknown</code>.
</p>
<p><code>and</code> is not commutative:
<code>a and b</code> might not be equal to <code>b and a</code> due to the treatment of indeterminate operands.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>or</b>
<a name="IDX64"></a>
</dt>
<dd><p>The logical disjunction operator.
<code>or</code> is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
</p>
<p><code>or</code> forces evaluation (like <code>is</code>) of one or more operands,
and may force evaluation of all operands.
</p>
<p>Operands are evaluated in the order in which they appear.
<code>or</code> evaluates only as many of its operands as necessary to determine the result.
If any operand is <code>true</code>,
the result is <code>true</code> and no further operands are evaluated.
</p>
<p>The global flag <code>prederror</code> governs the behavior of <code>or</code>
when an evaluated operand cannot be determined to be <code>true</code> or <code>false</code>.
<code>or</code> prints an error message when <code>prederror</code> is <code>true</code>.
Otherwise, <code>or</code> returns <code>unknown</code>.
</p>
<p><code>or</code> is not commutative:
<code>a or b</code> might not be equal to <code>b or a</code> due to the treatment of indeterminate operands.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>not</b>
<a name="IDX65"></a>
</dt>
<dd><p>The logical negation operator.
<code>not</code> is a prefix operator;
its operand is a Boolean expression, and its result is a Boolean value.
</p>
<p><code>not</code> forces evaluation (like <code>is</code>) of its operand.
</p>
<p>The global flag <code>prederror</code> governs the behavior of <code>not</code>
when its operand cannot be determined to be <code>true</code> or <code>false</code>.
<code>not</code> prints an error message when <code>prederror</code> is <code>true</code>.
Otherwise, <code>not</code> returns <code>unknown</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>abs</b><i> (<var>expr</var>)</i>
<a name="IDX66"></a>
</dt>
<dd><p>Returns the absolute value <var>expr</var>.  If <var>expr</var> is complex, returns the complex
modulus of <var>expr</var>.
</p>
</dd></dl>

<dl>
<dt><u>Keyword:</u> <b>additive</b>
<a name="IDX67"></a>
</dt>
<dd><p>If <code>declare(f,additive)</code> has been executed, then:
</p>
<p>(1) If <code>f</code> is univariate, whenever the simplifier encounters <code>f</code> applied
to a sum, <code>f</code> will be distributed over that sum.  I.e. <code>f(y+x)</code> will
simplify to <code>f(y)+f(x)</code>.
</p>
<p>(2) If <code>f</code> is a function of 2 or more arguments, additivity is defined as 
additivity in the first argument to <code>f</code>, as in the case of <code>sum</code> or 
<code>integrate</code>, i.e. <code>f(h(x)+g(x),x)</code> will simplify to <code>f(h(x),x)+f(g(x),x)</code>.
This simplification does not occur when <code>f</code> is applied to expressions of
the form <code>sum(x[i],i,lower-limit,upper-limit)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Keyword:</u> <b>allbut</b>
<a name="IDX68"></a>
</dt>
<dd><p>works with the <code>part</code> commands (i.e. <code>part</code>, <code>inpart</code>, <code>substpart</code>,
<code>substinpart</code>, <code>dpart</code>, and <code>lpart</code>).  For example,
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) expr : e + d + c + b + a;
(%o1)                   e + d + c + b + a
(%i2) part (expr, [2, 5]);
(%o2)                         d + a
</pre></td></tr></table>
<p>while
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) expr : e + d + c + b + a;
(%o1)                   e + d + c + b + a
(%i2) part (expr, allbut (2, 5));
(%o2)                       e + c + b
</pre></td></tr></table>
<p><code>allbut</code> is also recognized by <code>kill</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
(%o1)                 [11, 22, 33, 44, 55]
(%i2) kill (allbut (cc, dd));
(%o0)                         done
(%i1) [aa, bb, cc, dd];
(%o1)                   [aa, bb, 33, 44]
</pre></td></tr></table>
<p><code>kill(allbut(<var>a_1</var>, <var>a_2</var>, ...))</code> has the effect of <code>kill(all)</code>
except that it does not kill the symbols <var>a_1</var>, <var>a_2</var>, ... .
</p>
</dd></dl>

<dl>
<dt><u>Declaration:</u> <b>antisymmetric</b>
<a name="IDX69"></a>
</dt>
<dd><p>If <code>declare(h,antisymmetric)</code> is done, this tells the
simplifier that <code>h</code> is antisymmetric.  E.g. <code>h(x,z,y)</code> will simplify to
<code>- h(x, y, z)</code>.  That is, it will give (-1)^n times the result given by
<code>symmetric</code> or <code>commutative</code>, where n is the number of interchanges of two
arguments necessary to convert it to that form.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>cabs</b><i> (<var>expr</var>)</i>
<a name="IDX70"></a>
</dt>
<dd><p>Returns the complex absolute value (the complex modulus) of
<var>expr</var>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>ceiling</b><i> (<var>x</var>)</i>
<a name="IDX71"></a>
</dt>
<dd><p>When <var>x</var> is a real number, return the least integer that 
is greater than or equal to <var>x</var>.  
</p>
<p>If <var>x</var> is a constant expression (<code>10 * %pi</code>, for example), 
<code>ceiling</code> evaluates <var>x</var> using big floating point numbers, and 
applies <code>ceiling</code> to the resulting big float. Because <code>ceiling</code> uses
floating point evaluation, it's possible, although unlikely, 
that <code>ceiling</code> could return an erroneous value for constant
inputs. To guard against errors, the floating point evaluation
is done using three values for <code>fpprec</code>.
</p>
<p>For non-constant inputs, <code>ceiling</code> tries to return a simplified
value.  Here are examples of the simplifications that <code>ceiling</code>
knows about:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) ceiling (ceiling (x));
(%o1)                      ceiling(x)
(%i2) ceiling (floor (x));
(%o2)                       floor(x)
(%i3) declare (n, integer)$
(%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
(%o4)                [n, abs(n), max(n, 6)]
(%i5) assume (x &gt; 0, x &lt; 1)$
(%i6) ceiling (x);
(%o6)                           1
(%i7) tex (ceiling (a));
$$\left \lceil a \right \rceil$$
(%o7)                         false
</pre></td></tr></table>
<p>The function <code>ceiling</code> does not automatically map over lists or matrices.
Finally, for all inputs that are manifestly complex, <code>ceiling</code> returns 
a noun form.
</p>
<p>If the range of a function is a subset of the integers, it can be
declared to be <code>integervalued</code>. Both the <code>ceiling</code> and <code>floor</code> functions
can use this information; for example:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) declare (f, integervalued)$
(%i2) floor (f(x));
(%o2)                         f(x)
(%i3) ceiling (f(x) - 1);
(%o3)                       f(x) - 1
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>charfun</b><i> (<var>p</var>)</i>
<a name="IDX72"></a>
</dt>
<dd><p>Return 0 when the predicate <var>p</var> evaluates to <code>false</code>; return
1 when the predicate evaluates to <code>true</code>.  When the predicate
evaluates to something other than <code>true</code> or <code>false</code> (unknown), 
return a noun form.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) charfun (x &lt; 1);
(%o1)                    charfun(x &lt; 1)
(%i2) subst (x = -1, %);
(%o2)                           1
(%i3) e : charfun ('&quot;and&quot; (-1 &lt; x, x &lt; 1))$
(%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
(%o4)                       [0, 1, 0]
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Declaration:</u> <b>commutative</b>
<a name="IDX73"></a>
</dt>
<dd><p>If <code>declare(h,commutative)</code> is done, this tells the
simplifier that <code>h</code> is a commutative function.  E.g. <code>h(x,z,y)</code> will
simplify to <code>h(x, y, z)</code>.  This is the same as <code>symmetric</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>compare</b><i> (<var>x</var>, <var>y</var>)</i>
<a name="IDX74"></a>
</dt>
<dd><p>Return a comparison operator <var>op</var>
(<code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, <code>&gt;=</code>, <code>=</code>, or <code>#</code>) such that
<code>is (<var>x</var> <var>op</var> <var>y</var>)</code> evaluates to true;
when either <var>x</var> or <var>y</var> depends on <code>%i</code> and
<code><var>x</var> # <var>y</var></code>, return <code>notcomparable</code>;
when there is no such operator or
Maxima isn't able to determine the operator, return <code>unknown</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) compare (1, 2);
(%o1)                           &lt;
(%i2) compare (1, x);
(%o2)                        unknown
(%i3) compare (%i, %i);
(%o3)                           =
(%i4) compare (%i, %i + 1);
(%o4)                     notcomparable
(%i5) compare (1/x, 0);
(%o5)                           #
(%i6) compare (x, abs(x));
(%o6)                          &lt;=
</pre></td></tr></table>
<p>The function <code>compare</code> doesn't try to determine whether the real domains of
its arguments are nonempty; thus
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
(%o1)                           &lt;
</pre></td></tr></table>
<p>The real domain of <code>acos (x^2 + 1)</code> is empty.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>entier</b><i> (<var>x</var>)</i>
<a name="IDX75"></a>
</dt>
<dd><p>Returns the largest integer less than or equal to <var>x</var> where <var>x</var> is numeric.  <code>fix</code> (as in
<code>fixnum</code>) is a synonym for this, so <code>fix(<var>x</var>)</code> is precisely the same.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>equal</b><i> (<var>a</var>, <var>b</var>)</i>
<a name="IDX76"></a>
</dt>
<dd><p>Represents equivalence, that is, equal value.
</p>
<p>By itself, <code>equal</code> does not evaluate or simplify.
The function <code>is</code> attempts to evaluate <code>equal</code> to a Boolean value.
<code>is(equal(<var>a</var>, <var>b</var>))</code> 
returns <code>true</code> (or <code>false</code>) if
and only if <var>a</var> and <var>b</var> are equal (or not equal) for all possible
values of their variables, as determined by evaluating <code>ratsimp(<var>a</var> - <var>b</var>)</code>;
if <code>ratsimp</code> returns 0, the two expressions are considered equivalent.
Two expressions may be equivalent even if they are not syntactically equal (i.e., identical).
</p>
<p>When <code>is</code> fails to reduce <code>equal</code> to <code>true</code> or <code>false</code>,
the result is governed by the global flag <code>prederror</code>.
When <code>prederror</code> is <code>true</code>,
<code>is</code> complains with an error message.
Otherwise, <code>is</code> returns <code>unknown</code>.
</p>
<p>In addition to <code>is</code>,
some other operators evaluate <code>equal</code> and <code>notequal</code> to <code>true</code> or <code>false</code>,
namely <code>if</code>, <code>and</code>, <code>or</code>, and <code>not</code>.
</p>

<p>The negation of <code>equal</code> is <code>notequal</code>.
Note that because of the rules for evaluation of predicate expressions
(in particular because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>),
<code>not equal(<var>a</var>, <var>b</var>)</code>
is equivalent to <code>is(notequal(<var>a</var>, <var>b</var>))</code>
instead of <code>notequal(<var>a</var>, <var>b</var>)</code>.
</p>
<p>Examples:
</p>
<p>By itself, <code>equal</code> does not evaluate or simplify.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                        2
(%o1)            equal(x  - 1, (x - 1) (x + 1))
(%i2) equal (x, x + 1);
(%o2)                    equal(x, x + 1)
(%i3) equal (x, y);
(%o3)                      equal(x, y)
</pre></td></tr></table>
<p>The function <code>is</code> attempts to evaluate <code>equal</code> to a Boolean value.
<code>is(equal(<var>a</var>, <var>b</var>))</code> returns <code>true</code> when <code>ratsimp(<var>a</var> - <var>b</var>)</code> returns 0.
Two expressions may be equivalent even if they are not syntactically equal (i.e., identical).
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
(%o1)                           0
(%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
(%o2)                         true
(%i3) is (x^2 - 1 = (x + 1) * (x - 1));
(%o3)                         false
(%i4) ratsimp (x - (x + 1));
(%o4)                          - 1
(%i5) is (equal (x, x + 1));
(%o5)                         false
(%i6) is (x = x + 1);
(%o6)                         false
(%i7) ratsimp (x - y);
(%o7)                         x - y
(%i8) is (equal (x, y));
Maxima was unable to evaluate the predicate:
equal(x, y)
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i9) is (x = y);
(%o9)                         false
</pre></td></tr></table>
<p>When <code>is</code> fails to reduce <code>equal</code> to <code>true</code> or <code>false</code>,
the result is governed by the global flag <code>prederror</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                    2             2
(%o1)             [x  + 2 x + 1, x  - 2 x - 1]
(%i2) ratsimp (aa - bb);
(%o2)                        4 x + 2
(%i3) prederror : true;
(%o3)                         true
(%i4) is (equal (aa, bb));
Maxima was unable to evaluate the predicate:
       2             2
equal(x  + 2 x + 1, x  - 2 x - 1)
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i5) prederror : false;
(%o5)                         false
(%i6) is (equal (aa, bb));
(%o6)                        unknown
</pre></td></tr></table>
<p>Some operators evaluate <code>equal</code> and <code>notequal</code> to <code>true</code> or <code>false</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) if equal (a, b) then FOO else BAR;
Maxima was unable to evaluate the predicate:
equal(a, b)
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i2) eq_1 : equal (x, x + 1);
(%o2)                    equal(x, x + 1)
(%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                         2                   2
(%o3)             equal(y  + 2 y + 1, (y + 1) )
(%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
(%o4)                  [false, true, true]
</pre></td></tr></table>
<p>Because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>,
<code>not equal(<var>a</var>, <var>b</var>)</code> is equivalent to <code>is(notequal(<var>a</var>, <var>b</var>))</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
(%o1)            [notequal(2 z, 2 z - 1), true]
(%i2) is (notequal (2*z, 2*z - 1));
(%o2)                         true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>floor</b><i> (<var>x</var>)</i>
<a name="IDX77"></a>
</dt>
<dd><p>When <var>x</var> is a real number, return the largest integer that 
is less than or equal to <var>x</var>.
</p>
<p>If <var>x</var> is a constant expression (<code>10 * %pi</code>, for example), 
<code>floor</code> evaluates <var>x</var> using big floating point numbers, and 
applies floor to the resulting big float. Because floor uses
floating point evaluation, it's possible, although unlikely, 
that <code>floor</code> could return  an erroneous value for constant 
inputs.  To guard against errors, the floating point evaluation
is done using three values for <code>fpprec</code>.
</p>
<p>For non-constant inputs, <code>floor</code> tries to return a simplified
value.  Here are examples of the simplifications that <code>floor</code>
knows about:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) floor (ceiling (x));
(%o1)                      ceiling(x)
(%i2) floor (floor (x));
(%o2)                       floor(x)
(%i3) declare (n, integer)$
(%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
(%o4)                [n, abs(n), min(n, 6)]
(%i5) assume (x &gt; 0, x &lt; 1)$
(%i6) floor (x);
(%o6)                           0
(%i7) tex (floor (a));
$$\left \lfloor a \right \rfloor$$
(%o7)                         false
</pre></td></tr></table>
<p>The function <code>floor</code> does not automatically map over lists or matrices.
Finally, for all inputs that are manifestly complex, <code>floor</code> returns 
a noun form.
</p>
<p>If the range of a function is a subset of the integers, it can be
declared to be <code>integervalued</code>. Both the <code>ceiling</code> and <code>floor</code> functions
can use this information; for example:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) declare (f, integervalued)$
(%i2) floor (f(x));
(%o2)                         f(x)
(%i3) ceiling (f(x) - 1);
(%o3)                       f(x) - 1
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>notequal</b><i> (<var>a</var>, <var>b</var>)</i>
<a name="IDX78"></a>
</dt>
<dd><p>Represents the negation of <code>equal(<var>a</var>, <var>b</var>)</code>.
</p>
<p>Note that because of the rules for evaluation of predicate expressions
(in particular because <code>not <var>expr</var></code> causes evaluation of <var>expr</var>),
<code>not equal(<var>a</var>, <var>b</var>)</code>
is equivalent to <code>is(notequal(<var>a</var>, <var>b</var>))</code>
instead of <code>notequal(<var>a</var>, <var>b</var>)</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) equal (a, b);
(%o1)                      equal(a, b)
(%i2) maybe (equal (a, b));
(%o2)                        unknown
(%i3) notequal (a, b);
(%o3)                    notequal(a, b)
(%i4) not equal (a, b);
Maxima was unable to evaluate the predicate:
equal(a, b)
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i5) maybe (notequal (a, b));
(%o5)                        unknown
(%i6) maybe (not equal (a, b));
(%o6)                        unknown
(%i7) assume (a &gt; b);
(%o7)                        [a &gt; b]
(%i8) equal (a, b);
(%o8)                      equal(a, b)
(%i9) maybe (equal (a, b));
(%o9)                         false
(%i10) notequal (a, b);
(%o10)                   notequal(a, b)
(%i11) not equal (a, b);
(%o11)                        true
(%i12) maybe (notequal (a, b));
(%o12)                        true
(%i13) maybe (not equal (a, b));
(%o13)                        true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>eval</b>
<a name="IDX79"></a>
</dt>
<dd><p>As an argument in a call to <code>ev (<var>expr</var>)</code>,
<code>eval</code> causes an extra evaluation of <var>expr</var>.
See <code>ev</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>evenp</b><i> (<var>expr</var>)</i>
<a name="IDX80"></a>
</dt>
<dd><p>Returns <code>true</code> if <var>expr</var> is an even integer.
<code>false</code> is returned in all other cases.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>fix</b><i> (<var>x</var>)</i>
<a name="IDX81"></a>
</dt>
<dd><p>A synonym for <code>entier (<var>x</var>)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>fullmap</b><i> (<var>f</var>, <var>expr_1</var>, ...)</i>
<a name="IDX82"></a>
</dt>
<dd><p>Similar to <code>map</code>, but <code>fullmap</code> keeps mapping
down all subexpressions until the main operators are no longer the
same.
</p>
<p><code>fullmap</code> is used by the Maxima
simplifier for certain matrix manipulations; thus, Maxima sometimes generates
an error message concerning <code>fullmap</code> even though <code>fullmap</code> was not
explicitly called by the user.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) a + b * c;
(%o1)                        b c + a
(%i2) fullmap (g, %);
(%o2)                   g(b) g(c) + g(a)
(%i3) map (g, %th(2));
(%o3)                     g(b c) + g(a)
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>fullmapl</b><i> (<var>f</var>, <var>list_1</var>, ...)</i>
<a name="IDX83"></a>
</dt>
<dd><p>Similar to <code>fullmap</code>, but <code>fullmapl</code> only maps onto
lists and matrices.
</p>
<p>Example:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) fullmapl (&quot;+&quot;, [3, [4, 5]], [[a, 1], [0, -1.5]]);
(%o1)                [[a + 3, 4], [4, 3.5]]
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>is</b><i> (<var>expr</var>)</i>
<a name="IDX84"></a>
</dt>
<dd><p>Attempts to determine whether the predicate <var>expr</var> 
is provable from the facts in the <code>assume</code> database.
</p>
<p>If the predicate is provably <code>true</code> or <code>false</code>,
<code>is</code> returns <code>true</code> or <code>false</code>, respectively.
Otherwise, the return value is governed by the global flag <code>prederror</code>.
When <code>prederror</code> is <code>true</code>,
<code>is</code> complains with an error message.
Otherwise, <code>is</code> returns <code>unknown</code>.
</p>
<p><code>ev(<var>expr</var>, pred)</code>
(which can be written  <code><var>expr</var>, pred</code> at the interactive prompt)
is equivalent to <code>is(<var>expr</var>)</code>.
</p>
<p>See also <code>assume</code>, <code>facts</code>, and <code>maybe</code>.
</p>
<p>Examples:
</p>
<p><code>is</code> causes evaluation of predicates.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) %pi &gt; %e;
(%o1)                       %pi &gt; %e
(%i2) is (%pi &gt; %e);
(%o2)                         true
</pre></td></tr></table>
<p><code>is</code> attempts to derive predicates from the <code>assume</code> database.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) assume (a &gt; b);
(%o1)                        [a &gt; b]
(%i2) assume (b &gt; c);
(%o2)                        [b &gt; c]
(%i3) is (a &lt; b);
(%o3)                         false
(%i4) is (a &gt; c);
(%o4)                         true
(%i5) is (equal (a, c));
(%o5)                         false
</pre></td></tr></table>
<p>If <code>is</code> can neither prove nor disprove a predicate from the <code>assume</code> database,
the global flag <code>prederror</code> governs the behavior of <code>is</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) assume (a &gt; b);
(%o1)                        [a &gt; b]
(%i2) prederror: true$
(%i3) is (a &gt; 0);
Maxima was unable to evaluate the predicate:
a &gt; 0
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) prederror: false$
(%i5) is (a &gt; 0);
(%o5)                        unknown
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>maybe</b><i> (<var>expr</var>)</i>
<a name="IDX85"></a>
</dt>
<dd><p>Attempts to determine whether the predicate <var>expr</var> 
is provable from the facts in the <code>assume</code> database.
</p>
<p>If the predicate is provably <code>true</code> or <code>false</code>,
<code>maybe</code> returns <code>true</code> or <code>false</code>, respectively.
Otherwise, <code>maybe</code> returns <code>unknown</code>.
</p>
<p><code>maybe</code> is functionally equivalent to <code>is</code> with <code>prederror: false</code>,
but the result is computed without actually assigning a value to <code>prederror</code>.
</p>
<p>See also <code>assume</code>, <code>facts</code>, and <code>is</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) maybe (x &gt; 0);
(%o1)                        unknown
(%i2) assume (x &gt; 1);
(%o2)                        [x &gt; 1]
(%i3) maybe (x &gt; 0);
(%o3)                         true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>isqrt</b><i> (<var>x</var>)</i>
<a name="IDX86"></a>
</dt>
<dd><p>Returns the &quot;integer square root&quot;
of the absolute value of <var>x</var>,
which is an integer.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>lmax</b><i> (<var>L</var>)</i>
<a name="IDX87"></a>
</dt>
<dd><p>When <var>L</var> is a list or a set, return <code>apply ('max, args (<var>L</var>))</code>.  When <var>L</var> isn't a
list or a set, signal an error.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>lmin</b><i> (<var>L</var>)</i>
<a name="IDX88"></a>
</dt>
<dd><p>When <var>L</var> is a list or a set, return <code>apply ('min, args (<var>L</var>))</code>. When <var>L</var> isn't a
list or a set, signal an error.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>max</b><i> (<var>x_1</var>, ..., <var>x_n</var>)</i>
<a name="IDX89"></a>
</dt>
<dd><p>Return a simplified value for the maximum of the expressions <var>x_1</var> through <var>x_n</var>.
When <code>get (trylevel, maxmin)</code>, is 2 or greater, <code>max</code> uses the simplification 
<code>max (e, -e) --&gt; |e|</code>.  When <code>get (trylevel, maxmin)</code> is 3 or greater, <var>max</var> tries
to eliminate expressions that are between two other arguments; for example,
<code>max (x, 2*x, 3*x) --&gt; max (x, 3*x)</code>. To set the value of <code>trylevel</code> to 2, use
<code>put (trylevel, 2, maxmin)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>min</b><i> (<var>x_1</var>, ..., <var>x_n</var>)</i>
<a name="IDX90"></a>
</dt>
<dd><p>Return a simplified value for the minimum of the expressions <code>x_1</code> through <code>x_n</code>.
When <code>get (trylevel, maxmin)</code>, is 2 or greater, <code>min</code> uses the simplification 
<code>min (e, -e) --&gt; -|e|</code>.  When <code>get (trylevel, maxmin)</code> is 3 or greater, <code>min</code> tries
to eliminate expressions that are between two other arguments; for example,
<code>min (x, 2*x, 3*x) --&gt; min (x, 3*x)</code>. To set the value of <code>trylevel</code> to 2, use
<code>put (trylevel, 2, maxmin)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>polymod</b><i> (<var>p</var>)</i>
<a name="IDX91"></a>
</dt>
<dt><u>Function:</u> <b>polymod</b><i> (<var>p</var>, <var>m</var>)</i>
<a name="IDX92"></a>
</dt>
<dd><p>Converts the polynomial <var>p</var> to a modular representation
with respect to the current modulus which is the value of the variable
<code>modulus</code>.  
</p>
<p><code>polymod (<var>p</var>, <var>m</var>)</code> specifies a modulus <var>m</var> to be used 
instead of the current value of <code>modulus</code>.
</p>
<p>See <code>modulus</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>mod</b><i> (<var>x</var>, <var>y</var>)</i>
<a name="IDX93"></a>
</dt>
<dd><p>If <var>x</var> and <var>y</var> are real numbers and <var>y</var> is nonzero,
return <code><var>x</var> - <var>y</var> * floor(<var>x</var> / <var>y</var>)</code>.
Further for all real <var>x</var>, we have <code>mod (<var>x</var>, 0) = <var>x</var></code>. For a discussion of
the definition <code>mod (<var>x</var>, 0) = <var>x</var></code>, see Section 3.4, of &quot;Concrete Mathematics,&quot; 
by Graham, Knuth, and Patashnik. The function <code>mod (<var>x</var>, 1)</code> 
is a sawtooth function with period 1 with <code>mod (1, 1) = 0</code> and 
<code>mod (0, 1) = 0</code>.
</p>
<p>To find the principal argument (a number in the interval <code>(-%pi, %pi]</code>) of a 
complex number, use the function <code><var>x</var> |-&gt; %pi - mod (%pi - <var>x</var>, 2*%pi)</code>, where 
<var>x</var> is an argument.
</p>
<p>When <var>x</var> and <var>y</var> are constant expressions (<code>10 * %pi</code>, for example), <code>mod</code>
uses the same big float evaluation scheme that <code>floor</code> and <code>ceiling</code> uses.
Again, it's possible, although unlikely, that <code>mod</code> could return an
erroneous value in such cases.
</p>
<p>For nonnumerical arguments <var>x</var> or <var>y</var>, <code>mod</code> knows several simplification 
rules:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) mod (x, 0);
(%o1)                           x
(%i2) mod (a*x, a*y);
(%o2)                      a mod(x, y)
(%i3) mod (0, x);
(%o3)                           0
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>oddp</b><i> (<var>expr</var>)</i>
<a name="IDX94"></a>
</dt>
<dd><p>is <code>true</code> if <var>expr</var> is an odd integer.
<code>false</code> is returned in all other cases.
</p>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>pred</b>
<a name="IDX95"></a>
</dt>
<dd><p>As an argument in a call to <code>ev (<var>expr</var>)</code>,
<code>pred</code> causes predicates (expressions which evaluate to <code>true</code>
or <code>false</code>) to be evaluated.
See <code>ev</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>make_random_state</b><i> (<var>n</var>)</i>
<a name="IDX96"></a>
</dt>
<dt><u>Function:</u> <b>make_random_state</b><i> (<var>s</var>)</i>
<a name="IDX97"></a>
</dt>
<dt><u>Function:</u> <b>make_random_state</b><i> (true)</i>
<a name="IDX98"></a>
</dt>
<dt><u>Function:</u> <b>make_random_state</b><i> (false)</i>
<a name="IDX99"></a>
</dt>
<dd>
<p>A random state object represents the state of the random number generator.
The state comprises 627 32-bit words.
</p>
<p><code>make_random_state (<var>n</var>)</code> returns a new random state object
created from an integer seed value equal to <var>n</var> modulo 2^32.
<var>n</var> may be negative.
</p>

<p><code>make_random_state (<var>s</var>)</code> returns a copy of the random state <var>s</var>.
</p>
<p><code>make_random_state (true)</code> returns a new random state object,
using the current computer clock time as the seed.
</p>
<p><code>make_random_state (false)</code> returns a copy of the current state
of the random number generator.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>set_random_state</b><i> (<var>s</var>)</i>
<a name="IDX100"></a>
</dt>
<dd><p>Copies <var>s</var> to the random number generator state.
</p>
<p><code>set_random_state</code> always returns <code>done</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>random</b><i> (<var>x</var>)</i>
<a name="IDX101"></a>
</dt>
<dd><p>Returns a pseudorandom number. If <var>x</var> is an integer, <code>random (<var>x</var>)</code> returns an
integer from 0 through <code><var>x</var> - 1</code> inclusive. If <var>x</var> is a floating point number,
<code>random (<var>x</var>)</code> returns a nonnegative floating point number less than <var>x</var>.
<code>random</code> complains with an error if <var>x</var> is neither an integer nor a float,
or if <var>x</var> is not positive.
</p>
<p>The functions <code>make_random_state</code> and <code>set_random_state</code>
maintain the state of the random number generator.
</p>
<p>The Maxima random number generator is an implementation of the Mersenne twister MT 19937.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) s1: make_random_state (654321)$
(%i2) set_random_state (s1);
(%o2)                         done
(%i3) random (1000);
(%o3)                          768
(%i4) random (9573684);
(%o4)                        7657880
(%i5) random (2^75);
(%o5)                11804491615036831636390
(%i6) s2: make_random_state (false)$
(%i7) random (1.0);
(%o7)                   .2310127244107132
(%i8) random (10.0);
(%o8)                   4.394553645870825
(%i9) random (100.0);
(%o9)                   32.28666704056853
(%i10) set_random_state (s2);
(%o10)                        done
(%i11) random (1.0);
(%o11)                  .2310127244107132
(%i12) random (10.0);
(%o12)                  4.394553645870825
(%i13) random (100.0);
(%o13)                  32.28666704056853
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>rationalize</b><i> (<var>expr</var>)</i>
<a name="IDX102"></a>
</dt>
<dd><p>Convert all double floats and big floats in the Maxima expression
<var>expr</var> to their exact rational equivalents. If you are not familiar with
the binary representation of floating point numbers, you might
be surprised that <code>rationalize (0.1)</code> does not equal 1/10.  This behavior
isn't special to Maxima - the number 1/10 has a repeating, not a terminating,
binary representation.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) rationalize (0.5);
                                1
(%o1)                           -
                                2
(%i2) rationalize (0.1);
                               1
(%o2)                          --
                               10
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0);
                             209715
(%o4)                        -------
                             2097152
(%i5) fpprec : 20$
(%i6) rationalize (0.1b0);
                     236118324143482260685
(%o6)                ----------------------
                     2361183241434822606848
(%i7) rationalize (sin (0.1*x + 5.6));
                              x    28
(%o7)                     sin(-- + --)
                              10   5
</pre></td></tr></table>
<p>Example use:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) unitfrac(r) := block([uf : [], q],
    if not(ratnump(r)) then error(&quot;The input to 'unitfrac' must be a rational number&quot;),
    while r # 0 do (
        uf : cons(q : 1/ceiling(1/r), uf),
        r : r - q),
    reverse(uf));
(%o1) unitfrac(r) := block([uf : [], q], 
if not ratnump(r) then error(&quot;The input to 'unitfrac' must be a rational number&quot;
                                     1
), while r # 0 do (uf : cons(q : ----------, uf), r : r - q), 
                                         1
                                 ceiling(-)
                                         r
reverse(uf))
(%i2) unitfrac (9/10);
                            1  1  1
(%o2)                      [-, -, --]
                            2  3  15
(%i3) apply (&quot;+&quot;, %);
                               9
(%o3)                          --
                               10
(%i4) unitfrac (-9/10);
                                  1
(%o4)                       [- 1, --]
                                  10
(%i5) apply (&quot;+&quot;, %);
                                9
(%o5)                         - --
                                10
(%i6) unitfrac (36/37);
                        1  1  1  1    1
(%o6)                  [-, -, -, --, ----]
                        2  3  8  69  6808
(%i7) apply (&quot;+&quot;, %);
                               36
(%o7)                          --
                               37
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sign</b><i> (<var>expr</var>)</i>
<a name="IDX103"></a>
</dt>
<dd><p>Attempts to determine the sign of <var>expr</var>
on the basis of the facts in the current data base.  It returns one of
the following answers: <code>pos</code> (positive), <code>neg</code> (negative), <code>zero</code>, <code>pz</code>
(positive or zero), <code>nz</code> (negative or zero), <code>pn</code> (positive or negative),
or <code>pnz</code> (positive, negative, or zero, i.e. nothing known).
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>signum</b><i> (<var>x</var>)</i>
<a name="IDX104"></a>
</dt>
<dd><p>For numeric <var>x</var>, returns 0 if <var>x</var> is 0, otherwise returns -1 or +1
as <var>x</var> is less than or greater than 0, respectively.
</p>
<p>If <var>x</var> is not numeric then a simplified but equivalent form is returned.
For example, <code>signum(-x)</code> gives <code>-signum(x)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sort</b><i> (<var>L</var>, <var>P</var>)</i>
<a name="IDX105"></a>
</dt>
<dt><u>Function:</u> <b>sort</b><i> (<var>L</var>)</i>
<a name="IDX106"></a>
</dt>
<dd><p>Sorts a list <var>L</var> according to a predicate <code>P</code> of two arguments,
such that <code><var>P</var> (<var>L</var>[k], <var>L</var>[k + 1])</code> is <code>true</code>
for any two successive elements.
The predicate may be specified as the name of a function or binary infix operator,
or as a <code>lambda</code> expression.
If specified as the name of an operator,
the name is enclosed in &quot;double quotes&quot;.
</p>
<p>The sorted list is returned as a new object;
the argument <var>L</var> is not modified.
To construct the return value,
<code>sort</code> makes a shallow copy of the elements of <var>L</var>.
</p>
<p>If the predicate <var>P</var> is not a total order on the elements of <var>L</var>,
then <code>sort</code> might run to completion without error,
but the result is undefined.
<code>sort</code> complains if the predicate evaluates to something other
than <code>true</code> or <code>false</code>.
</p>
<p><code>sort (<var>L</var>)</code> is equivalent to <code>sort (<var>L</var>, orderlessp)</code>.
That is, the default sorting order is ascending,
as determined by <code>orderlessp</code>.
All Maxima atoms and expressions are comparable under <code>orderlessp</code>,
although there are isolated examples of expressions for which <code>orderlessp</code> is not transitive;
this is a bug.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
               5
(%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
               2
(%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
                                                   5
(%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                   2
(%i3) sort ([%pi, 3, 4, %e, %gamma]);
(%o3)                [3, 4, %e, %gamma, %pi]
(%i4) sort ([%pi, 3, 4, %e, %gamma], &quot;&lt;&quot;);
(%o4)                [%gamma, %e, 3, %pi, 4]
(%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
(%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
(%i6) sort (my_list);
(%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
(%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
(%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sqrt</b><i> (<var>x</var>)</i>
<a name="IDX107"></a>
</dt>
<dd><p>The square root of <var>x</var>. It is represented internally by
<code><var>x</var>^(1/2)</code>.  See also <code>rootscontract</code>.
</p>
<p><code>radexpand</code> if <code>true</code> will cause nth roots of factors of a product
which are powers of n to be pulled outside of the radical, e.g.
<code>sqrt(16*x^2)</code> will become <code>4*x</code> only if <code>radexpand</code> is <code>true</code>.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>sqrtdispflag</b>
<a name="IDX108"></a>
</dt>
<dd><p>Default value: <code>true</code>
</p>
<p>When <code>sqrtdispflag</code> is <code>false</code>,
causes <code>sqrt</code> to display with exponent 1/2.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sublis</b><i> (<var>list</var>, <var>expr</var>)</i>
<a name="IDX109"></a>
</dt>
<dd><p>Makes multiple parallel substitutions into an expression.
</p>
<p>The variable <code>sublis_apply_lambda</code> controls simplification after
<code>sublis</code>.
</p>
<p>Example:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sublis ([a=b, b=a], sin(a) + cos(b));
(%o1)                    sin(b) + cos(a)
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sublist</b><i> (<var>list</var>, <var>p</var>)</i>
<a name="IDX110"></a>
</dt>
<dd><p>Returns the list of elements of <var>list</var> for which the
predicate <code>p</code> returns <code>true</code>.
</p>
<p>Example:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) L: [1, 2, 3, 4, 5, 6];
(%o1)                  [1, 2, 3, 4, 5, 6]
(%i2) sublist (L, evenp);
(%o2)                       [2, 4, 6]
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>sublis_apply_lambda</b>
<a name="IDX111"></a>
</dt>
<dd><p>Default value: <code>true</code> - controls whether <code>lambda</code>'s
substituted are applied in simplification after <code>sublis</code> is used or
whether you have to do an <code>ev</code> to get things to apply. <code>true</code> means do the
application.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>subst</b><i> (<var>a</var>, <var>b</var>, <var>c</var>)</i>
<a name="IDX112"></a>
</dt>
<dd><p>Substitutes <var>a</var> for <var>b</var> in <var>c</var>.  <var>b</var> must be an atom or a
complete subexpression of <var>c</var>.  For example, <code>x+y+z</code> is a complete
subexpression of <code>2*(x+y+z)/w</code> while <code>x+y</code> is not. When <var>b</var> does not have
these characteristics, one may sometimes use <code>substpart</code> or <code>ratsubst</code>
(see below).  Alternatively, if <var>b</var> is of the form <code>e/f</code> then one could
use <code>subst (a*f, e, c)</code> while if <var>b</var> is of the form <code>e^(1/f)</code> then one could
use <code>subst (a^f, e, c)</code>.  The <code>subst</code> command also discerns the <code>x^y</code> in <code>x^-y</code>
so that <code>subst (a, sqrt(x), 1/sqrt(x))</code> yields <code>1/a</code>.  <var>a</var> and <var>b</var> may also be
operators of an expression enclosed in double-quotes <code>&quot;</code> or they may be function
names.  If one wishes to substitute for the independent variable in
derivative forms then the <code>at</code> function (see below) should be used.
</p>
<p><code>subst</code> is an alias for <code>substitute</code>.
</p>
<p><code>subst (<var>eq_1</var>, <var>expr</var>)</code> or <code>subst ([<var>eq_1</var>, ..., <var>eq_k</var>], <var>expr</var>)</code>
are other permissible
forms.  The <var>eq_i</var> are equations indicating substitutions to be made.
For each equation, the right side will be substituted for the left in
the expression <var>expr</var>.
</p>
<p><code>exptsubst</code> if <code>true</code> permits substitutions
like <code>y</code> for <code>%e^x</code> in <code>%e^(a*x)</code> to take place.
</p>
<p>When <code>opsubst</code> is <code>false</code>,
<code>subst</code> will not attempt to substitute into the operator of an expression.
E.g. <code>(opsubst: false, subst (x^2, r, r+r[0]))</code> will work.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) subst (a, x+y, x + (x+y)^2 + y);
                                    2
(%o1)                      y + x + a
(%i2) subst (-%i, %i, a + b*%i);
(%o2)                       a - %i b
</pre></td></tr></table>

<p>For further examples, do <code>example (subst)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>substinpart</b><i> (<var>x</var>, <var>expr</var>, <var>n_1</var>, ..., <var>n_k</var>)</i>
<a name="IDX113"></a>
</dt>
<dd><p>Similar to <code>substpart</code>, but <code>substinpart</code> works on the
internal representation of <var>expr</var>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x . 'diff (f(x), x, 2);
                              2
                             d
(%o1)                   x . (--- (f(x)))
                               2
                             dx
(%i2) substinpart (d^2, %, 2);
                                  2
(%o2)                        x . d
(%i3) substinpart (f1, f[1](x + 1), 0);
(%o3)                       f1(x + 1)
</pre></td></tr></table>
<p>If the last argument to a part function is a list of indices then
several subexpressions are picked out, each one corresponding to an
index of the list.  Thus
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) part (x + y + z, [1, 3]);
(%o1)                         z + x
</pre></td></tr></table>
<p><code>piece</code> holds the value of the last expression selected when using the
part functions.  It is set during the execution of the function and
thus may be referred to in the function itself as shown below.
If <code>partswitch</code> is set to <code>true</code> then <code>end</code> is returned when a
selected part of an expression doesn't exist, otherwise an error
message is given.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
              3         2       2            3
(%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
(%i2) part (expr, 2, [1, 3]);
                                  2
(%o2)                         54 y
(%i3) sqrt (piece/54);
(%o3)                        abs(y)
(%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                               3
(%o4)               (3 y + 2 x)  + y + x + 1
(%i5) expr: 1/x + y/x - 1/z;
                             1   y   1
(%o5)                      - - + - + -
                             z   x   x
(%i6) substpart (xthru (piece), expr, [2, 3]);
                            y + 1   1
(%o6)                       ----- - -
                              x     z
</pre></td></tr></table>
<p>Also, setting the option <code>inflag</code> to <code>true</code> and calling <code>part</code> or <code>substpart</code> is 
the same as calling <code>inpart</code> or <code>substinpart</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>substpart</b><i> (<var>x</var>, <var>expr</var>, <var>n_1</var>, ..., <var>n_k</var>)</i>
<a name="IDX114"></a>
</dt>
<dd><p>Substitutes <var>x</var> for the subexpression
picked out by the rest of the arguments as in <code>part</code>.  It returns the
new value of <var>expr</var>.  <var>x</var> may be some operator to be substituted for an
operator of <var>expr</var>.  In some cases <var>x</var> needs to be enclosed in double-quotes <code>&quot;</code>
(e.g.  <code>substpart (&quot;+&quot;, a*b, 0)</code> yields <code>b + a</code>).
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) 1/(x^2 + 2);
                               1
(%o1)                        ------
                              2
                             x  + 2
(%i2) substpart (3/2, %, 2, 1, 2);
                               1
(%o2)                       --------
                             3/2
                            x    + 2
(%i3) a*x + f(b, y);
(%o3)                     a x + f(b, y)
(%i4) substpart (&quot;+&quot;, %, 1, 0);
(%o4)                    x + f(b, y) + a
</pre></td></tr></table>
<p>Also, setting the option <code>inflag</code> to <code>true</code> and calling <code>part</code> or <code>substpart</code> is 
the same as calling <code>inpart</code> or <code>substinpart</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>subvarp</b><i> (<var>expr</var>)</i>
<a name="IDX115"></a>
</dt>
<dd><p>Returns <code>true</code> if <var>expr</var> is a subscripted variable, for example
<code>a[i]</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>symbolp</b><i> (<var>expr</var>)</i>
<a name="IDX116"></a>
</dt>
<dd><p>Returns <code>true</code> if <var>expr</var> is a symbol, else <code>false</code>.
In effect, <code>symbolp(x)</code> is equivalent to the predicate <code>atom(x) and not numberp(x)</code>.
</p>
<p>See also <a href="maxima_6.html#SEC26">Identifiers</a>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>unorder</b><i> ()</i>
<a name="IDX117"></a>
</dt>
<dd><p>Disables the aliasing created by the last use of the ordering
commands <code>ordergreat</code> and <code>orderless</code>. <code>ordergreat</code> and <code>orderless</code> may not
be used more than one time each without calling <code>unorder</code>. 
See also <code>ordergreat</code> and <code>orderless</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) unorder();
(%o1)                          []
(%i2) b*x + a^2;
                                   2
(%o2)                       b x + a
(%i3) ordergreat (a);
(%o3)                         done
(%i4) b*x + a^2;
 %th(1) - %th(3);
                             2
(%o4)                       a  + b x
(%i5) unorder();
                              2    2
(%o5)                        a  - a
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>vectorpotential</b><i> (<var>givencurl</var>)</i>
<a name="IDX118"></a>
</dt>
<dd><p>Returns the vector potential of a given
curl vector, in the current coordinate system.
<code>potentialzeroloc</code> has a similar role as for <code>potential</code>, but the order of
the left-hand sides of the equations must be a cyclic permutation of
the coordinate variables.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>xthru</b><i> (<var>expr</var>)</i>
<a name="IDX119"></a>
</dt>
<dd><p>Combines all terms of <var>expr</var> (which should be a sum) over a
common denominator without expanding products and exponentiated sums
as <code>ratsimp</code> does.  <code>xthru</code> cancels common factors in the numerator and
denominator of rational expressions but only if the factors are
explicit.
</p>
<p>Sometimes it is better to use <code>xthru</code> before <code>ratsimp</code>ing an
expression in order to cause explicit factors of the gcd of the
numerator and denominator to be canceled thus simplifying the
expression to be <code>ratsimp</code>ed.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                20
                 1       (x + 2)   - 2 y       x
(%o1)        --------- + --------------- - ---------
                    19             20             20
             (y + x)        (y + x)        (y + x)
(%i2) xthru (%);
                                 20
                          (x + 2)   - y
(%o2)                     -------------
                                   20
                            (y + x)
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>zeroequiv</b><i> (<var>expr</var>, <var>v</var>)</i>
<a name="IDX120"></a>
</dt>
<dd><p>Tests whether the expression <var>expr</var> in the variable
<var>v</var> is equivalent to zero, returning <code>true</code>, <code>false</code>, or
<code>dontknow</code>.
</p>
<p><code>zeroequiv</code> has these restrictions:
</p><ol>
<li>
Do not use functions that Maxima does not know how to
differentiate and evaluate.
</li><li>
If the expression has poles on the real line, there may be errors
in the result (but this is unlikely to occur).
</li><li>
If the expression contains functions which are not solutions to
first order differential equations (e.g.  Bessel functions) there may
be incorrect results.
</li><li>
The algorithm uses evaluation at randomly chosen points for
carefully selected subexpressions.  This is always a somewhat
hazardous business, although the algorithm tries to minimize the
potential for error.
</li></ol>

<p>For example <code>zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)</code> returns
<code>true</code> and <code>zeroequiv (%e^x + x, x)</code> returns <code>false</code>.
On the other hand <code>zeroequiv (log(a*b) - log(a) - log(b), a)</code> returns <code>dontknow</code> because
of the presence of an extra parameter <code>b</code>.
</p>
</dd></dl>

<hr size="6">
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC14" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="maxima_6.html#SEC21" title="Next chapter"> &gt;&gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima.html#SEC_Top" title="Cover (top) of document">Top</a>]</td>
<td valign="middle" align="left">[<a href="maxima_toc.html#SEC_Contents" title="Table of contents">Contents</a>]</td>
<td valign="middle" align="left">[<a href="maxima_72.html#SEC264" title="Index">Index</a>]</td>
<td valign="middle" align="left">[<a href="maxima_abt.html#SEC_About" title="About (help)"> ? </a>]</td>
</tr></table>
<p>
 <font size="-1">
  This document was generated by <em>Robert Dodier</em> on <em>September, 20 2006</em> using <a href="http://texi2html.cvshome.org/"><em>texi2html 1.76</em></a>.
 </font>
 <br>

</p>
</body>
</html>