doc/tutorial/pt/minimal-maxima.tex

   1 % /minimal-maxima.tex/1.2/Tue Dec 20 05:35:05 2005//
   2 \documentclass[12pt]{article}
   3
   4 \usepackage[latin1]{inputenc}
   5 \usepackage[brazil]{babel}
   6 \usepackage[dvipdfm,colorlinks,linkcolor=red]{hyperref}
   7
   8 \addtolength{\topmargin}{-0.5in}
   9 \addtolength{\textheight}{1in}
  10 \addtolength{\footskip}{0.5in}
  11
  12 \setlength{\parskip}{8pt}
  13 \setlength{\parindent}{0pt}
  14
  15 \title{Maxima Mínimo\\
  16 {\small Liberado sob os termos da Licença pública GNU, Versão 2}}
  17 \author{Autor - Robert Dodier. Tradutor - Jorge Barros de Abreu.}
  18
  19 \date{\today}
  20
  21 \begin{document}
  22 \maketitle
  23
  24 \section{O que é Maxima?}
  25
  26 Maxima\footnote
  27 {Home page: \url{http://maxima.sourceforge.net} \\
  28 Documentos: \url{http://maxima.sourceforge.net/pt/documentation.html} \\
  29 Manual de referência: \url{http://maxima.sourceforge.net/pt/maxima.html}}
  30 é um sistema que trabalha com expressões,
  31 tais como $x + y$, $sin (a + b \pi)$, e $u \cdot v - v \cdot u$.\\
  32
  33 Maxima não está muito preocupado sobre o significado de uma expressão.
  34 Se uma expressão é representativa ou não quem decide é o usuário.
  35
  36 Algumas vezes você quer atribuir valores a entidades desconhecidas
  37 e avaliar a expressão.
  38 Maxima está disponível para fazer isso.
  39 Mas Maxima está também disponível para adiar atribuições de valores específicos;
  40 você pode realizar muitas manipulações de uma expressão,
  41 e somente mais adiante (ou nunca) atribuir valores a entidades desconhecidas.
  42
  43 Vamos ver alguns exemplos.
  44
  45 \begin{enumerate}
  46
  47 \item Quero calcular o volume de uma esfera.
  48 % V: 4/3 * %pi * r^3;
  49 \begin{verbatim}
  50 (%i1) V: 4/3 * %pi * r^3;
  51                                    3
  52                             4 %pi r
  53 (%o1)                       --------
  54                                3
  55 \end{verbatim}
  56
  57 \item O raio é 10.
  58 % r: 10;
  59 \begin{verbatim}
  60 (%i2) r: 10;
  61 (%o2)                          10
  62 \end{verbatim}
  63
  64 \item $V$ é o mesmo que antes; Maxima não muda $V$ até que eu diga a ele para fazer isso.
  65 % V;
  66 \begin{verbatim}
  67 (%i3) V;
  68                                    3
  69                             4 %pi r
  70 (%o3)                       --------
  71                                3
  72 \end{verbatim}
  73
  74 \item Digo ao maxima para re-avaliar $V$.
  75 % ''V;
  76 \begin{verbatim}
  77 (%i4) ''V;
  78                             4000 %pi
  79 (%o4)                       --------
  80                                3
  81 \end{verbatim}
  82
  83 \item Gostaria de ver um valor numérico em lugar de uma expressão.
  84 % ''V, numer;
  85 \begin{verbatim}
  86 (%i5) ''V, numer;
  87 (%o5)                   4188.79020478639
  88 \end{verbatim}
  89
  90 \end{enumerate}
  91
  92 \section{Expressões}
  93
  94 Tudo no Maxima é uma expressão,
  95 incluindo expressões matemáticas, objetos, e construções de programação.
  96 uma expressão é ou um átomo, ou um operador junto com seus argumentos.
  97
  98 Um átomo é um símbolo (um nome), uma seqüência de caracteres entre apóstrofos,
  99 ou um número (ou inteiro ou em ponto flutuante).
 100
 101 Todas as expressões não atômicas são representadas como $\mathit{op}(a_1, \ldots, a_n)$
 102 onde $\mathit{op}$ é o nome de um operador
 103 e $a_1, \ldots, a_n$ são seus argumentos.
 104 (A expressão pode ser mostrada de forma diferente,
 105 mas a representação interna é a mesma.)
 106 Os argumentos de uma expressão podem ser átomos ou expressões não atômicas.
 107
 108 Expressões matemáticas possuem operadores matemáticos,
 109 tais como $+ \; - \; * \; / \; < \; = \; >$
 110 ou uma avaliação de função tal como $\mathbf{sin}(x), \mathbf{bessel\_j}(n, x)$.
 111 Em tais casos, o operador é a função.
 112
 113 Objetos no Maxima são expressões.
 114 Uma lista $[a_1, \ldots, a_n]$ é uma expressão $\mathbf{list}(a_1, \ldots, a_n)$.
 115 Uma matriz é uma expressão
 116 \[
 117 \mathbf{matrix}(\mathbf{list}(a_{1,1}, \ldots, a_{1,n}), \ldots, \mathbf{list}(a_{m,1}, \ldots, a_{m,n}))
 118 \]
 119
 120 Construções de programação são expressões.
 121 Um bloco de código $\mathbf{block} (a_1, \ldots, a_n)$ é uma expressão com operador $\mathbf{block}$
 122 e argumentos $a_1, \ldots, a_n$.
 123 Uma declaração condicional $\mathbf{if\ } a \mathbf{\ then\ } b \mathbf{\ elseif\ } c \mathbf{\ then\ } d$
 124 é uma expressão $\mathbf{if}(a, b, c, d)$.
 125 Um ciclo $\mathbf{for\ } a \mathbf{\ in\ } L \mathbf{\ do\ } S$ é uma expressão similar a $\mathbf{do}(a, L, S)$.
 126
 127 A função do Maxima $\mathbf{op}$ retorna o operador de uma expressão não atômica.
 128 A função $\mathbf{args}$ retorna os argumentos de uma expressão não atômica.
 129 A função $\mathbf{atom}$ diz se uma expressão é um átomo ou não.
 130
 131 Vamos ver alguns exemplos mais.
 132
 133 \begin{enumerate}
 134
 135 \item Átomos são símbolos, seqüências de caracteres, e números.
 136 Agrupei muitos exemplos em uma lista então podemos vê-los todos juntos.
 137 % [a, foo, foo_bar, "Hello, world!", 42, 17.29];
 138
 139 \begin{verbatim}
 140 (%i2) [a, foo, foo_bar, "Hello, world!", 42, 17.29];
 141 (%o2)      [a, foo, foo_bar, Hello, world!, 42, 17.29]
 142 \end{verbatim}
 143
 144 \item Mathematical expressions.
 145 % [a + b + c, a * b * c, foo = bar, a*b < c*d];
 146
 147 \begin{verbatim}
 148 (%i1) [a + b + c, a * b * c, foo = bar, a*b < c*d];
 149 (%o1)       [c + b + a, a b c, foo = bar, a b < c d]
 150 \end{verbatim}
 151
 152 \item Listas e matrizes.
 153 Os elementos de uma lista ou matriz podem ser qualquer tipo de expressão,
 154 mesmo outra lista ou matriz.
 155 % L: [a, b, c, %pi, %e, 1729, 1/(a*d - b*c)];
 156 % L2: [a, b, [c, %pi, [%e, 1729], 1/(a*d - b*c)]];
 157 % L [7];
 158 % L2 [3];
 159 % M: matrix ([%pi, 17], [29, %e]);
 160 % M2: matrix ([[%pi, 17], a*d - b*c], [matrix ([1, a], [b, 7]), %e]);
 161 % M [2][1];
 162 % M2 [2][1];
 163
 164 \begin{verbatim}
 165 (%i1) L: [a, b, c, %pi, %e, 1729, 1/(a*d - b*c)];
 166                                             1
 167 (%o1)          [a, b, c, %pi, %e, 1729, ---------]
 168                                         a d - b c
 169 (%i2) L2: [a, b, [c, %pi, [%e, 1729], 1/(a*d - b*c)]];
 170                                              1
 171 (%o2)        [a, b, [c, %pi, [%e, 1729], ---------]]
 172                                          a d - b c
 173 (%i3) L [7];
 174                                 1
 175 (%o3)                       ---------
 176                             a d - b c
 177 (%i4) L2 [3];
 178                                           1
 179 (%o4)            [c, %pi, [%e, 1729], ---------]
 180                                       a d - b c
 181 (%i5) M: matrix ([%pi, 17], [29, %e]);
 182                            [ %pi  17 ]
 183 (%o5)                      [         ]
 184                            [ 29   %e ]
 185 (%i6) M2: matrix ([[%pi, 17], a*d - b*c], [matrix ([1, a], [b, 7]), %e]);
 186                     [ [%pi, 17]  a d - b c ]
 187                     [                      ]
 188 (%o6)               [ [ 1  a ]             ]
 189                     [ [      ]      %e     ]
 190                     [ [ b  7 ]             ]
 191 (%i7) M [2][1];
 192 (%o7)                          29
 193 (%i8) M2 [2][1];
 194                             [ 1  a ]
 195 (%o8)                       [      ]
 196                             [ b  7 ]
 197 \end{verbatim}
 198
 199 \item Construção de programação são expressões.
 200 $x : y$ significa atribua $y$ a $x$; o valor da expressão de atribuição é $y$.
 201 $\mathbf{block}$ agrupa muitas expressões, e as avalia uma vez após outra;
 202 o valor do bloco é o valor da última expressão.
 203 % (a: 42) - (b: 17);
 204 % [a, b];
 205 % block ([a], a: 42, a^2 - 1600) + block ([b], b: 5, %pi^b);
 206 % (if a > 1 then %pi else %e) + (if b < 0 then 1/2 else 1/7);
 207
 208 \begin{verbatim}
 209 (%i1) (a: 42) - (b: 17);
 210 (%o1)                          25
 211 (%i2) [a, b];
 212 (%o2)                       [42, 17]
 213 (%i3) block ([a], a: 42, a^2 - 1600) + block ([b], b: 5, %pi^b);
 214                               5
 215 (%o3)                      %pi  + 164
 216 (%i4) (if a > 1 then %pi else %e) + (if b < 0 then 1/2 else 1/7);
 217                                    1
 218 (%o4)                        %pi + -
 219                                    7
 220 \end{verbatim}
 221
 222 \item $\mathbf{op}$ retorna o operador, $\mathbf{args}$ retorna os argumentos,
 223 $\mathbf{atom}$ diz se uma expressão é um átomo ou não.
 224 % op (p + q);
 225 % op (p + q > p*q);
 226 % op (sin (p + q));
 227 % op (foo (p, q));
 228 % op (foo (p, q) := p - q);
 229 % args (p + q);
 230 % args (p + q > p*q);
 231 % args (sin (p + q));
 232 % args (foo (p, q));
 233 % args (foo (p, q) := p - q);
 234 % atom (p);
 235 % atom (p + q);
 236 % atom (sin (p + q));
 237
 238 \begin{verbatim}
 239 (%i1) op (p + q);
 240 (%o1)                           +
 241 (%i2) op (p + q > p*q);
 242 (%o2)                           >
 243 (%i3) op (sin (p + q));
 244 (%o3)                          sin
 245 (%i4) op (foo (p, q));
 246 (%o4)                          foo
 247 (%i5) op (foo (p, q) := p - q);
 248 (%o5)                          :=
 249 (%i6) args (p + q);
 250 (%o6)                        [q, p]
 251 (%i7) args (p + q > p*q);
 252 (%o7)                     [q + p, p q]
 253 (%i8) args (sin (p + q));
 254 (%o8)                        [q + p]
 255 (%i9) args (foo (p, q));
 256 (%o9)                       [p, - q]
 257 (%i10) args (foo (p, q) := p - q);
 258 (%o10)                 [foo(p, q), p - q]
 259 (%i11) atom (p);
 260 (%o11)                        true
 261 (%i12) atom (p + q);
 262 (%o12)                        false
 263 (%i13) atom (sin (p + q));
 264 (%o13)                        false
 265 \end{verbatim}
 266
 267 \item Operadores e argumentos de construções de programação.
 268 O apóstrofo simples diz ao Maxima para construir a expressão mas não fazer a avaliação para um momento posterior escolhido pelo usuário.
 269 Vamos voltar paa aquele último.
 270 % op ('(block ([a], a: 42, a^2 - 1600)));
 271 % op ('(if p > q then p else q));
 272 % op ('(for x in L do print (x)));
 273 % args ('(block ([a], a: 42, a^2 - 1600)));
 274 % args ('(if p > q then p else q));
 275 % args ('(for x in L do print (x)));
 276
 277 \begin{verbatim}
 278 (%i1) op ('(block ([a], a: 42, a^2 - 1600)));
 279 (%o1)                         block
 280 (%i2) op ('(if p > q then p else q));
 281 (%o2)                          if
 282 (%i3) op ('(for x in L do print (x)));
 283 (%o3)                         mdoin
 284 (%i4) args ('(block ([a], a: 42, a^2 - 1600)));
 285                                    2
 286 (%o4)               [[a], a : 42, a  - 1600]
 287 (%i5) args ('(if p > q then p else q));
 288 (%o5)                  [p > q, p, true, q]
 289 (%i6) args ('(for x in L do print (x)));
 290 (%o6)     [x, L, false, false, false, false, print(x)]
 291 \end{verbatim}
 292
 293 \end{enumerate}
 294
 295 \section{Avaliação}
 296
 297 O valor de um símbolo é uma expressão associada ao símbolo.
 298 Todo símbolo tem um valor;
 299 se não for de outra forma atribuido um valor, um símbolo avalia para si mesmo.
 300 (E.g., $x$ avalia para $x$ se não for de outra forma atribuido um valor.)
 301
 302 Números e seqüências de caractere avaliam para si mesmos.
 303
 304 Um expressão não atômica é avaliada aproximadamente como segue.
 305
 306 \begin{enumerate}
 307 \item Cada argumento do operadro da expressão é avaliado.
 308 \item Se um operador está associado a uma função que pode ser chamada, a função é chamada,
 309 e o valor de retorno da função é o valor da expressão.
 310 \end{enumerate}
 311
 312 Avaliação é modificada de várias maneiras.
 313 Algumas modificações causam menos avaliação:
 314
 315 \begin{enumerate}
 316 \item Algumas funções não avaliam algumas ou todos os seus argumentos,
 317     ou de outra forma modificam a avaliação de seus argumentos.
 318     % Exemplos: $\mathbf{kill}$, $\mathbf{save}$, $\mathbf{sum}$, $\mathbf{:=}$ (definição de função).
 319 \item Um apóstrofo simples $'$ evita avaliação.
 320     \begin{enumerate}
 321     \item $'a$ avalia para $a$. Qualquer outro valor de $a$ é ignorado.
 322     \item $'f(a_1, \ldots, a_n)$ avaliam para $f(\mathbf{ev}(a_1), \ldots, \mathbf{ev}(a_n))$.
 323         É isso, os argumetos são avaliados mas $f$ não é chamada.
 324     \item $'(\ldots)$ evita avaliação de quaisquer expressões dentro de $(...)$.
 325     \end{enumerate}
 326 \end{enumerate}
 327
 328 Algumas modificações causam mais avaliação:
 329
 330 \begin{enumerate}
 331 \item Dois apóstrofos $''a$ causam uma avaliação extra na hora em que a expressão $a$ é passada.
 332 \item $\mathbf{ev}(a)$ causa uma avaliação extra de $a$ toda vez que $\mathbf{ev}(a)$ for avaliado.
 333 \item O idioma $\mathbf{apply}(f, [a_1, \ldots, a_n])$ causa a avaliação
 334     dos argumentos $a_1, \ldots, a_n$ mesmo se $f$ comumente colocar um apoóstrofo nos argumentos $a_1, \ldots, a_n$.
 335 \item $\mathbf{define}$ constrói uma definição de função da mesma forma que $\mathbf{:=}$,
 336     nas $\mathbf{define}$ avalia o corpo da função enquanto $\mathbf{:=}$ coloca um apóstrofo nesse mesmo corpo não avaliando-o portanto.
 337 \end{enumerate}
 338
 339 Vamos considerar como algumas funções são avaliadas.
 340
 341 \begin{enumerate}
 342
 343 \item Símbolos avaliam para simesmos se não forem de outra forma atribuidos a um valor.
 344 % block (a: 1, b: 2, e: 5);
 345 % [a, b, c, d, e];
 346
 347 \begin{verbatim}
 348 (%i1) block (a: 1, b: 2, e: 5);
 349 (%o1)                           5
 350 (%i2) [a, b, c, d, e];
 351 (%o2)                    [1, 2, c, d, 5]
 352 \end{verbatim}
 353
 354 \item Argumentos de um operador são comumente avaliados (a menos que a avaliação seja evitada de uma forma ou de outra).
 355 % block (x: %pi, y: %e);
 356 % sin (x + y);
 357 % x > y;
 358 % x!;
 359
 360 \begin{verbatim}
 361 (%i1) block (x: %pi, y: %e);
 362 (%o1)                          %e
 363 (%i2) sin (x + y);
 364 (%o2)                       - sin(%e)
 365 (%i3) x > y;
 366 (%o3)                       %pi > %e
 367 (%i4) x!;
 368 (%o4)                         %pi!
 369 \end{verbatim}
 370
 371 \item Se um operador corresponde a uma função que pode ser chamada,
 372 a função é chamada (a menos que isso seja evitado por algum meio).
 373 De outra forma eavaliação retorna outra expressão com o mesmo operador.
 374 % foo (p, q) := p - q;
 375 % p: %phi;
 376 % foo (p, q);
 377 % bar (p, q);
 378
 379 \begin{verbatim}
 380 (%i1) foo (p, q) := p - q;
 381 (%o1)                  foo(p, q) := p - q
 382 (%i2) p: %phi;
 383 (%o2)                         %phi
 384 (%i3) foo (p, q);
 385 (%o3)                       %phi - q
 386 (%i4) bar (p, q);
 387 (%o4)                     bar(%phi, q)
 388 \end{verbatim}
 389
 390 \item Algumas funções colocam apóstrofo em seus argumentos.
 391 Exemplos: $\mathbf{save}$, $\mathbf{:=}$, $\mathbf{kill}$.
 392 % block (a: 1, b: %pi, c: x + y);
 393 % [a, b, c];
 394 % save ("tmp.save", a, b, c);
 395 % f (a) := a^b;
 396 % f (7);
 397 % kill (a, b, c);
 398 % [a, b, c];
 399
 400 \begin{verbatim}
 401 (%i1) block (a: 1, b: %pi, c: x + y);
 402 (%o1)                         y + x
 403 (%i2) [a, b, c];
 404 (%o2)                    [1, %pi, y + x]
 405 (%i3) save ("tmp.save", a, b, c);
 406 (%o3)                       tmp.save
 407 (%i4) f (a) := a^b;
 408                                     b
 409 (%o4)                      f(a) := a
 410 (%i5) f (7);
 411                                %pi
 412 (%o5)                         7
 413 (%i6) kill (a, b, c);
 414 (%o6)                         done
 415 (%i7) [a, b, c];
 416 (%o7)                       [a, b, c]
 417 \end{verbatim}
 418
 419 \item Um apóstrofo simples evita avaliação mesmo se isso puder comumente acontecer.
 420 % foo (x, y) := y - x;
 421 % block (a: %e, b: 17);
 422 % foo (a, b);
 423 % foo ('a, 'b);
 424 % 'foo (a, b);
 425 % '(foo (a, b));
 426
 427 \begin{verbatim}
 428 (%i1) foo (x, y) := y - x;
 429 (%o1)                  foo(x, y) := y - x
 430 (%i2) block (a: %e, b: 17);
 431 (%o2)                          17
 432 (%i3) foo (a, b);
 433 (%o3)                        17 - %e
 434 (%i4) foo ('a, 'b);
 435 (%o4)                         b - a
 436 (%i5) 'foo (a, b);
 437 (%o5)                      foo(%e, 17)
 438 (%i6) '(foo (a, b));
 439 (%o6)                       foo(a, b)
 440 \end{verbatim}
 441
 442 \item Dois apóstrofos simples (apóstrofo-apóstrofo) fazem com que ocorra uma avaliação extra na hora em que a expressão for passada.
 443 % diff (sin (x), x);
 444 % foo (x) := diff (sin (x), x);
 445 % foo (x) := ''(diff (sin (x), x));
 446
 447 \begin{verbatim}
 448 (%i1) diff (sin (x), x);
 449 (%o1)                        cos(x)
 450 (%i2) foo (x) := diff (sin (x), x);
 451 (%o2)               foo(x) := diff(sin(x), x)
 452 (%i3) foo (x) := ''(diff (sin (x), x));
 453 (%o3)                   foo(x) := cos(x)
 454 \end{verbatim}
 455
 456 \item $\mathbf{ev}$ faz com que uma avaliação extra ocorra toda vez que isso for avaliado.
 457 Contrasta com o efeito de apóstrofo-apóstrofo.
 458 % block (xx: yy, yy: zz);
 459 % [xx, yy];
 460 % foo (x) := ''x;
 461 % foo (xx);
 462 % bar (x) := ev (x);
 463 % bar (xx);
 464
 465 \begin{verbatim}
 466 (%i1) block (xx: yy, yy: zz);
 467 (%o1)                          zz
 468 (%i2) [xx, yy];
 469 (%o2)                       [yy, zz]
 470 (%i3) foo (x) := ''x;
 471 (%o3)                      foo(x) := x
 472 (%i4) foo (xx);
 473 (%o4)                          yy
 474 (%i5) bar (x) := ev (x);
 475 (%o5)                    bar(x) := ev(x)
 476 (%i6) bar (xx);
 477 (%o6)                          zz
 478 \end{verbatim}
 479
 480 \item $\mathbf{apply}$ faz com que ocorra a avaliação do argumento mesmo mesmo se eles estiverem comumente com apóstrofo.
 481 % block (a: aa, b: bb, c: cc);
 482 % block (aa: 11, bb: 22, cc: 33);
 483 % [a, b, c, aa, bb, cc];
 484 % apply (kill, [a, b, c]);
 485 % [a, b, c, aa, bb, cc];
 486 % kill (a, b, c);
 487 % [a, b, c, aa, bb, cc];
 488
 489 \begin{verbatim}
 490 (%i1) block (a: aa, b: bb, c: cc);
 491 (%o1)                          cc
 492 (%i2) block (aa: 11, bb: 22, cc: 33);
 493 (%o2)                          33
 494 (%i3) [a, b, c, aa, bb, cc];
 495 (%o3)               [aa, bb, cc, 11, 22, 33]
 496 (%i4) apply (kill, [a, b, c]);
 497 (%o4)                         done
 498 (%i5) [a, b, c, aa, bb, cc];
 499 (%o5)               [aa, bb, cc, aa, bb, cc]
 500 (%i6) kill (a, b, c);
 501 (%o6)                         done
 502 (%i7) [a, b, c, aa, bb, cc];
 503 (%o7)                 [a, b, c, aa, bb, cc]
 504 \end{verbatim}
 505
 506 \item $\mathbf{define}$ avalia o corpo de uma definição de função.
 507 % integrate (sin (a*x), x, 0, %pi);
 508 % foo (x) := integrate (sin (a*x), x, 0, %pi);
 509 % define (foo (x), integrate (sin (a*x), x, 0, %pi));
 510
 511 \begin{verbatim}
 512 (%i1) integrate (sin (a*x), x, 0, %pi);
 513                          1   cos(%pi a)
 514 (%o1)                    - - ----------
 515                          a       a
 516 (%i2) foo (x) := integrate (sin (a*x), x, 0, %pi);
 517 (%o2)       foo(x) := integrate(sin(a x), x, 0, %pi)
 518 (%i3) define (foo (x), integrate (sin (a*x), x, 0, %pi));
 519                               1   cos(%pi a)
 520 (%o3)               foo(x) := - - ----------
 521                               a       a
 522 \end{verbatim}
 523
 524 \end{enumerate}
 525
 526 \section{Simplificação}
 527
 528 Após avaliar uma expressão,
 529 Maxima tenta encontrar uma expressão equivalente que é ``mais simples.''
 530 Maxima aplica muitas regras que abrange noções convencionais de simplicidade.
 531 Por exemplo,
 532 $1 + 1$ simplifica para $2$,
 533 $x + x$ simplifica para $2 x$,
 534 and $\mathbf{sin}(\mathbf{\%pi})$ simplifica para $0$.
 535
 536 Todavia,
 537 muitas bem conhecidas identidades não são aplicadas automaticamente.
 538 Por exemplo,
 539 fórmulas de arco duplo para funções trigonométricas,
 540 ou rearranjos de razões tais como $a/b + c/b \rightarrow (a + c)/b$.
 541 Existem muitas funções que podem aplicar identidades.
 542
 543 Simplificação é sempre aplicada a menos que explicitamente evitada.
 544 Simplificação é aplicada mesmo se uma expressão não for avaliada.
 545
 546 $\mathbf{tellsimpafter}$ estabelece regras de simplificação definidas pelo usuário.
 547
 548 Vamos ver alguns exemplos de simplificação.
 549
 550 \begin{enumerate}
 551
 552 \item Apóstrofo evita avaliação mas não simplificação.
 553 Quando o sinalizador global $\mathbf{simp}$ for $\mathbf{false}$,
 554 simplificação é evitada mas não a avaliação.
 555
 556 % '[1 + 1, x + x, x * x, sin (%pi)];
 557 % simp: false$
 558 % block ([x: 1], x + x);
 559 % simp: true$
 560
 561 \begin{verbatim}
 562 (%i1) '[1 + 1, x + x, x * x, sin (%pi)];
 563                                    2
 564 (%o1)                    [2, 2 x, x , 0]
 565 (%i2) simp: false$
 566 (%i3) block ([x: 1], x + x);
 567 (%o3)                         1 + 1
 568 \end{verbatim}
 569
 570 \item Algumas identidade não são aplicadas automaticamente.
 571 $\mathbf{expand}$, $\mathbf{ratsimp}$, $\mathbf{trigexpand}$, $\mathbf{demoivre}$
 572 são algumas funções que aplicam identidades.
 573
 574 % (a + b)^2;
 575 % expand (%);
 576 % a/b + c/b;
 577 % ratsimp (%);
 578 % sin (2*x);
 579 % trigexpand (%);
 580 % a * exp (b * %i);
 581 % demoivre (%);
 582
 583 \begin{verbatim}
 584 (%i1) (a + b)^2;
 585                                    2
 586 (%o1)                       (b + a)
 587 (%i2) expand (%);
 588                           2            2
 589 (%o2)                    b  + 2 a b + a
 590 (%i3) a/b + c/b;
 591                               c   a
 592 (%o3)                         - + -
 593                               b   b
 594 (%i4) ratsimp (%);
 595                               c + a
 596 (%o4)                         -----
 597                                 b
 598 (%i5) sin (2*x);
 599 (%o5)                       sin(2 x)
 600 (%i6) trigexpand (%);
 601 (%o6)                    2 cos(x) sin(x)
 602 (%i7) a * exp (b * %i);
 603                                 %i b
 604 (%o7)                       a %e
 605 (%i8) demoivre (%);
 606 (%o8)                a (%i sin(b) + cos(b))
 607 \end{verbatim}
 608
 609 \end{enumerate}
 610
 611 \section{apply, map, e lambda}
 612
 613 \begin{enumerate}
 614
 615 \item $\mathbf{apply}$ constrói e avalia uma expressão.
 616 Os argumentos da expressão são sempre avaliados (mesmo se eles não puderem ser avaliados de outra forma).
 617 % apply (sin, [x * %pi]);
 618 % L: [a, b, c, x, y, z];
 619 % apply ("+", L);
 620
 621 \begin{verbatim}
 622 (%i1) apply (sin, [x * %pi]);
 623 (%o1)                      sin(%pi x)
 624 (%i2) L: [a, b, c, x, y, z];
 625 (%o2)                  [a, b, c, x, y, z]
 626 (%i3) apply ("+", L);
 627 (%o3)                 z + y + x + c + b + a
 628 \end{verbatim}
 629
 630 \item $\mathbf{map}$ constrói e avalia uma expressão usando ítens individuais de uma lista de argumentos.
 631 Os argumentos de uma expressão sào sempre avaliados (mesmo se eles não puderem ser avaliados de outra forma).
 632 O resultado é uma lista.
 633 % map (foo, [x, y, z]);
 634 % map ("+", [1, 2, 3], [a, b, c]);
 635 % map (atom, [a, b, c, a + b, a + b + c]);
 636
 637 \begin{verbatim}
 638 (%i1) map (foo, [x, y, z]);
 639 (%o1)               [foo(x), foo(y), foo(z)]
 640 (%i2) map ("+", [1, 2, 3], [a, b, c]);
 641 (%o2)                 [a + 1, b + 2, c + 3]
 642 (%i3) map (atom, [a, b, c, a + b, a + b + c]);
 643 (%o3)           [true, true, true, false, false]
 644 \end{verbatim}
 645
 646 \item $\mathbf{lambda}$ constrói uma expressão lambda (i.e., uma função sem nome).
 647 A expressão lambda pode ser usada em alguns contextos como uma função comum que possui nome.
 648 $\mathbf{lambda}$ não avalia o corpo da função.
 649 % f: lambda ([x, y], (x + y)*(x - y));
 650 % f (a, b);
 651 % apply (f, [p, q]);
 652 % map (f, [1, 2, 3], [a, b, c]);
 653 %% apply (lambda ([x, y], (x + y)*(x - y)), [p, q]);
 654 %% map (lambda ([x, y], (x + y)*(x - y)), [1, 2, 3], [a, b, c]);
 655
 656 \begin{verbatim}
 657 (%i1) f: lambda ([x, y], (x + y)*(x - y));
 658 (%o1)            lambda([x, y], (x + y) (x - y))
 659 (%i2) f (a, b);
 660 (%o2)                    (a - b) (b + a)
 661 (%i3) apply (f, [p, q]);
 662 (%o3)                    (p - q) (q + p)
 663 (%i4) map (f, [1, 2, 3], [a, b, c]);
 664 (%o4)  [(1 - a) (a + 1), (2 - b) (b + 2), (3 - c) (c + 3)]
 665 \end{verbatim}
 666
 667 \end{enumerate}
 668
 669 \section{Tipos de objetos internos}
 670
 671 Um objeto é representado como uma expressão.
 672 Como outra expressão, um objeto compreende um operador e seus argumentos.
 673
 674 Os mais importantes tipos de objets internos são listas, matrizes, e conjuntos.
 675
 676 \subsection{Listas}
 677
 678 \begin{enumerate}
 679
 680 \item Uma lista é indicada dessa forma: $[a, b, c]$.
 681
 682 \item If $L$ é uma lista, $L[i]$ é seu $i$'ésimo elemento. $L[1]$ é o primeiro elemento.
 683
 684 \item $\mathbf{map}(\mathit{f}, L)$ aplica $\mathit{f}$ a cada elemento de $L$.
 685
 686 \item $\mathbf{apply}(\mathbf{"+"}, L)$ é a soma dos elementos de $L$.
 687
 688 \item $\mathbf{for\ } x \mathbf{\ in \ } L \mathbf{\ do \ } \mathit{expr}$
 689     avalia $\mathit{expr}$ para cada elemento de $L$.
 690
 691 \item $\mathbf{length}(L)$ é o número de elementos em $L$.
 692
 693 \end{enumerate}
 694
 695 \subsection{Matrizes}
 696
 697 \begin{enumerate}
 698
 699 \item Uma matriz é definida da seguinte forma: $\mathbf{matrix}(L_1, \ldots, L_n)$
 700     onde $L_1, \ldots, L_n$ são listas que representam as linhas da matriz.
 701
 702 \item Se $M$ for uma matriz, $M[i, j]$ ou $M[i][j]$ é seu $(i, j)$'ésimo elemento.
 703     $M[1,1]$ é o elemento no canto superior esquerdo.
 704
 705 \item O operador $\mathbf{.}$ representa multiplicação não comutativa.
 706     $M . L$, $L . M$, e $M . N$ são produtos não comutativos,
 707     onde $L$ é uma lista e $M$ e $N$ são matrizes.
 708
 709 % \item $M\mathbf{\hat{ }\hat{ }}n$ é a potenciação não comutativa, i.e., $M . M . \ldots . M$.
 710
 711 \item $\mathbf{transpose}(M)$ é a transposta de $M$.
 712
 713 \item $\mathbf{eigenvalues}(M)$ retorna o autovalor de $M$.
 714
 715 \item $\mathbf{eigenvectors}(M)$ retorna o autovetor de $M$.
 716
 717 \item $\mathbf{length}(M)$ retorna o nuúmero de linhas de $M$.
 718
 719 \item $\mathbf{length}(\mathbf{transpose}(M))$ retorna o número de colunas de $M$.
 720
 721 \end{enumerate}
 722
 723 \subsection{Conjuntos}
 724
 725 \begin{enumerate}
 726
 727 \item Maxima entende conjuntos finitos explicitamente definidos.
 728     Conjuntos não são o mesmo qque listas; uma conversão explícita é necessária para mudar de um para outro.
 729
 730 \item Um conjunto é especificado dessa forma:
 731     $\mathbf{set}(a, b, c, \ldots)$ onde os elementos do conjunto são $a, b, c, \ldots$.
 732
 733 \item $\mathbf{union} (A, B)$ é a união dos conjuntos $A$ e $B$.
 734
 735 \item $\mathbf{intersection} (A, B)$ é a intersecção dos conjuntos $A$ e $B$.
 736
 737 \item $\mathbf{cardinality} (A)$ é o número de elementos no conjunto $A$.
 738
 739 \end{enumerate}
 740
 741 \section{Como fazer para...}
 742
 743 \subsection{Definir uma função}
 744
 745 \begin{enumerate}
 746
 747 \item O operador $\mathbf{:=}$ define uma função, colocando um apóstrofo no corpo da função.
 748
 749 Nesse exemplo, $\mathbf{diff}$ é reavalado toda vez que a função for chamada.
 750 O argumento é substituído por $x$ e a expressão resultante é avaliada.
 751 Quando o argumento for alguma outra coisa que não um símbolo, isso causa um erro:
 752 para $\mathbf{foo} (1)$ Maxima tenta avaliar $\mathbf{diff} (\mathbf{sin}(1)^2, 1)$.
 753 % foo (x) := diff (sin(x)^2, x);
 754 % foo (u);
 755 % foo (1);
 756
 757 \begin{verbatim}
 758 (%i1) foo (x) := diff (sin(x)^2, x);
 759                                      2
 760 (%o1)              foo(x) := diff(sin (x), x)
 761 (%i2) foo (u);
 762 (%o2)                    2 cos(u) sin(u)
 763 (%i3) foo (1);
 764 Non-variable 2nd argument to diff:
 765 1
 766 #0: foo(x=1)
 767  -- an error.
 768 \end{verbatim}
 769
 770 \item $\mathbf{define}$ define uma função, avaliando o corpo da função.
 771
 772 Nesse exemplo, $\mathbf{diff}$ é avaliado somente uma vez (quando a função é definida).
 773 $\mathbf{foo} (1)$ is OK now.
 774 % define (foo (x), diff (sin(x)^2, x));
 775 % foo (u);
 776 % foo (1);
 777
 778 \begin{verbatim}
 779 (%i1) define (foo (x), diff (sin(x)^2, x));
 780 (%o1)               foo(x) := 2 cos(x) sin(x)
 781 (%i2) foo (u);
 782 (%o2)                    2 cos(u) sin(u)
 783 (%i3) foo (1);
 784 (%o3)                    2 cos(1) sin(1)
 785 \end{verbatim}
 786
 787 \end{enumerate}
 788
 789 \subsection{Resolver uma equação}
 790 % eq_1: a * x + b * y + z = %pi;
 791 % eq_2: z - 5*y + x = 0;
 792 % s: solve ([eq_1, eq_2], [x, z]);
 793 % length (s);
 794 % [subst (s[1], eq_1), subst (s[1], eq_2)];
 795 % ratsimp (%);
 796
 797 \begin{verbatim}
 798 (%i1) eq_1: a * x + b * y + z = %pi;
 799 (%o1)                  z + b y + a x = %pi
 800 (%i2) eq_2: z - 5*y + x = 0;
 801 (%o2)                    z - 5 y + x = 0
 802 (%i3) s: solve ([eq_1, eq_2], [x, z]);
 803                 (b + 5) y - %pi      (b + 5 a) y - %pi
 804 (%o3)   [[x = - ---------------, z = -----------------]]
 805                      a - 1                 a - 1
 806 (%i4) length (s);
 807 (%o4)                           1
 808 (%i5) [subst (s[1], eq_1), subst (s[1], eq_2)];
 809        (b + 5 a) y - %pi   a ((b + 5) y - %pi)
 810 (%o5) [----------------- - ------------------- + b y = %pi,
 811              a - 1                a - 1
 812                    (b + 5 a) y - %pi   (b + 5) y - %pi
 813                    ----------------- - --------------- - 5 y = 0]
 814                          a - 1              a - 1
 815 (%i6) ratsimp (%);
 816 (%o6)                  [%pi = %pi, 0 = 0]
 817 \end{verbatim}
 818
 819 \subsection{Integrar e diferenciar}
 820
 821 $\mathbf{integrate}$ calcular integrais definidas e indefinidas.
 822 % integrate (1/(1 + x), x, 0, 1);
 823 % integrate (exp(-u) * sin(u), u, 0, inf);
 824 % assume (a > 0);
 825 % integrate (1/(1 + x), x, 0, a);
 826 % integrate (exp(-a*u) * sin(a*u), u, 0, inf);
 827 % integrate (exp (sin (t)), t, 0, %pi);
 828 % 'integrate (exp(-u) * sin(u), u, 0, inf);
 829
 830 \begin{verbatim}
 831 (%i1) integrate (1/(1 + x), x, 0, 1);
 832 (%o1)                        log(2)
 833 (%i2) integrate (exp(-u) * sin(u), u, 0, inf);
 834                                 1
 835 (%o2)                           -
 836                                 2
 837 (%i3) assume (a > 0);
 838 (%o3)                        [a > 0]
 839 (%i4) integrate (1/(1 + x), x, 0, a);
 840 (%o4)                      log(a + 1)
 841 (%i5) integrate (exp(-a*u) * sin(a*u), u, 0, inf);
 842                                 1
 843 (%o5)                          ---
 844                                2 a
 845 (%i6) integrate (exp (sin (t)), t, 0, %pi);
 846                          %pi
 847                         /
 848                         [      sin(t)
 849 (%o6)                   I    %e       dt
 850                         ]
 851                         /
 852                          0
 853 (%i7) 'integrate (exp(-u) * sin(u), u, 0, inf);
 854                        inf
 855                       /
 856                       [      - u
 857 (%o7)                 I    %e    sin(u) du
 858                       ]
 859                       /
 860                        0
 861 \end{verbatim}
 862
 863 $\mathbf{diff}$ calcular derivadas.
 864 % diff (sin (y*x));
 865 % diff (sin (y*x), x);
 866 % diff (sin (y*x), y);
 867 % diff (sin (y*x), x, 2);
 868 % 'diff (sin (y*x), x, 2);
 869
 870 \begin{verbatim}
 871 (%i1) diff (sin (y*x));
 872 (%o1)         x cos(x y) del(y) + y cos(x y) del(x)
 873 (%i2) diff (sin (y*x), x);
 874 (%o2)                      y cos(x y)
 875 (%i3) diff (sin (y*x), y);
 876 (%o3)                      x cos(x y)
 877 (%i4) diff (sin (y*x), x, 2);
 878                              2
 879 (%o4)                     - y  sin(x y)
 880 (%i5) 'diff (sin (y*x), x, 2);
 881                           2
 882                          d
 883 (%o5)                    --- (sin(x y))
 884                            2
 885                          dx
 886 \end{verbatim}
 887
 888 \subsection{Fazer um gráfico}
 889
 890 $\mathbf{plot2d}$ desenhar gráficos bidimensionais.
 891 % plot2d (exp(-u) * sin(u), [u, 0, 2*%pi]);
 892 % plot2d ([exp(-u), exp(-u) * sin(u)], [u, 0, 2*%pi]);
 893 % xx: makelist (i/2.5, i, 1, 10);
 894 % yy: map (lambda ([x], exp(-x) * sin(x)), xx);
 895 % plot2d ([discrete, xx, yy]);
 896 % plot2d ([discrete, xx, yy], [gnuplot_curve_styles, ["with points"]]);
 897
 898 \begin{verbatim}
 899 (%i1) plot2d (exp(-u) * sin(u), [u, 0, 2*%pi]);
 900 (%o1)
 901 (%i2) plot2d ([exp(-u), exp(-u) * sin(u)], [u, 0, 2*%pi]);
 902 (%o2)
 903 (%i3) xx: makelist (i/2.5, i, 1, 10);
 904 (%o3)  [0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8, 3.2, 3.6, 4.0]
 905 (%i4) yy: map (lambda ([x], exp(-x) * sin(x)), xx);
 906 (%o4) [0.261034921143457, 0.322328869227062, .2807247779692679,
 907 .2018104299334517, .1230600248057767, .0612766372619573,
 908 .0203706503896865, - .0023794587414574, - .0120913057698414,
 909 - 0.013861321214153]
 910 (%i5) plot2d ([discrete, xx, yy]);
 911 (%o5)
 912 (%i6) plot2d ([discrete, xx, yy], [gnuplot_curve_styles, ["with points"]]);
 913 (%o6)
 914 \end{verbatim}
 915
 916 Veja também $\mathbf{plot3d}$.
 917
 918 \subsection{Gravar e chamar um arquivo}
 919
 920 $\mathbf{save}$ escreve expressões em um arquivo.
 921 % a: foo - bar;
 922 % b: foo^2 * bar;
 923 % save ("my.session", a, b);
 924 % save ("my.session", all);
 925
 926 \begin{verbatim}
 927 (%i1) a: foo - bar;
 928 (%o1)                       foo - bar
 929 (%i2) b: foo^2 * bar;
 930                                    2
 931 (%o2)                       bar foo
 932 (%i3) save ("minha.sessao", a, b);
 933 (%o3)                      minha.sessao
 934 (%i4) save ("minha.sessao", all);
 935 (%o4)                      minha.sessao
 936 \end{verbatim}
 937
 938 $\mathbf{load}$ lê expressões de um arquivo.
 939 % load ("minha.sessao");
 940 % a;
 941 % b;
 942
 943 \begin{verbatim}
 944 (%i1) load ("minha.sessao");
 945 (%o4)                      minha.sessao
 946 (%i5) a;
 947 (%o5)                       foo - bar
 948 (%i6) b;
 949                                    2
 950 (%o6)                       bar foo
 951 \end{verbatim}
 952
 953 Veja também $\mathbf{stringout}$ e $\mathbf{batch}$.
 954
 955 \section{Programando no Maxima}
 956
 957 % dynamic scope
 958 % argument-quoting and argument-evaluating functions
 959 % directory organization: src, tests, share, doc
 960
 961 Existe um ambiente, que contém todos os símbolos do Maxima.
 962 Não existe como criar outro ambiente.
 963
 964 Todas as variáveis são globais a menos que pareçam em uma declaração de variáveis locais.
 965 Funções, expressões lambda, e blocos podem ter variáveis locais.
 966
 967 O valor de uma variável é aquele que foi atribuído mais recentemente,
 968 ou por uma atribuição explícita ou por atribuição de um valor a uma variável local
 969 em um bloco, função, ou expressão lambda.
 970 Essa política é conhecida como {\it escopo dinâmico}.
 971
 972 Se uma variável é uma variável local em uma função, expressão lambda, ou bloco,
 973 seu valor é local mas suas outras propriedades
 974 (como estabelecidas através de $\mathbf{declare}$)
 975 são globais.
 976 A função $\mathbf{local}$ faz uma variável local com relação a todas as propriedades.
 977
 978 Por padrão uma definição de função é global,
 979 mesmo se isso aparecer dentro de uma função, expressão lambda, ou bloco.
 980 $\mathbf{local}(f), f(x) \mathbf{\ :=\ } \ldots$ cria uma definição de função local.
 981
 982 $\mathbf{trace}(\mathit{foo})$ faz com que o Maxima mostre uma mensagem quando a função $\mathit{foo}$
 983 for iniciada e terminada.
 984
 985 Vamos ver alguns exemplos de programação no Maxima.
 986
 987 \begin{enumerate}
 988
 989 \item Todas as variáveis são globais a menos que apareçam em uma declaração de variáveis locais.
 990 Funções, expressões lambda, e blocos podem ter variáveis locais.
 991
 992 % (x: 42, y: 1729, z: foo*bar);
 993 % f (x, y) := x*y*z;
 994 % f (aa, bb);
 995 % lambda ([x, z], (x - z)/y);
 996 % apply (%, [uu, vv]);
 997 % block ([y, z], y: 65536, [x, y, z]);
 998
 999 \begin{verbatim}
1000 (%i1) (x: 42, y: 1729, z: foo*bar);
1001 (%o1)                        bar foo
1002 (%i2) f (x, y) := x*y*z;
1003 (%o2)                   f(x, y) := x y z
1004 (%i3) f (aa, bb);
1005 (%o3)                     aa bar bb foo
1006 (%i4) lambda ([x, z], (x - z)/y);
1007                                      x - z
1008 (%o4)                 lambda([x, z], -----)
1009                                        y
1010 (%i5) apply (%, [uu, vv]);
1011                              uu - vv
1012 (%o5)                        -------
1013                               1729
1014 (%i6) block ([y, z], y: 65536, [x, y, z]);
1015 (%o6)                    [42, 65536, z]
1016 \end{verbatim}
1017
1018 \item O valor de uma variável é aquele que foi atribuido mais recentemente,
1019 ou por atribuição explícita ou por atribuição de um valor a uma variável local.
1020
1021 % foo (y) := x - y;
1022 % x: 1729;
1023 % foo (%pi);
1024 % bar (x) := foo (%e);
1025 % bar (42);
1026
1027 \begin{verbatim}
1028 (%i1) foo (y) := x - y;
1029 (%o1)                    foo(y) := x - y
1030 (%i2) x: 1729;
1031 (%o2)                         1729
1032 (%i3) foo (%pi);
1033 (%o3)                      1729 - %pi
1034 (%i4) bar (x) := foo (%e);
1035 (%o4)                   bar(x) := foo(%e)
1036 (%i5) bar (42);
1037 (%o5)                        42 - %e
1038 \end{verbatim}
1039
1040 \end{enumerate}
1041
1042 \section{Lisp e Maxima}
1043
1044 % symbols, $ e ?
1045 % defining an argument-evaluating function in lisp
1046 % defining an argument-quoting function in lisp
1047 % calling a function defined in maxima from lisp
1048 % useful lisp fcns: meval, simplifya, displa
1049
1050 A construção {\bf :lisp} $\mathit{expr}$ diz ao interpretador Lisp
1051 para avaliar $\mathit{expr}$.
1052 Essa construção é reconhecida em entradas através da linha de comando e em arquivos processados por $\mathbf{batch}$,
1053 mas não é reconhecida por $\mathbf{load}$.
1054
1055 O símbolo Maxima $\mathbf{foo}$ corresponde ao símbolo Lisp \$foo,
1056 e o símbolo Lisp foo corresponde ao símbolo Maxima $\mathbf{?foo}$.
1057
1058 {\bf :lisp} $\mathrm{(}\mathbf{defun\ } \mathrm{\$foo\ (a)\ (\ldots))}$
1059 define uma função Lisp $\mathrm{foo}$ que avalia seus argumentos.
1060 A partir o Maxima, a função é chamada como $\mathbf{foo}(a)$.
1061
1062 {\bf :lisp} $\mathrm{(}\mathbf{defmspec\ } \mathrm{\$foo\ (e)\ (\ldots))}$
1063 define uma função Lisp $\mathbf{foo}$ que coloca uma apóstrofo em seus argumentos não avaliando-os portanto.
1064 A partir do Maxima, a função é chamada como $\mathbf{foo}(a)$.
1065 Os argumentos de $\mathrm{\$foo}$ são $(\mathbf{cdr\ } e),$
1066 e $(\mathbf{caar\ } e)$ é sempre $\mathrm{\$foo}$ por si mesma.
1067
1068 A partir do Lisp, ta construção $(\mathbf{mfuncall\ '\$}\mathrm{foo\ }a_1 \ldots a_n)$
1069 chama a função $\mathbf{foo}$ definida no Maxima.
1070
1071 Vamos extender ao Lisp a partir do Maxima e vice-versa.
1072
1073 \begin{enumerate}
1074
1075 \item A construção {\bf :lisp} $\mathit{expr}$ diz ao interpretador Lisp
1076 para avaliar $\mathit{expr}$.
1077
1078 % (aa + bb)^2;
1079 % :lisp $%
1080 \begin{verbatim}
1081 (%i1) (aa + bb)^2;
1082                                     2
1083 (%o1)                      (bb + aa)
1084 (%i2) :lisp $%
1085 ((MEXPT SIMP) ((MPLUS SIMP) $AA $BB) 2)
1086 \end{verbatim}
1087
1088 \item {\bf :lisp} $\mathrm{(}\mathbf{defun\ } \mathrm{\$foo\ (a)\ (\ldots))}$
1089 define uma função Lisp $\mathbf{foo}$ que avalia seus argumentos.
1090
1091 % :lisp (defun $foo (a b) `((mplus) ((mtimes) ,a ,b) $%pi))
1092 % (p: x + y, q: x - y);
1093 % foo (p, q);
1094 \begin{verbatim}
1095 (%i1) :lisp (defun $foo (a b) `((mplus) ((mtimes) ,a ,b) $%pi))
1096 $FOO
1097 (%i1) (p: x + y, q: x - y);
1098 (%o1)                         x - y
1099 (%i2) foo (p, q);
1100 (%o2)                 (x - y) (y + x) + %pi
1101 \end{verbatim}
1102
1103 \item {\bf :lisp} $\mathrm{(}\mathbf{defmspec\ } \mathrm{\$foo\ (e)\ (\ldots))}$
1104 define uma função Lisp $\mathbf{foo}$ que coloca um apóstrofo em seus argumentos não avaliando-os portanto.
1105 % :lisp (defmspec $bar (e) (let ((a (cdr e))) `((mplus) ((mtimes) ,@a) $%pi)))
1106 % bar (p, q);
1107 % bar (''p, ''q);
1108 \begin{verbatim}
1109 (%i1) :lisp (defmspec $bar (e) (let ((a (cdr e))) `((mplus) ((mtimes) ,@a) $%pi)))
1110 #<CLOSURE LAMBDA (E) (LET ((A (CDR E))) `((MPLUS) ((MTIMES) ,@A) $%PI))>
1111 (%i1) bar (p, q);
1112 (%o1)                       p q + %pi
1113 (%i2) bar (''p, ''q);
1114 (%o2)                       p q + %pi
1115 \end{verbatim}
1116
1117 \item Partindo do Lisp, a construção $(\mathbf{mfuncall\ '\$}\mathrm{foo\ }a_1 \ldots a_n)$
1118 chama a função $\mathbf{foo}$ definida no Maxima.
1119
1120 % blurf (x) := x^2;
1121 % :lisp (displa (mfuncall '$blurf '((mplus) $grotz $mumble)))
1122 \begin{verbatim}
1123 (%i1) blurf (x) := x^2;
1124                                       2
1125 (%o1)                    blurf(x) := x
1126 (%i2) :lisp (displa (mfuncall '$blurf '((mplus) $grotz $mumble)))
1127                 2
1128 (mumble + grotz)
1129 NIL
1130 \end{verbatim}
1131
1132 \end{enumerate}
1133
1134 \end{document}