File: maxima_149.html

package info (click to toggle)
maxima 5.47.0-9
links: PTS
area: main
in suites: forky
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 (837 lines) | stat: -rw-r--r-- 48,584 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: Функции и переменные для программирования на Maxima</title>

<meta name="description" content="Maxima Manual: Функции и переменные для программирования на Maxima">
<meta name="keywords" content="Maxima Manual: Функции и переменные для программирования на Maxima">
<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_147.html#g_t_041f_0440_043e_0433_0440_0430_043c_043c_044b-Maxima" rel="up" title="Программы Maxima">
<link href="maxima_150.html#g_t_041e_0442_043b_0430_0434_043a_0430" rel="next" title="Отладка">
<link href="maxima_148.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_043f_0440_043e_0433_0440_0430_043c_043c_0438_0440_043e_0432_0430_043d_0438_0435-_043d_0430-Maxima" rel="previous" title="Введение в программирование на Maxima">
<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-_043f_0440_043e_0433_0440_0430_043c_043c_0438_0440_043e_0432_0430_043d_0438_044f-_043d_0430-Maxima"></a>
<div class="header">
<p>
Previous: <a href="maxima_148.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_043f_0440_043e_0433_0440_0430_043c_043c_0438_0440_043e_0432_0430_043d_0438_0435-_043d_0430-Maxima" accesskey="p" rel="previous">Введение в программирование на Maxima</a>, Up: <a href="maxima_147.html#g_t_041f_0440_043e_0433_0440_0430_043c_043c_044b-Maxima" accesskey="u" rel="up">Программы Maxima</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-programmirovaniya-na-Maxima"></a>
<h3 class="section">38.2 Функции и переменные для программирования на Maxima</h3>

<a name="Item_003a-Program_002fdeffn_002fbacktrace"></a><dl>
<dt><a name="index-backtrace"></a>Функция: <strong>backtrace</strong> <em>()</em></dt>
<dt><a name="index-backtrace-1"></a>Функция: <strong>backtrace</strong> <em>(<var>n</var>)</em></dt>
<dd><p>Печатает стек вызовов, т.е. список функций, которые
вызывают текущую активную функцию.
</p>
<p>Вызов <code>backtrace()</code> печатает весь стек вызовов.
</p>
<p>Вызов <code>backtrace (<var>n</var>)</code> печатает <var>n</var> последних
функций, включая текущую.
</p>
<p>Функция <code>backtrace</code> может вызываться внутри программы, функции или из интерактивного
приглашение а не только из контекста отладки.
</p>
<p>Примеры:
</p>
<ul>
<li> Вызов <code>backtrace()</code> печатает весь стек вызовов.

<div class="example">
<pre class="example">(%i1) h(x) := g(x/7)$
(%i2) g(x) := f(x-11)$
(%i3) f(x) := e(x^2)$
(%i4) e(x) := (backtrace(), 2*x + 13)$
(%i5) h(10);
#0: e(x=4489/49)
#1: f(x=-67/7)
#2: g(x=10/7)
#3: h(x=10)
                              9615
(%o5)                         ----
                               49
</pre></div>
</li></ul>

<ul>
<li> Вызов <code>backtrace (<var>n</var>)</code> печатает <var>n</var> последних
функций, включая текущую.

<div class="example">
<pre class="example">(%i1) h(x) := (backtrace(1), g(x/7))$
(%i2) g(x) := (backtrace(1), f(x-11))$
(%i3) f(x) := (backtrace(1), e(x^2))$
(%i4) e(x) := (backtrace(1), 2*x + 13)$
(%i5) h(10);
#0: h(x=10)
#0: g(x=10/7)
#0: f(x=-67/7)
#0: e(x=4489/49)
                              9615
(%o5)                         ----
                               49
</pre></div>
</li></ul>




</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fdo"></a><dl>
<dt><a name="index-do"></a>Специальный оператор: <strong>do</strong></dt>
<dd><p>Команда <code>do</code> используется для выполнения итераций.  Т.к. команда <code>do</code> 
довольно обща, то она будет описана в двух частях.
Сначала будет описана обычная форма, аналогична используемым 
в нескольких других языках программирования (Fortran, Algol, PL/I и т.д.).
Далее будут описаны другие возможности.
</p>
<p>Существует три формы команды, отличающиеся только условием
завершения.  А именно:
</p>
<ul>
<li> <code>for <var>variable</var>: <var>initial_value</var> step <var>increment</var>
      thru <var>limit</var> do <var>body</var></code>
</li><li> <code>for <var>variable</var>: <var>initial_value</var> step <var>increment</var>
      while <var>condition</var> do <var>body</var></code>
</li><li> <code>for <var>variable</var>: <var>initial_value</var> step <var>increment</var>
      unless <var>condition</var> do <var>body</var></code>
</li></ul>

<p>(Как альтернатива, команда <code>step</code> может быть задана после условия завершения или 
границы.)
</p>
<p>Параметры <var>initial_value</var>, <var>increment</var>, <var>limit</var> и <var>body</var> 
могут быть произвольными выражениями.  Если приращение равно 1, то команда
&quot;<code>step 1</code>&quot; может быть опущена.
</p>
<p>Перед выполнение команды <code>do</code>, переменной <var>variable</var> 
(далее называемой управляющей переменной) присваивается начальное значение <var>initial_value</var>. 
Далее: (1) если значение управляющей переменной превышает верхнюю границу,
задаваемую <code>thru</code>, или если условие <code>unless</code> равно <code>true</code>, 
или условие <code>while</code> равно <code>false</code>, то <code>do</code> завершается.
(2) Вычисляется <var>body</var>.  (3) Приращение добавляется к управляющей переменой.  
Шаги (1) &ndash; (3) повторяются до выполнения условия завершения.  
Можно задавать несколько условий завершения.  В этом случае команда <code>do</code> 
завершается при удовлетворении любого из них.
</p>
<p>Обычно тест <code>thru</code> выполняется, когда управляющая переменная становится больше 
<var>limit</var>, когда приращение <var>increment</var> неотрицательно, или, если переменная становится меньше
<var>limit</var>, когда приращение <var>increment</var> отрицательно.
Параметры <var>increment</var> и <var>limit</var> могут быть нечисловыми выражениями, если 
может быть определено их неравенство.  Однако, если <var>increment</var> не является
синтаксически отрицательным (например, отрицательным числом) в момент начала выполнения команды <code>do</code>,
то Maxima предполагает положительность <var>increment</var> во время выполнения <code>do</code>.
Если на самом деле <var>increment</var> окажется неположительным, то <code>do</code> 
может не завершиться надлежащим образом.
</p>
<p>Отметим, что <var>limit</var>, <var>increment</var> и условие завершения вычисляются
заново для каждой итерации.  Таким образом, если какое-либо из этих выражений требует 
длительного вычисления, но не меняется от итерации к итерации при вычислении
<var>body</var>, то будет более эффективным присвоить их
значение переменной до выполнения <code>do</code> и использовать эту переменную.
</p>
<p>Значение, обычно возвращаемое командой <code>do</code>, есть атом <code>done</code>.
Однако, функция <code>return</code> может быть использована внутри <var>body</var>
для завершения <code>do</code> и задания возвращаемого значения.
Отметим, что вызов <code>return</code> внутри цикла <code>do</code>, расположенного  в блоке
<code>block</code>, завершает <code>do</code> а не блок <code>block</code>.  
Функция <code>go</code> не может быть использована для выхода из команды <code>do</code> 
в объемлющий блок <code>block</code>.
</p>
<p>Управляющая переменная всегда локальна в рамках <code>do</code>, т.е.
эту переменную можно использовать внутри цикла и это не
окажет влияния на переменную с тем же именем вне <code>do</code>.  
После завершения <code>do</code>, управляющая переменная остается несвязанной.
</p>
<div class="example">
<pre class="example">(%i1) for a:-3 thru 26 step 7 do display(a)$
                             a = - 3

                              a = 4

                             a = 11

                             a = 18

                             a = 25
</pre></div>

<div class="example">
<pre class="example">(%i1) s: 0$
(%i2) for i: 1 while i &lt;= 10 do s: s+i;
(%o2)                         done
(%i3) s;
(%o3)                          55
</pre></div>

<p>Отметим, что условие <code>while i &lt;= 10</code> эквивалентно условию
<code>unless i &gt; 10</code> или условию <code>thru 10</code>.
</p>
<div class="example">
<pre class="example">(%i1) series: 1$
(%i2) term: exp (sin (x))$
(%i3) for p: 1 unless p &gt; 7 do
          (term: diff (term, x)/p, 
           series: series + subst (x=0, term)*x^p)$
(%i4) series;
                  7    6     5    4    2
                 x    x     x    x    x
(%o4)            -- - --- - -- - -- + -- + x + 1
                 90   240   15   8    2
</pre></div>

<p>что дает 8 членов ряда Тейлора для <code>e^sin(x)</code>.
</p>
<div class="example">
<pre class="example">(%i1) poly: 0$
(%i2) for i: 1 thru 5 do
          for j: i step -1 thru 1 do
              poly: poly + i*x^j$
(%i3) poly;
                  5      4       3       2
(%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
(%i4) guess: -3.0$
(%i5) for i: 1 thru 10 do
          (guess: subst (guess, x, 0.5*(x + 10/x)),
           if abs (guess^2 - 10) &lt; 0.00005 then return (guess));
(%o5)                  - 3.162280701754386
</pre></div>

<p>В этом примере вычисляется отрицательный квадратный корень числа 10 
с использованием метода Ньютона-Рафсона с максимальным числом итераций 10.  
Если условие сходимости не будет выполнено, то возвращается значение
<code>done</code>.
</p>
<p>Вместо добавления значения к управляющей переменной возможен
другой способ ее изменения на каждом цикле итерации.
В этом случае можно использовать <code>next <var>expression</var></code> вместо <code>step <var>increment</var></code>.
Что вызывает присваивание управляющей переменной значения <var>expression</var>
при каждой итерации.
</p>
<div class="example">
<pre class="example">(%i6) for count: 2 next 3*count thru 20 do display (count)$
                            count = 2

                            count = 6

                           count = 18
</pre></div>

<p>Синтаксис <code>for <var>variable</var> from <var>value</var> ...do...</code> может
быть использован как альтернатива <code>for <var>variable</var>: <var>value</var> ...do...</code>.  
Что позволяет располагать <code>from <var>value</var></code> после значений <code>step</code> или <code>next</code>, 
или после условия завершения.  Если <code>from <var>value</var></code> опущено, то в качестве начального
значения предполагается 1.
</p>
<p>Иногда требуется выполнить итерации без использования управляющей переменной.  
В этом случае можно задать только условие завершения без команд
инициализации и изменения управляющей переменной, как сделано в
следующем примере, вычисляющем квадратный корень числа 5 при 
неточном затравочном значении.
</p>
<div class="example">
<pre class="example">(%i1) x: 1000$
(%i2) thru 20 do x: 0.5*(x + 5.0/x)$
(%i3) x;
(%o3)                   2.23606797749979
(%i4) sqrt(5), numer;
(%o4)                   2.23606797749979
</pre></div>

<p>Если необходимо, то можно полностью опустить условия завершения
и использовать только <code>do <var>body</var></code>, что вызывает бесконечное 
вычисление <var>body</var>.  В этом случае для завершения <code>do</code> следует
использовать <code>return</code>.
</p>
<div class="example">
<pre class="example">(%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
          do (y: ev(df), x: x - f(x)/y, 
              if abs (f (x)) &lt; 5e-6 then return (x)))$
(%i2) sqr (x) := x^2 - 5.0$
(%i3) newton (sqr, 1000);
(%o3)                   2.236068027062195
</pre></div>

<p>(Заметим, что <code>return</code> вызывает возвращение текущего значения <code>x</code> 
в качестве значения <code>do</code>.  Блок <code>block</code> завершается, и значение <code>do</code> 
возвращается в качестве значения блока, т.к. <code>do</code> является последней командой <code>block</code>.)
</p>
<p>В Maxima доступна еще одна форма команды <code>do</code>.  Ее синтаксис:
</p>
<div class="example">
<pre class="example">for <var>variable</var> in <var>list</var> <var>end_tests</var> do <var>body</var>
</pre></div>

<p>Элементы списка <var>list</var> (произвольные выражения) 
последовательно присваиваются переменной <var>variable</var>
Для каждой итерации вычисления <var>body</var>.  
Необязательное условие <var>end_tests</var> может использоваться для завершения <code>do</code>,
иначе цикл завершится при исчерпании <var>list</var> или при выполнении <code>return</code> 
внутри <var>body</var>.  (На самом деле, <var>list</var> может быть любым
неатомарным выражением, последовательные части которого будут использованы в итерации.)
</p>
<div class="example">
<pre class="example">(%i1)  for f in [log, rho, atan] do ldisp(f(1))$
(%t1)                                  0
(%t2)                                rho(1)
                                     %pi
(%t3)                                 ---
                                      4
(%i4) ev(%t3,numer);
(%o4)                             0.78539816
</pre></div>




</dd></dl>

<a name="Item_003a-Program_002fdeffn_002ferrcatch"></a><dl>
<dt><a name="index-errcatch"></a>Функция: <strong>errcatch</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Вычисляет одно за другим выражения  <var>expr_1</var>, ..., <var>expr_n</var> 
и, если не возникает ошибок, возвращает <code>[<var>expr_n</var>]</code> (список).  
Если при вычислении одного из аргументов возникает ошибка, то
<code>errcatch</code> предотвращает дальнейшее распространение ошибки и возвращает
пустой список <code>[]</code> без дальнейшего вычисления аргументов.
</p>
<p>Функция <code>errcatch</code> полезна в пакетных <code>batch</code> файлах,
если ожидается возможное возникновение ошибки, что без 
перехвата ошибки приводит к завершению <code>batch</code>.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002ferror"></a><dl>
<dt><a name="index-error"></a>Функция: <strong>error</strong> <em>(<var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dt><a name="index-error-1"></a>Системная переменная: <strong>error</strong></dt>
<dd><p>Вычисляет и печатает <var>expr_1</var>, ..., <var>expr_n</var>, и
затем вызывает ошибку, что возвращает управление на верхний
уровень Maxima или ближайшему объемлющему <code>errcatch</code>.
</p>
<p>Значением переменной <code>error</code> является список, описывающий ошибку.
Первый элемент <code>error</code> &ndash; строка форматирования,
которая объединяет все строки из параметров <var>expr_1</var>, ..., <var>expr_n</var>,
остальные элементы &ndash; есть значения нестроковых аргументов.
</p>
<p>Функция <code>errormsg()</code> форматирует и печатает <code>error</code>,
что повторяет печать самой последней ошибки.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002ferrormsg"></a><dl>
<dt><a name="index-errormsg"></a>Функция: <strong>errormsg</strong> <em>()</em></dt>
<dd><p>Повторяет печать самой последней ошибки.
Информация об ошибке содержится в переменной <code>error</code>, и <code>errormsg</code> 
форматирует и печатает ее.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002ffor"></a><dl>
<dt><a name="index-for"></a>Специальный оператор: <strong>for</strong></dt>
<dd><p>Используется в циклах. См. <code>do</code> для описания средств Maxima для
организации итераций.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fgo"></a><dl>
<dt><a name="index-go"></a>Функция: <strong>go</strong> <em>(<var>tag</var>)</em></dt>
<dd><p>Используется внутри блока <code>block</code> для передачи управления на команду,
помеченную параметром <code>go</code>.  Для пометки команды в блоке, перед ней помещают
другую команду в виде атома (метки).  Например:
</p>
<div class="example">
<pre class="example">block ([x], x:1, loop, x+1, ..., go(loop), ...)
</pre></div>

<p>Аргументом <code>go</code> должна быть метка, определенная в том же блоке <code>block</code>.  
Нельзя использовать <code>go</code> для передачи управления на метку в блоке отличном от
того, где находится сама команда <code>go</code>.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fif"></a><dl>
<dt><a name="index-if"></a>Специальный оператор: <strong>if</strong></dt>
<dd><p>Условное вычисление. Существуют различные формы условного выражения <code>if</code>.
</p>
<p><code>if <var>cond_1</var> then <var>expr_1</var> else <var>expr_0</var></code>
вычисляет и возвращает значение <var>expr_1</var>, если значение <var>cond_1</var> равно <code>true</code>,
иначе вычисляет и возвращает значение <code>expr_0</code>.
</p>
<p><code>if <var>cond_1</var> then <var>expr_1</var> elseif <var>cond_2</var> then <var>expr_2</var> elseif ... else <var>expr_0</var></code>
вычисляет и возвращает значение <var>expr_k</var>, если <var>cond_k</var> равно <code>true</code> 
а все предыдущие условия равны <code>false</code>.
Если не одно из условий не равно <code>true</code>, то вычисляется и возвращается значение <var>expr_0</var>.
</p>
<p>Если завершающее <code>else</code> отсутствует, то в конце подразумевается <code>else false</code>.
Т.е. <code>if <var>cond_1</var> then <var>expr_1</var></code> эквивалентно 
<code>if <var>cond_1</var> then <var>expr_1</var> else false</code>,
а <code>if <var>cond_1</var> then <var>expr_1</var> elseif ... elseif <var>cond_n</var> then <var>expr_n</var></code>
эквивалентно
<code>if <var>cond_1</var> then <var>expr_1</var> elseif ... elseif <var>cond_n</var> then <var>expr_n</var> else false</code>.
</p>
<p>Альтернативы <var>expr_0</var>, ..., <var>expr_n</var> могут быть произвольными выражениями Maxima,
включая вложенные <code>if</code> выражения.
Альтернативы не упрощаются и не вычисляются до тех пор пока соответствующее условие
не равно <code>true</code>.
</p>
<p>Условия <var>cond_1</var>, ..., <var>cond_n</var> являются выражениями, которые потенциально или фактически
вычисляются в <code>true</code> или <code>false</code>.
Если значение условия не равно ни <code>true</code>, ни <code>false</code>, то
поведение <code>if</code> управляется глобальной переменной <code>prederror</code>.
Если <code>prederror</code> равна <code>true</code>, то любое значение условия, отличное от <code>true</code> или <code>false</code>,
считается ошибкой.  Иначе, условия, которые не вычисляются в <code>true</code> или <code>false</code>,
считаются допустимыми и результатом вычисления является условное выражение.
</p>
<p>Вместе с другими элементами, условия могут включать следующие логические операторы
и операторы отношения.
</p>
<div class="example">
<pre class="example">Операция                    Символ      Тип
 
меньше                      &lt;           отношение, инфиксный
меньше или равно            &lt;=          отношение, инфиксный
равенство (синтаксическое)  =           отношение, инфиксный
отрицание =                 #           отношение, инфиксный
равенство (значение)        equal       отношение, функция
отрицане equal              notequal    отношение, функция
больше или равно            &gt;=          отношение, инфиксный
больше                      &gt;           отношение, инфиксный
и                           and         логический, инфиксный
или                         or          логический, инфиксный
нет                         not         логический, префиксный
</pre></div>





</dd></dl>

<a name="map"></a><a name="Item_003a-Program_002fdeffn_002fmap"></a><dl>
<dt><a name="index-map"></a>Функция: <strong>map</strong> <em>(<var>f</var>, <var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Возвращает выражение, с оператором верхнего уровня таким же как у выражений 
<var>expr_1</var>, ..., <var>expr_n</var> но аргументы которого являются результатами 
применения <var>f</var> к соответствующим аргументам выражений <var>expr_i</var>.  
Здесь, <var>f</var> &ndash; либо функция <em>n</em> аргументов, либо <code>lambda</code> 
выражение с <em>n</em> аргументами.
</p>
<p>Если переменная <code>maperror</code> равна <code>false</code>, то <code>map</code>:
(1) остановится на самом коротком выражении <var>expr_i</var>, если не все <var>expr_i</var> 
имеют одинаковую длину; (2) применит <var>f</var> к [<var>expr_1</var>, <var>expr_2</var>,...],
если не все <var>expr_i</var> имеют одинаковый тип.  Если <code>maperror</code> равна <code>true</code>,
то в оба вышеуказанных случая считаются ошибкой.
</p>
<p>Одним из применений функции <code>map</code> является применение какой-либо функции
(например, <code>partfrac</code>) к каждому члену большого выражения вместо применения 
ее к выражению целиком, что может привести к слишком сложным вычислениям и,
как следствие, к нехватке памяти.
</p>
<div class="example">
<pre class="example">(%i1) map(f,x+a*y+b*z);
(%o1)                        f(b z) + f(a y) + f(x)
(%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                           1       1        1
(%o2)                     ----- - ----- + -------- + x
                         x + 2   x + 1          2
                                         (x + 1)
(%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                      1
(%o3)                            y + ----- + 1
                                    x + 1
(%i4) map(&quot;=&quot;,[a,b],[-0.5,3]);
(%o4)                          [a = - 0.5, b = 3]


</pre></div>




</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fmapatom"></a><dl>
<dt><a name="index-mapatom"></a>Функция: <strong>mapatom</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Возвращает <code>true</code> тогда и только тогда, когда выражение <var>expr</var> рассматривается map-процедурами
как атомарное выражение.  К таким &quot;mapatoms&quot; относятся атомы, числа (включая рациональные) и
переменные с индексом.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdefvr_002fmaperror"></a><dl>
<dt><a name="index-maperror"></a>Управляющая переменная: <strong>maperror</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p>Если переменная <code>maperror</code> равна <code>false</code>, то все <code>map</code> функции, например:
</p>
<div class="example">
<pre class="example">map (<var>f</var>, <var>expr_1</var>, <var>expr_2</var>, ...)
</pre></div>

<p>(1) остановится на самом коротком выражении <var>expr_i</var>, если не все <var>expr_i</var> 
имеют одинаковую длину; (2) применит <var>f</var> к [<var>expr_1</var>, <var>expr_2</var>,...],
если не все <var>expr_i</var> имеют одинаковый тип.  
</p>
<p>Если <code>maperror</code> равна <code>true</code>,
то в оба вышеуказанных случая считаются ошибками.
</p>



</dd></dl>


<a name="Item_003a-Program_002fdefvr_002fmapprint"></a><dl>
<dt><a name="index-mapprint"></a>Управляющая переменная: <strong>mapprint</strong></dt>
<dd><p>Значение по умолчанию: <code>true</code>
</p>
<p>Если переменная <code>mapprint</code> равна <code>true</code>, то функции 
<code>map</code>, <code>mapl</code> и <code>fullmap</code> в определенных ситуациях 
выдают различные сообщения.  Включая ситуации, когда <code>map</code> использует
<code>apply</code> или <code>map</code> обрезает до самого короткого списка.
</p>
<p>Если <code>mapprint</code> равна <code>false</code>, то данные сообщения подавляются.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fmaplist"></a><dl>
<dt><a name="index-maplist"></a>Функция: <strong>maplist</strong> <em>(<var>f</var>, <var>expr_1</var>, ..., <var>expr_n</var>)</em></dt>
<dd><p>Возвращает список с <var>f</var>, примененной к частям выражений 
<var>expr_1</var>, ..., <var>expr_n</var>.
<var>f</var> &ndash; есть имя функции или лямбда-выражение.
</p>
<p>Функция <code>maplist</code> отличается от <code>map (<var>f</var>, <var>expr_1</var>, ..., <var>expr_n</var>)</code>,
которая возвращает выражение с главным оператором, одним для всех выражений <var>expr_i</var>
(за исключеним упрощений и случая, когда <code>map</code> выполняет <code>apply</code>).
</p>



</dd></dl>

<a name="Item_003a-Program_002fdefvr_002fprederror"></a><dl>
<dt><a name="index-prederror"></a>Управляющая переменная: <strong>prederror</strong></dt>
<dd><p>Значение по умолчанию: <code>false</code>
</p>
<p>Если <code>prederror</code> равна <code>true</code>, то ошибка случается всякий раз, как только
вычисленное значение предиката команды <code>if</code> или функции <code>is</code> отлично от 
<code>true</code> или <code>false</code>.
</p>
<p>Если  <code>false</code>, то в этом случае возвращается <code>unknown</code>.  
Работа с <code>prederror: false</code> не поддерживается транслированном коде.
Однако, <code>maybe</code> поддерживается в транслированном коде.
</p>
<p>См. также <code>is</code> и <code>maybe</code>.
</p>




</dd></dl>

<a name="Item_003a-Program_002fdeffn_002freturn"></a><dl>
<dt><a name="index-return"></a>Функция: <strong>return</strong> <em>(<var>value</var>)</em></dt>
<dd><p>Используется для явного выхода из блока, делая <var>value</var> значением этого блока.
См. <code>block</code> для более детального описания.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fscanmap"></a><dl>
<dt><a name="index-scanmap"></a>Функция: <strong>scanmap</strong> <em>(<var>f</var>, <var>expr</var>)</em></dt>
<dt><a name="index-scanmap-1"></a>Функция: <strong>scanmap</strong> <em>(<var>f</var>, <var>expr</var>, bottomup)</em></dt>
<dd><p>Применяет функцию <var>f</var> к <var>expr</var> рекурсивно начиная с верхнего уровня и глубже.
Это может быть полезно, если, например, требуется полная факторизация:
</p>
<div class="example">
<pre class="example">(%i1) exp:(a^2+2*a+1)*y + x^2$
(%i2) scanmap(factor,exp);
                                    2      2
(%o2)                         (a + 1)  y + x
</pre></div>

<p>Отметим, что то, как <code>scanmap</code> применяет данную функцию <code>factor</code> к подвыражениям
<var>expr</var>, зависит от формы этого выражения.  И если дана другая форма <var>expr</var>,
то результат <code>scanmap</code> может быть другим.  Так, <code>%o2</code> не получится,
если <code>scanmap</code> применить к раскрытому варианту <code>exp</code>:
</p>
<div class="example">
<pre class="example">(%i3) scanmap(factor,expand(exp));
                           2                  2
(%o3)                      a  y + 2 a y + y + x
</pre></div>

<p>Еще один пример рекурсивного применения <code>scanmap</code> ко всем подвыражениям,
включая экспоненты:
</p>
<div class="example">
<pre class="example">(%i4) expr : u*v^(a*x+b) + c$
(%i5) scanmap('f, expr);
                    f(f(f(a) f(x)) + f(b))
(%o5) f(f(f(u) f(f(v)                      )) + f(c))
</pre></div>

<p><code>scanmap (<var>f</var>, <var>expr</var>, bottomup)</code> применяет <var>f</var> к <var>expr</var> с
самого глубокого уровня вверх.  Например, для неопределенной функции <code>f</code>,
</p>
<div class="example">
<pre class="example">scanmap(f,a*x+b) -&gt;
   f(a*x+b) -&gt; f(f(a*x)+f(b)) -&gt; f(f(f(a)*f(x))+f(b))
scanmap(f,a*x+b,bottomup) -&gt; f(a)*f(x)+f(b)
    -&gt; f(f(a)*f(x))+f(b) -&gt;
     f(f(f(a)*f(x))+f(b))
</pre></div>

<p>В данном случае результат одинаков для обоих вариантов вызова.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fthrow"></a><dl>
<dt><a name="index-throw"></a>Функция: <strong>throw</strong> <em>(<var>expr</var>)</em></dt>
<dd><p>Вычисляет выражение <var>expr</var> и &quot;бросает&quot; его значение вверх до ближайшего <code>catch</code>.  
Функции <code>throw</code> и <code>catch</code> реализуют механизм нелокального возврата.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002fwhile"></a><dl>
<dt><a name="index-while"></a>Специальный оператор: <strong>while</strong></dt>
<dd><a name="Item_003a-Program_002fdeffn_002funless"></a></dd><dt><a name="index-unless"></a>Специальный оператор: <strong>unless</strong></dt>
<dd><p>См. <code>do</code>.
</p>



</dd></dl>

<a name="Item_003a-Program_002fdeffn_002foutermap"></a><dl>
<dt><a name="index-outermap"></a>Функция: <strong>outermap</strong> <em>(<var>f</var>, <var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dd><p>Применяет функцию <var>f</var> к каждому элементу внешнего произведения 
<var>a_1</var> x <var>a_2</var> ... x <var>a_n</var>.
</p>
<p><var>f</var> &ndash; есть имя функции с <em>n</em> аргументами или
лямбда-выражение с <em>n</em> аргументами.
Каждый элемент <var>a_k</var> может быть списком, списком списков, матрицей или любым другим выражением.
</p>
<p>Значение <code>outermap</code> является вложенной структурой.
Пусть <var>x</var> является возвращаемым значением.
Тогда <var>x</var> имеет ту же структуру, как первый аргумент (список, список списков или матрица),
<code><var>x</var>[i_1]...[i_m]</code> имеет ту же структуру, как второй аргумент (список, список списков или матрица),
<code><var>x</var>[i_1]...[i_m][j_1]...[j_n]</code> имеет ту же структуру, как третий аргумент (список, список списков или матрица),
и т.д., где <var>m</var>, <var>n</var>, ... &ndash; есть число индексов, необходимых для для доступа к элементам
каждого из аргументов (один для списка, два для матрицы, еще один для вложенного списка).
Аргументы, не являющиеся списками и матрицами, не оказывают влияния на возвращаемое значение.
</p>
<p>Отметим, что результат <code>outermap</code> отличается от применения <var>f</var> ко всем
элементам внешнего произведения, возвращаемого <code>cartesian_product</code>.
Функция <code>outermap</code> сохраняет структуру аргументов в возвращаемом значении, а <code>cartesian_product</code> нет.
</p>
<p>Функция <code>outermap</code> вычисляет свои аргументы.
</p>
<p>См. также <code>map</code>, <code>maplist</code> и <code>apply</code>.
</p>
<p>Примеры:
</p>
<p>Простые примеры <code>outermap</code>.
Для прояснения комбинации аргументов, <code>F</code> оставлена неопределенной.
</p>
<div class="example">
<pre class="example">(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
         [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
(%o2)    [                                            ]
         [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
(%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
       [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
(%o3) [[                        ], [                        ]]
       [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
(%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
       [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
(%o4) [[ [            ]  [            ] ], 
       [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                              [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                              [ [            ]  [            ] ]]
                              [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
(%i5) outermap (&quot;+&quot;, [a, b, c], [1, 2, 3]);
(%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3], 
                                           [c + 1, c + 2, c + 3]]
</pre></div>

<p>Более детальное исследование работы <code>outermap</code>.
Первый, второй и третий аргументы являются матрицей, списком и матрицей соответственно.
Возвращаемое значение является матрицей.
Каждый элемент этой матрицы есть список, и каждый элемент данного списка &ndash; матрица.
</p>
<div class="example">
<pre class="example">(%i1) arg_1 :  matrix ([a, b], [c, d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) arg_2 : [11, 22];
(%o2)                       [11, 22]
(%i3) arg_3 : matrix ([xx, yy]);
(%o3)                      [ xx  yy ]
(%i4) xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1, 
                                                     arg_2, arg_3);
               [  [      a        a  ]  [      a        a  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
(%o4)  Col 1 = [                                              ]
               [  [      c        c  ]  [      c        c  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
                 [  [      b        b  ]  [      b        b  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
         Col 2 = [                                              ]
                 [  [      d        d  ]  [      d        d  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
(%i5) xx_1 : xx_0 [1][1];
           [      a        a  ]  [      a        a  ]
(%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
           [      11       11 ]  [      22       22 ]
(%i6) xx_2 : xx_0 [1][1] [1];
                      [      a        a  ]
(%o6)                 [ xx + --  yy + -- ]
                      [      11       11 ]
(%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                  a
(%o7)                        xx + --
                                  11
(%i8) [op (arg_1), op (arg_2), op (arg_3)];
(%o8)                  [matrix, [, matrix]
(%i9) [op (xx_0), op (xx_1), op (xx_2)];
(%o9)                  [matrix, [, matrix]
</pre></div>

<p>Функция <code>outermap</code> сохраняет структуру аргументов в возвращаемом значении, а <code>cartesian_product</code> нет.
</p>
<div class="example">
<pre class="example">(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) setify (flatten (%));
(%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)}
(%i3) map (lambda ([L], apply (F, L)), 
(%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)}
(%i4) is (equal (%, %th (2)));
(%o4)                         true
</pre></div>




</dd></dl>


<hr>
<div class="header">
<p>
Previous: <a href="maxima_148.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_043f_0440_043e_0433_0440_0430_043c_043c_0438_0440_043e_0432_0430_043d_0438_0435-_043d_0430-Maxima" accesskey="p" rel="previous">Введение в программирование на Maxima</a>, Up: <a href="maxima_147.html#g_t_041f_0440_043e_0433_0440_0430_043c_043c_044b-Maxima" accesskey="u" rel="up">Программы Maxima</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>