1
This is maxima.info, produced by makeinfo version 4.7 from maxima.texi.
3
Esse é um Manual do Maxima no formato Texinfo
5
Copyright 1994,2001 William F. Schelter
8
* Maxima: (maxima). Um sistema de álgebra computacional.
12
File: maxima.info, Node: Definições para Entrada e Saída, Prev: Arquivos, Up: Entrada e Saída
14
9.4 Definições para Entrada e Saída de Dados
15
============================================
17
-- Variável de sistema: __
18
`__' é a expressão de entrada atualmente sendo avaliada. Isto é,
19
enquanto um expressão de entrada <expr> está sendo avaliada, `__'
22
`__' é atribuída à expressão de entrada antes de a entrada ser
23
simplificada ou avaliada. Todavia, o valor de `__' é simplificado
24
(mas não avaliado) quando for mostrado.
26
`__' é reconhecido por `batch' e `load'. Em um arquivo processado
27
por `batch', `__' tem o mesmo significado que na linha de comando
28
interativa. Em um arquivo processado por `load', `__' está
29
associado à expressão de entrada mais recentemente informada no
30
prompt interativo ou em um arquivo de lote (batch); `__' não é
31
associado à expressões de entrada no arquivo que está sendo
32
processado. Em particular, quando `load (<nomedearquivo>)' for
33
chamado a partir da linha de comando interativa, `__' é associado
34
a `load (<filename>)' enquanto o arquivo está sendo processado.
36
Veja também `_' e `%'.
40
(%i1) print ("Eu fui chamada como", __);
41
Eu fui chamada como print(Eu fui chamada como, __)
42
(%o1) print(Eu fui chamada como, __)
45
(%i3) g (x) := (print ("Expressão atual de entrada =", __), 0);
46
(%o3) g(x) := (print("Expressão atual de entrada =", __), 0)
47
(%i4) [aa : 1, bb : 2, cc : 3];
49
(%i5) (aa + bb + cc)/(dd + ee + g(x));
51
Expressão atual de entrada = --------------
58
-- Variável de sistema: _
59
`_' é a mais recente expressão de entrada (e.g., `%i1', `%i2',
62
A `_' é atribuída à expressão de entrada antes dela ser
63
simplificada ou avaliada. Todavia, o valor de `_' é simplificado
64
(mas não avaliado) quando for mostrado.
66
`_' é reconhecido por `batch' e `load'. Em um arquivo processado
67
por `batch', `_' tem o mesmo significado que na linha de comando
68
interativa. Em um arquivo processado por load `load', `_' está
69
associado à expressão de entrada mais recentemente avaliada na
70
linha de comando interativa ou em um arquivo de lote; `_' não está
71
associada a expressões de entrada no arquivo que está sendo
74
Veja também `__' e `%'.
87
((%SIN) ((MQUOTIENT) $%PI 2))
104
-- Variável de sistema: %
105
`%' é a expressão de saída (e.g., `%o1', `%o2', `%o3', ...) mais
106
recentemente calculada pelo Maxima, pode ou não ser mostrada.
108
`%' é reconhecida por `batch' e `load'. Em um arquivo processado
109
por `batch', `%' tem o mesmo significado que na linha de comando
110
interativa. Em um arquivo processado por `load', `%' é associado
111
à expressão de entrada mais recentemente calculada na linha de
112
comando interativa ou em um arquivo de lote; `%' não está
113
associada a expressões de saída no arquivo que está sendo
116
Veja também `_', `%%', e `%th'
119
-- Variável de sistema: %%
120
Em declaração composta, a saber `block', `lambda', ou `(<s_1>,
121
..., <s_n>)', `%%' é os valor da declaração anterior. Por exemplo,
123
block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
124
block ([prev], prev: integrate (x^5, x), ev (prev, x=2) - ev (prev, x=1));
126
retornam o mesmo resultado, a saber `21/2'.
128
Uma declaração composta pode compreender outras declarações
129
compostas. Pode uma declaração ser simples ou composta, `%%' é o
130
valor da declaração anterior. Por exemplo,
132
block (block (a^n, %%*42), %%/6)
136
Dentro da declaração composta, o valor de `%%' pode ser
137
inspecionado em uma parada de linha de comando, que é aberta pela
138
execução da função `break'. Por exemplo, na parada de linha de
141
block (a: 42, break ())$
143
digitando `%%;' retorna `42'.
145
Na primeira declaração em uma declaração composta, ou fora de uma
146
declaração composta, `%%' é indefinido.
148
`%%' reconhecido por `batch' e `load', e possem o mesmo
149
significao que na linha de comando interativa.
154
-- Variável de opção: %edispflag
155
Valor padrão: `false'
157
Quando `%edispflag' é `true', Maxima mostra `%e' para um expoente
158
negativo como um quociente. Por exemplo, `%e^-x' é mostrado como
163
O valor da <i>'ésima expressão prévia de saída. Isto é, se a
164
próxima expressão a ser calculada for a <n>'ésima saída, `%th
165
(<m>)' será a (<n> - <m>)'ésima saída.
167
`%th' é útil em arquivos `batch' ou para referir-se a um grupo de
168
expressões de saída. Por exemplo,
170
block (s: 0, for i:1 thru 10 do s: s + %th (i))$
172
escolhe `s' para a soma das últimas dez expressões de saída.
174
`%th' é reconhecido por `batch' e `load'. Em um arquivo
175
processado por `batch', `%th' possue o mesmo significado que na
176
linha de comando interativa. Em um arquivo processado por `load',
177
`%th' refere-se a expressões de saída mais recentemente calculadas
178
na linha de comando interativa ou em um arquivo de lote; `%th' não
179
se refere a expressões de saída no arquivo que está sendo
185
-- Símbolo especial: ?
186
Como prefixo para uma função ou nome de variável, `?' significa que
187
o nome é um nome Lisp, não um nome Maxima. Por exemplo, `?round'
188
significa a função Lisp `ROUND'. Veja *Note Lisp e Maxima:: para
189
mais sobre esse ponto.
191
A notação `? word' (um ponto de interrogação seguido de uma
192
palavra e separado desta por um espaço em branco) é equivalente a
196
-- Variável de opção: absboxchar
199
`absboxchar' é o caracter usado para para desenhar o sinal de valor
200
absoluto em torno de expressões que são maiores que uma linha de
204
-- Variável de opção: file_output_append
205
Valor padrão: `false'
207
`file_output_append' governa se funções de saída de arquivo anexam
208
ao final ou truncam seu arquivo de saída. Quando
209
`file_output_append' for `true', tais funções anexam ao final de
210
seu arquivo de saída. De outra forma, o arquivo de saída é
213
`save', `stringout', e `with_stdout' respeitam
214
`file_output_append'. Outras funções que escrevem arquivos de
215
saída não respeitam `file_output_append'. Em partivular, montagem
216
de gráficos e traduções de funções sempre truncam seu arquivo de
217
saída, e `tex' e `appendfile' sempre anexam ao final.
220
-- Função: appendfile (<filename>)
221
Adiciona ao final de <filename> uma transcrição do console.
222
`appendfile' é o mesmo que `writefile', exceto que o arquivo
223
transcrito, se já existe, terá sempre alguma coisa adicionada ao
226
`closefile' fecha o arquivo transcrito que foi aberto
227
anteriormente por `appendfile' ou por `writefile'.
230
-- Função: batch (<filename>)
231
Lê expressões Maxima do arquivo <filename> e as avalia. `batch'
232
procura pelo arquivo <filename> na lista `file_search_maxima'.
235
<filename> compreende uma seqüência de expressões Maxima, cada uma
236
terminada com `;' ou `$'. A varável especial `%' e a função `%th'
237
referem-se a resultados prévios dentro do arquivo. O arquivo pode
238
incluir construções `:lisp'. Espaços, tabulações, e o caracter de
239
nova linha no arquivo serão ignorados. um arquivo de entrada
240
conveniente pode ser criado por um editor de texto ou pela função
243
`batch' lê cada expressão de entrada de <filename>, mostra a
244
entrada para o console, calcula a correspondente expressão de
245
saída, e mostra a expressão de saída. Rótulos de entrada são
246
atribuídos para expressões de entrada e rótulos de saída são
247
atribuídos para expressões de saída. `batch' avalia toda
248
expressão de entrada no arquivo a menos que exista um erro. Se
249
uma entrada de usuário for requisitada (by `asksign' ou
250
`askinteger', por exemplo) `batch' interrompe para coletar a
251
entrada requisitada e então continua.
253
Isso possibilita interromper `batch' pela digitação de `control-C'
254
no console. O efeito de `control-C' depende da subjacente
255
implementação do Lisp.
257
`batch' tem muitos usos, tais como fornecer um reservatório para
258
trabalhar linhas de comando, para fornecer demonstrações livres de
259
erros, ou para ajudar a organizar alguma coisa na solução de
262
`batch' avalia seu argumento. `batch' não possui valor de retorno.
264
Veja também `load', `batchload', e `demo'.
267
-- Função: batchload (<filename>)
268
Lê expressões Maxima de <filename> e as avalia, sem mostrar a
269
entrada ou expressões de saída e sem atribuir rótulos para
270
expressões de saída. Saídas impressas (tais como produzidas por
271
`print' ou `describe') são mostradas, todavia.
273
A variável especial `%' e a função `%th' referem-se a resultados
274
anteriores do interpretador interativo, não a resultados dentro do
275
arquivo. O arquivo não pode incluir construções `:lisp'.
277
`batchload' retorna o caminho de <filename>, como uma seqüência de
278
caracteres. `batchload' avalia seu argumento.
280
Veja também `batch' e `load'.
283
-- Função: closefile ()
284
Fecha o arquivo transcrito aberto por `writefile' ou `appendfile'.
287
-- Função: collapse (<expr>)
288
Reduz <expr> fazendo com que todas as suas subexpressões comuns
289
(i.e., iguais) serem compartilhadas (i.e., usam a mesma células),
290
dessa forma exonomizando espaço. (`collapse' é uma subrotina
291
usada pelo comando `optimize'.) Dessa forma, chamar `collapse'
292
pode ser útil após um `save' arquivo. Você pode diminuir muitas
293
expressões juntas pelo uso de `collapse ([<expr_1>, ...,
294
<expr_n>])'. Similarmente, você pode diminuir os elementos de um
295
array `A' fazendo `collapse (listarray ('A))'.
298
-- Função: concat (<arg_1>, <arg_2>, ...)
299
Concatena seus argumentos. Os argumentos devem obrigatóriamente
300
serem avaliados para atomos. O valor de retorno é um símbolo se o
301
primeiro argumento for um símbolo e uma seqüência de caracteres no
302
formato do Maxima em caso contrário.
304
`concat' avalia seus argumentos. O apóstrofo `'' evita avaliação.
308
(%i3) concat (y, z/2);
310
(%i4) concat ('y, z/2);
313
Um símbolo construído por `concat' pode ser atribuído a um valor e
314
aparecer em expressões. O operador de atribuição `::' (duplo dois
315
pontos) avalia seu lado esquerdo.
317
(%i5) a: concat ('y, z/2);
330
Note que embora `concat (1, 2)' seja visto como um números, isso é
331
uma seqüência de caracteres no formato do Maxima.
333
(%i10) concat (1, 2) + 3;
337
-- Função: sconcat (<arg_1>, <arg_2>, ...)
338
Concatena seus argumentos em uma seqüência de caracteres. Ao
339
contrário de `concat', os argumentos arrumados não precisam ser
342
O resultado é uma seqüência de caracteres no format do Lisp.
344
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
345
(%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
348
-- Função: disp (<expr_1>, <expr_2>, ...)
349
é como `display' mas somente os valores dos argumentos são
350
mostrados em lugar de equações. Isso é útil para argumentos
351
complicados que não possuem nomes ou onde somente o valor do
352
argumento é de interesse e não o nome.
355
-- Função: dispcon (<tensor_1>, <tensor_2>, ...)
356
-- Função: dispcon (all)
357
Mostram as propriedades de contração de seus argumentos como foram
358
dados para `defcon'. `dispcon (all)' mostra todas as propriedades
359
de contração que foram definidas.
362
-- Função: display (<expr_1>, <expr_2>, ...)
363
Mostra equações cujo lado esquerdo é <expr_i> não avaliado, e cujo
364
lado direito é o valor da expressão centrada na linha. Essa
365
função é útil em blocos e em `for' declarações com o objetivo de
366
ter resultados intermediários mostrados. The Os argumentos para
367
`display' são usualmente átomos, variáveis subscritas, ou chamadas
368
de função. Veja também `disp'.
370
(%i1) display(B[1,2]);
377
-- Variável de opção: display2d
380
Quando `display2d' é `false', O console visualizador é
381
unidimensional ao invés de bidimensional.
384
-- Variável de opção: display_format_internal
385
Valor padrão: `false'
387
Quando `display_format_internal' é `true', expressões são
388
mostradas sem ser por caminhos que escondam a representação
389
matemática interna. O visualizador então corresponde ao que
390
`inpart' retorna em lugar de `part'.
395
a-b; A - B A + (- 1) B
408
-- Função: dispterms (<expr>)
409
Mostra <expr> em partes uma abaixo da outra. Isto é, primeiro o
410
operador de <expr> é mostrado, então cada parcela em uma adição,
411
ou fatores em um produto, ou parte de uma expressão mais geral é
412
mostrado separadamente. Isso é útil se <expr> é muito larga para
413
ser mostrada de outra forma. Por exemplo se `P1', `P2', ... são
414
expressões muito largas então o programa visualizador pode sair
415
fora do espaço de armazenamento na tentativa de mostrar `P1 + P2 +
416
...' tudo de uma vez. Todavia, `dispterms (P1 + P2 + ...)'
417
mostra `P1', então abaixo disso `P2', etc. Quando não usando
418
`dispterms', se uma expressão exponencial é muito alta para ser
419
mostrada como `A^B' isso aparece como `expt (A, B)' (ou como
420
`ncexpt (A, B)' no caso de `A^^B').
423
-- Variável de opção: error_size
426
`error_size' modifica mensagens de erro conforme o tamanho das
427
expressões que aparecem nelas. Se o tamanho de uma expressão
428
(como determinado pela função Lisp `ERROR-SIZE') é maior que
429
`error_size', a expressão é substituída na mensagem por um símbolo,
430
e o o símbolo é atribuído à expressão. Os símbolos são obtidos da
433
De outra forma, a expressão é menor que `error_size', e a
434
expressão é mostrada na mensagem.
436
Veja também `error' e `error_syms'.
440
O tamanho de `U', como determinado por `ERROR-SIZE', é 24.
442
(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$
444
(%i2) error_size: 20$
446
(%i3) error ("Expressão exemplo é", U);
448
Expressão exemplo é errexp1
449
-- an error. Quitting. To debug this try debugmode(true);
456
(%i5) error_size: 30$
458
(%i6) error ("Expressão exemplo é", U);
463
Expressão exemplo é --------------
465
-- an error. Quitting. To debug this try debugmode(true);
468
-- Variável de opção: error_syms
469
Valor padrão: `[errexp1, errexp2, errexp3]'
471
Em mensagens de erro, expressões mais largas que `error_size' são
472
substituídas por símbolos, e os símbolos são escolhidos para as
473
expressões. Os símbolos são obtidos da lista `error_syms'. A
474
primeira expressão muito larga é substituída por `error_syms[1]',
475
a segunda por `error_syms[2]', e assim por diante.
477
Se houverem mais expressões muito largas que há elementos em
478
`error_syms', símbolos são construídos automaticamente, com o
479
<n>-ésimo símbolo equivalente a `concat ('errexp, <n>)'.
481
Veja também `error' e `error_size'.
484
-- Função: expt (<a>, <b>)
485
Se uma expressão exponencial é muito alta para ser mostrada cmo
486
`<a>^<b>' isso aparece como `expt (<a>, <b>)' (ou como `ncexpt
487
(<a>, <b>)' no caso de `<a>^^<b>').
489
`expt' e `ncexpt' não são reconhecidas em entradas.
492
-- Variável de opção: exptdispflag
495
Quando `exptdispflag' é `true', Maxima mostra expressões com
496
expoente negativo usando quocientes, e.g., `X^(-1)' como `1/X'.
499
-- Função: filename_merge (<path>, <filename>)
500
Constroem um caminho modificado de <path> e <filename>. Se o
501
componente final de <path> é da forma `###.<algumacoisa>', o
502
componente é substituído com `<filename>.<algumacoisa>'. De outra
503
forma, o componente final é simplesmente substituído por
507
-- Função: file_search (<filename>)
508
-- Função: file_search (<filename>, <pathlist>)
509
`file_search' procura pelo arquivo <filename> e retorna o caminho
510
para o arquivo (como uma seqüência de caracteres) se ele for
511
achado; de outra forma `file_search' retorna `false'.
512
`file_search (<filename>)' procura nos diretórios padrões de busca,
513
que são especificados pelas variáveis `file_search_maxima',
514
`file_search_lisp', e `file_search_demo'.
516
`file_search' primeiro verifica se o nome atual passado existe,
517
antes de tentar coincidir esse nome atual com o modelo "coringa"
518
de busca do arquivo. Veja `file_search_maxima' concernente a
519
modelos de busca de arquivos.
521
O argumento <filename> pode ser um caminho e nome de arquivo, ou
522
apenas um nome de arquivo, ou, se um diretório de busca de arquivo
523
inclui um modelo de busca de arquivo, apenas a base do nome de
524
arquivo (sem uma extensão). Por exemplo,
526
file_search ("/home/wfs/special/zeta.mac");
527
file_search ("zeta.mac");
528
file_search ("zeta");
530
todos acham o mesmo arquivo, assumindo que o arquivo exista e
531
`/home/wfs/special/###.mac' está em `file_search_maxima'.
533
`file_search (<filename>, <pathlist>)' procura somente nesses
534
diretórios especificados por <pathlist>, que é uma lista de
535
seqüências de caracteres. O argumento <pathlist> substitui os
536
diretórios de busca padrão, então se a lista do caminho é dada,
537
`file_search' procura somente nesses especificados, e não qualquer
538
dos diretórios padrão de busca. Mesmo se existe somente um
539
diretório em <pathlist>, esse deve ainda ser dado como uma lista
540
de um único elemento.
542
O usuário pode modificar o diretório de busca padrão. Veja
543
`file_search_maxima'.
545
`file_search' é invocado por `load' com `file_search_maxima' e
546
`file_search_lisp' como diretórios de busca.
549
-- Variável de opção: file_search_maxima
550
-- Variável de opção: file_search_lisp
551
-- Variável de opção: file_search_demo
552
Essas variáveis especificam listas de diretórios a serem procurados
553
por `load', `demo', e algumas outras funções do Maxima. O valor
554
padrão dessas variáveis nomeia vários diretórios na instalaçã
557
O usuáro pode modificar essas variáveis, quer substituindo os
558
valores padrão ou colocando no final diretórios adicionais. Por
561
file_search_maxima: ["/usr/local/foo/###.mac",
562
"/usr/local/bar/###.mac"]$
564
substitui o valor padrão de `file_search_maxima', enquanto
566
file_search_maxima: append (file_search_maxima,
567
["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
569
adiciona no final da lista dois diretórios adicionais. Isso pode
570
ser conveniente para colocar assim uma expressão no arquivo
571
`maxima-init.mac' de forma que o caminho de busca de arquivo é
572
atribuído automaticamente quando o Maxima inicia.
574
Multiplas extensões de arquivo e e multiplos caminhos podem ser
575
especificados por construções "coringa" especiais. A seqüência de
576
caracteres `###' expande a busca para além do nome básico,
577
enquanto uma lista separada por vírgulas e entre chaves
578
`{foo,bar,baz}' expande em multiplas seqüências de caracteres.
579
Por exemplo, supondo que o nome básico a ser procurado seja
582
"/home/{wfs,gcj}/###.{lisp,mac}"
584
expande em `/home/wfs/neumann.lisp', `/home/gcj/neumann.lisp',
585
`/home/wfs/neumann.mac', e `/home/gcj/neumann.mac'.
588
-- Função: file_type (<filename>)
589
Retorna uma suposta informação sobre o conteúdo de <filename>,
590
baseada na extensão do arquivo. <filename> não precisa referir-se
591
a um arquivo atual; nenhuma tentativa é feita para abrir o arquivo
592
e inspecionar seu conteúdo.
594
O valor de retorno é um símbolo, qualquer um entre `object',
595
`lisp', ou `maxima'. Se a extensão começa com `m' ou `d',
596
`file_type' retorna `maxima'. Se a extensão começa om `l',
597
`file_type' retorna `lisp'. Se nenhum dos acima, `file_type'
601
-- Função: grind (<expr>)
602
-- Variável de opção: grind
603
A função `grind' imprime <expr> para o console em uma forma
604
adequada de entrada para Maxima. `grind' sempre retorna `done'.
606
Quando <expr> for um nome de uma função ou o nome de uma macro,
607
`grind' mostra na tela a definição da função ou da macro em lugar
610
Veja também `string', que retorna uma seqüência de caracteres em
611
lugar de imprimir sua saída. `grind' tenta imprimir a expressão
612
de uma maneira que a faz levemente mais fácil para ler que a saída
615
Quando a variável `grind' é `true', a saída de `string' e
616
`stringout' tem o mesmo formato que `grind'; de outra forma
617
nenhuma tentativa é feita para formatar especialmente a saída
618
dessas funções. O valor padrão da variável `grind' é `false'.
620
`grind' pode também ser especificado como um argumento de
621
`playback'. Quando `grind' está presente, `playback' imprime
622
expressões de entrada no mesmo formato que a função `grind'. De
623
outra forma, nenhuma tentativa é feita para formatar especialmente
624
as expressões de entrada. `grind' avalia seus argumentos.
633
(%i3) [aa, 1729, aa + 1729];
634
(%o3) [aa, 1729, aa + 1729]
638
(%i5) matrix ([aa, 17], [29, bb]);
643
matrix([aa,17],[29,bb])$
645
(%i7) set (aa, 17, 29, bb);
646
(%o7) {17, 29, aa, bb}
650
(%i9) exp (aa / (bb + 17)^29);
659
(%i11) expr: expand ((aa + bb)^10);
661
(%o11) bb + 10 aa bb + 45 aa bb + 120 aa bb + 210 aa bb
663
+ 252 aa bb + 210 aa bb + 120 aa bb + 45 aa bb
667
bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
668
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
671
(%i13) string (expr);
672
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
673
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
675
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
676
p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do
677
(x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then
678
p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i],
679
for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
680
(%i15) grind (cholesky);
682
[n:length(A),L:copymatrix(A),
683
p:makelist(0,i,1,length(A))],
685
(for j from i thru n do
686
(x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
687
if i = j then p[i]:1/sqrt(x)
688
else L[j,i]:x*p[i])),
689
for i thru n do L[i,i]:1/p[i],
690
for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
692
(%i16) string (fundef (cholesky));
693
(%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
694
t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
695
[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
696
) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
697
n do (for j from i+1 thru n do L[i,j]:0),L)
700
-- Variável de opção: ibase
703
Inteiros fornecidos dentro do Maxima são interpretados com
704
respeito à base `ibase'.
706
A `ibase' pode ser atribuído qualquer inteiro entre 2 e 35
707
(decimal), inclusive. Quando `ibase' é maior que 10, os numerais
708
compreendem aos numerais decimais de 0 até 9 mais as letras
709
maiúsculas do alfabeto A, B, C, ..., como necessário. Os numerais
710
para a base 35, a maior base aceitável, compreendem de 0 até 9 e
716
-- Variável de opção: inchar
719
`inchar' é o prefixo dos rótulos de expressões fornecidas pelo
720
usuário. Maxima automaticamente constrói um rótulo para cada
721
expressão de entrada por concatenação de `inchar' e `linenum'. A
722
`inchar' pode ser atribuído qualquer seqüência de caracteres ou
723
símbolo, não necessariamente um caracter simples.
725
(%i1) inchar: "input";
727
(input1) expand ((a+b)^3);
729
(%o1) b + 3 a b + 3 a b + a
732
Veja também `labels'.
735
-- Função: ldisp (<expr_1>, ..., <expr_n>)
736
Mostra expressões <expr_1>, ..., <expr_n> para o console como
737
saída impressa na tela. `ldisp' atribue um rótulo de expressão
738
intermediária a cada argumento e retorna a lista de rótulos.
747
(%o2) b + 3 a b + 3 a b + a
753
(%t4) b + 3 a b + 3 a b + a
761
(%o5) b + 3 a b + 3 a b + a
764
-- Função: ldisplay (<expr_1>, ..., <expr_n>)
765
Mostra expressões <expr_1>, ..., <expr_n> para o console como
766
saída impressa na tela. Cada expressão é impressa como uma
767
equação da forma `lhs = rhs' na qual `lhs' é um dos argumentos de
768
`ldisplay' e `rhs' é seu valor. Tipicamente cada argumento é uma
769
variável. `ldisp' atribui um rótulo de expressão intermediáia a
770
cada equação e retorna a lista de rótulos.
772
Veja também `display'.
779
(%o2) b + 3 a b + 3 a b + a
780
(%i3) ldisplay (e, f);
785
(%t4) f = b + 3 a b + 3 a b + a
793
(%o5) f = b + 3 a b + 3 a b + a
796
-- Variável de opção: linechar
799
`linechar' é o refixo de rótulos de expressões intermediárias
800
gerados pelo Maxima. Maxima constrói um rótulo para cada
801
expressão intermediária (se for mostrada) pela concatenação de
802
`linechar' e `linenum'. A `linechar' pode ser atribuído qualquer
803
seqüência de caracteres ou símbolo, não necessáriamente um
806
Expressões intermediárias podem ou não serem mostradas. See
807
`programmode' e `labels'.
810
-- Variável de opção: linel
813
`linel' é a largura assumida (em caracteres) do console para o
814
propósito de mostrar expressões. A `linel' pode ser atribuído
815
qualquer valor pelo usuário, embora valores muio pequenos ou muito
816
grandes possam ser impraticáveis. Textos impressos por funções
817
internas do Maxima, tais como mensagens de erro e a saída de
818
`describe', não são afetadas por `linel'.
821
-- Variável de opção: lispdisp
822
Valor padrão: `false'
824
Quando `lispdisp' for `true', símbolos Lisp são mostrados com um
825
ponto de interrogação `?' na frente. De outra forma, símbolos
826
Lisp serão mostrados sem o ponto de interrogaçõ na frente.
830
(%i1) lispdisp: false$
833
(%i3) lispdisp: true$
838
-- Função: load (<nomedearquivo>)
839
Avalia expressões em <nomedearquivo>, dessa forma conduzindo
840
variáveis, funções, e outros objetos dentro do Maxima. A
841
associação de qualquer objeto existente é substituída pela
842
associação recuperada de <nomedearquivo>. Para achar o arquivo,
843
`load' chama `file_search' com `file_search_maxima' e
844
`file_search_lisp' como diretórios de busca. Se `load' obtém
845
sucesso, isso retorna o nome do arquivo. De outra forma `load'
846
imprime uma mensagem e erro.
848
`load' trabalha igualmente bem para códigos Lisp e códigos Maxima.
849
Arquivos criados por `save', `translate_file', e `compile_file',
850
que criam códigos Lisp, e `stringout', que criam códigos Maxima,
851
podem ser processadas por `load'. `load' chama `loadfile' para
852
carregar arquivos Lisp e `batchload' para carregar arquivos Maxima.
854
`load' não reconhece construções `:lisp' em arquivos do Maxima, e
855
quando processando <nomedearquivo>, as variáveis globais `_',
856
`__', `%', e `%th' possuem as mesmas associações que possuiam
857
quando `load' foi chamada.
859
Veja também `loadfile', `batch', `batchload', e `demo'.
860
`loadfile' processa arquivos Lisp; `batch', `batchload', e `demo'
861
processam arquivos Maxima.
863
Veja `file_search' para mais detalhes sobre o mecanismo de busca
866
`load' avalia seu argumento.
869
-- Função: loadfile (<nomedearquivo>)
870
Avalia expressões Lisp em <nomedearquivo>. `loadfile' não invoca
871
`file_search', então `nomedearquivo' deve obrigatóriamente incluir
872
a extensão do arquivo e tanto quanto o caminho como necessário
873
para achar o arquivo.
875
`loadfile' pode processar arquivos criados por `save',
876
`translate_file', e `compile_file'. O usuário pode achar isso
877
mais conveniente para usar `load' em lugar de `loadfile'.
879
`loadfile' avalia seu argumento, então `nomedearquivo' deve
880
obrigatóriamente ser uma seqüência de caracteres literal, não uma
881
variável do tipo seqüência de caracteres. O operador
882
apóstrofo-apóstrofo `''' não aceita avaliação.
885
-- Variável de opção: loadprint
888
`loadprint' diz se deve imprimir uma mensagem quando um arquivo é
891
* Quando `loadprint' é `true', sempre imprime uma mensagem.
893
* Quando `loadprint' é `'loadfile', imprime uma mensagem
894
somente se um arquivo é chamado pela função `loadfile'.
896
* Quando `loadprint' é `'autoload', imprime uma mensagem
897
somente se um arquivo é automaticamente carregado. Veja
900
* Quando `loadprint' é `false', nunca imprime uma mensagem.
903
-- Variável de opção: obase
906
`obase' é a base para inteiros mostrados pelo Maxima.
908
A `obase' poode ser atribuído qualquer inteiro entre 2 e 35
909
(decimal), inclusive. Quando `obase' é maior que 10, os numerais
910
compreendem os numerais decimais de 0 até 9 e letras maiúsulas do
911
alfabeto A, B, C, ..., quando necessário. Os numerais para a base
912
35, a maior base aceitável, compreendem de 0 até 9, e de A até Y.
917
-- Variável de opção: outchar
920
`outchar' é o prefixo dos rótulos de expressões calculadas pelo
921
Maxima. Maxima automaticamente constrói um rótulo para cada
922
expressão calculada pela concatenação de `outchar' e `linenum'. A
923
`outchar' pode ser atribuído qualquer seqüência de caracteres ou
924
símbolo, não necessáriamente um caractere simples.
926
(%i1) outchar: "output";
928
(%i2) expand ((a+b)^3);
930
(output2) b + 3 a b + 3 a b + a
933
Veja também `labels'.
936
-- Variável de opção: packagefile
937
Valor padrão: `false'
939
Projetistas de pacotes que usam `save' ou `translate' para criar
940
pacotes (arquivos) para outros usarem podem querer escolher
941
`packagefile: true' para prevenir qu informações sejam
942
acrescentadas à lista de informações do Maxima (e.g. `values',
943
`funções') exceto onde necessário quando o arquivo é carregado.
944
Nesse caminho, o conteúdo do pacote não pegará no caminho do
945
usuário quando ele adicionar seus próprios dados. Note que isso
946
não resolve o problema de possíveis conflitos de nome. Também
947
note que o sinalizador simplesmente afeta o que é saída para o
948
arquivo pacote. Escolhendo o sinalizador para `true' é também
949
útil para criar arquivos de init do Maxima.
952
-- Variável de opção: pfeformat
953
Valor padrão: `false'
955
Quando `pfeformat' é `true', uma razão de inteiros é mostrada com
956
o caractere sólido (barra normal), e um denominador inteiro `n' é
957
mostrado como um termo multiplicativo em primeiro lugar `1/n'.
959
(%i1) pfeformat: false$
968
(%i4) pfeformat: true$
975
-- Função: print (<expr_1>, ..., <expr_n>)
976
Avalia e mostra <expr_1>, ..., <expr_n> uma após a outra, da
977
esquerda para a direita, iniciando no lado esquerdo do console.
979
O valor retornado por `print' é o valor de seu último argumento.
980
`print' não gera rótulos de expressão intermediária.
982
Veja também `display', `disp', `ldisplay', e `ldisp'. Essas
983
funções mostram uma expressão por linha, enquanto `print' tenta
984
mostrar duas ou mais expressões por linha.
986
Para mostrar o conteúdo de um arquivo, veja `printfile'.
988
(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
990
(a+b)^3 is b + 3 a b + 3 a b + a log (a^10/b) is
994
(%o2) 10 log(a) - log(b)
995
(%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
999
b + 3 a b + 3 a b + a
1006
-- Função: tcl_output (<list>, <i0>, <skip>)
1007
-- Função: tcl_output (<list>, <i0>)
1008
-- Função: tcl_output ([<list_1>, ..., <list_n>], <i>)
1009
Imprime os elementos de uma lista entre chaves `{ }', conveniente
1010
como parte de um programa na linguagem Tcl/Tk.
1012
`tcl_output (<list>, <i0>, <skip>)' imprime <list>, começando com
1013
o elemento <i0> e imprimindo elementos `<i0> + <skip>', `<i0> + 2
1016
`tcl_output (<list>, <i0>)' é equivalente a `tcl_output (<list>,
1019
`tcl_output ([<list_1>, ..., <list_n>], <i>)' imprime os
1020
<i>'ésimos elementos de <list_1>, ..., <list_n>.
1024
(%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$
1026
{1.000000000 4.000000000
1028
(%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$
1030
{2.000000000 5.000000000
1032
(%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$
1034
{((RAT SIMP) 3 7) ((RAT SIMP) 11 13)
1036
(%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$
1040
(%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$
1042
{SIMP 1.000000000 11.00000000
1046
-- Função: read (<expr_1>, ..., <expr_n>)
1047
Imprime <expr_1>, ..., <expr_n>, então lê uma expressão do console
1048
e retorna a expressão avaliada. A expressão é terminada com um
1049
ponto e vírgula `;' ou o sinal de dólar `$'.
1051
Veja também `readonly'.
1054
(%i2) foo: read ("foo is", foo, " -- enter new value.")$
1055
foo is 42 -- enter new value.
1062
-- Função: readonly (<expr_1>, ..., <expr_n>)
1063
Imprime <expr_1>, ..., <expr_n>, então lê uma expressão do console
1064
e retorna a expressão (sem avaliação). A expressão é terminada
1065
com um `;' (ponto e vírgula) ou `$' (sinal de dólar).
1068
(%i2) foo: readonly ("Forneça uma expressão:");
1073
(%i3) foo: read ("Forneça uma expressão:");
1081
-- Função: reveal (<expr>, <depth>)
1082
Substitue partes de <expr> no inteiro especificado <depth> com
1085
* Somas e diferenças são substituídas por `sum(<n>)' onde <n> é
1086
o número de operandos do produto.
1088
* Produtos são substituídos por `product(<n>)' onde <n> é o
1089
número de operandos da multiplicação.
1091
* Exponenciais são substituídos por `expt'.
1093
* Quocientes são substituídos por `quotient'.
1095
* Negação unária é substituída por `negterm'.
1097
Quando <depth> é maior que ou igual à máxima intensidade de <expr>,
1098
`reveal (<expr>, <depth>)' retornam <expr> sem modificações.
1100
`reveal' avalia seus argumentos. `reveal' retorna expressão
1105
(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1108
(%o1) -------------------------
1111
(%i2) reveal (e, 1);
1113
(%i3) reveal (e, 2);
1117
(%i4) reveal (e, 3);
1118
expt + negterm + expt
1119
(%o4) ------------------------
1120
product(2) + expt + expt
1121
(%i5) reveal (e, 4);
1124
(%o5) ------------------------------------
1125
product(2) product(2)
1127
(%i6) reveal (e, 5);
1130
(%o6) --------------------------
1133
(%i7) reveal (e, 6);
1136
(%o7) -------------------------
1141
-- Variável de opção: rmxchar
1144
`rmxchar' é the caractere desenhado lado direito de uma matriz.
1146
Veja também `lmxchar'.
1149
-- Função: save (<filename>, <name_1>, <name_2>, <name_3>, ...)
1150
-- Função: save (<filename>, values, functions, labels, ...)
1151
-- Função: save (<filename>, [<m>, <n>])
1152
-- Função: save (<filename>, <name_1>=<expr_1>, ...)
1153
-- Função: save (<filename>, all)
1154
Armazena os valores correntes de <name_1>, <name_2>, <name_3>,
1155
..., em <filename>. Os argumentos são os nomes das variáveis,
1156
funções, ou outros objetos. Se um nome não possui valore ou
1157
função associada a ele, esse nome sem nenhum valor ou função
1158
associado será ignorado. `save' retorna <filename>.
1160
`save' armazena dados na forma de expressões Lisp. Os dados
1161
armazenados por `save' podem ser recuperados por `load
1164
O sinalizador global `file_output_append' governa se `save' anexa
1165
ao final ou trunca o arquivo de saída. Quando
1166
`file_output_append' for `true', `save' anexa ao final doarquivo
1167
de saída. De outra forma, `save' trunca o arquivo de saída.
1168
Nesse caso, `save' cria o arquivo se ele não existir ainda.
1170
A forma especial `save (<filename>, values, functions, labels,
1171
...)' armazena os ítens nomeados por `values', `funções',
1172
`labels', etc. Os nomes podem ser quaisquer especificados pela
1173
variável `infolists'. `values' compreende todas as variáveis
1174
definidas pelo usuário.
1176
A forma especial `save (<filename>, [<m>, <n>])' armazena os
1177
valores de rótulos de entrada e saída de <m> até <n>. Note que
1178
<m> e <n> devem obrigatóriamente ser inteiros literais. Rótulos
1179
de entrada e saída podem também ser armazenados um a um, e.g.,
1180
`save ("foo.1", %i42, %o42)'. `save (<filename>, labels)'
1181
armazena todos os rótulos de entrada e saída. Quando rótulos
1182
armazenados são recuperados, eles substituem rótulos existentes.
1184
A forma especial `save (<filename>, <name_1>=<expr_1>,
1185
<name_2>=<expr_2>, ...)' armazena os valores de <expr_1>,
1186
<expr_2>, ..., com nomes <name_1>, <name_2>, .... Isso é útil
1187
para aplicar essa forma para rótulos de entrada e saída, e.g.,
1188
`save ("foo.1", aa=%o88)'. O lado direito dessa igualdade nessa
1189
forma pode ser qualquer expressão, que é avaliada. Essa forma não
1190
introduz os novos nomes no ambiente corrente do Maxima, mas
1191
somente armazena-os em <filename>.
1193
Essa forma especial e a forma geral de `save' podem ser misturados.
1194
Por exemplo, `save (<filename>, aa, bb, cc=42, funções, [11, 17])'.
1196
A forma especial `save (<filename>, all)' armazena o estado
1197
corrente do Maxima. Isso inclui todas as variáveis definidas pelo
1198
usuário, funções, arrays, etc., bem como alguns ítens definidos
1199
automaticamente. Os ítes salvos incluem variáveis de sistema,
1200
tais como `file_search_maxima' ou `showtime', se a elas tiverem
1201
sido atribuídos novos valores pelo usuário; veja `myoptions'.
1203
`save' avalia seus argumentos. <filename> deve obrigatóriamente
1204
ser uma seqüência de caracteres, não uma variável tipo seqüência
1205
de caracteres. O primeiro e o último rótulos a salvar, se
1206
especificado, devem obrigatóriamente serem inteiros. O operador
1207
apóstrofo-apóstrofo `''' avalia uma variável tipo seqüência de
1208
caracteres para seu valor seqüência de caracteres, e.g., `s:
1209
"foo.1"$ save (''s, all)$', e variáveis inteiras para seus valores
1210
inteiros, e.g., `m: 5$ n: 12$ save ("foo.1", [''m, ''n])$'.
1213
-- Variável de opção: savedef
1214
Valor padrão: `true'
1216
Quando `savedef' é `true', a vesão Maxima de uma função de usuário
1217
é preservada quando a função é traduzida. Isso permite que a
1218
definição seja mostrada por `dispfun' e autoriza a função a ser
1221
Quando `savedef' é `false', os nomes de funções traduzidas são
1222
removidos da lista de `funções'.
1225
-- Função: show (<expr>)
1226
Mostra `expr' com os objetos indexados tendo índices covariantes
1227
como subscritos, índices contravariantes como sobrescritos. Os
1228
índices derivativos são mostrados como subscritos, separados dos
1229
índices covariantes por uma vírgula.
1232
-- Função: showratvars (<expr>)
1233
Retorna uma lista de variáveis expressão racional canônica (CRE)
1234
na expressão `expr'.
1236
Veja também `ratvars'.
1239
-- Variável de opção: stardisp
1240
Valor padrão: `false'
1242
Quando `stardisp' é `true', multiplicação é mostrada com um
1243
asterisco `*' entre os operandos.
1246
-- Função: string (<expr>)
1247
Converte `expr' para a notação linear do Maxima apenas como se
1248
tivesse sido digitada.
1250
O valor de retorno de `string' é uma seqüência de caracteres, e
1251
dessa forma não pode ser usada em um cálculo.
1254
-- Variável Lisp: stringdisp
1255
Valor padrão: `false'
1257
Quando `?stringdisp' for `true', seqüências de caracteres serão
1258
mostradas contidas em aspas duplas. De outra forma, aspas não são
1261
`?stringdisp' é sempre `true' quando mostrando uma definição de
1264
`?stringdisp' é uma variável Lisp, então deve ser escrita com um
1265
ponto de interrogação `?' na frente.
1269
(%i1) ?stringdisp: false$
1270
(%i2) "This is an example string.";
1271
(%o2) This is an example string.
1272
(%i3) foo () := print ("This is a string in a function definition.");
1274
print("This is a string in a function definition.")
1275
(%i4) ?stringdisp: true$
1276
(%i5) "This is an example string.";
1277
(%o5) "This is an example string."
1280
-- Função: stringout (<filename>, <expr_1>, <expr_2>, <expr_3>, ...)
1281
-- Função: stringout (<filename>, [<m>, <n>])
1282
-- Função: stringout (<filename>, input)
1283
-- Função: stringout (<filename>, functions)
1284
-- Função: stringout (<filename>, values)
1285
`stringout' escreve expressões para um arquivo na mesma forma de
1286
expressões que foram digitadas para entrada. O arquivo pode então
1287
ser usado como entrada para comandos `batch' ou `demo', e isso
1288
pode ser editado para qualquer propósito. `stringout' pode ser
1289
executado enquanto `writefile' está em progresso.
1291
O sinalizador global `file_output_append' governa se `stringout'
1292
anexa ao final ou trunca o arquivo de saída. Quando
1293
`file_output_append' for `true', `stringout' anexa ao final do
1294
arquivo de sad'a. De outra forma, `stringout' trunca o arquivo de
1295
saída. Nesse caso, `stringout' cria o arquivo de saída se ele não
1298
A forma geral de `stringout' escreve os valores de um ou mais
1299
expressões para o arquivo de saída. Note que se uma expressão é
1300
uma variável, somente o valor da variável é escrito e não o nome
1301
da variável. Como um útil caso especial, as expressões podem ser
1302
rótulos de entrada (`%i1', `%i2', `%i3', ...) ou rótulos de saída
1303
(`%o1', `%o2', `%o3', ...).
1305
Se `grind' é `true', `stringout' formata a saída usando o formato
1306
`grind'. De outra forma o formato `string' é usado. Veja `grind'
1309
A forma especial `stringout (<filename>, [<m>, <n>])' escreve os
1310
valores dos rótulos de entrada de m até n, inclusive.
1312
A forma especial `stringout (<filename>, input)' escreve todos os
1313
rótulos de entrada para o arquivo.
1315
A forma especial `stringout (<filename>, functions)' escreve todas
1316
as funções definidas pelo usuário (nomeadas pela lista global
1317
`functions') para o arquivo.
1319
A forma especial `stringout (<filename>, values)' escreve todas as
1320
variáveis atribuídas pelo usuário (nomeadas pela lista global
1321
`values') para o arquivo. Cada variável é impressa como uma
1322
declaração de atribuição, com o nome da variável seguida de dois
1323
pontos, e seu valor. Note que a forma geral de `stringout' não
1324
imprime variáveis como declarações de atribuição.
1327
-- Função: tex (<expr>)
1328
-- Função: tex (<rótulo>)
1329
-- Função: tex (<expr>, <momearquivo>)
1330
-- Função: tex (<label>, <nomearquivo>)
1331
Imprime uma representação de uma expressão adequada para o sistema
1332
TeX de preparação de documento. O resultado é um fragmento de um
1333
documento, que pode ser copiado dentro de um documento maior.
1334
Esse fragmento não pode ser processado de forma direta e isolada.
1336
`tex (<expr>)' imprime uma representação TeX da <expr> no console.
1338
`tex (<rótulo>)' imprime uma representação TeX de uma expressão
1339
chamada <rótulo> e atribui a essa um rótulo de equação (a ser
1340
mostrado à esquerda da expressão). O rótulo de equação TeX é o
1341
mesmo que o rótulo da equação no Maxima.
1343
`tex (<expr>, <nomearquivo>)' anexa ao final uma representação TeX
1344
de <expr> no arquivo <nomearquivo>. `tex' não avalia o argumento
1345
<nomearquivo>; apóstrofo-apóstrofo `''' força a avaliação so
1348
`tex (<rótulo>, <nomearquivo>)' anexa ao final uma representação
1349
TeX da expressão chamada de <rótulo>, com um rótulo de equação, ao
1350
arquivo <nomearquivo>.
1352
`tex' não avalia o argumento <nomearquivo>; apóstrofo-apóstrofo
1353
`''' força a avaliação so argumento. `tex' avalia seus argumentos
1354
após testar esse argumento para ver se é um rótulo. duplo
1355
apóstrofo `''' força a avaliação do argumento, desse modo
1356
frustrando o teste e prevenindo o rótulo.
1358
Veja também `texput'.
1362
(%i1) integrate (1/(1+x^3), x);
1365
log(x - x + 1) sqrt(3) log(x + 1)
1366
(%o1) - --------------- + ------------- + ----------
1369
$$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
1370
}\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
1371
}\over{3}}\leqno{\tt (\%o1)}$$
1373
(%i3) tex (integrate (sin(x), x));
1376
(%i4) tex (%o1, "foo.tex");
1380
-- Função: texput (<a>, <s>)
1381
-- Função: texput (<a>, <s>, <operator_type>)
1382
-- Função: texput (<a>, [<s_1>, <s_2>], matchfix)
1383
-- Função: texput (<a>, [<s_1>, <s_2>, <s_3>], matchfix)
1384
Escolhe a saída TeX para o átomo <a>, que pode ser um símbolo ou o
1385
nome de um operador.
1387
`texput (<a>, <s>)' faz com que a função `tex' interpole a
1388
seqüência de caracteres <s> dentro da saída TeX em lugar de <a>.
1390
`texput (<a>, <s>, <operator_type>)', onde <operator_type> é
1391
`prefix', `infix', ou `postfix' faz com que a função `tex'
1392
interpole <s> dentro da saída TeX em lugar de <a>, e coloca o
1393
texto interpolado na posição apropriada.
1395
`texput (<a>, [<s_1>, <s_2>], matchfix)' faz com que a função
1396
`tex' interpole <s_1> e <s_2> dentro da saída TeX sobre qualquer
1397
lado dos argumentos de <a>. Os argumentos (se mais de um) são
1398
separados por vírgulas.
1400
`texput (<a>, [<s_1>, <s_2>, <s_3>], matchfix)' faz com que a
1401
função `tex' interpole <s_1> e <s_2> dentro da saída TeX sobre
1402
qualquer lado dos argumentos de <a>, com <s_3> separando os
1407
(%i1) texput (me,"\\mu_e");
1412
(%i3) texput (lcm, "\\mathrm{lcm}");
1414
(%i4) tex (lcm (a, b));
1415
$$\mathrm{lcm}\left(a , b\right)$$
1417
(%i5) prefix ("grad");
1419
(%i6) texput ("grad", " \\nabla ", prefix);
1426
(%i9) texput ("~", " \\times ", infix);
1431
(%i11) postfix ("@");
1433
(%i12) texput ("@", "!!", postfix);
1438
(%i14) matchfix ("<<", ">>");
1440
(%i15) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
1441
(%o15) \langle ( \rangle , false)
1443
$$ \langle a \rangle $$
1445
(%i17) tex (<<a, b>>);
1446
$$ \langle a , b \rangle $$
1448
(%i18) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], matchfix);
1449
(%o18) \langle ( \rangle , \, | \,)
1451
$$ \langle a \rangle $$
1453
(%i20) tex (<<a, b>>);
1454
$$ \langle a \, | \,b \rangle $$
1458
-- Função: system (<comando>)
1459
Executa <comando> como um processo separado. O comando é passado
1460
ao shell padraõ para execução. `system' não é suportado por todos
1461
os sistemas operacionais, mas geralmente existe em ambientes Unix
1464
Supondo que `_hist.out' é uma lista de freqüência que você deseja
1465
imprimir como um gráfico em barras usando `xgraph'.
1467
(%i1) (with_stdout("_hist.out",
1468
for i:1 thru length(hist) do (
1470
system("xgraph -bar -brw .7 -nl < _hist.out"));
1472
Com o objetivo de fazer com que a impressão do gráfico seja
1473
concluída em segundo plano (retornando o controle para o Maxima) e
1474
remover o arquivo temporário após isso ter sido concluído faça:
1476
system("(xgraph -bar -brw .7 -nl < _hist.out; rm -f _hist.out)&")
1479
-- Variável de opção: ttyoff
1480
Valor padrão: `false'
1482
Quando `ttyoff' é `true', expressões de saída não são mostradas.
1483
Expressões de saída são ainda calculadas e atribuídas rótulos.
1486
Textos impresso por funções internas do Maxima, tais como
1487
mensagens de erro e a saída de `describe', não são afetadas por
1491
-- Função: with_stdout (<filename>, <expr_1>, <expr_2>, <expr_3>, ...)
1492
Abre <filename> e então avalia <expr_1>, <expr_2>, <expr_3>, ....
1493
Os valores dos argumentos não são armazenados em <filename>, mas
1494
qualquer saída impressa gerada pela avaliação dos argumentos (de
1495
`print', `display', `disp', ou `grind', por exemplo) vai para
1496
<filename> em lugar do console.
1498
O sinalizador global `file_output_append' governa se `with_stdout'
1499
anexa ao final ou trunca o arquivo de saída. Quando
1500
`file_output_append' for `true', `with_stdout' anexa ao final do
1501
arquivo de saída. De outra forma, `with_stdout' trunca o arquivo
1502
de saída. Nesse caso, `with_stdout' cria o arquivo se ele não
1505
`with_stdout' retorna o valor do seu argumento final.
1507
Veja também `writefile'.
1509
(%i1) with_stdout ("tmp.out", for i:5 thru 10 do print (i, "! yields", i!))$
1510
(%i2) printfile ("tmp.out")$
1519
-- Função: writefile (<filename>)
1520
Começa escrevendo uma transcrição da sessão Maxima para <filename>.
1521
Toda interação entre o usuário e Maxima é então gravada nesse
1522
arquivo, da mesma forma que aparece no console.
1524
Como a transcrição é impressa no formato de saída do console, isso
1525
não pode ser reaproveitado pelo Maxima. Para fazer um arquivo
1526
contendo expressões que podem ser reaproveitadas, veja `save' e
1527
`stringout'. `save' armazena expressões no formato Lisp, enquanto
1528
`stringout' armazena expressões no formato Maxima.
1530
O efeito de executar `writefile' quando <filename> ainda existe
1531
depende da implementação Lisp subjacente; o arquivo transcrito
1532
pode ser substituído, ou o arquivo pode receber um anexo.
1533
`appendfile' sempre anexa para o arquivo transcrito.
1535
Isso pode ser conveniente para executar `playback' após
1536
`writefile' para salvar a visualização de interações prévias.
1537
Como `playback' mostra somente as variáveis de entrada e saída
1538
(`%i1', `%o1', etc.), qualquer saída gerada por uma declaração de
1539
impressão em uma função (como oposição a um valor de retorno) não
1540
é mostrada por `playback'.
1542
`closefile' fecha o arquivo transcrito aberto por `writefile' ou
1547
File: maxima.info, Node: Ponto Flutuante, Next: Contextos, Prev: Entrada e Saída, Up: Top
1554
* Definições para ponto Flutuante::
1557
File: maxima.info, Node: Definições para ponto Flutuante, Prev: Ponto Flutuante, Up: Ponto Flutuante
1559
10.1 Definições para ponto Flutuante
1560
====================================
1562
-- Função: bffac (<expr>, <n>)
1563
Versão para grandes números em ponto flutuante da função
1564
`factorial' (usa o artifício gamma). O segundo argumento informa
1565
quantos dígitos reter e retornar, isso é uma boa idéia para
1566
requisitar precisão adicional.
1568
`load ("bffac")' chama essa função.
1571
-- Variável de Opção: algepsilon
1574
`algepsilon' é usada por `algsys'.
1577
-- Função: bfloat (<expr>)
1578
Converte todos os números e funções de números em <expr> para
1579
grandes números em ponto flutuante (bigfloat). O número de
1580
algarismos significativos no grande número em ponto flutuante
1581
resultante é especificado através da variável global `fpprec'.
1583
Quando `float2bf' for `false' uma mensagem de alerta é mostrada
1584
quando uma número em ponto flutuante (float) é convertido em um
1585
grande número em ponto flutuante (bigfloat - uma vez que isso pode
1586
resultar em perda de precisão).
1589
-- Função: bfloatp (<expr>)
1590
Retorna `true' se a avaliação da <expr> resultar em um grande
1591
número em ponto flutuante, de outra forma retorna `false'.
1594
-- Função: bfpsi (<n>, <z>, <fpprec>)
1595
-- Função: bfpsi0 (<z>, <fpprec>)
1596
`bfpsi' é a função `polygamma' de argumentos reais <z> e ordem de
1597
inteiro <n>. `bfpsi0' é a função `digamma'. `bfpsi0 (<z>,
1598
<fpprec>)' é equivalente a `bfpsi (0, <z>, <fpprec>)'.
1600
Essas funções retornam valores em grandes números em ponto
1601
flutuante. <fpprec> é a precisão do valor de retorno dos grandes
1602
números em ponto flutuante.
1604
`load ("bffac")' chama essas funções.
1607
-- Variável de Opção: bftorat
1608
Valor padrão: `false'
1610
`bftorat' controla a conversão de `bfloats' para números racionais.
1611
Quando `bftorat' for `false', `ratepsilon' será usada para
1612
controlar a conversão (isso resulta em números racionais
1613
relativametne pequenos). Quando `bftorat' for `true', o número
1614
racional gerado irá representar precisamente o `bfloat'.
1617
-- Variável de Opção: bftrunc
1618
Valor padrão: `true'
1620
`bftrunc' faz com que tilhas de zeros em grandes números em ponto
1621
flutuante diferentes de zero sejam ocultadas. Desse modo, se
1622
`bftrunc' for `false', `bfloat (1)' será mostrado como
1623
`1.000000000000000B0'. De outra forma, será mostrado como `1.0B0'.
1626
-- Função: cbffac (<z>, <fpprec>)
1627
Fatorial complexo de grandes números em ponto flutuante.
1629
`load ("bffac")' chama essa função.
1632
-- Função: float (<expr>)
1633
Converte inteiros, números racionais e grandes números em ponto
1634
flutuante em <expr> para números em ponto flutuante. Da mesma
1635
forma um `evflag', `float' faz com que números racionais
1636
não-inteiros e grandes números em ponto flutuante sejam
1637
convertidos para ponto flutuante.
1640
-- Variável de Opção: float2bf
1641
Valor padrão: `false'
1643
Quando `float2bf' for `false', uma mensagem de alerta é mostrada
1644
quando um número em ponto flutuante é convertido em um grande
1645
número em ponto flutuante (uma vez que isso pode resultar em perda
1649
-- Função: floatnump (<expr>)
1650
Retorna `true' se <expr> for um número em ponto flutuante, de
1651
outra forma retorna `false'.
1654
-- Variável de Opção: fpprec
1657
`fpprec' é o número de algarismos significativos para aritmética
1658
sobre grandes números em ponto flutuante `fpprec' não afeta
1659
cálculos sobre números em ponto flutuante comuns.
1661
Veja também `bfloat' e `fpprintprec'.
1664
-- Variável de Opção: fpprintprec
1667
`fpprintprec' é o n;umero de dígitos a serem mostrados na tela
1668
quando no caso de nuúmeros em ponto flutuante e no caso de grandes
1669
números em ponto flutuante.
1671
Para números em ponto flutuante comuns, quando `fpprintprec' tiver
1672
um valor entre 2 e 16 (inclusive), o n;umero de dígitos mostrado
1673
na tela é igual a `fpprintprec'. De outra forma, `fpprintprec' é
1674
0, ou maior que 16, e o número de dígitos mostrados é 16.
1676
Para grandes números em ponto flutuante, quando `fpprintprec'
1677
tiver um valor entre 2 e `fpprec' (inclusive), o n;umero de
1678
dígitos mostrados é giaul a `fpprintprec'. De outra forma,
1679
`fpprintprec' é 0, ou maior que `fpprec', e o n;umero de dígitos
1680
mostrados é igual a `fpprec'.
1682
`fpprintprec' não pode ser 1.
1685
-- Função Lisp: ?round (<x>)
1686
-- Função Lisp: ?round (<x>, <divisor>)
1687
Arredonda o ponto flutuante <x> para o inteiro mais próximo. O
1688
argumento obrigatoriamente deve ser um ponto flutuante comum, não
1689
um grandes números em ponto flutuante. A `?' começando o nome
1690
indica que isso é uma função Lisp.
1692
(%i1) ?round (-2.8);
1696
-- Função Lisp: ?truncate (<x>)
1697
-- Função Lisp: ?truncate (<x>, <divisor>)
1698
Trunca o ponto flutuante <x> na direção do 0, para transormar-se
1699
em um inteiro. O argumento deve ser um número em ponto flutuante
1700
comum, não um grandes números em ponto flutuante. A `?'
1701
começando o nome indica que isso é uma função Lisp.
1703
(%i1) ?truncate (-2.8);
1705
(%i2) ?truncate (2.4);
1707
(%i3) ?truncate (2.8);
1712
File: maxima.info, Node: Contextos, Next: Polinômios, Prev: Ponto Flutuante, Up: Top
1719
* Definições para Contextos::
1722
File: maxima.info, Node: Definições para Contextos, Prev: Contextos, Up: Contextos
1724
11.1 Definições para Contextos
1725
==============================
1727
-- Função: activate (<context_1>, ..., <context_n>)
1728
Ativa os contextos <context_1>, ..., <context_n>. Os fatos nesses
1729
contextos estão então disponíveis para fazer deduções e recuperar
1730
informação. Os fatos nesses contextos não são listadas através de
1733
A variável `activecontexts' é a lista de contextos que estão
1734
ativos pelo caminho da função `activate'.
1737
-- Variável de sistema: activecontexts
1740
`activecontexts' é a lista de contextos que estão ativos pelo
1741
caminho da função `activate', em oposição a sendo ativo porque
1742
eles são subcontextos do contexto corrente.
1745
-- Função: assume (<pred_1>, ..., <pred_n>)
1746
Adiciona predicados <pred_1>, ..., <pred_n> ao contexto corrente.
1747
Se um predicado for incossistente ou redundante com os predicados
1748
no contexto corrente, esses predicados não são adicionados ao
1749
contexto. O contexto acumula predicados de cada chamada a
1752
`assume' retorna uma lista cujos elementos são os predicados
1753
adicionados ao contexto ou os átomos `redundant' ou `inconsistent'
1756
Os predicados <pred_1>, ..., <pred_n> podem somente ser expressões
1757
com os operadores relacionais `< <= equal notequal >=' e `>'.
1758
Predicados não podem ser expressões de igualdades literais `=' ou
1759
expressões de desigualdades literais `#', nem podem elas serem
1760
funções de predicado tais como `integerp'.
1762
Predicados combinados da forma `<pred_1> and ... and <pred_n>' são
1763
reconhecidos, mas não `<pred_1> or ... or <pred_n>'. `not
1764
<pred_k>' é reconhecidos se <pred_k> for um predicado relacional.
1765
Expressões da forma `not (<pred_1> and <pred_2>)' and `not
1766
(<pred_1> or <pred_2>)' não são reconhecidas.
1768
O mecanismo de dedução do Maxima não é muito forte; exitem
1769
conseqüências muito óbvias as quais não podem ser determinadas por
1770
meio de `is'. Isso é uma fraqueza conhecida.
1772
`assume' avalia seus argumentos.
1774
Veja também `is', `facts', `forget', `context', e `declare'.
1778
(%i1) assume (xx > 0, yy < -1, zz >= 0);
1779
(%o1) [xx > 0, yy < - 1, zz >= 0]
1780
(%i2) assume (aa < bb and bb < cc);
1781
(%o2) [bb > aa, cc > bb]
1783
(%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
1786
(%i5) is (yy < -yy);
1788
(%i6) is (sinh (bb - aa) > 0);
1790
(%i7) forget (bb > aa);
1792
(%i8) prederror : false;
1794
(%i9) is (sinh (bb - aa) > 0);
1796
(%i10) is (bb^2 < cc^2);
1800
-- Variável de opção: assumescalar
1801
Valor padrão: `true'
1803
`assumescalar' ajuda a governar se expressões `expr' para as quais
1804
`nonscalarp (expr)' for `false' são assumidas comportar-se como
1805
escalares para certas transformações.
1807
Tomemos `expr' representando qualquer expressão outra que não uma
1808
lista ou uma matriz, e tomemos `[1, 2, 3]' representando qualquer
1809
lista ou matriz. Então `expr . [1, 2, 3]' retorna `[expr, 2 expr,
1810
3 expr]' se `assumescalar' for `true', ou `scalarp (expr)' for
1811
`true', ou `constantp (expr)' for `true'.
1813
Se `assumescalar' for `true', tais expressões irão comportar-se
1814
como escalares somente para operadores comutativos, mas não para
1815
multiplicação não comutativa `.'.
1817
Quando `assumescalar' for `false', tais expressões irão
1818
comportar-se como não escalares.
1820
Quando `assumescalar' for `all', tais expressões irão comportar-se
1821
como escalares para todos os operadores listados acima.
1824
-- Variável de opção: assume_pos
1825
Valor padrão: `false'
1827
Quando `assume_pos' for `true' e o sinal de um parâmetro <x> não
1828
pode ser determinado a partir do contexto corrente ou outras
1829
considerações, `sign' e `asksign (<x>)' retornam `true'. Isso
1830
pode impedir algum questionamento de `asksign' gerado
1831
automaticamente, tal como pode surgir de `integrate' ou de outros
1834
Por padrão, um parâmetro é <x> tal como `symbolp (<x>)' or
1835
`subvarp (<x>)'. A classe de expressões consideradas parâmetros
1836
pode ser modificada para alguma abrangência através da variável
1839
`sign' e `asksign' tentam deduzir o sinal de expressões a partir
1840
de sinais de operandos dentro da expressão. Por exemplo, se `a' e
1841
`b' são ambos positivos, então `a + b' é também positivo.
1843
Todavia, não existe caminho para desviar todos os questionamentos
1844
de `asksign'. Particularmente, quando o argumento de `asksign'
1845
for uma diferença `<x> - <y>' ou um logarítmo `log(<x>)',
1846
`asksign' sempre solicita uma entrada ao usuário, mesmo quando
1847
`assume_pos' for `true' e `assume_pos_pred' for uma função que
1848
retorna `true' para todos os argumentos.
1851
-- Variável de opção: assume_pos_pred
1852
Valor padrão: `false'
1854
Quando `assume_pos_pred' for atribuído o nome de uma função ou uma
1855
expressão lambda de um argumento <x>, aquela função é chamada para
1856
determinar se <x> é considerado um parâmetro para o propósito de
1857
`assume_pos'. `assume_pos_pred' é ignorado quando `assume_pos'
1860
A função `assume_pos_pred' é chamada através de `sign' e de
1861
`asksign' com um argumento <x> que é ou um átomo, uma variável
1862
subscrita, ou uma expressão de chamada de função. Se a função
1863
`assume_pos_pred' retorna `true', <x> é considerado um parâmetro
1864
para o propósito de `assume_pos'.
1866
Por padrão, um parâmetro é <x> tal que `symbolp (x)' ou `subvarp
1869
Veja também `assume' e `assume_pos'.
1873
(%i1) assume_pos: true$
1874
(%i2) assume_pos_pred: symbolp$
1879
(%i5) assume_pos_pred: lambda ([x], display (x), true)$
1884
(%i7) asksign (a[1]);
1889
(%i8) asksign (foo (a));
1893
(%i9) asksign (foo (a) + bar (b));
1899
(%i10) asksign (log (a));
1902
Is a - 1 positive, negative, or zero?
1906
(%i11) asksign (a - b);
1915
Is b - a positive, negative, or zero?
1921
-- Variável de opção: context
1922
Valor padrão: `initial'
1924
`context' nomeia a coleção de fatos mantida através de `assume' e
1925
`forget'. `assume' adiciona fatos à coleção nomeada através de
1926
`context', enquanto `forget' remove fatos.
1928
Associando `context' para um nome <foo> altera o contexto corrente
1929
para <foo>. Se o contexto especificado <foo> não existe ainda,
1930
ele é criado automaticamente através de uma chamada a `newcontext'.
1931
O contexto especificado é ativado automaticamente.
1933
Veja `contexts' para uma descrição geral do mecanismo de contexto.
1936
-- Variável de opção: contexts
1937
Valor padrão: `[initial, global]'
1939
`contexts' é uma lista dos contextos que existem atualmente,
1940
incluindo o contexto ativo atualmente.
1942
O mecanismo de contexto torna possível para um usuário associar e
1943
nomear uma porção selecionada de fatos, chamada um contexto.
1944
Assim que isso for concluído, o usuário pode ter o Maxima
1945
assumindo ou esquecendo grande quantidade de fatos meramente
1946
através da ativação ou desativação seu contexto.
1948
Qualquer átomo simbólico pode ser um contexto, e os fatos contidos
1949
naquele contexto irão ser retidos em armazenamento até que sejam
1950
destruídos um por um através de chamadas a `forget' ou destruídos
1951
com um conjunto através de uma chamada a `kill' para destruir o
1952
contexto que eles pertencem.
1954
Contextos existem em uma hierarquía, com o raíz sempre sendo o
1955
contexto `global', que contém informações sobre Maxima que alguma
1956
função precisa. Quando em um contexto dado, todos os fatos naquele
1957
contexto estão "ativos" (significando que eles são usados em
1958
deduções e recuperados) como estão também todos os fatos em
1959
qualquer contexto que for um subcontexto do contexto ativo.
1961
Quando um novo Maxima for iniciado, o usuário está em um contexto
1962
chamado `initial', que tem `global' como um subcontexto.
1964
Veja também `facts', `newcontext', `supcontext', `killcontext',
1965
`activate', `deactivate', `assume', e `forget'.
1968
-- Função: deactivate (<context_1>, ..., <context_n>)
1969
Desativa os contextos especificados <context_1>, ..., <context_n>.
1972
-- Função: facts (<item>)
1974
Se <item> for o nome de um contexto, `facts (<item>)' retorna uma
1975
lista de fatos no contexto especificado.
1977
Se <item> não for o nome de um contexto, `facts (<item>)' retorna
1978
uma lista de fatos conhecidos sobre <item> no contexto atual.
1979
Fatos que estão atuvos, mas em um diferente contexto, não são
1982
`facts ()' (i.e., sem argumento) lista o contexto atual.
1985
-- Declaração: features
1986
Maxima recnhece ceertas propriedades matemáticas de funções e
1987
variáveis. Essas são chamadas "recursos".
1989
`declare (<x>, <foo>)' fornece a propriedade <foo> para a função
1992
`declare (<foo>, recurso)' declara um novo recurso <foo>. Por
1993
exemplo, `declare ([red, green, blue], feature)' declara três
1994
novos recursos, `red', `green', e `blue'.
1996
O predicado `featurep (<x>, <foo>)' retorna `true' se <x> possui a
1997
propriedade <foo>, e `false' de outra forma.
1999
A infolista `features' é uma lista de recursos conhecidos. São
2000
esses `integer', `noninteger', `even', `odd', `rational',
2001
`irrational', `real', `imaginary', `complex', `analytic',
2002
`increasing', `decreasing', `oddfun', `evenfun', `posfun',
2003
`commutative', `lassociative', `rassociative', `symmetric', e
2004
`antisymmetric', mais quaisquer recursos definidos pelo usuário.
2006
`features' é uma lista de recursos matemáticos. Existe também uma
2007
lista de recursos não matemáticos, recursos dependentes do
2008
sistema. Veja `status'.
2011
-- Função: forget (<pred_1>, ..., <pred_n>)
2012
-- Função: forget (<L>)
2013
Remove predicados estabelecidos através de `assume'. Os
2014
predicados podem ser expressões equivalentes a (mas não
2015
necessáriamente idênticas a) esses prevamentes assumidos.
2017
`forget (<L>)', onde <L> é uma lista de predicados, esquece cada
2021
-- Função: killcontext (<context_1>, ..., <context_n>)
2022
Mata os contextos <context_1>, ..., <context_n>.
2024
Se um dos contextos estiver for o contexto atual, o novo contexto
2025
atual irá tornar-se o primeiro subcontexto disponível do contexto
2026
atual que não tiver sido morto. Se o primeiro contexto disponível
2027
não morto for `global' então `initial' é usado em seu lugar. Se o
2028
contexto `initial' for morto, um novo, porém vazio contexto
2031
`killcontext' recusa-se a matar um contexto que estiver ativo
2032
atualmente, ou porque ele é um subcontexto do contexto atual, ou
2033
através do uso da função `activate'.
2035
`killcontext' avalia seus argumentos. `killcontext' retorna
2039
-- Função: newcontext (<nome>)
2040
Cria um novo contexto, porém vazio, chamado <nome>, que tem
2041
`global' como seu único subcontexto. O contexto recentemente
2042
criado torna-se o contexto ativo atualmente.
2044
`newcontext' avalia seu argumento. `newcontext' retorna <nome>.
2047
-- Função: supcontext (<nome>, <context>)
2048
-- Função: supcontext (<nome>)
2049
Cria um novo contexto, chamado <nome>, que tem <context> como um
2050
subcontexto. <context> deve existir.
2052
Se <context> não for especificado, o contexto atual é assumido.
2056
File: maxima.info, Node: Polinômios, Next: Constantes, Prev: Contextos, Up: Top
2063
* Introdução a Polinômios::
2064
* Definições para Polinômios::
2067
File: maxima.info, Node: Introdução a Polinômios, Next: Definições para Polinômios, Prev: Polinômios, Up: Polinômios
2069
12.1 Introdução a Polinômios
2070
============================
2072
Polinômios são armazenados no Maxima ou na forma geral ou na forma de
2073
Expressões Racionais Canônicas (CRE). Essa última é uma forma padrão,
2074
e é usada internamente por operações tais como `factor', `ratsimp', e
2077
Expressões Racionais Canônicas constituem um tipo de representação
2078
que é especialmente adequado para polinômios expandidos e funções
2079
racionais (também para polinômios parcialmente fatorados e funções
2080
racionais quando RATFAC for escolhida para `true'). Nessa forma CRE uma
2081
ordenação de variáveis (da mais para a menos importante) é assumida
2082
para cada expressão. Polinômios são representados recursivamente por
2083
uma lista consistindo da variável principal seguida por uma série de
2084
pares de expressões, uma para cada termo do polinômio. O primeiro
2085
membro de cada par é o expoente da variável principal naquele termo e o
2086
segundo membro é o coeficiente daquele termo que pode ser um número ou
2087
um polinômio em outra variável novamente respresentado nessa forma.
2088
Sendo assim a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e
2089
que a parte principal da forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1
2090
0 -3)) assumindo Y como sendo a variável principal, e é (X 1 (Y 1 2 0
2091
1) 0 -3) assumindo X como sendo a variável principal. A variável
2092
principal é usualmente determineda pela ordem alfabética reversa. As
2093
"variáveis" de uma expressão CRE não necessariamente devem ser
2094
atômicas. De fato qualquer subexpressão cujo principal operador não
2095
for + - * / or ^ com expoente inteiro será considerado uma "variável"
2096
da expressão (na forma CRE) na qual essa ocorrer. Por exemplo as
2097
variáveis CRE da expressão X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e
2098
SIN(X+1). Se o usuário não especifica uma ordem de variáveis pelo uso
2099
da função RATVARS Maxima escolherá a alfabética por conta própria. Em
2100
geral, CREs representam expressões racionais, isto é, razões de
2101
polinômios, onde o numerador e o denominador não possuem fatores
2102
comuns, e o denominador for positivo. A forma interna é essencialmente
2103
um par de polinômios (o numerador e o denominador) precedidos pela
2104
lista de ordenação de variável. Se uma expressão a ser mostrada
2105
estiver na forma CRE ou se contiver quaisquer subexpressões na forma
2106
CRE, o símbolo /R/ seguirá o rótulo da linha. Veja a função RAT para
2107
saber como converter uma expressão para a forma CRE. Uma forma CRE
2108
extendida é usada para a representação de séries de Taylor. A noção de
2109
uma expressão racional é extendida de modo que os expoentes das
2110
variáveis podem ser números racionais positivos ou negativos em lugar
2111
de apenas inteiros positivos e os coeficientes podem eles mesmos serem
2112
expressões racionais como descrito acima em lugar de apenas polinômios.
2113
Estes são representados internamente por uma forma polinomial
2114
recursiva que é similar à forma CRE e é a generalização dessa mesma
2115
forma CRE, mas carrega informação adicional tal com o grau de
2116
truncação. Do mesmo modo que na forma CRE, o símbolo /T/ segue o
2117
rótulo de linha que contém as tais expressões.
2120
File: maxima.info, Node: Definições para Polinômios, Prev: Introdução a Polinômios, Up: Polinômios
2122
12.2 Definições para Polinômios
2123
===============================
2125
-- Variável de opção: algebraic
2126
Valor Padrão: `false'
2128
`algebraic' deve ser escolhida para `true' com o objetivo de que a
2129
simplificação de inteiros algébricos tenha efeito.
2132
-- Variável de opção: berlefact
2133
Valor Padrão: `true'
2135
Quando `berlefact' for `false' então o algorítmo de fatoração de
2136
Kronecker será usado. De outra forma o algorítmo de Berlekamp,
2137
que é o padrão, será usado.
2140
-- Função: bezout (<p1>, <p2>, <x>)
2141
uma alternativa para o comando `resultant'. Isso retorna uma
2142
matriz. `determinant' dessa matriz é o resultante desejado.
2145
-- Função: bothcoef (<expr>, <x>)
2146
Retorna uma lista da qual o primeiro membro é o coeficiente de <x>
2147
em <expr> (como achado por `ratcoef' se <expr> está na forma CRE
2148
de outro modo por `coeff') e cujo segundo membro é a parte
2149
restante de <expr>. Isto é, `[A, B]' onde `<expr> = A*<x> + B'.
2153
(%i1) islinear (expr, x) := block ([c],
2154
c: bothcoef (rat (expr, x), x),
2155
é (freeof (x, c) and c[1] # 0))$
2156
(%i2) islinear ((r^2 - (x - r)^2)/x, x);
2160
-- Função: coeff (<expr>, <x>, <n>)
2161
Retorna o coeficiente de `<x>^<n>' em <expr>. <n> pode ser
2162
omitido se for 1. <x> pode ser um átomo, ou subexpressão completa
2163
de <expr> e.g., `sin(x)', `a[i+1]', `x + y', etc. (No último caso a
2164
expressão `(x + y)' pode ocorrer em <expr>). Algumas vezes isso
2165
pode ser necessário para expandir ou fatorar <expr> com o objetivo
2166
de fazer `<x>^<n>' explicito. Isso não é realizado por `coeff'.
2170
(%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
2172
(%i2) coeff (y + x*%e^x + 1, x, 0);
2176
-- Função: combine (<expr>)
2177
Simplifica a adição <expr> por termos combinados com o mesmo
2178
denominador dentro de um termo simples.
2181
-- Função: content (<p_1>, <x_1>, ..., <x_n>)
2182
Retorna uma lista cujo primeiro elemento é o máximo divisor comum
2183
dos coeficientes dos termos do polinômio <p_1> na variável <x_n>
2184
(isso é o conteúdo) e cujo segundo elemento é o polinômio <p_1>
2185
dividido pelo conteúdo.
2189
(%i1) content (2*x*y + 4*x^2*y^2, y);
2191
(%o1) [2 x, 2 x y + y]
2194
-- Função: denom (<expr>)
2195
Retorna o denominador da expressão racional <expr>.
2198
-- Função: divide (<p_1>, <p_2>, <x_1>, ..., <x_n>)
2199
calcula o quocietne e o resto do polinômio <p_1> dividido pelo
2200
polinômio <p_2>, na variável principal do polinômio, <x_n>. As
2201
outras variáveis são como na função `ratvars'. O resultado é uma
2202
lista cujo primeiro elemento é o quociente e cujo segundo elemento
2207
(%i1) divide (x + y, x - y, x);
2209
(%i2) divide (x + y, x - y);
2212
Note que `y' é a variável principal no segundo exemplo.
2215
-- Função: eliminate ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_k>])
2216
Elimina variáveis de equações (ou expressões assumidas iguais a
2217
zero) pegando resultantes sucessivos. Isso retorna uma lista de
2218
`<n> - <k>' expressões com <k> variáveis <x_1>, ..., <x_k>
2219
eliminadas. Primeiro <x_1> é eliminado retornando `<n> - 1'
2220
expressões, então `x_2' é eliminado, etc. Se `<k> = <n>' então
2221
uma expressão simples em uma lista é retornada livre das variáveis
2222
<x_1>, ..., <x_k>. Nesse caso `solve' é chamado para resolver a
2223
última resultante para a última variável.
2227
(%i1) expr1: 2*x^2 + y*x + z;
2230
(%i2) expr2: 3*x + 5*y - z - 1;
2231
(%o2) - z + 5 y + 3 x - 1
2232
(%i3) expr3: z^2 + x - y^2 + 5;
2235
(%i4) eliminate ([expr3, expr2, expr1], [y, z]);
2237
(%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x
2240
- 5154 x - 1291 x + 7688 x + 15376]
2243
-- Função: ezgcd (<p_1>, <p_2>, <p_3>, ...)
2244
Retorna uma lista cujo primeiro elemento é o m.d.c. dos polinômios
2245
<p_1>, <p_2>, <p_3>, ... e cujos restantes elementos são os
2246
polinômios divididos pelo mdc. Isso sempre usa o algorítmo
2250
-- Variável de opção: facexpand
2251
Valor Padrão: `true'
2253
`facexpand' controla se os fatores irredutíveis retornados por
2254
`factor' estão na forma expandida (o padrão) ou na forma recursiva
2258
-- Função: factcomb (<expr>)
2259
Tenta combinar os coeficientes de fatoriais em <expr> com os
2260
próprios fatoriais convertendo, por exemplo, `(n + 1)*n!' em `(n +
2263
`sumsplitfact' se escolhida para `false' fará com que
2264
`minfactorial' seja aplicado após um `factcomb'.
2267
-- Função: factor (<expr>)
2268
Fatora a expressão <expr>, contendo qualquer número de variáveis
2269
ou funções, em fatores irredutíveis sobre os inteiros. `factor
2270
(<expr>, p)' fatora <expr> sobre o campo dos inteiros com um
2271
elemento adjunto cujo menor polinômio é p.
2273
`factor' usa a função `ifactors' para fatorar inteiros.
2275
`factorflag' se `false' suprime a fatoração de fatores inteiros de
2276
expressões racionais.
2278
`dontfactor' pode ser escolhida para uma lista de variáveis com
2279
relação à qual fatoração não é para ocorrer. (Essa é inicialmente
2280
vazia). Fatoração também não acontece com relação a quaisquer
2281
variáveis que são menos importantes (usando a ordenação de
2282
variável assumida pela forma CRE) como essas na lista `dontfactor'.
2284
`savefactors' se `true' faz com que os fatores de uma expressão que
2285
é um produto de fatores seja guardada por certas funções com o
2286
objetivo de aumentar a velocidade de futuras fatorações de
2287
expressões contendo alguns dos mesmos fatores.
2289
`berlefact' se `false' então o algorítmo de fatoração de Kronecker
2290
será usado de outra forma o algorítmo de Berlekamp, que é o
2293
`intfaclim' se `true' maxima irá interromper a fatoração de
2294
inteiros se nenhum fator for encontrado após tentar divisões e o
2295
método rho de Pollard. Se escolhida para `false' (esse é o caso
2296
quando o usuário chama `factor' explicitamente), a fatoração
2297
completa do inteiro será tentada. A escolha do usuário para
2298
`intfaclim' é usada para chamadas internas a `factor'. Dessa
2299
forma, `intfaclim' pode ser resetada para evitar que o Maxima
2300
gaste um tempo muito longo fatorando inteiros grandes.
2304
(%i1) factor (2^63 - 1);
2306
(%o1) 7 73 127 337 92737 649657
2307
(%i2) factor (-8*y - 4*x + z^2*(2*y + x));
2308
(%o2) (2 y + x) (z - 2) (z + 2)
2309
(%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
2311
(%o3) x y + 2 x y + y - x - 2 x - 1
2312
(%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
2314
(x + 2 x + 1) (y - 1)
2315
(%o4) ----------------------
2317
(%i5) factor (1 + %e^(3*x));
2319
(%o5) (%e + 1) (%e - %e + 1)
2320
(%i6) factor (1 + x^4, a^2 - 2);
2322
(%o6) (x - a x + 1) (x + a x + 1)
2323
(%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
2325
(%o7) - (y + x) (z - x) (z + x)
2326
(%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
2328
(%o8) ------------------------
2330
(x + 3) (x + b) (x + c)
2333
(%o9) (x + 2)/(x + (2 c + b + 3) x
2336
+ (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c )
2337
(%i10) partfrac (%, x);
2339
(%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c
2342
+ (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c))
2345
- ---------------------------------
2347
(c + (- b - 3) c + 3 b) (x + c)
2350
+ -------------------------------------------------
2352
((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b)
2355
- ----------------------------------------------
2357
((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3)
2358
(%i11) map ('factor, %);
2360
c - 4 c - b + 6 c - 2
2361
(%o11) - ------------------------- - ------------------------
2363
(c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c)
2366
+ ------------------------ - ------------------------
2368
(b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3)
2369
(%i12) ratsimp ((x^5 - 1)/(x - 1));
2371
(%o12) x + x + x + x + 1
2372
(%i13) subst (a, x, %);
2374
(%o13) a + a + a + a + 1
2375
(%i14) factor (%th(2), %);
2377
(%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1)
2378
(%i15) factor (1 + x^12);
2380
(%o15) (x + 1) (x - x + 1)
2381
(%i16) factor (1 + x^99);
2383
(%o16) (x + 1) (x - x + 1) (x - x + 1)
2386
(x - x + x - x + x - x + x - x + x - x + 1)
2388
20 19 17 16 14 13 11 10 9 7 6
2389
(x + x - x - x + x + x - x - x - x + x + x
2391
4 3 60 57 51 48 42 39 33
2392
- x - x + x + 1) (x + x - x - x + x + x - x
2395
- x - x + x + x - x - x + x + 1)
2398
-- Variável de opção: factorflag
2399
Valor Padrão: `false'
2401
Quando `factorflag' for `false', suprime a fatoração de fatores
2402
inteiros em expressões racionais.
2405
-- Função: factorout (<expr>, <x_1>, <x_2>, ...)
2406
Rearranja a adição <expr> em uma adição de parcelas da forma `f
2407
(<x_1>, <x_2>, ...)*g' onde `g' é um produto de expressões que não
2408
possuem qualquer <x_i> e `f' é fatorado.
2411
-- Função: factorsum (<expr>)
2412
Tenta agrupar parcelas em fatores de <expr> que são adições em
2413
grupos de parcelas tais que sua adição é fatorável. `factorsum'
2414
pode recuperar o resultado de `expand ((x + y)^2 + (z + w)^2)' mas
2415
não pode recuperar `expand ((x + 1)^2 + (x + y)^2)' porque os
2416
termos possuem variáveis em comum.
2420
(%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
2422
(%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x
2425
+ 2 u v x + u x + a w + v + 2 u v + u
2426
(%i2) factorsum (%);
2428
(%o2) (x + 1) (a (z + w) + (v + u) )
2431
-- Função: fasttimes (<p_1>, <p_2>)
2432
Retorna o produto dos polinômios <p_1> e <p_2> usando um algorítmo
2433
especial para a multiplicação de polinômios. `p_1' e `p_2' podem
2434
ser de várias variáveis, densos, e aproximadamente do mesmo
2435
tamanho. A multiplicação clássica é de ordem `n_1 n_2' onde `n_1'
2436
é o grau de `p_1' and `n_2' é o grau de `p_2'. `fasttimes' é da
2437
ordem `max (n_1, n_2)^1.585'.
2440
-- Função: fullratsimp (<expr>)
2441
`fullratsimp' aplica repetidamente `ratsimp' seguido por
2442
simplificação não racional a uma expressão até que nenhuma mudança
2443
adicional ocorra, e retorna o resultado.
2445
Quando expressões não racionais estão envolvidas, uma chamada a
2446
`ratsimp' seguida como é usual por uma simplificação não racional
2447
("geral") pode não ser suficiente para retornar um resultado
2448
simplificado. Algumas vezes, mais que uma tal chamada pode ser
2449
necessária. `fullratsimp' faz esse processo convenientemente.
2451
`fullratsimp (<expr>, <x_1>, ..., <x_n>)' pega um ou mais
2452
argumentos similar a `ratsimp' e `rat'.
2456
(%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
2459
(%o1) -----------------------
2462
(%i2) ratsimp (expr);
2465
(%o2) ---------------
2468
(%i3) fullratsimp (expr);
2474
(%o4)/R/ -----------------------
2479
-- Função: fullratsubst (<a>, <b>, <c>)
2480
é o mesmo que `ratsubst' exceto que essa chama a si mesma
2481
recursivamente sobre esse resultado até que o resultado para de
2482
mudar. Essa função é útil quando a expressão de substituição e a
2483
expressão substituída tenham uma ou mais variáveis em comum.
2485
`fullratsubst' irá também aceitar seus argumentos no formato de
2486
`lratsubst'. Isto é, o primeiro argumento pode ser uma
2487
substituição simples de equação ou uma lista de tais equações,
2488
enquanto o segundo argumento é a expressão sendo processada.
2490
`load ("lrats")' chama `fullratsubst' e `lratsubst'.
2494
(%i1) load ("lrats")$
2496
* `subst' pode realizar multiplas substituições. `lratsubst' é
2499
(%i2) subst ([a = b, c = d], a + c);
2501
(%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
2502
(%o3) (d + a c) e + a d + b c
2504
* Se somente uma substituição é desejada, então uma equação
2505
simples pode ser dada como primeiro argumento.
2507
(%i4) lratsubst (a^2 = b, a^3);
2510
* `fullratsubst' é equivalente a `ratsubst' exceto que essa
2511
executa recursivamente até que seu resultado para de mudar.
2513
(%i5) ratsubst (b*a, a^2, a^3);
2516
(%i6) fullratsubst (b*a, a^2, a^3);
2520
* `fullratsubst' também aceita uma lista de equações ou uma
2521
equação simples como primeiro argumento.
2523
(%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
2525
(%i8) fullratsubst (a^2 = b*a, a^3);
2529
* `fullratsubst' pode causar uma recursão infinita.
2531
(%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));
2533
*** - Lisp stack overflow. RESET
2536
-- Função: gcd (<p_1>, <p_2>, <x_1>, ...)
2537
Retorna o máximo divisor comum entre <p_1> e <p_2>. O sinalizador
2538
`gcd' determina qual algorítmo é empregado. Escolhendo `gcd' para
2539
`ez', `subres', `red', ou `spmod' seleciona o algorítmo `ezgcd',
2540
subresultante `prs', reduzido, ou modular, respectivamente. Se
2541
`gcd' for `false' então `gcd (<p_1>, <p_2>, <x>)' sempre retorna 1
2542
para todo <x>. Muitas funções (e.g. `ratsimp', `factor', etc.)
2543
fazem com que mdc's sejam feitos implicitamente. Para polinômios
2544
homogêneos é recomendado que `gcd' igual a `subres' seja usado.
2545
Para pegar o mdc quando uma expressão algébrica está presente,
2546
e.g. `gcd (<x>^2 - 2*sqrt(2)*<x> + 2, <x> - sqrt(2))', `algebraic'
2547
deve ser `true' e `gcd' não deve ser `ez'. `subres' é um novo
2548
algorítmo, e pessoas que tenham estado usando a opção `red' podem
2549
provavelmente alterar isso para `subres'.
2551
O sinalizador `gcd', padrão: `subres', se `false' irá também
2552
evitar o máximo divisor comum de ser usado quando expressões são
2553
convertidas para a forma de expressão racional canônica (CRE).
2554
Isso irá algumas vezes aumentar a velocidade dos cálculos se mdc's
2558
-- Função: gcdex (<f>, <g>)
2559
-- Função: gcdex (<f>, <g>, <x>)
2560
Retornam uma lista `[<a>, <b>, <u>]' onde <u> é o máximo divisor
2561
comum (mdc) entre <f> e <g>, e <u> é igual a `<a> <f> + <b> <g>'.
2562
Os argumentos <f> e <g> podem ser polinômios de uma variável, ou
2563
de outra forma polinômios em <x> uma main(principal) variável
2564
suprida desde que nós precisamos estar em um domínio de ideal
2565
principal para isso trabalhar. O mdc significa o mdc considerando
2566
<f> e <g> como polinômios de uma única variável com coeficientes
2567
sendo funções racionais em outras variáveis.
2569
`gcdex' implementa o algorítmo Euclideano, onde temos a seqüência
2570
of `L[i]: [a[i], b[i], r[i]]' que são todos perpendiculares a `[f,
2571
g, -1]' e o próximo se é construído como se `q =
2572
quotient(r[i]/r[i+1])' então `L[i+2]: L[i] - q L[i+1]', e isso
2573
encerra em `L[i+1]' quando o resto `r[i+2]' for zero.
2575
(%i1) gcdex (x^2 + 1, x^3 + 4);
2578
(%o1)/R/ [- ------------, -----, 1]
2580
(%i2) % . [x^2 + 1, x^3 + 4, -1];
2583
Note que o mdc adiante é `1' uma vez que trabalhamos em `k(y)[x]',
2584
o `y+1' não pode ser esperado em `k[y, x]'.
2586
(%i1) gcdex (x*(y + 1), y^2 - 1, x);
2588
(%o1)/R/ [0, ------, 1]
2593
-- Função: gcfactor (<n>)
2594
Fatora o inteiro Gaussiano <n> sobre os inteiros Gaussianos, i.e.,
2595
números da forma `<a> + <b> `%i'' onde <a> e <b> são inteiros
2596
raconais (i.e., inteiros comuns). Fatorações são normalizadas
2597
fazendo <a> e <b> não negativos.
2600
-- Função: gfactor (<expr>)
2601
Fatora o polinômio <expr> sobre os inteiros de Gauss (isto é, os
2602
inteiros com a unidade imaginária `%i' adjunta). Isso é como
2603
`factor (<expr>, <a>^2+1)' trocando <a> por `%i'.
2607
(%i1) gfactor (x^4 - 1);
2608
(%o1) (x - 1) (x + 1) (x - %i) (x + %i)
2611
-- Função: gfactorsum (<expr>)
2612
é similar a `factorsum' mas aplica `gfactor' em lugar de `factor'.
2615
-- Função: hipow (<expr>, <x>)
2616
Retorna o maior expoente explícito de <x> em <expr>. <x> pode ser
2617
uma variável ou uma expressão geral. Se <x> não aparece em <expr>,
2618
`hipow' retorna `0'.
2620
`hipow' não considera expressões equivalentes a `expr'. Em
2621
particular, `hipow' não expande `expr', então `hipow (<expr>,
2622
<x>)' e `hipow (expand (<expr>, <x>))' podem retornar diferentes
2627
(%i1) hipow (y^3 * x^2 + x * y^4, x);
2629
(%i2) hipow ((x + y)^5, x);
2631
(%i3) hipow (expand ((x + y)^5), x);
2633
(%i4) hipow ((x + y)^5, x + y);
2635
(%i5) hipow (expand ((x + y)^5), x + y);
2639
-- Variável de opção: intfaclim
2642
Se `true', maxima irá interromper a fatoração de inteiros se
2643
nenhum fator for encontrado após tentar divisões e o método rho de
2644
Pollard e a fatoração não irá ser completada.
2646
Quando `intfaclim' for `false' (esse é o caso quando o usuário
2647
chama `factor' explicitamente), a fatoração completa irá ser
2648
tentada. `intfaclim' é escolhida para `false' quando fatores são
2649
calculados em `divisors', `divsum' e `totient'.
2651
Chamadas internas a `factor' respeitam o valor especificado pelo
2652
usuário para `intfaclim'. Setting `intfaclim' to `true' may reduce
2653
`intfaclim'. Escolhendo `intfaclim' para `true' podemos reduzir o
2654
tempo gasto fatorando grandes inteiros.
2657
-- Variável de opção: keepfloat
2658
Valor Padrão: `false'
2660
Quando `keepfloat' for `true', evitamos que números em ponto
2661
flutuante sejam racionalizados quando expressões que os possuem
2662
são então convertidas para a forma de expressão racional canônica
2666
-- Função: lratsubst (<L>, <expr>)
2667
é análogo a `subst (<L>, <expr>)' exceto que esse usa `ratsubst'
2668
em lugar de `subst'.
2670
O primeiro argumento de `lratsubst' é uma equação ou uma lista de
2671
equações idênticas em formato para que sejam aceitas por `subst'.
2672
As substituições são feitas na ordem dada pela lista de equações,
2673
isto é, da esquerda para a direita.
2675
`load ("lrats")' chama `fullratsubst' e `lratsubst'.
2679
(%i1) load ("lrats")$
2681
* `subst' pode realizar multiplas substituições. `lratsubst' é
2684
(%i2) subst ([a = b, c = d], a + c);
2686
(%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
2687
(%o3) (d + a c) e + a d + b c
2689
* Se somente uma substituição for desejada, então uma equação
2690
simples pode ser dada como primeiro argumento.
2692
(%i4) lratsubst (a^2 = b, a^3);
2696
-- Variável de opção: modulus
2697
Valor Padrão: `false'
2699
Quando `modulus' for um número positivo <p>, operações sobre os
2700
números racionais (como retornado por `rat' e funções relacionadas)
2701
são realizadas módulo <p>, usando o então chamado sistema de
2702
módulo "balanceado" no qual `<n> módulo <p>' é definido como um
2703
inteiro <k> em `[-(<p>-1)/2, ..., 0, ..., (<p>-1)/2]' quando <p>
2704
for ímpar, ou `[-(<p>/2 - 1), ..., 0, ...., <p>/2]' quando <p> for
2705
par, tal que `<a> <p> + <k>' seja igual a <n> para algum inteiro
2708
Se <expr> já estiver na forma de expressão racional canônica (CRE)
2709
quando `modulus' for colocado em seu valor original, então você
2710
pode precisar repetir o rat <expr>, e.g., `expr: rat (ratdisrep
2711
(expr))', com o objetivo de pegar resultados corretos.
2713
Tipicamente `modulus' é escolhido para um número primo. Se
2714
`modulus' for escolhido para um inteiro não primo positivo, essa
2715
escolha é aceita, mas uma mensagem de alerta é mostrada. Maxima
2716
permitirá que zero ou um inteiro negativo seja atribuído a
2717
`modulus', embora isso não seja limpo se aquele tiver quaisquer
2718
conseqüências úteis.
2721
-- Função: num (<expr>)
2722
Retorna o numerador de <expr> se isso for uma razão. Se <expr>
2723
não for uma razão, <expr> é retornado.
2725
`num' avalia seu argumento.
2728
-- Função: polydecomp (<p>, <x>)
2729
Decompões o polinômio <p> na variável <x> em uma composição
2730
funcional de polinômios em <x>. `polydecomp' retorna uma lista
2731
`[<p_1>, ..., <p_n>]' tal que
2733
lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...))
2735
seja igual a <p>. O grau de <p_i> é maior que 1 para <i> menor
2738
Tal decomposição não é única.
2742
(%i1) polydecomp (x^210, x);
2744
(%o1) [x , x , x , x ]
2745
(%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
2747
(%o2) x - 2 x - 2 x + x + 2 x - a + 1
2748
(%i3) polydecomp (p, x);
2750
(%o3) [x - a, x - x - 1]
2752
As seguintes funções compõem `L = [e_1, ..., e_n]' como funções em
2753
`x'; essa funçào é a inversa de `polydecomp':
2756
block ([r : x], for e in L do r : subst (e, x, r), r) $
2758
Re-exprimindo o exemplo acima usando `compose':
2760
(%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
2762
(%o3) [x - a, x - x - 1]
2764
Note que apesar de `compose (polydecomp (<p>, <x>), <x>)' sempre
2765
retornar <p> (não expandido), `polydecomp (compose ([<p_1>, ...,
2766
<p_n>], <x>), <x>)' não necessáriamente retorna `[<p_1>, ...,
2769
(%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
2771
(%o4) [x + 2, x + 1]
2772
(%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
2775
(%o5) [------, ------, 2 x + 1]
2779
-- Função: quotient (<p_1>, <p_2>)
2780
-- Função: quotient (<p_1>, <p_2>, <x_1>, ..., <x_n>)
2781
Retorna o polinômio <p_1> dividido pelo polinômio <p_2>. Os
2782
argumentos <x_1>, ..., <x_n> são interpretados como em `ratvars'.
2784
`quotient' retorna o primeiro elemento de uma lista de dois
2785
elementos retornada por `divide'.
2788
-- Função: rat (<expr>)
2789
-- Função: rat (<expr>, <x_1>, ..., <x_n>)
2790
Converte <expr> para a forma de expressão racional canônica (CRE)
2791
expandindo e combinando todos os termos sobre um denominador comum
2792
e cancelando para fora o máximo divisor comum entre o numerador e
2793
o denominador, também convertendo números em ponto flutuante para
2794
números racionais dentro da tolerância de `ratepsilon'. As
2795
variáveis são ordenadas de acordo com <x_1>, ..., <x_n>, se
2796
especificado, como em `ratvars'.
2798
`rat' geralmente não simplifica funções outras que não sejam
2799
adição `+', subtração `-', multiplicação `*', divisão `/', e
2800
exponenciação com expoente inteiro, uma vez que `ratsimp' não
2801
manuseia esses casos. Note que átomos (números e variáveis) na
2802
forma CRE não são os mesmos que eles são na forma geral. Por
2803
exemplo, `rat(x)- x' retorna `rat(0)' que tem uma representação
2804
interna diferente de 0.
2806
Quando `ratfac' for `true', `rat' retorna uma forma parcialmente
2807
fatorada para CRE. Durante operações racionais a expressão é
2808
mantida como totalmente fatorada como possível sem uma chamada ao
2809
pacote de fatoração (`factor'). Isso pode sempre economizar
2810
espaço de memória e algum tempo em algumas computações. O
2811
numerador e o denominador são ainda tidos como relativamente primos
2812
(e.g. `rat ((x^2 - 1)^4/(x + 1)^2)' retorna `(x - 1)^4 (x +
2813
1)^2)', mas os fatores dentro de cada parte podem não ser
2814
relativamente primos.
2816
`ratprint' se `false' suprime a impressão de mensagens informando
2817
o usuário de conversões de números em ponto flutuante para números
2820
`keepfloat' se `true' evita que números em ponto flutuante sejam
2821
convertidos para números racionais.
2823
Veja também `ratexpand' e `ratsimp'.
2827
(%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /(4*y^2 + x^2);
2830
(y + a) (2 y + x) (------------ + 1)
2833
(%o1) ------------------------------------
2836
(%i2) rat (%, y, a, x);
2842
-- Variável de opção: ratalgdenom
2843
Valor Padrão: `true'
2845
Quando `ratalgdenom' for `true', permite racionalização de
2846
denominadores com respeito a radicais tenham efeito.
2847
`ratalgdenom' tem efeito somente quando expressões racionais
2848
canônicas (CRE) forem usadas no modo algébrico.
2851
-- Função: ratcoef (<expr>, <x>, <n>)
2852
-- Função: ratcoef (<expr>, <x>)
2853
Retorna o coeficiente da expressão `<x>^<n>' dentro da expressão
2854
<expr>. Se omitido, <n> é assumido ser 1.
2856
O valor de retorno está livre (exceto possivelmente em um senso
2857
não racional) das variáveis em <x>. Se nenhum coeficiente desse
2858
tipo existe, 0 é retornado.
2860
`ratcoef' expande e simplifica racionalmente seu primeiro
2861
argumento e dessa forma pode produzir respostas diferentes das de
2862
`coeff' que é puramente sintática. Dessa forma `ratcoef ((x +
2863
1)/y + x, x)' retorna `(y + 1)/y' ao passo que `coeff' retorna 1.
2865
`ratcoef (<expr>, <x>, 0)', visualiza <expr> como uma adição,
2866
retornando uma soma desses termos que não possuem <x>. portanto
2867
se <x> ocorre para quaisquer expoentes negativos, `ratcoef' pode
2870
Uma vez que <expr> é racionalmente simplificada antes de ser
2871
examinada, coeficientes podem não aparecer inteiramente no caminho
2872
que eles foram pensados.
2876
(%i1) s: a*x + b*x + 5$
2877
(%i2) ratcoef (s, a + b);
2881
-- Função: ratdenom (<expr>)
2882
Retorna o denominador de <expr>, após forçar a conversão de <expr>
2883
para expressão racional canônica (CRE). O valor de retorno é a
2886
<expr> é forçada para uma CRE por `rat' se não for já uma CRE.
2887
Essa conversão pode mudar a forma de <expr> colocando todos os
2888
termos sobre um denominador comum.
2890
`denom' é similar, mas retorna uma expressão comum em lugar de uma
2891
CRE. Também, `denom' não tenta colocar todos os termos sobre um
2892
denominador comum, e dessa forma algumas expressões que são
2893
consideradas razões por `ratdenom' não são consideradas razões por
2897
-- Variável de opção: ratdenomdivide
2898
Valor Padrão: `true'
2900
Quando `ratdenomdivide' for `true', `ratexpand' expande uma razão
2901
cujo o numerador for uma adição dentro de uma soma de razões,
2902
tendo todos um denominador comum. De outra forma, `ratexpand'
2903
colapsa uma adição de razões dentro de uma razão simples, cujo
2904
numerador seja a adição dos numeradores de cada razão.
2908
(%i1) expr: (x^2 + x + 1)/(y^2 + 7);
2914
(%i2) ratdenomdivide: true$
2915
(%i3) ratexpand (expr);
2918
(%o3) ------ + ------ + ------
2921
(%i4) ratdenomdivide: false$
2922
(%i5) ratexpand (expr);
2928
(%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
2931
(%o6) ------ + ------
2934
(%i7) ratexpand (expr2);
2942
-- Função: ratdiff (<expr>, <x>)
2943
Realiza a derivação da expressão racional <expr> com relação a <x>.
2944
<expr> deve ser uma razão de polinômios ou um polinômio em <x>. O
2945
argumento <x> pode ser uma variável ou uma subexpressão de <expr>.
2947
O resultado é equivalente a `diff', embora talvez em uma forma
2948
diferente. `ratdiff' pode ser mais rápida que `diff', para
2949
expressões racionais.
2951
`ratdiff' retorna uma expressão racional canônica (CRE) se `expr'
2952
for uma CRE. De outra forma, `ratdiff' retorna uma expressão
2955
`ratdiff' considera somente as dependências de <expr> sobre <x>, e
2956
ignora quaisquer dependências estabelecidas por `depends'.
2960
(%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
2963
(%o1) ----------------
2966
(%i2) ratdiff (expr, x);
2968
8 x + 40 x - 55 x - 60 x - 50
2969
(%o2) - ---------------------------------
2972
(%i3) expr: f(x)^3 - f(x)^2 + 7;
2974
(%o3) f (x) - f (x) + 7
2975
(%i4) ratdiff (expr, f(x));
2977
(%o4) 3 f (x) - 2 f(x)
2978
(%i5) expr: (a + b)^3 + (a + b)^2;
2980
(%o5) (b + a) + (b + a)
2981
(%i6) ratdiff (expr, a + b);
2983
(%o6) 3 b + (6 a + 2) b + 3 a + 2 a
2986
-- Função: ratdisrep (<expr>)
2987
Retorna seu argumento como uma expressão geral. Se <expr> for uma
2988
expressão geral, é retornada inalterada.
2990
Tipicamente `ratdisrep' é chamada para converter uma expressão
2991
racional canônica (CRE) em uma expressão geral. Isso é algumas
2992
vezes conveniente se deseja-se parar o "contágio", ou caso se
2993
esteja usando funções racionais em contextos não racionais.
2995
Veja também `totaldisrep'.
2998
-- Variável de opção: ratepsilon
2999
Valor Padrão: 2.0e-8
3001
`ratepsilon' é a tolerância usada em conversões de números em
3002
ponto flutuante para números racionais.
3005
-- Função: ratexpand (<expr>)
3006
-- Variável de opção: ratexpand
3007
Expande <expr> multiplicando para fora produtos de somas e somas
3008
exponenciadas, combinando frações sobre um denominador comum,
3009
cancelando o máximo divisor comum entre entre o numerador e o
3010
denominador, então quebrando o numerador (se for uma soma) dentro
3011
de suas respectivas parcelas divididas pelo denominador.
3013
O valor de retorno de `ratexpand' é uma expressão geral, mesmo se
3014
<expr> for uma expressão racional canônica (CRE).
3016
O comutador `ratexpand' se `true' fará com que expressões CRE
3017
sejam completamente expandidas quando forem convertidas de volta
3018
para a forma geral ou mostradas, enquanto se for `false' então
3019
elas serão colocadas na forma recursiva. Veja também `ratsimp'.
3021
Quando `ratdenomdivide' for `true', `ratexpand' expande uma razão
3022
na qual o numerador é uma adição dentro de uma adição de razões,
3023
todas tendo um denominador comum. De outra forma, `ratexpand'
3024
contrai uma soma de razões em uma razão simples, cujo numerador é
3025
a soma dos numeradores de cada razão.
3027
Quando `keepfloat' for `true', evita que números em ponto
3028
flutuante sejam racionalizados quando expressões que contenham
3029
números em ponto flutuante forem convertidas para a forma de
3030
expressão racional canônica (CRE).
3034
(%i1) ratexpand ((2*x - 3*y)^3);
3036
(%o1) - 27 y + 54 x y - 36 x y + 8 x
3037
(%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
3039
(%o2) -------- + -----
3042
(%i3) expand (expr);
3044
(%o3) ------------ - ------------ + -----
3046
x + 2 x + 1 x + 2 x + 1
3047
(%i4) ratexpand (expr);
3050
(%o4) --------------- + ---------------
3052
x + x - x - 1 x + x - x - 1
3055
-- Variável de opção: ratfac
3056
Valor Padrão: `false'
3058
Quando `ratfac' for `true', expressões racionais canônicas (CRE)
3059
são manipuladas na forma parcialmente fatorada.
3061
Durante operações racionais a expressão é mantida como
3062
completamente fatorada como foi possível sem chamadas a `factor'.
3063
Isso pode sempre economizar espaço e pode economizar tempo em
3064
algumas computações. O numerador e o denominador são feitos
3065
relativamente primos, por exemplo `rat ((x^2 - 1)^4/(x + 1)^2)'
3066
retorna `(x - 1)^4 (x + 1)^2)', mas o fator dentro de cada parte
3067
pode não ser relativamente primo.
3069
No pacote `ctensor' (Manipulação de componentes de tensores),
3070
tensores de Ricci, Einstein, Riemann, e de Weyl e a curvatura
3071
escalar são fatorados automaticamente quando `ratfac' for `true'.
3072
`ratfac' pode somente ser escolhido para casos onde as componentes
3073
tensoriais sejam sabidametne consistidas de poucos termos.
3075
Os esquemas de `ratfac' e de `ratweight' são incompatíveis e não
3076
podem ambos serem usados ao mesmo tempo.
3079
-- Função: ratnumer (<expr>)
3080
Retorna o numerador de <expr>, após forçar <expr> para uma
3081
expressão racional canônica (CRE). O valor de retorno é uma CRE.
3083
<expr> é forçada para uma CRE por `rat' se isso não for já uma CRE.
3084
Essa conversão pode alterar a forma de <expr> pela colocação de
3085
todos os termos sobre um denominador comum.
3087
`num' é similar, mas retorna uma expressão comum em lugar de uma
3088
CRE. Também, `num' não tenta colocar todos os termos sobre um
3089
denominador comum, e dessa forma algumas expressões que são
3090
consideradas razões por `ratnumer' não são consideradas razões por
3094
-- Função: ratnump (<expr>)
3095
Retorna `true' se <expr> for um inteiro literal ou razão de
3096
inteiros literais, de outra forma retorna `false'.
3099
-- Função: ratp (<expr>)
3100
Retorna `true' se <expr> for uma expressão racional canônica (CRE)
3101
ou CRE extendida, de outra forma retorna `false'.
3103
CRE são criadas por `rat' e funções relacionadas. CRE extendidas
3104
são criadas por `taylor' e funções relacionadas.
3107
-- Variável de opção: ratprint
3108
Valor Padrão: `true'
3110
Quando `ratprint' for `true', uma mensagem informando ao usuário
3111
da conversão de números em ponto flutuante para números racionais
3115
-- Função: ratsimp (<expr>)
3116
-- Função: ratsimp (<expr>, <x_1>, ..., <x_n>)
3117
Simplifica a expressão <expr> e todas as suas subexpressões,
3118
incluindo os argumentos para funções não racionais. O resultado é
3119
retornado como o quociente de dois polinômios na forma recursiva,
3120
isto é, os coeficientes de variável principal são polinômios em
3121
outras variáveis. Variáveis podem incluir funções não racionais
3122
(e.g., `sin (x^2 + 1)') e os argumentos para quaisquer tais
3123
funções são também simplificados racionalmente.
3125
`ratsimp (<expr>, <x_1>, ..., <x_n>)' habilita simplificação
3126
racional com a especiicação de variável ordenando como em
3129
Quando `ratsimpexpons' for `true', `ratsimp' é aplicado para os
3130
expoentes de expressões durante a simplificação.
3132
Veja também `ratexpand'. Note que `ratsimp' é afetado por algum
3133
dos sinalizadores que afetam `ratexpand'.
3137
(%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
3139
x (log(x) + 1) - log (x)
3140
(%o1) sin(------) = %e
3145
(%o2) sin(-----) = %e x
3147
(%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
3149
(x - 1) - sqrt(x - 1) (x + 1)
3150
(%o3) --------------------------------
3151
sqrt((x - 1) (x + 1))
3154
(%o4) - -------------
3157
(%i5) x^(a + 1/a), ratsimpexpons: true;
3165
-- Variável de opção: ratsimpexpons
3166
Valor Padrão: `false'
3168
Quando `ratsimpexpons' for `true', `ratsimp' é aplicado para os
3169
expoentes de expressões durante uma simplificação.
3172
-- Função: ratsubst (<a>, <b>, <c>)
3173
Substitue <a> por <b> em <c> e retorna a expressão resultante.
3174
<b> pode também ser uma adição, produto, expoente, etc.
3176
`ratsubst' sabe alguma coisa do significado de expressões uma vez
3177
que `subst' não é uma substituição puramente sintática. Dessa
3178
forma `subst (a, x + y, x + y + z)' retorna `x + y + z' ao passo
3179
que `ratsubst' retorna `z + a'.
3181
Quando `radsubstflag' for `true', `ratsubst' faz substituição de
3182
radicais em expressões que explicitamente não possuem esses
3187
(%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
3190
(%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
3192
(%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1
3193
(%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
3195
(%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
3196
(%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
3198
(%o4) cos (x) - 2 cos (x) + 1
3199
(%i5) radsubstflag: false$
3200
(%i6) ratsubst (u, sqrt(x), x);
3202
(%i7) radsubstflag: true$
3203
(%i8) ratsubst (u, sqrt(x), x);
3208
-- Função: ratvars (<x_1>, ..., <x_n>)
3209
-- Função: ratvars ()
3210
-- Variável de sistema: ratvars
3211
Declara variáveis principais <x_1>, ..., <x_n> para expressões
3212
racionais. <x_n>, se presente em uma expressão racional, é
3213
considerada a variável principal. De outra forma, <x_[n-1]> é
3214
considerada a variável principal se presente, e assim por diante
3215
até as variáveis precedentes para <x_1>, que é considerada a
3216
variável principal somente se nenhuma das variáveis que a sucedem
3219
Se uma variável em uma expressão racional não está presente na
3220
lista `ratvars', a ela é dada uma prioridade menor que <x_1>.
3222
Os argumentos para `ratvars' podem ser ou variáveis ou funções não
3223
racionais tais como `sin(x)'.
3225
A variável `ratvars' é uma lista de argumentos da função `ratvars'
3226
quando ela foi chamada mais recentemente. Cada chamada para a
3227
função `ratvars' sobre-grava a lista apagando seu conteúdo
3228
anterior. `ratvars ()' limpa a lista.
3231
-- Função: ratweight (<x_1>, <w_1>, ..., <x_n>, <w_n>)
3232
-- Função: ratweight ()
3233
Atribui um peso <w_i> para a variável <x_i>. Isso faz com que um
3234
termo seja substituído por 0 se seu peso exceder o valor da
3235
variável `ratwtlvl' (o padrão retorna sem truncação). O peso de
3236
um termo é a soma dos produtos dos pesos de uma variável no termo
3237
vezes seu expoente. Por exemplo, o peso de `3 x_1^2 x_2' é `2 w_1
3238
+ w_2'. A truncação de acordo com `ratwtlvl' é realizada somente
3239
quando multiplicando ou exponencializando expressões racionais
3242
`ratweight ()' retorna a lista cumulativa de atribuições de pesos.
3244
Nota: Os esquemas de `ratfac' e `ratweight' são incompatíveis e
3245
não podem ambo serem usados ao mesmo tempo.
3249
(%i1) ratweight (a, 1, b, 1);
3251
(%i2) expr1: rat(a + b + 1)$
3254
(%o3)/R/ b + (2 a + 2) b + a + 2 a + 1
3257
(%o5)/R/ 2 b + 2 a + 1
3260
-- Variável de sistema: ratweights
3263
`ratweights' é a lista de pesos atribuídos por `ratweight'. A
3264
lista é cumulativa: cada chamada a `ratweight' coloca ítens
3265
adicionais na lista.
3267
`kill (ratweights)' e `save (ratweights)' ambos trabalham como
3271
-- Variável de opção: ratwtlvl
3272
Valor Padrão: `false'
3274
`ratwtlvl' é usada em combinação com a função `ratweight' para
3275
controlar a truncação de expressão racionais canônicas (CRE).
3276
Para o valor padrão `false', nenhuma truncação ocorre.
3279
-- Função: remainder (<p_1>, <p_2>)
3280
-- Função: remainder (<p_1>, <p_2>, <x_1>, ..., <x_n>)
3281
Retorna o resto do polinômio <p_1> dividido pelo polinômio <p_2>.
3282
Os argumentos <x_1>, ..., <x_n> são interpretados como em
3285
`remainder' retorna o segundo elemento de uma lista de dois
3286
elementos retornada por `divide'.
3289
-- Função: resultant (<p_1>, <p_2>, <x>)
3290
-- Variável: resultant
3291
Calcula o resultante de dois polinômios <p_1> e <p_2>, eliminando
3292
a variável <x>. O resultante é um determinante dos coeficientes
3293
de <x> em <p_1> e <p_2>, que é igual a zero se e somente se <p_1>
3294
e <p_2> tiverem um fator em comum não constante.
3296
Se <p_1> ou <p_2> puderem ser fatorados, pode ser desejável chamar
3297
`factor' antes de chamar `resultant'.
3299
A variável `resultant' controla que algorítmo será usado para
3300
calcular o resultante. `subres' para o prs subresultante, `mod'
3301
para o algorítmo resultante modular, e `red' para prs reduzido.
3302
Para muitos problemas `subres' pode ser melhor. Para alguns
3303
problemas com valores grandes de grau de uma única variável ou de
3304
duas variáveis `mod' pode ser melhor.
3306
A função `bezout' pega os mesmos argumentos que `resultant' e
3307
retorna uma matriz. O determinante do valor de retorno é o
3308
resultante desejado.
3311
-- Variável de opção: savefactors
3312
Valor Padrão: `false'
3314
Quando `savefactors' for `true', faz com que os fatores de uma
3315
expressão que é um produto de fatores sejam gravados por certas
3316
funções com o objetivo de aumentar a velocidade em posteriores
3317
fatorações de expressões contendo algum desses mesmos fatores.
3320
-- Função: sqfr (<expr>)
3321
é similar a `factor' exceto que os fatores do polinômio são
3322
"livres de raízes". Isto é, eles possuem fatores somente de grau
3323
um. Esse algorítmo, que é também usado no primeiro estágio de
3324
`factor', utiliza o fato que um polinômio tem em comum com sua
3325
n'ésima derivada todos os seus fatores de grau maior que n. Dessa
3326
forma pegando o maior divisor comum com o polinômio das derivadas
3327
com relação a cada variável no polinômio, todos os fatores de grau
3328
maior que 1 podem ser achados.
3332
(%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
3334
(%o1) (2 x + 1) (x - 1)
3337
-- Função: tellrat (<p_1>, ..., <p_n>)
3338
-- Função: tellrat ()
3339
Adiciona ao anel dos inteiros algébricos conhecidos do Maxima os
3340
elementos que são as soluções dos polinômios <p_1>, ..., <p_n>.
3341
Cada argumento <p_i> é um polinômio concoeficientes inteiros.
3343
`tellrat (<x>)' efetivamente significa substituir 0 por <x> em
3346
`tellrat ()' retorna uma lista das substituições correntes.
3348
`algebraic' deve ser escolhida para `true' com o objetivo de que a
3349
simplificação de inteiros algébricos tenha efeito.
3351
Maxima inicialmente sabe sobre a unidade imaginária `%i' e todas
3352
as raízes de inteiros.
3354
Existe um comando `untellrat' que pega kernels (núcleos) e remove
3355
propriedades `tellrat'.
3357
Quando fazemos `tellrat' em um polinômio de várias variáveis,
3358
e.g., `tellrat (x^2 - y^2)', pode existir uma ambigüidade como para
3359
ou substituir `<y>^2' por `<x>^2' ou vice-versa. Maxima seleciona
3360
uma ordenação particular, mas se o usuário desejar especificar
3361
qual e.g. `tellrat (y^2 = x^2)' forneçe uma sintaxe que diga para
3362
substituir `<y>^2' por `<x>^2'.
3366
(%i1) 10*(%i + 1)/(%i + 3^(1/3));
3371
(%i2) ev (ratdisrep (rat(%)), algebraic);
3373
(%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2
3374
(%i3) tellrat (1 + a + a^2);
3377
(%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
3379
(%o4) ------------- + -----------------
3380
sqrt(2) a - 1 sqrt(3) + sqrt(2)
3381
(%i5) ev (ratdisrep (rat(%)), algebraic);
3382
(7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
3383
(%o5) ----------------------------------------------
3385
(%i6) tellrat (y^2 = x^2);
3387
(%o6) [y - x , a + a + 1]
3390
-- Função: totaldisrep (<expr>)
3391
Converte toda subexpressão de <expr> da forma de expressão
3392
racionais canônicas (CRE) para a forma geral e retorna o resultado.
3393
Se <expr> é em sí mesma na forma CRE então `totaldisrep' é
3394
identica a `ratdisrep'.
3396
`totaldisrep' pode ser usada para fazer um `ratdisrep' em
3397
expressões tais como equações, listas, matrizes, etc., que tiverem
3398
algumas subexpressões na forma CRE.
3401
-- Função: untellrat (<x_1>, ..., <x_n>)
3402
Remove propriedades `tellrat' de <x_1>, ..., <x_n>.
3406
File: maxima.info, Node: Constantes, Next: Logarítmos, Prev: Polinômios, Up: Top
3413
* Definições para Constantes::
3416
File: maxima.info, Node: Definições para Constantes, Prev: Constantes, Up: Constantes
3418
13.1 Definições para Constantes
3419
===============================
3422
- A base dos logarítmos naturais, e, é representada no Maxima como
3427
- a contante Booleana, falso. (NIL em Lisp)
3431
- infinito positivo real.
3434
-- Constante: infinity
3435
- infinito complexo.
3439
- menos infinito real.
3443
- "pi" é representado no Maxima como `%pi'.
3447
- a constante Booleana, verdadeiro. (T em Lisp)
3451
File: maxima.info, Node: Logarítmos, Next: Trigonometria, Prev: Constantes, Up: Top
3458
* Definições para Logarítmos::
3461
File: maxima.info, Node: Definições para Logarítmos, Prev: Logarítmos, Up: Logarítmos
3463
14.1 Definições para Logarítmos
3464
===============================
3466
-- Variável de opção: %e_to_numlog
3467
Valor padrão: `false'
3469
Quando `true', sendo `r' algum número racional, e `x' alguma
3470
expressão, `%e^(r*log(x))' irá ser simplificado em `x^r' .
3471
Note-se que o comando `radcan' também faz essa transformação, e
3472
transformações mais complicadas desse tipo também. O comando
3473
`logcontract' "contrai" expressões contendo `log'.
3476
-- Função: li [<s>] (<z>)
3477
Representa a função polilogarítmo de ordem <s> e argumento <z>,
3478
definida por meio de séries infinitas
3488
`li [1]' é `- log (1 - z)'. `li [2]' e `li [3]' são as funções
3489
dilogarítmo e trilogarítmo, respectivamente.
3491
Quando a ordem for 1, o polilogarítmo simplifica para `- log (1 -
3492
z)', o qual por sua vez simplifica para um valor numérico se <z>
3493
for um número em ponto flutuante real ou complexo ou o sinalizador
3494
de avaliação `numer' estiver presente.
3496
Quando a ordem for 2 ou 3, o polilogarítmo simplifica para um
3497
valor numérico se <z> for um número real em ponto flutuante ou o
3498
sinalizador de avaliação `numer' estiver presente.
3502
(%i1) assume (x > 0);
3504
(%i2) integrate ((log (1 - t)) / t, t, 0, x);
3510
(%i4) li [2] (7), numer;
3511
(%o4) 1.24827317833392 - 6.113257021832577 %i
3515
(%i6) li [2] (7), numer;
3516
(%o6) 1.24827317833392 - 6.113257021832577 %i
3517
(%i7) L : makelist (i / 4.0, i, 0, 8);
3518
(%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
3519
(%i8) map (lambda ([x], li [2] (x)), L);
3520
(%o8) [0, .2676526384986274, .5822405249432515,
3521
.9784693966661848, 1.64493407, 2.190177004178597
3522
- .7010261407036192 %i, 2.374395264042415
3523
- 1.273806203464065 %i, 2.448686757245154
3524
- 1.758084846201883 %i, 2.467401098097648
3525
- 2.177586087815347 %i]
3526
(%i9) map (lambda ([x], li [3] (x)), L);
3527
(%o9) [0, .2584613953442624, 0.537213192678042,
3528
.8444258046482203, 1.2020569, 1.642866878950322
3529
- .07821473130035025 %i, 2.060877505514697
3530
- .2582419849982037 %i, 2.433418896388322
3531
- .4919260182322965 %i, 2.762071904015935
3532
- .7546938285978846 %i]
3535
-- Função: log (<x>)
3536
Representa o logarítmo natural (base e) de <x>.
3538
Maxima não possui uma função interna para logarítmo de base 10 ou
3539
de outras bases. `log10(x) := log(x) / log(10)' é uma definição
3542
Simplificação e avaliação de logarítmos são governadas por muitos
3543
sinalizadores globais:
3545
`logexpand' - faz com que `log(a^b)' torne-se `b*log(a)'. Se
3546
`logexpand' for escolhida para `all', `log(a*b)' irá também
3547
simplificar para `log(a)+log(b)'. Se `logexpand' for escolhida
3548
para `super', então `log(a/b)' irá também simplificar para
3549
`log(a)-log(b)' para números racionais `a/b', `a#1'. (`log(1/b)',
3550
para `b' inteiro, sempre simplifica). Se `logexpand' for
3551
escolhida para `false', todas essas simplificações irão ser
3554
`logsimp' - se `false' então nenhuma simplificação de `%e' para um
3555
expoente contendo `log''s é concluída.
3557
`lognumer' - se `true' então argumentos negativos em ponto
3558
flutuante para `log' irá sempre ser convertido para seu valor
3559
absoluto antes que `log' seja tomado. Se `numer' for também
3560
`true', então argumentos negativos inteiros para `log' irão também
3561
ser convertidos para seu valor absoluto.
3563
`lognegint' - se `true' implementa a regra `log(-n)' ->
3564
`log(n)+%i*%pi' para `n' um inteiro positivo.
3566
`%e_to_numlog' - quando `true', `r' sendo algum número racional, e
3567
`x' alguma expressão, `%e^(r*log(x))' irá ser simplificado em
3568
`x^r' . Note-se que o comando `radcan' também faz essa
3569
transformação, e transformações mais complicadas desse tipo também.
3570
O comando `logcontract' "contrai" expressões contendo `log'.
3573
-- Variável de opção: logabs
3574
Valor padrão: `false'
3576
Quando fazendo integração indefinida onde logs são gerados, e.g.
3577
`integrate(1/x,x)', a resposta é dada em termos de `log(abs(...))'
3578
se `logabs' for `true', mas em termos de `log(...)' se `logabs'
3579
for `false'. Para integração definida, a escolha `logabs:true' é
3580
usada, porque aqui "avaliação" de integral indefinida nos extremos
3581
é muitas vezes necessária.
3584
-- Variável de opção: logarc
3585
-- Função: logarc (<expr>)
3586
Se `true' irá fazer com que as funções circularee inversas e
3587
hiperbólicas sejam convertidas em formas logarítimicas.
3588
`logarc(<exp>)' irá fazer com que essa conversão para uma expressão
3589
particular <exp> sem escolher o comutador ou tendo que re-avaliar
3590
a expressão com `ev'.
3592
Quando a variável global `logarc' for `true', funções circulares
3593
inversas e funções hiperbólicas são substituídas por suas funções
3594
logarítmicas equivalentes. O valor padrão de `logarc' é `false'.
3596
A função `logarc(<expr>)' realiza aquela substituíção para uma
3597
expressão <expr> sem modificar o valor da variável global `logarc'.
3600
-- Variável de opção: logconcoeffp
3601
Valor padrão: `false'
3603
Controla quais coeficientes são contraídos quando usando
3604
`logcontract'. Pode ser escolhida para o nome de uma função
3605
predicado de um argumento. E.g. se você gosta de gerar raízes
3606
quadradas, você pode fazer `logconcoeffp:'logconfun$
3607
logconfun(m):=featurep(m,integer) ou ratnump(m)$' . Então
3608
`logcontract(1/2*log(x));' irá fornecer `log(sqrt(x))'.
3611
-- Função: logcontract (<expr>)
3612
Recursivamente examina a expressão <expr>, transformando
3613
subexpressões da forma `a1*log(b1) + a2*log(b2) + c' em
3614
`log(ratsimp(b1^a1 * b2^a2)) + c'
3616
(%i1) 2*(a*log(x) + 2*a*log(y))$
3617
(%i2) logcontract(%);
3621
Se você faz `declare(n,integer);' então
3622
`logcontract(2*a*n*log(x));' fornece `a*log(x^(2*n))'. Os
3623
coeficientes que "contraem" dessa maneira são aqueles tais que 2 e
3624
`n' que satisfazem `featurep(coeff,integer)'. O usuário pode
3625
controlar quais coeficientes são contraídos escolhendo a opção
3626
`logconcoeffp' para o nome de uma função predicado de um
3627
argumento. E.g. se você gosta de gerara raízes quadradas, você
3628
pode fazer `logconcoeffp:'logconfun$
3629
logconfun(m):=featurep(m,integer) ou ratnump(m)$' . então
3630
`logcontract(1/2*log(x));' irá fornecer `log(sqrt(x))'.
3633
-- Variável de opção: logexpand
3634
Valor padrão: `true'
3636
Faz com que `log(a^b)' torne-se `b*log(a)'. Se for escolhida para
3637
`all', `log(a*b)' irá também simplificar para `log(a)+log(b)'. Se
3638
for escolhida para `super', então `log(a/b)' irá também
3639
simplificar para `log(a)-log(b)' para números racionais `a/b',
3640
`a#1'. (`log(1/b)', para `b' inteiro, sempre simplifica). Se for
3641
escolhida para `false', todas essas simplificações irão ser
3645
-- Variável de opção: lognegint
3646
Valor padrão: `false'
3648
Se `true' implementa a regra `log(-n)' -> `log(n)+%i*%pi' para `n'
3649
um inteiro positivo.
3652
-- Variável de opção: lognumer
3653
Valor padrão: `false'
3655
Se `true' então argumentos negativos em ponto flutuante para `log'
3656
irão sempre ser convertidos para seus valores absolutos antes que
3657
o `log' seja tomado. Se `numer' for também `true', então
3658
argumentos inteiros negativos para `log' irão também ser
3659
convertidos para seus valores absolutos.
3662
-- Variável de opção: logsimp
3663
Valor padrão: `true'
3665
Se `false' então nenhuma simplificação de `%e' para um expoente
3666
contendo `log''s é concluída.
3669
-- Função: plog (<x>)
3670
Representa o principal ramo logarítmos naturais avaliados para
3671
complexos com `-%pi' < `carg(<x>)' <= `+%pi' .
3675
File: maxima.info, Node: Trigonometria, Next: Funções Especiais, Prev: Logarítmos, Up: Top
3682
* Introdução ao Pacote Trigonométrico::
3683
* Definições para Trigonometria::
3686
File: maxima.info, Node: Introdução ao Pacote Trigonométrico, Next: Definições para Trigonometria, Prev: Trigonometria, Up: Trigonometria
3688
15.1 Introdução ao Pacote Trigonométrico
3689
========================================
3691
Maxima tem muitas funções trigonométricas definidas. Não todas as
3692
identidades trigonometricas estão programadas, mas isso é possível para
3693
o usuário adicionar muitas delas usando a compatibilidade de
3694
correspondência de modelos do sistema. As funções trigonométricas
3695
definidas no Maxima são: `acos', `acosh', `acot', `acoth', `acsc',
3696
`acsch', `asec', `asech', `asin', `asinh', `atan', `atanh', `cos',
3697
`cosh', `cot', `coth', `csc', `csch', `sec', `sech', `sin', `sinh',
3698
`tan', e `tanh'. Existe uma coleção de comandos especialmente para
3699
manusear funções trigonométricas, veja `trigexpand', `trigreduce', e o
3700
comutador `trigsign'. Dois pacotes compartilhados extendem as regras
3701
de simplificação construídas no Maxima, `ntrig' e `atrig1'. Faça
3702
`describe(<comando>)' para detalhes.
3705
File: maxima.info, Node: Definições para Trigonometria, Prev: Introdução ao Pacote Trigonométrico, Up: Trigonometria
3707
15.2 Definições para Trigonometria
3708
==================================
3710
-- Função: acos (<x>)
3714
-- Função: acosh (<x>)
3715
- Arco Cosseno Hiperbólico.
3718
-- Função: acot (<x>)
3722
-- Função: acoth (<x>)
3723
- Arco Cotangente Hiperbólico.
3726
-- Função: acsc (<x>)
3730
-- Função: acsch (<x>)
3731
- Arco Cossecante Hiperbólico.
3734
-- Função: asec (<x>)
3738
-- Função: asech (<x>)
3739
- Arco Secante Hiperbólico.
3742
-- Função: asin (<x>)
3746
-- Função: asinh (<x>)
3747
- Arco Seno Hiperbólico.
3750
-- Função: atan (<x>)
3754
-- Função: atan2 (<y>, <x>)
3755
- retorna o valor de `atan(<y>/<x>)' no intervalo de `-%pi' a
3759
-- Função: atanh (<x>)
3760
- Arco tangente Hiperbólico.
3764
O pacote `atrig1' contém muitas regras adicionais de simplificação
3765
para funções trigonométricas inversas. Junto com regras já
3766
conhecidas para Maxima, os seguintes ângulos estão completamente
3767
implementados: `0', `%pi/6', `%pi/4', `%pi/3', and `%pi/2'. Os
3768
ângulos correspondentes nos outros três quadrantes estão também
3769
disponíveis. Faça `load(atrig1);' para usá-lo.
3772
-- Função: cos (<x>)
3776
-- Função: cosh (<x>)
3777
- Cosseno hiperbólico.
3780
-- Função: cot (<x>)
3784
-- Função: coth (<x>)
3785
- Cotangente Hyperbólica.
3788
-- Função: csc (<x>)
3792
-- Função: csch (<x>)
3793
- Cossecante Hyperbólica.
3796
-- Variável de opção: halfangles
3797
Default value: `false'
3799
Quando `halfangles' for `true', meios-ângulos são simplificados
3804
O pacote `ntrig' contém um conjunto de regras de simplificação que
3805
são usadas para simplificar função trigonométrica cujos argumentos
3806
estão na forma `<f>(<n> %pi/10)' onde <f> é qualquer das funções
3807
`sin', `cos', `tan', `csc', `sec' e `cot'.
3810
-- Função: sec (<x>)
3814
-- Função: sech (<x>)
3815
- Secante Hyperbólica.
3818
-- Função: sin (<x>)
3822
-- Função: sinh (<x>)
3826
-- Função: tan (<x>)
3830
-- Função: tanh (<x>)
3831
- Tangente Hyperbólica.
3834
-- Função: trigexpand (<expr>)
3835
Expande funções trigonometricas e hyperbólicas de adições de
3836
ângulos e de ângulos multiplos que ocorram em <expr>. Para
3837
melhores resultados, <expr> deve ser expandida. Para intensificar
3838
o controle do usuário na simplificação, essa função expande
3839
somente um nível de cada vez, expandindo adições de ângulos ou
3840
ângulos multiplos. Para obter expansão completa dentro de senos e
3841
cossenos imediatamente, escolha o comutador `trigexpand: true'.
3843
`trigexpand' é governada pelos seguintes sinalizadores globais:
3846
Se `true' causa expansão de todas as expressões contendo
3847
senos e cossenos ocorrendo subseqüêntemente.
3850
Se `true' faz com que meios-ângulos sejam simplificados
3854
Controla a regra "soma" para `trigexpand', expansão de
3855
adições (e.g. `sin(x + y)') terão lugar somente se
3856
`trigexpandplus' for `true'.
3859
Controla a regra "produto" para `trigexpand', expansão de
3860
produtos (e.g. `sin(2 x)') terão lugar somente se
3861
`trigexpandtimes' for `true'.
3865
(%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
3867
(%o1) - sin (x) + 3 cos (x) + x
3868
(%i2) trigexpand(sin(10*x+y));
3869
(%o2) cos(10 x) sin(y) + sin(10 x) cos(y)
3872
-- Variável de opção: trigexpandplus
3873
Valor padrão: `true'
3875
`trigexpandplus' controla a regra da "soma" para `trigexpand'.
3876
Dessa forma, quando o comando `trigexpand' for usado ou o
3877
comutador `trigexpand' escolhido para `true', expansão de adições
3878
(e.g. `sin(x+y))' terão lugar somente se `trigexpandplus' for
3882
-- Variável de opção: trigexpandtimes
3883
Valor padrão: `true'
3885
`trigexpandtimes' controla a regra "produto" para `trigexpand'.
3886
Dessa forma, quando o comando `trigexpand' for usado ou o
3887
comutador `trigexpand' escolhido para `true', expansão de produtos
3888
(e.g. `sin(2*x)') terão lugar somente se `trigexpandtimes' for
3892
-- Variável de opção: triginverses
3895
`triginverses' controla a simplificação de composições de funções
3896
trigonométricas e hiperbólicas com suas funções inversas.
3898
Se `all', ambas e.g. `atan(tan(<x>))' e `tan(atan(<x>))'
3899
simplificarão para <x>.
3901
Se `true', a simplificação de `<arcfun>(<fun>(<x>))' é
3904
Se `false', ambas as simplificações `<arcfun>(<fun>(<x>))' e
3905
`<fun>(<arcfun>(<x>))' são desabilitadas.
3908
-- Função: trigreduce (<expr>, <x>)
3909
-- Função: trigreduce (<expr>)
3910
Combina produtos e expoentes de senos e cossenso trigonométricos e
3911
hiperbólicos de <x> dentro daqueles de múltiplos de <x>. Também
3912
tenta eliminar essas funções quando elas ocorrerem em
3913
denominadores. Se <x> for omitido então todas as variáveis em
3916
Veja também `poissimp'.
3918
(%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
3919
cos(2 x) cos(2 x) 1 1
3920
(%o1) -------- + 3 (-------- + -) + x - -
3923
As rotinas de simplificação trigonométrica irão usar informações
3924
declaradas em alguns casos simples. Declarações sobre variáveis
3925
são usadas como segue, e.g.
3927
(%i1) declare(j, integer, e, even, o, odd)$
3928
(%i2) sin(x + (e + 1/2)*%pi);
3930
(%i3) sin(x + (o + 1/2)*%pi);
3934
-- Variável de opção: trigsign
3935
Valor padrão: `true'
3937
Quando `trigsign' for `true', permite simplificação de argumentos
3938
negativos para funções trigonométricas. E.g., `sin(-x)'
3939
transformar-se-á em `-sin(x)' somente se `trigsign' for `true'.
3942
-- Função: trigsimp (<expr>)
3943
Utiliza as identidades sin(x)^2 + cos(x)^2 = 1 and cosh(x)^2 -
3944
sinh(x)^2 = 1 para simplificar expressões contendo `tan', `sec',
3945
etc., para `sin', `cos', `sinh', `cosh'.
3947
`trigreduce', `ratsimp', e `radcan' podem estar habilitadas a
3948
adicionar simplificações ao resultado.
3950
`demo ("trgsmp.dem")' mostra alguns exemplos de `trigsimp'.
3953
-- Função: trigrat (<expr>)
3954
Fornece uma forma quase-linear simplificada canônica de uma
3955
expressão trigonométrica; <expr> é uma fração racional de muitos
3956
`sin', `cos' ou `tan', os argumentos delas são formas lineares em
3957
algumas variáveis (ou kernels-núcleos) e `%pi/<n>' (<n> inteiro)
3958
com coeficientes inteiros. O resultado é uma fração simplificada
3959
com numerador e denominador ambos lineares em `sin' e `cos'.
3960
Dessa forma `trigrat' lineariza sempre quando isso for passível.
3962
(%i1) trigrat(sin(3*a)/sin(a+%pi/3));
3963
(%o1) sqrt(3) sin(2 a) + cos(2 a) - 1
3965
O seguinte exemplo encontra-se em Davenport, Siret, and Tournier,
3966
Calcul Formel, Masson (ou em inglês, Addison-Wesley), seção 1.5.5,
3969
(%i1) c: %pi/3 - a - b;
3973
(%i2) bc: sin(a)*sin(3*c)/sin(a+b);
3974
sin(a) sin(3 b + 3 a)
3975
(%o2) ---------------------
3977
(%i3) ba: bc, c=a, a=c$
3978
(%i4) ac2: ba^2 + bc^2 - 2*bc*ba*cos(b);
3980
sin (a) sin (3 b + 3 a)
3981
(%o4) -----------------------
3986
2 sin(a) sin(3 a) cos(b) sin(b + a - ---) sin(3 b + 3 a)
3988
- --------------------------------------------------------
3990
sin(a - ---) sin(b + a)
3994
sin (3 a) sin (b + a - ---)
3996
+ ---------------------------
4000
(%i5) trigrat (ac2);
4001
(%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
4003
- 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
4005
- 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
4007
+ 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
4009
+ sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
4011
+ sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
4017
File: maxima.info, Node: Funções Especiais, Next: Funções Elípticas, Prev: Trigonometria, Up: Top
4019
16 Funções Especiais
4020
********************
4024
* Introdução a Funções Especiais::
4026
* Definições para Funções Especiais::
4029
File: maxima.info, Node: Introdução a Funções Especiais, Next: specint, Prev: Funções Especiais, Up: Funções Especiais
4031
16.1 Introdução a Funções Especiais
4032
===================================
4035
File: maxima.info, Node: specint, Next: Definições para Funções Especiais, Prev: Introdução a Funções Especiais, Up: Funções Especiais
4040
`hypgeo' é um pacote para manusear transformações de Laplace de
4041
funções especiais. `hyp' é um pacote para manusear funções
4042
Hipergeométricas generalizadas.
4044
`specint' tenta calcular a integral definida (sobre o intervalo de
4045
zero a infinito) de uma expressão contendo funções especiais. Quando o
4046
integrando contém um fator `exp (-s t)', o resultado é uma
4047
transformação de Laplace.
4049
A sintaxe é como segue:
4051
specint (exp (-s*<t>) * <expr>, <t>);
4053
onde <t> é a variável de integração e <expr> é uma expressão
4054
contendo funções especiais.
4056
Se `specint' não puder calcular a integral, o valor de retorno pode
4057
conter vários símbolos Lisp, incluindo `other-defint-to-follow-negtest',
4058
`other-lt-exponential-to-follow', `product-of-y-with-nofract-indices',
4059
etc.; isso é um bug.
4061
A notação de função especial segue adiante:
4063
bessel_j (index, expr) Função de Bessel, primeiro tipo
4064
bessel_y (index, expr) Função de Bessel, segundo tipo
4065
bessel_i (index, expr) Função de Bessel modificada, primeiro tipo
4066
bessel_k (index, expr) Função de Bessel modificada, segundo tipo
4067
%he[n] (z) Polinômio de Hermite (Note bem: `he', não `h'. Veja A&S 22.5.18)
4068
%p[u,v] (z) Função de Legendre
4069
%q[u,v] (z) Função de Legendre, segundo tipo
4070
hstruve[n] (z) Função H de Struve H
4071
lstruve[n] (z) Função de L Struve
4072
%f[p,q] ([], [], expr) Função Hipergeométrica Generalizada
4073
gamma() Função Gamma
4074
gammagreek(a,z) Função gama incompleta
4075
gammaincomplete(a,z) Final da função gama incompleta
4077
%m[u,k] (z) Função de Whittaker, primeiro tipo
4078
%w[u,k] (z) Função de Whittaker, segundo tipo
4079
erfc (z) Complemento da função erf (função de erros - integral da distribuição normal)
4080
ei (z) Integral de exponencial (?)
4081
kelliptic (z) integral eliptica completa de primeiro tipo (K)
4082
%d [n] (z) Função cilíndrica parabólica
4084
`demo ("hypgeo")' mostra muitos exemplos de transformações de
4085
Laplace calculadas através de `specint'.
4087
Esse é um trabalho em andamento. Alguns nomes de funções podem
4091
File: maxima.info, Node: Definições para Funções Especiais, Prev: specint, Up: Funções Especiais
4093
16.3 Definições para Funções Especiais
4094
======================================
4096
-- Função: airy (<x>)
4097
A função de Airy Ai. Se o argumento <x> for um número, o valor
4098
numérico de `airy (<x>)' é retornado. de outra forma, uma
4099
expressão não avaliada `airy (<x>)' é retornada.
4101
A equação de Airy `diff (y(x), x, 2) - x y(x) = 0' tem duas
4102
soluções linearmente independentes, chamadas `ai' e `bi'. Essa
4103
equação é muito popular como uma aproximação para problemas mais
4104
complicados em muitos ambientes de física matemática.
4106
`load ("airy")' chama as funções `ai', `bi', `dai', e `dbi'.
4108
O pacote `airy' contém rotinas para calcular `ai' e `bi' e suas
4109
derivadas `dai' e `dbi'. O resultado é um número em ponto
4110
flutuante se o argumento for um número, e uma expressão não
4111
avaliada de outra forma.
4113
Um erro ocorre se o argumento for maior que o esperado causando um
4114
estouro nas exponenciais, ou uma perda de precisão no `sin' ou no
4115
`cos'. Isso faz o intervalo de validade sobre -2800 a 10^38 para
4116
`ai' e `dai', e de -2800 a 25 para `bi' e `dbi'.
4118
Essas regras de derivação são conhecidas para Maxima:
4119
* `diff (ai(x), x)' retorna `dai(x)',
4121
* `diff (dai(x), x)' retorna `x ai(x)',
4123
* `diff (bi(x), x)' retorna `dbi(x)',
4125
* `diff (dbi(x), x)' retorna `x bi(x)'.
4127
Valores de função são calculados a partir das séries de Taylor
4128
convergentes para `abs(<x>) < 3', e a partir de expansões
4129
assintóticas para `<x> < -3' ou `<x> > 3' como necessário. Esses
4130
resultados somente apresentam discrepâncias numéricas muito
4131
pequenas em `<x> = 3' e `<x> = -3'. Para detalhes, veja
4132
Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão
4133
10.4 e Tabela 10.11.
4135
`ev (taylor (ai(x), x, 0, 9), infeval)' retorna uma expansão de
4136
Taylor em ponto flutuante da função `ai'. Uma expressão similar
4137
pode ser construída para `bi'.
4140
-- Função: airy_ai (<x>)
4141
A função de Airy Ai, como definida em Abramowitz e Stegun,
4142
Handbook of Mathematical Functions, Sessão 10.4.
4144
A equação de Airy `diff (y(x), x, 2) - x y(x) = 0' tem duas
4145
soluções linearmente independentes, `y = Ai(x)' e `y = Bi(x)'. A
4146
derivada de `diff (airy_ai(x), x)' é `airy_dai(x)'.
4148
Se o argumento `x' for um número real ou um número complexo
4149
qualquer deles em ponto flutuante , o valor numérico de `airy_ai'
4150
é retornado quando possível.
4152
Veja também `airy_bi', `airy_dai', `airy_dbi'.
4154
-- Função: airy_dai (<x>)
4155
A derivada da função de Airy Ai `airy_ai(x)'.
4159
-- Função: airy_bi (<x>)
4160
A função de Airy Bi, como definida em Abramowitz e Stegun,
4161
Handbook of Mathematical Functions, Sessão 10.4, é a segunda
4162
solução da equação de Airy `diff (y(x), x, 2) - x y(x) = 0'.
4164
Se o argumento `x' for um número real ou um número complexo
4165
qualquer deles em ponto flutuante, o valor numérico de `airy_bi' é
4166
retornado quando possível. Em outros casos a expressão não
4167
avaliada é retornada.
4169
A derivada de `diff (airy_bi(x), x)' é `airy_dbi(x)'.
4171
Veja `airy_ai', `airy_dbi'.
4173
-- Função: airy_dbi (<x>)
4174
A derivada de função de Airy Bi `airy_bi(x)'.
4176
Veja `airy_ai' e `airy_bi'.
4179
`asympa' é um pacote para análise assintótica. O pacote contém
4180
funções de simplificação para análise assintótica, incluindo as
4181
funções "grande O" e "pequeno o" que são largamente usadas em
4182
análises de complexidade e análise numérica.
4184
`load ("asympa")' chama esse pacote.
4187
-- Função: bessel (<z>, <a>)
4188
A função de Bessel de primeiro tipo.
4190
Essa função está desatualizada. Escreva `bessel_j (<z>, <a>)' em
4194
-- Função: bessel_j (<v>, <z>)
4195
A função de Bessel do primeiro tipo de ordem v e argumento z.
4197
`bessel_j' calcula o array `besselarray' tal que `besselarray [i]
4198
= bessel_j [i + v - int(v)] (z)' para `i' de zero a `int(v)'.
4200
`bessel_j' é definida como
4202
==== k - v - 2 k v + 2 k
4204
> --------------------------
4205
/ k! gamma(v + k + 1)
4209
todavia séries infinitas não são usadas nos cálculos.
4212
-- Função: bessel_y (<v>, <z>)
4213
A função de Bessel do segundo tipo de ordem v e argumento z.
4215
`bessel_y' calcula o array `besselarray' tal que `besselarray [i]
4216
= bessel_y [i + v - int(v)] (z)' para `i' de zero a `int(v)'.
4218
`bessel_y' é definida como
4219
cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
4220
-------------------------------------------
4223
quando v não for um inteiro. Quando v for um inteiro n, o limite
4224
com v aprocimando-se de n é tomado.
4227
-- Função: bessel_i (<v>, <z>)
4228
A função de Bessel modificada de primeiro tipo de ordem v e
4231
`bessel_i' calcula o array `besselarray' tal que `besselarray [i]
4232
= bessel_i [i + v - int(v)] (z)' para `i' de zero a `int(v)'.
4234
`bessel_i' é definida como
4236
==== - v - 2 k v + 2 k
4238
> -------------------
4239
/ k! gamma(v + k + 1)
4243
todavia séries infinitas não são usadas nos cálculos.
4246
-- Função: bessel_k (<v>, <z>)
4247
A função de Bessel modificada de segundo tipo de ordem v e
4250
`bessel_k' calcula o array `besselarray' tal que `besselarray [i]
4251
= bessel_k [i + v - int(v)] (z)' para `i' de zero a `int(v)'.
4253
`bessel_k' é definida como
4254
%pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
4255
-------------------------------------------------
4258
quando v não for inteiro. Se v for um inteiro n, então o limite
4259
com v aproximando-se de n é tomado.
4262
-- Variável de opção: besselexpand
4263
Valor padrão: `false'
4265
Expansões de controle de funções de Bessel quando a ordem for a
4266
metade de um inteiro ímpar. Nesse caso, as funções de Bessel
4267
podem ser expandidas em termos de outras funções elementares.
4268
Quando `besselexpand' for `true', a função de Bessel é expandida.
4270
(%i1) besselexpand: false$
4271
(%i2) bessel_j (3/2, z);
4273
(%o2) bessel_j(-, z)
4275
(%i3) besselexpand: true$
4276
(%i4) bessel_j (3/2, z);
4278
(%o4) sqrt(---) (------ - ------)
4283
A função de Bessel de primeiro tipo de ordem 0.
4285
Essa função está desatualizada. Escreva `bessel_j (0, <x>)' em
4290
A função de Bessel de primeiro tipo de ordem 1.
4292
Essa função está desatualizada. Escreva `bessel_j (1, <x>)' em
4296
-- Função: jn (<x>, <n>)
4297
A função de Bessel de primeiro tipo de ordem <n>.
4299
Essa função éstá desatualizada. Escreva `bessel_j (<n>, <x>)' em
4304
A função de Bessel modificada de primeiro tipo de ordem 0.
4306
Essa função éstá desatualizada. Escreva `bessel_i (0, <x>)' em
4311
A função de Bessel modificada de primeiro tipo de ordem 1.
4313
Essa função está desatualizada. Escreva `bessel_i (1, `x')' em
4317
-- Função: beta (<x>, <y>)
4318
A função beta, definida como `gamma(x) gamma(y)/gamma(x + y)'.
4321
-- Função: gamma (<x>)
4324
Veja também `makegamma'.
4326
A variável `gammalim' controla a simplificação da função gama.
4328
A constante de Euler-Mascheroni é `%gamma'.
4331
-- Variável de opção: gammalim
4332
Valor padrão: 1000000
4334
`gammalim' controla a simplificação da função gama para integral e
4335
argumentos na forma de números racionais. Se o valor absoluto do
4336
argumento não for maior que `gammalim', então a simplificação
4337
ocorrerá. Note que `factlim' comuta controle de simplificaçcão do
4338
resultado de `gamma' de um argumento inteiro também.
4341
-- Função: intopois (<a>)
4342
Converte <a> em um código de Poisson.
4345
-- Função: makefact (<expr>)
4346
Transforma instâncias de funções binomiais, gama, e beta em <expr>
4349
Veja também `makegamma'.
4352
-- Função: makegamma (<expr>)
4353
Transforma instâncias de funções binomiais, fatorial, e beta em
4354
<expr> para funções gama.
4356
Veja também `makefact'.
4359
-- Função: numfactor (<expr>)
4360
Retorna o fator numérico multiplicando a expressão <expr>, que
4361
pode ser um termo simples.
4363
`content' retorna o máximo divisor comum (mdc) de todos os termos
4370
(%i2) numfactor (%);
4376
-- Função: outofpois (<a>)
4377
Converte <a> de um código de Poisson para uma representação geral.
4378
Se <a> não for uma forma de Poisson, `outofpois' realiza a
4379
conversão, i.e., o valor de retorno é `outofpois (intopois (<a>))'.
4380
Essa função é desse modo um simplificador canônico para adições e
4381
potências de termos de seno e cosseno de um tipo particular.
4384
-- Função: poisdiff (<a>, <b>)
4385
Deriva <a> com relação a <b>. <b> deve ocorrer somente nos
4386
argumentos trigonométricos ou somente nos coeficientes.
4389
-- Função: poisexpt (<a>, <b>)
4390
Funcionalmente identica a `intopois (<a>^<b>)'. <b> deve ser um
4394
-- Função: poisint (<a>, <b>)
4395
Integra em um senso restrito similarmente (para `poisdiff').
4396
Termos não periódicos em <b> são diminuídos se <b> estiver em
4397
argumentos trigonométricos.
4400
-- Variável de opção: poislim
4403
`poislim' determina o domínio dos coeficientes nos argumentos de
4404
funções trigonométricas. O valor inicial de 5 corresponde ao
4405
intervalo [-2^(5-1)+1,2^(5-1)], ou [-15,16], mas isso pode ser
4406
alterado para [-2^(n-1)+1, 2^(n-1)].
4409
-- Função: poismap (<series>, <sinfn>, <cosfn>)
4410
mapeará as funções <sinfn> sobre os termos de seno e <cosfn>
4411
ssobre os termos de cosseno das séries de Poisson dadas. <sinfn>
4412
e <cosfn> são funções de dois argumentos que são um coeficiente e
4413
uma parte trigonométrica de um termo em séries respectivamente.
4416
-- Função: poisplus (<a>, <b>)
4417
É funcionalmente identica a `intopois (a + b)'.
4420
-- Função: poissimp (<a>)
4421
Converte <a> em séries de Poisson para <a> em representação geral.
4424
-- Símbolo especial: poisson
4425
O símbolo `/P/' segue o rótulo de linha de uma expressão contendo
4429
-- Função: poissubst (<a>, <b>, <c>)
4430
Substitue <a> por <b> em <c>. <c> é uma série de Poisson.
4432
(1) Quando <B> é uma variável <u>, <v>, <w>, <x>, <y>, ou <z>,
4433
então <a> deve ser uma expressão linear nessas variáveis (e.g.,
4436
(2) Quando <b> for outra que não essas variáveis, então <a> deve
4437
também ser livre dessas variáveis, e alé disso, livre de senos ou
4440
`poissubst (<a>, <b>, <c>, <d>, <n>)' é um tipo especial d
4441
substituição que opera sobre <a> e <b> como no tipo (1) acima, mas
4442
onde <d> é uma série de Poisson, expande `cos(<d>)' e `sin(<d>)'
4443
para a ordem <n> como provendo o resultado da substituição `<a> +
4444
<d>' por <b> em <c>. A idéia é que <d> é uma expansão em termos
4445
de um pequeno parâmetro. Por exemplo, `poissubst (u, v, cos(v),
4446
%e, 3)' retorna `cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)'.
4449
-- Função: poistimes (<a>, <b>)
4450
É funcionalmente idêntica a `intopois (<a>*<b>)'.
4453
-- Função: poistrim ()
4454
é um nome de função reservado que (se o usuário tiver definido uma
4455
função com esse nome) é aplicada durante multiplicação de Poisson.
4456
Isso é uma função predicada de 6 argumentos que são os
4457
coeficientes de <u>, <v>, ..., <z> em um termo. Termos para os
4458
quais `poistrim' for `true' (para os coeficientes daquele termo)
4459
são eliminados durante a multiplicação.
4462
-- Função: printpois (<a>)
4463
Mostra uma série de Poisson em um formato legível. Em comum com
4464
`outofpois', essa função converterá <a> em um código de Poisson
4465
primeiro, se necessário.
4468
-- Função: psi [<n>](<x>)
4469
A derivada de `log (gamma (<x>))' de ordem `<n>+1'. Dessa forma,
4470
`psi[0](<x>)' é a primeira derivada, `psi[1](<x>)' é a segunda
4473
Maxima não sabe como, em geral, calcular um valor numérico de
4474
`psi', mas Maxima pode calcular alguns valores exatos para
4475
argumentos racionais. Muitas variáveis controlam qual intervalo
4476
de argumentos racionais `psi' irá retornar um valor exato, se
4477
possível. Veja `maxpsiposint', `maxpsinegint', `maxpsifracnum', e
4478
`maxpsifracnum'. Isto é, <x> deve localizar-se entre
4479
`maxpsinegint' e `maxpsiposint'. Se o valor absoluto da parte
4480
facionária de <x> for racional e tiver um numerador menor que
4481
`maxpsifracnum' e tiver um denominador menor que
4482
`maxpsifracdenom', `psi' irá retornar um valor exato.
4484
A função `bfpsi' no pacote `bffac' pode calcular valores numéricos.
4487
-- Variável de opção: maxpsiposint
4490
`maxpsiposint' é o maior valor positivo para o qual `psi[n](x)'
4491
irá tentar calcular um valor exato.
4494
-- Variável de opção: maxpsinegint
4497
`maxpsinegint' é o valor mais negativo para o qual `psi[n](x)' irá
4498
tentar calcular um valor exato. Isto é, se <x> for menor que
4499
`maxnegint', `psi[n](<x>)' não irá retornar resposta simplificada,
4500
mesmo se isso for possível.
4503
-- Variável de opção: maxpsifracnum
4506
Tomemos <x> como sendo um número racional menor que a unidade e da
4507
forma `p/q'. Se `p' for menor que `maxpsifracnum', então
4508
`psi[<n>](<x>)' não irá tentar retornar um valor simplificado.
4511
-- Variável de opção: maxpsifracdenom
4514
Tomemos <x> como sendo um número racional menor que a unidade e da
4515
forma `p/q'. Se `q' for maior que `maxpsifracdeonm', então
4516
`psi[<n>](<x>)' não irá tentar retornar um valor simplificado.
4520
File: maxima.info, Node: Funções Elípticas, Next: Limites, Prev: Funções Especiais, Up: Top
4522
17 Funções Elípticas
4523
********************
4527
* Introdução a Funções Elípticas e Integrais::
4528
* Definições para Funções Elípticas::
4529
* Definições para Integrais Elípticas::
4532
File: maxima.info, Node: Introdução a Funções Elípticas e Integrais, Next: Definições para Funções Elípticas, Up: Top
4534
17.1 Introdução a Funções Elípticas e Integrais
4535
===============================================
4537
Maxima inclui suporte a funções elípticas Jacobianas e a integrais
4538
elípticas completas e incompletas. Isso inclui manipulação simbólica
4539
dessas funções e avaliação numérica também. Definições dessas
4540
funções e muitas de suas propriedades podem ser encontradas em
4541
Abramowitz e Stegun, Capítulos 16-17. Tanto quanto possível, usamos as
4542
definições e relações dadas aí.
4544
Em particular, todas as funções elípticas e integrais elípticas usam
4545
o parâmetro m em lugar de módulo k ou o ângulo modular \alpha. Isso é
4546
uma área onde discordamos de Abramowitz e Stegun que usam o ângulo
4547
modular para as funções elípticas. As seguintes relações são
4548
verdadeiras: m = k^2 e k = \sin(\alpha)
4550
As funções elípticas e integrais elípticas estão primariamente
4551
tencionando suportar computação simbólica. Portanto, a maiora das
4552
derivadas de funções e integrais são conhecidas. Todavia, se valores
4553
em ponto flutuante forem dados, um resultado em ponto flutuante é
4556
Suporte para a maioria de outras propriedades das funções elípticas e
4557
integrais elípticas além das derivadas não foram ainda escritas.
4559
Alguns exemplos de funções elípticas:
4561
(%i1) jacobi_sn (u, m);
4562
(%o1) jacobi_sn(u, m)
4563
(%i2) jacobi_sn (u, 1);
4565
(%i3) jacobi_sn (u, 0);
4567
(%i4) diff (jacobi_sn (u, m), u);
4568
(%o4) jacobi_cn(u, m) jacobi_dn(u, m)
4569
(%i5) diff (jacobi_sn (u, m), m);
4570
(%o5) jacobi_cn(u, m) jacobi_dn(u, m)
4572
elliptic_e(asin(jacobi_sn(u, m)), m)
4573
(u - ------------------------------------)/(2 m)
4577
jacobi_cn (u, m) jacobi_sn(u, m)
4578
+ --------------------------------
4581
Alguns exemplos de integrais elípticas:
4583
(%i1) elliptic_f (phi, m);
4584
(%o1) elliptic_f(phi, m)
4585
(%i2) elliptic_f (phi, 0);
4587
(%i3) elliptic_f (phi, 1);
4589
(%o3) log(tan(--- + ---))
4591
(%i4) elliptic_e (phi, 1);
4593
(%i5) elliptic_e (phi, 0);
4595
(%i6) elliptic_kc (1/2);
4597
(%o6) elliptic_kc(-)
4599
(%i7) makegamma (%);
4605
(%i8) diff (elliptic_f (phi, m), phi);
4607
(%o8) ---------------------
4609
sqrt(1 - m sin (phi))
4610
(%i9) diff (elliptic_f (phi, m), m);
4611
elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m)
4612
(%o9) (-----------------------------------------------
4616
- ---------------------)/(2 (1 - m))
4618
sqrt(1 - m sin (phi))
4620
Suporte a funções elípticas e integrais elípticas foi escrito por
4621
Raymond Toy. Foi colocado sob os termos da Licençã Pública Geral (GPL)
4622
que governa a distribuição do Maxima.
4625
File: maxima.info, Node: Definições para Funções Elípticas, Next: Definições para Integrais Elípticas, Prev: Introdução a Funções Elípticas e Integrais, Up: Top
4627
17.2 Definições para Funções Elípticas
4628
======================================
4630
-- Função: jacobi_sn (<u>, <m>)
4631
A Função elíptica Jacobiana sn(u,m).
4633
-- Função: jacobi_cn (<u>, <m>)
4634
A função elíptica Jacobiana cn(u,m).
4636
-- Função: jacobi_dn (<u>, <m>)
4637
A função elíptica Jacobiana dn(u,m).
4639
-- Função: jacobi_ns (<u>, <m>)
4640
A função elíptica Jacobiana ns(u,m) = 1/sn(u,m).
4642
-- Função: jacobi_sc (<u>, <m>)
4643
A função elíptica Jacobiana sc(u,m) = sn(u,m)/cn(u,m).
4645
-- Função: jacobi_sd (<u>, <m>)
4646
A função elíptica Jacobiana sd(u,m) = sn(u,m)/dn(u,m).
4648
-- Função: jacobi_nc (<u>, <m>)
4649
A função elíptica Jacobiana nc(u,m) = 1/cn(u,m).
4651
-- Função: jacobi_cs (<u>, <m>)
4652
A função elíptica Jacobiana cs(u,m) = cn(u,m)/sn(u,m).
4654
-- Função: jacobi_cd (<u>, <m>)
4655
A função elíptica Jacobiana cd(u,m) = cn(u,m)/dn(u,m).
4657
-- Função: jacobi_nd (<u>, <m>)
4658
A função elíptica Jacobiana nc(u,m) = 1/cn(u,m).
4660
-- Função: jacobi_ds (<u>, <m>)
4661
A função elíptica Jacobiana ds(u,m) = dn(u,m)/sn(u,m).
4663
-- Função: jacobi_dc (<u>, <m>)
4664
A função elíptica Jacobiana dc(u,m) = dn(u,m)/cn(u,m).
4666
-- Função: inverse_jacobi_sn (<u>, <m>)
4667
A inversa da função elíptica Jacobiana sn(u,m).
4669
-- Função: inverse_jacobi_cn (<u>, <m>)
4670
A inversa da função elíptica Jacobiana cn(u,m).
4672
-- Função: inverse_jacobi_dn (<u>, <m>)
4673
A inversa da função elíptica Jacobiana dn(u,m).
4675
-- Função: inverse_jacobi_ns (<u>, <m>)
4676
A inversa da função elíptica Jacobiana ns(u,m).
4678
-- Função: inverse_jacobi_sc (<u>, <m>)
4679
A inversa da função elíptica Jacobiana sc(u,m).
4681
-- Função: inverse_jacobi_sd (<u>, <m>)
4682
A inversa da função elíptica Jacobiana sd(u,m).
4684
-- Função: inverse_jacobi_nc (<u>, <m>)
4685
A inversa da função elíptica Jacobiana nc(u,m).
4687
-- Função: inverse_jacobi_cs (<u>, <m>)
4688
A inversa da função elíptica Jacobiana cs(u,m).
4690
-- Função: inverse_jacobi_cd (<u>, <m>)
4691
A inversa da função elíptica Jacobiana cd(u,m).
4693
-- Função: inverse_jacobi_nd (<u>, <m>)
4694
A inversa da função elíptica Jacobiana nc(u,m).
4696
-- Função: inverse_jacobi_ds (<u>, <m>)
4697
A inversa da função elíptica Jacobiana ds(u,m).
4699
-- Função: inverse_jacobi_dc (<u>, <m>)
4700
A inversa da função elíptica Jacobiana dc(u,m).
4703
File: maxima.info, Node: Definições para Integrais Elípticas, Prev: Definições para Funções Elípticas, Up: Top
4705
17.3 Definições para Integrais Elípticas
4706
========================================
4708
-- Função: elliptic_f (<phi>, <m>)
4709
A integral elíptica incompleta de primeiro tipo, definida como
4711
integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)
4713
Veja também *Note elliptic_e:: e *Note elliptic_kc::.
4716
-- Função: elliptic_e (<phi>, <m>)
4717
A integral elíptica incompleta de segundo tipo, definida como
4719
elliptic_e(u, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi) Veja
4720
também *Note elliptic_e:: and *Note elliptic_ec::.
4723
-- Função: elliptic_eu (<u>, <m>)
4724
A integral elíptica incompleta de segundo tipo, definida como
4725
integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2),
4730
Isso é relacionado a elliptic_e através de elliptic_eu(u, m) =
4731
elliptic_e(asin(sn(u,m)),m) Veja também *Note elliptic_e::.
4733
-- Função: elliptic_pi (<n>, <phi>, <m>)
4734
A integral elíptica incompleta de terceiro tipo, definida como
4736
integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)
4738
Somente a derivada em relação a phi é conhecida pelo Maxima.
4740
-- Função: elliptic_kc (<m>)
4741
A integral elíptica completa de primeiro tipo, definida como
4743
integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)
4745
Para certos valores de m, o valor da integral é conhecido em
4746
termos de funções Gamma. Use `makegamma' para avaliar esse valor.
4748
-- Função: elliptic_ec (<m>)
4749
A integral elíptica completa de sgundo tipo, definida como
4751
integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)
4753
Para certos valores de m, o valor da integral é conhecido em
4754
termos de funçõesvGamma. Use `makegamma' para avaliar esse valor.
4757
File: maxima.info, Node: Limites, Next: Diferenciação, Prev: Funções Elípticas, Up: Top
4764
* Definições para Limites::
4767
File: maxima.info, Node: Definições para Limites, Prev: Limites, Up: Limites
4769
18.1 Definições para Limites
4770
============================
4772
-- Variável de Opção: lhospitallim
4775
`lhospitallim' é o máximo número de vezes que a regra L'Hospital é
4776
usada em `limit'. Isso evita ciclos infinitos em casos como
4777
`limit (cot(x)/csc(x), x, 0)'.
4780
-- Função: limit (<expr>, <x>, <val>, <dir>)
4781
-- Função: limit (<expr>, <x>, <val>)
4782
-- Função: limit (<expr>)
4783
Calcula o limite de <expr> com a variável real <x> aproximando-se
4784
do valor <val> pela direção <dir>. <dir> pode ter o valor `plus'
4785
para um limite pela direita, `minus' para um limite pela esquerda,
4786
ou pode ser omitido (implicando em um limite em ambos os lados é
4787
para ser computado).
4789
`limit' usa os seguintes símbolos especiais: `inf' (infinito
4790
positivo) e `minf' (infinito negativo). Em saídas essa função
4791
pode também usar `und' (undefined - não definido), `ind'
4792
(indefinido mas associado) e `infinity' (infinito complexo).
4794
`lhospitallim' é o máximo número de vezes que a regra L'Hospital é
4795
usada em `limit'. Isso evita ciclos infinitos em casos como
4796
`limit (cot(x)/csc(x), x, 0)'.
4798
`tlimswitch' quando `true' fará o pacote `limit' usar série de
4799
Taylor quando possível.
4801
`limsubst' evita que `limit' tente substituições sobre formas
4802
desconhecidas. Isso é para evitar erros como `limit (f(n)/f(n+1),
4803
n, inf)' dando igual a 1. Escolhendo `limsubst' para `true'
4804
permitirá tais substituições.
4806
`limit' com um argumento é muitas vezes chamado em ocasiões para
4807
simplificar expressões de constantes, por exemplo, `limit (inf-1)'.
4809
`example (limit)' mostra alguns exemplos.
4811
Para saber sobre o método utilizado veja Wang, P., "Evaluation of
4812
Definite Integrals by Symbolic Manipulation", tese de Ph.D., MAC
4813
TR-92, Outubro de 1971.
4816
-- Variável de Opção: limsubst
4817
valor padrão: `false' - evita que `limit' tente substituições sobre
4818
formas desconhecidas. Isso é para evitar erros como `limit
4819
(f(n)/f(n+1), n, inf)' dando igual a 1. Escolhendo `limsubst'
4820
para `true' permitirá tais substituições.
4823
-- Função: tlimit (<expr>, <x>, <val>, <dir>)
4824
-- Função: tlimit (<expr>, <x>, <val>)
4825
-- Função: tlimit (<expr>)
4826
Retorna `limit' com `tlimswitch' escolhido para `true'.
4829
-- Variável de Opção: tlimswitch
4830
Valor padrão: `false'
4832
Quando `tlimswitch' for `true', fará o pacote `limit' usar série
4833
de Taylor quando possível.
4837
File: maxima.info, Node: Diferenciação, Next: Integração, Prev: Limites, Up: Top
4844
* Definições para Diferenciação::
4847
File: maxima.info, Node: Definições para Diferenciação, Prev: Diferenciação, Up: Diferenciação
4849
19.1 Definições para Diferenciação
4850
==================================
4852
-- Função: antid (<expr>, <x>, <u(x)>)
4853
Retorna uma lista de dois elementos, tais que uma antiderivada de
4854
<expr> com relação a <x> pode ser constuída a partir da lista. A
4855
expressão <expr> pode conter uma função desconhecida <u> e suas
4858
Tome <L>, uma lista de dois elementos, como sendo o valor de
4859
retorno de `antid'. Então `<L>[1] + 'integrate (<L>[2], <x>)' é
4860
uma antiderivada de <expr> com relação a <x>.
4862
Quando `antid' obtém sucesso inteiramente, o segundo elemento do
4863
valor de retorno é zero. De outra forma, o segundo elemento é não
4864
zero, e o primeiro elemento não zero ou zero. Se `antid' não pode
4865
fazer nenhum progresso, o primeiro elemento é zero e o segundo não
4868
`load ("antid")' chama essa função. O pacote `antid' também
4869
define as funções `nonzeroandfreeof' e `linear'.
4871
`antid' está relacionada a `antidiff' como segue. Tome <L>, uma
4872
lista de dois elementos, que é o valor de retorno de `antid'.
4873
Então o valor de retorno de `antidiff' é igual a `<L>[1] +
4874
'integrate (<L>[2], <x>)' onde <x> é a variável de integração.
4878
(%i1) load ("antid")$
4879
(%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
4881
(%o2) y(x) %e (-- (z(x)))
4883
(%i3) a1: antid (expr, x, z(x));
4885
(%o3) [y(x) %e , - %e (-- (y(x)))]
4887
(%i4) a2: antidiff (expr, x, z(x));
4890
(%o4) y(x) %e - I %e (-- (y(x))) dx
4893
(%i5) a2 - (first (a1) + 'integrate (second (a1), x));
4895
(%i6) antid (expr, x, y(x));
4897
(%o6) [0, y(x) %e (-- (z(x)))]
4899
(%i7) antidiff (expr, x, y(x));
4902
(%o7) I y(x) %e (-- (z(x))) dx
4907
-- Função: antidiff (<expr>, <x>, <u>(<x>))
4908
Retorna uma antiderivada de <expr> com relação a <x>. A expressão
4909
<expr> pode conter uma função desconhecida <u> e suas derivadas.
4911
Quando `antidiff' obtém sucesso inteiramente, a expressão
4912
resultante é livre do sinal de integral (isto é, livre do
4913
substantivo `integrate'). De outra forma, `antidiff' retorna uma
4914
expressão que é parcialmente ou inteiramente dentro de um sinal de
4915
um sinal de integral. Se `antidiff' não pode fazer qualquer
4916
progresso, o valor de retorno é inteiramente dentro de um sinal de
4919
`load ("antid")' chama essa função. O pacote `antid' também
4920
define as funções `nonzeroandfreeof' e `linear'.
4922
`antidiff' é relacionada a `antid' como segue. Tome <L>, uma
4923
lista de dois elementos, como sendo o valor de retorno de `antid'.
4924
Então o valor de retorno de `antidiff' é igual a `<L>[1] +
4925
'integrate (<L>[2], <x>)' onde <x> é a variável de integração.
4929
(%i1) load ("antid")$
4930
(%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
4932
(%o2) y(x) %e (-- (z(x)))
4934
(%i3) a1: antid (expr, x, z(x));
4936
(%o3) [y(x) %e , - %e (-- (y(x)))]
4938
(%i4) a2: antidiff (expr, x, z(x));
4941
(%o4) y(x) %e - I %e (-- (y(x))) dx
4944
(%i5) a2 - (first (a1) + 'integrate (second (a1), x));
4946
(%i6) antid (expr, x, y(x));
4948
(%o6) [0, y(x) %e (-- (z(x)))]
4950
(%i7) antidiff (expr, x, y(x));
4953
(%o7) I y(x) %e (-- (z(x))) dx
4958
-- propriedade: atomgrad
4959
`atomgrad' é a propriedade do gradiente atômico de uma expressão.
4960
Essa propriedade é atribuída por `gradef'.
4963
-- Função: atvalue (<expr>, [<x_1> = <a_1>, ..., <x_m> = <a_m>], <c>)
4964
-- Função: atvalue (<expr>, <x_1> = <a_1>, <c>)
4965
Atribui o valor <c> a <expr> no ponto `<x> = <a>'. Tipicamente
4966
valores de extremidade são estabelecidos por esse mecanismo.
4968
<expr> é a função de avaliação, `<f>(<x_1>, ..., <x_m>)', ou uma
4969
derivada, `diff (<f>(<x_1>, ..., <x_m>), <x_1>, <n_1>, ..., <x_n>,
4970
<n_m>)' na qual os argumentos da função explicitamente aparecem.
4971
<n_i> é a ordem de diferenciação com relação a <x_i>.
4973
O ponto no qual o `atvalue' é estabelecido é dado pela lista de
4974
equações `[<x_1> = <a_1>, ..., <x_m> = <a_m>]'. Se existe uma
4975
variável simples <x_1>, uma única equação pode ser dada sem ser
4976
contida em uma lista.
4978
`printprops ([<f_1>, <f_2>, ...], atvalue)' mostra os `atvalues'
4979
das funções `<f_1>, <f_2>, ...' como especificado por chamadas a
4980
`atvalue'. `printprops (<f>, atvalue)' mostra os `atvalues' de
4981
uma função <f>. `printprops (all, atvalue)' mostra os `atvalue's
4982
de todas as funções para as quais `atvalue's são definidos.
4984
Os simbolos `@1', `@2', ... representam as variáveis <x_1>, <x_2>,
4985
... quando `atvalue's são mostrados.
4987
`atvalue' avalia seus argumentos. `atvalue' retorna <c>, o
4992
(%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
4995
(%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
4997
(%i3) printprops (all, atvalue);
5000
--- (f(@1, @2))! = @2 + 1
5008
(%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
5010
(%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
5012
(%i5) at (%, [x = 0, y = 1]);
5015
(%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! )
5021
O cálculo exterior de formas diferenciais é uma ferramenta básica
5022
de geometria diferencial desenvolvida por Elie Cartan e tem
5023
importantes aplicações na teoria das equações diferenciais
5024
parciais. O pacote `cartan' implementa as funções `ext_diff' e
5025
`lie_diff', juntamente com os operadores `~' (produto da cunha) e
5026
`|' (contração de uma forma com um vetor.) Digite `demo (tensor)'
5027
para ver uma breve descrição desses comandos juntamente com
5030
`cartan' foi implementado por F.B. Estabrook e H.D. Wahlquist.
5033
-- Função: del (<x>)
5034
`del (<x>)' representa a diferencial da variável x.
5036
`diff' retorna uma expressão contendo `del' se uma variável
5037
independente não for especificada. Nesse caso, o valor de retorno
5038
é a então chamada "diferencial total".
5042
(%i1) diff (log (x));
5046
(%i2) diff (exp (x*y));
5048
(%o2) x %e del(y) + y %e del(x)
5050
(%o3) x y del(z) + x z del(y) + y z del(x)
5053
-- Função: delta (<t>)
5054
A função Delta de Dirac.
5056
Correntemente somente `laplace' sabe sobre a função `delta'.
5060
(%i1) laplace (delta (t - a) * sin(b*t), t, s);
5061
Is a positive, negative, or zero?
5068
-- Variável: dependencies
5071
`dependencies' é a lista de átomos que possuem dependências
5072
funcionais, atribuídas por `depends' ou `gradef'. A lista
5073
`dependencies' é cumulativa: cada chamada a `depends' ou a
5074
`gradef' anexa ítens adicionais.
5076
Veja `depends' e `gradef'.
5079
-- Função: depends (<f_1>, <x_1>, ..., <f_n>, <x_n>)
5080
Declara dependêcias funcionais entre variáveis para o propósito de
5081
calcular derivadas. Na ausência de dependêcias declaradas, `diff
5082
(f, x)' retorna zero. Se `depends (f, x)' for declarada, `diff
5083
(f, x)' retorna uma derivada simbólica (isto é, um substantivo
5086
Cada argumento <f_1>, <x_1>, etc., pode ser o nome de uma variável
5087
ou array, ou uma lista de nomes. Todo elemento de <f_i> (talvez
5088
apenas um elemento simples) é declarado para depender de todo
5089
elemento de <x_i> (talvez apenas um elemento simples). Se algum
5090
<f_i> for o nome de um array ou contém o nome de um array, todos
5091
os elementos do array dependem de <x_i>.
5093
`diff' reconhece dependências indiretas estabelecidas por `depends'
5094
e aplica a regra da cadeia nesses casos.
5096
`remove (<f>, dependency)' remove todas as dependências declaradas
5099
`depends' retorna uma lista de dependências estabelecidas. As
5100
dependências são anexadas à variável global `dependencies'.
5101
`depends' avalia seus argumentos.
5103
`diff' é o único comando Maxima que reconhece dependências
5104
estabelecidas por `depends'. Outras funções (`integrate',
5105
`laplace', etc.) somente reconhecem dependências explicitamente
5106
representadas por seus argumentos. Por exemplo, `integrate' não
5107
reconhece a dependência de `f' sobre `x' a menos que
5108
explicitamente representada como `integrate (f(x), x)'.
5110
(%i1) depends ([f, g], x);
5112
(%i2) depends ([r, s], [u, v, w]);
5113
(%o2) [r(u, v, w), s(u, v, w)]
5114
(%i3) depends (u, t);
5117
(%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
5118
(%i5) diff (r.s, u);
5120
(%o5) -- . s + r . --
5123
(%i6) diff (r.s, t);
5125
(%o6) -- -- . s + r . -- --
5128
(%i7) remove (r, dependency);
5130
(%i8) diff (r.s, t);
5136
-- Variável de opção: derivabbrev
5137
Valor padrão: `false'
5139
Quando `derivabbrev' for `true', derivadas simbólicas (isto é,
5140
substantivos `diff') são mostradas como subscritos. De outra
5141
forma, derivadas são mostradas na notação de Leibniz `dy/dx'.
5144
-- Função: derivdegree (<expr>, <y>, <x>)
5145
Retorna o maior grau de uma derivada da variável dependente <y>
5146
com relação à variável independente <x> ocorrendo em <expr>.
5149
(%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
5152
(%o1) --- + --- + x --
5155
(%i2) derivdegree (%, y, x);
5159
-- Função: derivlist (<var_1>, ..., <var_k>)
5160
Causa somente diferenciações com relação às variáveis indicadas,
5161
dentro do comando `ev'.
5164
-- Variável de opção: derivsubst
5165
Valor padrão: `false'
5167
Quando `derivsubst' for `true', uma substiruíção não sintática
5168
tais como `subst (x, 'diff (y, t), 'diff (y, t, 2))' retorna
5172
-- Função: diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)
5173
-- Função: diff (<expr>, <x>, <n>)
5174
-- Função: diff (<expr>, <x>)
5175
-- Função: diff (<expr>)
5176
Retorna uma derivada ou diferencial de <expr> com relação a alguma
5177
ou todas as variáveis em <expr>.
5179
`diff (<expr>, <x>, <n>)' retorna a <n>'ésima derivada de <expr>
5182
`diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)' retorna a
5183
derivada parcial mista de <expr> com relação a <x_1>, ..., <x_m>.
5184
Isso é equivalente a `diff (... (diff (<expr>, <x_m>, <n_m>) ...),
5187
`diff (<expr>, <x>)' retorna a primeira derivada de <expr> com
5188
relação a uma variável <x>.
5190
`diff (<expr>)' retorna a diferencial total de <expr>, isto é, a
5191
soma das derivadas de <expr> com relação a cada uma de suas
5192
variáveis vezes a diferencial `del' de cada variável. Nenhuma
5193
simplificação adicional de `del' é oferecida.
5195
A forma substantiva de `diff' é requerida em alguns contextos, tal
5196
como declarando uma equação diferencial. Nesses casos, `diff'
5197
pode ser colocado apóstrofo (com `'diff') para retornar a forma
5198
substantiva em lugar da realização da diferenciação.
5200
Quando `derivabbrev' for `true', derivadas são mostradas como
5201
subscritos. De outra forma, derivadas são mostradas na notação de
5206
(%i1) diff (exp (f(x)), x, 2);
5209
(%o1) %e (--- (f(x))) + %e (-- (f(x)))
5212
(%i2) derivabbrev: true$
5213
(%i3) 'integrate (f(x, y), y, g(x), h(x));
5225
(%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x)
5230
Para o pacote tensor, as seguintes modificações foram incorporadas:
5232
(1) As derivadas de quaisquer objetos indexados em <expr> terão as
5233
variáveis <x_i> anexadas como argumentos adicionais. Então todos
5234
os índices de derivada serão ordenados.
5236
(2) As variáveis <x_i> podem ser inteiros de 1 até o valor de uma
5237
variável `dimension' [valor padrão: 4]. Isso fará com que a
5238
diferenciação seja concluída com relação aos <x_i>'ésimos membros
5239
da lista `coordinates' que pode ser escolhida para uma lista de
5240
nomes de coordenadas, e.g., `[x, y, z, t]'. Se `coordinates' for
5241
associada a uma variável atômica, então aquela variável subscrita
5242
por <x_i> será usada para uma variável de diferenciação. Isso
5243
permite um array de nomes de coordenadas ou nomes subscritos como
5244
`X[1]', `X[2]', ... sejam usados. Se `coordinates' não foram
5245
atribuídas um valor, então as variáveis seram tratadas como em (1)
5249
-- Símbolo especial: diff
5250
Quando `diff' está presente como um `evflag' em chamadas para `ev',
5251
Todas as diferenciações indicadas em `expr' são realizdas.
5254
-- Função: dscalar (<f>)
5255
Aplica o d'Alembertiano escalar para a função escalar <f>.
5257
`load ("ctensor")' chama essa função.
5260
-- Função: express (<expr>)
5261
Expande o substantivo do operador diferencial em expressões em
5262
termos de derivadas parciais. `express' reconhece os operadores
5263
`grad', `div', `curl', `laplacian'. `express' também expande o
5266
Derivadas simbólicas (isto é, substantivos `diff') no valor de
5267
retorno de `express' podem ser avaliadas incluíndo `diff' na
5268
chamada à função `ev' ou na linha de comando. Nesse contexto,
5269
`diff' age como uma `evfun'.
5271
`load ("vect")' chama essa função.
5275
(%i1) load ("vect")$
5276
(%i2) grad (x^2 + y^2 + z^2);
5278
(%o2) grad (z + y + x )
5280
d 2 2 2 d 2 2 2 d 2 2 2
5281
(%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )]
5284
(%o4) [2 x, 2 y, 2 z]
5285
(%i5) div ([x^2, y^2, z^2]);
5287
(%o5) div [x , y , z ]
5290
(%o6) -- (z ) + -- (y ) + -- (x )
5293
(%o7) 2 z + 2 y + 2 x
5294
(%i8) curl ([x^2, y^2, z^2]);
5296
(%o8) curl [x , y , z ]
5298
d 2 d 2 d 2 d 2 d 2 d 2
5299
(%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
5301
(%i10) ev (%, diff);
5303
(%i11) laplacian (x^2 * y^2 * z^2);
5305
(%o11) laplacian (x y z )
5308
d 2 2 2 d 2 2 2 d 2 2 2
5309
(%o12) --- (x y z ) + --- (x y z ) + --- (x y z )
5312
(%i13) ev (%, diff);
5314
(%o13) 2 y z + 2 x z + 2 x y
5315
(%i14) [a, b, c] ~ [x, y, z];
5316
(%o14) [a, b, c] ~ [x, y, z]
5318
(%o15) [b z - c y, c x - a z, a y - b x]
5321
-- Função: gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)
5322
-- Função: gradef (<a>, <x>, <expr>)
5323
Define as derivadas parciais (i.e., os componentes do gradiente)
5324
da função <f> ou variável <a>.
5326
`gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)' define
5327
`d<f>/d<x_i>' como <g_i>, onde <g_i> é uma expressão; <g_i> pode
5328
ser uma chamada de função, mas não o nome de uma função. O número
5329
de derivadas parciais <m> pode ser menor que o número de
5330
argumentos <n>, nesses casos derivadas são definidas com relação a
5331
<x_1> até <x_m> somente.
5333
`gradef (<a>, <x>, <expr>)' define uma derivada de variável <a>
5334
com relação a <x> como <expr>. Isso também estabelece a
5335
dependência de <a> sobre <x> (via `depends (<a>, <x>)').
5337
O primeiro argumento `<f>(<x_1>, ..., <x_n>)' ou <a> é acompanhado
5338
de apóstrofo, mas os argumentos restantes <g_1>, ..., <g_m> são
5339
avaliados. `gradef' retorna a função ou variável para as quais as
5340
derivadas parciais são definidas.
5342
`gradef' pode redefinir as derivadas de funções internas do Maxima.
5343
Por exemplo, `gradef (sin(x), sqrt (1 - sin(x)^2))' redefine uma
5346
`gradef' não pode definir derivadas parciais para um função
5349
`printprops ([<f_1>, ..., <f_n>], gradef)' mostra as derivadas
5350
parciais das funções <f_1>, ..., <f_n>, como definidas por
5353
`printprops ([<a_n>, ..., <a_n>], atomgrad)' mostra as derivadas
5354
parciais das variáveis <a_n>, ..., <a_n>, como definidas por
5357
`gradefs' é a lista de funções para as quais derivadas parciais
5358
foram definidas por `gradef'. `gradefs' não inclui quaisquer
5359
variáveis para quais derivadas parciais foram definidas por
5362
Gradientes são necessários quando, por exemplo, uma função não é
5363
conhecida explicitamente mas suas derivadas primeiras são e isso é
5364
desejado para obter derivadas de ordem superior.
5367
-- Variável de sistema: gradefs
5370
`gradefs' é a lista de funções para as quais derivadas parciais
5371
foram definidas por `gradef'. `gradefs' não inclui quaisquer
5372
variáveis para as quais derivadas parciais foram deinidas por
5376
-- Função: laplace (<expr>, <t>, <s>)
5377
Tenta calcular a transformada de Laplace de <expr> com relação a
5378
uma variável <t> e parâmetro de transformação <s>. Se `laplace'
5379
não pode achar uma solução, um substantivo `'laplace' é retornado.
5381
`laplace' reconhece em <expr> as funções `delta', `exp', `log',
5382
`sin', `cos', `sinh', `cosh', e `erf', também `derivative',
5383
`integrate', `sum', e `ilt'. Se algumas outras funções estiverem
5384
presente, `laplace' pode não ser habilitada a calcular a
5387
<expr> pode também ser uma equação linear, diferencial de
5388
coeficiente contante no qual caso o `atvalue' da variável
5389
dependente é usado. O requerido `atvalue' pode ser fornecido ou
5390
antes ou depois da transformada ser calculada. Uma vez que as
5391
condições iniciais devem ser especificadas em zero, se um teve
5392
condições de limite impostas em qualquer outro lugar ele pode
5393
impor essas sobre a solução geral e eliminar as constantes
5394
resolvendo a solução geral para essas e substituindo seus valores
5397
`laplace' reconhece integrais de convolução da forma `integrate
5398
(f(x) * g(t - x), x, 0, t)'; outros tipos de convoluções não são
5401
Relações funcionais devem ser explicitamente representadas em
5402
<expr>; relações implícitas, estabelecidas por `depends', não são
5403
reconhecidas. Isto é, se <f> depende de <x> e <y>, `f (x, y)'
5404
deve aparecer em <expr>.
5406
Veja também `ilt', a transformada inversa de Laplace.
5410
(%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
5413
(%o1) ---------------
5416
(%i2) laplace ('diff (f (x), x), x, s);
5417
(%o2) s laplace(f(x), x, s) - f(0)
5418
(%i3) diff (diff (delta (t), t), t);
5421
(%o3) --- (delta(t))
5424
(%i4) laplace (%, t, s);
5427
(%o4) - -- (delta(t))! + s - delta(0) s
5433
File: maxima.info, Node: Integração, Next: Equações, Prev: Diferenciação, Up: Top
5440
* Introdução a Integração::
5441
* Definições para Integração::
5442
* Introdução a QUADPACK::
5443
* Definições para QUADPACK::
5446
File: maxima.info, Node: Introdução a Integração, Next: Definições para Integração, Prev: Integração, Up: Integração
5448
20.1 Introdução a Integração
5449
============================
5451
Maxima tem muitas rotinas para manusear integração. A função
5452
`integrate' faz uso de muitas dessas. Exite também o pacote `antid',
5453
que manuseia uma função não especificada (e suas derivadas,
5454
certamente). Para usos numéricos, existe a função `romberg'; um
5455
integrador adaptativo que usa a regra da quadratura dos currais de
5456
Newton, chamada `quanc8'; e uma escolha de integradores adaptativos de
5457
Quadpack, a saber `quad_qag', `quad_qags', etc., os quais são descritos
5458
sob o tópico `QUADPACK'. Funções hipergeométricas estão sendo
5459
trabalhadas, veja `specint' for details. Geralmente falando, Maxima
5460
somente manuseia integrais que são integráveis em termos de "funções
5461
elementares" (funções racionais, trigonometricas, logarítmicas,
5462
exponenciais, radicais, etc.) e umas poucas extensões (função de erro,
5463
dilogarithm). Isso não manuseia integrais em termos de funções
5464
desconhecidas tais como `g(x)' e `h(x)'.
5467
File: maxima.info, Node: Definições para Integração, Next: Introdução a QUADPACK, Prev: Introdução a Integração, Up: Integração
5469
20.2 Definições para Integração
5470
===============================
5472
-- Função: changevar (<expr>, <f(x,y)>, <y>, <x>)
5473
Faz a mudança de variável dada por `<f(x,y)> = 0' em todas as
5474
integrais que ocorrem em <expr> com integração em relação a <x>.
5475
A nova variável é <y>.
5477
(%i1) assume(a > 0)$
5478
(%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
5486
(%i3) changevar (%, y-z^2/a, z, y);
5494
(%o3) - ----------------------------
5497
Uma expressão contendo uma forma substantiva, tais como as
5498
instâncias de `'integrate' acima, pode ser avaliada por `ev' com o
5499
sinalizador `nouns'. Por exemplo, a expressão retornada por
5500
`changevar' acima pode ser avaliada por `ev (%o3, nouns)'.
5502
`changevar' pode também ser usada para alterações nos índices de
5503
uma soma ou de um produto. Todavia, isso deve obrigatóriamente
5504
ser realizado de forma que quando uma alteração é feita em uma
5505
soma ou produto, essa mudança deve ser um artifício, i.e., `i = j+
5506
...', não uma função de grau mais alto. E.g.,
5508
(%i4) sum (a[i]*x^(i-2), i, 0, inf);
5516
(%i5) changevar (%, i-2-n, n, i);
5526
-- Função: dblint (<f>, <r>, <s>, <a>, <b>)
5527
Uma rotina de integral dupla que foi escrita no alto-nível do
5528
Maxima e então traduzida e compilada para linguagem de máquina.
5529
Use `load (dblint)' para acessar esse pacote. Isso usa o método
5530
da regra de Simpson em ambas as direções x e y para calcular
5538
A função <f> deve ser uma função traduzida ou compilada de duas
5539
variáveis, e <r> e <s> devem cada uma ser uma função traduzida ou
5540
compilada de uma variável, enquanto <a> e <b> devem ser números em
5541
ponto flutuante. A rotina tem duas variáveis globais que
5542
determinam o número de divisões dos intervalos x e y: `dblint_x' e
5543
`dblint_y', ambas as quais são inicialmente 10, e podem ser
5544
alteradas independentemente para outros valores inteiros (existem
5545
`2*dblint_x+1' pontos calculados na direção x , e `2*dblint_y+1'
5546
na direção y). A rotina subdivide o eixo X e então para cada
5547
valor de X isso primeiro calcula `<r>(x)' e `<s>(x)'; então o eixo
5548
Y entre `<r>(x)' e `<s>(x)' é subdividido e a integral ao longo do
5549
eixo Y é executada usando a regra de Simpson; então a integral ao
5550
longo do eixo X é concluída usando a regra de Simpson com os
5551
valores da função sendo as integrais-Y. Esse procedimento pode
5552
ser numericamente instável por uma grande variedade razões, mas
5553
razoávelmente rápido: evite usar isso sobre funções altamente
5554
oscilatórias e funções com singularidades (postes ou pontos de
5555
ramificação na região). As integrais Y dependem de quanto
5556
fragmentados `<r>(x)' e `<s>(x)' são, então se a ditância `<s>(x)
5557
- <r>(x)' varia rapidamente com X, nesse ponto pode ter erros
5558
substanciais provenientes de truncação com diferentes
5559
saltos-tamanhos nas várias integrais Y. Um pode incrementar
5560
`dblint_x' e `dblint_y' em uma tentativa para melhorar a
5561
convergência da reião, com sacrifício do tempo de computação. Os
5562
valores da função não são salvos, então se a função é muito
5563
desperdiçadora de tempo,você terá de esperar por re-computação se
5564
você mudar qualquer coisa (desculpe). Isso é requerido que as
5565
funções <f>, <r>, e <s> sejam ainda traduzidas ou compiladas
5566
previamente chamando `dblint'. Isso resultará em ordens de
5567
magnitude de melhoramentos de velocidade sobre o código
5568
interpretado em muitos casos!
5570
`demo (dblint)' executa uma demonstração de `dblint' aplicado a um
5574
-- Função: defint (<expr>, <x>, <a>, <b>)
5575
Tenta calcular uma integral definida. `defint' é chamada por
5576
`integrate' quando limites de integração são especificados, i.e.,
5577
quando `integrate' é chamado como `integrate (<expr>, <x>, <a>,
5578
<b>)'. Dessa forma do ponto de vista do usuário, isso é
5579
suficiente para chamar `integrate'.
5581
`defint' retorna uma expressão simbólica, e executa um dos dois:
5582
ou calcula a integral ou a forma substantiva da integral. Veja
5583
`quad_qag' e funções rellacionadas para aproximação numérica de
5584
integrais definidas.
5587
-- Função: erf (<x>)
5588
Representa a função de erro, cuja derivada é:
5589
`2*exp(-x^2)/sqrt(%pi)'.
5592
-- Variável de opção: erfflag
5593
Valor padrão: `true'
5595
Quando `erfflag' é `false', previne `risch' da introdução da
5596
função `erf' na resposta se não houver nenhum no integrando para
5600
-- Função: ilt (<expr>, <t>, <s>)
5601
Calcula a transformação inversa de Laplace de <expr> em relação a
5602
<t> e parâmetro <s>. <expr> deve ser uma razão de polinômios cujo
5603
denominador tem somente fatores lineares e quadráticos. Usando a
5604
funções `laplace' e `ilt' juntas com as funções `solve' ou
5605
`linsolve' o usuário pode resolver uma diferencial simples ou uma
5606
equação integral de convolução ou um conjunto delas.
5608
(%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
5612
(%o1) I f(t - x) sinh(a x) dx + b f(t) = t
5616
(%i2) laplace (%, t, s);
5617
a laplace(f(t), t, s) 2
5618
(%o2) b laplace(f(t), t, s) + --------------------- = --
5621
(%i3) linsolve ([%], ['laplace(f(t), t, s)]);
5624
(%o3) [laplace(f(t), t, s) = --------------------]
5627
(%i4) ilt (rhs (first (%)), s, t);
5628
Is a b (a b - 1) positive, negative, or zero?
5631
sqrt(a b (a b - 1)) t
5632
2 cosh(---------------------) 2
5634
(%o4) - ----------------------------- + -------
5639
+ ------------------
5644
-- Função: integrate (<expr>, <x>)
5645
-- Função: integrate (<expr>, <x>, <a>, <b>)
5646
Tenta símbolicamente calcular a integral de <expr> em relação a
5647
<x>. `integrate (<expr>, <x>)' é uma integral indefinida,
5648
enquanto `integrate (<expr>, <x>, <a>, <b>)' é uma integral
5649
definida, com limites de integração <a> e <b>. Os limites não
5650
poderam conter <x>, embora `integrate' não imponha essa restrição.
5651
<a> não precisa ser menor que <b>. Se <b> é igual a <a>,
5652
`integrate' retorna zero.
5654
Veja `quad_qag' e funções relacionadas para aproximação numérica
5655
de integrais definidas. Veja `residue' para computação de
5656
resíduos (integração complexa). Veja `antid' para uma forma
5657
alternativa de calcular integrais indefinidas.
5659
A integral (uma expressão livre de `integrate') é retornada se
5660
`integrate' obtém sucesso. De outra forma o valor de retorno é a
5661
forma substantiva da integral (o operador com apóstrofo
5662
`'integrate') ou uma expressão contendo uma ou mais formas
5663
substantivas. A forma substantiva de `integrate' é mostrada com
5664
um sinal de integral.
5666
Em algumas circunstâncias isso é útil para construir uma forma
5667
substantiva manualmente, colocando em `integrate' um apóstrofo,
5668
e.g., `'integrate (<expr>, <x>)'. Por exemplo, a integral pode
5669
depender de alguns parâmetos que não estão ainda calculados. A
5670
forma substantiva pode ser aplicada a seus argumentos por `ev
5671
(<i>, nouns)' onde <i> é a forma substantiva de interesse.
5673
`integrate' manuseia integrais definidas separadamente das
5674
indefinidas, e utiliza uma gama de heurísticas para manusear cada
5675
caso. Casos especiais de integrais definidas incluem limites de
5676
integração iguais a zero ou infinito (`inf' ou `minf'), funções
5677
trigonométricas com limites de integração iguais a zero e `%pi' ou
5678
`2 %pi', funções racionais, integrais relacionadas para as
5679
definições de funções `beta' e `psi', e algumas integrais
5680
logarítmicas e trigonométricas. Processando funções racionais
5681
pode incluir computação de resíduo. Se um caso especial aplicável
5682
não é encontrado, tentativa será feita para calcular a integra
5683
indefinida e avaliar isso nos limites de integração. Isso pode
5684
incluir pegar um limite como um limite de integração tendendo ao
5685
infinito ou a menos infinito; veja também `ldefint'.
5687
Casos especiais de integrais indefinidas incluem funções
5688
trigonométricas, exponenciais e funções logarítmicas, e funções
5689
racionais. `integrate' pode também fazer uso de uma curta tabela
5690
de integais elementares.
5692
`integrate' pode realizar uma mudança de variável se o integrando
5693
tem a forma `f(g(x)) * diff(g(x), x)'. `integrate' tenta achar
5694
uma subexpressão `g(x)' de forma que a derivada de `g(x)' divida o
5695
integrando. Essa busca pode fazer uso de derivadas definidas pela
5696
função `gradef'. Veja também `changevar' e `antid'.
5698
Se nenhum dos procedimentos heurísticos acha uma integral
5699
indefinida, o algorítmo de Risch é executado. O sinalizador
5700
`risch' pode ser escolhido como um `evflag', na chamada para `ev'
5701
ou na linha de comando, e.g., `ev (integrate (<expr>, <x>),
5702
risch)' ou `integrate (<expr>, <x>), risch'. Se `risch' está
5703
presente, `integrate' chama a função `risch' sem tentar
5704
heurísticas primeiro. Veja também `risch'.
5706
`integrate' trabalha somente com relações funcionais representadas
5707
explicitamente com a notação `f(x)'. `integrate' não respeita
5708
dependências implicitas estabelecidas pela função `depends'.
5709
`integrate' pode necessitar conhecer alguma propriedade de um
5710
parâmetro no integrando. `integrate' irá primeiro consultar a
5711
base de dados do `assume', e , se a variável de interesse não está
5712
lá, `integrate' perguntará ao usuário. Dependendo da pergunta,
5713
respostas adequadas são `yes;' ou `no;', ou `pos;', `zero;', ou
5716
`integrate' não é, por padrão, declarada ser linear. Veja
5717
`declare' e `linear'.
5719
`integrate' tenta integração por partes somente em uns poucos
5724
* Integrais definidas e indefinidas elementares.
5726
(%i1) integrate (sin(x)^3, x);
5729
(%o1) ------- - cos(x)
5731
(%i2) integrate (x/ sqrt (b^2 - x^2), x);
5733
(%o2) - sqrt(b - x )
5734
(%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
5739
(%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
5744
* Uso de `assume' e dúvida interativa.
5746
(%i1) assume (a > 1)$
5747
(%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
5749
Is ------- an integer?
5753
Is 2 a - 3 positive, negative, or zero?
5757
(%o2) beta(a + 1, - - a)
5760
* Mudança de variável. Existem duas mudanças de variável nesse
5761
exemplo: uma usando a derivada estabelecida por `gradef', e
5762
uma usando a derivação `diff(r(x))' de uma função não
5763
especificada `r(x)'.
5765
(%i3) gradef (q(x), sin(x**2));
5767
(%i4) diff (log (q (r (x))), x);
5769
(-- (r(x))) sin(r (x))
5771
(%o4) ----------------------
5773
(%i5) integrate (%, x);
5776
* O valor de retorno contém a forma substantiva `'integrate'.
5777
Nesse exemplo, Maxima pode extrair um fator do denominador de
5778
uma função racional, mas não pode fatorar o restante ou de
5779
outra forma achar sua integral. `grind' mostra a forma
5780
substantiva `'integrate' no resultado. Veja também
5781
`integrate_use_rootsof' para mais sobre integrais de funções
5784
(%i1) expand ((x-4) * (x^3+2*x+1));
5786
(%o1) x - 4 x + 2 x - 7 x - 4
5787
(%i2) integrate (1/%, x);
5792
log(x - 4) / x + 2 x + 1
5793
(%o2) ---------- - ------------------
5796
log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$
5798
* Definindo uma função em termos de uma integral. O corpo de
5799
uma função não é avaliado quando a função é definida. Dessa
5800
forma o corpo de `f_1' nesse exemplo contém a forma
5801
substantiva de `integrate'. O operador apóstrofo-apóstrofo
5802
`''' faz com que a integral seja avaliada, e o resultado
5803
transforme-se no corpo de `f_2'.
5805
(%i1) f_1 (a) := integrate (x^3, x, 1, a);
5807
(%o1) f_1(a) := integrate(x , x, 1, a)
5808
(%i2) ev (f_1 (7), nouns);
5810
(%i3) /* Note parentheses around integrate(...) here */
5811
f_2 (a) := ''(integrate (x^3, x, 1, a));
5814
(%o3) f_2(a) := -- - -
5820
-- Variável de sistema: integration_constant_counter
5823
`integração_constant_counter' é um contador que é atualizado a
5824
cada vez que uma constante de integração (nomeada pelo Maxima,
5825
e.g., `integrationconstant1') é introduzida em uma expressão pela
5826
integração indefinida de uma equação.
5829
-- Variável de opção: integrate_use_rootsof
5830
Valor padrão: `false'
5832
Quando `integrate_use_rootsof' é `true' e o denominador de uma
5833
função racional não pode ser fatorado, `integrate' retorna a
5834
integral em uma forma que é uma soma sobre as raízes (não
5835
conhecidas ainda) do denominador.
5837
Por exemplo, com `integrate_use_rootsof' escolhido para `false',
5838
`integrate' retorna uma integral não resolvida de uma função
5839
racional na forma substantiva:
5841
(%i1) integrate_use_rootsof: false$
5842
(%i2) integrate (1/(1+x+x^5), x);
5845
I ------------ dx 2 x + 1
5846
] 3 2 2 5 atan(-------)
5847
/ x - x + 1 log(x + x + 1) sqrt(3)
5848
(%o2) ----------------- - --------------- + ---------------
5851
Agora vamos escolher o sinalizador para ser true e a parte não
5852
resolvida da integral será expressa como um somatório sobre as
5853
raízes do denominador da função racional:
5855
(%i3) integrate_use_rootsof: true$
5856
(%i4) integrate (1/(1+x+x^5), x);
5858
\ (%r4 - 4 %r4 + 5) log(x - %r4)
5859
> -------------------------------
5863
%r4 in rootsof(x - x + 1)
5864
(%o4) ----------------------------------------------------------
5869
log(x + x + 1) sqrt(3)
5870
- --------------- + ---------------
5873
Alternativamente o usuário pode calcular as raízes do denominador
5874
separadamente, e então expressar o integrando em termos dessas
5875
raízes, e.g., `1/((x - a)*(x - b)*(x - c))' ou `1/((x^2 - (a+b)*x
5876
+ a*b)*(x - c))' se o denominador for um polinômio cúbico.
5877
Algumas vezes isso ajudará Maxima a obter resultados mais úteis.
5880
-- Função: ldefint (<expr>, <x>, <a>, <b>)
5881
Tenta calcular a integral definida de <expr> pelo uso de `limit'
5882
para avaliar a integral indefinida <expr> em relação a <x> no
5883
limite superior <b> e no limite inferior <a>. Se isso falha para
5884
calcular a integral definida, `ldefint' retorna uma expressão
5885
contendo limites como formas substantivas.
5887
`ldefint' não é chamada por `integrate', então executando `ldefint
5888
(<expr>, <x>, <a>, <b>)' pode retornar um resultado diferente de
5889
`integrate (<expr>, <x>, <a>, <b>)'. `ldefint' sempre usa o mesmo
5890
método para avaliar a integral definida, enquanto `integrate' pode
5891
utilizar várias heurísticas e pode reconhecer alguns casos
5895
-- Função: potential (<givengradient>)
5896
O cálculo faz uso da variável global `potentialzeroloc[0]' que
5897
deve ser `nonlist' ou da forma
5899
[indeterminatej=expressãoj, indeterminatek=expressãok, ...]
5901
O formador sendo equivalente para a expressão nonlist para todos
5902
os lados direitos-manuseados mais tarde. Os lados direitos
5903
indicados são usados como o limite inferior de integração. O
5904
sucesso das integrações pode depender de seus valores e de sua
5905
ordem. `potentialzeroloc' é inicialmente escolhido para 0.
5909
O pacote `qq' (que pode ser carregado com `load ("qq")') contém
5910
uma função `quanc8' que pode pegar ou 3 ou 4 arguments. A versão
5911
de 3 argumentos calcula a integral da função especificada como
5912
primeiro argumento sobre o intervalo de lo a hi como em `quanc8
5913
('função, lo, hi)'. o nome da função pode receber apóstrofo. A
5914
versão de 4 argumentos calculará a integral da função ou expressão
5915
(primeiro argumento) em relação à variável (segundo argumento) no
5916
intervalo de `lo' a `hi' como em `quanc8(<f(x) or expressão in x>,
5917
x, lo, hi)'. O método usado é o da quadratura dos currais de
5918
Newton, e a rotina é adaptativa. Isso irá dessa forma gastar
5919
tempo dividindo o intervalo somente quando necessário para
5920
completar as condições de erro especificadas pelas variáveis
5921
`quanc8_relerr' (valor padrão=1.0e-4) e `quanc8_abserr' (valor
5922
padrão=1.0e-8) que dão o teste de erro relativo:
5924
|integral(função) - valor calculado| < quanc8_relerr*|integral(função)|
5926
e o teste de erro absoluto:
5928
|integral(função) - valor calculado| < quanc8_abserr
5930
`printfile ("qq.usg")' yields additional informação.
5933
-- Função: quanc8 (<expr>, <a>, <b>)
5934
Um integrador adaptativo. Demonstração e arquivos de utilização
5935
são fornecidos. O método é para usar a regra da quadratura dos
5936
currais de Newton, daí o nome da função `quanc8', disponível em
5937
versões de 3 ou 4 argumentos. Verificação de erro absoluto e erro
5938
relativo são usadas. Para usar isso faça `load ("qq")'. Veja
5942
-- Função: residue (<expr>, <z>, <z_0>)
5943
Calcula o resíduo no plano complexo da expressão <expr> quando a
5944
variável <z> assumes o valor <z_0>. O resíduo é o coeficiente de
5945
`(<z> - <z_0>)^(-1)' nas séries de Laurent para <expr>.
5947
(%i1) residue (s/(s**2+a**2), s, a*%i);
5951
(%i2) residue (sin(a*x)/x**4, x, 0);
5958
-- Função: risch (<expr>, <x>)
5959
Integra <expr> em relação a <x> usando um caso transcendental do
5960
algorítmo de Risch. (O caso algébrico do algorítmo de Risch foi
5961
implementado.) Isso atualmente manuseia os casos de exponenciais
5962
aninhadas e logarítmos que a parte principal de `integrate' não
5963
pode fazer. `integrate' irá aplicar automaticamente `risch' se
5966
`erfflag', se `false', previne `risch' da introdução da função
5967
`erf' na resposta se não for achado nenhum no integrando para
5970
(%i1) risch (x^2*erf(x), x);
5973
%pi x erf(x) + (sqrt(%pi) x + sqrt(%pi)) %e
5974
(%o1) -------------------------------------------------
5976
(%i2) diff(%, x), ratsimp;
5981
-- Função: romberg (<expr>, <x>, <a>, <b>)
5982
-- Função: romberg (<expr>, <a>, <b>)
5983
Integração de Romberg. Existem dois caminhos para usar essa
5984
função. O primeiro é um caminho ineficiente como a versão de
5985
integral definida de `integrate': `romberg (<integrando>,
5986
<variável of integração>, <lower limit>, <upper limit>)'.
5990
(%i1) showtime: true$
5991
(%i2) romberg (sin(y), y, 0, %pi);
5992
Evaluação took 0.00 seconds (0.01 elapsed) using 25.293 KB.
5993
(%o2) 2.000000016288042
5994
(%i3) 1/((x-1)^2+1/100) + 1/((x-2)^2+1/1000) + 1/((x-3)^2+1/200)$
5996
(%i5) rombergtol: 1e-6$
5997
(%i6) rombergit: 15$
5998
(%i7) romberg (f(x), x, -5, 5);
5999
Evaluação took 11.97 seconds (12.21 elapsed) using 12.423 MB.
6000
(%o7) 173.6730736617464
6002
O segundo é um caminho eficiente que é usado como segue:
6004
romberg (<função name>, <lower limit>, <upper limit>);
6006
Continuando o exemplo acima, temos:
6007
(%i8) f(x) := (mode_declare ([função(f), x], float), ''(%th(5)))$
6010
(%i10) romberg (f, -5, 5);
6011
Evaluação took 3.51 seconds (3.86 elapsed) using 6.641 MB.
6012
(%o10) 173.6730736617464
6014
O primeiro argumento deve ser uma função trauzida ou compilada.
6015
(Se for compilada isso deve ser declarado para retorno a
6016
`flonum'.) Se o primeiro argumento não for já traduzido,
6017
`romberg' não tentará traduzí-lo mas resultará um erro.
6019
A precisão da integração é governada pelas variáveis globais
6020
`rombergtol' (valor padrão 1.E-4) e `rombergit' (valor padrão 11).
6021
`romberg' retornará um resultado se a diferença relativa em
6022
sucessivas aproximações for menor que `rombergtol'. Isso tentará
6023
dividir ao meio o tamanho do passo `rombergit' vezes antes que
6024
isso seja abandonado. O número de iterações e avaliações da
6025
função que `romberg' fará é governado por `rombergabs' e
6028
`romberg' pode ser chamada recursivamente e dessa forma pode fazer
6029
integrais duplas e triplas.
6032
(%i1) assume (x > 0)$
6033
(%i2) integrate (integrate (x*y/(x+y), y, 0, x/2), x, 1, 3)$
6035
26 log(3) - 26 log(2) - 13
6036
(%o3) - --------------------------
6039
(%o4) .8193023963959073
6040
(%i5) define_variable (x, 0.0, float, "Global variável in função F")$
6041
(%i6) f(y) := (mode_declare (y, float), x*y/(x+y))$
6042
(%i7) g(x) := romberg ('f, 0, x/2)$
6043
(%i8) romberg (g, 1, 3);
6044
(%o8) .8193022864324522
6046
A vantagem com esse caminho é que a função `f' pode ser usada para
6047
outros propósitos, como imprimir gráficos. A desvantagem é que
6048
você tem que inventar um nome para ambas a função `f' e sua
6049
variável independente `x'. Ou, sem a variável global:
6051
(%i1) g_1(x) := (mode_declare (x, float), romberg (x*y/(x+y), y, 0, x/2))$
6052
(%i2) romberg (g_1, 1, 3);
6053
(%o2) .8193022864324522
6055
A vantagem aqui é que o código é menor.
6057
(%i3) q (a, b) := romberg (romberg (x*y/(x+y), y, 0, x/2), x, a, b)$
6059
(%o4) .8193022864324522
6061
Isso é sempre o caminho mais curto, e as variáveis não precisam
6062
ser declaradas porque elas estão no contexto de `romberg'. O uso
6063
de `romberg' para integrais multiplas pode ter grandes
6064
desvantagens, apesar disso. O amontoado de cálculos extras
6065
necessários por causa da informação geométrica descartada durante
6066
o processo pela expressão de integrais multiplas por esse caminho
6067
pode ser incrível. O usuário deverá ter certeza de entender e
6068
usar os comutadores `rombergtol' e `rombergit'.
6071
-- Variável de opção: rombergabs
6074
Assumindo que estimativas sucessivas produzidas por `romberg' são
6075
`y[0]', `y[1]', `y[2]', etc., então `romberg' retornará após `n'
6076
iterações se (grasseiramente falando)
6078
(abs(y[n]-y[n-1]) <= rombergabs ou
6079
abs(y[n]-y[n-1])/(if y[n]=0.0 then 1.0 else y[n]) <= rombergtol)
6081
for `true'. (A condição sobre o número de iterações dadas por
6082
`rombergmin' deve também ser satisfeita.) Dessa forma se
6083
`rombergabs' é 0.0 (o padrão) você apenas pega o teste de erro
6084
relativo. A utilidade de uma variável adicional vem quando você
6085
executar uma integral, quando a contribuição dominante vem de uma
6086
pequena região. Então você pode fazer a integral sobre uma pequena
6087
região dominante primeiro, usando a verificação relativa de
6088
precisão, seguida pela integral sobre o restante da região usando
6089
a verificação absoluta de erro.
6091
Exemplo: Suponha que você quer calcular
6093
'integrate (exp(-x), x, 0, 50)
6095
(numericamente) com uma precisão relativa de 1 parte em 10000000.
6096
Defina a função. `n' é o contador, então nós podemos ver quantas
6097
avaliações de função foram necessárias. Primeiro de tudo tente
6098
fazer a integral completa de uma só vez.
6100
(%i1) f(x) := (mode_declare (n, integer, x, float), n:n+1, exp(-x))$
6102
Warning-> n é an undefined global variable.
6103
(%i3) block ([rombergtol: 1.e-6, romberabs: 0.0], n:0, romberg (f, 0, 50));
6104
(%o3) 1.000000000488271
6108
Que aproximadamente precisou de 257 avaliações de função . Agora
6109
faça a integral inteligentemente, primeiro fazendo
6110
`'integrate (exp(-x), x, 0, 10)' e então escolhendo `rombergabs'
6111
para 1.E-6 vezes (nessa integral parcial). Isso
6112
aproximdamente pega somente 130 avaliações de função.
6114
(%i5) block ([rombergtol: 1.e-6, rombergabs:0.0, sum:0.0],
6115
n: 0, sum: romberg (f, 0, 10), rombergabs: sum*rombergtol, rombergtol:0.0,
6116
sum + romberg (f, 10, 50));
6117
(%o5) 1.000000001234793
6121
Então se `f(x)' onde a função pegou um longo tempo de computação, o
6122
segundo método fez a mesma tarefa 2 vezes mais rápido.
6125
-- Variável de opção: rombergit
6128
A precisão do comando `romberg' de integração é governada pelas
6129
variáveis globais `rombergtol' e `rombergit'. `romberg' retornará
6130
um resultado se a diferença relativa em sucessivas approximações é
6131
menor que `rombergtol'. Isso tentará dividir ao meio o tamanho do
6132
passoe `rombergit' vezes antes disso ser abandonado.
6135
-- Variável de opção: rombergmin
6138
`rombergmin' governa o número mínimo de avaliações de função que
6139
`romberg' fará. `romberg' avaliará seu primeiro argumento pelo
6140
menos `2^(rombergmin+2)+1' vezes. Isso é útil para integrar
6141
funções oscilatórias, onde o teste normal de convergência pode
6142
lgumas vezes inadequadamente passar.
6145
-- Variável de opção: rombergtol
6148
A precisão do comando de integração de `romberg' é governada pelas
6149
variáveis globais `rombergtol' e `rombergit'. `romberg' retornará
6150
um resultado se a difereça relativa em sucessivas aproximações é
6151
menor que `rombergtol'. Isso tentará dividir ao meio o tamanho do
6152
passo `rombergit' vezes antes disso ser abandonado.
6155
-- Função: tldefint (<expr>, <x>, <a>, <b>)
6156
Equivalente a `ldefint' com `tlimswitch' escolhido para `true'.
6160
File: maxima.info, Node: Introdução a QUADPACK, Next: Definições para QUADPACK, Prev: Definições para Integração, Up: Integração
6162
20.3 Introdução a QUADPACK
6163
==========================
6165
QUADPACK é uma coleção de funções para aálculo numérico de integrais
6166
definidas unidimensionais. O pacote QUADPACK resultou da junção de um
6167
projeto de R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), e D.
6170
A biblioteca QUADPACK inclída no Maxima é uma tradução automática
6171
(feita através do programa `f2cl') do código fonte em de QUADPACK como
6172
aparece na SLATEC Common Mathematical Library, Versão 4.1 (5). A
6173
biblioteca Fortran SLATEC é datada de Julho de 1993, mas as funções
6174
QUADPACK foram escritas alguns anos antes. Existe outra versão de
6175
QUADPACK em Netlib (6); não está claro no que aquela versão difere da
6176
versão existente em SLATEC.
6178
As funções QUADPACK incluídas no Maxima são toda automáticas, no
6179
sentido de que essas funções tentam calcular um resultado para uma
6180
precisão específica, requerendo um número não especificado de
6181
avaliações de função. A tradução do Lisp do Maxima da iblioteca
6182
QUADPACK também inclui algumas funçòes não automáticas, mas elas não
6183
são expostas a nível de Maxima.
6185
Informação adicionalsobre a bilioteca QUADPACK pode ser encontrada
6186
no livro do QUADPACK (7).
6192
Integração de uma função genérica sobre um intervalo finito.
6193
`quad_qag' implementa um integrador adaptativo globalmente simples
6194
usando a estratégia de Aind (Piessens, 1973). O chamador pode
6195
escolher entre 6 pares de formulas da quadratura de Gauss-Kronrod
6196
para a componente de avaliação da regra. As regras de alto grau
6197
são adequadas para integrandos fortemente oscilantes.
6200
Integração de uma função genérica sob um intervalo finito.
6201
`quad_qags' implementa subdivisão de intervalos globalmente
6202
adaptativos com extrapolação (de Doncker, 1978) por meio do
6203
algorítmo de Epsilon (Wynn, 1956).
6206
Integração de uma função genérica sobre um intervalo finito ou
6207
semi-finito. O intervalo é mapeado sobre um intervalo finito e
6208
então a mesma estratégia de `quad_qags' é aplicada.
6211
Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um
6212
intervalo finito, onde omega é uma constante. A componente de
6213
avaliação da regra é baseada na técnica modificada de
6214
Clenshaw-Curtis. `quad_qawo' aplica subdivisão adaptativa com
6215
extrapolação, similar a `quad_qags'.
6218
Calcula uma transformação de cosseno de Fourier ou de um seno de
6219
Fourier sobre um intervalo semi-finito. O mesmo aproxima como
6220
`quad_qawo' aplicado sobre intervalos finitos sucessivos, e
6221
aceleração de convergência por meio d algorítimo de Epsilon (Wynn,
6222
1956) aplicado a séries de contribuições de integrais.
6225
Integraçào de w(x) f(x) sobre um intervalo finito [a, b], onde w é
6226
uma função da forma (x - a)^alpha (b - x)^beta v(x) e v(x) é 1 ou
6227
log(x - a) ou log(b - x) ou log(x - a) log(b - x), e alpha > -1 e
6228
beta > -1. Auma estratégia de subdivisão adaptativa é aplicada,
6229
com integração modificada de Clenshaw-Curtis sobre os
6230
subintervalos que possuem a ou b.
6233
Calcula o valor principal de Cauchy de f(x)/(x - c) sobre um
6234
intervalo finito (a, b) e um c especificado. A estratégia é
6235
globalmente adaptativa, e a integração modificada de
6236
Clenshaw-Curtis é usada sobre subamplitudes que possuírem o ponto
6239
---------- Footnotes ----------
6241
(1) Applied Mathematics and Programming Division, K.U. Leuven
6243
(2) Applied Mathematics and Programming Division, K.U. Leuven
6245
(3) Institut für Mathematik, T.U. Wien
6247
(4) National Bureau of Standards, Washington, D.C., U.S.A
6249
(5) http://www.netlib.org/slatec
6251
(6) http://www.netlib.org/quadpack
6253
(7) R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, e D.K.
6254
Kahaner. QUADPACK: A Subroutine Package for Automatic Integration.
6255
Berlin: Springer-Verlag, 1983, ISBN 0387125531.
6258
File: maxima.info, Node: Definições para QUADPACK, Prev: Introdução a QUADPACK, Up: Integração
6260
20.4 Definições para QUADPACK
6261
=============================
6263
-- Função: quad_qag (<f(x)>, <x>, <a>, <b>, <chave>, <epsrel>,
6265
-- Função: quad_qag (<f>, <x>, <a>, <b>, <chave>, <epsrel>, <limite>)
6266
Integração de uma função genérica sobre um intervalo finito.
6267
`quad_qag' implementa um integrador adaptativo globalmente simples
6268
usando a estratégia de Aind (Piessens, 1973). O chamador pode
6269
escolher entre 6 pares de fórmulas da quadratura de Gauss-Kronrod
6270
para a componente de avaliação da regra. As regras de alto nível
6271
são adequadas para integrandos fortemente oscilatórios.
6273
`quad_qag' calcula a integral
6275
integrate (f(x), x, a, b)
6277
A função a ser integrada é <f(x)>, com variável dependente <x>, e
6278
a função é para ser integrada entre os limites <a> e <b>. <chave>
6279
é o integrador a ser usado e pode ser um inteiro entre 1 e 6,
6280
inclusive. O valor de <chave> seleciona a ordem da regra de
6281
integração de Gauss-Kronrod. Regra de alta ordem são adequadas
6282
para integrandos fortemente oscilatórios.
6284
O integrando pode ser especidficado como o nome de uma função
6285
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6286
Maxima, ou uma expressão geral do Maxima.
6288
A integração numérica é concluída adaptativamente pela subdivisão a
6289
região de integração até que a precisão desejada for completada.
6291
Os argumentos opcionais <epsrel> e <limite> são o erro relativo
6292
desejado e o número máximo de subintervalos respectivamente.
6293
<epsrel> padrão em 1e-8 e <limite> é 200.
6295
`quad_qag' retorna uma lista de quatro elementos:
6297
* uma aproximação para a integral,
6299
* o erro absoluto estimado da aproximação,
6301
* o número de avaliações do integrando,
6303
* um código de erro.
6305
O código de erro (quarto elemento do valor de retorno) pode ter os
6309
se nenhum problema for encontrado;
6312
se muitos subintervalos foram concluídos;
6315
se erro excessivo é detectado;
6318
se ocorre comportamento extremamente ruim do integrando;
6321
se a entrada é inválida.
6326
(%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3);
6327
(%o1) [.4444444444492108, 3.1700968502883E-9, 961, 0]
6328
(%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
6333
-- Função: quad_qags (<f(x)>, <x>, <a>, <b>, <epsrel>, <limite>)
6334
-- Função: quad_qags (<f>, <x>, <a>, <b>, <epsrel>, <limite>)
6335
Integração de uma função geral sobre um intervalo finito.
6336
`quad_qags' implementa subdivisão de intervalo globalmente
6337
adaptativa com extrapolação (de Doncker, 1978) através do
6338
algorítmo de (Wynn, 1956).
6340
`quad_qags' computes the integral
6342
integrate (f(x), x, a, b)
6344
A função a ser integrada é <f(x)>, com variável dependente <x>, e
6345
a função é para ser integrada entre os limites <a> e <b>.
6347
O integrando pode ser especidficado como o nome de uma função
6348
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6349
Maxima, ou uma expressão geral do Maxima.
6351
Os argumentos opcionais <epsrel> e <limite> são o erro relativo
6352
desejado e o número máximo de subintervalos, respectivamente.
6353
<epsrel> padrão em 1e-8 e <limite> é 200.
6355
`quad_qags' retorna uma lista de quatro elementos:
6357
* uma aproximação para a integral,
6359
* o erro absoluto estimado da aproximação,
6361
* o número de avaliações do integrando,
6363
* um código de erro.
6365
O código de erro (quarto elemento do valor de retorno) pode ter os
6369
nenhum problema foi encontrado;
6372
muitos subintervalos foram concluídos;
6375
erro excessivo é detectado;
6378
ocorreu comportamento excessivamente ruim do integrando;
6381
falhou para convergência
6384
integral é provavelmente divergente ou lentamente convergente
6387
se a entrada é inválida.
6391
(%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1);
6392
(%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0]
6394
Note que `quad_qags' é mais preciso e eficiente que `quad_qag'
6395
para esse integrando.
6398
-- Função: quad_qagi (<f(x)>, <x>, <a>, <inftype>, <epsrel>, <limite>)
6399
-- Função: quad_qagi (<f>, <x>, <a>, <inftype>, <epsrel>, <limite>)
6400
Integração de uma função genérica sobre um intervalo finito ou
6401
semi-finito. O intervalo é mapeado sobre um intervalo finito e
6402
então a mesma estratégia que em `quad_qags' é aplicada.
6404
`quad_qagi' avalia uma das seguintes integrais
6406
integrate (f(x), x, minf, inf)
6408
integrate (f(x), x, minf, a)
6410
integrate (f(x), x, a, minf, inf)
6412
usando a rotina Quadpack QAGI. A função a ser integrada é <f(x)>,
6413
com variável dependente <x>, e a função é para ser integrada sobre
6414
um intervalo infinito.
6416
O integrando pode ser especidficado como o nome de uma função
6417
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6418
Maxima, ou uma expressão geral do Maxima.
6420
O parâmetro <inftype> determina o intervalo de integração como
6424
O intervalo vai de <a> ao infinito positivo.
6427
O intervalo vai do infinito negativo até <a>.
6430
O intervalo corresponde a toda reta real.
6432
Os argumentos opcionais <epsrel> e <limite> são o erro relativo
6433
desejado e o número maximo de subintervalos, respectivamente.
6434
<epsrel> padrão para 1e-8 e <limite> é 200.
6436
`quad_qagi' retorna uma lista de quatro elementos:
6438
* uma aproximação para a integral,
6440
* o erro absoluto estimado da aproximação,
6442
* o número de avaliações do integrando,
6444
* um código de erro.
6446
O código de erro (quarto elemento do valor de retorno) pode ter os
6450
nenhum problema foi encontrado;
6453
muitos subintervalos foram concluídos;
6456
erro excessivo é detectado;
6459
ocorreu comportamento excessivamente ruim do integrando;
6462
falhou para convergência;
6465
integral é provavelmente divergente ou lentamente convergente;
6468
se a entrada for inválida.
6473
(%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf);
6474
(%o1) [0.03125, 2.95916102995002E-11, 105, 0]
6475
(%i2) integrate (x^2*exp(-4*x), x, 0, inf);
6481
-- Função: quad_qawc (<f(x)>, <x>, <c>, <a>, <b>, <epsrel>, <limite>)
6482
-- Função: quad_qawc (<f>, <x>, <c>, <a>, <b>, <epsrel>, <limite>)
6483
Calcula o valor principal de Cauchy de f(x)/(x - c) over a finite
6484
interval. A estratégia é globalmente adaptativa, e a integração de
6485
Clenshaw-Curtis modificada é usada sobre as subamplitudes que
6486
possuírem o ponto x = c.
6488
`quad_qawc' calcula o valor principal de Cauchy de
6490
integrate (f(x)/(x - c), x, a, b)
6492
usando a rotina Quadpack QAWC. A função a ser integrada é
6493
`<f(x)>/(<x> - <c>)', com variável dependente <x>, e a função é
6494
para ser integrada sobre o intervalo que vai de <a> até <b>.
6496
O integrando pode ser especidficado como o nome de uma função
6497
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6498
Maxima, ou uma expressão geral do Maxima.
6500
Os argumentos opcionais <epsrel> e <limite> são o erro relativo
6501
desejado e o máximo número de subintervalos, respectivamente.
6502
<epsrel> padrão para 1e-8 e <limite> é 200.
6504
`quad_qawc' retorna uma lista de quatro elementos:
6506
* uma aproximação para a integral,
6508
* o erro absoluto estimado da aproximação,
6510
* o número de avaliações do integrando,
6512
* um código de erro.
6514
O código de erro (quarto elemento do valoor de retorno) pode ter
6518
nenhum problema foi encontrado;
6521
muitos subintervalos foram concluídos;
6524
erro excessivo é detectado;
6527
ocorreu comportamento excessivamente ruim do integrando;
6530
se a entrada é inválida.
6535
(%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5);
6536
(%o1) [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
6537
(%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5);
6541
4 log(------------- + -------------)
6544
(%o2) (-----------------------------------------
6551
2 4 atan(4 4 ) 2 4 atan(4 ) alpha
6552
- --------------------------- - -------------------------)/2
6555
(%i3) ev (%, alpha=5, numer);
6556
(%o3) - 3.130120337415917
6559
-- Função: quad_qawf (<f(x)>, <x>, <a>, <omega>, <trig>, <epsabs>,
6560
<limit>, <maxp1>, <limlst>)
6561
-- Função: quad_qawf (<f>, <x>, <a>, <omega>, <trig>, <epsabs>,
6562
<limit>, <maxp1>, <limlst>)
6563
Calcula uma transformação de cosseno de Fourier ou de um seno de
6564
Fourier sobre um intervalo semi-finito. usando a função QAWF do
6565
pacote Quadpack. A mesma aproxima como em `quad_qawo' quando
6566
aplicada sobre intervalos finitos sucessivos, e aceleração de
6567
convergência por meio d algorítimo de Epsilon (Wynn, 1956)
6568
aplicado a séries de contribuições de integrais.
6570
`quad_qawf' calcula a integral
6572
integrate (f(x)*w(x), x, a, inf)
6574
A função peso w é selecionada por <trig>:
6577
w(x) = cos (omega x)
6580
w(x) = sin (omega x)
6582
O integrando pode ser especidficado como o nome de uma função
6583
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6584
Maxima, ou uma expressão geral do Maxima.
6586
Os argumentos opcionais são:
6589
Erro absoluto de aproximação desejado. Padrão é 1d-10.
6592
Tamanho de array interno de trabalho. (<limit> - <limlst>)/2
6593
é o maximo número de subintervalos para usar. O Padrão é 200.
6596
O número máximo dos momentos de Chebyshev. Deve ser maior
6597
que 0. O padrão é 100.
6600
Limite superior sobre número de ciclos. Deve ser maior ou
6601
igual a 3. O padrão é 10.
6603
<epsabs> e <limit> são o erro relativo desejado e o número maximo
6604
de subintervalos, respectivamente. <epsrel> padrão para 1e-8 e
6607
`quad_qawf' retorna uma lista de quatro elementos:
6609
* uma aproximação para a integral,
6611
* o erro absoluto estimado da aproximação,
6613
* o número de avaliações do integrando,
6615
* um código de erro.
6617
O código de erro (quarto elemento do valor de retorno) pode ter os
6621
nenhum problema foi encontrado;
6624
muitos subintervalos foram concluídos;
6627
erro excessivo é detectado;
6630
ocorreu um comportamento excessivamente ruim do integrando;
6633
se a entrada é invalida.
6638
(%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos);
6639
(%o1) [.6901942235215714, 2.84846300257552E-11, 215, 0]
6640
(%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
6643
(%o2) -----------------
6645
(%i3) ev (%, numer);
6646
(%o3) .6901942235215714
6649
-- Função: quad_qawo (<f(x)>, <x>, <a>, <b>, <omega>, <trig>,
6650
<epsabs>, <limite>, <maxp1>, <limlst>)
6651
-- Função: quad_qawo (<f>, <x>, <a>, <b>, <omega>, <trig>, <epsabs>,
6652
<limite>, <maxp1>, <limlst>)
6653
Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um
6654
intervalo finito, onde omega é uma constante. A componente de
6655
avaliação da regra é baseada na técnica modificada de
6656
Clenshaw-Curtis. `quad_qawo' aplica subdivisão adaptativa com
6657
extrapolação, similar a `quad_qags'.
6659
`quad_qawo' calcula a integral usando a rotina Quadpack QAWO:
6661
integrate (f(x)*w(x), x, a, b)
6663
A função peso w é selecionada por <trig>:
6666
w(x) = cos (omega x)
6669
w(x) = sin (omega x)
6671
O integrando pode ser especidficado como o nome de uma função
6672
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6673
Maxima, ou uma expressão geral do Maxima.
6675
Os argumentos opcionais são:
6678
Erro absoluto desejado de aproximação. O Padrão é 1d-10.
6681
Tamanho do array interno de trabalho. (<limite> -
6682
<limlst>)/2 é o número máximo de subintervalos a serem
6683
usados. Default é 200.
6686
Número máximo dos momentos de Chebyshev. Deve ser maior que
6690
Limite superior sobre o número de ciclos. Deve ser maior que
6691
ou igual a 3. O padrão é 10.
6693
<epsabs> e <limite> são o erro relativo desejado e o número máximo
6694
de subintervalos, respectivamente. <epsrel> o padrão é 1e-8 e
6697
`quad_qawo' retorna uma lista de quatro elementos:
6699
* uma aproximação para a integral,
6701
* o erro absoluto estimado da aproximação,
6703
* o número de avaliações do integrando,
6705
* um código de erro.
6707
O código de erro (quarto elemento do valor de retorno) pode ter os
6711
nenhum problema foi encontrado;
6714
muitos subintervalos foram concluídos;
6717
erro excessivo é detectado;
6720
comportamento extremamente ruim do integrando;
6723
se a entrada é inválida.
6728
(%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
6729
(%o1) [1.376043389877692, 4.72710759424899E-11, 765, 0]
6730
(%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf));
6731
alpha/2 - 1/2 2 alpha
6732
sqrt(%pi) 2 sqrt(sqrt(2 + 1) + 1)
6733
(%o2) -----------------------------------------------------
6736
(%i3) ev (%, alpha=2, numer);
6737
(%o3) 1.376043390090716
6740
-- Função: quad_qaws (<f(x)>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>,
6742
-- Função: quad_qaws (<f>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>,
6744
Integração de w(x) f(x) sobre um intervalo finito, onde w(x) é uma
6745
certa função algébrica ou logarítmica. Uma estratégia de
6746
subdivisão globalmente adaptativa é aplicada, com integração
6747
modificada de Clenshaw-Curtis sobre os subintervalos que possuírem
6748
os pontos finais dos intervalos de integração.
6750
`quad_qaws' calcula a integral usando a rotina Quadpack QAWS:
6752
integrate (f(x)*w(x), x, a, b)
6754
A função peso w é selecionada por <wfun>:
6757
w(x) = (x - a)^alpha (b - x)^beta
6760
w(x) = (x - a)^alpha (b - x)^beta log(x - a)
6763
w(x) = (x - a)^alpha (b - x)^beta log(b - x)
6766
w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)
6768
O integrando pode ser especidficado como o nome de uma função
6769
Maxima ou uma função Lisp ou um operador, uma expressão lambda do
6770
Maxima, ou uma expressão geral do Maxima.
6772
O argumentos opcionais são:
6775
Erro absoluto desejado de aproximação. O padrão é 1d-10.
6778
Tamanho do array interno de trabalho. (<limite> -
6779
<limlst>)/2 é o número máximo de subintervalos para usar. O
6782
<epsabs> e <limit> são o erro relativo desejado e o número máximo
6783
de subintervalos, respectivamente. <epsrel> o padrão é 1e-8 e
6786
`quad_qaws' retorna uma lista de quatro elementos:
6788
* uma aproximação para a integral,
6790
* o erro absoluto estimado da aproximação,
6792
* o número de avaliações do integrando,
6794
* um código de erro.
6796
O código de erro (quarto elemento do valor de retorno) pode ter os
6800
nenhum problema foi encontrado;
6803
muitos subintervalos foram concluídos;
6806
erro excessivo é detectado;
6809
ocorreu um comportamento excessivamente ruim do integrando;
6812
se a entrada é invalida.
6817
(%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1);
6818
(%o1) [8.750097361672832, 1.24321522715422E-10, 170, 0]
6819
(%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
6821
Is 4 2 - 1 positive, negative, or zero?
6825
2 %pi 2 sqrt(2 2 + 1)
6826
(%o2) -------------------------------
6829
(%i3) ev (%, alpha=4, numer);
6830
(%o3) 8.750097361672829
6834
File: maxima.info, Node: Equações, Next: Equações Diferenciais, Prev: Integração, Up: Top
6841
* Definições para Equações::
added
removed
doc/info/pt.utf8/maxima.info-2
