File: maxima_41.html

package info (click to toggle)
maxima 5.47.0-9
links: PTS
area: main
in suites: forky, sid
size: 193,104 kB
sloc: lisp: 434,678; fortran: 14,665; tcl: 10,990; sh: 4,577; makefile: 2,763; ansic: 447; java: 328; python: 262; perl: 201; xml: 60; awk: 28; sed: 15; javascript: 2
file content (2102 lines) | stat: -rw-r--r-- 105,968 bytes
parent folder | download | duplicates (2)
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.1, http://www.gnu.org/software/texinfo/ -->
<head>
<title>Maxima Manual: Функции и переменные для ввода и вывода</title>

<meta name="description" content="Maxima Manual: Функции и переменные для ввода и вывода">
<meta name="keywords" content="Maxima Manual: Функции и переменные для ввода и вывода">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link href="maxima_toc.html#Top" rel="start" title="Top">
<link href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" rel="index" title="Указатель функций и переменных">
<link href="maxima_toc.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="maxima_38.html#g_t_0412_0432_043e_0434-_0438-_0432_044b_0432_043e_0434" rel="up" title="Ввод и вывод">
<link href="maxima_42.html#g_t_041a_043e_043d_0442_0435_043a_0441_0442_044b" rel="next" title="Контексты">
<link href="maxima_40.html#g_t_0424_0430_0439_043b_044b" rel="previous" title="Файлы">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
body {color: black; background: white;  margin-left: 8%; margin-right: 13%;
      font-family: "FreeSans", sans-serif}
h1 {font-size: 150%; font-family: "FreeSans", sans-serif}
h2 {font-size: 125%; font-family: "FreeSans", sans-serif}
h3 {font-size: 100%; font-family: "FreeSans", sans-serif}
a[href] {color: rgb(0,0,255); text-decoration: none;}
a[href]:hover {background: rgb(220,220,220);}
div.textbox {border: solid; border-width: thin; 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);}
pre.example {border: 1px solid rgb(180,180,180); padding-top: 1em;
    padding-bottom: 1em; padding-left: 1em; padding-right: 1em;
    background-color: rgb(238,238,255)}
div.spacerbox {border: none; padding-top: 2em; padding-bottom: 2em}
div.image {margin: 0; padding: 1em; text-align: center}
div.categorybox {border: 1px solid gray; padding-top: 1em; padding-bottom: 1em;
    padding-left: 1em; padding-right: 1em; background: rgb(247,242,220)}
img {max-width:80%; max-height: 80%; display: block; margin-left: auto; margin-right: auto}

-->
</style>

<link rel="icon" href="figures/favicon.ico">
<script src="https://polyfill.io/v3/polyfill.min.js?features=es6>"></script>
<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head>

<body lang="ru" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="g_t_0424_0443_043d_043a_0446_0438_0438-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0435-_0434_043b_044f-_0432_0432_043e_0434_0430-_0438-_0432_044b_0432_043e_0434_0430"></a>
<div class="header">
<p>
Previous: <a href="maxima_40.html#g_t_0424_0430_0439_043b_044b" accesskey="p" rel="previous">Файлы</a>, Up: <a href="maxima_38.html#g_t_0412_0432_043e_0434-_0438-_0432_044b_0432_043e_0434" accesskey="u" rel="up">Ввод и вывод</a> &nbsp; [<a href="maxima_toc.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" title="Index" rel="index">Index</a>]</p>
</div>
<a name="Funkcii-i-peremennye-dlya-vvoda-i-vyvoda"></a>
<h3 class="section">9.3 Функции и переменные для ввода и вывода</h3>

<a name="Item_003a-Input_002fdefvr_002f_005f_005f"></a><dl>
<dt><a name="index-_005f_005f"></a>Системная переменная: <strong>__</strong></dt>
<dd><p><code>__</code> - введенное выражение, обрабатываемое в данный момент.
То есть, пока вычисляется <var>expr</var>, <code>__</code> равно <var>expr</var>.
</p>
<p>Введенное выражение присваивается переменной <code>__</code> до упрощения или вычисления.
Однако, значение <code>__</code> упрощается (но не вычисляется) во время вывода.
</p>
<p><code>__</code> распознается функциями <code>batch</code> и <code>load</code>.
В файле, обрабатываемом с помощью <code>batch</code>, <code>__</code> означает то же самое,
что и в режиме диалога. Когда файл обрабатывается функцией <code>load</code>, <code>__</code>
имеет значения последнего, введенного в режиме диалога или пакетном файле, выражения.
<code>__</code> не принимает значения выражений, которые вводятся в обрабатываемом файле.
В частности, если <code>load (<var>filename</var>)</code> вызывается в режиме диалога, 
то во время выполнения файла <code>__</code> имеет значение <code>load(<var>filename</var>)</code>.
</p>
<p>См. также <code>_</code> и <code>%</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) print (&quot;I was called as&quot;, __);
I was called as print(I was called as, __) 
(%o1)              print(I was called as, __)
(%i2) foo (__);
(%o2)                     foo(foo(__))
(%i3) g (x) := (print (&quot;Current input expression =&quot;, __), 0);
(%o3) g(x) := (print(&quot;Current input expression =&quot;, __), 0)
(%i4) [aa : 1, bb : 2, cc : 3];
(%o4)                       [1, 2, 3]
(%i5) (aa + bb + cc)/(dd + ee + g(x));
                            cc + bb + aa
Current input expression = -------------- 
                           g(x) + ee + dd
                                6
(%o5)                        -------
                             ee + dd
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002f_005f"></a><dl>
<dt><a name="index-_005f"></a>Системная переменная: <strong>_</strong></dt>
<dd>
<p><code>_</code> - самое последнее из введенных выражений (таких как <code>%i1</code>, <code>%i2</code>, <code>%i3</code>, ...).
</p>
<p>Введенное выражение присваивается переменной <code>_</code> до упрощения или вычисления.
Однако, это значение упрощается (но не вычисляется) во время вывода.
</p>
<p><code>_</code> обрабатывается функциями <code>batch</code> и <code>load</code>. 
Во время обработки файла функцией <code>batch</code> переменная <code>_</code> означает то же, что и в
режиме диалога.
Когда файл обрабатывается функцией <code>load</code>, значение переменной <code>_</code> принимает
последнее вычисленное выражение, которое было введено в диалоговом режиме или пакетном файле.
Выражения, вводимые в обрабатываемом файле, не присваиваются переменной <code>_</code>.
</p>
<p>См. также <code>__</code> и <code>%</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) 13 + 29;
(%o1)                          42
(%i2) :lisp $_
((MPLUS) 13 29)
(%i2) _;
(%o2)                          42
(%i3) sin (%pi/2);
(%o3)                           1
(%i4) :lisp $_
((%SIN) ((MQUOTIENT) $%PI 2))
(%i4) _;
(%o4)                           1
(%i5) a: 13$
(%i6) b: 29$
(%i7) a + b;
(%o7)                          42
(%i8) :lisp $_
((MPLUS) $A $B)
(%i8) _;
(%o8)                         b + a
(%i9) a + b;
(%o9)                          42
(%i10) ev (_);
(%o10)                         42
</pre></div>






</dd></dl>

<a name="Item_003a-Input_002fdefvr_002f_0025"></a><dl>
<dt><a name="index-_0025"></a>Системная переменная: <strong>%</strong></dt>
<dd><p><code>%</code> - вывод (<code>%o1</code>, <code>%o2</code>, <code>o3</code>, ...) последнего обработанного
выражения, даже если он не выводится.
</p>
<p><code>%</code> обрабатывается командами <code>batch</code> и <code>load</code>.
В файле, обрабатываемом командой <code>batch</code>, <code>%</code> имеет то же значение, что и
в режиме диалога. В файле, обрабатываемого командой <code>load</code>, Значение <code>%</code> принимает
вывод последнего обработанного в диалоговом режиме выражения. Переменной <code>%</code> не присваивается
вывод выражений обрабатываемого файла.
</p>
<p>См. также <code>_</code>, <code>%%</code> и <code>%th</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002f_0025_0025"></a><dl>
<dt><a name="index-_0025_0025"></a>Системная переменная: <strong>%%</strong></dt>
<dd><p>В составных выражениях таких как <code>block</code>, <code>lambda</code>, или <code>(<var>s_1</var>, ..., <var>s_n</var>)</code>,
<code>%%</code> - значение предыдущего утверждения. К примеру выражения,
</p>
<div class="example">
<pre class="example">block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
block ([prev], prev: integrate (x^5, x),
               ev (prev, x=2) - ev (prev, x=1));
</pre></div>

<p>дадут один и тот же результат, то есть <code>21/2</code>.
</p>
<p>Составное выражение может быть частью другого составного выражения. И в случае простого утверждения,
и в случае, когда утверждение является составным выражением, <code>%%</code> принимает значение предыдущего утверждения.
К примеру,
</p>
<div class="example">
<pre class="example">block (block (a^n, %%*42), %%/6)
</pre></div>

<p>выдаст <code>7*a^n</code>.
</p>
<p>Внутри составного утверждения, значение <code>%%</code> можно проверить в диалоге
команды <code>break</code>. К примеру, следующее выражение
</p>
<div class="example">
<pre class="example">block (a: 42, break ())$
</pre></div>

<p>открывает диалог, в котором результатом ввода <code>%%;</code> будет <code>42</code>.
</p>
<p>В первом утверждении составного выражения или вне составного выражения
переменная <code>%%</code> не определена.
</p>
<p>Переменная <code>%%</code> распознается функциями <code>batch</code> и <code>load</code>,
и имеет то же значение, что и в режиме диалога.
</p>
<p>См. также <code>%</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002f_0025edispflag"></a><dl>
<dt><a name="index-_0025edispflag"></a>Управляющая переменная: <strong>%edispflag</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>%edispflag</code> установлена равной <code>true</code>, Maxima отображает <code>%e</code> отрицательной
степени. К примеру, <code>%e^-x</code> отображается как <code>1/%e^x</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002f_0025th"></a><dl>
<dt><a name="index-_0025th"></a>Функция: <strong>%th</strong> <em>(<var>i</var>)</em></dt>
<dd><p>Значение <var>i</var>-го предыдущего вывода. То есть, если следующим вычисленным выражением
будет вывод с номером <var>n</var>, то <code>%th (<var>m</var>)</code> примет значение вывода с номером (<var>n</var> - <var>m</var>).
</p>
<p><code>%th</code> полезна в пакетных <code>batch</code>-файлах или в ссылках на группу выведенных выражений.
К примеру,
</p>
<div class="example">
<pre class="example">block (s: 0, for i:1 thru 10 do s: s + %th (i))$
</pre></div>

<p>присвоит переменной <code>s</code> сумму последних десяти выведенных выражений.
</p>
<p><code>%th</code> обрабатывается функциями <code>batch</code> и <code>load</code>.
В файле, обрабатываемом функцией <code>batch</code>, <code>%th</code> означает то же, 
что и в режиме диалога. В файле, обрабатываемом командой <code>load</code>, 
<code>%th</code> ссылается на выведенные выражения, которые были вычислены последними в режиме диалога
или пакетном файле. <code>%th</code> не ссылается на выражения, выводимые в процессе работы <code>load</code>.
</p>
<p>См. также <code>%</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002f_003f"></a><dl>
<dt><a name="index-_003f"></a>Специальный символ: <strong>?</strong></dt>
<dd><p>Стоящий перед именем функции или переменной символ <code>?</code> означает что
это имя функции или переменной из Lisp, а не из Maxima.
К примеру, <code>?round</code> означает Lisp-функцию <code>ROUND</code>.
См. дополнительно <a href="maxima_4.html#Lisp-_0438-Maxima">Lisp и Maxima</a>.
</p>
<p>Запись <code>? word</code> (вопросительный знак и следующее за ним слово разделены пробелом)
эквивалентна записи <code>describe(&quot;word&quot;)</code>.
Вопросительный знак должен находиться в начале строки ввода, иначе он не определится
как запрос на документацию.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002f_003f_003f"></a><dl>
<dt><a name="index-_003f_003f"></a>Специальный символ: <strong>??</strong></dt>
<dd>
<p>Запись <code>?? word</code> (<code>??</code> и следующее за ним слово разделяются символом пробела)
эквивалентна записи <code>descrive(&quot;word&quot;, inexact)</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fabsboxchar"></a><dl>
<dt><a name="index-absboxchar"></a>Управляющая переменная: <strong>absboxchar</strong></dt>
<dd><p>Значение по умолчанию: <code>!</code>
</p>
<p>Символ <code>absboxchar</code> используется для изображения знака модуля вокруг, 
выражений, занимающих по высоте больше одной строчки.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002ffile_005foutput_005fappend"></a><dl>
<dt><a name="index-file_005foutput_005fappend"></a>Управляющая переменная: <strong>file_output_append</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p><code>file_output_append</code> управляет тем, будет ли вывод в функции добавляться в конец
или замещать содержимое выводимого файла.
Когда <code>file_output_append</code> равна <code>true</code>, такие функции добавляют вывод к файлу,
иначе выводимый файл переписывается заново.
</p>
<p>Функции <code>save</code>, <code>strungout</code> и <code>with_stdout</code> учитывают <code>file_output_append</code>.
Остальные функции, которые записываю выход во внешние файлы, не учитывают <code>file_output_append</code>.
В частности, графические и транслирующие функции всегда замещает содержимое выводимого файла, а
<code>tex</code> и <code>strungout</code> всегда дописываю в конец.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fappendfile"></a><dl>
<dt><a name="index-appendfile"></a>Функция: <strong>appendfile</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Добавляет копию консольного вывода в <var>filename</var>. 
<code>appendfile</code> работает так же как и <code>writefile</code>,
но отличие в том, что если файл существует, он всегда дописывается.
</p>
<p><code>closefile</code> закрывает трансляцию в файл открытый функциями <code>appendfile</code> или <code>writefile</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fbatch"></a><dl>
<dt><a name="index-batch"></a>Функция: <strong>batch</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Считывает выражения Maxima из <var>filename</var>, и обрабатывает их.
<code>batch</code> ищет <var>filename</var> в директориях списка <code>file_search_maxima</code>.
См. <code>file_search</code>.
</p>
<p><var>filename</var> содержит последовательность выражений Maxima,
завершающихся символами <code>;</code> или <code>$</code>.
Специальные переменная <code>%</code> и функция <code>%th</code>
ссылаются на предыдущие результаты внутри файла.
Файл может включать конструкции <code>:lisp</code>.
Символы пробела, табуляции и новой строки в файле игнорируются.
Подходящий входной файл может быть создан при помощи текстового редактора или 
функцией <code>stringout</code>.
</p>
<p><code>batch</code> считывает каждое входящее выражение из <var>filename</var>,
отображает его ввод в консоли,
вычисляет соответствующее выходящее выражение
и выводит его.
Входящим выражениям присваиваются входные метки, а выходящим &ndash; выходные.
<code>batch</code> вычисляет все входящие выражения файла до тех пор пока в них не
встретится ошибка.
Если запрашивается пользовательский ввод (к примеру, командами <code>asksign</code> или <code>askinteger</code>),
выполнение <code>batch</code> останавливается для сбора требуемого ввода и затем продолжается.
</p>
<p>Возможна остановка <code>batch</code> нажатием <code>control-C</code> в консоли.
Эффект нажатия <code>control-C</code> зависит от реализации лежащего в основе Lisp.
</p>
<p><code>batch</code> может использоваться в различных целях.
Для хранения рабочих командных строк, дающих возможность проводить демонстрации без ошибок,
или может помочь организовать работу над решением сложных задач.
</p>
<p><code>batch</code> вычисляет свой аргумент.
<code>batch</code> не возвращает значений.
</p>
<p>См. также <code>load</code>, <code>batchload</code> и <code>demo</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fbatchload"></a><dl>
<dt><a name="index-batchload"></a>Функция: <strong>batchload</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Считывает выражения Maxima из <var>filename</var> и вычисляет их,
не отображая входные и выходные выражения и не присваивая ссылок
выходным выражениям.
Однако, печатаемый вывод (такой, какой производят команды <code>print</code> или <code>describe</code>)
отображается.
</p>
<p>Специальная переменная <code>%</code> и функция <code>%th</code>
ссылается на предыдущие результаты из режима диалога, но не на результаты
внутри файла.
Файл не может включать конструкции <code>:lisp</code>.
</p>
<p><code>batchload</code> возвращает путь к <var>filename</var> в виде строки.
<code>batchload</code> вычисляет свой аргумент.
</p>
<p>См. также <code>batch</code> и <code>load</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fclosefile"></a><dl>
<dt><a name="index-closefile"></a>Функция: <strong>closefile</strong> <em>()</em></dt>
<dd><p>Закрывает запись в файл, открытую командой <code>writefile</code> или <code>appendfile</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fcollapse"></a><dl>
<dt><a name="index-collapse"></a>Функция: <strong>collapse</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Сворачивает выражение <var>expr</var> делая все его общие (т.е. равные)
ссылающимися на одни ячейки памяти, тем самым сохраняя память.
Функция (<code>collapse</code> используется командой <code>optimize</code>.
Таким образом, вызов <code>collapse</code> может быть полезным до выгрузки в <code>save</code> файл. 
Можно свернуть несколько выражений вместе используя команду  
<code>collapse ([<var>expr_1</var>, ..., <var>expr_n</var>])</code>.  
Аналогично, можно свернуть элементы массива <code>A</code> 
при помощи команды <code>collapse (listarray ('A))</code>.
</p>



</dd></dl>

<a name="concat"></a><a name="Item_003a-Input_002fdeffn_002fconcat"></a><dl>
<dt><a name="index-concat"></a>Функция: <strong>concat</strong> <em>(<var>arg_1</var>, <var>arg_2</var>, ...)</em></dt>
<dd><p>Сцепляет свои аргументы. Аргументы должны быть атомами.
Возвращаемое значение является символом, если первый аргумент &ndash; символ, и строкой
в противном случае.
</p>
<p><code>concat</code> вычисляет свои аргументы.
Одиночная кавычка <code>'</code> предотвращает вычисление.
</p>
<div class="example">
<pre class="example">(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3)                          744
(%i4) concat ('y, z/2);
(%o4)                          y44
</pre></div>

<p>Символу, полученному с помощью <code>concat</code>, можно присваивать значения
и использовать его в выражениях.
<code>::</code> (двойное двоеточие) &ndash; оператор присваивания, который вычисляет свой левый операнд.
</p>
<div class="example">
<pre class="example">(%i5) a: concat ('y, z/2);
(%o5)                          y44
(%i6) a:: 123;
(%o6)                          123
(%i7) y44;
(%o7)                          123
(%i8) b^a;
                               y44
(%o8)                         b
(%i9) %, numer;
                               123
(%o9)                         b
</pre></div>

<p>Заметьте, что несмотря на то, что <code>concat (1, 2)</code> выглядит как число, результат является строкой.
</p>
<div class="example">
<pre class="example">(%i10) concat (1, 2) + 3;
(%o10)                       12 + 3
</pre></div>






</dd></dl>

<a name="sconcat"></a><a name="Item_003a-Input_002fdeffn_002fsconcat"></a><dl>
<dt><a name="index-sconcat"></a>Функция: <strong>sconcat</strong> <em>(<var>arg_1</var>, <var>arg_2</var>, ...)</em></dt>
<dd>
<p>Сцепляет аргументы в строки. В отличии от <code>concat</code>, аргументы не обязаны
быть атомами.
</p>
<div class="example">
<pre class="example">(%i1) sconcat (&quot;xx[&quot;, 3, &quot;]:&quot;, expand ((x+y)^3));
(%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
</pre></div>






</dd></dl>


<a name="Item_003a-Input_002fdeffn_002fdisp"></a><dl>
<dt><a name="index-disp"></a>Функция: <strong>disp</strong> <em>(<var>expr_1</var>, <var>expr_2</var>, ...)</em></dt>
<dd><p>то же что и <code>display</code>, но отличается тем что значение аргументов отображаются 
без выражений. Это полезно для сложных аргументов, у которых нет имени или
в случае, когда интерес представляет только значение без имени. 
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fdispcon"></a><dl>
<dt><a name="index-dispcon"></a>Функция: <strong>dispcon</strong> <em>(<var>tensor_1</var>, <var>tensor_2</var>, ...)</em></dt>
<dt><a name="index-dispcon-1"></a>Функция: <strong>dispcon</strong> <em>(all)</em></dt>
<dd><p>Отображает ограничения аргументов, наложенные на них командой <code>defcon</code>.
<code>dispcon (all)</code> отображает все ограничения, которые были заданы.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fdisplay"></a><dl>
<dt><a name="index-display"></a>Функция: <strong>display</strong> <em>(<var>expr_1</var>, <var>expr_2</var>, ...)</em></dt>
<dd><p>Отображает равенства, выравненные по центру. Левыми частями равенств являются не вычисленные
выражения <var>expr_i</var>, a правыми &ndash; их значения.
Эта функция полезна в блоках и конструкциях <code>for</code> для вывода промежуточных результатов.
Аргументы <code>display</code> обычно являются атомами, переменными с индексом, или
вызовами функций. См. также <code>disp</code>.
</p>
<div class="example">
<pre class="example">(%i1) display(B[1,2]);
                                      2
                         B     = X - X
                          1, 2
(%o1)                            done
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fdisplay2d"></a><dl>
<dt><a name="index-display2d"></a>Управляющая переменная: <strong>display2d</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p>Когда <code>display2d</code> равна <code>false</code>, консольный вывод производится в строковой (одномерной) форме,
а не в наглядной (двумерной).
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fdisplay_005fformat_005finternal"></a><dl>
<dt><a name="index-display_005fformat_005finternal"></a>Управляющая переменная: <strong>display_format_internal</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>display_format_internal</code> равна  <code>true</code>,
выражения отображаются без преобразования, которое &quot;прячет&quot; 
внутреннее математическое представление.
Тогда вывод соответствует результату функции <code>inpart</code>, а не <code>part</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">User     part       inpart
a-b;      a - b     a + (- 1) b

           a            - 1
a/b;       -         a b
           b
                       1/2
sqrt(x);   sqrt(x)    x

          4 X        4
X*4/3;    ---        - X
           3         3
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fdispterms"></a><dl>
<dt><a name="index-dispterms"></a>Функция: <strong>dispterms</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Выводит друг под другом части <var>expr</var>.
Первым отображается оператор выражения <var>expr</var>, затем каждое слагаемое суммы, множители
произведения или части более общего выражения отображаются отдельно. Это полезно,
когда <var>expr</var> слишком большое для иных способов отображения. К примеру, если 
<code>P1</code>, <code>P2</code>, ... &ndash; очень большие выражения, то программе может не хватить
памяти при попытке отобразить <code>P1 + P2 + ...</code> как единое целое.
Однако, <code>dispterms (P1 + P2 + ...)</code> отображает <code>P1</code>, затем ниже <code>P2</code> и т. д.
Если не использовать <code>dispterms</code>, когда показательное выражение 
слишком широко, для отображения в виде <code>A^B</code>, то оно выводится в виде <code>expt (A, B)</code>
(или <code>ncexpt (A, B)</code> в случае <code>A^^B</code>).
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002ferror_005fsize"></a><dl>
<dt><a name="index-error_005fsize"></a>Управляющая переменная: <strong>error_size</strong></dt>
<dd><p>Значение по умолчанию: 10
</p>
<p><code>error_size</code> изменяет сообщения об ошибках, в зависимости от размера выражения, которое появляется в нем.
Если размер выражения (определенный с помощью Lisp-функции <code>ERROR-SIZE</code>)
больше чем <code>error_size</code>, выражение замещается символом, а символу присваивается
выражение. Символы берутся из списка <code>error_syms</code>.
</p>
<p>В противном случае, когда выражение меньше чем <code>error_size</code>, оно и выводится
в сообщении.
</p>
<p>См. также <code>error</code> и <code>error_syms</code>.
</p>
<p>Пример:
</p>
<p><code>ERROR-SIZE</code> задает размер <code>U</code> равным 24.
</p>
<div class="example">
<pre class="example">(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$

(%i2) error_size: 20$

(%i3) error (&quot;Example expression is&quot;, U);

Example expression is errexp1
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) errexp1;
                            E
                           D
                          C   + B + A
(%o4)                    --------------
                         cos(X - 1) + 1
(%i5) error_size: 30$

(%i6) error (&quot;Example expression is&quot;, U);

                         E
                        D
                       C   + B + A
Example expression is --------------
                      cos(X - 1) + 1
 -- an error.  Quitting.  To debug this try debugmode(true);
</pre></div>






</dd></dl>

<a name="Item_003a-Input_002fdefvr_002ferror_005fsyms"></a><dl>
<dt><a name="index-error_005fsyms"></a>Управляющая переменная: <strong>error_syms</strong></dt>
<dd><p>Значение по умолчанию: <code>[errexp1, errexp2, errexp3]</code>
</p>
<p>В сообщениях об ошибках, выражения большие чем <code>error_size</code> заменяются символами
и присваиваются этим символам. Символы берутся из списка <code>error_syms</code>.
Первое слишком большое выражения заменяется символом <code>error_syms[1]</code>,
второе символом <code>error_syms[2]</code> и так далее.
</p>
<p>Если слишком больших выражений больше чем элементов в <code>error_syms</code>,
то символы генерируются автоматически, <code>n</code>-ный символ равен <code>concat ('errexp, <var>n</var>)</code>.
</p>
<p>См. также <code>error</code> и <code>error_size</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fexpt"></a><dl>
<dt><a name="index-expt"></a>Функция: <strong>expt</strong> <em>(<var>a</var>, <var>b</var>)</em></dt>
<dd><p>Если показательное выражение слишком широко для отображения в виде <code><var>a</var>^<var>b</var></code>),
оно выводится в виде <code>expt (<var>a</var>, <var>b</var>)</code> (или <code>ncexpt (<var>a</var>, <var>b</var>)</code>
в случае <code><var>a</var>^^<var>b</var></code>).
</p>
<p><code>expt</code> и <code>ncexpt</code> не распознаются при вводе.
</p>
</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fexptdispflag"></a><dl>
<dt><a name="index-exptdispflag"></a>Управляющая переменная: <strong>exptdispflag</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p>Когда <code>exptdispflag</code> равна <code>true</code>, Maxima отображает выражения
с отрицательными степенями в виде дробей, например <code>X^(-1)</code> в виде <code>1/X</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ffilename_005fmerge"></a><dl>
<dt><a name="index-filename_005fmerge"></a>Функция: <strong>filename_merge</strong> <em>(<var>path</var>, <var>filename</var>)</em></dt>
<dd><p>Составляет путь из <var>path</var> и <var>filename</var>. Если последняя часть пути <var>path</var>
имеет форму <code>###.<var>something</var></code>, эта часть заменяется на <code><var>filename</var>.<var>something</var></code>.
В противном случае последняя часть заменяется на <var>filename</var>.
</p>
<p>Результатом является объект пути Lisp.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ffile_005fsearch"></a><dl>
<dt><a name="index-file_005fsearch"></a>Функция: <strong>file_search</strong> <em>(<var>filename</var>)</em></dt>
<dt><a name="index-file_005fsearch-1"></a>Функция: <strong>file_search</strong> <em>(<var>filename</var>, <var>pathlist</var>)</em></dt>
<dd>
<p><code>file_search</code> ищет файл <var>filename</var> и возвращает путь к этому файлу (в виде строки),
если может его найти, иначе возвращает <code>false</code>.
<code>file_search (<var>filename</var>)</code> ищет в определенных по умолчанию каталогах для поиска, которые
указаны в переменных <code>file_search_maxima</code>, <code>file_search_lisp</code> и <code>file_search_demo</code>.
</p>
<p>Перед попыткой сопоставить имя с шаблонами поиска файлов.
<code>file_search</code> первым делом проверяет существование искомого файла.
См. <code>file_search_maxima</code> о шаблонах поиска файла.
</p>
<p>Аргумент <var>filename</var> может быть как путем с именем, так и просто именем файла.
Если каталог включен в пути поиска вместе с поисковым шаблоном файла,
то <var>filename</var> может быть именем без расширения.
В примере
</p>
<div class="example">
<pre class="example">file_search (&quot;/home/wfs/special/zeta.mac&quot;);
file_search (&quot;zeta.mac&quot;);
file_search (&quot;zeta&quot;);
</pre></div>

<p>будет найден один и тот же файл, если он существует и <code>/home/wfs/special/###.mac</code> включен
в <code>file_search_maxima</code>.
</p>
<p><code>file_search (<var>filename</var>, <var>pathlist</var>)</code> осуществляет поиск в каталогах,
заданных переменной <var>pathlist</var>, которая представляет из себя список строк.
Аргумент <var>pathlist</var> замещает каталоги поиска, определенные по умолчанию, так если дан список путей,
<code>file_search</code> ищет только в заданных там и не ищет в путях по умолчанию.
Даже если <var>pathlist</var> содержит только один каталог, <var>pathlist</var> должен быть задан, как список из одного 
элемента.
</p>
<p>Пользователь может изменять пути, определенные по умолчанию. См. <code>file_search_maxima</code>.
</p>
<p><code>file_search</code> используется функцией <code>load</code>, шаблоны поиска файлов берутся
из <code>file_search_maxima</code> и <code>file_search_lisp</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002ffile_005fsearch_005fmaxima"></a><dl>
<dt><a name="index-file_005fsearch_005fmaxima"></a>Управляющая переменная: <strong>file_search_maxima</strong></dt>
<dd><a name="Item_003a-Input_002fdefvr_002ffile_005fsearch_005flisp"></a></dd><dt><a name="index-file_005fsearch_005flisp"></a>Управляющая переменная: <strong>file_search_lisp</strong></dt>
<dd><a name="Item_003a-Input_002fdefvr_002ffile_005fsearch_005fdemo"></a></dd><dt><a name="index-file_005fsearch_005fdemo"></a>Управляющая переменная: <strong>file_search_demo</strong></dt>
<dd><p>Эти переменные задают списки каталогов, в которых производят поиск функции
<code>load</code>, <code>demo</code> и некоторые другие функции Maxima.
По умолчанию в них заданы различные каталоги из путей установки Maxima.
</p>
<p>Пользователь может изменить эти переменные, удалить значения по умолчанию или 
добавить дополнительные каталоги. 
Например,
</p>
<div class="example">
<pre class="example">file_search_maxima: [&quot;/usr/local/foo/###.mac&quot;,
    &quot;/usr/local/bar/###.mac&quot;]$
</pre></div>

<p>удаляет начальные директории списка <code>file_search_maxima</code>,
в то время как
</p>
<div class="example">
<pre class="example">file_search_maxima: append (file_search_maxima,
    [&quot;/usr/local/foo/###.mac&quot;, &quot;/usr/local/bar/###.mac&quot;])$
</pre></div>

<p>добавляет две дополнительные директории.
Иногда удобно разместить такие выражения в файле <code>maxima-init.mac</code>,
чтобы путь поиска файла назначался автоматически при запуске Maxima.
</p>
<p>При помощи шаблонов поиска файлов можно определить несколько расширений файлов и несколько путей. 
Строка <code>###</code> заменяется запрашиваемым именем,
в то время как список разделенных запятыми имен, заключенный в фигурные скобки, <code>{foo,bar,baz}</code>
раскрывается в множество строк.
В качестве примера предположим, что искомое имя &ndash; <code>neumann</code>, тогда
</p>
<div class="example">
<pre class="example">&quot;/home/{wfs,gcj}/###.{lisp,mac}&quot;
</pre></div>

<p>раскроется в <code>/home/wfs/neumann.lisp</code>, <code>/home/gcj/neumann.lisp</code>, <code>/home/wfs/neumann.mac</code> и
<code>/home/gcj/neumann.mac</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ffile_005ftype"></a><dl>
<dt><a name="index-file_005ftype"></a>Функция: <strong>file_type</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Возвращает предположение о содержимом <var>filename</var>, на основе 
его расширения. <var>filename</var> не должен ссылаться на существующий файл,
не происходит попыток открыть файл и проверить содержимое.
</p>
<p>Возвращаемое значение является одним из символов: <code>object</code>, <code>lisp</code> или <code>maxima</code>.
Если расширение начинается на <code>m</code> или <code>d</code>, <code>file_type</code> возвращается <code>maxima</code>.
Если расширение начинается на <code>l</code>, <code>file_type</code> возвращается <code>lisp</code>.
Если ни один из перечисленных вариантов, то <code>file_type</code> возвращается <code>object</code>.
</p>




</dd></dl>

<a name="grind"></a><a name="Item_003a-Input_002fdeffn_002fgrind"></a><dl>
<dt><a name="index-grind"></a>Функция: <strong>grind</strong> <em>(<var>expr</var>)</em></dt>
<dt><a name="index-grind-1"></a>Управляющая переменная: <strong>grind</strong></dt>
<dd><p>Функция <code>grind</code> выводит <var>expr</var> в консоль в форме
подходящем для ввода в Maxima. <code>grind</code> всегда возвращает <code>done</code>.
</p>
<p>Когда <var>expr</var> является именем функции или макрокоманды, <code>grind</code> печатает
определение функции или макрокоманды вместо просто имени.
</p>
<p>См. также <code>string</code>, которая возвращает строку, а не печатает вывод. 
<code>grind</code> пытается печатать выражение способом, который делает его проще
для чтения, чем вывод команды <code>string</code>.
</p>
<p>Когда переменная <code>grind</code> равна <code>true</code>, вывод <code>string</code> и <code>stringout</code>
имеет тот же вид, что и вывод <code>grind</code>.
В противном случае специального форматирования вывода этих функций не производится.
По умолчанию значение переменной <code>grind</code> равно <code>false</code>.
</p>
<p><code>grind</code> может так же быть задана как аргумент <code>playback</code>.
Когда <code>grind</code> задана, <code>playback</code> печатает входное выражение в таком же 
виде как функция <code>grind</code>. 
В противном случае специального форматирования вывода не производится.
</p>
<p><code>grind</code> вычисляет свой аргумент.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) aa + 1729;
(%o1)                       aa + 1729
(%i2) grind (%);
aa+1729$
(%o2)                         done
(%i3) [aa, 1729, aa + 1729];
(%o3)                 [aa, 1729, aa + 1729]
(%i4) grind (%);
[aa,1729,aa+1729]$
(%o4)                         done
(%i5) matrix ([aa, 17], [29, bb]);
                           [ aa  17 ]
(%o5)                      [        ]
                           [ 29  bb ]
(%i6) grind (%);
matrix([aa,17],[29,bb])$
(%o6)                         done
(%i7) set (aa, 17, 29, bb);
(%o7)                   {17, 29, aa, bb}
(%i8) grind (%);
{17,29,aa,bb}$
(%o8)                         done
(%i9) exp (aa / (bb + 17)^29);
                                aa
                            -----------
                                     29
                            (bb + 17)
(%o9)                     %e
(%i10) grind (%);
%e^(aa/(bb+17)^29)$
(%o10)                        done
(%i11) expr: expand ((aa + bb)^10);
         10           9        2   8         3   7         4   6
(%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
         5   5         6   4         7   3        8   2
 + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
        9        10
 + 10 aa  bb + aa
(%i12) grind (expr);
bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
     +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
     +10*aa^9*bb+aa^10$
(%o12)                        done
(%i13) string (expr);
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
bb+aa^10
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
  p : makelist (0, i, 1, length (A))], for i thru n do
  for j : i thru n do
  (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
  if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
  for i thru n do L[i, i] : 1 / p[i],
  for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
(%i15) grind (cholesky);
cholesky(A):=block(
         [n:length(A),L:copymatrix(A),
          p:makelist(0,i,1,length(A))],
         for i thru n do
             (for j from i thru n do
                  (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                   if i = j then p[i]:1/sqrt(x)
                       else L[j,i]:x*p[i])),
         for i thru n do L[i,i]:1/p[i],
         for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
(%o15)                        done
(%i16) string (fundef (cholesky));
(%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
n do (for j from i+1 thru n do L[i,j]:0),L)
</pre></div>






</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fibase"></a><dl>
<dt><a name="index-ibase"></a>Управляющая переменная: <strong>ibase</strong></dt>
<dd><p>Значение по умолчанию: 10
</p>
<p>Целые вводимые в Maxima распознаются с учетом основания системы счисления <code>ibase</code>.
</p>
<p>Переменной <code>ibase</code> может быть присвоено значение между 2 и 35 (в десятичной), включительно.
Когда <code>ibase</code> больше чем 10, в состав цифр входят десятичные цифры от 0 до 9
и заглавные буквы алфавита A, B, C, ..., по мере необходимости.
</p>
<p>Цифры для основания 35, наибольшего возможного, включают цифры от 0 до 9 и буквы от A до Z.
</p>

<p>См. также <code>obase</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002finchar"></a><dl>
<dt><a name="index-inchar"></a>Управляющая переменная: <strong>inchar</strong></dt>
<dd><p>Значение по умолчанию: <code>%i</code>
</p>
<p><code>inchar</code> &ndash; префикс перед метками выражений, вводимых пользователем.
Maxima автоматически генерирует ссылку для каждого входного выражения,
соединяя <code>inchar</code> и <code>linenum</code>.
Переменной <code>inchar</code> может быть присвоена любая строка или обозначение, не обязательно 
состоящее из одной буквы.
</p>
<div class="example">
<pre class="example">(%i1) inchar: &quot;input&quot;;
(%o1)                                input
(input1) expand ((a+b)^3);
                            3        2      2      3
(%o1)                      b  + 3 a b  + 3 a  b + a
(input2)
</pre></div>

<p>См. также <code>labels</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fldisp"></a><dl>
<dt><a name="index-ldisp"></a>Функция: <strong>ldisp</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Отображает выражения <var>expr_1</var>, ..., <var>expr_n</var> в консоли как в печатном выводе.
<code>ldisp</code> присваивает метки промежуточных выражений для каждого аргумента
и возвращает список меток.
</p>
<p>См. также <code>disp</code>.
</p>
<div class="example">
<pre class="example">(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisp (e, f);
                                   3
(%t3)                       (b + a)

                     3        2      2      3
(%t4)               b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                   3
(%o4)                       (b + a)
(%i5) %t4;
                     3        2      2      3
(%o5)               b  + 3 a b  + 3 a  b + a
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fldisplay"></a><dl>
<dt><a name="index-ldisplay"></a>Функция: <strong>ldisplay</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Отображает выражения <var>expr_1</var>, ..., <var>expr_n</var> в консоли как при выводе.
Каждое выражение печатается в виде равенства <code>lhs = rhs</code>,
в котором <code>lhs</code> &ndash; один из аргументов функции <code>ldisplay</code>,
а <code>rhs</code> &ndash; его значение.
Обычно каждый аргумент &ndash; переменная.
<code>ldisp</code> присваивает метки промежуточных выражений каждому равенству
и возвращает список меток.
</p>
<p>См. также <code>display</code>.
</p>
<div class="example">
<pre class="example">(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisplay (e, f);
                                     3
(%t3)                     e = (b + a)

                       3        2      2      3
(%t4)             f = b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                     3
(%o4)                     e = (b + a)
(%i5) %t4;
                       3        2      2      3
(%o5)             f = b  + 3 a b  + 3 a  b + a
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002flinechar"></a><dl>
<dt><a name="index-linechar"></a>Управляющая переменная: <strong>linechar</strong></dt>
<dd><p>Значение по умолчанию: <code>%t</code>
</p>
<p><code>linechar</code> &ndash; префикс меток промежуточных выражений, генерируемых Maxima.
Maxima генерирует метки для каждого промежуточного выражения (если оно отображается),
соединяя <code>linechar</code> и <code>linenum</code>.
Переменной <code>linechar</code> может быть присвоена любая строка или символ, не обязательно
одиночная буква.
</p>
<p>Промежуточный выражения могут отображаться, а могут и не отображаться.
См. <code>programmode</code> и <code>labels</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002flinel"></a><dl>
<dt><a name="index-linel"></a>Управляющая переменная: <strong>linel</strong></dt>
<dd><p>Значение по умолчанию: 79
</p>
<p><code>linel</code> &ndash; ширина консоли (в символах) для вывода выражений.
Пользователь может задать любое значение <code>linel</code>, хотя очень маленькие или
очень большие значения могут оказаться неудобными.
Текст выводимый встроенными функциями Maxima, такой как сообщения об ошибках и вывод <code>describe</code>,
не зависит от <code>linel</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002flispdisp"></a><dl>
<dt><a name="index-lispdisp"></a>Управляющая переменная: <strong>lispdisp</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>lispdisp</code> равна <code>true</code>,
Lisp символы отображаются с вопросительным знаком <code>?</code> перед ними.
В противном случае Lisp символы отображаются без знака.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) lispdisp: false$
(%i2) ?foo + ?bar;
(%o2)                       foo + bar
(%i3) lispdisp: true$
(%i4) ?foo + ?bar;
(%o4)                      ?foo + ?bar
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fload"></a><dl>
<dt><a name="index-load"></a>Функция: <strong>load</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Вычисляет выражения в <var>filename</var>,
тем самым загружая переменные, функции и другие объекты в Maxima.
Значения любых существовавших объектов заменяются связями, полученными из <var>filename</var>.
Для поиска файла <code>load</code> вызывает <code>file_search</code>,
пути поиска берутся из <code>file_search_maxima</code> и <code>file_search_lisp</code>.
Если <code>load</code> выполнена успешно, то возвращается имя файла, иначе печатается сообщение об ошибке.
</p>
<p><code>load</code> работает с равным успехом как для Lisp, так и для Maxima программ.
Файлы, созданные командами <code>save</code>, <code>translate_file</code> и <code>compile_file</code>, которые создают
код Lisp, и <code>stringout</code>, которая создает код Maxima, могут быть обработаны функцией <code>load</code>.
<code>load</code> вызывает <code>loadfile</code> для загрузки Lisp файлов и <code>batchload</code> для загрузки Maxima файлов.
</p>
<p><code>load</code> не распознает конструкции <code>:lisp</code> в файлах Maxima, и во время обработки <var>filename</var>,
глобальные переменные <code>_</code>, <code>__</code>, <code>%</code> и <code>%th</code> имеют те связи, которые были у них в момент 
вызова <code>load</code>.
</p>
<p>См. также <code>loadfile</code>, <code>batch</code>, <code>batchload</code> и <code>demo</code>.
<code>batch</code>, <code>batchload</code> и <code>demo</code> выполняют Maxima файлы.
</p>
<p>См. <code>file_search</code> для более подробного ознакомления с механизмом поиска файлов.
</p>
<p><code>load</code> вычисляет свой аргумент.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002floadfile"></a><dl>
<dt><a name="index-loadfile"></a>Функция: <strong>loadfile</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Вычисляет выражения Lisp в <var>filename</var>.
<code>loadfile</code> не вызывает <code>file_search</code>, поэтому <code>filename</code> должен включать
расширение и информацию о пути, достаточную для поиска файла.
</p>
<p><code>loadfile</code> может обрабатывать файлы, созданные командами <code>save</code>, <code>translate_file</code> и <code>compile_file</code>.
Возможно, удобнее использовать <code>load</code> вместо <code>loadfile</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002floadprint"></a><dl>
<dt><a name="index-loadprint"></a>Управляющая переменная: <strong>loadprint</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p><code>loadprint</code> управляет печатью сообщение после загрузки файла.
</p>
<ul>
<li> Если <code>loadprint</code> равна <code>true</code>, сообщение всегда выводится.
</li><li> Если <code>loadprint</code> равна <code>'loadfile</code>, сообщение выводится только в случае,
когда файл загружается функцией <code>loadfile</code>.
</li><li> Когда <code>loadprint</code> равна <code>'autoload</code>,
сообщение выводится только если файл загружается автоматически.
См. <code>setup_autoload</code>.
</li><li> Когда <code>loadprint</code> равен <code>false</code>, сообщение не выводится.
</li></ul>






</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fobase"></a><dl>
<dt><a name="index-obase"></a>Управляющая переменная: <strong>obase</strong></dt>
<dd><p>Значение по умолчанию: 10
</p>
<p><code>obase</code> &ndash; основание системы счисления в которой Maxima отображает целые числа.
</p>
<p>Переменной <code>obase</code> можно присвоить любое целое число между 2 и 35 (десятичное),
включительно.
Когда <code>obase</code> больше десяти, цифрами являются десятичные цифры от 0 до 9 и 
заглавные буквы латинского алфавита A, B, C, ..., по мере необходимости.
Цифры системы с основанием 35, самым большим из допустимых,
включают цифры от 0 до 9 и буквы от A до Y.
</p>
<p>См. также <code>ibase</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002foutchar"></a><dl>
<dt><a name="index-outchar"></a>Управляющая переменная: <strong>outchar</strong></dt>
<dd><p>Значение по умолчанию: <code>%o</code>
</p>
<p><code>outchar</code> &ndash; это префикс меток для выражений, вычисленных системой Maxima.
Maxima автоматически генерирует метки для каждого вычисленного выражения, соединяя
<code>outchar</code> с <code>linenum</code>.
Переменной <code>outchar</code> можно присвоить любую строку или символ, не обязательно 
одиночную букву.
</p>
<div class="example">
<pre class="example">(%i1) outchar: &quot;output&quot;;
(output1)                           output
(%i2) expand ((a+b)^3);
                            3        2      2      3
(output2)                  b  + 3 a b  + 3 a  b + a
(%i3)
</pre></div>

<p>См. также <code>labels</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fpackagefile"></a><dl>
<dt><a name="index-packagefile"></a>Управляющая переменная: <strong>packagefile</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Разработчики, которые используют <code>save</code> или <code>translate</code>, создавая пакеты (файлы)
для использования другими, возможно захотят установить <code>packagefile: true</code>,
чтобы при загрузке файла предотвратить 
занесение информации, кроме необходимой, в списки Maxima (такие как <code>values</code>,
<code>functions</code>).
В этом случае содержимое пакета будет загружено не в виде пользовательских данных.
Заметим, что это не решает проблему возможного конфликта имен.
Также заметим, что переменная просто указывает на то, что выводится в пакетный файл.
Установка управляющей переменной в <code>true</code> также полезна для создания 
инициализационных файлов Maxima.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fpfeformat"></a><dl>
<dt><a name="index-pfeformat"></a>Управляющая переменная: <strong>pfeformat</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда   <code>pfeformat</code> равна <code>true</code>, рациональная дробь отображается при помощи 
косой черты (прямого слэша). Целочисленный знаменатель <code>n</code> отображается 
как множитель <code>1/n</code>.
</p>
<div class="example">
<pre class="example">(%i1) pfeformat: false$
(%i2) 2^16/7^3;
                              65536
(%o2)                         -----
                               343
(%i3) (a+b)/8;
                              b + a
(%o3)                         -----
                                8
(%i4) pfeformat: true$ 
(%i5) 2^16/7^3;
(%o5)                       65536/343
(%i6) (a+b)/8;
(%o6)                      1/8 (b + a)
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fprint"></a><dl>
<dt><a name="index-print"></a>Функция: <strong>print</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Вычисляет и отображает <var>expr_1</var>, ..., <var>expr_n</var> одно за другим,
слева направо, начиная с левого края экрана консоли.
</p>
<p>Функция <code>print</code> возвращает значение своего последнего аргумента.
<code>print</code> не создает меток промежуточных выражений.
</p>
<p>См. также <code>display</code>, <code>disp</code>, <code>ldisplay</code> и <code>ldisp</code>.
Эти функции отображают по одному выражению на строку, в то время как <code>print</code> старается 
отобразить по два или больше выражений в каждой строке.
</p>
<p>Чтобы отобразить содержимое файла, см. <code>printfile</code>.
</p>
<div class="example">
<pre class="example">(%i1) r: print (&quot;(a+b)^3 is&quot;, expand ((a+b)^3), &quot;log (a^10/b) is&quot;,
      radcan (log (a^10/b)))$
            3        2      2      3
(a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is 

                                              10 log(a) - log(b) 
(%i2) r;
(%o2)                  10 log(a) - log(b)
(%i3) disp (&quot;(a+b)^3 is&quot;, expand ((a+b)^3), &quot;log (a^10/b) is&quot;,
      radcan (log (a^10/b)))$
                           (a+b)^3 is

                     3        2      2      3
                    b  + 3 a b  + 3 a  b + a

                         log (a^10/b) is

                       10 log(a) - log(b)
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fprintfile"></a><dl>
<dt><a name="index-printfile"></a>Функция: <strong>printfile</strong> <em>(<var>path</var>)</em></dt>
<dd>
<p>Выводит файл с именем <var>path</var> на консоль.
Значение <var>path</var> может быть строкой или символом.
Если символ, то он преобразуется в строку.
</p>
<p>Если файл с именем <var>path</var> доступен в текущей директории, то 
он печатается на консоли.
В противном случае <code>printfile</code> пытается найти файл добавляя <var>path</var>
ко всем элементам <code>file_search_usage</code>
при помощи <code>filename_merge</code>.
</p>
<p><code>printfile</code> возвращает <var>path</var>, если файл существует,
и результат успешного поиска файла.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ftcl_005foutput"></a><dl>
<dt><a name="index-tcl_005foutput"></a>Функция: <strong>tcl_output</strong> <em>(<var>list</var>, <var>i0</var>, <var>skip</var>)</em></dt>
<dt><a name="index-tcl_005foutput-1"></a>Функция: <strong>tcl_output</strong> <em>(<var>list</var>, <var>i0</var>)</em></dt>
<dt><a name="index-tcl_005foutput-2"></a>Функция: <strong>tcl_output</strong> <em>([<var>list_1</var>, ..., <var>list_n</var>], <var>i</var>)</em></dt>
<dd>
<p>Выводит элементы списков заключенными в фигурные скобки <code>{ }</code>,
в виде пригодном для использования в языке Tcl/Tk.
</p>

<p><code>tcl_output (<var>list</var>, <var>i0</var>, <var>skip</var>)</code>
выводит элементы списка <var>list</var> с номерами <var>i0</var>, <code><var>i0</var> + <var>skip</var></code>,
<code><var>i0</var> + 2 <var>skip</var></code> и так далее.
</p>
<p><code>tcl_output (<var>list</var>, <var>i0</var>)</code> равнозначна <code>tcl_output (<var>list</var>, <var>i0</var>, 2)</code>.
</p>
<p><code>tcl_output ([<var>list_1</var>, ..., <var>list_n</var>], <var>i</var>)</code>
выводит <var>i</var>-ые элементы списков <var>list_1</var>, ..., <var>list_n</var>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$

 {1.000000000     4.000000000     
 }
(%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$

 {2.000000000     5.000000000     
 }
(%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$

 {((RAT SIMP) 3 7) ((RAT SIMP) 11 13) 
 }
(%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$

 {$Y1 $Y2 $Y3 
 }
(%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

 {SIMP 1.000000000     11.00000000     
 }
</pre></div>

</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fread"></a><dl>
<dt><a name="index-read"></a>Функция: <strong>read</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Выводит <var>expr_1</var>, ..., <var>expr_n</var>, затем считывает одно выражение с консоли и 
возвращает вычисленное выражение.
</p>
<p>См. также <code>readonly</code>.
</p>
<div class="example">
<pre class="example">(%i1) foo: 42$ 
(%i2) foo: read (&quot;foo is&quot;, foo, &quot; -- enter new value.&quot;)$
foo is 42  -- enter new value. 
(a+b)^3;
(%i3) foo;
                                     3
(%o3)                         (b + a)
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002freadonly"></a><dl>
<dt><a name="index-readonly"></a>Функция: <strong>readonly</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Выводит <var>expr_1</var>, ..., <var>expr_n</var>, затем считывает одно выражение с консоли
и Возвращает его без вычисления.
</p>
<div class="example">
<pre class="example">(%i1) aa: 7$
(%i2) foo: readonly (&quot;Enter an expression:&quot;);
Enter an expression: 
2^aa;
                                  aa
(%o2)                            2
(%i3) foo: read (&quot;Enter an expression:&quot;);
Enter an expression: 
2^aa;
(%o3)                            128
</pre></div>

<p>См. также <code>read</code>.
</p>




</dd></dl>

<a name="reveal"></a><a name="Item_003a-Input_002fdeffn_002freveal"></a><dl>
<dt><a name="index-reveal"></a>Функция: <strong>reveal</strong> <em>(<var>expr</var>, <var>depth</var>)</em></dt>
<dd><p>Замещает части выражения <var>expr</var> заданного уровня вложенности <var>depth</var>
кратким описанием.
</p>
<ul>
<li> Суммы и разности заменяются на <code>Sum(<var>n</var>)</code>,
где <var>n</var> &ndash; количество слагаемых.
</li><li> Произведения заменяются на <code>Product(<var>n</var>)</code>,
где <var>n</var> &ndash; количество множителей.
</li><li> Степени заменяются на <code>Expt</code>.
</li><li> Дроби заменяются на <code>Quotient</code>.
</li><li> Унарное отрицание заменяется на <code>Negterm</code>.
</li></ul>

<p>Если <var>depth</var> больше или равен максимальному уровню вложенности в выражении <var>expr</var>,
то <code>reveal (<var>expr</var>, <var>depth</var>)</code> возвращает <var>expr</var> без изменений.
</p>
<p><code>reveal</code> вычисляет свои аргументы.
<code>reveal</code> возвращает анализируемое выражение.
</p>
<p>Пример:
</p>
<div class="example">
<pre class="example">(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                          2            2
                         b  - 2 a b + a
(%o1)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
(%i2) reveal (e, 1);
(%o2)                       Quotient
(%i3) reveal (e, 2);
                             Sum(3)
(%o3)                        ------
                             Sum(3)
(%i4) reveal (e, 3);
                     Expt + Negterm + Expt
(%o4)               ------------------------
                    Product(2) + Expt + Expt
(%i5) reveal (e, 4);
                       2                 2
                      b  - Product(3) + a
(%o5)         ------------------------------------
                         Product(2)     Product(2)
              2 Expt + %e           + %e
(%i6) reveal (e, 5);
                         2            2
                        b  - 2 a b + a
(%o6)              --------------------------
                       Sum(2)     2 b     2 a
                   2 %e       + %e    + %e
(%i7) reveal (e, 6);
                          2            2
                         b  - 2 a b + a
(%o7)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
</pre></div>






</dd></dl>

<a name="Item_003a-Input_002fdefvr_002frmxchar"></a><dl>
<dt><a name="index-rmxchar"></a>Управляющая переменная: <strong>rmxchar</strong></dt>
<dd><p>Значение по умолчанию: <code>]</code>
</p>
<p>Правая сторона матриц изображается символами <code>rmxchar</code>.
</p>
<p>См. также <code>lmxchar</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fsave"></a><dl>
<dt><a name="index-save"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, <var>name_1</var>, <var>name_2</var>, <var>name_3</var>, ...)</em></dt>
<dt><a name="index-save-1"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, values, functions, labels, ...)</em></dt>
<dt><a name="index-save-2"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, [<var>m</var>, <var>n</var>])</em></dt>
<dt><a name="index-save-3"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, <var>name_1</var>=<var>expr_1</var>, ...)</em></dt>
<dt><a name="index-save-4"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, all)</em></dt>
<dt><a name="index-save-5"></a>Функция: <strong>save</strong> <em>(<var>filename</var>, <var>name_1</var>=<var>expr_1</var>, <var>name_2</var>=<var>expr_2</var>, ...)</em></dt>
<dd>
<p>Сохраняет текущие значения аргументов <var>name_1</var>, <var>name_2</var>, <var>name_3</var>, ..., в <var>filename</var>.
Аргументами являются имена переменных, функций и прочих объектов.
Если имя не имеет значения или связанной с ним функцией, оно игнорируется.
<code>save</code> возвращает <var>filename</var>.
</p>
<p><code>save</code> сохраняет данные в форме Lisp выражений.
Данные, сохраненные функцией <code>save</code>, можно загрузить при помощи <code>load (<var>filename</var>)</code>.
</p>
<p>Глобальная управляющая переменная <code>file_output_append</code> управляет тем,
будет ли информация добавлена к файлу, или файл будет переписан заново.
Когда <code>file_output_append</code> равен <code>true</code>, происходит добавление,
иначе <code>save</code> переписывает файл вывода. В обоих случаях <code>save</code> создает
файл, если он до этого не существовал.
</p>
<p>Особая форма <code>save (<var>filename</var>, values, functions, labels, ...)</code>
сохраняет элементы перечисленные в списках <code>values</code>, <code>functions</code>, <code>labels</code> и т. д.
Возможны любые имена определенные в <code>infolist</code>.
<code>values</code> включает все определенные пользователем переменные.
</p>
<p>Особая форма <code>save (<var>filename</var>, [<var>m</var>, <var>n</var>])</code> сохраняет значения
входных и результирующих выражений с номерами от <var>m</var> до <var>n</var>.
Заметим, что <var>m</var> и <var>n</var> должны быть буквальными целыми.
Входные и результирующие метки можно также записать одну за другой, например, <code>save (&quot;foo.1&quot;, %i42, %o42)</code>.
<code>save (<var>filename</var>, labels)</code> сохраняет все входные и результирующие выражения.
Сохраненные выражения при загрузке заменяют существующие.
</p>
<p>Особая форма <code>save (<var>filename</var>, <var>name_1</var>=<var>expr_1</var>, <var>name_2</var>=<var>expr_2</var>, ...)</code>
сохраняет значения <var>expr_1</var>, <var>expr_2</var>, ... с именами <var>name_1</var>, <var>name_2</var>, ...
Эту форму полезно применять для входных и результирующих меток, 
например, <code>save (&quot;foo.1&quot;, aa=%o88)</code>.
С правой стороны равенства в этой форме может стоять любое выражение, которое вычисляется.
Эта форма не вводит новые имена в текущий сеанс Maxima, только сохраняет их в <var>filename</var>.
</p>
<p>Эти особые формы и общую форму функции <code>save</code> можно как угодно смешивать.
Например: <code>save (<var>filename</var>, aa, bb, cc=42, functions, [11, 17])</code>.
</p>
<p>Особая форма <code>save (<var>filename</var>, all)</code> сохраняет текущее состояние Maxima,
включая все определенные пользователем переменные, функции, массивы и т. д., а также
элементы, заданные автоматически.
Сохраняемые элементы включают в себя системные переменные, такие как <code>file_search_maxima</code> или <code>showtime</code>,
если пользователь присвоил им новые значения. См. <code>myoptions</code>.
</p>
<p><code>save</code> вычисляет <var>filename</var>, все остальные аргументы не вычисляются.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fsavedef"></a><dl>
<dt><a name="index-savedef"></a>Управляющая переменная: <strong>savedef</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p>Когда <code>savedef</code> равно <code>true</code>, Maxima версия определенной пользователем функции
защищается, при ее трансляции. Это позволяет
отобразить ее определение при помощи <code>dispfun</code> и дает возможность редактировать ее.
</p>
<p>Когда <code>savedef</code> равна <code>false</code>, имена транслируемых функций
удаляются из списка <code>functions</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fshow"></a><dl>
<dt><a name="index-show"></a>Функция: <strong>show</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>При отображении <code>expr</code>, у индексированных объектов ковариантные
индексы показываются как нижние, а контравариантные &ndash;
как верхние. Индексы дифференцирования отображаются нижними и отделяются от
ковариантных запятой.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fshowratvars"></a><dl>
<dt><a name="index-showratvars"></a>Функция: <strong>showratvars</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Возвращает список переменных в каноническом рациональном выражении <code>expr</code>.
</p>
<p>См. также <code>ratvars</code>.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fstardisp"></a><dl>
<dt><a name="index-stardisp"></a>Управляющая переменная: <strong>stardisp</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>stardisp</code> равно <code>true</code>, произведение отображается 
со звездочкой между операндами.
</p>




</dd></dl>

<a name="string"></a><a name="Item_003a-Input_002fdeffn_002fstring"></a><dl>
<dt><a name="index-string"></a>Функция: <strong>string</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Преобразовывает <code>expr</code> в линейное представление,
как оно было бы введено с клавиатуры.
</p>
<p>Значение, возвращаемое функцией <code>string</code>, является строкой,
поэтому не может использоваться в вычислениях.
</p>




</dd></dl>

<a name="stringdisp"></a><a name="Item_003a-Input_002fdefvr_002fstringdisp"></a><dl>
<dt><a name="index-stringdisp"></a>Управляющая переменная: <strong>stringdisp</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>stringdisp</code> равна <code>true</code>,
строки отображаются заключенными в двойные кавычки.
В противном случае кавычки опускаются.
</p>
<p><code>stringdisp</code> всегда <code>true</code>, при выводе определений функций.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) stringdisp: false$
(%i2) &quot;This is an example string.&quot;;
(%o2)              This is an example string.
(%i3) foo () :=
      print (&quot;This is a string in a function definition.&quot;);
(%o3) foo() := 
              print(&quot;This is a string in a function definition.&quot;)
(%i4) stringdisp: true$
(%i5) &quot;This is an example string.&quot;;
(%o5)             &quot;This is an example string.&quot;
</pre></div>





</dd></dl>

<a name="stringout"></a><a name="Item_003a-Input_002fdeffn_002fstringout"></a><dl>
<dt><a name="index-stringout"></a>Функция: <strong>stringout</strong> <em>(<var>filename</var>, <var>expr_1</var>, <var>expr_2</var>, <var>expr_3</var>, ...)</em></dt>
<dt><a name="index-stringout-1"></a>Функция: <strong>stringout</strong> <em>(<var>filename</var>, [<var>m</var>, <var>n</var>])</em></dt>
<dt><a name="index-stringout-2"></a>Функция: <strong>stringout</strong> <em>(<var>filename</var>, input)</em></dt>
<dt><a name="index-stringout-3"></a>Функция: <strong>stringout</strong> <em>(<var>filename</var>, functions)</em></dt>
<dt><a name="index-stringout-4"></a>Функция: <strong>stringout</strong> <em>(<var>filename</var>, values)</em></dt>
<dd>
<p><code>stringout</code> записывает выражение в файл в той же форме, в которой 
оно было бы введено с клавиатуры. Файл можно использовать в качестве входного для 
команд <code>batch</code> или <code>demo</code>, его также можно редактировать для любых целей.
<code>stringout</code> можно выполнять во время работы <code>writefile</code>.
</p>
<p>Глобальная переменная <code>file_output_append</code> определяет будет ли 
<code>stringout</code> добавлять или переписывать выходной файл.
Если <code>file_output_append</code> равна <code>true</code>,
<code>stringout</code> дописывает выходной файл, иначе переписывает его.
В обоих случаях <code>stringout</code> создает файл, если тот не существовал.
</p>
<p>Общий вид команды <code>stringout</code> записывает значения одного или нескольких выражений в файл.
Заметим, что если выражения являются переменной, записывается только значение переменной, но не ее имя.
В полезном специальном случае, выражения могут быть метками входных 
(<code>%i1</code>, <code>%i2</code>, <code>%i3</code>, ...) или результирующих (<code>%o1</code>, <code>%o2</code>, <code>%o3</code>, ...) выражений.
</p>
<p>Если <code>grind</code> равна <code>true</code>, <code>stringout</code> форматирует выход используя формат <code>grind</code>.
Иначе используется формат <code>string</code>. См. <code>grind</code> и <code>string</code>.
</p>
<p>Особая форма <code>stringout (<var>filename</var>, [<var>m</var>, <var>n</var>)</code> записывает значения входных выражений,
с номерами от m до n, включительно.
</p>
<p>Особая форма <code>stringout (<var>filename</var>, input)</code> записывает в файл все входные выражения.
</p>
<p>Особая форма <code>stringout (<var>filename</var>, functions)</code> записывает в файл все пользовательские функции 
(перечисленные в глобальном списке <code>functions</code>).
</p>
<p>Особая форма <code>stringout (<var>filename</var>, values)</code> записывает в файл все пользовательские 
переменные (перечисленные в глобальном списке <code>values</code>). Каждая переменная выводится как
оператор присваивания: с именем переменной, двоеточием и ее значением. Заметим, что общая форма 
<code>stringout</code> не выводит переменные в виде операторов присваивания.
</p>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ftex"></a><dl>
<dt><a name="index-tex"></a>Функция: <strong>tex</strong> <em>(<var>expr</var>)</em></dt>
<dt><a name="index-tex-1"></a>Функция: <strong>tex</strong> <em>(<var>expr</var>, <var>filename</var>)</em></dt>
<dt><a name="index-tex-2"></a>Функция: <strong>tex</strong> <em>(<var>expr</var>, false)</em></dt>
<dt><a name="index-tex-3"></a>Функция: <strong>tex</strong> <em>(<var>label</var>)</em></dt>
<dt><a name="index-tex-4"></a>Функция: <strong>tex</strong> <em>(<var>label</var>, <var>filename</var>)</em></dt>
<dt><a name="index-tex-5"></a>Функция: <strong>tex</strong> <em>(<var>label</var>, false)</em></dt>
<dd>
<p>Отображает выражение в представлении подходящим для системы подготовки документов TeX.
Результат &ndash; фрагмент документа, который можно скопировать в больший документ, но сам по себе
он для обработки не подходит.
</p>
<p><code>tex (<var>expr</var>)</code> отображает TeX-представление выражения <var>expr</var> в консоль.
</p>
<p><code> (<var>label</var>)</code> отображает TeX-представление выражения, помеченное <var>label</var>,
и назначает его метке выражения (отображаемой слева от выражения).
Метки выражений TeX совпадают с метками Maxima.
</p>

<p><code>tex (<var>expr</var>, <var>filename</var>)</code> и <code>tex (<var>label</var>, <var>filename</var>)</code>
добавляют свой TeX-вывод в файл <var>filename</var>.
</p>
<p><code>tex (<var>expr</var>, false)</code> и <code>tex (<var>label</var>, false)</code>
возвращают свой вывод в виде строки.
</p>
<p><code>tex</code> вычисляет свой первый аргумент после попытки определить, не является ли он меткой.
Оператор две кавычки <code>''</code> вызывает вычисление аргумента, предотвращая
попытки проверить, является ли он меткой. 
</p>
<p>См. также <code>texput</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) integrate (1/(1+x^3), x);
                                    2 x - 1
                  2            atan(-------)
             log(x  - x + 1)        sqrt(3)    log(x + 1)
(%o1)      - --------------- + ------------- + ----------
                    6             sqrt(3)          3
(%i2) tex (%o1);
$$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
 }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
 }\over{3}}\leqno{\tt (\%o1)}$$
(%o2)                          (\%o1)
(%i3) tex (integrate (sin(x), x));
$$-\cos x$$
(%o3)                           false
(%i4) tex (%o1, &quot;foo.tex&quot;);
(%o4)                          (\%o1)
</pre></div>

<p><code>tex (<var>expr</var>, false)</code> возвращает свой вывод в виде строки.
</p>
<div class="example">
<pre class="example">(%i1) S : tex (x * y * z, false);
(%o1) $$x\,y\,z$$
(%i2) S;
(%o2) $$x\,y\,z$$
</pre></div>






</dd></dl>

<a name="Item_003a-Input_002fdeffn_002ftexput"></a><dl>
<dt><a name="index-texput"></a>Функция: <strong>texput</strong> <em>(<var>a</var>, <var>s</var>)</em></dt>
<dt><a name="index-texput-1"></a>Функция: <strong>texput</strong> <em>(<var>a</var>, <var>s</var>, <var>operator_type</var>)</em></dt>
<dt><a name="index-texput-2"></a>Функция: <strong>texput</strong> <em>(<var>a</var>, [<var>s_1</var>, <var>s_2</var>], matchfix)</em></dt>
<dt><a name="index-texput-3"></a>Функция: <strong>texput</strong> <em>(<var>a</var>, [<var>s_1</var>, <var>s_2</var>, <var>s_3</var>], matchfix)</em></dt>
<dd>
<p>Задает TeX вывод для атома <var>a</var>, который может быть символом или именем оператора.
</p>
<p><code>texput (<var>a</var>, <var>s</var>)</code> заставляет функцию <code>tex</code> в своем выводе вставлять
строку <var>s</var> вместо <var>a</var>.
</p>
<p><code>texput (<var>a</var>, <var>s</var>, <var>operator_type</var>)</code>,
где <var>operator_type</var> можеть принимать значения <code>prefix</code>, <code>infix</code>, <code>postfix</code>, <code>nary</code>
или <code>nofix</code>, заставляет функцию <code>tex</code> вставлять <var>s</var> вместо <var>a</var> и помещать 
вставленный текст в подходящую позицию.
</p>
<p><code>texput (<var>a</var>, [<var>s_1</var>, <var>s_2</var>], matchfix)</code>
заставляет <code>tex</code> вставлять <var>s_1</var> и <var>s_2</var> в вывод TeX с обоих сторон аргументов атома <var>a</var>.
Аргументы (если их несколько) разделяются запятыми.
</p>
<p><code>textpput (<var>a</var>, [<var>s_1</var>, <var>s_2</var>, <var>s_3</var>], matchfix)</code>
заставляет <code>tex</code> в TeX-выводе вставлять <var>s_1</var> и <var>s_2</var> с обоих сторон аргументов атома <var>a</var>
и разделять их аргументом <var>s_3</var>.
</p>
<p>Примеры:
</p>
<p>Определение TeX вывода переменной.
</p>
<div class="example">
<pre class="example">(%i1) texput (me,&quot;\\mu_e&quot;);
(%o1)                         \mu_e
(%i2) tex (me);
$$\mu_e$$
(%o2)                         false
</pre></div>

<p>Определение TeX вывода обычной функции (не оператору).
</p>
<div class="example">
<pre class="example">(%i1) texput (lcm, &quot;\\mathrm{lcm}&quot;);
(%o1)                     \mathrm{lcm}
(%i2) tex (lcm (a, b));
$$\mathrm{lcm}\left(a , b\right)$$
(%o2)                         false
</pre></div>

<p>Определение TeX вывода префиксного оператора.
</p>
<div class="example">
<pre class="example">(%i1) prefix (&quot;grad&quot;);
(%o1)                         grad
(%i2) texput (&quot;grad&quot;, &quot; \\nabla &quot;, prefix);
(%o2)                        \nabla 
(%i3) tex (grad f);
$$ \nabla f$$
(%o3)                         false
</pre></div>

<p>Определение вывода инфиксного оператора.
</p>
<div class="example">
<pre class="example">(%i1) infix (&quot;~&quot;);
(%o1)                           ~
(%i2) texput (&quot;~&quot;, &quot; \\times &quot;, infix);
(%o2)                        \times 
(%i3) tex (a ~ b);
$$a \times b$$
(%o3)                         false
</pre></div>

<p>Определение вывода постфиксного оператора.
</p>
<div class="example">
<pre class="example">(%i1) postfix (&quot;##&quot;);
(%o1)                          ##
(%i2) texput (&quot;##&quot;, &quot;!!&quot;, postfix);
(%o2)                          !!
(%i3) tex (x ##);
$$x!!$$
(%o3)                         false
</pre></div>

<p>Определение вывода n-арного оператора.
</p>
<div class="example">
<pre class="example">(%i1) nary (&quot;@@&quot;);
(%o1)                          @@
(%i2) texput (&quot;@@&quot;, &quot; \\circ &quot;, nary);
(%o2)                         \circ 
(%i3) tex (a @@ b @@ c @@ d);
$$a \circ b \circ c \circ d$$
(%o3)                         false
</pre></div>

<p>Определение TeX вывода безфиксного оператора без аргументов.
</p>
<div class="example">
<pre class="example">(%i1) nofix (&quot;foo&quot;);
(%o1)                          foo
(%i2) texput (&quot;foo&quot;, &quot;\\mathsc{foo}&quot;, nofix);
(%o2)                     \mathsc{foo}
(%i3) tex (foo);
$$\mathsc{foo}$$
(%o3)                         false
</pre></div>

<p>Назначение вывода матчфиксному парному оператору.
</p>
<div class="example">
<pre class="example">(%i1) matchfix (&quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;);
(%o1)                          &lt;&lt;
(%i2) texput (&quot;&lt;&lt;&quot;, [&quot; \\langle &quot;, &quot; \\rangle &quot;], matchfix);
(%o2)                [ \langle ,  \rangle ]
(%i3) tex (&lt;&lt;a&gt;&gt;);
$$ \langle a \rangle $$
(%o3)                         false
(%i4) tex (&lt;&lt;a, b&gt;&gt;);
$$ \langle a , b \rangle $$
(%o4)                         false
(%i5) texput (&quot;&lt;&lt;&quot;, [&quot; \\langle &quot;, &quot; \\rangle &quot;, &quot; \\, | \\,&quot;],
      matchfix);
(%o5)           [ \langle ,  \rangle ,  \, | \,]
(%i6) tex (&lt;&lt;a&gt;&gt;);
$$ \langle a \rangle $$
(%o6)                         false
(%i7) tex (&lt;&lt;a, b&gt;&gt;);
$$ \langle a \, | \,b \rangle $$
(%o7)                         false
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fsystem"></a><dl>
<dt><a name="index-system"></a>Функция: <strong>system</strong> <em>(<var>command</var>)</em></dt>
<dd><p>Выполняет команду <var>command</var> как отдельный процесс. 
Команда отправляется на выполнение командной оболочке, заданной по умолчанию.
<code>system</code> поддерживается не всеми операционными системами, она в основном существует 
в Unix и Unix-подобных окружениях.
</p>
<p>Предположим, что <code>_hist.out</code> &ndash; список частот, который вы хотите изобразить в виде гистограммы
при помощи программы <code>xgraph</code>.
</p>
<div class="example">
<pre class="example">(%i1) (with_stdout(&quot;_hist.out&quot;,
           for i:1 thru length(hist) do (
             print(i,hist[i]))),
       system(&quot;xgraph -bar -brw .7 -nl &lt; _hist.out&quot;));
</pre></div>

<p>Для того чтобы создать готовый график в фоновом режиме (вернуться к управлению Maxima)
и удалить временный файл после завершения, сделайте так:
</p>
<div class="example">
<pre class="example">system(&quot;(xgraph -bar -brw .7 -nl &lt; _hist.out;  rm -f _hist.out)&amp;&quot;)
</pre></div>

</dd></dl>

<a name="Item_003a-Input_002fdefvr_002fttyoff"></a><dl>
<dt><a name="index-ttyoff"></a>Управляющая переменная: <strong>ttyoff</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Когда <code>ttyoff</code> равна <code>true</code>, выводимые выражения не отображаются.
Выводимые выражения по прежнему вычисляются и связываются с метками. См. <code>labels</code>.
</p>
<p><code>ttyoff</code> не влияет на текст, отображаемый встроенными функциями, такой как 
сообщения об ошибках и вывод <code>describe</code>.
</p>




</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fwith_005fstdout"></a><dl>
<dt><a name="index-with_005fstdout"></a>Функция: <strong>with_stdout</strong> <em>(<var>f</var>, <var>expr_1</var>, <var>expr_2</var>, <var>expr_3</var>, ...)</em></dt>
<dt><a name="index-with_005fstdout-1"></a>Функция: <strong>with_stdout</strong> <em>(<var>s</var>, <var>expr_1</var>, <var>expr_2</var>, <var>expr_3</var>, ...)</em></dt>
<dd><p>Вычисляет <var>expr_1</var>, <var>expr_2</var>, <var>expr_3</var>, ... и записывает любой сгенерированный
вывод в файл <var>f</var> или в выходной поток <var>s</var>.
Вычисленные выражения не записываются в вывод.
Вывод может генерироваться кроме прочих функциями <code>print</code>, <code>display</code>, <code>grind</code>.
</p>
<p>Глобальная переменная <code>file_output_append</code> управляет тем, будет ли <code>with_stdout</code>
дописывать или переписывать заново файл <var>f</var>.
Если <code>file_output_append</code> равна <code>true</code>, <code>with_stdout</code> добавляет вывод к файлу.
Иначе <code>with_stdout</code> переписывает файл.
В обоих случаях, <code>with_stdout</code> создает файл, если тот не существовал.
</p>
<p><code>with_stdout</code> возвращает значение своего последнего аргумента.
</p>
<p>См. также  <code>writefile</code>.
</p>
<div class="example">
<pre class="example">(%i1) with_stdout (&quot;tmp.out&quot;, for i:5 thru 10 do
      print (i, &quot;! yields&quot;, i!))$
(%i2) printfile (&quot;tmp.out&quot;)$
5 ! yields 120 
6 ! yields 720 
7 ! yields 5040 
8 ! yields 40320 
9 ! yields 362880 
10 ! yields 3628800
</pre></div>





</dd></dl>

<a name="Item_003a-Input_002fdeffn_002fwritefile"></a><dl>
<dt><a name="index-writefile"></a>Функция: <strong>writefile</strong> <em>(<var>filename</var>)</em></dt>
<dd><p>Начинает записывать копию сессии Maxima в <var>filename</var>.
Все взаимодействия между пользователем и Maxima  записываются в этот файл точно в том виде,
в котором они показываются в консоли.
</p>
<p>Копия печатается в формате консольного вывода, который не может быть перезагружен в Maxima.
Если хотите создать файл, содержащий выражения, с возможностью его загрузки, см. <code>save</code> и <code>stringout</code>.
<code>save</code> сохраняет выражения в форме Lisp, в то время как <code>stringout</code> сохраняет их в форме Maxima. 
</p>
<p>Результат выполнения <code>writefile</code>, когда <var>filename</var> уже существует, зависит
от реализации лежащего в основе Lisp. Выходной файл может быть стерт или дописан.
<code>appendfile</code> всегда дописывает файл.
</p>
<p>Может оказаться удобным выполнить <code>playback</code> после <code>writefile</code> чтобы сохранить 
отображение предыдущих взаимодействий. Так <code>playback</code> отображает только входные или результирующие 
переменные (<code>%i1</code>, <code>%o1</code> и т. д.), любой вывод, создаваемый печатающими выражениями в 
функциях (в противоположность возвращаемому значению), не отображается функцией <code>playback</code>.
</p>
<p><code>closefile</code> закрывает файл, который открыла <code>writefile</code> или <code>appendfile</code>.
</p>





</dd></dl>

<a name="Introduction-to-Maxima_0027s-Database"></a><hr>
<div class="header">
<p>
Previous: <a href="maxima_40.html#g_t_0424_0430_0439_043b_044b" accesskey="p" rel="previous">Файлы</a>, Up: <a href="maxima_38.html#g_t_0412_0432_043e_0434-_0438-_0432_044b_0432_043e_0434" accesskey="u" rel="up">Ввод и вывод</a> &nbsp; [<a href="maxima_toc.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" title="Index" rel="index">Index</a>]</p>
</div>



</body>
</html>