| blob | 5eff10853238e09ae5240eac114d4519ff6a9dd9 |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Command.texi/1.44/Sat Jun 2 00:12:33 2007/-ko/
3 @iftex
4 @hyphenation{si-na-li-za-do-res}
5 @hyphenation{de-mo-ra-da-men-te}
6 @hyphenation{va-lo-res}
7 @end iftex
8 @menu
9 * Introdução a Linha de Comando::
10 * Funções e Variáveis Definidas para Linha de Comando::
11 @end menu
13 @node Introdução a Linha de Comando, Funções e Variáveis Definidas para Linha de Comando, Linha de Comando, Linha de Comando
14 @section Introdução a Linha de Comando
16 @c NEEDS EXAMPLES
17 @c THIS ITEM IS VERY IMPORTANT !!
18 @deffn {Operador} '
19 @ifinfo
20 @fnindex Operador Apóstrofo
21 @end ifinfo
22 O operador apóstrofo @code{'} evita avaliação.
24 Aplicado a um símbolo,
25 o apóstrofo evita avaliação do símbolo.
27 Aplicado a uma chamada de função,
28 o apóstrofo evita avaliação da chamada de função,
29 embora os argumentos da função sejam ainda avaliados (se a avaliação não for de outra forma evitada).
30 O resultado é a forma substantiva da chamada de função.
32 Aplicada a uma espressão com parêntesis,
33 o apóstrofo evita avaliação de todos os símbolos e chamadas de função na expressão.
34 @c DUNNO IF THESE EXAMPLES ARE STILL NEEDED -- COVERED BY ITEMS UNDER "Examples"
35 E.g., @code{'(f(x))} significa não avalie a expressão @code{f(x)}.
36 @code{'f(x)} (com apóstrofo aplicado a @code{f} em lugar de @code{f(x)})
37 retorna a forma substantiva de @code{f} aplicada a @code{[x]}.
39 O apóstrofo nao evita simplificação.
41 Quando o sinalizador global @code{noundisp} for @code{true},
42 substantivos são mostrados com um apóstrofo.
43 Esse comutador é sempre @code{true} quando mostrando definições de funções.
45 Veja também operador apóstrofo-apóstrofo @code{''} e @code{nouns}.
47 Exemplos:
49 Aplicado a um símbolo,
50 o apóstrofo evita avaliação do símbolo.
52 @c ===beg===
53 @c aa: 1024;
54 @c aa^2;
55 @c 'aa^2;
56 @c ''%;
57 @c ===end===
58 @example
59 (%i1) aa: 1024;
60 (%o1) 1024
61 (%i2) aa^2;
62 (%o2) 1048576
63 (%i3) 'aa^2;
64 2
65 (%o3) aa
66 (%i4) ''%;
67 (%o4) 1048576
68 @end example
70 Aplicado a uma chamada de função,
71 o apóstrofo evita avaliação da chamada de função.
72 O resultado é a forma substantiva da chamada de função.
74 @c ===beg===
75 @c x0: 5;
76 @c x1: 7;
77 @c integrate (x^2, x, x0, x1);
78 @c 'integrate (x^2, x, x0, x1);
79 @c %, nouns;
80 @c ===end===
81 @example
82 (%i1) x0: 5;
83 (%o1) 5
84 (%i2) x1: 7;
85 (%o2) 7
86 (%i3) integrate (x^2, x, x0, x1);
87 218
88 (%o3) ---
89 3
90 (%i4) 'integrate (x^2, x, x0, x1);
91 7
92 /
93 [ 2
94 (%o4) I x dx
95 ]
96 /
97 5
98 (%i5) %, nouns;
99 218
100 (%o5) ---
101 3
102 @end example
104 Aplicado a uma expressão com parêntesis,
105 o apóstrofo evita avaliação de todos os símbolos e chamadas de função na expressão.
107 @c ===beg===
108 @c aa: 1024;
109 @c bb: 19;
110 @c sqrt(aa) + bb;
111 @c '(sqrt(aa) + bb);
112 @c ''%;
113 @c ===end===
114 @example
115 (%i1) aa: 1024;
116 (%o1) 1024
117 (%i2) bb: 19;
118 (%o2) 19
119 (%i3) sqrt(aa) + bb;
120 (%o3) 51
121 (%i4) '(sqrt(aa) + bb);
122 (%o4) bb + sqrt(aa)
123 (%i5) ''%;
124 (%o5) 51
125 @end example
127 O apóstrofo não evita simplificação.
129 @c ===beg===
130 @c sin (17 * %pi) + cos (17 * %pi);
131 @c '(sin (17 * %pi) + cos (17 * %pi));
132 @c ===end===
133 @example
134 (%i1) sin (17 * %pi) + cos (17 * %pi);
135 (%o1) - 1
136 (%i2) '(sin (17 * %pi) + cos (17 * %pi));
137 (%o2) - 1
138 @end example
140 @end deffn
142 @deffn {Operador} ''
143 @ifinfo
144 @fnindex Operador apóstrofo-apóstrofo
145 @end ifinfo
146 O operador apóstrofo-apóstrofo @code{'@w{}'} (dois apóstrofost) modifica avaliação em expressões de entrada.
148 Aplicado a uma expressão geral @var{expr}, apóstrofo-apóstrofo faz com que o valor de @var{expr}
149 seja substituído por @var{expr} na expressão de entrada.
151 Aplicado ao operadro de uma expressão,
152 apóstrofo-apóstrofo modifica o operadro de um susbstantivo para um verbo (se esse operador não for já um verbo).
154 O operador apóstrofo-apóstrofo é aplicado através do passador de entrada;
155 o apóstrofo-apóstrofo não é armazenado como parte de uma expressão de entrada passada.
156 O operador apóstrofo-apóstrofo é sempre aplicado tão rapidamente quanto for passado,
157 e não pode receber um terceiro apóstrofo.
158 Dessa forma faz com que ocorra avaliação quando essa avaliação for de outra forma suprimida,
159 da mesma forma que em definições de função, definições de expressãoes lambda, e expressões que recebem um apóstrofo simples @code{'}.
161 Apóstrofo-apóstrofo é reconhecido por @code{batch} e @code{load}.
163 Veja também o operador apóstrofo @code{'} e @code{nouns}.
165 Exemplos:
167 Aplicado a uma expressão geral @var{expr}, apóstrofo-apóstrofo fazem com que o valor de @var{expr}
168 seja substituido por @var{expr} na expressão de entrada.
170 @c ===beg===
171 @c expand ((a + b)^3);
172 @c [_, ''_];
173 @c [%i1, ''%i1];
174 @c [aa : cc, bb : dd, cc : 17, dd : 29];
175 @c foo_1 (x) := aa - bb * x;
176 @c foo_1 (10);
177 @c ''%;
178 @c ''(foo_1 (10));
179 @c foo_2 (x) := ''aa - ''bb * x;
180 @c foo_2 (10);
181 @c [x0 : x1, x1 : x2, x2 : x3];
182 @c x0;
183 @c ''x0;
184 @c '' ''x0;
185 @c ===end===
186 @example
187 (%i1) expand ((a + b)^3);
188 3 2 2 3
189 (%o1) b + 3 a b + 3 a b + a
190 (%i2) [_, ''_];
191 3 3 2 2 3
192 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ]
193 (%i3) [%i1, ''%i1];
194 3 3 2 2 3
195 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ]
196 (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
197 (%o4) [cc, dd, 17, 29]
198 (%i5) foo_1 (x) := aa - bb * x;
199 (%o5) foo_1(x) := aa - bb x
200 (%i6) foo_1 (10);
201 (%o6) cc - 10 dd
202 (%i7) ''%;
203 (%o7) - 273
204 (%i8) ''(foo_1 (10));
205 (%o8) - 273
206 (%i9) foo_2 (x) := ''aa - ''bb * x;
207 (%o9) foo_2(x) := cc - dd x
208 (%i10) foo_2 (10);
209 (%o10) - 273
210 (%i11) [x0 : x1, x1 : x2, x2 : x3];
211 (%o11) [x1, x2, x3]
212 (%i12) x0;
213 (%o12) x1
214 (%i13) ''x0;
215 (%o13) x2
216 (%i14) '' ''x0;
217 (%o14) x3
218 @end example
220 Aplicado ao operador de uma expressão,
221 apóstrofo-apóstrofo muda o operadro de um substantivo para um verbo (se esse operadro não for já um verbo).
223 @c ===beg===
224 @c sin (1);
225 @c ''sin (1);
226 @c declare (foo, noun);
227 @c foo (x) := x - 1729;
228 @c foo (100);
229 @c ''foo (100);
230 @c ===end===
231 @example
232 (%i1) sin (1);
233 (%o1) sin(1)
234 (%i2) ''sin (1);
235 (%o2) 0.8414709848079
236 (%i3) declare (foo, noun);
237 (%o3) done
238 (%i4) foo (x) := x - 1729;
239 (%o4) ''foo(x) := x - 1729
240 (%i5) foo (100);
241 (%o5) foo(100)
242 (%i6) ''foo (100);
243 (%o6) - 1629
244 @end example
246 O operador apóstrofo-apóstrofo é aplicado por meio de um passador de entrada;
247 operador-apóstrofo não é armazenado como parte da expressão de entrada.
249 @c ===beg===
250 @c [aa : bb, cc : dd, bb : 1234, dd : 5678];
251 @c aa + cc;
252 @c display (_, op (_), args (_));
253 @c ''(aa + cc);
254 @c display (_, op (_), args (_));
255 @c ===end===
256 @example
257 (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
258 (%o1) [bb, dd, 1234, 5678]
259 (%i2) aa + cc;
260 (%o2) dd + bb
261 (%i3) display (_, op (_), args (_));
262 _ = cc + aa
264 op(cc + aa) = +
266 args(cc + aa) = [cc, aa]
268 (%o3) done
269 (%i4) ''(aa + cc);
270 (%o4) 6912
271 (%i5) display (_, op (_), args (_));
272 _ = dd + bb
274 op(dd + bb) = +
276 args(dd + bb) = [dd, bb]
278 (%o5) done
279 @end example
281 Apóstrofo apóstrofo faz com que ocorra avaliação quando a avaliação tiver sido de outra forma suprimida,
282 da mesma forma que em definições de função, da mesma forma que em definições de função lambda expressions, E expressões que recebem o apóstrofo simples @code{'}.
284 @c ===beg===
285 @c foo_1a (x) := ''(integrate (log (x), x));
286 @c foo_1b (x) := integrate (log (x), x);
287 @c dispfun (foo_1a, foo_1b);
288 @c integrate (log (x), x);
289 @c foo_2a (x) := ''%;
290 @c foo_2b (x) := %;
291 @c dispfun (foo_2a, foo_2b);
292 @c F : lambda ([u], diff (sin (u), u));
293 @c G : lambda ([u], ''(diff (sin (u), u)));
294 @c '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
295 @c '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
296 @c ===end===
297 @example
298 (%i1) foo_1a (x) := ''(integrate (log (x), x));
299 (%o1) foo_1a(x) := x log(x) - x
300 (%i2) foo_1b (x) := integrate (log (x), x);
301 (%o2) foo_1b(x) := integrate(log(x), x)
302 (%i3) dispfun (foo_1a, foo_1b);
303 (%t3) foo_1a(x) := x log(x) - x
305 (%t4) foo_1b(x) := integrate(log(x), x)
307 (%o4) [%t3, %t4]
308 (%i4) integrate (log (x), x);
309 (%o4) x log(x) - x
310 (%i5) foo_2a (x) := ''%;
311 (%o5) foo_2a(x) := x log(x) - x
312 (%i6) foo_2b (x) := %;
313 (%o6) foo_2b(x) := %
314 (%i7) dispfun (foo_2a, foo_2b);
315 (%t7) foo_2a(x) := x log(x) - x
317 (%t8) foo_2b(x) := %
319 (%o8) [%t7, %t8]
320 (%i8) F : lambda ([u], diff (sin (u), u));
321 (%o8) lambda([u], diff(sin(u), u))
322 (%i9) G : lambda ([u], ''(diff (sin (u), u)));
323 (%o9) lambda([u], cos(u))
324 (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
325 (%o10) sum(b , k, 1, 3) + sum(a , k, 1, 3)
326 k k
327 (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
328 (%o11) b + a + b + a + b + a
329 3 3 2 2 1 1
330 @end example
332 @end deffn
334 @node Funções e Variáveis Definidas para Linha de Comando, , Introdução a Linha de Comando, Linha de Comando
335 @section Funções e Variáveis Definidas para Linha de Comando
337 @c NEEDS WORK, ESPECIALLY EXAMPLES
338 @deffn {Função} alias (@var{new_name_1}, @var{old_name_1}, ..., @var{new_name_n}, @var{old_name_n})
339 provê um
340 nome alternativo para uma função (de usuário ou de sistema), variável, array, etc.
341 Qualquer número de argumentos pode ser usado.
343 @end deffn
345 @defvr {Variável de opção} debugmode
346 Valor padrão: @code{false}
348 Quando um erro do Maxima ocorre, Maxima iniciará o depurador se @code{debugmode} for @code{true}.
349 O usuário pode informar comandos para examinar o histórico de chamadas, marcar pontos de parada, percorrer uma linha por vez
350 o código do Maxima, e assim por diante. Veja @code{debugging} para uma lista de opções do depurador.
352 Habilitando @code{debugmode} por meio da alteração de seu valor para @code{true}, não serão capturados erros do Lisp.
353 @c DO WE WANT TO SAY MORE ABOUT DEBUGGING LISP ERRORS ???
354 @c I'M NOT CONVINCED WE WANT TO OPEN THAT CAN OF WORMS !!!
356 @end defvr
358 @c NEEDS CLARIFICATION
359 @c VERY IMPORTANT !!
360 @deffn {Função} ev (@var{expr}, @var{arg_1}, ..., @var{arg_n})
361 Avalia a expressão @var{expr} no ambiente
362 especificado pelos argumentos @var{arg_1}, ..., @var{arg_n}.
363 Os argumentos são comutadores (sinalizadores Booleanos), atribuições, equações, e funções.
364 @code{ev} retorna o resultado (outra expressão) da avaliação.
366 A avaliação é realizada em passos, como segue.
368 @enumerate
369 @item
370 Primeiro o ambiente é preparado examinando os argumentos que podem
371 ser quaisquer ou todos os seguintes.
373 @itemize @bullet
374 @item
375 @code{simp} faz com que @var{expr} seja simplificado independentemente da posição do
376 comutador @code{simp} que inibe simplificação se @code{false}.
377 @item
378 @code{noeval} suprime a fase de avaliação de @code{ev} (veja passo (4) adiante).
379 Isso é útil juntamente com outros comutadores e faz com que
380 @var{expr} seja simplificado novamente sem ser reavaliado.
381 @item
382 @code{nouns} causa a avaliação de formas substantivas
383 (tipicamente funções não avaliadas tais como @code{'integrate} ou @code{'diff})
384 em @var{expr}.
385 @item
386 @code{expand} causa expansão.
387 @item
388 @code{expand (@var{m}, @var{n})} causa expansão, alterando os valores de @code{maxposex} e
389 @code{maxnegex} para @var{m} e @var{n} respectivamente.
390 @item
391 @code{detout} faz com que qualquer matriz inversa calculada em @var{expr} tenha seu
392 determinante mantido fora da inversa ao invés de dividindo a
393 cada elemento.
394 @item
395 @code{diff} faz com que todas as diferenciações indicadas em @var{expr} sejam executadas.
396 @item
397 @code{derivlist (@var{x}, @var{y}, @var{z}, ...)} causa somente diferenciações referentes às
398 variáveis indicadas.
399 @item
400 @code{float} faz com que números racionais não inteiros sejam convertidos para ponto
401 flutuante.
402 @item
403 @code{numer} faz com que algumas funções matemáticas (incluindo a exponenciação)
404 com argumentos sejam valiadas em ponto flutuante. Isso faz com que
405 variávels em @var{expr} que tenham sido dados numervals (valores numéricos) sejam substituídas por
406 seus valores. Isso também modifica o comutador @code{float} para ativado.
407 @item
408 @code{pred} faz com que predicados (expressões que podem ser avaliados em @code{true} ou @code{false})
409 sejam avaliadas.
410 @item
411 @code{eval} faz com que uma avaliação posterior de @var{expr} ocorra. (Veja passo (5)
412 adiante.)
413 @code{eval} pode ocorrer multiplas vezes.
414 Para cada instância de @code{eval}, a expressão é avaliada novamente.
415 @item
416 @code{A} onde @code{A} é um átomo declarado seja um sinalizador de avaliação (veja @code{evflag})
417 faz com que @code{A} seja associado a
418 @code{true} durante a avaliação de @var{expr}.
419 @item
420 @code{V: expresão} (ou alternativamente @code{V=expressão}) faz com que @code{V} seja associado ao
421 valor de @code{expressão} durante a avaliação de @var{expr}. Note que se @code{V} é uma
422 opção do Maxima, então @code{expression} é usada para seu valor durante a
423 avaliação de @var{expr}. Se mais que um argumento para @code{ev} é desse tipo
424 então a associação termina em paralelo. Se @code{V} é uma expressão não atômica
425 então a substituição, ao invés de uma associação, é executada.
426 @item
427 @code{F} onde @code{F}, um nome de função, tenha sido declarado para ser uma função de avaliação (veja @code{evfun})
428 faz com que @code{F}
429 seja aplicado a @var{expr}.
430 @item
431 Qualquer outro nome de função (e.g., @code{sum}) causa a avaliação de ocorrências
432 desses nomes em @var{expr} mesmo que eles tenham sido verbos.
433 @item
434 De forma adicional uma função ocorrendo em @var{expr} (digamos @code{F(x)}) pode ser definida
435 localmente para o propósito dessa avaliação de @var{expr} dando
436 @code{F(x) := expressão} como um argumento para @code{ev}.
437 @item
438 Se um átomo não mensionado acima ou uma variável subscrita ou
439 expressão subscrita for dada como um argumento, isso é avaliado e
440 se o resultado for uma equação ou uma atribuição então a associação indicada
441 ou substituição é executada. Se o resultado for uma lista então os
442 membros da lista serão tratados como se eles fossem argumentos adicionais
443 dados para @code{ev}. Isso permite que uma lista de equações seja dada (e.g. @code{[X=1, Y=A**2]})
444 ou que seja dado uma lista de nomes de equações (e.g., @code{[%t1, %t2]} onde @code{%t1} e
445 @code{%t2} são equações) tais como aquelas listas retornadas por @code{solve}.
446 @end itemize
448 Os argumentos de @code{ev} podem ser dados em qualquer ordem com exceção de
449 substituições de equações que são manuseadas em seq@"{u}ência, da esquerda para a direita,
450 e funções de avaliação que são compostas, e.g., @code{ev (@var{expr}, ratsimp, realpart)} são
451 manuseadas como @code{realpart (ratsimp (@var{expr}))}.
453 Os comutadores @code{simp}, @code{numer}, @code{float}, e @code{pred} podem também ser alterados localmente em um
454 bloco, ou globalmente no Maxima dessa forma eles irã
455 permanecer em efeito até serem resetados ao término da execução do bloco.
457 Se @var{expr} for uma expressão racional canônica (CRE),
458 então a expressão retornada por @code{ev} é também uma CRE,
459 contanto que os comutadores @code{numer} e @code{float} não sejam ambos @code{true}.
461 @item
462 Durante o passo (1), é feito uma lista de variáveis não subscritas
463 aparecendo do lado esquerdo das equações nos argumentos ou nos
464 valores de alguns argumentos se o valor for uma equação. As variáveis
465 (variáveis subscritas que não possuem funções array
466 associadas bem como variáveis não subscritas) na expressão @var{expr} são
467 substituídas por seus valores globais, exceto para esse aparecendo nessa
468 lista. Usualmente, @var{expr} é apenas um rótulo ou @code{%}
469 (como em @code{%i2} no exemplo adiante), então esse
470 passo simplesmente repete a expressão nomeada pelo rótulo, de modo que @code{ev}
471 possa trabalhar sobre isso.
473 @item
474 Se quaisquer substituições tiveem sido indicadas pelos argumentos, elas serão
475 realizadas agora.
477 @item
478 A expressão resultante é então reavaliada (a menos que um dos
479 argumentos seja @code{noeval}) e simplificada conforme os argumentos. Note que
480 qualquer chamada de função em @var{expr} será completada depois das variáveis
481 nela serem avalidas e que @code{ev(F(x))} dessa forma possa comportar-se como @code{F(ev(x))}.
483 @item
484 Para cada instância de @code{eval} nos argumentos, os passos (3) e (4) são repetidos.
485 @end enumerate
487 Exemplos
489 @example
490 (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
491 d 2
492 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1)
493 dw
494 (%i2) ev (%, sin, expand, diff, x=2, y=1);
495 2
496 (%o2) cos(w) + w + 2 w + cos(1) + 1.909297426825682
497 @end example
499 Uma sintaxe alternativa de alto nível tem sido provida por @code{ev}, por meio da qual
500 se pode apenas digitar seus argumentos, sem o @code{ev()}. Isto é, se pode
501 escrever simplesmente
503 @example
504 @var{expr}, @var{arg_1}, ..., @var{arg_n}
505 @end example
507 Isso não é permitido como parte de
508 outra expressão, e.g., em funções, blocos, etc.
510 Observe o processo de associação paralela no seguinte exemplo.
512 @example
513 (%i3) programmode: false;
514 (%o3) false
515 (%i4) x+y, x: a+y, y: 2;
516 (%o4) y + a + 2
517 (%i5) 2*x - 3*y = 3$
518 (%i6) -3*x + 2*y = -4$
519 (%i7) solve ([%o5, %o6]);
520 Solution
522 1
523 (%t7) y = - -
524 5
526 6
527 (%t8) x = -
528 5
529 (%o8) [[%t7, %t8]]
530 (%i8) %o6, %o8;
531 (%o8) - 4 = - 4
532 (%i9) x + 1/x > gamma (1/2);
533 1
534 (%o9) x + - > sqrt(%pi)
535 x
536 (%i10) %, numer, x=1/2;
537 (%o10) 2.5 > 1.772453850905516
538 (%i11) %, pred;
539 (%o11) true
540 @end example
542 @end deffn
544 @defvr {Propriedade} evflag
545 Quando um símbolo @var{x} tem a propriedade @code{evflag},
546 as expressões @code{ev(@var{expr}, @var{x})} e @code{@var{expr}, @var{x}}
547 (na linha de comando interativa) são equivalentes a @code{ev(@var{expr}, @var{x} = true)}.
548 Isto é, @var{x} está associada a @code{true} enquanto @var{expr} for avaliada.
550 A expressão @code{declare(@var{x}, evflag)}
551 fornece a propriedade @code{evflag} para a variável @var{x}.
553 Os sinalizadores que possuem a propriedade @code{evflag} por padrão são os seguintes:
554 @c FOLLOWING LIST CONSTRUCTED FROM LIST UNDER (prog1 '(evflag properties) ...)
555 @c NEAR LINE 2649 OF mlisp.lisp AT PRESENT (2004/11).
556 @code{algebraic},
557 @code{cauchysum},
558 @code{demoivre},
559 @code{dotscrules},
560 @code{%emode},
561 @code{%enumer},
562 @code{exponentialize},
563 @code{exptisolate},
564 @code{factorflag},
565 @code{float},
566 @code{halfangles},
567 @code{infeval},
568 @code{isolate_wrt_times},
569 @code{keepfloat},
570 @code{letrat},
571 @code{listarith},
572 @code{logabs},
573 @code{logarc},
574 @code{logexpand},
575 @code{lognegint},
576 @code{lognumer},
577 @code{m1pbranch},
578 @code{numer_pbranch},
579 @code{programmode},
580 @code{radexpand},
581 @code{ratalgdenom},
582 @code{ratfac},
583 @code{ratmx},
584 @code{ratsimpexpons},
585 @code{simp},
586 @code{simpsum},
587 @code{sumexpand}, e
588 @code{trigexpand}.
590 Exemplos:
592 @c ===beg===
593 @c sin (1/2);
594 @c sin (1/2), float;
595 @c sin (1/2), float=true;
596 @c simp : false;
597 @c 1 + 1;
598 @c 1 + 1, simp;
599 @c simp : true;
600 @c sum (1/k^2, k, 1, inf);
601 @c sum (1/k^2, k, 1, inf), simpsum;
602 @c declare (aa, evflag);
603 @c if aa = true then YES else NO;
604 @c if aa = true then YES else NO, aa;
605 @c ===end===
606 @example
607 (%i1) sin (1/2);
608 1
609 (%o1) sin(-)
610 2
611 (%i2) sin (1/2), float;
612 (%o2) 0.479425538604203
613 (%i3) sin (1/2), float=true;
614 (%o3) 0.479425538604203
615 (%i4) simp : false;
616 (%o4) false
617 (%i5) 1 + 1;
618 (%o5) 1 + 1
619 (%i6) 1 + 1, simp;
620 (%o6) 2
621 (%i7) simp : true;
622 (%o7) true
623 (%i8) sum (1/k^2, k, 1, inf);
624 inf
625 ====
626 \ 1
627 (%o8) > --
628 / 2
629 ==== k
630 k = 1
631 (%i9) sum (1/k^2, k, 1, inf), simpsum;
632 2
633 %pi
634 (%o9) ----
635 6
636 (%i10) declare (aa, evflag);
637 (%o10) done
638 (%i11) if aa = true then SIM else NÃO;
639 (%o11) NÃO
640 (%i12) if aa = true then SIM else NÃO, aa;
641 (%o12) SIM
642 @end example
644 @end defvr
646 @defvr {Propriedade} evfun
647 Quando uma função @var{F} tem a propriedade @code{evfun},
648 as expressões @code{ev(@var{expr}, @var{F})} e @code{@var{expr}, @var{F}}
649 (na linha de comando interativa)
650 são equivalentes a @code{@var{F}(ev(@var{expr}))}.
652 Se duas ou mais funções @var{F}, @var{G}, etc., que possuem a propriedade @code{evfun} forem especificadas,
653 as funções serão aplicadas na ordem em que forem especificadas.
655 A expressão @code{declare(@var{F}, evfun)}
656 fornece a propriedade @code{evfun} para a função @var{F}.
658 As funções que possuem a propriedade @code{evfun} por padrão são as seguintes:
659 @c FOLLOWING LIST CONSTRUCTED FROM LIST UNDER (prog1 '(evfun properties) ...)
660 @c NEAR LINE 2643 IN mlisp.lisp AT PRESENT (2004/11).
661 @code{bfloat},
662 @code{factor},
663 @code{fullratsimp},
664 @code{logcontract},
665 @code{polarform},
666 @code{radcan},
667 @code{ratexpand},
668 @code{ratsimp},
669 @code{rectform},
670 @code{rootscontract},
671 @code{trigexpand}, e
672 @code{trigreduce}.
674 Exemplos:
676 @c ===beg===
677 @c x^3 - 1;
678 @c x^3 - 1, factor;
679 @c factor (x^3 - 1);
680 @c cos(4 * x) / sin(x)^4;
681 @c cos(4 * x) / sin(x)^4, trigexpand;
682 @c cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
683 @c ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
684 @c declare ([F, G], evfun);
685 @c (aa : bb, bb : cc, cc : dd);
686 @c aa;
687 @c aa, F;
688 @c F (aa);
689 @c F (ev (aa));
690 @c aa, F, G;
691 @c G (F (ev (aa)));
692 @c ===end===
693 @example
694 (%i1) x^3 - 1;
695 3
696 (%o1) x - 1
697 (%i2) x^3 - 1, factor;
698 2
699 (%o2) (x - 1) (x + x + 1)
700 (%i3) factor (x^3 - 1);
701 2
702 (%o3) (x - 1) (x + x + 1)
703 (%i4) cos(4 * x) / sin(x)^4;
704 cos(4 x)
705 (%o4) --------
706 4
707 sin (x)
708 (%i5) cos(4 * x) / sin(x)^4, trigexpand;
709 4 2 2 4
710 sin (x) - 6 cos (x) sin (x) + cos (x)
711 (%o5) -------------------------------------
712 4
713 sin (x)
714 (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
715 2 4
716 6 cos (x) cos (x)
717 (%o6) - --------- + ------- + 1
718 2 4
719 sin (x) sin (x)
720 (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
721 2 4
722 6 cos (x) cos (x)
723 (%o7) - --------- + ------- + 1
724 2 4
725 sin (x) sin (x)
726 (%i8) declare ([F, G], evfun);
727 (%o8) done
728 (%i9) (aa : bb, bb : cc, cc : dd);
729 (%o9) dd
730 (%i10) aa;
731 (%o10) bb
732 (%i11) aa, F;
733 (%o11) F(cc)
734 (%i12) F (aa);
735 (%o12) F(bb)
736 (%i13) F (ev (aa));
737 (%o13) F(cc)
738 (%i14) aa, F, G;
739 (%o14) G(F(cc))
740 (%i15) G (F (ev (aa)));
741 (%o15) G(F(cc))
742 @end example
744 @end defvr
746 @c NEEDS WORK
747 @defvr {Variável de opção} infeval
748 Habilita o modo "avaliação infinita". @code{ev} repetidamente avalia
749 uma expressão até que ela permaneça invariante. Para prevenir uma
750 variável, digamos @code{X}, seja demoradamente avaliada nesso modo, simplesmente
751 inclua @code{X='X} como um argumento para @code{ev}. Certamente expressões tais como
752 @code{ev (X, X=X+1, infeval)} irão gerar um ciclo infinito.
754 @end defvr
756 @c REVIEW FOR ACCURACY AND COMPLETENESS
757 @c THIS ITEM IS VERY IMPORTANT !!
758 @c NEEDS EXAMPLES
759 @deffn {Função} kill (@var{a_1}, ..., @var{a_n})
760 @deffnx {Função} kill (labels)
761 @deffnx {Função} kill (inlabels, outlabels, linelabels)
762 @deffnx {Função} kill (@var{n})
763 @deffnx {Função} kill ([@var{m}, @var{n}])
764 @deffnx {Função} kill (values, functions, arrays, ...)
765 @deffnx {Função} kill (all)
766 @deffnx {Função} kill (allbut (@var{a_1}, ..., @var{a_n}))
768 Remove todas as associações (valor, funções, array, ou regra) dos argumentos
769 @var{a_1}, ..., @var{a_n}.
770 Um argumento @var{a_k} pode ser um símbolo ou um elemento de array simples.
771 Quando @var{a_k} for um elemento de array simples, @code{kill} remove a associação daquele elemento
772 sem afetar qualquer outro elemento do array.
774 Muitos argumentos especiais são reconhecidos.
775 Diferentes famílias de argumentos
776 podem ser combinadas, e.g., @code{kill (inlabels, functions, allbut (foo, bar))}
778 todos os rótulos de entrada, de saída, e de expressões intermediárias criados até então.
779 @code{kill (inlabels)} libera somente rótudos de entrada
780 que começam com o valor corrente de @code{inchar}.
781 De forma semelhante,
782 @code{kill (outlabels)} libera somente rótulos de saída
783 que começam com o valor corrente de @code{outchar},
784 e @code{kill (linelabels)} libera somente rótulos de expressões intermediárias
785 que começam com o valor corrente de @code{linechar}.
787 @code{kill (@var{n})}, onde @var{n} é um inteiro,
788 libera os @var{n} mais recentes rótulos de entrada e saída.
790 @code{kill ([@var{m}, @var{n}])} libera rótulos de entrada e saída de @var{m} até @var{n}.
792 @code{kill (@var{infolist})}, onde @var{infolist} é um item em @code{infolists}
793 (tais como @code{values}, @code{functions}, ou @code{arrays})
794 libera todos os ítens em @var{infolist}.
795 Veja também @code{infolists}.
797 @code{kill (all)} liberar todos os ítens em todas as infolists.
798 @code{kill (all)} não retorna variáveis globais para seus valores padrões;
799 Veja @code{reset} sobre esse ponto.
801 @code{kill (allbut (@var{a_1}, ..., @var{a_n}))}
802 remove a associação de todos os itens sobre todas as infolistas exceto para @var{a_1}, ..., @var{a_n}.
803 @code{kill (allbut (@var{infolist}))} libera todos os ítens exceto para si próprio em @var{infolist},
804 onde @var{infolist} é @code{values}, @code{functions}, @code{arrays}, etc.
806 A memória usada por uma propriedade de associação não será liberada até que todos os símbolos
807 sejam liberados disso.
808 Em particular, para liberar a memória usada pelo valor de um símbolo,
809 deve-se liberar o rótulo de saída que mosta o valor associado, bem como liberando o próprio símbolo.
811 @code{kill} coloca um apóstro em seus argumentos (não os avalia).
812 O operador apóstrofo-apóstrofo, @code{'@w{}'}, faz com que ocorra avaliação.
814 @code{kill (@var{símbolo})} libera todas as propriedades de @var{símbolo}.
815 Em oposição, @code{remvalue}, @code{remfunction}, @code{remarray}, e @code{remrule}
816 liberam uma propriedade específica.
818 @code{kill} sempre retorna @code{done}, igualmente se um argumento não tem associações.
820 @end deffn
822 @deffn {Função} labels (@var{símbolo})
823 @deffnx {Variável de sistema} labels
824 Retorna a lista de rótulos de entradas, de saída, de expressões intermediárias que começam com @var{símbolo}.
825 Tipicamente @var{símbolo} é o valor de @code{inchar}, @code{outchar}, ou @code{linechar}.
826 O caracter rótulo pode ser dado com ou sem o sinal de porcentagem,
827 então, por exemplo, @code{i} e @code{%i} retornam o mesmo resultado.
829 Se nenhum rótulo começa com @var{símbolo}, @code{labels} retorna uma lista vazia.
831 A função @code{labels} não avalia seu argumento.
832 O operador apóstrofo-apóstrofo @code{'@w{}'} faz com que ocorra avaliação.
833 Por exemplo,
834 @code{labels (''inchar)} retorna os rótulos de entrada que começam com o caractere corrente do rótulo de entrada.
836 A variável @code{labels} é uma lista de rótulos de entrada, saída, e de expressões intermediárias,
837 incluindo todos os rótulos anteriores se @code{inchar}, @code{outchar}, ou @code{linechar} que tiverem sido redefinidos.
839 Por padrão, Maxima mostra o resultado de cada expressão de entrada do usuário,
840 dando ao resultado um rótulo de saída.
841 A exibição da saída é suprimida pelo encerramento da entrada com @code{$} (sinal de dolar)
842 em lugar de @code{;} (ponto e vírgula).
843 Um rótulo de saída é construido e associado ao resultado, mas não é mostrado,
844 e o rótulo pode ser referenciado da mesma forma que rótulos de saída mostrados.
845 Veja também @code{%}, @code{%%}, e @code{%th}.
847 Rótulos de expressões intermediárias podem ser gerados por algumas funções.
848 O sinalizador @code{programmode} controla se @code{solve} e algumas outras funções
849 geram rótulos de expressões intermediárias em lugar de retornar uma lista de expressões.
850 Algumas outras funções, tais como @code{ldisplay}, sempre geram rótulos de expressões intermediárias.
852 Veja também @code{inchar}, @code{outchar}, @code{linechar}, e @code{infolists}.
854 @end deffn
856 @c EXPAND; SHOW WHAT HAPPENS WHEN linenum IS ASSIGNED A VALUE
857 @defvr {Variável de sistema} linenum
858 Retorna o número da linha do par corrente de expressões de entrada e saída.
860 @end defvr
862 @c NEEDS WORK
863 @defvr {Variável de sistema} myoptions
864 Valor padrão: @code{[]}
866 @code{myoptions} é a lista de todas as opções alguma vez alteradas pelo usuário,
867 tenha ou não ele retornado a alteração para o seu valor padrão.
869 @end defvr
871 @defvr {Variável de opção} nolabels
872 Valor padrão: @code{false}
874 @c PREVIOUS DESCRIPTION OF nolabels: THIS IS OUT OF DATE
875 @c When @code{nolabels} is @code{true}, then no labels will be bound
876 @c except for intermediate expressão lines generated by the solve functions. This is most
877 @c useful in the batch mode where it eliminates the need to do
878 @c @code{kill (labels)} in order to free up storage.
880 Quando @code{nolabels} for @code{true},
881 rótulos de entrada e saída
882 (@code{%i} e @code{%o}, respectivamente)
883 são mostrados,
884 mas os rótulos não são associados aos resultados,
885 e os rótulos não são anexados ao final da lista @code{labels}.
886 Uma vez que rótulos não são associados aos resultados,
887 a reciclagem pode recuperar a memória tomada pelos resultados.
889 De outra forma rótulos de entrada e saída são associados aos resultados,
890 e os rótulos são anexados ao final da lista @code{labels}.
892 Veja também @code{batch}, @code{batchload}, e @code{labels}.
894 @end defvr
896 @c NEEDS WORK
897 @defvr {Variável de opção} optionset
898 Valor padrão: @code{false}
900 Quando @code{optionset} for @code{true}, Maxima mostrará uma
901 mensagem sempre que uma opção do Maxima for alterada. Isso é útil se o
902 usuário está incerto sobre a ortografia de alguma opção e quer ter certeza
903 que a variável por ele atribuído um valor foi realmente uma variável de opção.
905 @end defvr
907 @deffn {Função} playback ()
908 @deffnx {Função} playback (@var{n})
909 @deffnx {Função} playback ([@var{m}, @var{n}])
910 @deffnx {Função} playback ([@var{m}])
911 @deffnx {Função} playback (input)
912 @deffnx {Função} playback (slow)
913 @deffnx {Função} playback (time)
914 @deffnx {Função} playback (grind)
915 Mostra expressões de entrada, de saída, e expressões intermediárias,
916 sem refazer os cálculos.
917 @code{playback} somente mostra as expressões associadas a rótulos;
918 qualquer outra saída (tais como textos impressos por @code{print} ou @code{describe}, ou messagens de erro)
919 não é mostrada.
920 Veja também @code{labels}.
922 @code{playback} não avalia seus argumentos.
923 O operador apóstrofo-apóstrofo, @code{'@w{}'}, sobrepõe-se às aspas.
924 @code{playback} sempre retorna @code{done}.
926 @code{playback ()} (sem argumentos) mostra todas as entradas, saídas e expressões intermediárias
927 geradas até então.
928 Uma expressão de saída é mostrada mesmo se for suprimida pelo terminador @code{$}
929 quando ela tiver sido originalmente calculada.
931 @code{playback (@var{n})} mostra as mais recentes @var{n} expressões.
932 Cada entrada, saída e expressão intermediária
933 conta como um.
935 @code{playback ([@var{m}, @var{n}])} mostra entradas, saídas e expressões intermediárias
936 com os números de @var{m} até @var{n}, inclusive.
938 @code{playback ([@var{m}])} é equivalente a @code{playback ([@var{m}, @var{m}])};
939 isso usualmente imprime um par de expressões de entrada e saída.
941 @code{playback (input)} mostra todas as expressões de entrada geradas até então.
943 @code{playback (slow)} insere pausas entre expressões
944 e espera que o usuário pressione @code{enter}.
945 Esse comportamento é similar a @code{demo}.
946 @c WHAT DOES THE FOLLOWING MEAN ???
947 @code{playback (slow)} é útil juntamente com @code{save} ou @code{stringout}
948 quando criamos um arquivo secundário de armazenagem com a finalidade de capturar expressões úteis.
950 @code{playback (time)} mostra o tempo de computação de cada expressão.
951 @c DON'T BOTHER TO MENTION OBSOLETE OPTIONS !!!
952 @c The arguments @code{gctime} e @code{totaltime} have the same effect as @code{time}.
954 @code{playback (grind)} mostra expressões de entrada
955 no mesmo formato da função @code{grind}.
956 Expressões de saída não são afetadas pela opção @code{grind}.
957 Veja @code{grind}.
959 Argumentos podem ser combinados, e.g.,
960 @code{playback ([5, 10], grind, time, slow)}.
961 @c APPEARS TO BE input INTERSECT (UNION OF ALL OTHER ARGUMENTS). CORRECT ???
963 @end deffn
965 @c NEEDS WORK ESPECIALLY EXAMPLES
966 @c WHOLE BUSINESS WITH PROPERTIES IS PRETTY CONFUSING, TRY TO CLEAR IT UP
967 @deffn {Função} printprops (@var{a}, @var{i})
968 @deffnx {Função} printprops ([@var{a_1}, ..., @var{a_n}], @var{i})
969 @deffnx {Função} printprops (all, @var{i})
970 Mostra a propriedade como o indicador @var{i}
971 associada com o átomo @var{a}. @var{a} pode também ser uma lista de átomos ou o átomo
972 @code{all} nesse caso todos os átomos com a propriedade dada serão
973 usados. Por exemplo, @code{printprops ([f, g], atvalue)}. @code{printprops} é para
974 propriedades que não podem ser mostradas de outra forma, i.e. para
975 @code{atvalue}, @code{atomgrad}, @code{gradef}, e @code{matchdeclare}.
977 @end deffn
979 @defvr {Variável de opção} prompt
980 Valor padrão: @code{_}
982 @code{prompt} é o símbolo de linha de comando da função @code{demo},
983 modo @code{playback (slow)}, e da interrupção de ciclos do Maxima (como invocado por @code{break}).
985 @end defvr
987 @deffn {Função} quit ()
988 Encerra a sessão do Maxima.
989 Note que a função pode ser invocada como @code{quit();} ou @code{quit()$},
990 não por sí mesma @code{quit}.
992 Para parar um cálculo muito longo,
993 digite @code{control-C}.
994 A ação padrão é retornar à linha de comando do Maxima.
995 Se @code{*debugger-hook*} é @code{nil},
996 @code{control-C} abre o depurador Lisp.
997 Veja também @code{debugging}.
999 @end deffn
1001 @deffn {Função} remfunction (@var{f_1}, ..., @var{f_n})
1002 @deffnx {Função} remfunction (all)
1003 Desassocia as definições de função dos síbolos @var{f_1}, ..., @var{f_n}.
1004 Os argumentos podem ser os nomes de funções comuns (criadas por meio de @code{:=} ou @code{define})
1005 ou funções macro (criadas por meio de @code{::=}).
1007 @code{remfunction (all)} desassocia todas as definições de funcção.
1009 @code{remfunction} coloca um ap'ostrofo em seus argumentos (não os avalia).
1011 @code{remfunction} retorna uma lista de símbolos para a qual a definição de função foi desassociada.
1012 @code{false} é retornado em lugar de qualquer símbolo para o qual não exista definição de função.
1014 @end deffn
1016 @deffn {Função} reset ()
1017 Retorna muitas variáveis globais e opções, e algumas outras variáveis, para seus valores padrões.
1019 @code{reset} processa as variáveis na lista Lisp @code{*variable-initial-values*}.
1020 A macro Lisp @code{defmvar} coloca variáveis nessa lista (entre outras ações).
1021 Muitas, mas não todas, variáveis globais e opções são definidas por @code{defmvar},
1022 e algumas variáveis definidas por @code{defmvar} não são variáveis globais ou variáveis de opção.
1024 @end deffn
1026 @defvr {Variável de opção} showtime
1027 Valor padrão: @code{false}
1029 Quando @code{showtime} for @code{true}, o tempo de computação e o tempo decorrido são
1030 impressos na tela com cada expressão de saída.
1032 O tempo de cálculo é sempre gravado,
1033 então @code{time} e @code{playback} podem mostrar o tempo de cálculo
1034 mesmo quando @code{showtime} for @code{false}.
1036 Veja também @code{timer}.
1038 @end defvr
1040 @c IS THIS ANY DIFFERENT FROM ASSIGNING A PROPERTY ??
1041 @c THIS REALLY SEEMS LIKE A HACK
1042 @deffn {Função} sstatus (@var{recurso}, @var{pacote})
1043 Altera o status de @var{recurso} em @var{pacote}.
1044 Após @code{sstatus (@var{recurso}, @var{pacote})} ser executado,
1045 @code{status (@var{recurso}, @var{pacote})} retorna @code{true}.
1046 Isso pode ser útil para quem escreve pacotes, para
1047 manter um registro de quais recursos os pacotes usam.
1049 @end deffn
1051 @c NEEDS EXPANSION, EXAMPLES
1052 @deffn {Função} to_lisp ()
1053 Insere o sistema Lisp dentro do Maxima. @code{(to-maxima)} retorna para o Maxima.
1055 @end deffn
1057 @defvr {Variável de sistema} values
1058 Valor inicial: @code{[]}
1060 @code{values} é uma lista de todas as varáveis de usuário associadas (não opções Maxima ou comutadores).
1061 A lista compreende símbolos associados por @code{:} , @code{::}, ou @code{:=}.
1063 @end defvr