| blob | 1ca6905ee8188a9258b24d19d0ffaf90004d4519 |
1 @c /Function.texi/1.46/Fri Mar 2 00:44:37 2007/-ko/
2 @menu
3 * Introdução a Definição de Função::
4 * Função::
5 * Macros::
6 * Definições para Definição de Função::
7 @end menu
9 @node Introdução a Definição de Função, Função, Definição de Função, Definição de Função
10 @section Introdução a Definição de Função
12 @node Função, Macros, Introdução a Definição de Função, Definição de Função
13 @c NEEDS WORK, THIS TOPIC IS IMPORTANT
14 @c MENTION DYNAMIC SCOPE (VS LEXICAL SCOPE)
15 @section Função
16 @subsection Ordinary functions
18 Para definir uma função no Maxima usa-se o operador :=.
19 Por exemplo,
21 @example
22 f(x) := sin(x)
23 @end example
25 @noindent
26 define uma função @code{f}.
27 Funções an@^onimas podem também serem criadas usando @code{lambda}.
28 Por exemplo
30 @example
31 lambda ([i, j], ...)
32 @end example
34 @noindent
35 pode ser usada em lugar de @code{f}
36 onde
38 @example
39 f(i,j) := block ([], ...);
40 map (lambda ([i], i+1), l)
41 @end example
43 @noindent
44 retornará uma lista com 1 adicionado a cada termo.
46 Pode também definir uma função com um número
47 variável de argumentos, usando um argumento final que seja uma lista,
48 na qual serão inseridos todos os argumentos adicionais:
50 @example
51 (%i1) f ([u]) := u;
52 (%o1) f([u]) := u
53 (%i2) f (1, 2, 3, 4);
54 (%o2) [1, 2, 3, 4]
55 (%i3) f (a, b, [u]) := [a, b, u];
56 (%o3) f(a, b, [u]) := [a, b, u]
57 (%i4) f (1, 2, 3, 4, 5, 6);
58 (%o4) [1, 2, [3, 4, 5, 6]]
59 @end example
61 O lado direito na definição de uma
62 função é uma expressão. Assim, quando quiser que a
63 definição seja uma sequência de expressões, poderá
64 usar a forma
65 @example
66 f(x) := (expr1, expr2, ...., exprn);
67 @end example
69 e o valor de @var{exprn} é que é retornado pela função.
71 Se quiser introduzir um ponto de @code{retorno} em alguma expressão dentro da
72 função, deverá usar @code{block} e @code{return}.
74 @example
75 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)
76 @end example
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.
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:
86 []]}, que farão com que as três variáveis @code{a},@code{b},e
87 @code{c} não se refiram a seus valores globais, mas ao contrário
88 tenham esses valores especiais enquanto o código estiver executando a
89 parte dentro do bloco @code{block}, ou dentro da funções
90 chamadas de dentro do bloco @code{block}. Isso é chamado
91 associação @i{dynamic}, uma vez que as variáveis
92 permanecem do início do bloco pelo tempo que ele
93 existir. Quando regressar do bloco @code{block}, ou o descartar, os
94 valores antigos (quaisquer que sejam) das variáveis serão
95 restaurados. É certamente uma boa idéia para proteger as suas
96 variáveis nesse caminho. Note que as atribuições em
97 variáveis do bloco, são realizadas em paralelo. Isso
98 significa, que se tivesse usado @code{c: a} acima, o valor de @code{c}
99 seria o valor que @code{a} tinha antes do bloco, antes de ter obtido o
100 seu novo valor atribuído no bloco. Dessa forma fazendo alguma
101 coisa como
103 @example
104 block ([a: a], expr1, ... a: a+3, ..., exprn)
105 @end example
107 protegerá o valor externo de @code{a} de ser alterado, mas impedirá
108 aceder ao valor antigo. Assim, o lado direito de
109 atribuições, é avaliado no contexto inserido, antes
110 que qualquer avaliação ocorra. Usando apenas
111 @code{block ([x], ...} faremos com que o @code{x} tenho como valor a si
112 próprio; esse é o mesmo valor que teria no início de
113 uma sessão do @b{Maxima}.
115 Os actuais argumentos para uma função são tratados exactamente da mesma que
116 as variáveis em um bloco. Dessa forma em
118 @example
119 f(x) := (expr1, ..., exprn);
120 @end example
122 e
124 @example
125 f(1);
126 @end example
128 teremos um contexto similar para avaliação de expressões
129 como se tivéssemos concluído
131 @example
132 block ([x: 1], expr1, ..., exprn)
133 @end example
135 Dentro de funções, quando o lado direito de uma definição,
136 pode ser calculado em tempo de execução, isso é úti para usar @code{define} e
137 possivelmente @code{buildq}.
139 @subsection Função de Array
141 Uma função de Array armazena o valor da função na primeira vez que ela for chamada com um argumento dado,
142 e retorna o valor armazenado, sem recalcular esse valor, quando o mesmo argumento for fornecido.
143 De modo que uma função é muitas vezes chamada uma @i{função de memorização}.
145 Nomes de funções de Array são anexados ao final da lista global @code{arrays}
146 (não na lista global @code{functions}).
147 O comando @code{arrayinfo} retorna a lista de argumentos para os quais exite valores armazenados,
148 e @code{listarray} retorna os valores armazenados.
149 Os comandos @code{dispfun} e @code{fundef} retornam a definição da função de array.
151 O comando @code{arraymake} contrói uma chamada de função de array,
152 análogamente a @code{funmake} para funções comuns.
153 O comando @code{arrayapply} aplica uma função de array a seus argmentos,
154 análogamente a @code{apply} para funções comuns.
155 Não existe nada exactamente análogo a @code{map} para funções de array,
156 embora @code{map(lambda([@var{x}], @var{a}[@var{x}]), @var{L})} ou
157 @code{makelist(@var{a}[@var{x}], @var{x}, @var{L})}, onde @var{L} é uma lista,
158 não estejam tão longe disso.
160 O comando @code{remarray} remove uma definição de função de array (incluindo qualquer valor armazenado pela função removida),
161 análogo a @code{remfunction} para funções comuns.
163 o comando @code{kill(@var{a}[@var{x}])} remove o valor da função de array @var{a}
164 armazenado para o argumento @var{x};
165 a próxima vez que @var{a} foor chamada com o argumento @var{x},
166 o valor da função é recomputado.
167 Todavia, não exite caminho para remover todos os valores armazenados de uma vez,
168 excepto para @code{kill(@var{a})} ou @code{remarray(@var{a})},
169 o qual remove também remove a definição da função de array.
171 @node Macros, Definições para Definição de Função, Função, Definição de Função
172 @section Macros
174 @deffn {Função} buildq (@var{L}, @var{expr})
175 Substitue variáveis nomeadas pela lista @var{L} dentro da expressão @var{expr},
176 paralelamente,
177 sem avaliar @var{expr}.
178 A expressão resultante é simplificada,
179 mas não avaliada,
180 após @code{buildq} realizar a substituição.
182 Os elementos de @var{L} são símbolos ou expressões de atribuição @code{@var{símbolo}: @var{valor}},
183 avaliadas paralelamente.
184 Isto é, a associação de uma variável sobre o lado direito de uma atribuição
185 é a associação daquela variável no contexto do qual @code{buildq} for chamada,
186 não a associação daquela variável na lista @var{L} de variáveis.
187 Se alguma variável em @var{L} não dada como uma atribuição explícita,
188 sua associação em @code{buildq} é a mesma que no contexto no qual @code{buildq} for chamada.
190 Então as variáveis nomeadas em @var{L} são substituidas em @var{expr} paralelamente.
191 Isto é, a substituição para cada variável é determinada antes que qualquer substituição seja feita,
192 então a substituição para uma variável não tem efeito sobre qualquer outra.
194 Se qualquer variável @var{x} aparecer como @code{splice (@var{x})} em @var{expr},
195 então @var{x} deve estar associada para uma lista,
196 e a lista recebe uma aplicação da função @code{splice} (é interpolada) na @var{expr} em lugar de substituída.
198 Quaisquer variáveis em @var{expr} não aparecendo em @var{L} são levados no resultado tal como foram escritos,
199 mesmo se elas tiverem associações no contexto do qual @code{buildq} tiver sido chamada.
201 Exemplos
203 @code{a} é explicitamente associada a @code{x},
204 enquanto @code{b} tem a mesma associação (nomeadamente 29) como no contexto chamado,
205 e @code{c} é levada do começo ao fim da forma como foi escrita.
206 A expressão resultante não é avaliada até a avaliação explícita ( com duplo apóstrofo - não com aspas - @code{''%}.
208 @c ===beg===
209 @c (a: 17, b: 29, c: 1729)$
210 @c buildq ([a: x, b], a + b + c);
211 @c ''%;
212 @c ===end===
213 @example
214 (%i1) (a: 17, b: 29, c: 1729)$
215 (%i2) buildq ([a: x, b], a + b + c);
216 (%o2) x + c + 29
217 (%i3) ''%;
218 (%o3) x + 1758
219 @end example
221 @code{e} está associado a uma lista, a qual aparece também como tal nos argumentos de @code{foo},
222 e interpolada nos argumentos de @code{bar}.
224 @c ===beg===
225 @c buildq ([e: [a, b, c]], foo (x, e, y));
226 @c buildq ([e: [a, b, c]], bar (x, splice (e), y));
227 @c ===end===
228 @example
229 (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
230 (%o1) foo(x, [a, b, c], y)
231 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
232 (%o2) bar(x, a, b, c, y)
233 @end example
235 O resultado é simplificado após substituição.
236 Se a simplificação for aplicada antes da substituição, esses dois resultados podem ser iguais.
237 @c ===beg===
238 @c buildq ([e: [a, b, c]], splice (e) + splice (e));
239 @c buildq ([e: [a, b, c]], 2 * splice (e));
240 @c ===end===
241 @example
242 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
243 (%o1) 2 c + 2 b + 2 a
244 (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
245 (%o2) 2 a b c
246 @end example
248 As variáveis em @var{L} são associadas em paralelo; se associadas sequêncialmente,
249 o primeiro resultado pode ser @code{foo (b, b)}.
250 Substituições são realizadas em paralelo;
251 compare o segundo resultado com o resultado de @code{subst},
252 que realiza substituições sequêncialmente.
254 @c ===beg===
255 @c buildq ([a: b, b: a], foo (a, b));
256 @c buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
257 @c subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
258 @c ===end===
259 @example
260 (%i1) buildq ([a: b, b: a], foo (a, b));
261 (%o1) foo(b, a)
262 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
263 (%o2) bar(v, w, x, y, z, u)
264 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
265 (%o3) bar(u, u, u, u, u, u)
266 @end example
268 Constrói uma lista de euqções com algumas variáveis ou expressões sobre o lado esquerdo
269 e seus valores sobre o lado direito.
270 @code{macroexpand} mostra a expressão retornada por @code{show_values}.
272 @c ===beg===
273 @c show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
274 @c (a: 17, b: 29, c: 1729)$
275 @c macroexpand (show_values (a, b, c - a - b));
276 @c show_values (a, b, c - a - b);
277 @c ===end===
278 @example
279 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
280 (%o1) show_values([L]) ::= buildq([L], map("=", 'L, L))
281 (%i2) (a: 17, b: 29, c: 1729)$
282 (%i3) show_values (a, b, c - a - b);
283 (%o3) [a = 17, b = 29, c = 1729]
284 @end example
286 @end deffn
288 @deffn {Função} macroexpand (@var{expr})
289 Retorna a expansão da macro de @var{expr} sem avaliar a expressão,
290 quando @code{expr} for uma chamada de função de macro.
291 De outra forma, @code{macroexpand} retorna @var{expr}.
293 Se a expansão de @var{expr} retorna outra chamada de função de macro,
294 aquela chamada de função de macro é também expandida.
296 @code{macroexpand} coloca apóstrofo em seus argumentos, isto é, não os avalia.
297 Todavia, se a expansão de uma chamada de função de macro tiver algum efeito,
298 esse efeito colateral é executado.
300 Veja também @code{::=}, @code{macros}, e @code{macroexpand1}.
302 Exemplos
304 @c ===beg===
305 @c g (x) ::= x / 99;
306 @c h (x) ::= buildq ([x], g (x - a));
307 @c a: 1234;
308 @c macroexpand (h (y));
309 @c h (y);
310 @c ===end===
311 @example
312 (%i1) g (x) ::= x / 99;
313 x
314 (%o1) g(x) ::= --
315 99
316 (%i2) h (x) ::= buildq ([x], g (x - a));
317 (%o2) h(x) ::= buildq([x], g(x - a))
318 (%i3) a: 1234;
319 (%o3) 1234
320 (%i4) macroexpand (h (y));
321 y - a
322 (%o4) -----
323 99
324 (%i5) h (y);
325 y - 1234
326 (%o5) --------
327 99
328 @end example
330 @end deffn
332 @deffn {Função} macroexpand1 (@var{expr})
333 Retorna a expansão de macro de @var{expr} sem avaliar a expressão,
334 quando @code{expr} for uma chamada de função de macro.
335 De outra forma, @code{macroexpand1} retorna @var{expr}.
337 @code{macroexpand1} não avalia seus argumentos.
338 Todavia, se a expansão de uma chamada de função de macro tiver algum efeito,
339 esse efeito colateral é executado.
341 Se a expansão de @var{expr} retornar outra chamada de função de macro,
342 aquela chamada de função de macro não é expandida.
344 Veja também @code{::=}, @code{macros}, e @code{macroexpand}.
346 Examples
348 @c ===beg===
349 @c g (x) ::= x / 99;
350 @c h (x) ::= buildq ([x], g (x - a));
351 @c a: 1234;
352 @c macroexpand1 (h (y));
353 @c h (y);
354 @c ===end===
355 @example
356 (%i1) g (x) ::= x / 99;
357 x
358 (%o1) g(x) ::= --
359 99
360 (%i2) h (x) ::= buildq ([x], g (x - a));
361 (%o2) h(x) ::= buildq([x], g(x - a))
362 (%i3) a: 1234;
363 (%o3) 1234
364 (%i4) macroexpand1 (h (y));
365 (%o4) g(y - a)
366 (%i5) h (y);
367 y - 1234
368 (%o5) --------
369 99
370 @end example
372 @end deffn
374 @defvr {Global variable} macros
375 Default value: @code{[]}
377 @code{macros} é a lista de funções de macro definidas pelo utilizador.
378 O operador de definição de função de macro @code{::=} coloca uma nova função de macro nessa lista,
379 e @code{kill}, @code{remove}, e @code{remfunction} removem funções de macro da lista.
381 Veja também @code{infolists}.
383 @end defvr
385 @deffn {Função} splice (@var{a})
386 Une como se fosse um elo de ligação (interpola) a lista nomeada através do átomo @var{a} em uma expressão,
387 mas somente se @code{splice} aparecer dentro de @code{buildq};
388 de outra forma, @code{splice} é tratada como uma função indefinida.
389 Se aparecer dentro de @code{buildq} com @var{a} sozinho (sem @code{splice}),
390 @var{a} é substituido (não interpolado) como uma lista no resultado.
391 O argumento de @code{splice} pode somente ser um átomo;
392 não pode ser uma lista lateral ou uma expressão que retorna uma lista.
394 Tipicamente @code{splice} fornece os argumentos para uma função ou operador.
395 Para uma função @code{f}, a expressão @code{f (splice (@var{a}))} dentro de @code{buildq}
396 expande para @code{f (@var{a}[1], @var{a}[2], @var{a}[3], ...)}.
397 Para um operador @code{o}, a expressão @code{"o" (splice (@var{a})} dentro de @code{buildq}
398 expande para @code{"o" (@var{a}[1], @var{a}[2], @var{a}[3], ...)},
399 onde @code{o} pode ser qualquer tipo de operador (tipicamente um que toma múltiplos argumentos).
400 Note que o operador deve ser contido dentro de aspas duplas @code{"}.
402 Exemplos
404 @c ===beg===
405 @c buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
406 @c buildq ([x: [1, %pi]], "/" (splice (x)));
407 @c matchfix ("<>", "<>");
408 @c buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
409 @c ===end===
410 @example
411 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
412 foo(1, %pi, z - y)
413 (%o1) -----------------------
414 length([1, %pi, z - y])
415 (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
416 1
417 (%o2) ---
418 %pi
419 (%i3) matchfix ("<>", "<>");
420 (%o3) <>
421 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
422 (%o4) <>1, %pi, z - y<>
423 @end example
425 @end deffn
427 @c end concepts Definição de Função
428 @node Definições para Definição de Função, , Macros, Definição de Função
429 @section Definições para Definição de Função
431 @deffn {Função} apply (@var{F}, [@var{x_1}, ..., @var{x_n}])
432 Constrói e avalia uma expressãp @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
434 @code{apply} não tenta distinguir funções de array de funções comuns;
435 quando @var{F} for o nome de uma função de array,
436 @code{apply} avalia @code{@var{F}(...)}
437 (isto é, uma chamada de função com parêntesis em lugar de colchêtes).
438 @code{arrayapply} avalia uma chamada de função com colchêtes nesse caso.
440 Exemplos:
442 @code{apply} avalia seus argumentos.
443 Nesse exemplo, @code{min} é aplicado a @code{L}.
445 @c ===beg===
446 @c L : [1, 5, -10.2, 4, 3];
447 @c apply (min, L);
448 @c ===end===
449 @example
450 (%i1) L : [1, 5, -10.2, 4, 3];
451 (%o1) [1, 5, - 10.2, 4, 3]
452 (%i2) apply (min, L);
453 (%o2) - 10.2
454 @end example
456 @code{apply} avalia argumentos, mesmo se a função @var{F} disser que os argumentos não devem ser avaliados.
458 @c ===beg===
459 @c F (x) := x / 1729;
460 @c fname : F;
461 @c dispfun (F);
462 @c dispfun (fname);
463 @c apply (dispfun, [fname]);
464 @c ===end===
465 @example
466 (%i1) F (x) := x / 1729;
467 x
468 (%o1) F(x) := ----
469 1729
470 (%i2) fname : F;
471 (%o2) F
472 (%i3) dispfun (F);
473 x
474 (%t3) F(x) := ----
475 1729
477 (%o3) [%t3]
478 (%i4) dispfun (fname);
479 fname is not the name of a user function.
480 -- an error. Quitting. To debug this try debugmode(true);
481 (%i5) apply (dispfun, [fname]);
482 x
483 (%t5) F(x) := ----
484 1729
486 (%o5) [%t5]
487 @end example
489 @code{apply} avalia o nome de função @var{F}.
490 Apóstrofo @code{'} evita avaliação.
491 @code{demoivre} é o nome de uma variável global e também de uma função.
493 @c ===beg===
494 @c demoivre;
495 @c demoivre (exp (%i * x));
496 @c apply (demoivre, [exp (%i * x)]);
497 @c apply ('demoivre, [exp (%i * x)]);
498 @c ===end===
499 @example
500 (%i1) demoivre;
501 (%o1) false
502 (%i2) demoivre (exp (%i * x));
503 (%o2) %i sin(x) + cos(x)
504 (%i3) apply (demoivre, [exp (%i * x)]);
505 demoivre evaluates to false
506 Improper name or value in functional position.
507 -- an error. Quitting. To debug this try debugmode(true);
508 (%i4) apply ('demoivre, [exp (%i * x)]);
509 (%o4) %i sin(x) + cos(x)
510 @end example
512 @end deffn
515 @deffn {Função} block ([@var{v_1}, ..., @var{v_m}], @var{expr_1}, ..., @var{expr_n})
516 @deffnx {Função} block (@var{expr_1}, ..., @var{expr_n})
517 @code{block} avalia @var{expr_1}, ..., @var{expr_n} em sequência
518 e retorna o valor da última expressão avaliada.
519 A sequência pode ser modificada pelas funções @code{go}, @code{throw}, e @code{return}.
520 A última expressão é @var{expr_n} a menos que @code{return} ou uma expressão contendo @code{throw}
521 seja avaliada.
522 Algumas variáveis @var{v_1}, ..., @var{v_m} podem ser declaradas locais para o bloco;
523 essas são distinguidas das variáveis globais dos mesmos nomes.
524 Se variáveis não forem declaradas locais então a lista pode ser omitida.
525 Dentro do bloco,
526 qualquer variável que não @var{v_1}, ..., @var{v_m} é uma variável global.
528 @code{block} salva os valores correntes das variáveis @var{v_1}, ..., @var{v_m} (quaisquer valores)
529 na hora da entrada para o bloco,
530 então libera as variáveis dessa forma eles avaliam para si mesmos.
531 As variáveis locais podem ser associadas a valores arbitrários dentro do bloco mas quando o
532 bloco é encerrado o valores salvos são restaurados,
533 e os valores atribuídos dentro do bloco são perdidos.
535 @code{block} pode aparecer dentro de outro @code{block}.
536 Variáveis locais são estabelecidas cada vez que um novo @code{block} é avaliado.
537 Variáveis locais parecem ser globais para quaisquer blocos fechados.
538 Se uma variável é não local em um bloco,
539 seu valor é o valor mais recentemente atribuído por um bloco fechado, quaisquer que sejam,
540 de outra forma, seu valor é o valor da variável no ambiente global.
541 Essa política pode coincidir com o entendimento usual de "escopo dinâmico".
543 Se isso for desejado para salvar e restaurar outras propriedades locais
544 ao lado de @code{value}, por exemplo @code{array} (excepto para arrays completos),
545 @code{function}, @code{dependencies}, @code{atvalue}, @code{matchdeclare}, @code{atomgrad}, @code{constant}, e
546 @code{nonscalar} então a função @code{local} pode ser usada dentro do bloco
547 com argumentos sendo o nome das variáveis.
549 O valor do bloco é o valor da última declaração ou o
550 valor do argumento para a função @code{return} que pode ser usada para sair
551 explicitamente do bloco. A função @code{go} pode ser usada para transferir o
552 controle para a declaração do bloco que é identificada com o argumento
553 para @code{go}. Para identificar uma declaração, coloca-se antes dela um argumento at@^omico como
554 outra declaração no bloco. Por exemplo:
555 @code{block ([x], x:1, loop, x: x+1, ..., go(loop), ...)}. O argumento para @code{go} deve
556 ser o nome de um identificador que aparece dentro do bloco. Não se deve usar @code{go} para
557 transferir para um identificador em um outro bloco a não ser esse que contém o @code{go}.
559 Blocos tipicamente aparecem do lado direito de uma definição de função
560 mas podem ser usados em outros lugares também.
562 @end deffn
564 @c REPHRASE, NEEDS EXAMPLE
565 @deffn {Função} break (@var{expr_1}, ..., @var{expr_n})
566 Avalia e imprime @var{expr_1}, ..., @var{expr_n} e então
567 causa uma parada do Maxima nesse ponto e o utilizador pode examinar e alterar
568 seu ambiente. Nessa situação digite @code{exit;} para que o cálculo seja retomado.
570 @end deffn
572 @c FOR SOME REASON throw IS IN SOME OTHER FILE. MOVE throw INTO THIS FILE.
573 @c NEEDS CLARIFICATION
574 @deffn {Função} catch (@var{expr_1}, ..., @var{expr_n})
575 Avalia @var{expr_1}, ..., @var{expr_n} uma por uma; se qualquer avaliação
576 levar a uma avaliação de uma expressão da
577 forma @code{throw (arg)}, então o valor de @code{catch} é o valor de
578 @code{throw (arg)}, e expressões adicionais não são avaliadas.
579 Esse "retorno não local" atravessa assim qualquer profundidade de
580 aninhar para o mais próximo contendo @code{catch}.
581 Se não existe nenhum @code{catch} contendo um @code{throw}, uma mensagem de erro é impressa.
583 Se a avaliação de argumentos não leva para a avaliação de qualquer @code{throw}
584 então o valor de @code{catch} é o valor de @var{expr_n}.
586 @example
587 (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
588 (%i2) g(l) := catch (map (''%, l))$
589 (%i3) g ([1, 2, 3, 7]);
590 (%o3) [f(1), f(2), f(3), f(7)]
591 (%i4) g ([1, 2, -3, 7]);
592 (%o4) - 3
593 @end example
595 @c REWORD THIS PART.
596 A função @code{g} retorna uma lista de @code{f} de cada elemento de @code{l} se @code{l}
597 consiste somente de números não negativos; de outra forma, @code{g} "captura" o
598 primeiro elemento negativo de @code{l} e "arremessa-o".
600 @end deffn
602 @deffn {Função} compfile (@var{nomeficheiro}, @var{f_1}, ..., @var{f_n})
603 @deffnx {Função} compfile (@var{nomeficheiro}, funções)
604 @deffnx {Função} compfile (@var{nomeficheiro}, all)
606 Traduz fuções Maxima para Lisp
607 e escreve o código traduzido no ficheiro @var{nomeficheiro}.
609 @code{compfile(@var{nomeficheiro}, @var{f_1}, ..., @var{f_n})} traduz as
610 funções especificadas.
611 @code{compfile(@var{nomeficheiro}, functions)} e @code{compfile(@var{nomeficheiro}, all)}
612 traduz todas as funções definidas pelo utilizador.
614 As traduções Lisp não são avaliadas, nem é o ficheiro de saída processado pelo compilador Lisp.
615 @c SO LET'S CONSIDER GIVING THIS FUNCTION A MORE ACCURATE NAME.
616 @code{translate} cria e avalia traduções Lisp.
617 @code{compile_file} traduz Maxima para Lisp, e então executa o compilador Lisp.
619 Veja também @code{translate}, @code{translate_file}, e @code{compile_file}.
621 @end deffn
623 @c THIS VARIABLE IS OBSOLETE: ASSIGNING compgrind: true CAUSES compfile
624 @c TO EVENTUALLY CALL AN OBSOLETE FUNCTION SPRIN1.
625 @c RECOMMENDATION IS TO CUT THIS ITEM, AND CUT $compgrind FROM src/transs.lisp
626 @c @defvar compgrind
627 @c Default value: @code{false}
628 @c
629 @c When @code{compgrind} é @code{true}, function definitions printed by
630 @c @code{compfile} are pretty-printed.
631 @c
632 @c @end defvar
634 @deffn {Função} compile (@var{f_1}, ..., @var{f_n})
635 @deffnx {Função} compile (funções)
636 @deffnx {Função} compile (all)
637 Traduz funções Maxima @var{f_1}, ..., @var{f_n} para Lisp, avalia a tradução Lisp,
638 e chama a função Lisp @code{COMPILE} sobre cada função traduzida.
639 @code{compile} retorna uma lista de nomes de funções compiladas.
641 @code{compile (all)} ou @code{compile (funções)} compila todas as funções definidas pelo utilizador.
643 @code{compile} não avalia seus argumentos;
644 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação sobrepondo-se ao apóstrofo.
646 @end deffn
648 @deffn {Função} define (@var{f}(@var{x_1}, ..., @var{x_n}), @var{expr})
649 @deffnx {Função} define (@var{f}[@var{x_1}, ..., @var{x_n}], @var{expr})
650 @deffnx {Função} define (funmake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
651 @deffnx {Função} define (arraymake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
652 @deffnx {Função} define (ev (@var{expr_1}), @var{expr_2})
654 Define uma função chamada @var{f} com argumentos @var{x_1}, ..., @var{x_n} e corpo da função @var{expr}.
655 @code{define} sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliação).
656 A função então definida pode ser uma função comum do Maxima (com argumentos contidos entre parêtesis)
657 ou uma função de array (com argumentos contidos entre colchêtes).
659 Quando o último ou único argumento da função @var{x_n} for uma lista de um elemento,
660 a função definida por @code{define} aceita um número variável de argumentos.
661 Os argumentos actuais são atribuídos um a um a argumentos formais @var{x_1}, ..., @var{x_(n - 1)},
662 e quaisquer argumentos adicionais actuais, se estiverem presentes, são atribuídos a @var{x_n} como uma lista.
664 Quando o primeiro argumento de @code{define} for uma expressão da forma
665 @code{@var{f}(@var{x_1}, ..., @var{x_n})} or @code{@var{f}[@var{x_1}, ..., @var{x_n}]},
666 os argumentos são avaliados mas @var{f} não é avaliada,
667 mesmo se já existe anteriormente uma função ou variável com aquele nome.
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.
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}.
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 actual argumento.
678 de outra forma todos os argumentos actuais são avaliados.
680 Veja também @code{:=} and @code{::=}.
682 Exemplos:
684 @code{define} sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliação).
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
706 A função definida por @code{define} pode ser uma função comum do Maxima ou uma função de array.
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
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.
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
734 When the first argument is an expression with operator @code{funmake}, @code{arraymake}, or @code{ev},
735 the first argument is evaluated.
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
761 @end deffn
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})
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 utilizador, que são muitas vezes traduzidos ou compilados.
771 @code{define_variable} realiza os seguintes passos:
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.
778 @item
779 Se a variável é não associada, @var{default_value} é atribuído para @var{name}.
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
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
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}.
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.
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}.
814 Exemplos:
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;
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
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;
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)
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
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;
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
883 then error(Cannot assign to `baz_quux'.))
884 (%i3) qput (baz_quux, ''F, value_check);
885 (%o3) lambda([y], if y # 'baz_quux
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
898 @end deffn
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 utilizador @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 seleccionadas por um valor subscrito particular,
910 ou uma função subscrita definida com uma constante subscrita.
912 @code{dispfun (all)} mostra todas as funções definidas pelo utilizador como
913 dadas pelas @code{functions}, @code{arrays}, e listas de @code{macros},
914 omitindo funções subscritas definidas com constantes subscritas.
916 @code{dispfun} cria um Rótulo de expressão intermédia
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.
921 @code{dispfun} não avalia seus argumentos;
922 O operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
924 @code{dispfun} retorna a lista de rótulos de expressões intermédias correspondendo às funções mostradas.
926 Exemplos:
929 @c ===beg===
930 @c m(x, y) ::= x^(-y);
931 @c f(x, y) := x^(-y);
932 @c g[x, y] := x^(-y);
933 @c h[x](y) := x^(-y);
934 @c i[8](y) := 8^(-y);
935 @c dispfun (m, f, g, h, h[5], h[10], i[8]);
936 @c ''%;
937 @c ===end===
938 @example
939 (%i1) m(x, y) ::= x^(-y);
940 - y
941 (%o1) m(x, y) ::= x
942 (%i2) f(x, y) := x^(-y);
943 - y
944 (%o2) f(x, y) := x
945 (%i3) g[x, y] := x^(-y);
946 - y
947 (%o3) g := x
948 x, y
949 (%i4) h[x](y) := x^(-y);
950 - y
951 (%o4) h (y) := x
952 x
953 (%i5) i[8](y) := 8^(-y);
954 - y
955 (%o5) i (y) := 8
956 8
957 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
958 - y
959 (%t6) m(x, y) ::= x
961 - y
962 (%t7) f(x, y) := x
964 - y
965 (%t8) g := x
966 x, y
968 - y
969 (%t9) h (y) := x
970 x
972 1
973 (%t10) h (y) := --
974 5 y
975 5
977 1
978 (%t11) h (y) := ---
979 10 y
980 10
982 - y
983 (%t12) i (y) := 8
984 8
986 (%o12) [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
987 (%i12) ''%;
988 - y - y - y
989 (%o12) [m(x, y) ::= x , f(x, y) := x , g := x ,
990 x, y
991 - y 1 1 - y
992 h (y) := x , h (y) := --, h (y) := ---, i (y) := 8 ]
993 x 5 y 10 y 8
994 5 10
996 @end example
998 @end deffn
1000 @defvr {Variável de sistema} functions
1001 Valor por omissão: @code{[]}
1003 @code{functions} é uma lista de todas as funções comuns do Maxima
1004 na sessão corrente.
1005 Uma função comum é uma função construída através de
1006 @code{define} ou de @code{:=} e chamada com parêntesis @code{()}.
1007 Uma função pode ser definida pela linha de comando do Maxima de forma interativa com o utilizador
1008 ou em um ficheiro Maxima chamado por @code{load} ou @code{batch}.
1010 Funções de array (chamadas com colchêtes, e.g., @code{F[x]})
1011 e funções com subscritos (chamadas com colchêtes e parêntesis, e.g., @code{F[x](y)})
1012 são lsitados através da variável global @code{arrays}, e não por meio de @code{functions}.
1014 Funções Lisp não são mantidas em nenhuma lista.
1016 Exemplos:
1018 @c ===beg===
1019 @c F_1 (x) := x - 100;
1020 @c F_2 (x, y) := x / y;
1021 @c define (F_3 (x), sqrt (x));
1022 @c G_1 [x] := x - 100;
1023 @c G_2 [x, y] := x / y;
1024 @c define (G_3 [x], sqrt (x));
1025 @c H_1 [x] (y) := x^y;
1026 @c functions;
1027 @c arrays;
1028 @c ===end===
1029 @example
1030 (%i1) F_1 (x) := x - 100;
1031 (%o1) F_1(x) := x - 100
1032 (%i2) F_2 (x, y) := x / y;
1033 x
1034 (%o2) F_2(x, y) := -
1035 y
1036 (%i3) define (F_3 (x), sqrt (x));
1037 (%o3) F_3(x) := sqrt(x)
1038 (%i4) G_1 [x] := x - 100;
1039 (%o4) G_1 := x - 100
1040 x
1041 (%i5) G_2 [x, y] := x / y;
1042 x
1043 (%o5) G_2 := -
1044 x, y y
1045 (%i6) define (G_3 [x], sqrt (x));
1046 (%o6) G_3 := sqrt(x)
1047 x
1048 (%i7) H_1 [x] (y) := x^y;
1049 y
1050 (%o7) H_1 (y) := x
1051 x
1052 (%i8) functions;
1053 (%o8) [F_1(x), F_2(x, y), F_3(x)]
1054 (%i9) arrays;
1055 (%o9) [G_1, G_2, G_3, H_1]
1056 @end example
1058 @end defvr
1060 @deffn {Função} fundef (@var{f})
1061 Retorna a definição da função @var{f}.
1063 @c PROBABLY THIS WOULD BE CLEARER AS A BULLET LIST
1064 O argumento pode ser o nome de uma macro (definida com @code{::=}),
1065 uma função comum (definida com @code{:=} ou @code{define}),
1066 uma função array (definida com @code{:=} ou @code{define},
1067 mas contendo argumentos entre colchêtes @code{[ ]}),
1068 Uma função subscrita, (definida com @code{:=} ou @code{define},
1069 mas contendo alguns argumentos entre colchêtes e parêntesis @code{( )})
1070 uma da família de funções subscritas seleccionada por um valor particular subscrito,
1071 ou uma função subscrita definida com uma constante subscrita.
1073 @code{fundef} não avalia seu argumento;
1074 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
1076 @code{fundef (@var{f})} retorna a definição de @var{f}.
1077 Em contraste, @code{dispfun (@var{f})} cria um rótulo de expressão intermédia
1078 e atribui a definição para o rótulo.
1080 @c PROBABLY NEED SOME EXAMPLES HERE
1081 @end deffn
1083 @deffn {Função} funmake (@var{F}, [@var{arg_1}, ..., @var{arg_n}])
1084 Retorna uma expressão @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
1085 O valor de retorno é simplificado, mas não avaliado,
1086 então a função @var{F} não é chamada, mesmo se essa função @var{F} existir.
1088 @code{funmake} não tenta distinguir funções de array de funções comuns;
1089 quando @var{F} for o nome de uma função de array,
1090 @code{funmake} retorna @code{@var{F}(...)}
1091 (isto é, uma chamada de função com parêntesis em lugar de colchêtes).
1092 @code{arraymake} retorna uma chamada de função com colchêtes nesse caso.
1094 @code{funmake} avalia seus argumentos.
1096 Exemplos:
1098 @code{funmake} aplicada a uma função comum do Maxima.
1100 @c ===beg===
1101 @c F (x, y) := y^2 - x^2;
1102 @c funmake (F, [a + 1, b + 1]);
1103 @c ''%;
1104 @c ===end===
1105 @example
1106 (%i1) F (x, y) := y^2 - x^2;
1107 2 2
1108 (%o1) F(x, y) := y - x
1109 (%i2) funmake (F, [a + 1, b + 1]);
1110 (%o2) F(a + 1, b + 1)
1111 (%i3) ''%;
1112 2 2
1113 (%o3) (b + 1) - (a + 1)
1114 @end example
1116 @code{funmake} aplicada a uma macro.
1118 @c ===beg===
1119 @c G (x) ::= (x - 1)/2;
1120 @c funmake (G, [u]);
1121 @c ''%;
1122 @c ===end===
1123 @example
1124 (%i1) G (x) ::= (x - 1)/2;
1125 x - 1
1126 (%o1) G(x) ::= -----
1127 2
1128 (%i2) funmake (G, [u]);
1129 (%o2) G(u)
1130 (%i3) ''%;
1131 u - 1
1132 (%o3) -----
1133 2
1134 @end example
1136 @code{funmake} aplicada a uma função subscrita.
1138 @c ===beg===
1139 @c H [a] (x) := (x - 1)^a;
1140 @c funmake (H [n], [%e]);
1141 @c ''%;
1142 @c funmake ('(H [n]), [%e]);
1143 @c ''%;
1144 @c ===end===
1145 @example
1146 (%i1) H [a] (x) := (x - 1)^a;
1147 a
1148 (%o1) H (x) := (x - 1)
1149 a
1150 (%i2) funmake (H [n], [%e]);
1151 n
1152 (%o2) lambda([x], (x - 1) )(%e)
1153 (%i3) ''%;
1154 n
1155 (%o3) (%e - 1)
1156 (%i4) funmake ('(H [n]), [%e]);
1157 (%o4) H (%e)
1158 n
1159 (%i5) ''%;
1160 n
1161 (%o5) (%e - 1)
1162 @end example
1164 @code{funmake} aplicada a um símbolo que não é uma função definida de qualquer tipo.
1166 @c ===beg===
1167 @c funmake (A, [u]);
1168 @c ''%;
1169 @c ===end===
1170 @example
1171 (%i1) funmake (A, [u]);
1172 (%o1) A(u)
1173 (%i2) ''%;
1174 (%o2) A(u)
1175 @end example
1177 @code{funmake} avalia seus argumentos, mas não o valor de retorno.
1179 @c ===beg===
1180 @c det(a,b,c) := b^2 -4*a*c;
1181 @c (x : 8, y : 10, z : 12);
1182 @c f : det;
1183 @c funmake (f, [x, y, z]);
1184 @c ''%;
1185 @c ===end===
1186 @example
1187 (%i1) det(a,b,c) := b^2 -4*a*c;
1188 2
1189 (%o1) det(a, b, c) := b - 4 a c
1190 (%i2) (x : 8, y : 10, z : 12);
1191 (%o2) 12
1192 (%i3) f : det;
1193 (%o3) det
1194 (%i4) funmake (f, [x, y, z]);
1195 (%o4) det(8, 10, 12)
1196 (%i5) ''%;
1197 (%o5) - 284
1198 @end example
1199 Maxima simplifica o valor de retorno de @code{funmake}.
1201 @c ===beg===
1202 @c funmake (sin, [%pi / 2]);
1203 @c ===end===
1204 @example
1205 (%i1) funmake (sin, [%pi / 2]);
1206 (%o1) 1
1207 @end example
1209 @end deffn
1211 @deffn {Função} lambda ([@var{x_1}, ..., @var{x_m}], @var{expr_1}, ..., @var{expr_n})
1212 @deffnx {Função} lambda ([[@var{L}]], @var{expr_1}, ..., @var{expr_n})
1213 @deffnx {Função} lambda ([@var{x_1}, ..., @var{x_m}, [@var{L}]], @var{expr_1}, ..., @var{expr_n})
1214 Define e retorna uma expressão lambda (que é, uma função an@^onima)
1215 A função pode ter argumentos que sejam necessários @var{x_1}, ..., @var{x_m}
1216 e/ou argumentos opcionais @var{L}, os quais aparecem dentro do corpo da função como uma lista.
1217 O valor de retorno da função é @var{expr_n}.
1218 Uma expressão lambda pode ser atribuída para uma variável e avaliada como uma função comum.
1219 Uma expressão lambda pode aparecer em alguns contextos nos quais um nome de função é esperado.
1221 Quando a função é avaliada,
1222 variáveis locais não associadas @var{x_1}, ..., @var{x_m} são criadas.
1223 @code{lambda} pode aparecer dentro de @code{block} ou outra função @code{lambda};
1224 variáveis locais são estabelecidas cada vez que outro @code{block} ou função @code{lambda} é avaliada.
1225 Variáveis locais parecem ser globais para qualquer coisa contendo @code{block} ou @code{lambda}.
1226 Se uma variável é não local,
1227 seu valor é o valor mais recentemente atribuído em alguma coisa contendo @code{block} ou @code{lambda}, qualquer que seja,
1228 de outra forma, seu valor é o valor da variável no ambiente global.
1229 Essa política pode coincidir com o entendimento usual de "escopo dinâmico".
1231 Após variáveis locais serem estabelecidas,
1232 @var{expr_1} até @var{expr_n} são avaliadas novamente.
1233 a variável especial @code{%%}, representando o valor da expressão precedente,
1234 é reconhecida.
1235 @code{throw} e @code{catch} pode também aparecer na lista de expressões.
1237 @code{return} não pode aparecer em uma expressão lambda a menos que contendo @code{block},
1238 nesse caso @code{return} define o valor de retorno do bloco e não da
1239 expressão lambda,
1240 a menos que o bloco seja @var{expr_n}.
1241 Da mesma forma, @code{go} não pode aparecer em uma expressão lambda a menos que contendo @code{block}.
1243 @code{lambda} não avalia seus argumentos;
1244 o operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
1246 Exemplos:
1248 @itemize @bullet
1249 @item
1250 A expressão lambda pode ser atribuída para uma variável e avaliada como uma função comum.
1251 @end itemize
1252 @c ===beg===
1253 @c f: lambda ([x], x^2);
1254 @c f(a);
1255 @c ===end===
1256 @example
1257 (%i1) f: lambda ([x], x^2);
1258 2
1259 (%o1) lambda([x], x )
1260 (%i2) f(a);
1261 2
1262 (%o2) a
1263 @end example
1264 @itemize @bullet
1265 @item
1266 Uma expressão lambda pode aparecer em contextos nos quais uma avaliação de função é esperada como resposta.
1267 @end itemize
1268 @c ===beg===
1269 @c lambda ([x], x^2) (a);
1270 @c apply (lambda ([x], x^2), [a]);
1271 @c map (lambda ([x], x^2), [a, b, c, d, e]);
1272 @c ===end===
1273 @example
1274 (%i3) lambda ([x], x^2) (a);
1275 2
1276 (%o3) a
1277 (%i4) apply (lambda ([x], x^2), [a]);
1278 2
1279 (%o4) a
1280 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
1281 2 2 2 2 2
1282 (%o5) [a , b , c , d , e ]
1283 @end example
1284 @itemize @bullet
1285 @item
1286 Variáveis argumento são variáveis locais.
1287 Outras variáveis aparecem para serem variáveis globais.
1288 Variáveis globais são avaliadas ao mesmo tempo em que a expressão lambda é avaliada,
1289 a menos que alguma avaliação especial seja forçada por alguns meios, tais como @code{'@w{}'}.
1290 @end itemize
1291 @c ===beg===
1292 @c a: %pi$
1293 @c b: %e$
1294 @c g: lambda ([a], a*b);
1295 @c b: %gamma$
1296 @c g(1/2);
1297 @c g2: lambda ([a], a*''b);
1298 @c b: %e$
1299 @c g2(1/2);
1300 @c ===end===
1301 @example
1302 (%i6) a: %pi$
1303 (%i7) b: %e$
1304 (%i8) g: lambda ([a], a*b);
1305 (%o8) lambda([a], a b)
1306 (%i9) b: %gamma$
1307 (%i10) g(1/2);
1308 %gamma
1309 (%o10) ------
1310 2
1311 (%i11) g2: lambda ([a], a*''b);
1312 (%o11) lambda([a], a %gamma)
1313 (%i12) b: %e$
1314 (%i13) g2(1/2);
1315 %gamma
1316 (%o13) ------
1317 2
1318 @end example
1319 @itemize @bullet
1320 @item
1321 Expressões lambda podem ser aninhadas.
1322 Variáveis locais dentro de outra expressão lambda parece ser global para a expressão interna
1323 a menos que mascarada por variáveis locais de mesmos nomes.
1324 @end itemize
1325 @c ===beg===
1326 @c h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1327 @c h(%pi, %gamma);
1328 @c ===end===
1329 @example
1330 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1331 1
1332 (%o14) lambda([a, b], h2 : lambda([a], a b), h2(-))
1333 2
1334 (%i15) h(%pi, %gamma);
1335 %gamma
1336 (%o15) ------
1337 2
1338 @end example
1339 @itemize @bullet
1340 @item
1341 Uma vez que @code{lambda} não avalia seus argumentos, a expressão lambda @code{i} abaixo
1342 não define uma função "multiplicação por @code{a}".
1343 Tanto uma função pode ser definida via @code{buildq}, como na expressão lambda @code{i2} abaixo.
1344 @end itemize
1345 @c ===beg===
1346 @c i: lambda ([a], lambda ([x], a*x));
1347 @c i(1/2);
1348 @c i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1349 @c i2(1/2);
1350 @c i2(1/2)(%pi);
1351 @c ===end===
1352 @example
1353 (%i16) i: lambda ([a], lambda ([x], a*x));
1354 (%o16) lambda([a], lambda([x], a x))
1355 (%i17) i(1/2);
1356 (%o17) lambda([x], a x)
1357 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1358 (%o18) lambda([a], buildq([a : a], lambda([x], a x)))
1359 (%i19) i2(1/2);
1360 x
1361 (%o19) lambda([x], -)
1362 2
1363 (%i20) i2(1/2)(%pi);
1364 %pi
1365 (%o20) ---
1366 2
1367 @end example
1368 @itemize @bullet
1369 @item
1370 Uma expressão lambda pode receber um número variável de argumentos,
1371 os quais são indicados por meio de @code{[@var{L}]} como o argumento único ou argumento final.
1372 Os argumentos aparecem dentro do corpo da função como uma lista.
1373 @end itemize
1374 @c ===beg===
1375 @c f : lambda ([aa, bb, [cc]], aa * cc + bb);
1376 @c f (foo, %i, 17, 29, 256);
1377 @c g : lambda ([[aa]], apply ("+", aa));
1378 @c g (17, 29, x, y, z, %e);
1379 @c ===end===
1380 @example
1381 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
1382 (%o1) lambda([aa, bb, [cc]], aa cc + bb)
1383 (%i2) f (foo, %i, 17, 29, 256);
1384 (%o2) [17 foo + %i, 29 foo + %i, 256 foo + %i]
1385 (%i3) g : lambda ([[aa]], apply ("+", aa));
1386 (%o3) lambda([[aa]], apply(+, aa))
1387 (%i4) g (17, 29, x, y, z, %e);
1388 (%o4) z + y + x + %e + 46
1389 @end example
1390 @end deffn
1392 @c NEEDS CLARIFICATION AND EXAMPLES
1393 @deffn {Função} local (@var{v_1}, ..., @var{v_n})
1394 Declara as variáveis @var{v_1}, ..., @var{v_n} para serem locais com
1395 relação a todas as propriedades na declaração na qual essa função
1396 é usada.
1398 @code{local} não avalia seus argumentos.
1399 @code{local} retorna @code{done}.
1401 @code{local} pode somente ser usada em @code{block}, no corpo de definições
1402 de função ou expressões @code{lambda}, ou na função @code{ev}, e somente uma
1403 ocorrêcia é permitida em cada.
1405 @code{local} é independente de @code{context}.
1407 @end deffn
1409 @defvr {Variável de opção} macroexpansion
1410 Valor por omissão: @code{false}
1412 @code{macroexpansion} controla recursos avançados que
1413 afectam a eficiência de macros. Escolhas possíveis:
1415 @itemize @bullet
1416 @item
1417 @code{false} -- Macros expandem normalmente cada vez que são chamadas.
1418 @item
1419 @code{expand} -- A primeira vez de uma chamada particular é avaliada, a
1420 expansão é lembrada internamente, dessa forma não tem como ser
1421 recalculada em chamadas subsequênte rapidamente. A
1422 macro chama ainda chamadas @code{grind} e @code{display} normalmente. Todavia, memória extra é
1423 requerida para lembrar todas as expansões.
1424 @item
1425 @code{displace} -- A primeira vez de uma chamada particular é avaliada, a
1426 expansão é substituída pela chamada. Isso requer levemente menos
1427 armazenagem que quando @code{macroexpansion} é escolhida para @code{expand} e é razoávelmente rápido,
1428 mas tem a desvantagem de a macro original ser lentamente
1429 lembrada e daí a expansão será vista se @code{display} ou @code{grind} for
1430 chamada. Veja a documentação para @code{translate} e @code{macros} para maiores detalhes.
1431 @end itemize
1432 @c NEED SOME EXAMPLES HERE.
1434 @end defvr
1436 @defvr {Variável de opção} mode_checkp
1437 Valor por omissão: @code{true}
1439 @c WHAT DOES THIS MEAN ??
1440 Quando @code{mode_checkp} é @code{true}, @code{mode_declare} verifica os modos
1441 de associação de variáveis.
1442 @c NEED SOME EXAMPLES HERE.
1444 @end defvr
1446 @defvr {Variável de opção} mode_check_errorp
1447 Valor por omissão: @code{false}
1449 @c WHAT DOES THIS MEAN ??
1450 Quando @code{mode_check_errorp} é @code{true}, @code{mode_declare} chama
1451 a função "error".
1452 @c NEED SOME EXAMPLES HERE.
1454 @end defvr
1456 @defvr {Variável de opção} mode_check_warnp
1457 Valor por omissão: @code{true}
1459 @c WHAT DOES THIS MEAN ??
1460 Quando @code{mode_check_warnp} é @code{true}, modo "errors" são
1461 descritos.
1462 @c NEED SOME EXAMPLES HERE.
1464 @end defvr
1466 @c NEEDS CLARIFICATION AND EXAMPLES
1467 @deffn {Função} mode_declare (@var{y_1}, @var{mode_1}, ..., @var{y_n}, @var{mode_n})
1468 @code{mode_declare} é usado para declarar os modos de variáveis e
1469 funções para subsequênte tradução ou compilação das funções.
1470 @code{mode_declare} é tipicamente colocada no início de uma definição de
1471 função, no início de um script Maxima, ou executado através da linha de comando de forma interativa.
1473 Os argumentos de @code{mode_declare} são pares consistindo de uma variável e o modo que é
1474 um de @code{boolean}, @code{fixnum}, @code{number}, @code{rational}, ou @code{float}.
1475 Cada variável pode também
1476 ser uma lista de variáveis todas as quais são declaradas para ter o mesmo modo.
1478 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1479 Se uma variável é um array, e se todo elemento do array que é
1480 referenciado tiver um valor então @code{array (yi, complete, dim1, dim2, ...)}
1481 em lugar de
1482 @example
1483 array(yi, dim1, dim2, ...)
1484 @end example
1485 deverá ser usado primeiro
1486 declarando as associações do array.
1487 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1488 Se todos os elementos do array
1489 estão no modo @code{fixnum} (@code{float}), use @code{fixnum} (@code{float}) em lugar de @code{complete}.
1490 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1491 Também se todo elemento do array está no mesmo modo, digamos @code{m}, então
1493 @example
1494 mode_declare (completearray (yi), m))
1495 @end example
1497 deverá ser usado para uma tradução
1498 eficiente.
1500 Código numéricos usando arrays podem rodar mais rápidamente
1501 se for decladado o tamanho esperado do array, como em:
1503 @example
1504 mode_declare (completearray (a [10, 10]), float)
1505 @end example
1507 para um array numérico em ponto flutuante que é 10 x 10.
1509 Pode-se declarar o modo do resultado de uma função
1510 usando @code{function (f_1, f_2, ...)} como um argumento;
1511 aqui @code{f_1}, @code{f_2}, ... são nomes
1512 de funções. Por exemplo a expressão,
1514 @example
1515 mode_declare ([function (f_1, f_2, ...)], fixnum)
1516 @end example
1518 declara que os valores retornados por @code{f_1}, @code{f_2}, ... são inteiros palavra simples.
1520 @code{modedeclare} é um sin@^onimo para @code{mode_declare}.
1522 @end deffn
1524 @c WHAT IS THIS ABOUT ??
1525 @c NEEDS CLARIFICATION AND EXAMPLES
1526 @deffn {Função} mode_identity (@var{arg_1}, @var{arg_2})
1527 Uma forma especial usada com @code{mode_declare} e @code{macros} para
1528 declarar, e.g., uma lista de listas de números em ponto flutuante ou
1529 outros objectos de dados. O primeiro argumento para
1530 @code{mode_identity} é um valor primitivo nome de modo como dado para
1531 @code{mode_declare} (i.e., um de @code{float}, @code{fixnum},
1532 @code{number}, @code{list}, ou @code{any}), e o segundo argumento é
1533 uma expressão que é avaliada e retornada com o valor de
1534 @code{mode_identity}. No entanto, se o valor de retorno não é
1535 permitido pelo modo declarado no primeiro argumento, um erro ou alerta
1536 é sinalizado. Um ponto importante é que o modo da expressão como
1537 determinado pelo Maxima para o tradutor Lisp, será aquele dado como o
1538 primeiro argumento, independente de qualquer coisa que vá no segundo
1539 argumento. E.g., @code{x: 3.3; mode_identity (fixnum, x);} retorna um
1540 erro. @code{mode_identity (flonum, x)} returns 3.3 . Isto tem
1541 númerosas utilidades, por exemplo, se souber que @code{first (l)}
1542 retornou um número então poderá escrever @code{mode_identity
1543 (number, first (l))}. No entanto, um caminho mais eficiente para fazer a
1544 mesma coisa é definir uma nova primitiva,
1546 @example
1547 firstnumb (x) ::= buildq ([x], mode_identity (number, first(x)));
1548 @end example
1550 e usar @code{firstnumb} sempre que obtiver o primeiro de uma lista de
1551 números.
1553 @end deffn
1555 @c IS THERE ANY REASON TO SET transcompile: false ??
1556 @c MAYBE THIS VARIABLE COULD BE PERMANENTLY SET TO true AND STRUCK FROM THE DOCUMENTATION.
1557 @defvr {Variável de opção} transcompile
1558 Valor por omissão: @code{true}
1560 Quando @code{transcompile} é @code{true}, @code{translate} e @code{translate_file} geram
1561 declarações para fazer o código traduzido mais adequado para compilação.
1562 @c BUT THE DECLARATIONS DON'T SEEM TO BE NECESSARY, SO WHAT'S THE POINT AGAIN ??
1564 @code{compfile} escolhe @code{transcompile: true} para a duração.
1566 @end defvr
1568 @deffn {Função} translate (@var{f_1}, ..., @var{f_n})
1569 @deffnx {Função} translate (funções)
1570 @deffnx {Função} translate (all)
1571 Traduz funções definidas pelo utilizador
1572 @var{f_1}, ..., @var{f_n} da linguagem de Maxima para Lisp
1573 e avalia a tradução Lisp.
1574 Tipicamente as funções traduzidas executam mais rápido que as originais.
1576 @code{translate (all)} ou @code{translate (funções)} traduz todas as funções definidas pelo utilizador.
1578 Funções a serem traduzidas incluir~ao uma chamada para @code{mode_declare} no
1579 início quando possível com o objectivo de produzir um código mais eficiente. Por
1580 exemplo:
1582 @example
1583 f (x_1, x_2, ...) := block ([v_1, v_2, ...],
1584 mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)
1585 @end example
1587 @noindent
1589 quando @var{x_1}, @var{x_2}, ... são parâmetros para a função e
1590 @var{v_1}, @var{v_2}, ... são variáveis locais.
1592 Os nomes de funções traduzidas
1593 são removidos da lista @code{functions} se @code{savedef} é @code{false} (veja abaixo)
1594 e são adicionados nas listas @code{props}.
1596 Funções não poderão ser traduzidas
1597 a menos que elas sejam totalmente depuradas.
1599 Expressões são assumidas simplificadas; se não forem, um código correcto será gerado mas não será um código
1600 óptimo. Dessa forma, o utilizador não poderá escolher o comutador @code{simp} para @code{false}
1601 o qual inibe simplificação de expressões a serem traduzidas.
1603 O comutador @code{translate}, se @code{true}, causa tradução
1604 automatica de uma função de utilizador para Lisp.
1606 Note que funções
1607 traduzidas podem não executar identicamente para o caminho que elas faziam antes da
1608 tradução como certas incompatabilidades podem existir entre o Lisp
1609 e versões do Maxima. Principalmente, a função @code{rat} com mais de
1610 um argumento e a função @code{ratvars} não poderá ser usada se quaisquer
1611 variáveis são declaradas com @code{mode_declare} como sendo expressões rotacionais canónicas(CRE).
1612 Também a escolha @code{prederror: false}
1613 não traduzirá.
1614 @c WHAT ABOUT % AND %% ???
1616 @code{savedef} - se @code{true} fará com que a versão Maxima de uma função
1617 utilizador permaneça quando a função é traduzida com @code{translate}. Isso permite a
1618 que definição seja mostrada por @code{dispfun} e autoriza a função a ser
1619 editada.
1621 @code{transrun} - se @code{false} fará com que a versão interpretada de todas as
1622 funções sejam executadas (desde que estejam ainda disponíveis) em lugar da
1623 versão traduzida.
1625 O resultado retornado por @code{translate} é uma lista de nomes de
1626 funções traduzidas.
1628 @end deffn
1630 @deffn {Função} translate_file (@var{maxima_nomeficheiro})
1631 @deffnx {Função} translate_file (@var{maxima_nomeficheiro}, @var{lisp_nomeficheiro})
1632 Traduz um ficheiro com código Maxima para um ficheiro com código Lisp.
1633 @code{translate_file} retorna uma lista de três nomes de ficheiro:
1634 O nome do ficheiro Maxima, o nome do ficheiro Lisp, e o nome do ficheiro
1635 contendo informações adicionais sobre a tradução.
1636 @code{translate_file} avalia seus argumentos.
1638 @code{translate_file ("foo.mac"); load("foo.LISP")} é o mesmo que
1639 @code{batch ("foo.mac")} excepto por certas restrições,
1640 o uso de @code{'@w{}'} e @code{%}, por exemplo.
1641 @c FIGURE OUT WHAT THE RESTRICTIONS ARE AND STATE THEM
1643 @code{translate_file (@var{maxima_nomeficheiro})} traduz um ficheiro Maxima @var{maxima_nomeficheiro}
1644 para um similarmente chamado ficheiro Lisp.
1645 Por exemplo, @code{foo.mac} é traduzido em @code{foo.LISP}.
1646 O nome de ficheiro Maxima pod incluir nome ou nomes de directório(s),
1647 nesse caso o ficheiro de saída Lisp é escrito
1648 para o mesmo directório que a entrada Maxima.
1650 @code{translate_file (@var{maxima_nomeficheiro}, @var{lisp_nomeficheiro})} traduz
1651 um ficheiro Maxima @var{maxima_nomeficheiro} em um ficheiro Lisp @var{lisp_nomeficheiro}.
1652 @code{translate_file} ignora a extensão do nome do ficheiro, se qualquer, de @code{lisp_nomeficheiro};
1653 a extensão do ficheiro de saída Lisp é sempre @code{LISP}.
1654 O nome de ficheiro Lisp pode incluir um nome ou nomes de directórios),
1655 nesse caso o ficheiro de saída Lisp é escrito para o directório especificado.
1657 @code{translate_file} também escreve um ficheiro de mensagens de alerta
1658 do tradutor em vários graus de severidade.
1659 A extensão do nome de ficheiro desse ficheiro é @code{UNLISP}.
1660 Esse ficheiro pode conter informação valiosa, apesar de possivelmente obscura,
1661 para rastrear erros no código traduzido.
1662 O ficheiro @code{UNLISP} é sempre escrito
1663 para o mesmo directório que a entrada Maxima.
1665 @code{translate_file} emite código Lisp o qual faz com que
1666 algumas definições tenham efeito tão logo
1667 o código Lisp é compilado.
1668 Veja @code{compile_file} para mais sobre esse tópico.
1670 @c CHECK ALL THESE AND SEE WHICH ONES ARE OBSOLETE
1671 Veja também @code{tr_array_as_ref},
1672 @c tr_bind_mode_hook EXISTS BUT IT APPEARS TO BE A GROTESQUE UNDOCUMENTED HACK
1673 @c WE DON'T WANT TO MENTION IT
1674 @c @code{tr_bind_mode_hook},
1675 @code{tr_bound_function_applyp},
1676 @c tr_exponent EXISTS AND WORKS AS ADVERTISED IN src/troper.lisp
1677 @c NOT OTHERWISE DOCUMENTED; ITS EFFECT SEEMS TOO WEAK TO MENTION
1678 @code{tr_exponent},
1679 @code{tr_file_tty_messagesp},
1680 @code{tr_float_can_branch_complex},
1681 @code{tr_function_call_default},
1682 @code{tr_numer},
1683 @code{tr_optimize_max_loop},
1684 @code{tr_semicompile},
1685 @code{tr_state_vars},
1686 @code{tr_warnings_get},
1687 @code{tr_warn_bad_function_calls},
1688 @code{tr_warn_fexpr},
1689 @code{tr_warn_meval},
1690 @code{tr_warn_mode},
1691 @code{tr_warn_undeclared},
1692 e @code{tr_warn_undefined_variable}.
1694 @end deffn
1696 @defvr {Variável de opção} transrun
1697 Valor por omissão: @code{true}
1699 Quando @code{transrun} é @code{false} fará com que a versão
1700 interpretada de todas as funções sejam executadas (desde que estejam ainda disponíveis)
1701 em lugar de versão traduzidas.
1703 @end defvr
1705 @c IN WHAT CONTEXT IS tr_array_as_ref: false APPROPRIATE ??? NOT SEEING THE USEFULNESS HERE.
1706 @c ALSO, I GUESS WE SHOULD HAVE AN ITEM FOR translate_fast_arrays, ANOTHER CONFUSING FLAG ...
1707 @defvr {Variável de opção} tr_array_as_ref
1708 Valor por omissão: @code{true}
1710 Se @code{translate_fast_arrays} for @code{false}, referências a arrays no
1711 Código Lisp emitidas por @code{translate_file} são afectadas por @code{tr_array_as_ref}.
1712 Quando @code{tr_array_as_ref} é @code{true},
1713 nomes de arrays são avaliados,
1714 de outra forma nomes de arrays aparecem como símbolos literais no código traduzido.
1716 @code{tr_array_as_ref} não terão efeito se @code{translate_fast_arrays} for @code{true}.
1718 @end defvr
1720 @c WHY IS THIS FLAG NEEDED ??? UNDER WHAT CIRCUMSTANCES CAN TRANSLATION
1721 @c OF A BOUND VARIABLE USED AS A FUNCTION GO WRONG ???
1722 @defvr {Variável de opção} tr_bound_function_applyp
1723 Valor por omissão: @code{true}
1725 Quando @code{tr_bound_function_applyp} for @code{true}, Maxima emite um alerta se uma associação
1726 de variável (tal como um argumento de função) é achada sendo usada como uma função.
1727 @code{tr_bound_function_applyp} não afecta o código gerado em tais casos.
1729 Por exemplo, uma expressão tal como @code{g (f, x) := f (x+1)} irá disparar
1730 a mensagem de alerta.
1732 @end defvr
1734 @defvr {Variável de opção} tr_file_tty_messagesp
1735 Valor por omissão: @code{false}
1737 Quando @code{tr_file_tty_messagesp} é @code{true},
1738 messagens geradas por @code{translate_file} durante a tradução de um ficheiro são mostradas
1739 sobre o console e inseridas dentro do ficheiro UNLISP.
1740 Quando @code{false}, messagens sobre traduções de
1741 ficheiros são somente inseridas dentro do ficheiro UNLISP.
1743 @end defvr
1745 @c THIS FLAG APPEARS TO HAVE NO EFFECT. SHOULD CUT OUT THIS ITEM AND RELATED CODE.
1746 @c NOTE THAT THERE IS CODE IN src/transf.lisp WHICH USES THIS FLAG BUT THE MODE
1747 @c FLAG IS LOST SOMEWHERE ALONG THE WAY TO THE LISP OUTPUT FILE.
1748 @defvr {Variável de opção} tr_float_can_branch_complex
1749 Valor por omissão: @code{true}
1751 Diz ao tradutor Maxima-para-Lisp assumir que as funções
1752 @code{acos}, @code{asin}, @code{asec}, e @code{acsc} podem retornar resultados complexos.
1754 O efeito ostensivo de @code{tr_float_can_branch_complex} é mostrado adiante.
1755 Todavia, parece que esse sinalizador não tem efeito sobre a saída do tradutor.
1757 Quando isso for @code{true} então @code{acos(x)} será do modo @code{any}
1758 sempre que @code{x} for do modo @code{float} (como escolhido por @code{mode_declare}).
1759 Quando @code{false} então @code{acos(x)} será do modo
1760 @code{float} se e somente se @code{x} for do modo @code{float}.
1762 @end defvr
1764 @defvr {Variável de opção} tr_function_call_default
1765 Valor por omissão: @code{general}
1767 @code{false} significa abandonando e
1768 chamando @code{meval}, @code{expr} significa que Lisp assume função de argumento fixado. @code{general}, o
1769 código padrão dado como sendo bom para @code{mexprs} e @code{mlexprs} mas não @code{macros}.
1770 @code{general} garante que associações de variável são correctas em códigos compilados. No
1771 modo @code{general}, quando traduzindo F(X), se F for uma variável associada, então isso
1772 assumirá que @code{apply (f, [x])} é significativo, e traduz como tal, com
1773 o alerta apropriado. Não é necessário desabilitar isso. Com as
1774 escolhas padrão, sem mensagens de alerta implica compatibilidade total do
1775 código traduzido e compilado com o interpretador Maxima.
1777 @end defvr
1779 @defvr {Variável de opção} tr_numer
1780 Valor por omissão: @code{false}
1782 Quando @code{tr_numer} for @code{true} propriedades @code{numer} são usadas para
1783 átomos que possuem essa propriedade, e.g. @code{%pi}.
1785 @end defvr
1787 @defvr {Variável de opção} tr_optimize_max_loop
1788 Valor por omissão: 100
1790 @code{tr_optimize_max_loop} é número máximo de vezes do
1791 passo de macro-expansão e optimização que o tradutor irá executar
1792 considerando uma forma. Isso é para capturar erros de expansão de macro, e
1793 propriedades de optimização não terminadas.
1795 @end defvr
1797 @defvr {Variável de opção} tr_semicompile
1798 Valor por omissão: @code{false}
1800 Quando @code{tr_semicompile} for @code{true}, as formas de saída de @code{translate_file}
1801 e @code{compfile} serão macroexpandidas mas não compiladas em código
1802 de máquina pelo compilador Lisp.
1804 @end defvr
1806 @c ARE ANY OF THESE OBSOLETE ??
1807 @defvr {Variável de sistema} tr_state_vars
1808 Valor por omissão:
1809 @example
1810 [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
1811 tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
1812 tr_function_call_default, tr_array_as_ref,tr_numer]
1813 @end example
1815 A lista de comutadores que afectam a forma de saída da
1816 tradução.
1817 @c DOES THE GENERAL USER REALLY CARE ABOUT DEBUGGING THE TRANSLATOR ???
1818 Essa informação é útil para sistemas populares quando
1819 tentam depurar o tradutor. Comparando o produto traduzido
1820 para o qual pode ter sido produzido por um dado estado, isso é possível para
1821 rastrear erros.
1823 @end defvr
1825 @c tr_warnings_get EXISTS AND FUNCTIONS AS ADVERTISED (SORT OF) -- RETURNS *tr-runtime-warned*
1826 @c WHICH HAS ONLY A FEW KINDS OF WARNINGS PUSHED ONTO IT; IT'S CERTAINLY NOT COMPREHENSIVE
1827 @c DO WE REALLY NEED THIS SLIGHTLY WORKING FUNCTION ??
1828 @deffn {Função} tr_warnings_get ()
1829 Imprime uma lista de alertas que podem ter sido dadas pelo
1830 tradutor durante a tradução corrente.
1832 @end deffn
1834 @defvr {Variável de opção} tr_warn_bad_function_calls
1835 Valor por omissão: @code{true}
1837 - Emite um alerta quando
1838 chamadas de função estão sendo feitas por um caminho que pode não ser correcto devido
1839 a declarações impróprias que foram feitas em tempo de tradução.
1841 @end defvr
1843 @defvr {Variável de opção} tr_warn_fexpr
1844 Valor por omissão: @code{compfile}
1846 - Emite um alerta se quaisquer FEXPRs forem
1847 encontradas. FEXPRs não poderão normalmente ser saída em código traduzido,
1848 todas as formas de programa especial legítimo são traduzidas.
1850 @end defvr
1852 @defvr {Variável} tr_warn_meval
1853 Valor por omissão: @code{compfile}
1855 - Emite um alerta se a função
1856 @code{meval} recebe chamadas. Se @code{meval} é chamada isso indica problemas na
1857 tradução.
1859 @end defvr
1861 @defvr {Variável} tr_warn_mode
1862 Valor por omissão: @code{all}
1864 - Emite um alerta quando a variáveis forem
1865 atribuídos valores inapropriados para seu modo.
1867 @end defvr
1869 @defvr {Variável de opção} tr_warn_undeclared
1870 Valor por omissão: @code{compile}
1872 - Determina quando enviar
1873 alertas sobre variáveis não declaradas para o TTY.
1875 @end defvr
1877 @defvr {Variável de opção} tr_warn_undefined_variable
1878 Valor por omissão: @code{all}
1880 - Emite um alerta quando
1881 variáveis globais indefinidas forem vistas.
1883 @end defvr
1885 @deffn {Função} compile_file (@var{nomeficheiro})
1886 @deffnx {Função} compile_file (@var{nomeficheiro}, @var{nomeficheiro_compilado})
1887 @deffnx {Função} compile_file (@var{nomeficheiro}, @var{nomeficheiro_compilado}, @var{lisp_nomeficheiro})
1888 Traduz o ficheiro Maxima @var{nomeficheiro} para Lisp,
1889 executa o compilador Lisp,
1890 e, se a tradução e a compilação obtiverem sucesso, chama o código compilado dentro do Maxima.
1892 @code{compile_file} retorna uma lista dos nomes de quatro ficheiros:
1893 o ficheiro original do Maxima, o nome da tradução Lisp, uma ficheiro de notas sobre a tradução, e o nome do ficheiro que contém o código compilado.
1894 Se a compilação falhar,
1895 o quarto item é @code{false}.
1897 Algumas declarações e definições passam a ter efeito tão logo
1898 o código Lisp seja compilado (sem que seja necessário chamar o código compilado).
1899 Isso inclui funções definidas com o operador @code{:=},
1900 macros definidas com o operador @code{::=}, @c HEDGE -- DON'T KNOW IF THERE IS ANOTHER WAY
1901 @code{alias}, @code{declare},
1902 @code{define_variable}, @code{mode_declare},
1903 e
1904 @code{infix}, @code{matchfix},
1905 @code{nofix}, @code{postfix}, @code{prefix},
1906 e @code{compfile}.
1908 Atribuições e chamadas de função não serão avaliadas até que o código compilado seja carregado.
1909 Em particular, dentro do ficheiro Maxima,
1910 atribuições para sinalizadores traduzidos (@code{tr_numer}, etc.) não têm efeito sobre a tradução.
1912 @c @code{compile_file} may mistake warnings for errors and
1913 @c return @code{false} as the name of the compiled code when, in fact,
1914 @c the compilation succeeded. This é a bug.
1915 @c REPORTED AS SOURCEFORGE BUG # 1103722.
1917 @var{nomeficheiro} pode não conter declarações @code{:lisp}.
1919 @code{compile_file} avalia seus argumentos.
1921 @end deffn
1923 @c NEEDS CLARIFICATION
1924 @deffn {Função} declare_translated (@var{f_1}, @var{f_2}, ...)
1925 Quando traduzindo um ficheiro do código Maxima
1926 para Lisp, é importante para o programa tradutor saber quais funções
1927 no ficheiro são para serem chamadas como funções traduzidas ou compiladas,
1928 e quais outras são apenas funções Maxima ou indefinidas. Colocando essa
1929 declaração no topo do ficheiro, faremos conhecido que embora um símbolo
1930 diga que não temos ainda um valor de função Lisp, teremos uma em
1931 tempo de chamada. @code{(MFUNCTION-CALL fn arg1 arg2 ...)} é gerado quando
1932 o tradutor n~ao sabe que @code{fn} está sendo compilada para ser uma função Lisp.
1934 @end deffn