doc/info/pt_BR/Function.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /Function.texi/1.48/Sat Jun  2 00:12:46 2007/-ko/
   3 @menu
   4 * Introdução a Definição de Função::
   5 * Função::
   6 * Macros::
   7 * Funções e Variáveis para Definição de Função::
   8 @end menu
   9
  10 @node Introdução a Definição de Função, Função, Definição de Função, Definição de Função
  11 @section Introdução a Definição de Função
  12
  13 @node Função, Macros, Introdução a Definição de Função, Definição de Função
  14 @c NEEDS WORK, THIS TOPIC IS IMPORTANT
  15 @c MENTION DYNAMIC SCOPE (VS LEXICAL SCOPE)
  16 @section Função
  17 @subsection Ordinary functions
  18
  19 Para definir uma função no Maxima você usa o operador @code{:=}.
  20 E.g.
  21
  22 @example
  23 f(x) := sin(x)
  24 @end example
  25
  26 @noindent
  27 define uma função @code{f}.
  28 Funções anônimas podem também serem criadas usando @code{lambda}.
  29 Por exemplo
  30
  31 @example
  32 lambda ([i, j], ...)
  33 @end example
  34
  35 @noindent
  36 pode ser usada em lugar de @code{f}
  37 onde
  38
  39 @example
  40 f(i,j) := block ([], ...);
  41 map (lambda ([i], i+1), l)
  42 @end example
  43
  44 @noindent
  45 retornará uma lista com 1 adicionado a cada termo.
  46
  47 Você pode também definir uma função com um número variável de argumentos,
  48 teno um argumento final que é atribuído para uma lista de argumentos
  49 extras:
  50
  51 @example
  52 (%i1) f ([u]) := u;
  53 (%o1)                      f([u]) := u
  54 (%i2) f (1, 2, 3, 4);
  55 (%o2)                     [1, 2, 3, 4]
  56 (%i3) f (a, b, [u]) := [a, b, u];
  57 (%o3)               f(a, b, [u]) := [a, b, u]
  58 (%i4) f (1, 2, 3, 4, 5, 6);
  59 (%o4)                 [1, 2, [3, 4, 5, 6]]
  60 @end example
  61
  62 O lado direito de uma função é uma expressão.  Desse modo
  63 Se você quer uma seq@"{u}ência de expressões, você faz
  64
  65 @example
  66 f(x) := (expr1, expr2, ...., exprn);
  67 @end example
  68
  69 e o valor de @var{exprn} é que é retornado pela função.
  70
  71 Se você deseja fazer um @code{return} de alguma expressão dentro da
  72 função então você deve usar @code{block} e @code{return}.
  73
  74 @example
  75 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)
  76 @end example
  77
  78 é em si mesma uma expressão, e então poderá ocupar o lugar do
  79 lado direito de uma definição de função.  Aqui pode acontecer
  80 que o retorno aconteça mais facilmente que no exemplo anterior a essa última expressão.
  81
  82 @c COPY THIS STUFF TO @defun block AS NEEDED
  83 @c ESPECIALLY STUFF ABOUT LOCAL VARIABLES
  84 O primeiro @code{[]} no bloco, pode conter uma lista de variáveis e
  85 atribuições de variáveis, tais como @code{[a: 3, b, c: []]}, que farão com que as
  86 três variáveis @code{a},@code{b},e @code{c} não se refiram a seus
  87 valores globais, mas ao contrário tenham esses valores especiais enquanto o
  88 código estiver executando a parte dentro do bloco @code{block}, ou dentro da funções chamadas de
  89 dentro do bloco @code{block}.  Isso é chamado associação @i{dynamic}, uma vez que as
  90 variáveis permanecem do início do bloco pelo tempo que ele existir.  Uma vez que
  91 você retorna do @code{block}, ou descarta-o, os valores antigos (quaisquer que
  92 sejam) das variáveis serão restaurados.   É certamente uma boa idéia
  93 para proteger suas variáveis nesse caminho.   Note que as atribuições
  94 em variáveis do bloco, são concluídas em paralelo.   Isso significa, que se
  95 tiver usado @code{c: a} acima, o valor de @code{c} será
  96 o valor de @code{a} a partir do momento em que vocêntrou no bloco,
  97 mas antes @code{a} foi associado.   Dessa forma fazendo alguma coisa como
  98
  99 @example
 100 block ([a: a], expr1, ...  a: a+3, ..., exprn)
 101 @end example
 102
 103 protegerá o valor externo de @code{a} de ser alterado, mas
 104 impedirá você acessar o valor antigo.   Dessa forma o lado direito
 105 de atribuições, é avaliado no contexto inserido, antes que
 106 qualquer avaliação ocorra.
 107 Usando apenas @code{block ([x], ...} faremos com que o @code{x} tenha a si mesmo
 108 como valor, apenas como x teria se você tivesse entrado numa breve sessão do
 109 @b{Maxima}.
 110
 111 Os atuais argumentos para uma função são tratados exatamente da mesma que
 112 as variáveis em um bloco.  Dessa forma em
 113
 114 @example
 115 f(x) := (expr1, ..., exprn);
 116 @end example
 117
 118 e
 119
 120 @example
 121 f(1);
 122 @end example
 123
 124 teremos um contexto similar para avaliação de expressões
 125 como se tivéssemos concluído
 126
 127 @example
 128 block ([x: 1], expr1, ..., exprn)
 129 @end example
 130
 131 Dentro de funções, quando o lado direito de uma definição,
 132 pode ser calculado em tempo de execução, isso é úti para usar @code{define} e
 133 possivelmente @code{buildq}.
 134
 135 @subsection Função de Array
 136
 137 Uma função de Array armazena o valor da função na primeira vez que ela for chamada com um argumento dado,
 138 e retorna o valor armazenado, sem recalcular esse valor, quando o mesmo argumento for fornecido.
 139 De modo que uma função é muitas vezes chamada uma @i{função de memorização}.
 140
 141 Nomes de funções de Array são anexados ao final da lista global @code{arrays}
 142 (não na lista global @code{functions}).
 143 O comando @code{arrayinfo} retorna a lista de argumentos para os quais exite valores armazenados,
 144 e @code{listarray} retorna os valores armazenados.
 145 Os comandos @code{dispfun} e @code{fundef} retornam a definição da função de array.
 146
 147 O comando @code{arraymake} contrói uma chamada de função de array,
 148 análogamente a @code{funmake} para funções comuns.
 149 O comando @code{arrayapply} aplica uma função de array a seus argmentos,
 150 análogamente a @code{apply} para funções comuns.
 151 Não existe nada exatamente análogo a @code{map} para funções de array,
 152 embora @code{map(lambda([@var{x}], @var{a}[@var{x}]), @var{L})} ou
 153 @code{makelist(@var{a}[@var{x}], @var{x}, @var{L})}, onde @var{L} é uma lista,
 154 não estejam tão longe disso.
 155
 156 O comando @code{remarray} remove uma definição de função de array (incluindo qualquer valor armazenado pela função removida),
 157 análogo a @code{remfunction} para funções comuns.
 158
 159 o comando @code{kill(@var{a}[@var{x}])} remove o valor da função de array @var{a}
 160 armazenado para o argumento @var{x};
 161 a próxima vez que @var{a} foor chamada com o argumento @var{x},
 162 o valor da função é recomputado.
 163 Todavia, não exite caminho para remover todos os valores armazenados de uma vez,
 164 exceto para @code{kill(@var{a})} ou @code{remarray(@var{a})},
 165 o qual remove também remove a definição da função de array.
 166
 167 @node Macros, Funções e Variáveis para Definição de Função, Função, Definição de Função
 168 @section Macros
 169
 170 @deffn {Função} buildq (@var{L}, @var{expr})
 171 Substitue variáveis nomeadas pela lista @var{L} dentro da expressão @var{expr},
 172 paralelamente,
 173 sem avaliar @var{expr}.
 174 A expressão resultante é simplificada,
 175 mas não avaliada,
 176 após @code{buildq} realizar a substituição.
 177
 178 Os elementos de @var{L} são símbolos ou expressões de atribuição @code{@var{símbolo}: @var{valor}},
 179 avaliadas paralelamente.
 180 Isto é, a associação de uma variável sobre o lado direito de uma atribuição
 181 é a associação daquela variável no contexto do qual @code{buildq} for chamada,
 182 não a associação daquela variável na lista @var{L} de variáveis.
 183 Se alguma variável em @var{L} não dada como uma atribuição explícita,
 184 sua associação em @code{buildq} é a mesma que no contexto no qual @code{buildq} for chamada.
 185
 186 Então as variáveis nomeadas em @var{L} são substituidas em @var{expr} paralelamente.
 187 Isto é, a substituição para cada variável é determinada antes que qualquer substituição seja feita,
 188 então a substituição para uma variável não tem efeito sobre qualquer outra.
 189
 190 Se qualquer variável @var{x} aparecer como @code{splice (@var{x})} em @var{expr},
 191 então @var{x} deve estar associada para uma lista,
 192 e a lista recebe uma aplicação da função @code{splice} (é interpolada) na @var{expr} em lugar de substituída.
 193
 194 Quaisquer variáveis em @var{expr} não aparecendo em @var{L} são levados no resultado tal como foram escritos,
 195 mesmo se elas tiverem associações no contexto do qual @code{buildq} tiver sido chamada.
 196
 197 Exemplos
 198
 199 @code{a} é explicitamente associada a @code{x},
 200 enquanto @code{b} tem a mesma associação (nomeadamente 29) como no contexto chamado,
 201 e @code{c} é levada do começo ao fim da forma como foi escrita.
 202 A expressão resultante não é avaliada até a avaliação explícita ( com duplo apóstrofo - não com aspas - @code{''%}.
 203
 204 @c ===beg===
 205 @c (a: 17, b: 29, c: 1729)$
 206 @c buildq ([a: x, b], a + b + c);
 207 @c ''%;
 208 @c ===end===
 209 @example
 210 (%i1) (a: 17, b: 29, c: 1729)$
 211 (%i2) buildq ([a: x, b], a + b + c);
 212 (%o2)                      x + c + 29
 213 (%i3) ''%;
 214 (%o3)                       x + 1758
 215 @end example
 216
 217 @code{e} está associado a uma lista, a qual aparece também como tal nos argumentos de @code{foo},
 218 e interpolada nos argumentos de @code{bar}.
 219
 220 @c ===beg===
 221 @c buildq ([e: [a, b, c]], foo (x, e, y));
 222 @c buildq ([e: [a, b, c]], bar (x, splice (e), y));
 223 @c ===end===
 224 @example
 225 (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
 226 (%o1)                 foo(x, [a, b, c], y)
 227 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
 228 (%o2)                  bar(x, a, b, c, y)
 229 @end example
 230
 231 O resultado é simplificado após substituição.
 232 Se a simplificação for aplicada antes da substituição, esses dois resultados podem ser iguais.
 233 @c ===beg===
 234 @c buildq ([e: [a, b, c]], splice (e) + splice (e));
 235 @c buildq ([e: [a, b, c]], 2 * splice (e));
 236 @c ===end===
 237 @example
 238 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
 239 (%o1)                    2 c + 2 b + 2 a
 240 (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
 241 (%o2)                        2 a b c
 242 @end example
 243
 244 As variáveis em @var{L} são associadas em paralelo; se associadas seq@"{u}êncialmente,
 245 o primeiro resultado pode ser @code{foo (b, b)}.
 246 Substituições são realizadas em paralelo;
 247 compare o segundo resultado com o resultado de @code{subst},
 248 que realiza substituições seq@"{u}êncialmente.
 249
 250 @c ===beg===
 251 @c buildq ([a: b, b: a], foo (a, b));
 252 @c buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
 253 @c subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
 254 @c ===end===
 255 @example
 256 (%i1) buildq ([a: b, b: a], foo (a, b));
 257 (%o1)                       foo(b, a)
 258 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
 259 (%o2)                 bar(v, w, x, y, z, u)
 260 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
 261 (%o3)                 bar(u, u, u, u, u, u)
 262 @end example
 263
 264 Constrói uma lista de euqções com algumas variáveis ou expressões sobre o lado esquerdo
 265 e seus valores sobre o lado direito.
 266 @code{macroexpand} mostra a expressão retornada por @code{show_values}.
 267
 268 @c ===beg===
 269 @c show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
 270 @c (a: 17, b: 29, c: 1729)$
 271 @c show_values (a, b, c - a - b);
 272 @c macroexpand (show_values (a, b, c - a - b));
 273 @c ===end===
 274 @example
 275 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
 276 (%o1)   show_values([L]) ::= buildq([L], map("=", 'L, L))
 277 (%i2) (a: 17, b: 29, c: 1729)$
 278 (%i3) show_values (a, b, c - a - b);
 279 (%o3)          [a = 17, b = 29, c - b - a = 1683]
 280 (%i4) macroexpand (show_values (a, b, c - a - b));
 281 (%o4)    map(=, '([a, b, c - b - a]), [a, b, c - b - a])
 282 @end example
 283
 284 @end deffn
 285
 286 @deffn {Função} macroexpand (@var{expr})
 287 Retorna a expansão da macro de @var{expr} sem avaliar a expressão,
 288 quando @code{expr} for uma chamada de função de macro.
 289 De outra forma, @code{macroexpand} retorna @var{expr}.
 290
 291 Se a expansão de @var{expr} retorna outra chamada de função de macro,
 292 aquela chamada de função de macro é também expandida.
 293
 294 @code{macroexpand} coloca apóstrofo em seus argumentos, isto é, não os avalia.
 295 Todavia, se a expansão de uma chamada de função de macro tiver algum efeito,
 296 esse efeito colateral é executado.
 297
 298 Veja também @code{::=}, @code{macros}, e @code{macroexpand1}.
 299
 300 Exemplos
 301
 302 @c ===beg===
 303 @c g (x) ::= x / 99;
 304 @c h (x) ::= buildq ([x], g (x - a));
 305 @c a: 1234;
 306 @c macroexpand (h (y));
 307 @c h (y);
 308 @c ===end===
 309 @example
 310 (%i1) g (x) ::= x / 99;
 311                                     x
 312 (%o1)                      g(x) ::= --
 313                                     99
 314 (%i2) h (x) ::= buildq ([x], g (x - a));
 315 (%o2)            h(x) ::= buildq([x], g(x - a))
 316 (%i3) a: 1234;
 317 (%o3)                         1234
 318 (%i4) macroexpand (h (y));
 319                               y - a
 320 (%o4)                         -----
 321                                99
 322 (%i5) h (y);
 323                             y - 1234
 324 (%o5)                       --------
 325                                99
 326 @end example
 327
 328 @end deffn
 329
 330 @deffn {Função} macroexpand1 (@var{expr})
 331 Retorna a expansão de macro de @var{expr} sem avaliar a expressão,
 332 quando @code{expr} for uma chamada de função de macro.
 333 De outra forma, @code{macroexpand1} retorna @var{expr}.
 334
 335 @code{macroexpand1} não avalia seus argumentos.
 336 Todavia, se a expansão de uma chamada de função de macro tiver algum efeito,
 337 esse efeito colateral é executado.
 338
 339 Se a expansão de @var{expr} retornar outra chamada de função de macro,
 340 aquela chamada de função de macro não é expandida.
 341
 342 Veja também @code{::=}, @code{macros}, e @code{macroexpand}.
 343
 344 Exemplos
 345
 346 @c ===beg===
 347 @c g (x) ::= x / 99;
 348 @c h (x) ::= buildq ([x], g (x - a));
 349 @c a: 1234;
 350 @c macroexpand1 (h (y));
 351 @c h (y);
 352 @c ===end===
 353 @example
 354 (%i1) g (x) ::= x / 99;
 355                                     x
 356 (%o1)                      g(x) ::= --
 357                                     99
 358 (%i2) h (x) ::= buildq ([x], g (x - a));
 359 (%o2)            h(x) ::= buildq([x], g(x - a))
 360 (%i3) a: 1234;
 361 (%o3)                         1234
 362 (%i4) macroexpand1 (h (y));
 363 (%o4)                       g(y - a)
 364 (%i5) h (y);
 365                             y - 1234
 366 (%o5)                       --------
 367                                99
 368 @end example
 369
 370 @end deffn
 371
 372 @defvr {Global variable} macros
 373 Default value: @code{[]}
 374
 375 @code{macros} é a lista de funções de macro definidas pelo usuário.
 376 O operador de definição de função de macro @code{::=} coloca uma nova função de macro nessa lista,
 377 e @code{kill}, @code{remove}, e @code{remfunction} removem funções de macro da lista.
 378
 379 Veja também @code{infolists}.
 380
 381 @end defvr
 382
 383 @deffn {Função} splice (@var{a})
 384 Une como se fosse um elo de ligação (interpola) a lista nomeada através do átomo @var{a} em uma expressão,
 385 mas somente se @code{splice} aparecer dentro de @code{buildq};
 386 de outra forma, @code{splice} é tratada como uma função indefinida.
 387 Se aparecer dentro de @code{buildq} com @var{a} sozinho (sem @code{splice}),
 388 @var{a} é substituido (não interpolado) como uma lista no resultado.
 389 O argumento de @code{splice} pode somente ser um átomo;
 390 não pode ser uma lista lateral ou uma expressão que retorna uma lista.
 391
 392 Tipicamente @code{splice} fornece os argumentos para uma função ou operador.
 393 Para uma função @code{f}, a expressão @code{f (splice (@var{a}))} dentro de @code{buildq}
 394 expande para @code{f (@var{a}[1], @var{a}[2], @var{a}[3], ...)}.
 395 Para um operador @code{o}, a expressão @code{"o" (splice (@var{a})} dentro de @code{buildq}
 396 expande para @code{"o" (@var{a}[1], @var{a}[2], @var{a}[3], ...)},
 397 onde @code{o} pode ser qualquer tipo de operador (tipicamente um que toma multiplos argumentos).
 398 Note que o operador deve ser contido dentro de aspas duplas @code{"}.
 399
 400 Exemplos
 401
 402 @c ===beg===
 403 @c buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
 404 @c buildq ([x: [1, %pi]], "/" (splice (x)));
 405 @c matchfix ("<>", "<>");
 406 @c buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
 407 @c ===end===
 408 @example
 409 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
 410                        foo(1, %pi, z - y)
 411 (%o1)                -----------------------
 412                      length([1, %pi, z - y])
 413 (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
 414                                 1
 415 (%o2)                          ---
 416                                %pi
 417 (%i3) matchfix ("<>", "<>");
 418 (%o3)                          <>
 419 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
 420 (%o4)                   <>1, %pi, z - y<>
 421 @end example
 422
 423 @end deffn
 424
 425
 426 @c end concepts Definição de Função
 427 @node Funções e Variáveis para Definição de Função,  , Macros, Definição de Função
 428 @section Funções e Variáveis para Definição de Função
 429
 430 @deffn {Função} apply (@var{F}, [@var{x_1}, ..., @var{x_n}])
 431 Constrói e avalia uma expressãp @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
 432
 433 @code{apply} não tenta distinguir funções de array de funções comuns;
 434 quando @var{F} for o nome de uma função de array,
 435 @code{apply} avalia @code{@var{F}(...)}
 436 (isto é, uma chamada de função com parêntesis em lugar de colchêtes).
 437 @code{arrayapply} avalia uma chamada de função com colchêtes nesse caso.
 438
 439 Exemplos:
 440
 441 @code{apply} avalia seus argumentos.
 442 Nesse exemplo, @code{min} é aplicado a @code{L}.
 443
 444 @c ===beg===
 445 @c L : [1, 5, -10.2, 4, 3];
 446 @c apply (min, L);
 447 @c ===end===
 448 @example
 449 (%i1) L : [1, 5, -10.2, 4, 3];
 450 (%o1)                 [1, 5, - 10.2, 4, 3]
 451 (%i2) apply (min, L);
 452 (%o2)                        - 10.2
 453 @end example
 454
 455 @code{apply} avalia argumentos, mesmo se a função @var{F} disser que os argumentos não devem ser avaliados.
 456
 457 @c ===beg===
 458 @c F (x) := x / 1729;
 459 @c fname : F;
 460 @c dispfun (F);
 461 @c dispfun (fname);
 462 @c apply (dispfun, [fname]);
 463 @c ===end===
 464 @example
 465 (%i1) F (x) := x / 1729;
 466                                    x
 467 (%o1)                     F(x) := ----
 468                                   1729
 469 (%i2) fname : F;
 470 (%o2)                           F
 471 (%i3) dispfun (F);
 472                                    x
 473 (%t3)                     F(x) := ----
 474                                   1729
 475
 476 (%o3)                         [%t3]
 477 (%i4) dispfun (fname);
 478 fname is not the name of a user function.
 479  -- an error.  Quitting.  To debug this try debugmode(true);
 480 (%i5) apply (dispfun, [fname]);
 481                                    x
 482 (%t5)                     F(x) := ----
 483                                   1729
 484
 485 (%o5)                         [%t5]
 486 @end example
 487
 488 @code{apply} avalia o nome de função @var{F}.
 489 Apóstrofo @code{'} evita avaliação.
 490 @code{demoivre} é o nome de uma variável global e também de uma função.
 491
 492 @c ===beg===
 493 @c demoivre;
 494 @c demoivre (exp (%i * x));
 495 @c apply (demoivre, [exp (%i * x)]);
 496 @c apply ('demoivre, [exp (%i * x)]);
 497 @c ===end===
 498 @example
 499 (%i1) demoivre;
 500 (%o1)                         false
 501 (%i2) demoivre (exp (%i * x));
 502 (%o2)                  %i sin(x) + cos(x)
 503 (%i3) apply (demoivre, [exp (%i * x)]);
 504 demoivre evaluates to false
 505 Improper name or value in functional position.
 506  -- an error.  Quitting.  To debug this try debugmode(true);
 507 (%i4) apply ('demoivre, [exp (%i * x)]);
 508 (%o4)                  %i sin(x) + cos(x)
 509 @end example
 510
 511 @end deffn
 512
 513
 514 @deffn {Função} block ([@var{v_1}, ..., @var{v_m}], @var{expr_1}, ..., @var{expr_n})
 515 @deffnx {Função} block (@var{expr_1}, ..., @var{expr_n})
 516 @code{block} avalia @var{expr_1}, ..., @var{expr_n} em seq@"{u}ência
 517 e retorna o valor da última expressão avaliada.
 518 A seq@"{u}ência pode ser modificada pelas funções @code{go}, @code{throw}, e @code{return}.
 519 A última expressão é @var{expr_n} a menos que @code{return} ou uma expressão contendo @code{throw}
 520 seja avaliada.
 521 Algumas variáveis @var{v_1}, ..., @var{v_m} podem ser declaradas locais para o bloco;
 522 essas são distinguidas das variáveis globais dos mesmos nomes.
 523 Se variáveis não forem declaradas locais então a lista pode ser omitida.
 524 Dentro do bloco,
 525 qualquer variável que não @var{v_1}, ..., @var{v_m} é uma variável global.
 526
 527 @code{block} salva os valores correntes das variáveis @var{v_1}, ..., @var{v_m} (quaisquer valores)
 528 na hora da entrada para o bloco,
 529 então libera as variáveis dessa forma eles avaliam para si mesmos.
 530 As variáveis locais podem ser associadas a valores arbitrários dentro do bloco mas quando o
 531 bloco é encerrado o valores salvos são restaurados,
 532 e os valores atribuídos dentro do bloco são perdidos.
 533
 534 @code{block} pode aparecer dentro de outro @code{block}.
 535 Variáveis locais são estabelecidas cada vez que um novo @code{block} é avaliado.
 536 Variáveis locais parecem ser globais para quaisquer blocos fechados.
 537 Se uma variável é não local em um bloco,
 538 seu valor é o valor mais recentemente atribuído por um bloco fechado, quaisquer que sejam,
 539 de outra forma, seu valor é o valor da variável no ambiente global.
 540 Essa política pode coincidir com o entendimento usual de "escopo dinâmico".
 541
 542 Se isso for desejado para salvar e restaurar outras propriedades locais
 543 ao lado de @code{value}, por exemplo @code{array} (exceto para arrays completos),
 544 @code{function}, @code{dependencies}, @code{atvalue}, @code{matchdeclare}, @code{atomgrad}, @code{constant}, e
 545 @code{nonscalar} então a função @code{local} pode ser usada dentro do bloco
 546 com argumentos sendo o nome das variáveis.
 547
 548 O valor do bloco é o valor da última declaração ou o
 549 valor do argumento para a função @code{return} que pode ser usada para sair
 550 explicitamente do bloco.  A função @code{go} pode ser usada para transferir o
 551 controle para a declaração do bloco que é identificada com o argumento
 552 para @code{go}.  Para identificar uma declaração, coloca-se antes dela um argumento atômico como
 553 outra declaração no bloco.  Por exemplo:
 554 @code{block ([x], x:1, loop, x: x+1, ..., go(loop), ...)}.  O argumento para @code{go} deve
 555 ser o nome de um identificador que aparece dentro do bloco.  Não se deve usar @code{go} para
 556 transferir para um identificador em um outro bloco a não ser esse que contém o @code{go}.
 557
 558 Blocos tipicamente aparecem do lado direito de uma definição de função
 559 mas podem ser usados em outros lugares também.
 560
 561 @end deffn
 562
 563 @c REPHRASE, NEEDS EXAMPLE
 564 @deffn {Função} break (@var{expr_1}, ..., @var{expr_n})
 565 Avalia e imprime @var{expr_1}, ..., @var{expr_n} e então
 566 causa uma parada do Maxima nesse ponto e o usuário pode examinar e alterar
 567 seu ambiente.  Nessa situação digite @code{exit;} para que o cálculo seja retomado.
 568
 569 @end deffn
 570
 571 @c FOR SOME REASON throw IS IN SOME OTHER FILE.  MOVE throw INTO THIS FILE.
 572 @c NEEDS CLARIFICATION
 573 @deffn {Função} catch (@var{expr_1}, ..., @var{expr_n})
 574 Avalia @var{expr_1}, ..., @var{expr_n} uma por uma; se qualquer avaliação
 575 levar a uma avaliação de uma expressão da
 576 forma @code{throw (arg)}, então o valor de @code{catch} é o valor de
 577 @code{throw (arg)}, e expressões adicionais não são avaliadas.
 578 Esse "retorno não local" atravessa assim qualquer profundidade de
 579 aninhar para o mais próximo contendo @code{catch}.
 580 Se não existe nenhum @code{catch} contendo um @code{throw}, uma mensagem de erro é impressa.
 581
 582 Se a avaliação de argumentos não leva para a avaliação de qualquer @code{throw}
 583 então o valor de @code{catch} é o valor de @var{expr_n}.
 584
 585 @example
 586 (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
 587 (%i2) g(l) := catch (map (''%, l))$
 588 (%i3) g ([1, 2, 3, 7]);
 589 (%o3)               [f(1), f(2), f(3), f(7)]
 590 (%i4) g ([1, 2, -3, 7]);
 591 (%o4)                          - 3
 592 @end example
 593
 594 @c REWORD THIS PART.
 595 A função @code{g} retorna uma lista de @code{f} de cada elemento de @code{l} se @code{l}
 596 consiste somente de números não negativos; de outra forma, @code{g} "captura" o
 597 primeiro elemento negativo de @code{l} e "arremessa-o".
 598
 599 @end deffn
 600
 601 @deffn {Função} compfile (@var{nomearquivo}, @var{f_1}, ..., @var{f_n})
 602 @deffnx {Função} compfile (@var{nomearquivo}, funções)
 603 @deffnx {Função} compfile (@var{nomearquivo}, all)
 604
 605 Traduz fuções Maxima para Lisp
 606 e escreve o código traduzido no arquivo @var{nomearquivo}.
 607
 608 @code{compfile(@var{nomearquivo}, @var{f_1}, ..., @var{f_n})} traduz as
 609 funções especificadas.
 610 @code{compfile(@var{nomearquivo}, functions)} e @code{compfile(@var{nomearquivo}, all)}
 611 traduz todas as funções definidas pelo usuário.
 612
 613 As traduções Lisp não são avaliadas, nem é o arquivo de saída processado pelo compilador Lisp.
 614 @c SO LET'S CONSIDER GIVING THIS FUNCTION A MORE ACCURATE NAME.
 615 @code{translate} cria e avalia traduções Lisp.
 616 @code{compile_file} traduz Maxima para Lisp, e então executa o compilador Lisp.
 617
 618 Veja também @code{translate}, @code{translate_file}, e @code{compile_file}.
 619
 620 @end deffn
 621
 622 @c THIS VARIABLE IS OBSOLETE: ASSIGNING compgrind: true CAUSES compfile
 623 @c TO EVENTUALLY CALL AN OBSOLETE FUNCTION SPRIN1.
 624 @c RECOMMENDATION IS TO CUT THIS ITEM, AND CUT $compgrind FROM src/transs.lisp
 625 @c @defvar compgrind
 626 @c Default value: @code{false}
 627 @c
 628 @c When @code{compgrind} é @code{true}, function definitions printed by
 629 @c @code{compfile} are pretty-printed.
 630 @c
 631 @c @end defvar
 632
 633 @deffn {Função} compile (@var{f_1}, ..., @var{f_n})
 634 @deffnx {Função} compile (funções)
 635 @deffnx {Função} compile (all)
 636 Traduz funções Maxima @var{f_1}, ..., @var{f_n} para Lisp, avalia a tradução Lisp,
 637 e chama a função Lisp @code{COMPILE} sobre cada função traduzida.
 638 @code{compile} retorna uma lista de nomes de funções compiladas.
 639
 640 @code{compile (all)} ou @code{compile (funções)} compila todas as funções definidas pelo usuário.
 641
 642 @code{compile} não avalia seus argumentos;
 643 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação sobrepondo-se ao apóstrofo.
 644
 645 @end deffn
 646
 647 @deffn {Função} define (@var{f}(@var{x_1}, ..., @var{x_n}), @var{expr})
 648 @deffnx {Função} define (@var{f}[@var{x_1}, ..., @var{x_n}], @var{expr})
 649 @deffnx {Função} define (funmake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
 650 @deffnx {Função} define (arraymake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
 651 @deffnx {Função} define (ev (@var{expr_1}), @var{expr_2})
 652
 653 Define uma função chamada @var{f} com argumentos @var{x_1}, ..., @var{x_n} e corpo da função @var{expr}.
 654 @code{define} sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliação).
 655 A função então definida pode ser uma função comum do Maxima (com argumentos contidos entre parêtesis)
 656 ou uma função de array (com argumentos contidos entre colchêtes).
 657
 658 Quando o último ou único argumento da função @var{x_n} for uma lista de um elemento,
 659 a função definida por @code{define} aceita um número variável de argumentos.
 660 Os argumentos atuais são atribuídos um a um a argumentos formais @var{x_1}, ..., @var{x_(n - 1)},
 661 e quaisquer argumentos adicionais atuais, se estiverem presentes, são atribuídos a @var{x_n} como uma lista.
 662
 663 Quando o primeiro argumento de @code{define} for uma expressão da forma
 664 @code{@var{f}(@var{x_1}, ..., @var{x_n})} or @code{@var{f}[@var{x_1}, ..., @var{x_n}]},
 665 os argumentos são avaliados mas @var{f} não é avaliada,
 666 mesmo se já existe anteriormente uma função ou variável com aquele nome.
 667
 668 Quando o primeiro argumento for uma expressão com operador @code{funmake}, @code{arraymake}, ou @code{ev},
 669 o primeiro argumento será avaliado;
 670 isso permite para o nome da função seja calculado, também como o corpo.
 671
 672 Todas as definições de função aparecem no mesmo nível de escopo e visibilidade;
 673 definindo uma função @code{f} dentro de outra função @code{g}
 674 não limita o escopo de @code{f} a @code{g}.
 675
 676 Se algum argumento formal @var{x_k} for um símbolo com apóstrofo (após ter sido feita uma avaliação),
 677 a função definida por @code{define} não avalia o correspondente atual argumento.
 678 de outra forma todos os argumentos atuais são avaliados.
 679
 680 Veja também @code{:=} and @code{::=}.
 681
 682 Exemplos:
 683
 684 @code{define} sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliação).
 685
 686 @c ===beg===
 687 @c expr : cos(y) - sin(x);
 688 @c define (F1 (x, y), expr);
 689 @c F1 (a, b);
 690 @c F2 (x, y) := expr;
 691 @c F2 (a, b);
 692 @c ===end===
 693 @example
 694 (%i1) expr : cos(y) - sin(x);
 695 (%o1)                    cos(y) - sin(x)
 696 (%i2) define (F1 (x, y), expr);
 697 (%o2)              F1(x, y) := cos(y) - sin(x)
 698 (%i3) F1 (a, b);
 699 (%o3)                    cos(b) - sin(a)
 700 (%i4) F2 (x, y) := expr;
 701 (%o4)                   F2(x, y) := expr
 702 (%i5) F2 (a, b);
 703 (%o5)                    cos(y) - sin(x)
 704 @end example
 705
 706 A função definida por @code{define} pode ser uma função comum do Maxima ou uma função de array.
 707
 708 @c ===beg===
 709 @c define (G1 (x, y), x.y - y.x);
 710 @c define (G2 [x, y], x.y - y.x);
 711 @c ===end===
 712 @example
 713 (%i1) define (G1 (x, y), x.y - y.x);
 714 (%o1)               G1(x, y) := x . y - y . x
 715 (%i2) define (G2 [x, y], x.y - y.x);
 716 (%o2)                G2     := x . y - y . x
 717                        x, y
 718 @end example
 719
 720 Quando o último ou único argumento da função @var{x_n} for uma lista de um único elemento,
 721 a função definida por @code{define} aceita um número variável de argumentos.
 722
 723 @c ===beg===
 724 @c define (H ([L]), '(apply ("+", L)));
 725 @c H (a, b, c);
 726 @c ===end===
 727 @example
 728 (%i1) define (H ([L]), '(apply ("+", L)));
 729 (%o1)                H([L]) := apply("+", L)
 730 (%i2) H (a, b, c);
 731 (%o2)                       c + b + a
 732 @end example
 733
 734 When the first argument is an expression with operator @code{funmake}, @code{arraymake}, or @code{ev},
 735 the first argument is evaluated.
 736
 737 @c ===beg===
 738 @c [F : I, u : x];
 739 @c funmake (F, [u]);
 740 @c define (funmake (F, [u]), cos(u) + 1);
 741 @c define (arraymake (F, [u]), cos(u) + 1);
 742 @c define (foo (x, y), bar (y, x));
 743 @c define (ev (foo (x, y)), sin(x) - cos(y));
 744 @c ===end===
 745 @example
 746 (%i1) [F : I, u : x];
 747 (%o1)                        [I, x]
 748 (%i2) funmake (F, [u]);
 749 (%o2)                         I(x)
 750 (%i3) define (funmake (F, [u]), cos(u) + 1);
 751 (%o3)                  I(x) := cos(x) + 1
 752 (%i4) define (arraymake (F, [u]), cos(u) + 1);
 753 (%o4)                   I  := cos(x) + 1
 754                          x
 755 (%i5) define (foo (x, y), bar (y, x));
 756 (%o5)                foo(x, y) := bar(y, x)
 757 (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
 758 (%o6)             bar(y, x) := sin(x) - cos(y)
 759 @end example
 760
 761 @end deffn
 762
 763 @c SEE NOTE BELOW ABOUT THE DOCUMENTATION STRING
 764 @c @deffn {Função} define_variable (@var{name}, @var{default_value}, @var{mode}, @var{documentation})
 765 @deffn {Função} define_variable (@var{name}, @var{default_value}, @var{mode})
 766
 767 Introduz uma variável global dentro do ambiente Maxima.
 768 @c IMPORT OF FOLLOWING STATEMENT UNCLEAR: IN WHAT WAY IS define_variable MORE USEFUL IN TRANSLATED CODE ??
 769 @code{define_variable} é útil em pacotes escritos pelo usuário, que são muitas vezes traduzidos ou compilados.
 770
 771 @code{define_variable} realiza os seguintes passos:
 772
 773 @enumerate
 774 @item
 775 @code{mode_declare (@var{name}, @var{mode})} declara o modo de @var{name} para o tradutor.
 776 Veja @code{mode_declare} para uma lista dos modos possíveis.
 777
 778 @item
 779 Se a variável é não associada, @var{default_value} é atribuído para @var{name}.
 780
 781 @item
 782 @code{declare (@var{name}, special)} declara essa variável especial.
 783 @c CLARIFY THE MEANING OF SPECIAL FOR THE BENEFIT OF READERS OTHER THAN LISP PROGRAMMERS
 784
 785 @item
 786 Associa @var{name} com uma função de teste
 787 para garantir que a @var{name} seja somente atribuído valores do modo declarado.
 788 @end enumerate
 789
 790
 791 @c FOLLOWING STATEMENT APPEARS TO BE OUT OF DATE.
 792 @c EXAMINING DEFMSPEC $DEFINE_VARIABLE AND DEF%TR $DEFINE_VARIABLE IN src/trmode.lisp,
 793 @c IT APPEARS THAT THE 4TH ARGUMENT IS NEVER REFERRED TO.
 794 @c EXECUTING translate_file ON A MAXIMA BATCH FILE WHICH CONTAINS
 795 @c define_variable (foo, 2222, integer, "THIS IS FOO");
 796 @c DOES NOT PUT "THIS IS FOO" INTO THE LISP FILE NOR THE UNLISP FILE.
 797 @c The optional 4th argumento é a documentation string.  When
 798 @c @code{translate_file} é used on a package which includes documentation
 799 @c strings, a second file é output in addition to the Lisp file which
 800 @c will contain the documentation strings, formatted suitably for use in
 801 @c manuals, usage files, or (for instance) @code{describe}.
 802
 803 A propriedade @code{value_check} pode ser atribuída a qualquer variável que tenha sido definida
 804 via @code{define_variable} com um outro modo que não @code{any}.
 805 A propriedade @code{value_check} é uma expressão lambda ou o nome de uma função de uma variável,
 806 que é chamada quando uma tentativa é feita para atribuir um valor a uma variável.
 807 O argumento da  função @code{value_check} é o valor que será atribuído.
 808
 809 @code{define_variable} avalia @code{default_value}, e não avalia @code{name} e @code{mode}.
 810 @code{define_variable} retorna o valor corrente de @code{name},
 811 que é @code{default_value} se @code{name} não tiver sido associada antes,
 812 e de outra forma isso é o valor prévio de @code{name}.
 813
 814 Exemplos:
 815
 816 @code{foo} é uma variável Booleana, com o valor inicial @code{true}.
 817 @c GENERATED FROM:
 818 @c define_variable (foo, true, boolean);
 819 @c foo;
 820 @c foo: false;
 821 @c foo: %pi;
 822 @c foo;
 823
 824 @example
 825 (%i1) define_variable (foo, true, boolean);
 826 (%o1)                         true
 827 (%i2) foo;
 828 (%o2)                         true
 829 (%i3) foo: false;
 830 (%o3)                         false
 831 (%i4) foo: %pi;
 832 Error: foo was declared mode boolean, has value: %pi
 833  -- an error.  Quitting.  To debug this try debugmode(true);
 834 (%i5) foo;
 835 (%o5)                         false
 836 @end example
 837
 838 @code{bar} é uma variável inteira, que deve ser um número primo.
 839 @c GENERATED FROM:
 840 @c define_variable (bar, 2, integer);
 841 @c qput (bar, prime_test, value_check);
 842 @c prime_test (y) := if not primep(y) then error (y, "is not prime.");
 843 @c bar: 1439;
 844 @c bar: 1440;
 845 @c bar;
 846
 847 @example
 848 (%i1) define_variable (bar, 2, integer);
 849 (%o1)                           2
 850 (%i2) qput (bar, prime_test, value_check);
 851 (%o2)                      prime_test
 852 (%i3) prime_test (y) := if not primep(y) then error (y, "is not prime.");
 853 (%o3) prime_test(y) := if not primep(y)
 854
 855                                    then error(y, "is not prime.")
 856 (%i4) bar: 1439;
 857 (%o4)                         1439
 858 (%i5) bar: 1440;
 859 1440 é not prime.
 860 #0: prime_test(y=1440)
 861  -- an error.  Quitting.  To debug this try debugmode(true);
 862 (%i6) bar;
 863 (%o6)                         1439
 864 @end example
 865
 866 @code{baz_quux} é uma variável que não pode receber a atribuição de um valor.
 867 O modo @code{any_check} é como @code{any},
 868 mas @code{any_check} habilita o mecanismo @code{value_check}, e @code{any} não habilita.
 869 @c GENERATED FROM:
 870 @c define_variable (baz_quux, 'baz_quux, any_check);
 871 @c F: lambda ([y], if y # 'baz_quux then error ("Cannot assign to `baz_quux'."));
 872 @c qput (baz_quux, ''F, value_check);
 873 @c baz_quux: 'baz_quux;
 874 @c baz_quux: sqrt(2);
 875 @c baz_quux;
 876
 877 @example
 878 (%i1) define_variable (baz_quux, 'baz_quux, any_check);
 879 (%o1)                       baz_quux
 880 (%i2) F: lambda ([y], if y # 'baz_quux then error ("Cannot assign to `baz_quux'."));
 881 (%o2) lambda([y], if y # 'baz_quux
 882
 883                         then error(Cannot assign to `baz_quux'.))
 884 (%i3) qput (baz_quux, ''F, value_check);
 885 (%o3) lambda([y], if y # 'baz_quux
 886
 887                         then error(Cannot assign to `baz_quux'.))
 888 (%i4) baz_quux: 'baz_quux;
 889 (%o4)                       baz_quux
 890 (%i5) baz_quux: sqrt(2);
 891 Cannot assign to `baz_quux'.
 892 #0: lambda([y],if y # 'baz_quux then error("Cannot assign to `baz_quux'."))(y=sqrt(2))
 893  -- an error.  Quitting.  To debug this try debugmode(true);
 894 (%i6) baz_quux;
 895 (%o6)                       baz_quux
 896 @end example
 897
 898 @end deffn
 899
 900 @deffn {Função} dispfun (@var{f_1}, ..., @var{f_n})
 901 @deffnx {Função} dispfun (all)
 902 Mostra a definição de funções definidas pelo usuário @var{f_1}, ..., @var{f_n}.
 903 Cada argumento pode ser o nome de uma macro (definida com @code{::=}),
 904 uma função comum (definida com @code{:=} ou @code{define}),
 905 uma função array (definida com @code{:=} ou com @code{define},
 906 mas contendo argumentos entre colchêtes @code{[ ]}),
 907 uma função subscrita, (definida com @code{:=} ou @code{define},
 908 mas contendo alguns argumentos entre colchêtes e outros entre parêntesis @code{( )})
 909 uma da família de funções subscritas selecionadas por um valor subscrito particular,
 910 ou uma função subscrita definida com uma constante subscrita.
 911
 912 @code{dispfun (all)} mostra todas as funções definidas pelo usuário como
 913 dadas pelas @code{functions}, @code{arrays}, e listas de @code{macros},
 914 omitindo funções subscritas definidas com constantes subscritas.
 915
 916 @code{dispfun} cria um Rótulo de expressão intermediária
 917 (@code{%t1}, @code{%t2}, etc.)
 918 para cada função mostrada, e atribui a definição de função para o rótulo.
 919 Em contraste, @code{fundef} retorna a definição de função.
 920
 921 @code{dispfun} não avalia seus argumentos;
 922 O operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
 923 @code{dispfun} retorna a lista de rótulos de expressões intermediárias correspondendo às funções mostradas.
 924
 925 Exemplos:
 926
 927 @c ===beg===
 928 @c m(x, y) ::= x^(-y);
 929 @c f(x, y) :=  x^(-y);
 930 @c g[x, y] :=  x^(-y);
 931 @c h[x](y) :=  x^(-y);
 932 @c i[8](y) :=  8^(-y);
 933 @c dispfun (m, f, g, h, h[5], h[10], i[8]);
 934 @c ''%;
 935 @c ===end===
 936 @example
 937 (%i1) m(x, y) ::= x^(-y);
 938                                      - y
 939 (%o1)                   m(x, y) ::= x
 940 (%i2) f(x, y) :=  x^(-y);
 941                                      - y
 942 (%o2)                    f(x, y) := x
 943 (%i3) g[x, y] :=  x^(-y);
 944                                     - y
 945 (%o3)                     g     := x
 946                            x, y
 947 (%i4) h[x](y) :=  x^(-y);
 948                                     - y
 949 (%o4)                     h (y) := x
 950                            x
 951 (%i5) i[8](y) :=  8^(-y);
 952                                     - y
 953 (%o5)                     i (y) := 8
 954                            8
 955 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
 956                                      - y
 957 (%t6)                   m(x, y) ::= x
 958
 959                                      - y
 960 (%t7)                    f(x, y) := x
 961
 962                                     - y
 963 (%t8)                     g     := x
 964                            x, y
 965
 966                                     - y
 967 (%t9)                     h (y) := x
 968                            x
 969
 970                                     1
 971 (%t10)                     h (y) := --
 972                             5        y
 973                                     5
 974
 975                                      1
 976 (%t11)                    h  (y) := ---
 977                            10         y
 978                                     10
 979
 980                                     - y
 981 (%t12)                    i (y) := 8
 982                            8
 983
 984 (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
 985 (%i12) ''%;
 986                      - y              - y            - y
 987 (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
 988                                             x, y
 989                   - y           1              1             - y
 990         h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
 991          x              5        y   10         y   8
 992                                 5             10
 993 @end example
 994
 995 @end deffn
 996
 997 @defvr {Variável de sistema} functions
 998 Valor padrão: @code{[]}
 999
1000 @code{functions} é a lista de todas as funções comuns do Maxima
1001 na sessão corrente.
1002 Uma função comum é uma função construída através de
1003 @code{define} ou de @code{:=} e chamada com parêntesis @code{()}.
1004 Uma função pode ser definida pela linha de comando do Maxima de forma interativa com o usuário
1005 ou em um arquivo Maxima chamado por @code{load} ou @code{batch}.
1006
1007 Funções de array (chamadas com colchêtes, e.g., @code{F[x]})
1008 e funções com subscritos (chamadas com colchêtes e parêntesis, e.g., @code{F[x](y)})
1009 são lsitados através da variável global @code{arrays}, e não por meio de @code{functions}.
1010
1011 Funções Lisp não são mantidas em nenhuma lista.
1012
1013 Exemplos:
1014
1015 @c ===beg===
1016 @c F_1 (x) := x - 100;
1017 @c F_2 (x, y) := x / y;
1018 @c define (F_3 (x), sqrt (x));
1019 @c G_1 [x] := x - 100;
1020 @c G_2 [x, y] := x / y;
1021 @c define (G_3 [x], sqrt (x));
1022 @c H_1 [x] (y) := x^y;
1023 @c functions;
1024 @c arrays;
1025 @c ===end===
1026 @example
1027 (%i1) F_1 (x) := x - 100;
1028 (%o1)                   F_1(x) := x - 100
1029 (%i2) F_2 (x, y) := x / y;
1030                                       x
1031 (%o2)                    F_2(x, y) := -
1032                                       y
1033 (%i3) define (F_3 (x), sqrt (x));
1034 (%o3)                   F_3(x) := sqrt(x)
1035 (%i4) G_1 [x] := x - 100;
1036 (%o4)                    G_1  := x - 100
1037                             x
1038 (%i5) G_2 [x, y] := x / y;
1039                                      x
1040 (%o5)                     G_2     := -
1041                              x, y    y
1042 (%i6) define (G_3 [x], sqrt (x));
1043 (%o6)                    G_3  := sqrt(x)
1044                             x
1045 (%i7) H_1 [x] (y) := x^y;
1046                                       y
1047 (%o7)                     H_1 (y) := x
1048                              x
1049 (%i8) functions;
1050 (%o8)              [F_1(x), F_2(x, y), F_3(x)]
1051 (%i9) arrays;
1052 (%o9)                 [G_1, G_2, G_3, H_1]
1053 @end example
1054
1055 @end defvr
1056
1057 @deffn {Função} fundef (@var{f})
1058 Retorna a definição da função @var{f}.
1059
1060 @c PROBABLY THIS WOULD BE CLEARER AS A BULLET LIST
1061 O argumento pode ser o nome de uma macro (definida com @code{::=}),
1062 uma função comum (definida com @code{:=} ou @code{define}),
1063 uma função array (definida com @code{:=} ou @code{define},
1064 mas contendo argumentos entre colchêtes @code{[ ]}),
1065 Uma função subscrita, (definida com @code{:=} ou @code{define},
1066 mas contendo alguns argumentos entre colchêtes e parêntesis @code{( )})
1067 uma da família de funções subscritas selecionada por um valor particular subscrito,
1068 ou uma função subscrita definida com uma constante subscrita.
1069
1070 @code{fundef} não avalia seu argumento;
1071 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
1072
1073 @code{fundef (@var{f})} retorna a definição de @var{f}.
1074 Em contraste, @code{dispfun (@var{f})} cria um rótulo de expressão intermediária
1075 e atribui a definição para o rótulo.
1076
1077 @c PROBABLY NEED SOME EXAMPLES HERE
1078 @end deffn
1079
1080 @deffn {Função} funmake (@var{F}, [@var{arg_1}, ..., @var{arg_n}])
1081 Retorna uma expressão @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
1082 O valor de retorno é simplificado, mas não avaliado,
1083 então a função @var{F} não é chamada, mesmo se essa função @var{F} existir.
1084
1085 @code{funmake} não tenta distinguir funções de array de funções comuns;
1086 quando @var{F} for o nome de uma função de array,
1087 @code{funmake} retorna @code{@var{F}(...)}
1088 (isto é, uma chamada de função com parêntesis em lugar de colchêtes).
1089 @code{arraymake} retorna uma chamada de função com colchêtes nesse caso.
1090
1091 @code{funmake} avalia seus argumentos.
1092
1093 Exemplos:
1094
1095 @code{funmake} aplicada a uma função comum do Maxima.
1096
1097 @c ===beg===
1098 @c F (x, y) := y^2 - x^2;
1099 @c funmake (F, [a + 1, b + 1]);
1100 @c ''%;
1101 @c ===end===
1102 @example
1103 (%i1) F (x, y) := y^2 - x^2;
1104                                    2    2
1105 (%o1)                  F(x, y) := y  - x
1106 (%i2) funmake (F, [a + 1, b + 1]);
1107 (%o2)                    F(a + 1, b + 1)
1108 (%i3) ''%;
1109                               2          2
1110 (%o3)                  (b + 1)  - (a + 1)
1111 @end example
1112
1113 @code{funmake} aplicada a uma macro.
1114
1115 @c ===beg===
1116 @c G (x) ::= (x - 1)/2;
1117 @c funmake (G, [u]);
1118 @c ''%;
1119 @c ===end===
1120 @example
1121 (%i1) G (x) ::= (x - 1)/2;
1122                                   x - 1
1123 (%o1)                    G(x) ::= -----
1124                                     2
1125 (%i2) funmake (G, [u]);
1126 (%o2)                         G(u)
1127 (%i3) ''%;
1128                               u - 1
1129 (%o3)                         -----
1130                                 2
1131 @end example
1132
1133 @code{funmake} aplicada a uma função subscrita.
1134
1135 @c ===beg===
1136 @c H [a] (x) := (x - 1)^a;
1137 @c funmake (H [n], [%e]);
1138 @c ''%;
1139 @c funmake ('(H [n]), [%e]);
1140 @c ''%;
1141 @c ===end===
1142 @example
1143 (%i1) H [a] (x) := (x - 1)^a;
1144                                         a
1145 (%o1)                   H (x) := (x - 1)
1146                          a
1147 (%i2) funmake (H [n], [%e]);
1148                                        n
1149 (%o2)               lambda([x], (x - 1) )(%e)
1150 (%i3) ''%;
1151                                     n
1152 (%o3)                       (%e - 1)
1153 (%i4) funmake ('(H [n]), [%e]);
1154 (%o4)                        H (%e)
1155                               n
1156 (%i5) ''%;
1157                                     n
1158 (%o5)                       (%e - 1)
1159 @end example
1160
1161 @code{funmake} aplicada a um símbolo que não é uma função definida de qualquer tipo.
1162
1163 @c ===beg===
1164 @c funmake (A, [u]);
1165 @c ''%;
1166 @c ===end===
1167 @example
1168 (%i1) funmake (A, [u]);
1169 (%o1)                         A(u)
1170 (%i2) ''%;
1171 (%o2)                         A(u)
1172 @end example
1173
1174  @code{funmake} avalia seus argumentos, mas não o valor de retorno.
1175
1176 @c ===beg===
1177 @c det(a,b,c) := b^2 -4*a*c;
1178 @c (x : 8, y : 10, z : 12);
1179 @c f : det;
1180 @c funmake (f, [x, y, z]);
1181 @c ''%;
1182 @c ===end===
1183 @example
1184 (%i1) det(a,b,c) := b^2 -4*a*c;
1185                                     2
1186 (%o1)              det(a, b, c) := b  - 4 a c
1187 (%i2) (x : 8, y : 10, z : 12);
1188 (%o2)                          12
1189 (%i3) f : det;
1190 (%o3)                          det
1191 (%i4) funmake (f, [x, y, z]);
1192 (%o4)                    det(8, 10, 12)
1193 (%i5) ''%;
1194 (%o5)                         - 284
1195 @end example
1196
1197 Maxima simplifica o valor de retorno de @code{funmake}.
1198
1199 @c ===beg===
1200 @c funmake (sin, [%pi / 2]);
1201 @c ===end===
1202 @example
1203 (%i1) funmake (sin, [%pi / 2]);
1204 (%o1)                           1
1205 @end example
1206
1207 @end deffn
1208
1209 @deffn {Função} lambda ([@var{x_1}, ..., @var{x_m}], @var{expr_1}, ..., @var{expr_n})
1210 @deffnx {Função} lambda ([[@var{L}]], @var{expr_1}, ..., @var{expr_n})
1211 @deffnx {Função} lambda ([@var{x_1}, ..., @var{x_m}, [@var{L}]], @var{expr_1}, ..., @var{expr_n})
1212 Define e retorna uma expressão lambda (que é, uma função anônima)
1213 A função pode ter argumentos que sejam necessários @var{x_1}, ..., @var{x_m}
1214 e/ou argumentos opcionais @var{L}, os quais aparecem dentro do corpo da função como uma lista.
1215 O valor de retorno da função é @var{expr_n}.
1216 Uma expressão lambda pode ser atribuída para uma variável e avaliada como uma função comum.
1217 Uma expressão lambda pode aparecer em alguns contextos nos quais um nome de função é esperado.
1218
1219 Quando a função é avaliada,
1220 variáveis locais não associadas @var{x_1}, ..., @var{x_m} são criadas.
1221 @code{lambda} pode aparecer dentro de @code{block} ou outra função @code{lambda};
1222 variáveis locais são estabelecidas cada vez que outro @code{block} ou função @code{lambda} é avaliada.
1223 Variáveis locais parecem ser globais para qualquer coisa contendo @code{block} ou @code{lambda}.
1224 Se uma variável é não local,
1225 seu valor é o valor mais recentemente atribuído em alguma coisa contendo @code{block} ou @code{lambda}, qualquer que seja,
1226 de outra forma, seu valor é o valor da variável no ambiente global.
1227 Essa política pode coincidir com o entendimento usual de "escopo dinâmico".
1228
1229 Após variáveis locais serem estabelecidas,
1230 @var{expr_1} até @var{expr_n} são avaliadas novamente.
1231 a variável especial @code{%%}, representando o valor da expressão precedente,
1232 é reconhecida.
1233 @code{throw} e @code{catch} pode também aparecer na lista de expressões.
1234
1235 @code{return} não pode aparecer em uma expressão lambda a menos que contendo @code{block},
1236 nesse caso @code{return} define o valor de retorno do  bloco e não da
1237 expressão lambda,
1238 a menos que o bloco seja @var{expr_n}.
1239 Da mesma forma, @code{go} não pode aparecer em uma expressão lambda a menos que contendo @code{block}.
1240
1241 @code{lambda} não avalia seus argumentos;
1242 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
1243
1244 Exemplos:
1245
1246 @itemize @bullet
1247 @item
1248 A expressão lambda pode ser atribuída para uma variável e avaliada como uma função comum.
1249 @end itemize
1250 @c ===beg===
1251 @c f: lambda ([x], x^2);
1252 @c f(a);
1253 @c ===end===
1254 @example
1255 (%i1) f: lambda ([x], x^2);
1256                                       2
1257 (%o1)                    lambda([x], x )
1258 (%i2) f(a);
1259                                 2
1260 (%o2)                          a
1261 @end example
1262 @itemize @bullet
1263 @item
1264 Uma expressão lambda pode aparecer em contextos nos quais uma avaliação de função é esperada como resposta.
1265 @end itemize
1266 @c ===beg===
1267 @c lambda ([x], x^2) (a);
1268 @c apply (lambda ([x], x^2), [a]);
1269 @c map (lambda ([x], x^2), [a, b, c, d, e]);
1270 @c ===end===
1271 @example
1272 (%i3) lambda ([x], x^2) (a);
1273                                 2
1274 (%o3)                          a
1275 (%i4) apply (lambda ([x], x^2), [a]);
1276                                 2
1277 (%o4)                          a
1278 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
1279                         2   2   2   2   2
1280 (%o5)                 [a , b , c , d , e ]
1281 @end example
1282 @itemize @bullet
1283 @item
1284 Variáveis argumento são variáveis locais.
1285 Outras variáveis aparecem para serem variáveis globais.
1286 Variáveis globais são avaliadas ao mesmo tempo em que a expressão lambda é avaliada,
1287 a menos que alguma avaliação especial seja forçada por alguns meios, tais como @code{'@w{}'}.
1288 @end itemize
1289 @c ===beg===
1290 @c a: %pi$
1291 @c b: %e$
1292 @c g: lambda ([a], a*b);
1293 @c b: %gamma$
1294 @c g(1/2);
1295 @c g2: lambda ([a], a*''b);
1296 @c b: %e$
1297 @c g2(1/2);
1298 @c ===end===
1299 @example
1300 (%i6) a: %pi$
1301 (%i7) b: %e$
1302 (%i8) g: lambda ([a], a*b);
1303 (%o8)                   lambda([a], a b)
1304 (%i9) b: %gamma$
1305 (%i10) g(1/2);
1306                              %gamma
1307 (%o10)                       ------
1308                                2
1309 (%i11) g2: lambda ([a], a*''b);
1310 (%o11)                lambda([a], a %gamma)
1311 (%i12) b: %e$
1312 (%i13) g2(1/2);
1313                              %gamma
1314 (%o13)                       ------
1315                                2
1316 @end example
1317 @itemize @bullet
1318 @item
1319 Expressões lambda podem ser aninhadas.
1320 Variáveis locais dentro de outra expressão lambda parece ser global para a expressão interna
1321 a menos que mascarada por variáveis locais de mesmos nomes.
1322 @end itemize
1323 @c ===beg===
1324 @c h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1325 @c h(%pi, %gamma);
1326 @c ===end===
1327 @example
1328 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1329                                                    1
1330 (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
1331                                                    2
1332 (%i15) h(%pi, %gamma);
1333                              %gamma
1334 (%o15)                       ------
1335                                2
1336 @end example
1337 @itemize @bullet
1338 @item
1339 Uma vez que @code{lambda} não avalia seus argumentos, a expressão lambda @code{i} abaixo
1340 não define uma função "multiplicação por @code{a}".
1341 Tanto uma função pode ser definida via @code{buildq}, como na expressão lambda @code{i2} abaixo.
1342 @end itemize
1343 @c ===beg===
1344 @c i: lambda ([a], lambda ([x], a*x));
1345 @c i(1/2);
1346 @c i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1347 @c i2(1/2);
1348 @c i2(1/2)(%pi);
1349 @c ===end===
1350 @example
1351 (%i16) i: lambda ([a], lambda ([x], a*x));
1352 (%o16)            lambda([a], lambda([x], a x))
1353 (%i17) i(1/2);
1354 (%o17)                  lambda([x], a x)
1355 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1356 (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
1357 (%i19) i2(1/2);
1358                                      x
1359 (%o19)                   lambda([x], -)
1360                                      2
1361 (%i20) i2(1/2)(%pi);
1362                                %pi
1363 (%o20)                         ---
1364                                 2
1365 @end example
1366 @itemize @bullet
1367 @item
1368 Uma expressão lambda pode receber um número variável de argumentos,
1369 os quais são indicados por meio de @code{[@var{L}]} como o argumento único ou argumento final.
1370 Os argumentos aparecem dentro do corpo da função como uma lista.
1371 @end itemize
1372 @c ===beg===
1373 @c f : lambda ([aa, bb, [cc]], aa * cc + bb);
1374 @c f (foo, %i, 17, 29, 256);
1375 @c g : lambda ([[aa]], apply ("+", aa));
1376 @c g (17, 29, x, y, z, %e);
1377 @c ===end===
1378 @example
1379 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
1380 (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
1381 (%i2) f (foo, %i, 17, 29, 256);
1382 (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
1383 (%i3) g : lambda ([[aa]], apply ("+", aa));
1384 (%o3)             lambda([[aa]], apply(+, aa))
1385 (%i4) g (17, 29, x, y, z, %e);
1386 (%o4)                  z + y + x + %e + 46
1387 @end example
1388 @end deffn
1389
1390 @c NEEDS CLARIFICATION AND EXAMPLES
1391 @deffn {Função} local (@var{v_1}, ..., @var{v_n})
1392 Declara as variáveis @var{v_1}, ..., @var{v_n} para serem locais com
1393 relação a todas as propriedades na declaração na qual essa função
1394 é usada.
1395
1396 @code{local} não avalia seus argumentos.
1397 @code{local} retorna @code{done}.
1398
1399 @code{local} pode somente ser usada em @code{block}, no corpo de definições
1400 de função ou expressões @code{lambda}, ou na função @code{ev}, e somente uma
1401 ocorrêcia é permitida em cada.
1402
1403 @code{local} é independente de @code{context}.
1404
1405 @end deffn
1406
1407 @defvr {Variável de opção} macroexpansion
1408 Valor padrão: @code{false}
1409
1410 @code{macroexpansion} controla se a expansão (isto é, o valor de retorno) de uma função de macro
1411 é substituído pela chamada à função de macro.
1412 Uma substituição pode aumentar a velocidade de subseq@"{u}ênte avaliações da expressão,
1413 ao custo de armazenar a expansão.
1414
1415 @table @code
1416 @item false
1417 A expansão de uma função de macro não é substituída pela chamada de função de macro.
1418 @item expand
1419 Da primeira vez que a função de macro é avaliada,
1420 a expansão é armazenada.
1421 A expansão não é recalculada sobre chamadas subseq@"{u}êntes;
1422 qualquer efeito colateral (tais como @code{print} ou atribuições a variáveis globais) ocorrem
1423 somente quando chamadas à função de macro forem avaliadas primeiramente.
1424 Expansões em uma expressão não afetam outras expressões
1425 que possuem a mesma chamada à função de macro.
1426 @item displace
1427 Na primeira vez que uma função de macro é avaliada,
1428 a expansão é substituída pela chamada,
1429 dessa forma modificando a expressão a partir da qual a função de macro foi chamada.
1430 A expansão não é recalculada nas chamadas subseq@"{u}êntes;
1431 qualquer efeito colateral acontece somente quando a chamada à função de macro for avaliada primeiramente.
1432 Expansões na expressão não afetam outras expressões
1433 que possuem a mesma chamada à função de macro.
1434 @end table
1435
1436 Exemplos
1437
1438 Quandon @code{macroexpansion} for @code{false},
1439 uma função de macro é chamada a cada vez que a expressão que está chamando é avaliada,
1440 e a expressão que está chamandonão é modificada.
1441
1442 @c ===beg===
1443 @c f (x) := h (x) / g (x);
1444 @c g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1445 @c h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1446 @c macroexpansion: false;
1447 @c f (a * b);
1448 @c dispfun (f);
1449 @c f (a * b);
1450 @c ===end===
1451 @example
1452 (%i1) f (x) := h (x) / g (x);
1453                                   h(x)
1454 (%o1)                     f(x) := ----
1455                                   g(x)
1456 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1457 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1458                                                   return(x + 99))
1459 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1460 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1461                                                   return(x - 99))
1462 (%i4) macroexpansion: false;
1463 (%o4)                         false
1464 (%i5) f (a * b);
1465 x - 99 is equal to x
1466 x + 99 is equal to x
1467                             a b - 99
1468 (%o5)                       --------
1469                             a b + 99
1470 (%i6) dispfun (f);
1471                                   h(x)
1472 (%t6)                     f(x) := ----
1473                                   g(x)
1474
1475 (%o6)                         done
1476 (%i7) f (a * b);
1477 x - 99 is equal to x
1478 x + 99 is equal to x
1479                             a b - 99
1480 (%o7)                       --------
1481                             a b + 99
1482 @end example
1483
1484 Quando @code{macroexpansion} for @code{expand},
1485 uma função de macro é chamada uma única vez,
1486 e a expressão que está chamando não é modificada.
1487
1488 @c ===beg===
1489 @c f (x) := h (x) / g (x);
1490 @c g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1491 @c h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1492 @c macroexpansion: expand;
1493 @c f (a * b);
1494 @c dispfun (f);
1495 @c f (a * b);
1496 @c ===end===
1497 @example
1498 (%i1) f (x) := h (x) / g (x);
1499                                   h(x)
1500 (%o1)                     f(x) := ----
1501                                   g(x)
1502 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1503 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1504                                                   return(x + 99))
1505 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1506 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1507                                                   return(x - 99))
1508 (%i4) macroexpansion: expand;
1509 (%o4)                        expand
1510 (%i5) f (a * b);
1511 x - 99 is equal to x
1512 x + 99 is equal to x
1513                             a b - 99
1514 (%o5)                       --------
1515                             a b + 99
1516 (%i6) dispfun (f);
1517                                   h(x)
1518 (%t6)                     f(x) := ----
1519                                   g(x)
1520
1521 (%o6)                         done
1522 (%i7) f (a * b);
1523                             a b - 99
1524 (%o7)                       --------
1525                             a b + 99
1526 @end example
1527
1528 Quando @code{macroexpansion} for @code{expand},
1529 uma função de macro é chamada uma única vez,
1530 e a expressão que está chamando é modificada.
1531
1532 @c ===beg===
1533 @c f (x) := h (x) / g (x);
1534 @c g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1535 @c h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1536 @c macroexpansion: displace;
1537 @c f (a * b);
1538 @c dispfun (f);
1539 @c f (a * b);
1540 @c ===end===
1541 @example
1542 (%i1) f (x) := h (x) / g (x);
1543                                   h(x)
1544 (%o1)                     f(x) := ----
1545                                   g(x)
1546 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1547 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1548                                                   return(x + 99))
1549 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1550 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1551                                                   return(x - 99))
1552 (%i4) macroexpansion: displace;
1553 (%o4)                       displace
1554 (%i5) f (a * b);
1555 x - 99 is equal to x
1556 x + 99 is equal to x
1557                             a b - 99
1558 (%o5)                       --------
1559                             a b + 99
1560 (%i6) dispfun (f);
1561                                  x - 99
1562 (%t6)                    f(x) := ------
1563                                  x + 99
1564
1565 (%o6)                         done
1566 (%i7) f (a * b);
1567                             a b - 99
1568 (%o7)                       --------
1569                             a b + 99
1570 @end example
1571
1572 @end defvr
1573
1574 @defvr {Variável de opção} mode_checkp
1575 Valor padrão: @code{true}
1576
1577 @c WHAT DOES THIS MEAN ??
1578 Quando @code{mode_checkp} é @code{true}, @code{mode_declare} verifica os modos
1579 de associação de variáveis.
1580 @c NEED SOME EXAMPLES HERE.
1581
1582 @end defvr
1583
1584 @defvr {Variável de opção} mode_check_errorp
1585 Valor padrão: @code{false}
1586
1587 @c WHAT DOES THIS MEAN ??
1588 Quando @code{mode_check_errorp} é @code{true}, @code{mode_declare} chama
1589 a função "error".
1590 @c NEED SOME EXAMPLES HERE.
1591
1592 @end defvr
1593
1594 @defvr {Variável de opção} mode_check_warnp
1595 Valor padrão: @code{true}
1596
1597 @c WHAT DOES THIS MEAN ??
1598 Quando @code{mode_check_warnp} é @code{true}, modo "errors" são
1599 descritos.
1600 @c NEED SOME EXAMPLES HERE.
1601
1602 @end defvr
1603
1604 @c NEEDS CLARIFICATION AND EXAMPLES
1605 @deffn {Função} mode_declare (@var{y_1}, @var{mode_1}, ..., @var{y_n}, @var{mode_n})
1606 @code{mode_declare} é usado para declarar os modos de variáveis e
1607 funções para subseq@"{u}ênte tradução ou compilação das funções.
1608 @code{mode_declare} é tipicamente colocada no início de uma definição de
1609 função, no início de um script Maxima, ou executado através da linha de comando de forma interativa.
1610
1611 Os argumentos de @code{mode_declare} são pares consistindo de  uma variável e o modo que é
1612 um de @code{boolean}, @code{fixnum}, @code{number}, @code{rational}, ou @code{float}.
1613 Cada variável pode também
1614 ser uma lista de variáveis todas as quais são declaradas para ter o mesmo modo.
1615
1616 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1617 Se uma variável é um array, e se todo elemento do array que é
1618 referenciado tiver um valor então @code{array (yi, complete, dim1, dim2, ...)}
1619 em lugar de
1620 @example
1621 array(yi, dim1, dim2, ...)
1622 @end example
1623 deverá ser usado primeiro
1624 declarando as associações do array.
1625 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1626 Se todos os elementos do array
1627 estão no modo @code{fixnum} (@code{float}), use @code{fixnum} (@code{float}) em lugar de @code{complete}.
1628 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1629 Também se todo elemento do array está no mesmo modo, digamos @code{m}, então
1630
1631 @example
1632 mode_declare (completearray (yi), m))
1633 @end example
1634
1635 deverá ser usado para uma tradução
1636 eficiente.
1637
1638 Código numéricos usando arrays podem rodar mais rápidamente
1639 se for decladado o tamanho esperado do array, como em:
1640
1641 @example
1642 mode_declare (completearray (a [10, 10]), float)
1643 @end example
1644
1645 para um array numérico em ponto flutuante que é 10 x 10.
1646
1647 Pode-se declarar o modo do resultado de uma função
1648 usando @code{function (f_1, f_2, ...)} como um argumento;
1649 aqui @code{f_1}, @code{f_2}, ...  são nomes
1650 de funções.  Por exemplo a expressão,
1651
1652 @example
1653 mode_declare ([function (f_1, f_2, ...)], fixnum)
1654 @end example
1655
1656 declara que os valores retornados por @code{f_1}, @code{f_2}, ...  são inteiros palavra simples.
1657
1658 @code{modedeclare} é um sinônimo para @code{mode_declare}.
1659
1660 @end deffn
1661
1662 @c WHAT IS THIS ABOUT ??
1663 @c NEEDS CLARIFICATION AND EXAMPLES
1664 @deffn {Função} mode_identity (@var{arg_1}, @var{arg_2})
1665 Uma forma especial usada com @code{mode_declare} e
1666 @code{macros} para declarar, e.g., uma lista de listas de números em ponto flutuante ou outros
1667 objetos de dados.  O primeiro argumento para @code{mode_identity} é um valor primitivo
1668 nome de modo como dado para @code{mode_declare} (i.e., um de @code{float}, @code{fixnum}, @code{number},
1669 @code{list}, ou @code{any}), e o segundo argumento é uma expressão que é
1670 avaliada e retornada com o valor de @code{mode_identity}.  Todavia, se o
1671 valor de retorno não é permitido pelo modo declarado no primeiro
1672 argumento, um erro ou alerta é sinalizado.  Um ponto importante é
1673 que o modo da expressão como determinado pelo Maxima para o tradutor
1674 Lisp, será aquele dado como o primeiro argumento, independente de
1675 qualquer coisa que vá no segundo argumento.
1676 E.g., @code{x: 3.3; mode_identity (fixnum, x);} retorna um erro.  @code{mode_identity (flonum, x)}
1677 returns 3.3 .
1678 Isso tem númerosas utilidades, e.g., se você soube que @code{first (l)} retornou um
1679 número então você pode escrever @code{mode_identity (number, first (l))}.  Todavia,
1680 um mais eficiente caminho para fazer isso é definir uma nova primitiva,
1681
1682 @example
1683 firstnumb (x) ::= buildq ([x], mode_identity (number, first(x)));
1684 @end example
1685
1686 e usar @code{firstnumb}
1687 toda vez que você pegar o primeiro de uma lista de números.
1688
1689 @end deffn
1690
1691 @c IS THERE ANY REASON TO SET transcompile: false ??
1692 @c MAYBE THIS VARIABLE COULD BE PERMANENTLY SET TO true AND STRUCK FROM THE DOCUMENTATION.
1693 @defvr {Variável de opção} transcompile
1694 Valor padrão: @code{true}
1695
1696 Quando @code{transcompile} é @code{true}, @code{translate} e @code{translate_file} geram
1697 declarações para fazer o código traduzido mais adequado para compilação.
1698 @c BUT THE DECLARATIONS DON'T SEEM TO BE NECESSARY, SO WHAT'S THE POINT AGAIN ??
1699
1700 @code{compfile} escolhe @code{transcompile: true} para a duração.
1701
1702 @end defvr
1703
1704 @deffn {Função} translate (@var{f_1}, ..., @var{f_n})
1705 @deffnx {Função} translate (funções)
1706 @deffnx {Função} translate (all)
1707 Traduz funções definidas pelo usuário
1708 @var{f_1}, ..., @var{f_n} da linguagem de Maxima para Lisp
1709 e avalia a tradução Lisp.
1710 Tipicamente as funções traduzidas executam mais rápido que as originais.
1711
1712 @code{translate (all)} ou @code{translate (funções)} traduz todas as funções definidas pelo usuário.
1713
1714 Funções a serem traduzidas incluir~ao uma chamada para @code{mode_declare} no
1715 início quando possível com o objetivo de produzir um código mais eficiente.  Por
1716 exemplo:
1717
1718 @example
1719 f (x_1, x_2, ...) := block ([v_1, v_2, ...],
1720     mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)
1721 @end example
1722
1723 @noindent
1724
1725 quando @var{x_1}, @var{x_2}, ...  são parâmetros para a função e
1726 @var{v_1}, @var{v_2}, ...  são variáveis locais.
1727
1728 Os nomes de funções traduzidas
1729 são removidos da lista @code{functions} se @code{savedef} é @code{false} (veja abaixo)
1730 e são adicionados nas listas @code{props}.
1731
1732 Funções não poderão ser traduzidas
1733 a menos que elas sejam totalmente depuradas.
1734
1735 Expressões são assumidas simplificadas; se não forem, um código correto será gerado mas não será um código
1736 ótimo.  Dessa forma, o usuário não poderá escolher o comutador @code{simp} para @code{false}
1737 o qual inibe simplificação de expressões a serem traduzidas.
1738
1739 O comutador @code{translate}, se @code{true}, causa tradução
1740 automatica de uma função de usuário para Lisp.
1741
1742 Note que funções
1743 traduzidas podem não executar identicamente para o caminho que elas faziam antes da
1744 tradução como certas incompatabilidades podem existir entre o Lisp
1745 e versões do Maxima.  Principalmente, a função  @code{rat} com mais de
1746 um argumento e a função @code{ratvars} não poderá ser usada se quaisquer
1747 variáveis são declaradas com @code{mode_declare} como sendo expressões rotacionais canônicas(CRE).
1748 Também a escolha @code{prederror: false}
1749 não traduzirá.
1750 @c WHAT ABOUT % AND %% ???
1751
1752 @code{savedef} - se @code{true} fará com que a versão Maxima de uma função
1753  usuário permaneça quando a função é traduzida com @code{translate}.  Isso permite a
1754 que definição seja mostrada por @code{dispfun} e autoriza a função a ser
1755 editada.
1756
1757 @code{transrun} - se @code{false} fará com que a versão interpretada de todas as
1758 funções sejam executadas (desde que estejam ainda disponíveis) em lugar da
1759 versão traduzida.
1760
1761 O resultado retornado por @code{translate} é uma lista de nomes de
1762 funções traduzidas.
1763
1764 @end deffn
1765
1766 @deffn {Função} translate_file (@var{maxima_nomearquivo})
1767 @deffnx {Função} translate_file (@var{maxima_nomearquivo}, @var{lisp_nomearquivo})
1768 Traduz um arquivo com código Maxima para um arquivo com código Lisp.
1769 @code{translate_file} retorna uma lista de três nomes de arquivo:
1770 O nome do arquivo Maxima, o nome do arquivo Lisp, e o nome do arquivo
1771 contendo informações adicionais sobre a tradução.
1772 @code{translate_file} avalia seus argumentos.
1773
1774 @code{translate_file ("foo.mac"); load("foo.LISP")} é o mesmo que
1775 @code{batch ("foo.mac")} exceto por certas restrições,
1776 o uso de @code{'@w{}'} e @code{%}, por exemplo.
1777 @c FIGURE OUT WHAT THE RESTRICTIONS ARE AND STATE THEM
1778
1779 @code{translate_file (@var{maxima_nomearquivo})} traduz um arquivo Maxima @var{maxima_nomearquivo}
1780 para um similarmente chamado arquivo Lisp.
1781 Por exemplo, @code{foo.mac} é traduzido em @code{foo.LISP}.
1782 O nome de arquivo Maxima pod incluir nome ou nomes de diretório(s),
1783 nesse caso o arquivo de saída Lisp é escrito
1784 para o mesmo diretório que a entrada Maxima.
1785
1786 @code{translate_file (@var{maxima_nomearquivo}, @var{lisp_nomearquivo})} traduz
1787 um arquivo Maxima @var{maxima_nomearquivo} em um arquivo Lisp @var{lisp_nomearquivo}.
1788 @code{translate_file} ignora a extensão do nome do arquivo, se qualquer, de @code{lisp_nomearquivo};
1789 a extensão do arquivo de saída Lisp é sempre @code{LISP}.
1790 O nome de arquivo Lisp pode incluir um nome ou nomes de diretórios),
1791 nesse caso o arquivo de saída Lisp é escrito para o diretório especificado.
1792
1793 @code{translate_file} também escreve um arquivo de mensagens de alerta
1794 do tradutor em vários graus de severidade.
1795 A extensão do nome de arquivo desse arquivo é @code{UNLISP}.
1796 Esse arquivo pode conter informação valiosa, apesar de possivelmente obscura,
1797 para rastrear erros no código traduzido.
1798 O arquivo @code{UNLISP} é sempre escrito
1799 para o mesmo diretório que a entrada Maxima.
1800
1801 @code{translate_file} emite código Lisp o qual faz com que
1802 algumas definições tenham efeito tão logo
1803 o código Lisp é compilado.
1804 Veja @code{compile_file} para mais sobre esse tópico.
1805
1806 @c CHECK ALL THESE AND SEE WHICH ONES ARE OBSOLETE
1807 Veja também @code{tr_array_as_ref},
1808 @c tr_bind_mode_hook EXISTS BUT IT APPEARS TO BE A GROTESQUE UNDOCUMENTED HACK
1809 @c WE DON'T WANT TO MENTION IT
1810 @c @code{tr_bind_mode_hook},
1811 @code{tr_bound_function_applyp},
1812 @c tr_exponent EXISTS AND WORKS AS ADVERTISED IN src/troper.lisp
1813 @c NOT OTHERWISE DOCUMENTED; ITS EFFECT SEEMS TOO WEAK TO MENTION
1814 @code{tr_exponent},
1815 @code{tr_file_tty_messagesp},
1816 @code{tr_float_can_branch_complex},
1817 @code{tr_function_call_default},
1818 @code{tr_numer},
1819 @code{tr_optimize_max_loop},
1820 @code{tr_semicompile},
1821 @code{tr_state_vars},
1822 @code{tr_warnings_get},
1823 @code{tr_warn_bad_function_calls},
1824 @code{tr_warn_fexpr},
1825 @code{tr_warn_meval},
1826 @code{tr_warn_mode},
1827 @code{tr_warn_undeclared},
1828 e @code{tr_warn_undefined_variable}.
1829
1830 @end deffn
1831
1832 @defvr {Variável de opção} transrun
1833 Valor padrão: @code{true}
1834
1835 Quando @code{transrun} é @code{false} fará com que a versão
1836 interpretada de todas as funções sejam executadas (desde que estejam ainda disponíveis)
1837 em lugar de versão traduzidas.
1838
1839 @end defvr
1840
1841 @c IN WHAT CONTEXT IS tr_array_as_ref: false APPROPRIATE ??? NOT SEEING THE USEFULNESS HERE.
1842 @c ALSO, I GUESS WE SHOULD HAVE AN ITEM FOR translate_fast_arrays, ANOTHER CONFUSING FLAG ...
1843 @defvr {Variável de opção} tr_array_as_ref
1844 Valor padrão: @code{true}
1845
1846 Se @code{translate_fast_arrays} for @code{false}, referências a arrays no
1847 Código Lisp emitidas por @code{translate_file} são afetadas por @code{tr_array_as_ref}.
1848 Quando @code{tr_array_as_ref} é @code{true},
1849 nomes de arrays são avaliados,
1850 de outra forma nomes de arrays aparecem como símbolos literais no código traduzido.
1851
1852 @code{tr_array_as_ref} não terão efeito se @code{translate_fast_arrays} for @code{true}.
1853
1854 @end defvr
1855
1856 @c WHY IS THIS FLAG NEEDED ??? UNDER WHAT CIRCUMSTANCES CAN TRANSLATION
1857 @c OF A BOUND VARIABLE USED AS A FUNCTION GO WRONG ???
1858 @defvr {Variável de opção} tr_bound_function_applyp
1859 Valor padrão: @code{true}
1860
1861 Quando @code{tr_bound_function_applyp} for @code{true}, Maxima emite um alerta se uma associação
1862 de variável (tal como um argumento de função) é achada sendo usada como uma função.
1863 +@c WHAT DOES THIS MEAN ??
1864 @code{tr_bound_function_applyp} não afeta o código gerado em tais casos.
1865
1866 Por exemplo, uma expressão tal como @code{g (f, x) := f (x+1)} irá disparar
1867 a mensagem de alerta.
1868
1869 @end defvr
1870
1871 @defvr {Variável de opção} tr_file_tty_messagesp
1872 Valor padrão: @code{false}
1873
1874 Quando @code{tr_file_tty_messagesp} é @code{true},
1875 messagens geradas por @code{translate_file} durante a tradução de um arquivo são mostradas
1876 sobre o console e inseridas dentro do arquivo UNLISP.
1877 Quando @code{false}, messagens sobre traduções de
1878 arquivos são somente inseridas dentro do arquivo UNLISP.
1879
1880 @end defvr
1881
1882 @c THIS FLAG APPEARS TO HAVE NO EFFECT.  SHOULD CUT OUT THIS ITEM AND RELATED CODE.
1883 @c NOTE THAT THERE IS CODE IN src/transf.lisp WHICH USES THIS FLAG BUT THE MODE
1884 @c FLAG IS LOST SOMEWHERE ALONG THE WAY TO THE LISP OUTPUT FILE.
1885 @defvr {Variável de opção} tr_float_can_branch_complex
1886 Valor padrão: @code{true}
1887
1888 Diz ao tradutor Maxima-para-Lisp assumir que as funções
1889 @code{acos}, @code{asin}, @code{asec}, e @code{acsc} podem retornar resultados complexos.
1890
1891 O efeito ostensivo de @code{tr_float_can_branch_complex} é mostrado adiante.
1892 Todavia, parece que esse sinalizador não tem efeito sobre a saída do tradutor.
1893
1894 Quando isso for @code{true} então @code{acos(x)} será do modo @code{any}
1895 sempre que @code{x} for do modo @code{float} (como escolhido por @code{mode_declare}).
1896 Quando @code{false} então @code{acos(x)} será do modo
1897 @code{float} se e somente se @code{x} for do modo @code{float}.
1898
1899 @end defvr
1900
1901 @defvr {Variável de opção} tr_function_call_default
1902 Valor padrão: @code{general}
1903
1904 @code{false} significa abandonando e
1905 chamando @code{meval}, @code{expr} significa que Lisp assume função de argumento fixado.  @code{general}, o
1906 código padrão dado como sendo bom para @code{mexprs} e @code{mlexprs} mas não @code{macros}.
1907 @code{general} garante que associações de variável são corretas em códigos compilados.  No
1908 modo @code{general}, quando traduzindo F(X), se F for uma variável associada, então isso
1909 assumirá que @code{apply (f, [x])} é significativo, e traduz como tal, com
1910 o alerta apropriado.  Não é necessário desabilitar isso.  Com as
1911 escolhas padrão, sem mensagens de alerta implica compatibilidade total do
1912 código traduzido e compilado com o interpretador Maxima.
1913
1914 @end defvr
1915
1916 @defvr {Variável de opção} tr_numer
1917 Valor padrão: @code{false}
1918
1919 Quando @code{tr_numer} for @code{true} propriedades @code{numer} são usadas para
1920 átomos que possuem essa propriedade, e.g. @code{%pi}.
1921
1922 @end defvr
1923
1924 @defvr {Variável de opção} tr_optimize_max_loop
1925 Valor padrão: 100
1926
1927 @code{tr_optimize_max_loop} é número máximo de vezes do
1928 passo de macro-expansão e otimização que o tradutor irá executar
1929 considerando uma forma.  Isso é para capturar erros de expansão de macro, e
1930 propriedades de otimização não terminadas.
1931
1932 @end defvr
1933
1934 @defvr {Variável de opção} tr_semicompile
1935 Valor padrão: @code{false}
1936
1937 Quando @code{tr_semicompile} for @code{true}, as formas de saída de @code{translate_file}
1938 e @code{compfile} serão macroexpandidas mas não compiladas em código
1939 de máquina pelo compilador Lisp.
1940
1941 @end defvr
1942
1943 @c ARE ANY OF THESE OBSOLETE ??
1944 @defvr {Variável de sistema} tr_state_vars
1945 Valor padrão:
1946 @example
1947 [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
1948 tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
1949 tr_function_call_default, tr_array_as_ref,tr_numer]
1950 @end example
1951
1952 A lista de comutadores que afetam a forma de saída da
1953 tradução.
1954 @c DOES THE GENERAL USER REALLY CARE ABOUT DEBUGGING THE TRANSLATOR ???
1955 Essa informação é útil para sistemas populares quando
1956 tentam depurar o tradutor.  Comparando o produto traduzido
1957 para o qual pode ter sido produzido por um dado estado, isso é possível para
1958 rastrear erros.
1959
1960 @end defvr
1961
1962 @c tr_warnings_get EXISTS AND FUNCTIONS AS ADVERTISED (SORT OF) -- RETURNS *tr-runtime-warned*
1963 @c WHICH HAS ONLY A FEW KINDS OF WARNINGS PUSHED ONTO IT; IT'S CERTAINLY NOT COMPREHENSIVE
1964 @c DO WE REALLY NEED THIS SLIGHTLY WORKING FUNCTION ??
1965 @deffn {Função} tr_warnings_get ()
1966 Imprime uma lista de alertas que podem ter sido dadas pelo
1967 tradutor durante a tradução corrente.
1968
1969 @end deffn
1970
1971 @defvr {Variável de opção} tr_warn_bad_function_calls
1972 Valor padrão: @code{true}
1973
1974 - Emite um alerta quando
1975 chamadas de função estão sendo feitas por um caminho que pode não ser correto devido
1976 a declarações impróprias que foram feitas em tempo de tradução.
1977
1978 @end defvr
1979
1980 @defvr {Variável de opção} tr_warn_fexpr
1981 Valor padrão: @code{compfile}
1982
1983 - Emite um alerta se quaisquer FEXPRs forem
1984 encontradas.  FEXPRs não poderão normalmente ser saída em código traduzido,
1985 todas as formas de programa especial legítimo são traduzidas.
1986
1987 @end defvr
1988
1989 @defvr {Variável} tr_warn_meval
1990 Valor padrão: @code{compfile}
1991
1992 - Emite um alerta se a função
1993 @code{meval} recebe chamadas.  Se @code{meval} é chamada isso indica problemas na
1994 tradução.
1995
1996 @end defvr
1997
1998 @defvr {Variável} tr_warn_mode
1999 Valor padrão: @code{all}
2000
2001 - Emite um alerta quando a variáveis forem
2002 atribuídos valores inapropriados para seu modo.
2003
2004 @end defvr
2005
2006 @defvr {Variável de opção} tr_warn_undeclared
2007 Valor padrão: @code{compile}
2008
2009 - Determina quando enviar
2010 alertas sobre variáveis não declaradas para o TTY.
2011
2012 @end defvr
2013
2014 @defvr {Variável de opção} tr_warn_undefined_variable
2015 Valor padrão: @code{all}
2016
2017 - Emite um alerta quando
2018 variáveis globais indefinidas forem vistas.
2019
2020 @end defvr
2021
2022 @deffn {Função} compile_file (@var{nomearquivo})
2023 @deffnx {Função} compile_file (@var{nomearquivo}, @var{nomearquivo_compilado})
2024 @deffnx {Função} compile_file (@var{nomearquivo}, @var{nomearquivo_compilado}, @var{lisp_nomearquivo})
2025 Traduz o arquivo Maxima @var{nomearquivo} para Lisp,
2026 executa o compilador Lisp,
2027 e, se a tradução e a compilação obtiverem sucesso, chama o código compilado dentro do Maxima.
2028
2029 @code{compile_file} retorna uma lista dos nomes de quatro arquivos:
2030 o arquivo original do Maxima, o nome da tradução Lisp, uma arquivo de notas sobre a tradução, e o nome do arquivo que contém o código compilado.
2031 Se a compilação falhar,
2032 o quarto item é @code{false}.
2033
2034 Algumas declarações e definições passam a ter efeito tão logo
2035 o código Lisp seja compilado (sem que seja necessário chamar o código compilado).
2036 Isso inclui funções definidas com o operador @code{:=},
2037 macros definidas com o operador @code{::=}, @c HEDGE -- DON'T KNOW IF THERE IS ANOTHER WAY
2038 @code{alias}, @code{declare},
2039 @code{define_variable},  @code{mode_declare},
2040 e
2041 @code{infix}, @code{matchfix},
2042 @code{nofix}, @code{postfix}, @code{prefix},
2043 e @code{compfile}.
2044
2045 Atribuições e chamadas de função não serão avaliadas até que o código compilado seja carregado.
2046 Em particular, dentro do arquivo Maxima,
2047 atribuições para sinalizadores traduzidos (@code{tr_numer}, etc.) não têm efeito sobre a tradução.
2048
2049 @c @code{compile_file} may mistake warnings for errors and
2050 @c return @code{false} as the name of the compiled code when, in fact,
2051 @c the compilation succeeded.  This é a bug.
2052 @c REPORTED AS SOURCEFORGE BUG # 1103722.
2053
2054 @var{nomearquivo} pode não conter declarações @code{:lisp}.
2055
2056 @code{compile_file} avalia seus argumentos.
2057
2058 @end deffn
2059
2060 @c NEEDS CLARIFICATION
2061 @deffn {Função} declare_translated (@var{f_1}, @var{f_2}, ...)
2062 Quando traduzindo um arquivo do código Maxima
2063 para Lisp, é importante para o programa tradutor saber quais funções
2064 no arquivo são para serem chamadas como funções traduzidas ou compiladas,
2065 e quais outras são apenas funções Maxima ou indefinidas.  Colocando essa
2066 declaração no topo do arquivo, faremos conhecido que embora um símbolo
2067 diga que não temos ainda um valor de função Lisp, teremos uma em
2068 tempo de chamada.  @code{(MFUNCTION-CALL fn arg1 arg2 ...)} é gerado quando
2069 o tradutor n~ao sabe que @code{fn} está sendo compilada para ser uma função Lisp.
2070
2071 @end deffn
2072
2073