File: maxima_4.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 (1213 lines) | stat: -rw-r--r-- 46,997 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: 4. Command Line</title>

<meta name="description" content="Maxima Manual: 4. Command Line">
<meta name="keywords" content="Maxima Manual: 4. Command Line">
<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="Command-Line"></a>
<a name="SEC11"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="maxima_3.html#SEC10" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC12" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="maxima_3.html#SEC5" 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_5.html#SEC14" 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"> 4. Command Line </h1>

<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top"><a href="#SEC12">4.1 Introduction to Command Line</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top"><a href="#SEC13">4.2 Definitions for Command Line</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>

<hr size="6">
<a name="Introduction-to-Command-Line"></a>
<a name="SEC12"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC11" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC13" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC11" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC11" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_5.html#SEC14" 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"> 4.1 Introduction to Command Line </h2>

<dl>
<dt><u>Operator:</u> <b>'</b>
<a name="IDX12"></a>
</dt>
<dd><p>The single quote operator <code>'</code> prevents evaluation.
</p>
<p>Applied to a symbol,
the single quote prevents evaluation of the symbol.
</p>
<p>Applied to a function call,
the single quote prevents evaluation of the function call,
although the arguments of the function are still evaluated (if evaluation is not otherwise prevented).
The result is the noun form of the function call.
</p>
<p>Applied to a parenthesized expression,
the single quote prevents evaluation of all symbols and function calls in the expression.
E.g., <code>'(f(x))</code> means do not evaluate the expression <code>f(x)</code>.
<code>'f(x)</code> (with the single quote applied to <code>f</code> instead of <code>f(x)</code>)
means return the noun form of <code>f</code> applied to <code>[x]</code>.
</p>
<p>The single quote does not prevent simplification.
</p>
<p>When the global flag <code>noundisp</code> is <code>true</code>,
nouns display with a single quote.
This switch is always <code>true</code> when displaying function definitions.
</p>
<p>See also the quote-quote operator <code>''</code> and <code>nouns</code>.
</p>
<p>Examples:
</p>
<p>Applied to a symbol,
the single quote prevents evaluation of the symbol.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) aa: 1024;
(%o1)                         1024
(%i2) aa^2;
(%o2)                        1048576
(%i3) 'aa^2;
                                 2
(%o3)                          aa
(%i4) ''%;
(%o4)                        1048576
</pre></td></tr></table>
<p>Applied to a function call,
the single quote prevents evaluation of the function call.
The result is the noun form of the function call.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x0: 5;
(%o1)                           5
(%i2) x1: 7;
(%o2)                           7
(%i3) integrate (x^2, x, x0, x1);
                               218
(%o3)                          ---
                                3
(%i4) 'integrate (x^2, x, x0, x1);
                             7
                            /
                            [   2
(%o4)                       I  x  dx
                            ]
                            /
                             5
(%i5) %, nouns;
                               218
(%o5)                          ---
                                3
</pre></td></tr></table>
<p>Applied to a parenthesized expression,
the single quote prevents evaluation of all symbols and function calls in the expression.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) aa: 1024;
(%o1)                         1024
(%i2) bb: 19;
(%o2)                          19
(%i3) sqrt(aa) + bb;
(%o3)                          51
(%i4) '(sqrt(aa) + bb);
(%o4)                     bb + sqrt(aa)
(%i5) ''%;
(%o5)                          51
</pre></td></tr></table>
<p>The single quote does not prevent simplification.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sin (17 * %pi) + cos (17 * %pi);
(%o1)                          - 1
(%i2) '(sin (17 * %pi) + cos (17 * %pi));
(%o2)                          - 1
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Operator:</u> <b>&quot;</b>
<a name="IDX13"></a>
</dt>
<dd><p>The quote-quote operator <code>''</code> (two single quote marks) modifies evaluation in input expressions.
</p>
<p>Applied to a general expression <var>expr</var>, quote-quote causes the value of <var>expr</var>
to be substituted for <var>expr</var> in the input expression.
</p>
<p>Applied to the operator of an expression,
quote-quote changes the operator from a noun to a verb (if it is not already a verb).
</p>
<p>The quote-quote operator is applied by the input parser;
it is not stored as part of a parsed input expression.
The quote-quote operator is always applied as soon as it is parsed,
and cannot be quoted.
Thus quote-quote causes evaluation when evaluation is otherwise suppressed,
such as in function definitions, lambda expressions, and expressions quoted by single quote <code>'</code>.
</p>
<p>Quote-quote is recognized by <code>batch</code> and <code>load</code>.
</p>
<p>See also the single-quote operator <code>'</code> and <code>nouns</code>.
</p>
<p>Examples:
</p>
<p>Applied to a general expression <var>expr</var>, quote-quote causes the value of <var>expr</var>
to be substituted for <var>expr</var> in the input expression.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) expand ((a + b)^3);
                     3        2      2      3
(%o1)               b  + 3 a b  + 3 a  b + a
(%i2) [_, ''_];
                         3    3        2      2      3
(%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
(%i3) [%i1, ''%i1];
                         3    3        2      2      3
(%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
(%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
(%o4)                   [cc, dd, 17, 29]
(%i5) foo_1 (x) := aa - bb * x;
(%o5)                 foo_1(x) := aa - bb x
(%i6) foo_1 (10);
(%o6)                      cc - 10 dd
(%i7) ''%;
(%o7)                         - 273
(%i8) ''(foo_1 (10));
(%o8)                         - 273
(%i9) foo_2 (x) := ''aa - ''bb * x;
(%o9)                 foo_2(x) := cc - dd x
(%i10) foo_2 (10);
(%o10)                        - 273
(%i11) [x0 : x1, x1 : x2, x2 : x3];
(%o11)                    [x1, x2, x3]
(%i12) x0;
(%o12)                         x1
(%i13) ''x0;
(%o13)                         x2
(%i14) '' ''x0;
(%o14)                         x3
</pre></td></tr></table>
<p>Applied to the operator of an expression,
quote-quote changes the operator from a noun to a verb (if it is not already a verb).
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sin (1);
(%o1)                        sin(1)
(%i2) ''sin (1);
(%o2)                    0.8414709848079
(%i3) declare (foo, noun);
(%o3)                         done
(%i4) foo (x) := x - 1729;
(%o4)                 ''foo(x) := x - 1729
(%i5) foo (100);
(%o5)                       foo(100)
(%i6) ''foo (100);
(%o6)                        - 1629
</pre></td></tr></table>
<p>The quote-quote operator is applied by the input parser;
it is not stored as part of a parsed input expression.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
(%o1)                 [bb, dd, 1234, 5678]
(%i2) aa + cc;
(%o2)                        dd + bb
(%i3) display (_, op (_), args (_));
                           _ = cc + aa

                         op(cc + aa) = +

                    args(cc + aa) = [cc, aa]

(%o3)                         done
(%i4) ''(aa + cc);
(%o4)                         6912
(%i5) display (_, op (_), args (_));
                           _ = dd + bb

                         op(dd + bb) = +

                    args(dd + bb) = [dd, bb]

(%o5)                         done
</pre></td></tr></table>
<p>Quote-quote causes evaluation when evaluation is otherwise suppressed,
such as in function definitions, lambda expressions, and expressions quoted by single quote <code>'</code>.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) foo_1a (x) := ''(integrate (log (x), x));
(%o1)               foo_1a(x) := x log(x) - x
(%i2) foo_1b (x) := integrate (log (x), x);
(%o2)           foo_1b(x) := integrate(log(x), x)
(%i3) dispfun (foo_1a, foo_1b);
(%t3)               foo_1a(x) := x log(x) - x

(%t4)           foo_1b(x) := integrate(log(x), x)

(%o4)                      [%t3, %t4]
(%i4) integrate (log (x), x);
(%o4)                     x log(x) - x
(%i5) foo_2a (x) := ''%;
(%o5)               foo_2a(x) := x log(x) - x
(%i6) foo_2b (x) := %;
(%o6)                    foo_2b(x) := %
(%i7) dispfun (foo_2a, foo_2b);
(%t7)               foo_2a(x) := x log(x) - x

(%t8)                    foo_2b(x) := %

(%o8)                      [%t7, %t8]
(%i8) F : lambda ([u], diff (sin (u), u));
(%o8)             lambda([u], diff(sin(u), u))
(%i9) G : lambda ([u], ''(diff (sin (u), u)));
(%o9)                  lambda([u], cos(u))
(%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
(%o10)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                    k                  k
(%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
(%o11)             b  + a  + b  + a  + b  + a
                    3    3    2    2    1    1
</pre></td></tr></table>
</dd></dl>

<hr size="6">
<a name="Definitions-for-Command-Line"></a>
<a name="SEC13"></a>
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC12" title="Previous section in reading order"> &lt; </a>]</td>
<td valign="middle" align="left">[<a href="maxima_5.html#SEC14" title="Next section in reading order"> &gt; </a>]</td>
<td valign="middle" align="left"> &nbsp; </td>
<td valign="middle" align="left">[<a href="#SEC11" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="#SEC11" title="Up section"> Up </a>]</td>
<td valign="middle" align="left">[<a href="maxima_5.html#SEC14" 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"> 4.2 Definitions for Command Line </h2>

<dl>
<dt><u>Function:</u> <b>alias</b><i> (<var>new_name_1</var>, <var>old_name_1</var>, ..., <var>new_name_n</var>, <var>old_name_n</var>)</i>
<a name="IDX14"></a>
</dt>
<dd><p>provides an
alternate name for a (user or system) function, variable, array, etc.
Any even number of arguments may be used.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>debugmode</b>
<a name="IDX15"></a>
</dt>
<dd><p>Default value: <code>false</code>
</p>
<p>When a Maxima error occurs, Maxima will start the debugger if <code>debugmode</code> is <code>true</code>.
The user may enter commands to examine the call stack, set breakpoints, step
through Maxima code, and so on. See <code>debugging</code> for a list of debugger commands.
</p>
<p>Enabling <code>debugmode</code> will not catch Lisp errors.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>ev</b><i> (<var>expr</var>, <var>arg_1</var>, ..., <var>arg_n</var>)</i>
<a name="IDX16"></a>
</dt>
<dd><p>Evaluates the expression <var>expr</var> in the environment
specified by the arguments <var>arg_1</var>, ..., <var>arg_n</var>.
The arguments are switches (Boolean flags), assignments, equations, and functions.
<code>ev</code> returns the result (another expression) of the evaluation.
</p>
<p>The evaluation is carried out in steps, as follows.
</p>
<ol>
<li>
First the environment is set up by scanning the arguments which may
be any or all of the following.

<ul>
<li>
<code>simp</code> causes <var>expr</var> to be simplified regardless of the setting of the
switch <code>simp</code> which inhibits simplification if <code>false</code>.
</li><li>
<code>noeval</code> supresses the evaluation phase of <code>ev</code> (see step (4) below).
This is useful in conjunction with the other switches and in causing
<var>expr</var> to be resimplified without being reevaluated.
</li><li>
<code>nouns</code> causes the evaluation of noun forms
(typically unevaluated functions such as <code>'integrate</code> or <code>'diff</code>)
in <var>expr</var>.
</li><li>
<code>expand</code> causes expansion.
</li><li>
<code>expand (<var>m</var>, <var>n</var>)</code> causes expansion, setting the values of <code>maxposex</code> and
<code>maxnegex</code> to <var>m</var> and <var>n</var> respectively.
</li><li>
<code>detout</code> causes any matrix inverses computed in <var>expr</var> to have their
determinant kept outside of the inverse rather than dividing through
each element.
</li><li>
<code>diff</code> causes all differentiations indicated in <var>expr</var> to be performed.
</li><li>
<code>derivlist (<var>x</var>, <var>y</var>, <var>z</var>, ...)</code> causes only differentiations with respect to
the indicated variables.
</li><li>
<code>float</code> causes non-integral rational numbers to be converted to floating
point.
</li><li>
<code>numer</code> causes some mathematical functions (including exponentiation)
with numerical arguments to be evaluated in floating point.  It causes
variables in <var>expr</var> which have been given numervals to be replaced by
their values.  It also sets the <code>float</code> switch on.
</li><li>
<code>pred</code> causes predicates (expressions which evaluate to <code>true</code> or <code>false</code>)
to be evaluated.
</li><li>
<code>eval</code> causes an extra post-evaluation of <var>expr</var> to occur. (See step (5)
below.)
<code>eval</code> may occur multiple times.
For each instance of <code>eval</code>, the expression is evaluated again.
</li><li>
<code>A</code> where <code>A</code> is an atom declared to be an evaluation flag (see <code>evflag</code>)
causes <code>A</code> to be bound to
<code>true</code> during the evaluation of <var>expr</var>.
</li><li>
<code>V: expression</code> (or alternately <code>V=expression</code>) causes <code>V</code> to be bound to the
value of <code>expression</code> during the evaluation of <var>expr</var>.  Note that if <code>V</code> is a
Maxima option, then <code>expression</code> is used for its value during the
evaluation of <var>expr</var>.  If more than one argument to <code>ev</code> is of this type
then the binding is done in parallel.  If <code>V</code> is a non-atomic expression
then a substitution rather than a binding is performed.
</li><li>
<code>F</code> where <code>F</code>, a function name, has been declared to be an evaluation function (see <code>evfun</code>)
causes <code>F</code>
to be applied to <var>expr</var>.
</li><li>
Any other function names (e.g., <code>sum</code>) cause evaluation of occurrences
of those names in <var>expr</var> as though they were verbs.
</li><li>
In addition a function occurring in <var>expr</var> (say <code>F(x)</code>) may be defined
locally for the purpose of this evaluation of <var>expr</var> by giving
<code>F(x) := expression</code> as an argument to <code>ev</code>.
</li><li>
If an atom not mentioned above or a subscripted variable or
subscripted expression was given as an argument, it is evaluated and
if the result is an equation or assignment then the indicated binding
or substitution is performed.  If the result is a list then the
members of the list are treated as if they were additional arguments
given to <code>ev</code>. This permits a list of equations to be given (e.g. <code>[X=1, Y=A**2]</code>)
or a list of names of equations (e.g., <code>[%t1, %t2]</code> where <code>%t1</code> and
<code>%t2</code> are equations) such as that returned by <code>solve</code>.
</li></ul>

<p>The arguments of <code>ev</code> may be given in any order with the exception of
substitution equations which are handled in sequence, left to right,
and evaluation functions which are composed, e.g., <code>ev (<var>expr</var>, ratsimp, realpart)</code> is
handled as <code>realpart (ratsimp (<var>expr</var>))</code>.
</p>
<p>The <code>simp</code>, <code>numer</code>, <code>float</code>, and <code>pred</code> switches may also be set locally in a
block, or globally in Maxima so that they will
remain in effect until being reset.
</p>
<p>If <var>expr</var> is a canonical rational expression (CRE),
then the expression returned by <code>ev</code> is also a CRE,
provided the <code>numer</code> and <code>float</code> switches are not both <code>true</code>.
</p>
</li><li>
During step (1), a list is made of the non-subscripted
variables appearing on the left side of equations in the arguments or in
the value of some arguments if the value is an equation.  The variables
(subscripted variables which do not have associated array
functions as well as non-subscripted variables) in the expression <var>expr</var> are
replaced by their global values, except for those appearing in this
list.  Usually, <var>expr</var> is just a label or <code>%</code>
(as in <code>%i2</code> in the example below), so this
step simply retrieves the expression named by the label, so that <code>ev</code>
may work on it.

</li><li>
If any substitutions are indicated by the arguments, they are
carried out now.

</li><li>
The resulting expression is then re-evaluated (unless one of
the arguments was <code>noeval</code>) and simplified according to the arguments.  Note that
any function calls in <var>expr</var> will be carried out after the variables in
it are evaluated and that <code>ev(F(x))</code> thus may behave like <code>F(ev(x))</code>.

</li><li>
For each instance of <code>eval</code> in the arguments, steps (3) and (4) are repeated.
</li></ol>

<p>                     Examples
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                     d                    2
(%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                     dw
(%i2) ev (%, sin, expand, diff, x=2, y=1);
                          2
(%o2)           cos(w) + w  + 2 w + cos(1) + 1.909297426825682
</pre></td></tr></table>
<p>An alternate top level syntax has been provided for <code>ev</code>, whereby one
may just type in its arguments, without the <code>ev()</code>.  That is, one may
write simply
</p>
<table><tr><td>&nbsp;</td><td><pre class="example"><var>expr</var>, <var>arg_1</var>, ..., <var>arg_n</var>
</pre></td></tr></table>
<p>This is not permitted as part of
another expression, e.g., in functions, blocks, etc.
</p>
<p>Notice the parallel binding process in the following example.
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i3) programmode: false;
(%o3)                                false
(%i4) x+y, x: a+y, y: 2;
(%o4)                              y + a + 2
(%i5) 2*x - 3*y = 3$
(%i6) -3*x + 2*y = -4$
(%i7) solve ([%o5, %o6]);
Solution

                                          1
(%t7)                               y = - -
                                          5

                                         6
(%t8)                                x = -
                                         5
(%o8)                            [[%t7, %t8]]
(%i8) %o6, %o8;
(%o8)                              - 4 = - 4
(%i9) x + 1/x &gt; gamma (1/2);
                                   1
(%o9)                          x + - &gt; sqrt(%pi)
                                   x
(%i10) %, numer, x=1/2;
(%o10)                      2.5 &gt; 1.772453850905516
(%i11) %, pred;
(%o11)                               true
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Property:</u> <b>evflag</b>
<a name="IDX17"></a>
</dt>
<dd><p>When a symbol <var>x</var> has the <code>evflag</code> property,
the expressions <code>ev(<var>expr</var>, <var>x</var>)</code> and <code><var>expr</var>, <var>x</var></code>
(at the interactive prompt) are equivalent to <code>ev(<var>expr</var>, <var>x</var> = true)</code>.
That is, <var>x</var> is bound to <code>true</code> while <var>expr</var> is evaluated.
</p>
<p>The expression <code>declare(<var>x</var>, evflag)</code>
gives the <code>evflag</code> property to the variable <var>x</var>.
</p>
<p>The flags which have the <code>evflag</code> property by default are the following:
<code>algebraic</code>,
<code>cauchysum</code>,
<code>demoivre</code>,
<code>dotscrules</code>,
<code>%emode</code>,
<code>%enumer</code>,
<code>exponentialize</code>,
<code>exptisolate</code>,
<code>factorflag</code>,
<code>float</code>,
<code>halfangles</code>,
<code>infeval</code>,
<code>isolate_wrt_times</code>,
<code>keepfloat</code>,
<code>letrat</code>,
<code>listarith</code>,
<code>logabs</code>,
<code>logarc</code>,
<code>logexpand</code>,
<code>lognegint</code>,
<code>lognumer</code>,
<code>m1pbranch</code>,
<code>numer_pbranch</code>,
<code>programmode</code>,
<code>radexpand</code>,
<code>ratalgdenom</code>,
<code>ratfac</code>,
<code>ratmx</code>,
<code>ratsimpexpons</code>,
<code>simp</code>,
<code>simpsum</code>,
<code>sumexpand</code>, and
<code>trigexpand</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) sin (1/2);
                                 1
(%o1)                        sin(-)
                                 2
(%i2) sin (1/2), float;
(%o2)                   0.479425538604203
(%i3) sin (1/2), float=true;
(%o3)                   0.479425538604203
(%i4) simp : false;
(%o4)                         false
(%i5) 1 + 1;
(%o5)                         1 + 1
(%i6) 1 + 1, simp;
(%o6)                           2
(%i7) simp : true;
(%o7)                         true
(%i8) sum (1/k^2, k, 1, inf);
                            inf
                            ====
                            \     1
(%o8)                        &gt;    --
                            /      2
                            ====  k
                            k = 1
(%i9) sum (1/k^2, k, 1, inf), simpsum;
                                 2
                              %pi
(%o9)                         ----
                               6
(%i10) declare (aa, evflag);
(%o10)                        done
(%i11) if aa = true then YES else NO;
(%o11)                         NO
(%i12) if aa = true then YES else NO, aa;
(%o12)                         YES
</pre></td></tr></table>
</dd></dl>

<dl>
<dt><u>Property:</u> <b>evfun</b>
<a name="IDX18"></a>
</dt>
<dd><p>When a function <var>F</var> has the <code>evfun</code> property,
the expressions <code>ev(<var>expr</var>, <var>F</var>)</code> and <code><var>expr</var>, <var>F</var></code>
(at the interactive prompt)
are equivalent to <code><var>F</var>(ev(<var>expr</var>))</code>.
</p>
<p>If two or more <code>evfun</code> functions <var>F</var>, <var>G</var>, etc., are specified,
the functions are applied in the order that they are specified.
</p>
<p>The expression <code>declare(<var>F</var>, evfun)</code>
gives the <code>evfun</code> property to the function <var>F</var>.
</p>
<p>The functions which have the <code>evfun</code> property by default are the following:
<code>bfloat</code>,
<code>factor</code>,
<code>fullratsimp</code>,
<code>logcontract</code>,
<code>polarform</code>,
<code>radcan</code>,
<code>ratexpand</code>,
<code>ratsimp</code>,
<code>rectform</code>,
<code>rootscontract</code>,
<code>trigexpand</code>, and
<code>trigreduce</code>.
</p>
<p>Examples:
</p>
<table><tr><td>&nbsp;</td><td><pre class="example">(%i1) x^3 - 1;
                              3
(%o1)                        x  - 1
(%i2) x^3 - 1, factor;
                                2
(%o2)                 (x - 1) (x  + x + 1)
(%i3) factor (x^3 - 1);
                                2
(%o3)                 (x - 1) (x  + x + 1)
(%i4) cos(4 * x) / sin(x)^4;
                            cos(4 x)
(%o4)                       --------
                               4
                            sin (x)
(%i5) cos(4 * x) / sin(x)^4, trigexpand;
                 4           2       2         4
              sin (x) - 6 cos (x) sin (x) + cos (x)
(%o5)         -------------------------------------
                                4
                             sin (x)
(%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                           2         4
                      6 cos (x)   cos (x)
(%o6)               - --------- + ------- + 1
                          2          4
                       sin (x)    sin (x)
(%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                           2         4
                      6 cos (x)   cos (x)
(%o7)               - --------- + ------- + 1
                          2          4
                       sin (x)    sin (x)
(%i8) declare ([F, G], evfun);
(%o8)                         done
(%i9) (aa : bb, bb : cc, cc : dd);
(%o9)                          dd
(%i10) aa;
(%o10)                         bb
(%i11) aa, F;
(%o11)                        F(cc)
(%i12) F (aa);
(%o12)                        F(bb)
(%i13) F (ev (aa));
(%o13)                        F(cc)
(%i14) aa, F, G;
(%o14)                      G(F(cc))
(%i15) G (F (ev (aa)));
(%o15)                      G(F(cc))
</pre></td></tr></table>
</dd></dl>
<dl>
<dt><u>Option variable:</u> <b>infeval</b>
<a name="IDX19"></a>
</dt>
<dd><p>Enables &quot;infinite evaluation&quot; mode.  <code>ev</code> repeatedly
evaluates an expression until it stops changing.  To prevent a
variable, say <code>X</code>, from being evaluated away in this mode, simply
include <code>X='X</code> as an argument to <code>ev</code>.  Of course expressions such as
<code>ev (X, X=X+1, infeval)</code> will generate an infinite loop.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>kill</b><i> (<var>a_1</var>, ..., <var>a_n</var>)</i>
<a name="IDX20"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (labels)</i>
<a name="IDX21"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (inlabels, outlabels, linelabels)</i>
<a name="IDX22"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (<var>n</var>)</i>
<a name="IDX23"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> ([<var>m</var>, <var>n</var>])</i>
<a name="IDX24"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (values, functions, arrays, ...)</i>
<a name="IDX25"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (all)</i>
<a name="IDX26"></a>
</dt>
<dt><u>Function:</u> <b>kill</b><i> (allbut (<var>a_1</var>, ..., <var>a_n</var>))</i>
<a name="IDX27"></a>
</dt>
<dd><p>Removes all bindings (value, function, array, or rule) from the arguments
<var>a_1</var>, ..., <var>a_n</var>.
An argument <var>a_k</var> may be a symbol or a single array element.
When <var>a_k</var> is a single array element, <code>kill</code> unbinds that element
without affecting any other elements of the array.
</p>
<p>Several special arguments are recognized.
Different kinds of arguments
may be combined, e.g., <code>kill (inlabels, functions, allbut (foo, bar))</code>.
</p>
<p><code>kill (labels)</code> unbinds
all input, output, and intermediate expression labels created so far.
<code>kill (inlabels)</code> unbinds only input labels
which begin with the current value of <code>inchar</code>.
Likewise,
<code>kill (outlabels)</code> unbinds only output labels
which begin with the current value of <code>outchar</code>,
and <code>kill (linelabels)</code> unbinds only intermediate expression labels
which begin with the current value of <code>linechar</code>.
</p>
<p><code>kill (<var>n</var>)</code>, where <var>n</var> is an integer,
unbinds the <var>n</var> most recent input and output labels.
</p>
<p><code>kill ([<var>m</var>, <var>n</var>])</code> unbinds input and output labels <var>m</var> through <var>n</var>.
</p>
<p><code>kill (<var>infolist</var>)</code>, where <var>infolist</var> is any item in <code>infolists</code>
(such as <code>values</code>, <code>functions</code>, or <code>arrays</code>)
unbinds all items in <var>infolist</var>.
See also <code>infolists</code>.
</p>
<p><code>kill (all)</code> unbinds all items on all infolists.
<code>kill (all)</code> does not reset global variables to their default values;
see <code>reset</code> on this point.
</p>
<p><code>kill (allbut (<var>a_1</var>, ..., <var>a_n</var>))</code>
unbinds all items on all infolists except for <var>a_1</var>, ..., <var>a_n</var>.
<code>kill (allbut (<var>infolist</var>))</code> unbinds all items except for the ones on <var>infolist</var>,
where <var>infolist</var> is <code>values</code>, <code>functions</code>, <code>arrays</code>, etc.
</p>
<p>The memory taken up by a bound property is not released until all symbols
are unbound from it.
In particular, to release the memory taken up by the value of a symbol,
one unbinds the output label which shows the bound value, as well as unbinding the symbol itself.
</p>
<p><code>kill</code> quotes its arguments.
The quote-quote operator <code>''</code> defeats quotation.
</p>
<p><code>kill (<var>symbol</var>)</code> unbinds all properties of <var>symbol</var>.
In contrast, <code>remvalue</code>, <code>remfunction</code>, <code>remarray</code>, and <code>remrule</code>
unbind a specific property.
</p>
<p><code>kill</code> always returns <code>done</code>, even if an argument has no binding.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>labels</b><i> (<var>symbol</var>)</i>
<a name="IDX28"></a>
</dt>
<dt><u>System variable:</u> <b>labels</b>
<a name="IDX29"></a>
</dt>
<dd><p>Returns the list of input, output, or intermediate expression labels which begin with <var>symbol</var>.
Typically <var>symbol</var> is the value of <code>inchar</code>, <code>outchar</code>, or <code>linechar</code>.
The label character may be given with or without a percent sign,
so, for example, <code>i</code> and <code>%i</code> yield the same result.
</p>
<p>If no labels begin with <var>symbol</var>, <code>labels</code> returns an empty list.
</p>
<p>The function <code>labels</code> quotes its argument.
The quote-quote operator <code>''</code> defeats quotation.
For example,
<code>labels (''inchar)</code> returns the input labels which begin with the current input label character.
</p>
<p>The variable <code>labels</code> is the list of input, output, and intermediate expression labels,
including all previous labels if <code>inchar</code>, <code>outchar</code>, or <code>linechar</code> were redefined.
</p>
<p>By default, Maxima displays the result of each user input expression,
giving the result an output label.
The output display is suppressed by terminating the input with <code>$</code> (dollar sign)
instead of <code>;</code> (semicolon).
An output label is constructed and bound to the result, but not displayed,
and the label may be referenced in the same way as displayed output labels.
See also <code>%</code>, <code>%%</code>, and <code>%th</code>.
</p>
<p>Intermediate expression labels can be generated by some functions.
The flag <code>programmode</code> controls whether <code>solve</code> and some other functions
generate intermediate expression labels instead of returning a list of expressions.
Some other functions, such as <code>ldisplay</code>, always generate intermediate expression labels.
</p>
<p>See also <code>inchar</code>, <code>outchar</code>, <code>linechar</code>, and <code>infolists</code>.
</p>
</dd></dl>

<dl>
<dt><u>System variable:</u> <b>linenum</b>
<a name="IDX30"></a>
</dt>
<dd><p>The line number of the current pair of input and output expressions.
</p>
</dd></dl>

<dl>
<dt><u>System variable:</u> <b>myoptions</b>
<a name="IDX31"></a>
</dt>
<dd><p>Default value: <code>[]</code>
</p>
<p><code>myoptions</code> is the list of all options ever reset by the user,
whether or not they get reset to their default value.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>nolabels</b>
<a name="IDX32"></a>
</dt>
<dd><p>Default value: <code>false</code>
</p>
<p>When <code>nolabels</code> is <code>true</code>,
input and output result labels
(<code>%i</code> and <code>%o</code>, respectively)
are displayed,
but the labels are not bound to results,
and the labels are not appended to the <code>labels</code> list.
Since labels are not bound to results,
garbage collection can recover the memory taken up by the results.
</p>
<p>Otherwise input and output result labels are bound to results,
and the labels are appended to the <code>labels</code> list.
</p>
<p>Intermediate expression labels (<code>%t</code>) are not affected by <code>nolabels</code>;
whether <code>nolabels</code> is <code>true</code> or <code>false</code>,
intermediate expression labels are bound and appended to the <code>labels</code> list.
</p>
<p>See also <code>batch</code>, <code>load</code>, and <code>labels</code>.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>optionset</b>
<a name="IDX33"></a>
</dt>
<dd><p>Default value: <code>false</code>
</p>
<p>When <code>optionset</code> is <code>true</code>, Maxima prints out a
message whenever a Maxima option is reset.  This is useful if the
user is doubtful of the spelling of some option and wants to make sure
that the variable he assigned a value to was truly an option variable.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>playback</b><i> ()</i>
<a name="IDX34"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> (<var>n</var>)</i>
<a name="IDX35"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> ([<var>m</var>, <var>n</var>])</i>
<a name="IDX36"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> ([<var>m</var>])</i>
<a name="IDX37"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> (input)</i>
<a name="IDX38"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> (slow)</i>
<a name="IDX39"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> (time)</i>
<a name="IDX40"></a>
</dt>
<dt><u>Function:</u> <b>playback</b><i> (grind)</i>
<a name="IDX41"></a>
</dt>
<dd><p>Displays input, output, and intermediate expressions,
without recomputing them.
<code>playback</code> only displays the expressions bound to labels;
any other output (such as text printed by <code>print</code> or <code>describe</code>, or error messages)
is not displayed.
See also <code>labels</code>.
</p>
<p><code>playback</code> quotes its arguments.
The quote-quote operator <code>''</code> defeats quotation.
<code>playback</code> always returns <code>done</code>.
</p>
<p><code>playback ()</code> (with no arguments) displays all input, output, and intermediate expressions
generated so far.
An output expression is displayed even if it was suppressed by the <code>$</code> terminator
when it was originally computed.
</p>
<p><code>playback (<var>n</var>)</code> displays the most recent <var>n</var> expressions.
Each input, output, and intermediate expression counts as one.
</p>
<p><code>playback ([<var>m</var>, <var>n</var>])</code> displays input, output, and intermediate expressions
with numbers from <var>m</var> through <var>n</var>, inclusive.
</p>
<p><code>playback ([<var>m</var>])</code> is equivalent to <code>playback ([<var>m</var>, <var>m</var>])</code>;
this usually prints one pair of input and output expressions.
</p>
<p><code>playback (input)</code> displays all input expressions generated so far.
</p>
<p><code>playback (slow)</code> pauses between expressions
and waits for the user to press <code>enter</code>.
This behavior is similar to <code>demo</code>.
<code>playback (slow)</code> is useful in conjunction with <code>save</code> or <code>stringout</code>
when creating a secondary-storage file in order to pick out useful expressions.
</p>
<p><code>playback (time)</code> displays the computation time for each expression.
</p>
<p><code>playback (grind)</code> displays input expressions
in the same format as the <code>grind</code> function.
Output expressions are not affected by the <code>grind</code> option.
See <code>grind</code>.
</p>
<p>Arguments may be combined, e.g.,
<code>playback ([5, 10], grind, time, slow)</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>printprops</b><i> (<var>a</var>, <var>i</var>)</i>
<a name="IDX42"></a>
</dt>
<dt><u>Function:</u> <b>printprops</b><i> ([<var>a_1</var>, ..., <var>a_n</var>], <var>i</var>)</i>
<a name="IDX43"></a>
</dt>
<dt><u>Function:</u> <b>printprops</b><i> (all, <var>i</var>)</i>
<a name="IDX44"></a>
</dt>
<dd><p>Displays the property with the indicator <var>i</var>
associated with the atom <var>a</var>. <var>a</var> may also be a list of atoms or the atom
<code>all</code> in which case all of the atoms with the given property will be
used.  For example, <code>printprops ([f, g], atvalue)</code>.  <code>printprops</code> is for
properties that cannot otherwise be displayed, i.e. for
<code>atvalue</code>, <code>atomgrad</code>, <code>gradef</code>, and <code>matchdeclare</code>.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>prompt</b>
<a name="IDX45"></a>
</dt>
<dd><p>Default value: <code>_</code>
</p>
<p><code>prompt</code> is the prompt symbol of the <code>demo</code> function,
<code>playback (slow)</code> mode, and the Maxima break loop (as invoked by <code>break</code>).
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>quit</b><i> ()</i>
<a name="IDX46"></a>
</dt>
<dd><p>Terminates the Maxima session.
Note that the function must be invoked as <code>quit();</code> or <code>quit()$</code>,
not <code>quit</code> by itself.
</p>
<p>To stop a lengthy computation,
type <code>control-C</code>.
The default action is to return to the Maxima prompt.
If <code>*debugger-hook*</code> is <code>nil</code>,
<code>control-C</code> opens the Lisp debugger.
See also <code>debugging</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>remfunction</b><i> (<var>f_1</var>, ..., <var>f_n</var>)</i>
<a name="IDX47"></a>
</dt>
<dt><u>Function:</u> <b>remfunction</b><i> (all)</i>
<a name="IDX48"></a>
</dt>
<dd><p>Unbinds the function definitions of the symbols <var>f_1</var>, ..., <var>f_n</var>.
The arguments may be the names of ordinary functions (created by <code>:=</code> or <code>define</code>)
or macro functions (created by <code>::=</code>).
</p>
<p><code>remfunction (all)</code> unbinds all function definitions.
</p>
<p><code>remfunction</code> quotes its arguments.
</p>
<p><code>remfunction</code> returns a list of the symbols for which the function definition was unbound.
<code>false</code> is returned in place of any symbol for which there is no function definition.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>reset</b><i> ()</i>
<a name="IDX49"></a>
</dt>
<dd><p>Resets many global variables and options, and some other variables, to their default values.
</p>
<p><code>reset</code> processes the variables on the Lisp list <code>*variable-initial-values*</code>.
The Lisp macro <code>defmvar</code> puts variables on this list (among other actions).
Many, but not all, global variables and options are defined by <code>defmvar</code>,
and some variables defined by <code>defmvar</code> are not global variables or options.
</p>
</dd></dl>

<dl>
<dt><u>Option variable:</u> <b>showtime</b>
<a name="IDX50"></a>
</dt>
<dd><p>Default value: <code>false</code>
</p>
<p>When <code>showtime</code> is <code>true</code>, the computation time and elapsed time is
printed with each output expression.
</p>
<p>The computation time is always recorded,
so <code>time</code> and <code>playback</code> can display the computation time
even when <code>showtime</code> is <code>false</code>.
</p>
<p>See also <code>timer</code>.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>sstatus</b><i> (<var>feature</var>, <var>package</var>)</i>
<a name="IDX51"></a>
</dt>
<dd><p>Sets the status of <var>feature</var> in <var>package</var>.
After <code>sstatus (<var>feature</var>, <var>package</var>)</code> is executed,
<code>status (<var>feature</var>, <var>package</var>)</code> returns <code>true</code>.
This can be useful for package writers, to
keep track of what features they have loaded in.
</p>
</dd></dl>

<dl>
<dt><u>Function:</u> <b>to_lisp</b><i> ()</i>
<a name="IDX52"></a>
</dt>
<dd><p>Enters the Lisp system under Maxima. <code>(to-maxima)</code> returns to Maxima.
</p>
</dd></dl>

<dl>
<dt><u>System variable:</u> <b>values</b>
<a name="IDX53"></a>
</dt>
<dd><p>Initial value: <code>[]</code>
</p>
<p><code>values</code> is a list of all bound user variables (not Maxima options or switches).
The list comprises symbols bound by <code>:</code> , <code>::</code>, or <code>:=</code>.
</p>
</dd></dl>

<hr size="6">
<table cellpadding="1" cellspacing="1" border="0">
<tr><td valign="middle" align="left">[<a href="#SEC11" title="Beginning of this chapter or previous chapter"> &lt;&lt; </a>]</td>
<td valign="middle" align="left">[<a href="maxima_5.html#SEC14" 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>