1This is maxima.info, produced by makeinfo version 6.6 from maxima.texi. 2 3Esse é um Manual do Maxima no formato Texinfo 4 5 Copyright 1994,2001 William F. Schelter 6 7START-INFO-DIR-ENTRY 8* Maxima: (maxima). Um sistema de álgebra computacional. 9END-INFO-DIR-ENTRY 10 11 12File: maxima.info, Node: Ponto Flutuante, Next: Contextos, Prev: Entrada e Saída, Up: Top 13 1410 Ponto Flutuante 15****************** 16 17* Menu: 18 19* Funções e Variáveis Definidas para ponto Flutuante:: 20 21 22File: maxima.info, Node: Funções e Variáveis Definidas para ponto Flutuante, Prev: Ponto Flutuante, Up: Ponto Flutuante 23 2410.1 Funções e Variáveis Definidas para ponto Flutuante 25======================================================= 26 27 -- Função: bffac (<expr>, <n>) 28 Versão para grandes números em ponto flutuante da função 29 'factorial' (usa o artifício gamma). O segundo argumento informa 30 quantos dígitos reter e retornar, isso é uma boa idéia para 31 requisitar precisão adicional. 32 33 'load ("bffac")' chama essa função. 34 35 -- Variável de Opção: algepsilon 36 Valor padrão: 10^8 37 38 'algepsilon' é usada por 'algsys'. 39 40 -- Função: bfloat (<expr>) 41 Converte todos os números e funções de números em <expr> para 42 grandes números em ponto flutuante (bigfloat). O número de 43 algarismos significativos no grande número em ponto flutuante 44 resultante é especificado através da variável global 'fpprec'. 45 46 Quando 'float2bf' for 'false' uma mensagem de alerta é mostrada 47 quando uma número em ponto flutuante (float) é convertido em um 48 grande número em ponto flutuante (bigfloat - uma vez que isso pode 49 resultar em perda de precisão). 50 51 -- Função: bfloatp (<expr>) 52 Retorna 'true' se a avaliação da <expr> resultar em um grande 53 número em ponto flutuante, de outra forma retorna 'false'. 54 55 -- Função: bfpsi (<n>, <z>, <fpprec>) 56 -- Função: bfpsi0 (<z>, <fpprec>) 57 'bfpsi' é a função 'polygamma' de argumentos reais <z> e ordem de 58 inteiro <n>. 'bfpsi0' é a função 'digamma'. 'bfpsi0 (<z>, 59 <fpprec>)' é equivalente a 'bfpsi (0, <z>, <fpprec>)'. 60 61 Essas funções retornam valores em grandes números em ponto 62 flutuante. <fpprec> é a precisão do valor de retorno dos grandes 63 números em ponto flutuante. 64 65 'load ("bffac")' chama essas funções. 66 67 -- Variável de Opção: bftorat 68 Valor padrão: 'false' 69 70 'bftorat' controla a conversão de 'bfloats' para números racionais. 71 Quando 'bftorat' for 'false', 'ratepsilon' será usada para 72 controlar a conversão (isso resulta em números racionais 73 relativametne pequenos). Quando 'bftorat' for 'true', o número 74 racional gerado irá representar precisamente o 'bfloat'. 75 76 -- Variável de Opção: bftrunc 77 Valor padrão: 'true' 78 79 'bftrunc' faz com que tilhas de zeros em grandes números em ponto 80 flutuante diferentes de zero sejam ocultadas. Desse modo, se 81 'bftrunc' for 'false', 'bfloat (1)' será mostrado como 82 '1.000000000000000B0'. De outra forma, será mostrado como '1.0B0'. 83 84 -- Função: cbffac (<z>, <fpprec>) 85 Fatorial complexo de grandes números em ponto flutuante. 86 87 'load ("bffac")' chama essa função. 88 89 -- Função: float (<expr>) 90 Converte inteiros, números racionais e grandes números em ponto 91 flutuante em <expr> para números em ponto flutuante. Da mesma 92 forma um 'evflag', 'float' faz com que números racionais 93 não-inteiros e grandes números em ponto flutuante sejam convertidos 94 para ponto flutuante. 95 96 -- Variável de Opção: float2bf 97 Valor padrão: 'false' 98 99 Quando 'float2bf' for 'false', uma mensagem de alerta é mostrada 100 quando um número em ponto flutuante é convertido em um grande 101 número em ponto flutuante (uma vez que isso pode resultar em perda 102 de precisão). 103 104 -- Função: floatnump (<expr>) 105 Retorna 'true' se <expr> for um número em ponto flutuante, de outra 106 forma retorna 'false'. 107 108 -- Variável de Opção: fpprec 109 Valor padrão: 16 110 111 'fpprec' é o número de algarismos significativos para aritmética 112 sobre grandes números em ponto flutuante 'fpprec' não afeta 113 cálculos sobre números em ponto flutuante comuns. 114 115 Veja também 'bfloat' e 'fpprintprec'. 116 117 -- Variável de Opção: fpprintprec 118 Valor padrão: 0 119 120 'fpprintprec' é o n;umero de dígitos a serem mostrados na tela 121 quando no caso de nuúmeros em ponto flutuante e no caso de grandes 122 números em ponto flutuante. 123 124 Para números em ponto flutuante comuns, quando 'fpprintprec' tiver 125 um valor entre 2 e 16 (inclusive), o n;umero de dígitos mostrado na 126 tela é igual a 'fpprintprec'. De outra forma, 'fpprintprec' é 0, 127 ou maior que 16, e o número de dígitos mostrados é 16. 128 129 Para grandes números em ponto flutuante, quando 'fpprintprec' tiver 130 um valor entre 2 e 'fpprec' (inclusive), o n;umero de dígitos 131 mostrados é giaul a 'fpprintprec'. De outra forma, 'fpprintprec' é 132 0, ou maior que 'fpprec', e o n;umero de dígitos mostrados é igual 133 a 'fpprec'. 134 135 'fpprintprec' não pode ser 1. 136 137 138File: maxima.info, Node: Contextos, Next: Polinômios, Prev: Ponto Flutuante, Up: Top 139 14011 Contextos 141************ 142 143* Menu: 144 145* Funções e Variáveis Definidas para Contextos:: 146 147 148File: maxima.info, Node: Funções e Variáveis Definidas para Contextos, Prev: Contextos, Up: Contextos 149 15011.1 Funções e Variáveis Definidas para Contextos 151================================================= 152 153 -- Função: activate (<context_1>, ..., <context_n>) 154 Ativa os contextos <context_1>, ..., <context_n>. Os fatos nesses 155 contextos estão então disponíveis para fazer deduções e recuperar 156 informação. Os fatos nesses contextos não são listadas através de 157 'facts ()'. 158 159 A variável 'activecontexts' é a lista de contextos que estão ativos 160 pelo caminho da função 'activate'. 161 162 -- Variável de sistema: activecontexts 163 Valor padrão: '[]' 164 165 'activecontexts' é a lista de contextos que estão ativos pelo 166 caminho da função 'activate', em oposição a sendo ativo porque eles 167 são subcontextos do contexto corrente. 168 169 -- Função: assume (<pred_1>, ..., <pred_n>) 170 Adiciona predicados <pred_1>, ..., <pred_n> ao contexto corrente. 171 Se um predicado for incossistente ou redundante com os predicados 172 no contexto corrente, esses predicados não são adicionados ao 173 contexto. O contexto acumula predicados de cada chamada a 174 'assume'. 175 176 'assume' retorna uma lista cujos elementos são os predicados 177 adicionados ao contexto ou os átomos 'redundant' ou 'inconsistent' 178 onde for aplicável. 179 180 Os predicados <pred_1>, ..., <pred_n> podem somente ser expressões 181 com os operadores relacionais '< <= equal notequal >=' e '>'. 182 Predicados não podem ser expressões de igualdades literais '=' ou 183 expressões de desigualdades literais '#', nem podem elas serem 184 funções de predicado tais como 'integerp'. 185 186 Predicados combinados da forma '<pred_1> and ... and <pred_n>' são 187 reconhecidos, mas não '<pred_1> or ... or <pred_n>'. 'not 188 <pred_k>' é reconhecidos se <pred_k> for um predicado relacional. 189 Expressões da forma 'not (<pred_1> e <pred_2>)' and 'not (<pred_1> 190 or <pred_2>)' não são reconhecidas. 191 192 O mecanismo de dedução do Maxima não é muito forte; exitem 193 conseqüências muito óbvias as quais não podem ser determinadas por 194 meio de 'is'. Isso é uma fraqueza conhecida. 195 196 'assume' avalia seus argumentos. 197 198 Veja também 'is', 'facts', 'forget', 'context', e 'declare'. 199 200 Exemplos: 201 202 (%i1) assume (xx > 0, yy < -1, zz >= 0); 203 (%o1) [xx > 0, yy < - 1, zz >= 0] 204 (%i2) assume (aa < bb and bb < cc); 205 (%o2) [bb > aa, cc > bb] 206 (%i3) facts (); 207 (%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb] 208 (%i4) is (xx > yy); 209 (%o4) true 210 (%i5) is (yy < -yy); 211 (%o5) true 212 (%i6) is (sinh (bb - aa) > 0); 213 (%o6) true 214 (%i7) forget (bb > aa); 215 (%o7) [bb > aa] 216 (%i8) prederror : false; 217 (%o8) false 218 (%i9) is (sinh (bb - aa) > 0); 219 (%o9) unknown 220 (%i10) is (bb^2 < cc^2); 221 (%o10) unknown 222 223 -- Variável de opção: assumescalar 224 Valor padrão: 'true' 225 226 'assumescalar' ajuda a governar se expressões 'expr' para as quais 227 'nonscalarp (expr)' for 'false' são assumidas comportar-se como 228 escalares para certas transformações. 229 230 Tomemos 'expr' representando qualquer expressão outra que não uma 231 lista ou uma matriz, e tomemos '[1, 2, 3]' representando qualquer 232 lista ou matriz. Então 'expr . [1, 2, 3]' retorna '[expr, 2 expr, 233 3 expr]' se 'assumescalar' for 'true', ou 'scalarp (expr)' for 234 'true', ou 'constantp (expr)' for 'true'. 235 236 Se 'assumescalar' for 'true', tais expressões irão comportar-se 237 como escalares somente para operadores comutativos, mas não para 238 multiplicação não comutativa '.'. 239 240 Quando 'assumescalar' for 'false', tais expressões irão 241 comportar-se como não escalares. 242 243 Quando 'assumescalar' for 'all', tais expressões irão comportar-se 244 como escalares para todos os operadores listados acima. 245 246 -- Variável de opção: assume_pos 247 Valor padrão: 'false' 248 249 Quando 'assume_pos' for 'true' e o sinal de um parâmetro <x> não 250 pode ser determinado a partir do contexto corrente ou outras 251 considerações, 'sign' e 'asksign (<x>)' retornam 'true'. Isso pode 252 impedir algum questionamento de 'asksign' gerado automaticamente, 253 tal como pode surgir de 'integrate' ou de outros cálculos. 254 255 Por padrão, um parâmetro é <x> tal como 'symbolp (<x>)' or 'subvarp 256 (<x>)'. A classe de expressões consideradas parâmetros pode ser 257 modificada para alguma abrangência através da variável 258 'assume_pos_pred'. 259 260 'sign' e 'asksign' tentam deduzir o sinal de expressões a partir de 261 sinais de operandos dentro da expressão. Por exemplo, se 'a' e 'b' 262 são ambos positivos, então 'a + b' é também positivo. 263 264 Todavia, não existe caminho para desviar todos os questionamentos 265 de 'asksign'. Particularmente, quando o argumento de 'asksign' for 266 uma diferença '<x> - <y>' ou um logarítmo 'log(<x>)', 'asksign' 267 sempre solicita uma entrada ao usuário, mesmo quando 'assume_pos' 268 for 'true' e 'assume_pos_pred' for uma função que retorna 'true' 269 para todos os argumentos. 270 271 -- Variável de opção: assume_pos_pred 272 Valor padrão: 'false' 273 274 Quando 'assume_pos_pred' for atribuído o nome de uma função ou uma 275 expressão lambda de um argumento <x>, aquela função é chamada para 276 determinar se <x> é considerado um parâmetro para o propósito de 277 'assume_pos'. 'assume_pos_pred' é ignorado quando 'assume_pos' for 278 'false'. 279 280 A função 'assume_pos_pred' é chamada através de 'sign' e de 281 'asksign' com um argumento <x> que é ou um átomo, uma variável 282 subscrita, ou uma expressão de chamada de função. Se a função 283 'assume_pos_pred' retorna 'true', <x> é considerado um parâmetro 284 para o propósito de 'assume_pos'. 285 286 Por padrão, um parâmetro é <x> tal que 'symbolp (x)' ou 'subvarp 287 (x)'. 288 289 Veja também 'assume' e 'assume_pos'. 290 291 Exemplos: 292 293 (%i1) assume_pos: true$ 294 (%i2) assume_pos_pred: symbolp$ 295 (%i3) sign (a); 296 (%o3) pos 297 (%i4) sign (a[1]); 298 (%o4) pnz 299 (%i5) assume_pos_pred: lambda ([x], display (x), true)$ 300 (%i6) asksign (a); 301 x = a 302 303 (%o6) pos 304 (%i7) asksign (a[1]); 305 x = a 306 1 307 308 (%o7) pos 309 (%i8) asksign (foo (a)); 310 x = foo(a) 311 312 (%o8) pos 313 (%i9) asksign (foo (a) + bar (b)); 314 x = foo(a) 315 316 x = bar(b) 317 318 (%o9) pos 319 (%i10) asksign (log (a)); 320 x = a 321 322 Is a - 1 positive, negative, or zero? 323 324 p; 325 (%o10) pos 326 (%i11) asksign (a - b); 327 x = a 328 329 x = b 330 331 x = a 332 333 x = b 334 335 Is b - a positive, negative, or zero? 336 337 p; 338 (%o11) neg 339 340 -- Variável de opção: context 341 Valor padrão: 'initial' 342 343 'context' nomeia a coleção de fatos mantida através de 'assume' e 344 'forget'. 'assume' adiciona fatos à coleção nomeada através de 345 'context', enquanto 'forget' remove fatos. 346 347 Associando 'context' para um nome <foo> altera o contexto corrente 348 para <foo>. Se o contexto especificado <foo> não existe ainda, ele 349 é criado automaticamente através de uma chamada a 'newcontext'. O 350 contexto especificado é ativado automaticamente. 351 352 Veja 'contexts' para uma descrição geral do mecanismo de contexto. 353 354 -- Variável de opção: contexts 355 Valor padrão: '[initial, global]' 356 357 'contexts' é uma lista dos contextos que existem atualmente, 358 incluindo o contexto ativo atualmente. 359 360 O mecanismo de contexto torna possível para um usuário associar e 361 nomear uma porção selecionada de fatos, chamada um contexto. Assim 362 que isso for concluído, o usuário pode ter o Maxima assumindo ou 363 esquecendo grande quantidade de fatos meramente através da ativação 364 ou desativação seu contexto. 365 366 Qualquer átomo simbólico pode ser um contexto, e os fatos contidos 367 naquele contexto irão ser retidos em armazenamento até que sejam 368 destruídos um por um através de chamadas a 'forget' ou destruídos 369 com um conjunto através de uma chamada a 'kill' para destruir o 370 contexto que eles pertencem. 371 372 Contextos existem em uma hierarquía, com o raíz sempre sendo o 373 contexto 'global', que contém informações sobre Maxima que alguma 374 função precisa. Quando em um contexto dado, todos os fatos naquele 375 contexto estão "ativos" (significando que eles são usados em 376 deduções e recuperados) como estão também todos os fatos em 377 qualquer contexto que for um subcontexto do contexto ativo. 378 379 Quando um novo Maxima for iniciado, o usuário está em um contexto 380 chamado 'initial', que tem 'global' como um subcontexto. 381 382 Veja também 'facts', 'newcontext', 'supcontext', 'killcontext', 383 'activate', 'deactivate', 'assume', e 'forget'. 384 385 -- Função: deactivate (<context_1>, ..., <context_n>) 386 Desativa os contextos especificados <context_1>, ..., <context_n>. 387 388 -- Função: facts (<item>) 389 -- Função: facts () 390 Se <item> for o nome de um contexto, 'facts (<item>)' retorna uma 391 lista de fatos no contexto especificado. 392 393 Se <item> não for o nome de um contexto, 'facts (<item>)' retorna 394 uma lista de fatos conhecidos sobre <item> no contexto atual. 395 Fatos que estão atuvos, mas em um diferente contexto, não são 396 listados. 397 398 'facts ()' (i.e., sem argumento) lista o contexto atual. 399 400 -- Declaração: features 401 Maxima recnhece ceertas propriedades matemáticas de funções e 402 variáveis. Essas são chamadas "recursos". 403 404 'declare (<x>, <foo>)' fornece a propriedade <foo> para a função ou 405 variável <x>. 406 407 'declare (<foo>, recurso)' declara um novo recurso <foo>. Por 408 exemplo, 'declare ([red, green, blue], feature)' declara três novos 409 recursos, 'red', 'green', e 'blue'. 410 411 O predicado 'featurep (<x>, <foo>)' retorna 'true' se <x> possui a 412 propriedade <foo>, e 'false' de outra forma. 413 414 A infolista 'features' é uma lista de recursos conhecidos. São 415 esses 'integer', 'noninteger', 'even', 'odd', 'rational', 416 'irrational', 'real', 'imaginary', 'complex', 'analytic', 417 'increasing', 'decreasing', 'oddfun', 'evenfun', 'posfun', 418 'commutative', 'lassociative', 'rassociative', 'symmetric', e 419 'antisymmetric', mais quaisquer recursos definidos pelo usuário. 420 421 'features' é uma lista de recursos matemáticos. Existe também uma 422 lista de recursos não matemáticos, recursos dependentes do sistema. 423 Veja 'status'. 424 425 -- Função: forget (<pred_1>, ..., <pred_n>) 426 -- Função: forget (<L>) 427 Remove predicados estabelecidos através de 'assume'. Os predicados 428 podem ser expressões equivalentes a (mas não necessáriamente 429 idênticas a) esses prevamentes assumidos. 430 431 'forget (<L>)', onde <L> é uma lista de predicados, esquece cada 432 item da lista. 433 434 -- Função: killcontext (<context_1>, ..., <context_n>) 435 Mata os contextos <context_1>, ..., <context_n>. 436 437 Se um dos contextos estiver for o contexto atual, o novo contexto 438 atual irá tornar-se o primeiro subcontexto disponível do contexto 439 atual que não tiver sido morto. Se o primeiro contexto disponível 440 não morto for 'global' então 'initial' é usado em seu lugar. Se o 441 contexto 'initial' for morto, um novo, porém vazio contexto 442 'initial' é criado. 443 444 'killcontext' recusa-se a matar um contexto que estiver ativo 445 atualmente, ou porque ele é um subcontexto do contexto atual, ou 446 através do uso da função 'activate'. 447 448 'killcontext' avalia seus argumentos. 'killcontext' retorna 449 'done'. 450 451 -- Função: newcontext (<nome>) 452 Cria um novo contexto, porém vazio, chamado <nome>, que tem 453 'global' como seu único subcontexto. O contexto recentemente 454 criado torna-se o contexto ativo atualmente. 455 456 'newcontext' avalia seu argumento. 'newcontext' retorna <nome>. 457 458 -- Função: supcontext (<nome>, <context>) 459 -- Função: supcontext (<nome>) 460 Cria um novo contexto, chamado <nome>, que tem <context> como um 461 subcontexto. <context> deve existir. 462 463 Se <context> não for especificado, o contexto atual é assumido. 464 465 466File: maxima.info, Node: Polinômios, Next: Constantes, Prev: Contextos, Up: Top 467 46812 Polinômios 469************* 470 471* Menu: 472 473* Introdução a Polinômios:: 474* Funções e Variáveis Definidas para Polinômios:: 475 476 477File: maxima.info, Node: Introdução a Polinômios, Next: Funções e Variáveis Definidas para Polinômios, Prev: Polinômios, Up: Polinômios 478 47912.1 Introdução a Polinômios 480============================ 481 482Polinômios são armazenados no Maxima ou na forma geral ou na forma de 483Expressões Racionais Canônicas (CRE). Essa última é uma forma padrão, e 484é usada internamente por operações tais como 'factor', 'ratsimp', e 485assim por diante. 486 487 Expressões Racionais Canônicas constituem um tipo de representação 488que é especialmente adequado para polinômios expandidos e funções 489racionais (também para polinômios parcialmente fatorados e funções 490racionais quando RATFAC for escolhida para 'true'). Nessa forma CRE uma 491ordenação de variáveis (da mais para a menos importante) é assumida para 492cada expressão. Polinômios são representados recursivamente por uma 493lista consistindo da variável principal seguida por uma série de pares 494de expressões, uma para cada termo do polinômio. O primeiro membro de 495cada par é o expoente da variável principal naquele termo e o segundo 496membro é o coeficiente daquele termo que pode ser um número ou um 497polinômio em outra variável novamente respresentado nessa forma. Sendo 498assim a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e que a 499parte principal da forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1 0 -3)) 500assumindo Y como sendo a variável principal, e é (X 1 (Y 1 2 0 1) 0 -3) 501assumindo X como sendo a variável principal. A variável principal é 502usualmente determineda pela ordem alfabética reversa. As "variáveis" de 503uma expressão CRE não necessariamente devem ser atômicas. De fato 504qualquer subexpressão cujo principal operador não for + - * / or ^ com 505expoente inteiro será considerado uma "variável" da expressão (na forma 506CRE) na qual essa ocorrer. Por exemplo as variáveis CRE da expressão 507X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e SIN(X+1). Se o usuário não 508especifica uma ordem de variáveis pelo uso da função RATVARS Maxima 509escolherá a alfabética por conta própria. Em geral, CREs representam 510expressões racionais, isto é, razões de polinômios, onde o numerador e o 511denominador não possuem fatores comuns, e o denominador for positivo. A 512forma interna é essencialmente um par de polinômios (o numerador e o 513denominador) precedidos pela lista de ordenação de variável. Se uma 514expressão a ser mostrada estiver na forma CRE ou se contiver quaisquer 515subexpressões na forma CRE, o símbolo /R/ seguirá o rótulo da linha. 516Veja a função RAT para saber como converter uma expressão para a forma 517CRE. Uma forma CRE extendida é usada para a representação de séries de 518Taylor. A noção de uma expressão racional é extendida de modo que os 519expoentes das variáveis podem ser números racionais positivos ou 520negativos em lugar de apenas inteiros positivos e os coeficientes podem 521eles mesmos serem expressões racionais como descrito acima em lugar de 522apenas polinômios. Estes são representados internamente por uma forma 523polinomial recursiva que é similar à forma CRE e é a generalização dessa 524mesma forma CRE, mas carrega informação adicional tal com o grau de 525truncação. Do mesmo modo que na forma CRE, o símbolo /T/ segue o rótulo 526de linha que contém as tais expressões. 527 528 529File: maxima.info, Node: Funções e Variáveis Definidas para Polinômios, Prev: Introdução a Polinômios, Up: Polinômios 530 53112.2 Funções e Variáveis Definidas para Polinômios 532================================================== 533 534 -- Variável de opção: algebraic 535 Valor Padrão: 'false' 536 537 'algebraic' deve ser escolhida para 'true' com o objetivo de que a 538 simplificação de inteiros algébricos tenha efeito. 539 540 -- Variável de opção: berlefact 541 Valor Padrão: 'true' 542 543 Quando 'berlefact' for 'false' então o algorítmo de fatoração de 544 Kronecker será usado. De outra forma o algorítmo de Berlekamp, que 545 é o padrão, será usado. 546 547 -- Função: bezout (<p1>, <p2>, <x>) 548 uma alternativa para o comando 'resultant'. Isso retorna uma 549 matriz. 'determinant' dessa matriz é o resultante desejado. 550 551 -- Função: bothcoef (<expr>, <x>) 552 Retorna uma lista da qual o primeiro membro é o coeficiente de <x> 553 em <expr> (como achado por 'ratcoef' se <expr> está na forma CRE de 554 outro modo por 'coeff') e cujo segundo membro é a parte restante de 555 <expr>. Isto é, '[A, B]' onde '<expr> = A*<x> + B'. 556 557 Exemplo: 558 559 (%i1) islinear (expr, x) := block ([c], 560 c: bothcoef (rat (expr, x), x), 561 é (freeof (x, c) and c[1] # 0))$ 562 (%i2) islinear ((r^2 - (x - r)^2)/x, x); 563 (%o2) true 564 565 -- Função: coeff (<expr>, <x>, <n>) 566 Retorna o coeficiente de '<x>^<n>' em <expr>. <n> pode ser omitido 567 se for 1. <x> pode ser um átomo, ou subexpressão completa de 568 <expr> e.g., 'sin(x)', 'a[i+1]', 'x + y', etc. (No último caso a 569 expressão '(x + y)' pode ocorrer em <expr>). Algumas vezes isso 570 pode ser necessário para expandir ou fatorar <expr> com o objetivo 571 de fazer '<x>^<n>' explicito. Isso não é realizado por 'coeff'. 572 573 Exemplos: 574 575 (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x)); 576 (%o1) 2 a + 1 = 5 577 (%i2) coeff (y + x*%e^x + 1, x, 0); 578 (%o2) y + 1 579 580 -- Função: combine (<expr>) 581 Simplifica a adição <expr> por termos combinados com o mesmo 582 denominador dentro de um termo simples. 583 584 -- Função: content (<p_1>, <x_1>, ..., <x_n>) 585 Retorna uma lista cujo primeiro elemento é o máximo divisor comum 586 dos coeficientes dos termos do polinômio <p_1> na variável <x_n> 587 (isso é o conteúdo) e cujo segundo elemento é o polinômio <p_1> 588 dividido pelo conteúdo. 589 590 Exemplos: 591 592 (%i1) content (2*x*y + 4*x^2*y^2, y); 593 2 594 (%o1) [2 x, 2 x y + y] 595 596 -- Função: denom (<expr>) 597 Retorna o denominador da expressão racional <expr>. 598 599 -- Função: divide (<p_1>, <p_2>, <x_1>, ..., <x_n>) 600 calcula o quocietne e o resto do polinômio <p_1> dividido pelo 601 polinômio <p_2>, na variável principal do polinômio, <x_n>. As 602 outras variáveis são como na função 'ratvars'. O resultado é uma 603 lista cujo primeiro elemento é o quociente e cujo segundo elemento 604 é o resto. 605 606 Exemplos: 607 608 (%i1) divide (x + y, x - y, x); 609 (%o1) [1, 2 y] 610 (%i2) divide (x + y, x - y); 611 (%o2) [- 1, 2 x] 612 613 Note que 'y' é a variável principal no segundo exemplo. 614 615 -- Função: eliminate ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_k>]) 616 Elimina variáveis de equações (ou expressões assumidas iguais a 617 zero) pegando resultantes sucessivos. Isso retorna uma lista de 618 '<n> - <k>' expressões com <k> variáveis <x_1>, ..., <x_k> 619 eliminadas. Primeiro <x_1> é eliminado retornando '<n> - 1' 620 expressões, então 'x_2' é eliminado, etc. Se '<k> = <n>' então uma 621 expressão simples em uma lista é retornada livre das variáveis 622 <x_1>, ..., <x_k>. Nesse caso 'solve' é chamado para resolver a 623 última resultante para a última variável. 624 625 Exemplo: 626 627 (%i1) expr1: 2*x^2 + y*x + z; 628 2 629 (%o1) z + x y + 2 x 630 (%i2) expr2: 3*x + 5*y - z - 1; 631 (%o2) - z + 5 y + 3 x - 1 632 (%i3) expr3: z^2 + x - y^2 + 5; 633 2 2 634 (%o3) z - y + x + 5 635 (%i4) eliminate ([expr3, expr2, expr1], [y, z]); 636 8 7 6 5 4 637 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x 638 639 3 2 640 - 5154 x - 1291 x + 7688 x + 15376] 641 642 -- Função: ezgcd (<p_1>, <p_2>, <p_3>, ...) 643 Retorna uma lista cujo primeiro elemento é o m.d.c. dos polinômios 644 <p_1>, <p_2>, <p_3>, ... e cujos restantes elementos são os 645 polinômios divididos pelo mdc. Isso sempre usa o algorítmo 646 'ezgcd'. 647 648 -- Variável de opção: facexpand 649 Valor Padrão: 'true' 650 651 'facexpand' controla se os fatores irredutíveis retornados por 652 'factor' estão na forma expandida (o padrão) ou na forma recursiva 653 (CRE normal). 654 655 -- Função: factcomb (<expr>) 656 Tenta combinar os coeficientes de fatoriais em <expr> com os 657 próprios fatoriais convertendo, por exemplo, '(n + 1)*n!' em '(n + 658 1)!'. 659 660 'sumsplitfact' se escolhida para 'false' fará com que 661 'minfactorial' seja aplicado após um 'factcomb'. 662 663 -- Função: factor (<expr>) 664 -- Função: factor (<expr>, <p>) 665 666 Fatora a expressão <expr>, contendo qualquer número de variáveis ou 667 funções, em fatores irredutíveis sobre os inteiros. 'factor 668 (<expr>, <p>)' fatora <expr> sobre o campo dos inteiros com um 669 elemento adjunto cujo menor polinômio é <p>. 670 671 'factor' usa a função 'ifactors' para fatorar inteiros. 672 673 'factorflag' se 'false' suprime a fatoração de fatores inteiros de 674 expressões racionais. 675 676 'dontfactor' pode ser escolhida para uma lista de variáveis com 677 relação à qual fatoração não é para ocorrer. (Essa é inicialmente 678 vazia). Fatoração também não acontece com relação a quaisquer 679 variáveis que são menos importantes (usando a ordenação de variável 680 assumida pela forma CRE) como essas na lista 'dontfactor'. 681 682 'savefactors' se 'true' faz com que os fatores de uma expressão que 683 é um produto de fatores seja guardada por certas funções com o 684 objetivo de aumentar a velocidade de futuras fatorações de 685 expressões contendo alguns dos mesmos fatores. 686 687 'berlefact' se 'false' então o algorítmo de fatoração de Kronecker 688 será usado de outra forma o algorítmo de Berlekamp, que é o padrão, 689 será usado. 690 691 'intfaclim' se 'true' maxima irá interromper a fatoração de 692 inteiros se nenhum fator for encontrado após tentar divisões e o 693 método rho de Pollard. Se escolhida para 'false' (esse é o caso 694 quando o usuário chama 'factor' explicitamente), a fatoração 695 completa do inteiro será tentada. A escolha do usuário para 696 'intfaclim' é usada para chamadas internas a 'factor'. Dessa 697 forma, 'intfaclim' pode ser resetada para evitar que o Maxima gaste 698 um tempo muito longo fatorando inteiros grandes. 699 700 Exemplos: 701 702 (%i1) factor (2^63 - 1); 703 2 704 (%o1) 7 73 127 337 92737 649657 705 (%i2) factor (-8*y - 4*x + z^2*(2*y + x)); 706 (%o2) (2 y + x) (z - 2) (z + 2) 707 (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2; 708 2 2 2 2 2 709 (%o3) x y + 2 x y + y - x - 2 x - 1 710 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2))); 711 2 712 (x + 2 x + 1) (y - 1) 713 (%o4) ---------------------- 714 36 (y + 1) 715 (%i5) factor (1 + %e^(3*x)); 716 x 2 x x 717 (%o5) (%e + 1) (%e - %e + 1) 718 (%i6) factor (1 + x^4, a^2 - 2); 719 2 2 720 (%o6) (x - a x + 1) (x + a x + 1) 721 (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3); 722 2 723 (%o7) - (y + x) (z - x) (z + x) 724 (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2; 725 x + 2 726 (%o8) ------------------------ 727 2 728 (x + 3) (x + b) (x + c) 729 (%i9) ratsimp (%); 730 4 3 731 (%o9) (x + 2)/(x + (2 c + b + 3) x 732 733 2 2 2 2 734 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c ) 735 (%i10) partfrac (%, x); 736 2 4 3 737 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c 738 739 2 2 2 2 740 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c)) 741 742 c - 2 743 - --------------------------------- 744 2 2 745 (c + (- b - 3) c + 3 b) (x + c) 746 747 b - 2 748 + ------------------------------------------------- 749 2 2 3 2 750 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b) 751 752 1 753 - ---------------------------------------------- 754 2 755 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3) 756 (%i11) map ('factor, %); 757 2 758 c - 4 c - b + 6 c - 2 759 (%o11) - ------------------------- - ------------------------ 760 2 2 2 761 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c) 762 763 b - 2 1 764 + ------------------------ - ------------------------ 765 2 2 766 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3) 767 (%i12) ratsimp ((x^5 - 1)/(x - 1)); 768 4 3 2 769 (%o12) x + x + x + x + 1 770 (%i13) subst (a, x, %); 771 4 3 2 772 (%o13) a + a + a + a + 1 773 (%i14) factor (%th(2), %); 774 2 3 3 2 775 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1) 776 (%i15) factor (1 + x^12); 777 4 8 4 778 (%o15) (x + 1) (x - x + 1) 779 (%i16) factor (1 + x^99); 780 2 6 3 781 (%o16) (x + 1) (x - x + 1) (x - x + 1) 782 783 10 9 8 7 6 5 4 3 2 784 (x - x + x - x + x - x + x - x + x - x + 1) 785 786 20 19 17 16 14 13 11 10 9 7 6 787 (x + x - x - x + x + x - x - x - x + x + x 788 789 4 3 60 57 51 48 42 39 33 790 - x - x + x + 1) (x + x - x - x + x + x - x 791 792 30 27 21 18 12 9 3 793 - x - x + x + x - x - x + x + 1) 794 795 -- Variável de opção: factorflag 796 Valor Padrão: 'false' 797 798 Quando 'factorflag' for 'false', suprime a fatoração de fatores 799 inteiros em expressões racionais. 800 801 -- Função: factorout (<expr>, <x_1>, <x_2>, ...) 802 Rearranja a adição <expr> em uma adição de parcelas da forma 'f 803 (<x_1>, <x_2>, ...)*g' onde 'g' é um produto de expressões que não 804 possuem qualquer <x_i> e 'f' é fatorado. 805 806 -- Função: factorsum (<expr>) 807 Tenta agrupar parcelas em fatores de <expr> que são adições em 808 grupos de parcelas tais que sua adição é fatorável. 'factorsum' 809 pode recuperar o resultado de 'expand ((x + y)^2 + (z + w)^2)' mas 810 não pode recuperar 'expand ((x + 1)^2 + (x + y)^2)' porque os 811 termos possuem variáveis em comum. 812 813 Exemplo: 814 815 (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2)); 816 2 2 2 2 817 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x 818 819 2 2 2 2 820 + 2 u v x + u x + a w + v + 2 u v + u 821 (%i2) factorsum (%); 822 2 2 823 (%o2) (x + 1) (a (z + w) + (v + u) ) 824 825 -- Função: fasttimes (<p_1>, <p_2>) 826 Retorna o produto dos polinômios <p_1> e <p_2> usando um algorítmo 827 especial para a multiplicação de polinômios. 'p_1' e 'p_2' podem 828 ser de várias variáveis, densos, e aproximadamente do mesmo 829 tamanho. A multiplicação clássica é de ordem 'n_1 n_2' onde 'n_1' 830 é o grau de 'p_1' and 'n_2' é o grau de 'p_2'. 'fasttimes' é da 831 ordem 'max (n_1, n_2)^1.585'. 832 833 -- Função: fullratsimp (<expr>) 834 'fullratsimp' aplica repetidamente 'ratsimp' seguido por 835 simplificação não racional a uma expressão até que nenhuma mudança 836 adicional ocorra, e retorna o resultado. 837 838 Quando expressões não racionais estão envolvidas, uma chamada a 839 'ratsimp' seguida como é usual por uma simplificação não racional 840 ("geral") pode não ser suficiente para retornar um resultado 841 simplificado. Algumas vezes, mais que uma tal chamada pode ser 842 necessária. 'fullratsimp' faz esse processo convenientemente. 843 844 'fullratsimp (<expr>, <x_1>, ..., <x_n>)' pega um ou mais 845 argumentos similar a 'ratsimp' e 'rat'. 846 847 Exemplo: 848 849 (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1); 850 a/2 2 a/2 2 851 (x - 1) (x + 1) 852 (%o1) ----------------------- 853 a 854 x - 1 855 (%i2) ratsimp (expr); 856 2 a a 857 x - 2 x + 1 858 (%o2) --------------- 859 a 860 x - 1 861 (%i3) fullratsimp (expr); 862 a 863 (%o3) x - 1 864 (%i4) rat (expr); 865 a/2 4 a/2 2 866 (x ) - 2 (x ) + 1 867 (%o4)/R/ ----------------------- 868 a 869 x - 1 870 871 -- Função: fullratsubst (<a>, <b>, <c>) 872 é o mesmo que 'ratsubst' exceto que essa chama a si mesma 873 recursivamente sobre esse resultado até que o resultado para de 874 mudar. Essa função é útil quando a expressão de substituição e a 875 expressão substituída tenham uma ou mais variáveis em comum. 876 877 'fullratsubst' irá também aceitar seus argumentos no formato de 878 'lratsubst'. Isto é, o primeiro argumento pode ser uma 879 substituição simples de equação ou uma lista de tais equações, 880 enquanto o segundo argumento é a expressão sendo processada. 881 882 'load ("lrats")' chama 'fullratsubst' e 'lratsubst'. 883 884 Exemplos: 885 886 (%i1) load ("lrats")$ 887 * 'subst' pode realizar multiplas substituições. 'lratsubst' é 888 analogo a 'subst'. 889 (%i2) subst ([a = b, c = d], a + c); 890 (%o2) d + b 891 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); 892 (%o3) (d + a c) e + a d + b c 893 * Se somente uma substituição é desejada, então uma equação 894 simples pode ser dada como primeiro argumento. 895 (%i4) lratsubst (a^2 = b, a^3); 896 (%o4) a b 897 * 'fullratsubst' é equivalente a 'ratsubst' exceto que essa 898 executa recursivamente até que seu resultado para de mudar. 899 (%i5) ratsubst (b*a, a^2, a^3); 900 2 901 (%o5) a b 902 (%i6) fullratsubst (b*a, a^2, a^3); 903 2 904 (%o6) a b 905 * 'fullratsubst' também aceita uma lista de equações ou uma 906 equação simples como primeiro argumento. 907 (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c); 908 (%o7) b 909 (%i8) fullratsubst (a^2 = b*a, a^3); 910 2 911 (%o8) a b 912 * 'fullratsubst' pode causar uma recursão infinita. 913 (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3)); 914 915 *** - Lisp stack overflow. RESET 916 917 -- Função: gcd (<p_1>, <p_2>, <x_1>, ...) 918 Retorna o máximo divisor comum entre <p_1> e <p_2>. O sinalizador 919 'gcd' determina qual algorítmo é empregado. Escolhendo 'gcd' para 920 'ez', 'subres', 'red', ou 'spmod' seleciona o algorítmo 'ezgcd', 921 subresultante 'prs', reduzido, ou modular, respectivamente. Se 922 'gcd' for 'false' então 'gcd (<p_1>, <p_2>, <x>)' sempre retorna 1 923 para todo <x>. Muitas funções (e.g. 'ratsimp', 'factor', etc.) 924 fazem com que mdc's sejam feitos implicitamente. Para polinômios 925 homogêneos é recomendado que 'gcd' igual a 'subres' seja usado. 926 Para pegar o mdc quando uma expressão algébrica está presente, e.g. 927 'gcd (<x>^2 - 2*sqrt(2)*<x> + 2, <x> - sqrt(2))', 'algebraic' deve 928 ser 'true' e 'gcd' não deve ser 'ez'. 'subres' é um novo 929 algorítmo, e pessoas que tenham estado usando a opção 'red' podem 930 provavelmente alterar isso para 'subres'. 931 932 O sinalizador 'gcd', padrão: 'subres', se 'false' irá também evitar 933 o máximo divisor comum de ser usado quando expressões são 934 convertidas para a forma de expressão racional canônica (CRE). Isso 935 irá algumas vezes aumentar a velocidade dos cálculos se mdc's não 936 são requeridos. 937 938 -- Função: gcdex (<f>, <g>) 939 -- Função: gcdex (<f>, <g>, <x>) 940 Retornam uma lista '[<a>, <b>, <u>]' onde <u> é o máximo divisor 941 comum (mdc) entre <f> e <g>, e <u> é igual a '<a> <f> + <b> <g>'. 942 Os argumentos <f> e <g> podem ser polinômios de uma variável, ou de 943 outra forma polinômios em <x> uma main(principal) variável suprida 944 desde que nós precisamos estar em um domínio de ideal principal 945 para isso trabalhar. O mdc significa o mdc considerando <f> e <g> 946 como polinômios de uma única variável com coeficientes sendo 947 funções racionais em outras variáveis. 948 949 'gcdex' implementa o algorítmo Euclideano, onde temos a seqüência 950 of 'L[i]: [a[i], b[i], r[i]]' que são todos perpendiculares a '[f, 951 g, -1]' e o próximo se é construído como se 'q = 952 quotient(r[i]/r[i+1])' então 'L[i+2]: L[i] - q L[i+1]', e isso 953 encerra em 'L[i+1]' quando o resto 'r[i+2]' for zero. 954 955 (%i1) gcdex (x^2 + 1, x^3 + 4); 956 2 957 x + 4 x - 1 x + 4 958 (%o1)/R/ [- ------------, -----, 1] 959 17 17 960 (%i2) % . [x^2 + 1, x^3 + 4, -1]; 961 (%o2)/R/ 0 962 963 Note que o mdc adiante é '1' uma vez que trabalhamos em 'k(y)[x]', 964 o 'y+1' não pode ser esperado em 'k[y, x]'. 965 966 (%i1) gcdex (x*(y + 1), y^2 - 1, x); 967 1 968 (%o1)/R/ [0, ------, 1] 969 2 970 y - 1 971 972 -- Função: gcfactor (<n>) 973 Fatora o inteiro Gaussiano <n> sobre os inteiros Gaussianos, i.e., 974 números da forma '<a> + <b> %i' onde <a> e <b> são inteiros 975 raconais (i.e., inteiros comuns). Fatorações são normalizadas 976 fazendo <a> e <b> não negativos. 977 978 -- Função: gfactor (<expr>) 979 Fatora o polinômio <expr> sobre os inteiros de Gauss (isto é, os 980 inteiros com a unidade imaginária '%i' adjunta). Isso é como 981 'factor (<expr>, <a>^2+1)' trocando <a> por '%i'. 982 983 Exemplo: 984 985 (%i1) gfactor (x^4 - 1); 986 (%o1) (x - 1) (x + 1) (x - %i) (x + %i) 987 988 -- Função: gfactorsum (<expr>) 989 é similar a 'factorsum' mas aplica 'gfactor' em lugar de 'factor'. 990 991 -- Função: hipow (<expr>, <x>) 992 Retorna o maior expoente explícito de <x> em <expr>. <x> pode ser 993 uma variável ou uma expressão geral. Se <x> não aparece em <expr>, 994 'hipow' retorna '0'. 995 996 'hipow' não considera expressões equivalentes a 'expr'. Em 997 particular, 'hipow' não expande 'expr', então 'hipow (<expr>, <x>)' 998 e 'hipow (expand (<expr>, <x>))' podem retornar diferentes 999 resultados. 1000 1001 Exemplos: 1002 1003 (%i1) hipow (y^3 * x^2 + x * y^4, x); 1004 (%o1) 2 1005 (%i2) hipow ((x + y)^5, x); 1006 (%o2) 1 1007 (%i3) hipow (expand ((x + y)^5), x); 1008 (%o3) 5 1009 (%i4) hipow ((x + y)^5, x + y); 1010 (%o4) 5 1011 (%i5) hipow (expand ((x + y)^5), x + y); 1012 (%o5) 0 1013 1014 -- Variável de opção: intfaclim 1015 Valor padrão: true 1016 1017 Se 'true', maxima irá interromper a fatoração de inteiros se nenhum 1018 fator for encontrado após tentar divisões e o método rho de Pollard 1019 e a fatoração não será completada. 1020 1021 Quando 'intfaclim' for 'false' (esse é o caso quando o usuário 1022 chama 'factor' explicitamente), a fatoração completa será tentada. 1023 'intfaclim' é escolhida para 'false' quando fatores são calculados 1024 em 'divisors', 'divsum' e 'totient'. 1025 1026 Chamadas internas a 'factor' respeitam o valor especificado pelo 1027 usuário para 'intfaclim'. Setting 'intfaclim' to 'true' may reduce 1028 'intfaclim'. Escolhendo 'intfaclim' para 'true' podemos reduzir o 1029 tempo gasto fatorando grandes inteiros. 1030 1031 -- Variável de opção: keepfloat 1032 Valor Padrão: 'false' 1033 1034 Quando 'keepfloat' for 'true', evitamos que números em ponto 1035 flutuante sejam racionalizados quando expressões que os possuem são 1036 então convertidas para a forma de expressão racional canônica 1037 (CRE). 1038 1039 -- Função: lratsubst (<L>, <expr>) 1040 é análogo a 'subst (<L>, <expr>)' exceto que esse usa 'ratsubst' em 1041 lugar de 'subst'. 1042 1043 O primeiro argumento de 'lratsubst' é uma equação ou uma lista de 1044 equações idênticas em formato para que sejam aceitas por 'subst'. 1045 As substituições são feitas na ordem dada pela lista de equações, 1046 isto é, da esquerda para a direita. 1047 1048 'load ("lrats")' chama 'fullratsubst' e 'lratsubst'. 1049 1050 Exemplos: 1051 1052 (%i1) load ("lrats")$ 1053 * 'subst' pode realizar multiplas substituições. 'lratsubst' é 1054 analoga a 'subst'. 1055 (%i2) subst ([a = b, c = d], a + c); 1056 (%o2) d + b 1057 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); 1058 (%o3) (d + a c) e + a d + b c 1059 * Se somente uma substituição for desejada, então uma equação 1060 simples pode ser dada como primeiro argumento. 1061 (%i4) lratsubst (a^2 = b, a^3); 1062 (%o4) a b 1063 1064 -- Variável de opção: modulus 1065 Valor Padrão: 'false' 1066 1067 Quando 'modulus' for um número positivo <p>, operações sobre os 1068 números racionais (como retornado por 'rat' e funções relacionadas) 1069 são realizadas módulo <p>, usando o então chamado sistema de módulo 1070 "balanceado" no qual '<n> módulo <p>' é definido como um inteiro 1071 <k> em '[-(<p>-1)/2, ..., 0, ..., (<p>-1)/2]' quando <p> for ímpar, 1072 ou '[-(<p>/2 - 1), ..., 0, ...., <p>/2]' quando <p> for par, tal 1073 que '<a> <p> + <k>' seja igual a <n> para algum inteiro <a>. 1074 1075 Se <expr> já estiver na forma de expressão racional canônica (CRE) 1076 quando 'modulus' for colocado em seu valor original, então você 1077 pode precisar repetir o rat <expr>, e.g., 'expr: rat (ratdisrep 1078 (expr))', com o objetivo de pegar resultados corretos. 1079 1080 Tipicamente 'modulus' é escolhido para um número primo. Se 1081 'modulus' for escolhido para um inteiro não primo positivo, essa 1082 escolha é aceita, mas uma mensagem de alerta é mostrada. Maxima 1083 permitirá que zero ou um inteiro negativo seja atribuído a 1084 'modulus', embora isso não seja limpo se aquele tiver quaisquer 1085 conseqüências úteis. 1086 1087 -- Função: num (<expr>) 1088 Retorna o numerador de <expr> se isso for uma razão. Se <expr> não 1089 for uma razão, <expr> é retornado. 1090 1091 'num' avalia seu argumento. 1092 1093 -- Função: polydecomp (<p>, <x>) 1094 1095 Decompões o polinômio <p> na variável <x> em uma composição 1096 funcional de polinômios em <x>. 'polydecomp' retorna uma lista 1097 '[<p_1>, ..., <p_n>]' tal que 1098 1099 lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...)) 1100 1101 seja igual a <p>. O grau de <p_i> é maior que 1 para <i> menor que 1102 <n>. 1103 1104 Tal decomposição não é única. 1105 1106 Exemplos: 1107 1108 (%i1) polydecomp (x^210, x); 1109 7 5 3 2 1110 (%o1) [x , x , x , x ] 1111 (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a)); 1112 6 4 3 2 1113 (%o2) x - 2 x - 2 x + x + 2 x - a + 1 1114 (%i3) polydecomp (p, x); 1115 2 3 1116 (%o3) [x - a, x - x - 1] 1117 1118 As seguintes funções compõem 'L = [e_1, ..., e_n]' como funções em 1119 'x'; essa funçào é a inversa de 'polydecomp': 1120 1121 compose (L, x) := 1122 block ([r : x], for e in L do r : subst (e, x, r), r) $ 1123 1124 Re-exprimindo o exemplo acima usando 'compose': 1125 1126 (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x); 1127 2 3 1128 (%o3) [x - a, x - x - 1] 1129 1130 Note que apesar de 'compose (polydecomp (<p>, <x>), <x>)' sempre 1131 retornar <p> (não expandido), 'polydecomp (compose ([<p_1>, ..., 1132 <p_n>], <x>), <x>)' não necessáriamente retorna '[<p_1>, ..., 1133 <p_n>]': 1134 1135 (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x); 1136 2 2 1137 (%o4) [x + 2, x + 1] 1138 (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x); 1139 2 2 1140 x + 3 x + 5 1141 (%o5) [------, ------, 2 x + 1] 1142 4 2 1143 1144 -- Função: quotient (<p_1>, <p_2>) 1145 -- Função: quotient (<p_1>, <p_2>, <x_1>, ..., <x_n>) 1146 Retorna o polinômio <p_1> dividido pelo polinômio <p_2>. Os 1147 argumentos <x_1>, ..., <x_n> são interpretados como em 'ratvars'. 1148 1149 'quotient' retorna o primeiro elemento de uma lista de dois 1150 elementos retornada por 'divide'. 1151 1152 -- Função: rat (<expr>) 1153 -- Função: rat (<expr>, <x_1>, ..., <x_n>) 1154 Converte <expr> para a forma de expressão racional canônica (CRE) 1155 expandindo e combinando todos os termos sobre um denominador comum 1156 e cancelando para fora o máximo divisor comum entre o numerador e o 1157 denominador, também convertendo números em ponto flutuante para 1158 números racionais dentro da tolerância de 'ratepsilon'. As 1159 variáveis são ordenadas de acordo com <x_1>, ..., <x_n>, se 1160 especificado, como em 'ratvars'. 1161 1162 'rat' geralmente não simplifica funções outras que não sejam adição 1163 '+', subtração '-', multiplicação '*', divisão '/', e exponenciação 1164 com expoente inteiro, uma vez que 'ratsimp' não manuseia esses 1165 casos. Note que átomos (números e variáveis) na forma CRE não são 1166 os mesmos que eles são na forma geral. Por exemplo, 'rat(x)- x' 1167 retorna 'rat(0)' que tem uma representação interna diferente de 0. 1168 1169 Quando 'ratfac' for 'true', 'rat' retorna uma forma parcialmente 1170 fatorada para CRE. Durante operações racionais a expressão é 1171 mantida como totalmente fatorada como possível sem uma chamada ao 1172 pacote de fatoração ('factor'). Isso pode sempre economizar espaço 1173 de memória e algum tempo em algumas computações. O numerador e o 1174 denominador são ainda tidos como relativamente primos (e.g. 'rat 1175 ((x^2 - 1)^4/(x + 1)^2)' retorna '(x - 1)^4 (x + 1)^2)', mas os 1176 fatores dentro de cada parte podem não ser relativamente primos. 1177 1178 'ratprint' se 'false' suprime a impressão de mensagens informando o 1179 usuário de conversões de números em ponto flutuante para números 1180 racionais. 1181 1182 'keepfloat' se 'true' evita que números em ponto flutuante sejam 1183 convertidos para números racionais. 1184 1185 Veja também 'ratexpand' e 'ratsimp'. 1186 1187 Exemplos: 1188 1189 (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /(4*y^2 + x^2); 1190 4 1191 (x - 2 y) 1192 (y + a) (2 y + x) (------------ + 1) 1193 2 2 2 1194 (x - 4 y ) 1195 (%o1) ------------------------------------ 1196 2 2 1197 4 y + x 1198 (%i2) rat (%, y, a, x); 1199 2 a + 2 y 1200 (%o2)/R/ --------- 1201 x + 2 y 1202 1203 -- Variável de opção: ratalgdenom 1204 Valor Padrão: 'true' 1205 1206 Quando 'ratalgdenom' for 'true', permite racionalização de 1207 denominadores com respeito a radicais tenham efeito. 'ratalgdenom' 1208 tem efeito somente quando expressões racionais canônicas (CRE) 1209 forem usadas no modo algébrico. 1210 1211 -- Função: ratcoef (<expr>, <x>, <n>) 1212 -- Função: ratcoef (<expr>, <x>) 1213 Retorna o coeficiente da expressão '<x>^<n>' dentro da expressão 1214 <expr>. Se omitido, <n> é assumido ser 1. 1215 1216 O valor de retorno está livre (exceto possivelmente em um senso não 1217 racional) das variáveis em <x>. Se nenhum coeficiente desse tipo 1218 existe, 0 é retornado. 1219 1220 'ratcoef' expande e simplifica racionalmente seu primeiro argumento 1221 e dessa forma pode produzir respostas diferentes das de 'coeff' que 1222 é puramente sintática. Dessa forma 'ratcoef ((x + 1)/y + x, x)' 1223 retorna '(y + 1)/y' ao passo que 'coeff' retorna 1. 1224 1225 'ratcoef (<expr>, <x>, 0)', visualiza <expr> como uma adição, 1226 retornando uma soma desses termos que não possuem <x>. portanto se 1227 <x> ocorre para quaisquer expoentes negativos, 'ratcoef' pode não 1228 ser usado. 1229 1230 Uma vez que <expr> é racionalmente simplificada antes de ser 1231 examinada, coeficientes podem não aparecer inteiramente no caminho 1232 que eles foram pensados. 1233 1234 Exemplo: 1235 1236 (%i1) s: a*x + b*x + 5$ 1237 (%i2) ratcoef (s, a + b); 1238 (%o2) x 1239 1240 -- Função: ratdenom (<expr>) 1241 Retorna o denominador de <expr>, após forçar a conversão de <expr> 1242 para expressão racional canônica (CRE). O valor de retorno é a CRE. 1243 1244 <expr> é forçada para uma CRE por 'rat' se não for já uma CRE. Essa 1245 conversão pode mudar a forma de <expr> colocando todos os termos 1246 sobre um denominador comum. 1247 1248 'denom' é similar, mas retorna uma expressão comum em lugar de uma 1249 CRE. Também, 'denom' não tenta colocar todos os termos sobre um 1250 denominador comum, e dessa forma algumas expressões que são 1251 consideradas razões por 'ratdenom' não são consideradas razões por 1252 'denom'. 1253 1254 -- Variável de opção: ratdenomdivide 1255 Valor Padrão: 'true' 1256 1257 Quando 'ratdenomdivide' for 'true', 'ratexpand' expande uma razão 1258 cujo o numerador for uma adição dentro de uma soma de razões, tendo 1259 todos um denominador comum. De outra forma, 'ratexpand' colapsa 1260 uma adição de razões dentro de uma razão simples, cujo numerador 1261 seja a adição dos numeradores de cada razão. 1262 1263 Exemplos: 1264 1265 (%i1) expr: (x^2 + x + 1)/(y^2 + 7); 1266 2 1267 x + x + 1 1268 (%o1) ---------- 1269 2 1270 y + 7 1271 (%i2) ratdenomdivide: true$ 1272 (%i3) ratexpand (expr); 1273 2 1274 x x 1 1275 (%o3) ------ + ------ + ------ 1276 2 2 2 1277 y + 7 y + 7 y + 7 1278 (%i4) ratdenomdivide: false$ 1279 (%i5) ratexpand (expr); 1280 2 1281 x + x + 1 1282 (%o5) ---------- 1283 2 1284 y + 7 1285 (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3); 1286 2 1287 b a 1288 (%o6) ------ + ------ 1289 2 2 1290 b + 3 b + 3 1291 (%i7) ratexpand (expr2); 1292 2 1293 b + a 1294 (%o7) ------ 1295 2 1296 b + 3 1297 1298 -- Função: ratdiff (<expr>, <x>) 1299 Realiza a derivação da expressão racional <expr> com relação a <x>. 1300 <expr> deve ser uma razão de polinômios ou um polinômio em <x>. O 1301 argumento <x> pode ser uma variável ou uma subexpressão de <expr>. 1302 1303 O resultado é equivalente a 'diff', embora talvez em uma forma 1304 diferente. 'ratdiff' pode ser mais rápida que 'diff', para 1305 expressões racionais. 1306 1307 'ratdiff' retorna uma expressão racional canônica (CRE) se 'expr' 1308 for uma CRE. De outra forma, 'ratdiff' retorna uma expressão geral. 1309 1310 'ratdiff' considera somente as dependências de <expr> sobre <x>, e 1311 ignora quaisquer dependências estabelecidas por 'depends'. 1312 1313 Exemplo: 1314 1315 (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5); 1316 3 1317 4 x + 10 x - 11 1318 (%o1) ---------------- 1319 5 1320 x + 5 1321 (%i2) ratdiff (expr, x); 1322 7 5 4 2 1323 8 x + 40 x - 55 x - 60 x - 50 1324 (%o2) - --------------------------------- 1325 10 5 1326 x + 10 x + 25 1327 (%i3) expr: f(x)^3 - f(x)^2 + 7; 1328 3 2 1329 (%o3) f (x) - f (x) + 7 1330 (%i4) ratdiff (expr, f(x)); 1331 2 1332 (%o4) 3 f (x) - 2 f(x) 1333 (%i5) expr: (a + b)^3 + (a + b)^2; 1334 3 2 1335 (%o5) (b + a) + (b + a) 1336 (%i6) ratdiff (expr, a + b); 1337 2 2 1338 (%o6) 3 b + (6 a + 2) b + 3 a + 2 a 1339 1340 -- Função: ratdisrep (<expr>) 1341 Retorna seu argumento como uma expressão geral. Se <expr> for uma 1342 expressão geral, é retornada inalterada. 1343 1344 Tipicamente 'ratdisrep' é chamada para converter uma expressão 1345 racional canônica (CRE) em uma expressão geral. Isso é algumas 1346 vezes conveniente se deseja-se parar o "contágio", ou caso se 1347 esteja usando funções racionais em contextos não racionais. 1348 1349 Veja também 'totaldisrep'. 1350 1351 -- Variável de opção: ratepsilon 1352 Valor Padrão: 2.0e-8 1353 1354 'ratepsilon' é a tolerância usada em conversões de números em ponto 1355 flutuante para números racionais. 1356 1357 -- Função: ratexpand (<expr>) 1358 -- Variável de opção: ratexpand 1359 Expande <expr> multiplicando para fora produtos de somas e somas 1360 exponenciadas, combinando frações sobre um denominador comum, 1361 cancelando o máximo divisor comum entre entre o numerador e o 1362 denominador, então quebrando o numerador (se for uma soma) dentro 1363 de suas respectivas parcelas divididas pelo denominador. 1364 1365 O valor de retorno de 'ratexpand' é uma expressão geral, mesmo se 1366 <expr> for uma expressão racional canônica (CRE). 1367 1368 O comutador 'ratexpand' se 'true' fará com que expressões CRE sejam 1369 completamente expandidas quando forem convertidas de volta para a 1370 forma geral ou mostradas, enquanto se for 'false' então elas serão 1371 colocadas na forma recursiva. Veja também 'ratsimp'. 1372 1373 Quando 'ratdenomdivide' for 'true', 'ratexpand' expande uma razão 1374 na qual o numerador é uma adição dentro de uma adição de razões, 1375 todas tendo um denominador comum. De outra forma, 'ratexpand' 1376 contrai uma soma de razões em uma razão simples, cujo numerador é a 1377 soma dos numeradores de cada razão. 1378 1379 Quando 'keepfloat' for 'true', evita que números em ponto flutuante 1380 sejam racionalizados quando expressões que contenham números em 1381 ponto flutuante forem convertidas para a forma de expressão 1382 racional canônica (CRE). 1383 1384 Exemplos: 1385 1386 (%i1) ratexpand ((2*x - 3*y)^3); 1387 3 2 2 3 1388 (%o1) - 27 y + 54 x y - 36 x y + 8 x 1389 (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1); 1390 x - 1 1 1391 (%o2) -------- + ----- 1392 2 x - 1 1393 (x + 1) 1394 (%i3) expand (expr); 1395 x 1 1 1396 (%o3) ------------ - ------------ + ----- 1397 2 2 x - 1 1398 x + 2 x + 1 x + 2 x + 1 1399 (%i4) ratexpand (expr); 1400 2 1401 2 x 2 1402 (%o4) --------------- + --------------- 1403 3 2 3 2 1404 x + x - x - 1 x + x - x - 1 1405 1406 -- Variável de opção: ratfac 1407 Valor Padrão: 'false' 1408 1409 Quando 'ratfac' for 'true', expressões racionais canônicas (CRE) 1410 são manipuladas na forma parcialmente fatorada. 1411 1412 Durante operações racionais a expressão é mantida como 1413 completamente fatorada como foi possível sem chamadas a 'factor'. 1414 Isso pode sempre economizar espaço e pode economizar tempo em 1415 algumas computações. O numerador e o denominador são feitos 1416 relativamente primos, por exemplo 'rat ((x^2 - 1)^4/(x + 1)^2)' 1417 retorna '(x - 1)^4 (x + 1)^2)', mas o fator dentro de cada parte 1418 pode não ser relativamente primo. 1419 1420 No pacote 'ctensor' (Manipulação de componentes de tensores), 1421 tensores de Ricci, Einstein, Riemann, e de Weyl e a curvatura 1422 escalar são fatorados automaticamente quando 'ratfac' for 'true'. 1423 'ratfac' pode somente ser escolhido para casos onde as componentes 1424 tensoriais sejam sabidametne consistidas de poucos termos. 1425 1426 Os esquemas de 'ratfac' e de 'ratweight' são incompatíveis e não 1427 podem ambos serem usados ao mesmo tempo. 1428 1429 -- Função: ratnumer (<expr>) 1430 Retorna o numerador de <expr>, após forçar <expr> para uma 1431 expressão racional canônica (CRE). O valor de retorno é uma CRE. 1432 1433 <expr> é forçada para uma CRE por 'rat' se isso não for já uma CRE. 1434 Essa conversão pode alterar a forma de <expr> pela colocação de 1435 todos os termos sobre um denominador comum. 1436 1437 'num' é similar, mas retorna uma expressão comum em lugar de uma 1438 CRE. Também, 'num' não tenta colocar todos os termos sobre um 1439 denominador comum, e dessa forma algumas expressões que são 1440 consideradas razões por 'ratnumer' não são consideradas razões por 1441 'num'. 1442 1443 -- Função: ratnump (<expr>) 1444 Retorna 'true' se <expr> for um inteiro literal ou razão de 1445 inteiros literais, de outra forma retorna 'false'. 1446 1447 -- Função: ratp (<expr>) 1448 Retorna 'true' se <expr> for uma expressão racional canônica (CRE) 1449 ou CRE extendida, de outra forma retorna 'false'. 1450 1451 CRE são criadas por 'rat' e funções relacionadas. CRE extendidas 1452 são criadas por 'taylor' e funções relacionadas. 1453 1454 -- Variável de opção: ratprint 1455 Valor Padrão: 'true' 1456 1457 Quando 'ratprint' for 'true', uma mensagem informando ao usuário da 1458 conversão de números em ponto flutuante para números racionais é 1459 mostrada. 1460 1461 -- Função: ratsimp (<expr>) 1462 -- Função: ratsimp (<expr>, <x_1>, ..., <x_n>) 1463 Simplifica a expressão <expr> e todas as suas subexpressões, 1464 incluindo os argumentos para funções não racionais. O resultado é 1465 retornado como o quociente de dois polinômios na forma recursiva, 1466 isto é, os coeficientes de variável principal são polinômios em 1467 outras variáveis. Variáveis podem incluir funções não racionais 1468 (e.g., 'sin (x^2 + 1)') e os argumentos para quaisquer tais funções 1469 são também simplificados racionalmente. 1470 1471 'ratsimp (<expr>, <x_1>, ..., <x_n>)' habilita simplificação 1472 racional com a especiicação de variável ordenando como em 1473 'ratvars'. 1474 1475 Quando 'ratsimpexpons' for 'true', 'ratsimp' é aplicado para os 1476 expoentes de expressões durante a simplificação. 1477 1478 Veja também 'ratexpand'. Note que 'ratsimp' é afetado por algum 1479 dos sinalizadores que afetam 'ratexpand'. 1480 1481 Exemplos: 1482 1483 (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2); 1484 2 2 1485 x (log(x) + 1) - log (x) 1486 (%o1) sin(------) = %e 1487 2 1488 x + x 1489 (%i2) ratsimp (%); 1490 1 2 1491 (%o2) sin(-----) = %e x 1492 x + 1 1493 (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); 1494 3/2 1495 (x - 1) - sqrt(x - 1) (x + 1) 1496 (%o3) -------------------------------- 1497 sqrt((x - 1) (x + 1)) 1498 (%i4) ratsimp (%); 1499 2 sqrt(x - 1) 1500 (%o4) - ------------- 1501 2 1502 sqrt(x - 1) 1503 (%i5) x^(a + 1/a), ratsimpexpons: true; 1504 2 1505 a + 1 1506 ------ 1507 a 1508 (%o5) x 1509 1510 -- Variável de opção: ratsimpexpons 1511 Valor Padrão: 'false' 1512 1513 Quando 'ratsimpexpons' for 'true', 'ratsimp' é aplicado para os 1514 expoentes de expressões durante uma simplificação. 1515 1516 -- Função: ratsubst (<a>, <b>, <c>) 1517 Substitue <a> por <b> em <c> e retorna a expressão resultante. <b> 1518 pode também ser uma adição, produto, expoente, etc. 1519 1520 'ratsubst' sabe alguma coisa do significado de expressões uma vez 1521 que 'subst' não é uma substituição puramente sintática. Dessa 1522 forma 'subst (a, x + y, x + y + z)' retorna 'x + y + z' ao passo 1523 que 'ratsubst' retorna 'z + a'. 1524 1525 Quando 'radsubstflag' for 'true', 'ratsubst' faz substituição de 1526 radicais em expressões que explicitamente não possuem esses 1527 radicais. 1528 1529 Exemplos: 1530 1531 (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8); 1532 3 4 1533 (%o1) a x y + a 1534 (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1; 1535 4 3 2 1536 (%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1 1537 (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %); 1538 4 2 2 1539 (%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3 1540 (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4); 1541 4 2 1542 (%o4) cos (x) - 2 cos (x) + 1 1543 (%i5) radsubstflag: false$ 1544 (%i6) ratsubst (u, sqrt(x), x); 1545 (%o6) x 1546 (%i7) radsubstflag: true$ 1547 (%i8) ratsubst (u, sqrt(x), x); 1548 2 1549 (%o8) u 1550 1551 -- Função: ratvars (<x_1>, ..., <x_n>) 1552 -- Função: ratvars () 1553 -- Variável de sistema: ratvars 1554 Declara variáveis principais <x_1>, ..., <x_n> para expressões 1555 racionais. <x_n>, se presente em uma expressão racional, é 1556 considerada a variável principal. De outra forma, <x_[n-1]> é 1557 considerada a variável principal se presente, e assim por diante 1558 até as variáveis precedentes para <x_1>, que é considerada a 1559 variável principal somente se nenhuma das variáveis que a sucedem 1560 estiver presente. 1561 1562 Se uma variável em uma expressão racional não está presente na 1563 lista 'ratvars', a ela é dada uma prioridade menor que <x_1>. 1564 1565 Os argumentos para 'ratvars' podem ser ou variáveis ou funções não 1566 racionais tais como 'sin(x)'. 1567 1568 A variável 'ratvars' é uma lista de argumentos da função 'ratvars' 1569 quando ela foi chamada mais recentemente. Cada chamada para a 1570 função 'ratvars' sobre-grava a lista apagando seu conteúdo 1571 anterior. 'ratvars ()' limpa a lista. 1572 1573 -- Função: ratweight (<x_1>, <w_1>, ..., <x_n>, <w_n>) 1574 -- Função: ratweight () 1575 Atribui um peso <w_i> para a variável <x_i>. Isso faz com que um 1576 termo seja substituído por 0 se seu peso exceder o valor da 1577 variável 'ratwtlvl' (o padrão retorna sem truncação). O peso de um 1578 termo é a soma dos produtos dos pesos de uma variável no termo 1579 vezes seu expoente. Por exemplo, o peso de '3 x_1^2 x_2' é '2 w_1 1580 + w_2'. A truncação de acordo com 'ratwtlvl' é realizada somente 1581 quando multiplicando ou exponencializando expressões racionais 1582 canônicas (CRE). 1583 1584 'ratweight ()' retorna a lista cumulativa de atribuições de pesos. 1585 1586 Nota: Os esquemas de 'ratfac' e 'ratweight' são incompatíveis e não 1587 podem ambo serem usados ao mesmo tempo. 1588 1589 Exemplos: 1590 1591 (%i1) ratweight (a, 1, b, 1); 1592 (%o1) [a, 1, b, 1] 1593 (%i2) expr1: rat(a + b + 1)$ 1594 (%i3) expr1^2; 1595 2 2 1596 (%o3)/R/ b + (2 a + 2) b + a + 2 a + 1 1597 (%i4) ratwtlvl: 1$ 1598 (%i5) expr1^2; 1599 (%o5)/R/ 2 b + 2 a + 1 1600 1601 -- Variável de sistema: ratweights 1602 Valor Padrão: '[]' 1603 1604 'ratweights' é a lista de pesos atribuídos por 'ratweight'. A 1605 lista é cumulativa: cada chamada a 'ratweight' coloca ítens 1606 adicionais na lista. 1607 1608 'kill (ratweights)' e 'save (ratweights)' ambos trabalham como 1609 esperado. 1610 1611 -- Variável de opção: ratwtlvl 1612 Valor Padrão: 'false' 1613 1614 'ratwtlvl' é usada em combinação com a função 'ratweight' para 1615 controlar a truncação de expressão racionais canônicas (CRE). Para 1616 o valor padrão 'false', nenhuma truncação ocorre. 1617 1618 -- Função: remainder (<p_1>, <p_2>) 1619 -- Função: remainder (<p_1>, <p_2>, <x_1>, ..., <x_n>) 1620 Retorna o resto do polinômio <p_1> dividido pelo polinômio <p_2>. 1621 Os argumentos <x_1>, ..., <x_n> são interpretados como em 1622 'ratvars'. 1623 1624 'remainder' retorna o segundo elemento de uma lista de dois 1625 elementos retornada por 'divide'. 1626 1627 -- Função: resultant (<p_1>, <p_2>, <x>) 1628 -- Variável: resultant 1629 Calcula o resultante de dois polinômios <p_1> e <p_2>, eliminando a 1630 variável <x>. O resultante é um determinante dos coeficientes de 1631 <x> em <p_1> e <p_2>, que é igual a zero se e somente se <p_1> e 1632 <p_2> tiverem um fator em comum não constante. 1633 1634 Se <p_1> ou <p_2> puderem ser fatorados, pode ser desejável chamar 1635 'factor' antes de chamar 'resultant'. 1636 1637 A variável 'resultant' controla que algorítmo será usado para 1638 calcular o resultante. 'subres' para o prs subresultante, 'mod' 1639 para o algorítmo resultante modular, e 'red' para prs reduzido. 1640 Para muitos problemas 'subres' pode ser melhor. Para alguns 1641 problemas com valores grandes de grau de uma única variável ou de 1642 duas variáveis 'mod' pode ser melhor. 1643 1644 A função 'bezout' pega os mesmos argumentos que 'resultant' e 1645 retorna uma matriz. O determinante do valor de retorno é o 1646 resultante desejado. 1647 1648 -- Variável de opção: savefactors 1649 Valor Padrão: 'false' 1650 1651 Quando 'savefactors' for 'true', faz com que os fatores de uma 1652 expressão que é um produto de fatores sejam gravados por certas 1653 funções com o objetivo de aumentar a velocidade em posteriores 1654 fatorações de expressões contendo algum desses mesmos fatores. 1655 1656 -- Função: sqfr (<expr>) 1657 é similar a 'factor' exceto que os fatores do polinômio são "livres 1658 de raízes". Isto é, eles possuem fatores somente de grau um. Esse 1659 algorítmo, que é também usado no primeiro estágio de 'factor', 1660 utiliza o fato que um polinômio tem em comum com sua n'ésima 1661 derivada todos os seus fatores de grau maior que n. Dessa forma 1662 pegando o maior divisor comum com o polinômio das derivadas com 1663 relação a cada variável no polinômio, todos os fatores de grau 1664 maior que 1 podem ser achados. 1665 1666 Exemplo: 1667 1668 (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1); 1669 2 2 1670 (%o1) (2 x + 1) (x - 1) 1671 1672 -- Função: tellrat (<p_1>, ..., <p_n>) 1673 -- Função: tellrat () 1674 Adiciona ao anel dos inteiros algébricos conhecidos do Maxima os 1675 elementos que são as soluções dos polinômios <p_1>, ..., <p_n>. 1676 Cada argumento <p_i> é um polinômio concoeficientes inteiros. 1677 1678 'tellrat (<x>)' efetivamente significa substituir 0 por <x> em 1679 funções racionais. 1680 1681 'tellrat ()' retorna uma lista das substituições correntes. 1682 1683 'algebraic' deve ser escolhida para 'true' com o objetivo de que a 1684 simplificação de inteiros algébricos tenha efeito. 1685 1686 Maxima inicialmente sabe sobre a unidade imaginária '%i' e todas as 1687 raízes de inteiros. 1688 1689 Existe um comando 'untellrat' que pega kernels (núcleos) e remove 1690 propriedades 'tellrat'. 1691 1692 Quando fazemos 'tellrat' em um polinômio de várias variáveis, e.g., 1693 'tellrat (x^2 - y^2)', pode existir uma ambigüidade como para ou 1694 substituir '<y>^2' por '<x>^2' ou vice-versa. Maxima seleciona uma 1695 ordenação particular, mas se o usuário desejar especificar qual 1696 e.g. 'tellrat (y^2 = x^2)' forneçe uma sintaxe que diga para 1697 substituir '<y>^2' por '<x>^2'. 1698 1699 Exemplos: 1700 1701 (%i1) 10*(%i + 1)/(%i + 3^(1/3)); 1702 10 (%i + 1) 1703 (%o1) ----------- 1704 1/3 1705 %i + 3 1706 (%i2) ev (ratdisrep (rat(%)), algebraic); 1707 2/3 1/3 2/3 1/3 1708 (%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2 1709 (%i3) tellrat (1 + a + a^2); 1710 2 1711 (%o3) [a + a + 1] 1712 (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2)); 1713 1 a 1714 (%o4) ------------- + ----------------- 1715 sqrt(2) a - 1 sqrt(3) + sqrt(2) 1716 (%i5) ev (ratdisrep (rat(%)), algebraic); 1717 (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1 1718 (%o5) ---------------------------------------------- 1719 7 1720 (%i6) tellrat (y^2 = x^2); 1721 2 2 2 1722 (%o6) [y - x , a + a + 1] 1723 1724 -- Função: totaldisrep (<expr>) 1725 Converte toda subexpressão de <expr> da forma de expressão 1726 racionais canônicas (CRE) para a forma geral e retorna o resultado. 1727 Se <expr> é em sí mesma na forma CRE então 'totaldisrep' é identica 1728 a 'ratdisrep'. 1729 1730 'totaldisrep' pode ser usada para fazer um 'ratdisrep' em 1731 expressões tais como equações, listas, matrizes, etc., que tiverem 1732 algumas subexpressões na forma CRE. 1733 1734 -- Função: untellrat (<x_1>, ..., <x_n>) 1735 Remove propriedades 'tellrat' de <x_1>, ..., <x_n>. 1736 1737 1738File: maxima.info, Node: Constantes, Next: Logarítmos, Prev: Polinômios, Up: Top 1739 174013 Constantes 1741************* 1742 1743* Menu: 1744 1745* Funções e Variáveis Definidas para Constantes:: 1746 1747 1748File: maxima.info, Node: Funções e Variáveis Definidas para Constantes, Prev: Constantes, Up: Constantes 1749 175013.1 Funções e Variáveis Definidas para Constantes 1751================================================== 1752 1753 -- Constante: %e 1754 '%e' representa a base do logarítmo natural, também conhecido como 1755 constante de Euler. O valor numérico de '%e' é um número em ponto 1756 flutuante de precisão dupla 2.718281828459045d0. 1757 1758 -- Constante: %i 1759 '%i' representa a unidade imaginária, sqrt(- 1). 1760 1761 -- Constante: false 1762 'false' representa a constante Booleana falso. Maxima implementa 1763 'false' através do valor 'NIL' no Lisp. 1764 1765 -- Constante: inf 1766 'inf' representa o infinito positivo real. 1767 1768 -- Constante: infinity 1769 'infinity' representa o infinito complexo. 1770 1771 -- Constante: minf 1772 'minf' representa o menos infinito (i.e., negativo) real. 1773 1774 -- Constante: %phi 1775 1776 '%phi' representa o então chamado número áureo, (1 + sqrt(5))/2. O 1777 valor numérico de '%phi' é o número em ponto flutuante de de dupla 1778 precisão 1.618033988749895d0. 1779 1780 'fibtophi' expressa números de Fibonacci 'fib(n)' em termos de 1781 '%phi'. 1782 1783 Por padrão, Maxima não conhece as propriedade algébricas de '%phi'. 1784 Após avaliar 'tellrat(%phi^2 - %phi - 1)' e 'algebraic: true', 1785 'ratsimp' pode simplificar algumas expressãoes contendo '%phi'. 1786 1787 Exemplos: 1788 1789 'fibtophi' expresses Fibonacci numbers 'fib(n)' in terms of '%phi'. 1790 1791 (%i1) fibtophi (fib (n)); 1792 n n 1793 %phi - (1 - %phi) 1794 (%o1) ------------------- 1795 2 %phi - 1 1796 (%i2) fib (n-1) + fib (n) - fib (n+1); 1797 (%o2) - fib(n + 1) + fib(n) + fib(n - 1) 1798 (%i3) fibtophi (%); 1799 n + 1 n + 1 n n 1800 %phi - (1 - %phi) %phi - (1 - %phi) 1801 (%o3) - --------------------------- + ------------------- 1802 2 %phi - 1 2 %phi - 1 1803 n - 1 n - 1 1804 %phi - (1 - %phi) 1805 + --------------------------- 1806 2 %phi - 1 1807 (%i4) ratsimp (%); 1808 (%o4) 0 1809 1810 Por padrão, Maxima não conhece as propriedade algébricas de '%phi'. 1811 Após avaliar 'tellrat(%phi^2 - %phi - 1)' e 'algebraic: true', 1812 'ratsimp' pode simplificar algumas expressãoes contendo '%phi'. 1813 1814 (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1)); 1815 2 2 1816 (%o1) %phi A - %phi A - A + %phi - %phi - 1 1817 (%i2) ratsimp (e); 1818 2 2 1819 (%o2) (%phi - %phi - 1) A + %phi - %phi - 1 1820 (%i3) tellrat (%phi^2 - %phi - 1); 1821 2 1822 (%o3) [%phi - %phi - 1] 1823 (%i4) algebraic : true; 1824 (%o4) true 1825 (%i5) ratsimp (e); 1826 (%o5) 0 1827 1828 -- Constante: %pi 1829 '%pi' representa a razão do perímetro de um círculo para seu 1830 diâmetro. O valor numérico de '%pi' é o n;umero em ponto flutuante 1831 de dupla precisão 3.141592653589793d0. 1832 1833 -- Constante: true 1834 'true' representa a constante Booleana verdadeiro. Maxima 1835 implementa 'true' através do valor 'T' no Lisp. 1836 1837 1838File: maxima.info, Node: Logarítmos, Next: Trigonometria, Prev: Constantes, Up: Top 1839 184014 Logarítmos 1841************* 1842 1843* Menu: 1844 1845* Funções e Variáveis Definidas para Logarítmos:: 1846 1847 1848File: maxima.info, Node: Funções e Variáveis Definidas para Logarítmos, Prev: Logarítmos, Up: Logarítmos 1849 185014.1 Funções e Variáveis Definidas para Logarítmos 1851================================================== 1852 1853 -- Variável de opção: %e_to_numlog 1854 Valor padrão: 'false' 1855 1856 Quando 'true', sendo 'r' algum número racional, e 'x' alguma 1857 expressão, '%e^(r*log(x))' será simplificado em 'x^r' . Note-se 1858 que o comando 'radcan' também faz essa transformação, e 1859 transformações mais complicadas desse tipo também. O comando 1860 'logcontract' "contrai" expressões contendo 'log'. 1861 1862 -- Função: li [<s>] (<z>) 1863 Representa a função polilogarítmo de ordem <s> e argumento <z>, 1864 definida por meio de séries infinitas 1865 1866 inf 1867 ==== k 1868 \ z 1869 Li (z) = > -- 1870 s / s 1871 ==== k 1872 k = 1 1873 1874 'li [1]' é '- log (1 - z)'. 'li [2]' e 'li [3]' são as funções 1875 dilogarítmo e trilogarítmo, respectivamente. 1876 1877 Quando a ordem for 1, o polilogarítmo simplifica para '- log (1 - 1878 z)', o qual por sua vez simplifica para um valor numérico se <z> 1879 for um número em ponto flutuante real ou complexo ou o sinalizador 1880 de avaliação 'numer' estiver presente. 1881 1882 Quando a ordem for 2 ou 3, o polilogarítmo simplifica para um valor 1883 numérico se <z> for um número real em ponto flutuante ou o 1884 sinalizador de avaliação 'numer' estiver presente. 1885 1886 Exemplos: 1887 1888 (%i1) assume (x > 0); 1889 (%o1) [x > 0] 1890 (%i2) integrate ((log (1 - t)) / t, t, 0, x); 1891 (%o2) - li (x) 1892 2 1893 (%i3) li [2] (7); 1894 (%o3) li (7) 1895 2 1896 (%i4) li [2] (7), numer; 1897 (%o4) 1.24827317833392 - 6.113257021832577 %i 1898 (%i5) li [3] (7); 1899 (%o5) li (7) 1900 3 1901 (%i6) li [2] (7), numer; 1902 (%o6) 1.24827317833392 - 6.113257021832577 %i 1903 (%i7) L : makelist (i / 4.0, i, 0, 8); 1904 (%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0] 1905 (%i8) map (lambda ([x], li [2] (x)), L); 1906 (%o8) [0, .2676526384986274, .5822405249432515, 1907 .9784693966661848, 1.64493407, 2.190177004178597 1908 - .7010261407036192 %i, 2.374395264042415 1909 - 1.273806203464065 %i, 2.448686757245154 1910 - 1.758084846201883 %i, 2.467401098097648 1911 - 2.177586087815347 %i] 1912 (%i9) map (lambda ([x], li [3] (x)), L); 1913 (%o9) [0, .2584613953442624, 0.537213192678042, 1914 .8444258046482203, 1.2020569, 1.642866878950322 1915 - .07821473130035025 %i, 2.060877505514697 1916 - .2582419849982037 %i, 2.433418896388322 1917 - .4919260182322965 %i, 2.762071904015935 1918 - .7546938285978846 %i] 1919 1920 -- Função: log (<x>) 1921 Representa o logarítmo natural (base e) de <x>. 1922 1923 Maxima não possui uma função interna para logarítmo de base 10 ou 1924 de outras bases. 'log10(x) := log(x) / log(10)' é uma definição 1925 útil. 1926 1927 Simplificação e avaliação de logarítmos são governadas por muitos 1928 sinalizadores globais: 1929 1930 'logexpand' - faz com que 'log(a^b)' torne-se 'b*log(a)'. Se 1931 'logexpand' for escolhida para 'all', 'log(a*b)' irá também 1932 simplificar para 'log(a)+log(b)'. Se 'logexpand' for escolhida 1933 para 'super', então 'log(a/b)' irá também simplificar para 1934 'log(a)-log(b)' para números racionais 'a/b', 'a#1'. ('log(1/b)', 1935 para 'b' inteiro, sempre simplifica). Se 'logexpand' for escolhida 1936 para 'false', todas essas simplificações irão ser desabilitadas. 1937 1938 'logsimp' - se 'false' então nenhuma simplificação de '%e' para um 1939 expoente contendo 'log''s é concluída. 1940 1941 'lognumer' - se 'true' então argumentos negativos em ponto 1942 flutuante para 'log' irá sempre ser convertido para seu valor 1943 absoluto antes que 'log' seja tomado. Se 'numer' for também 1944 'true', então argumentos negativos inteiros para 'log' irão também 1945 ser convertidos para seu valor absoluto. 1946 1947 'lognegint' - se 'true' implementa a regra 'log(-n)' -> 1948 'log(n)+%i*%pi' para 'n' um inteiro positivo. 1949 1950 '%e_to_numlog' - quando 'true', 'r' sendo algum número racional, e 1951 'x' alguma expressão, '%e^(r*log(x))' será simplificado em 'x^r' . 1952 Note-se que o comando 'radcan' também faz essa transformação, e 1953 transformações mais complicadas desse tipo também. O comando 1954 'logcontract' "contrai" expressões contendo 'log'. 1955 1956 -- Variável de opção: logabs 1957 Valor padrão: 'false' 1958 1959 Quando fazendo integração indefinida onde logs são gerados, e.g. 1960 'integrate(1/x,x)', a resposta é dada em termos de 'log(abs(...))' 1961 se 'logabs' for 'true', mas em termos de 'log(...)' se 'logabs' for 1962 'false'. Para integração definida, a escolha 'logabs:true' é 1963 usada, porque aqui "avaliação" de integral indefinida nos extremos 1964 é muitas vezes necessária. 1965 1966 -- Variável de opção: logarc 1967 -- Função: logarc (<expr>) 1968 1969 Quando a variável global 'logarc' for 'true', funções circulares 1970 inversas e funções hiperbólicas serão convertidas em funções 1971 logarítimicas equivalentes. O valor padrão de 'logarc' é 'false'. 1972 1973 A função 'logarc(<expr>)' realiza aquela substituíção para uma 1974 expressão <expr> sem modificar o valor da variável global 'logarc'. 1975 1976 -- Variável de opção: logconcoeffp 1977 Valor padrão: 'false' 1978 1979 Controla quais coeficientes são contraídos quando usando 1980 'logcontract'. Pode ser escolhida para o nome de uma função 1981 predicado de um argumento. E.g. se você gosta de gerar raízes 1982 quadradas, você pode fazer 'logconcoeffp:'logconfun$ 1983 logconfun(m):=featurep(m,integer) ou ratnump(m)$' . Então 1984 'logcontract(1/2*log(x));' irá fornecer 'log(sqrt(x))'. 1985 1986 -- Função: logcontract (<expr>) 1987 Recursivamente examina a expressão <expr>, transformando 1988 subexpressões da forma 'a1*log(b1) + a2*log(b2) + c' em 1989 'log(ratsimp(b1^a1 * b2^a2)) + c' 1990 1991 (%i1) 2*(a*log(x) + 2*a*log(y))$ 1992 (%i2) logcontract(%); 1993 2 4 1994 (%o2) a log(x y ) 1995 1996 1997 Se você faz 'declare(n,integer);' então 1998 'logcontract(2*a*n*log(x));' fornece 'a*log(x^(2*n))'. Os 1999 coeficientes que "contraem" dessa maneira são aqueles tais que 2 e 2000 'n' que satisfazem 'featurep(coeff,integer)'. O usuário pode 2001 controlar quais coeficientes são contraídos escolhendo a opção 2002 'logconcoeffp' para o nome de uma função predicado de um argumento. 2003 E.g. se você gosta de gerara raízes quadradas, você pode fazer 2004 'logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) ou 2005 ratnump(m)$' . Então 'logcontract(1/2*log(x));' irá fornecer 2006 'log(sqrt(x))'. 2007 2008 -- Variável de opção: logexpand 2009 Valor padrão: 'true' 2010 2011 Faz com que 'log(a^b)' torne-se 'b*log(a)'. Se for escolhida para 2012 'all', 'log(a*b)' irá também simplificar para 'log(a)+log(b)'. Se 2013 for escolhida para 'super', então 'log(a/b)' irá também simplificar 2014 para 'log(a)-log(b)' para números racionais 'a/b', 'a#1'. 2015 ('log(1/b)', para 'b' inteiro, sempre simplifica). Se for 2016 escolhida para 'false', todas essas simplificações irão ser 2017 desabilitadas. 2018 2019 -- Variável de opção: lognegint 2020 Valor padrão: 'false' 2021 2022 Se 'true' implementa a regra 'log(-n)' -> 'log(n)+%i*%pi' para 'n' 2023 um inteiro positivo. 2024 2025 -- Variável de opção: lognumer 2026 Valor padrão: 'false' 2027 2028 Se 'true' então argumentos negativos em ponto flutuante para 'log' 2029 irão sempre ser convertidos para seus valores absolutos antes que o 2030 'log' seja tomado. Se 'numer' for também 'true', então argumentos 2031 inteiros negativos para 'log' irão também ser convertidos para seus 2032 valores absolutos. 2033 2034 -- Variável de opção: logsimp 2035 Valor padrão: 'true' 2036 2037 Se 'false' então nenhuma simplificação de '%e' para um expoente 2038 contendo 'log''s é concluída. 2039 2040 -- Função: plog (<x>) 2041 Representa o principal ramo logarítmos naturais avaliados para 2042 complexos com '-%pi' < 'carg(<x>)' <= '+%pi' . 2043 2044 2045File: maxima.info, Node: Trigonometria, Next: Funções Especiais, Prev: Logarítmos, Up: Top 2046 204715 Trigonometria 2048**************** 2049 2050* Menu: 2051 2052* Introdução ao Pacote Trigonométrico:: 2053* Funções e Variáveis Definidas para Trigonometria:: 2054 2055 2056File: maxima.info, Node: Introdução ao Pacote Trigonométrico, Next: Funções e Variáveis Definidas para Trigonometria, Prev: Trigonometria, Up: Trigonometria 2057 205815.1 Introdução ao Pacote Trigonométrico 2059======================================== 2060 2061Maxima tem muitas funções trigonométricas definidas. Não todas as 2062identidades trigonometricas estão programadas, mas isso é possível para 2063o usuário adicionar muitas delas usando a compatibilidade de 2064correspondência de modelos do sistema. As funções trigonométricas 2065definidas no Maxima são: 'acos', 'acosh', 'acot', 'acoth', 'acsc', 2066'acsch', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atanh', 'cos', 2067'cosh', 'cot', 'coth', 'csc', 'csch', 'sec', 'sech', 'sin', 'sinh', 2068'tan', e 'tanh'. Existe uma coleção de comandos especialmente para 2069manusear funções trigonométricas, veja 'trigexpand', 'trigreduce', e o 2070comutador 'trigsign'. Dois pacotes compartilhados extendem as regras de 2071simplificação construídas no Maxima, 'ntrig' e 'atrig1'. Faça 2072'describe(<comando>)' para detalhes. 2073 2074 2075File: maxima.info, Node: Funções e Variáveis Definidas para Trigonometria, Prev: Introdução ao Pacote Trigonométrico, Up: Trigonometria 2076 207715.2 Funções e Variáveis Definidas para Trigonometria 2078===================================================== 2079 2080 -- Função: acos (<x>) 2081 - Arco Cosseno. 2082 2083 -- Função: acosh (<x>) 2084 - Arco Cosseno Hiperbólico. 2085 2086 -- Função: acot (<x>) 2087 - Arco Cotangente. 2088 2089 -- Função: acoth (<x>) 2090 - Arco Cotangente Hiperbólico. 2091 2092 -- Função: acsc (<x>) 2093 - Arco Cossecante. 2094 2095 -- Função: acsch (<x>) 2096 - Arco Cossecante Hiperbólico. 2097 2098 -- Função: asec (<x>) 2099 - Arco Secante. 2100 2101 -- Função: asech (<x>) 2102 - Arco Secante Hiperbólico. 2103 2104 -- Função: asin (<x>) 2105 - Arco Seno. 2106 2107 -- Função: asinh (<x>) 2108 - Arco Seno Hiperbólico. 2109 2110 -- Função: atan (<x>) 2111 - Arco Tangente. 2112 2113 -- Função: atan2 (<y>, <x>) 2114 - retorna o valor de 'atan(<y>/<x>)' no intervalo de '-%pi' a 2115 '%pi'. 2116 2117 -- Função: atanh (<x>) 2118 - Arco tangente Hiperbólico. 2119 2120 -- Pacote: atrig1 2121 O pacote 'atrig1' contém muitas regras adicionais de simplificação 2122 para funções trigonométricas inversas. Junto com regras já 2123 conhecidas para Maxima, os seguintes ângulos estão completamente 2124 implementados: '0', '%pi/6', '%pi/4', '%pi/3', e '%pi/2'. Os 2125 ângulos correspondentes nos outros três quadrantes estão também 2126 disponíveis. Faça 'load(atrig1);' para usá-lo. 2127 2128 -- Função: cos (<x>) 2129 - Cosseno. 2130 2131 -- Função: cosh (<x>) 2132 - Cosseno hiperbólico. 2133 2134 -- Função: cot (<x>) 2135 - Cotangente. 2136 2137 -- Função: coth (<x>) 2138 - Cotangente Hyperbólica. 2139 2140 -- Função: csc (<x>) 2141 - Cossecante. 2142 2143 -- Função: csch (<x>) 2144 - Cossecante Hyperbólica. 2145 2146 -- Variável de opção: halfangles 2147 Default value: 'false' 2148 2149 Quando 'halfangles' for 'true', meios-ângulos são simplificados 2150 imediatamente. 2151 2152 -- Pacote: ntrig 2153 O pacote 'ntrig' contém um conjunto de regras de simplificação que 2154 são usadas para simplificar função trigonométrica cujos argumentos 2155 estão na forma '<f>(<n> %pi/10)' onde <f> é qualquer das funções 2156 'sin', 'cos', 'tan', 'csc', 'sec' e 'cot'. 2157 2158 -- Função: sec (<x>) 2159 - Secante. 2160 2161 -- Função: sech (<x>) 2162 - Secante Hyperbólica. 2163 2164 -- Função: sin (<x>) 2165 - Seno. 2166 2167 -- Função: sinh (<x>) 2168 - Seno Hyperbólico. 2169 2170 -- Função: tan (<x>) 2171 - Tangente. 2172 2173 -- Função: tanh (<x>) 2174 - Tangente Hyperbólica. 2175 2176 -- Função: trigexpand (<expr>) 2177 Expande funções trigonometricas e hyperbólicas de adições de 2178 ângulos e de ângulos multiplos que ocorram em <expr>. Para 2179 melhores resultados, <expr> deve ser expandida. Para intensificar 2180 o controle do usuário na simplificação, essa função expande somente 2181 um nível de cada vez, expandindo adições de ângulos ou ângulos 2182 multiplos. Para obter expansão completa dentro de senos e cossenos 2183 imediatamente, escolha o comutador 'trigexpand: true'. 2184 2185 'trigexpand' é governada pelos seguintes sinalizadores globais: 2186 2187 'trigexpand' 2188 Se 'true' causa expansão de todas as expressões contendo senos 2189 e cossenos ocorrendo subseqüêntemente. 2190 'halfangles' 2191 Se 'true' faz com que meios-ângulos sejam simplificados 2192 imediatamente. 2193 'trigexpandplus' 2194 Controla a regra "soma" para 'trigexpand', expansão de adições 2195 (e.g. 'sin(x + y)') terão lugar somente se 'trigexpandplus' 2196 for 'true'. 2197 'trigexpandtimes' 2198 Controla a regra "produto" para 'trigexpand', expansão de 2199 produtos (e.g. 'sin(2 x)') terão lugar somente se 2200 'trigexpandtimes' for 'true'. 2201 2202 Exemplos: 2203 2204 (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand; 2205 2 2 2206 (%o1) - sin (x) + 3 cos (x) + x 2207 (%i2) trigexpand(sin(10*x+y)); 2208 (%o2) cos(10 x) sin(y) + sin(10 x) cos(y) 2209 2210 2211 -- Variável de opção: trigexpandplus 2212 Valor padrão: 'true' 2213 2214 'trigexpandplus' controla a regra da "soma" para 'trigexpand'. 2215 Dessa forma, quando o comando 'trigexpand' for usado ou o comutador 2216 'trigexpand' escolhido para 'true', expansão de adições (e.g. 2217 'sin(x+y))' terão lugar somente se 'trigexpandplus' for 'true'. 2218 2219 -- Variável de opção: trigexpandtimes 2220 Valor padrão: 'true' 2221 2222 'trigexpandtimes' controla a regra "produto" para 'trigexpand'. 2223 Dessa forma, quando o comando 'trigexpand' for usado ou o comutador 2224 'trigexpand' escolhido para 'true', expansão de produtos (e.g. 2225 'sin(2*x)') terão lugar somente se 'trigexpandtimes' for 'true'. 2226 2227 -- Variável de opção: triginverses 2228 Valor padrão: 'all' 2229 2230 'triginverses' controla a simplificação de composições de funções 2231 trigonométricas e hiperbólicas com suas funções inversas. 2232 2233 Se 'all', ambas e.g. 'atan(tan(<x>))' e 'tan(atan(<x>))' 2234 simplificarão para <x>. 2235 2236 Se 'true', a simplificação de '<arcfun>(<fun>(<x>))' é 2237 desabilitada. 2238 2239 Se 'false', ambas as simplificações '<arcfun>(<fun>(<x>))' e 2240 '<fun>(<arcfun>(<x>))' são desabilitadas. 2241 2242 -- Função: trigreduce (<expr>, <x>) 2243 -- Função: trigreduce (<expr>) 2244 Combina produtos e expoentes de senos e cossenso trigonométricos e 2245 hiperbólicos de <x> dentro daqueles de múltiplos de <x>. Também 2246 tenta eliminar essas funções quando elas ocorrerem em 2247 denominadores. Se <x> for omitido então todas as variáveis em 2248 <expr> são usadas. 2249 2250 Veja também 'poissimp'. 2251 2252 (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x); 2253 cos(2 x) cos(2 x) 1 1 2254 (%o1) -------- + 3 (-------- + -) + x - - 2255 2 2 2 2 2256 2257 2258 As rotinas de simplificação trigonométrica irão usar informações 2259 declaradas em alguns casos simples. Declarações sobre variáveis 2260 são usadas como segue, e.g. 2261 2262 (%i1) declare(j, integer, e, even, o, odd)$ 2263 (%i2) sin(x + (e + 1/2)*%pi); 2264 (%o2) cos(x) 2265 (%i3) sin(x + (o + 1/2)*%pi); 2266 (%o3) - cos(x) 2267 2268 2269 -- Variável de opção: trigsign 2270 Valor padrão: 'true' 2271 2272 Quando 'trigsign' for 'true', permite simplificação de argumentos 2273 negativos para funções trigonométricas. E.g., 'sin(-x)' 2274 transformar-se-á em '-sin(x)' somente se 'trigsign' for 'true'. 2275 2276 -- Função: trigsimp (<expr>) 2277 Utiliza as identidades sin(x)^2 + cos(x)^2 = 1 and cosh(x)^2 - 2278 sinh(x)^2 = 1 para simplificar expressões contendo 'tan', 'sec', 2279 etc., para 'sin', 'cos', 'sinh', 'cosh'. 2280 2281 'trigreduce', 'ratsimp', e 'radcan' podem estar habilitadas a 2282 adicionar simplificações ao resultado. 2283 2284 'demo ("trgsmp.dem")' mostra alguns exemplos de 'trigsimp'. 2285 2286 -- Função: trigrat (<expr>) 2287 Fornece uma forma quase-linear simplificada canônica de uma 2288 expressão trigonométrica; <expr> é uma fração racional de muitos 2289 'sin', 'cos' ou 'tan', os argumentos delas são formas lineares em 2290 algumas variáveis (ou kernels-núcleos) e '%pi/<n>' (<n> inteiro) 2291 com coeficientes inteiros. O resultado é uma fração simplificada 2292 com numerador e denominador ambos lineares em 'sin' e 'cos'. Dessa 2293 forma 'trigrat' lineariza sempre quando isso for passível. 2294 2295 (%i1) trigrat(sin(3*a)/sin(a+%pi/3)); 2296 (%o1) sqrt(3) sin(2 a) + cos(2 a) - 1 2297 2298 2299 O seguinte exemplo encontra-se em Davenport, Siret, and Tournier, 2300 Calcul Formel, Masson (ou em inglês, Addison-Wesley), seção 1.5.5, 2301 teorema de Morley. 2302 2303 (%i1) c: %pi/3 - a - b; 2304 %pi 2305 (%o1) - b - a + --- 2306 3 2307 (%i2) bc: sin(a)*sin(3*c)/sin(a+b); 2308 sin(a) sin(3 b + 3 a) 2309 (%o2) --------------------- 2310 sin(b + a) 2311 (%i3) ba: bc, c=a, a=c$ 2312 (%i4) ac2: ba^2 + bc^2 - 2*bc*ba*cos(b); 2313 2 2 2314 sin (a) sin (3 b + 3 a) 2315 (%o4) ----------------------- 2316 2 2317 sin (b + a) 2318 2319 %pi 2320 2 sin(a) sin(3 a) cos(b) sin(b + a - ---) sin(3 b + 3 a) 2321 3 2322 - -------------------------------------------------------- 2323 %pi 2324 sin(a - ---) sin(b + a) 2325 3 2326 2327 2 2 %pi 2328 sin (3 a) sin (b + a - ---) 2329 3 2330 + --------------------------- 2331 2 %pi 2332 sin (a - ---) 2333 3 2334 (%i5) trigrat (ac2); 2335 (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a) 2336 2337 - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a) 2338 2339 - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a) 2340 2341 + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a) 2342 2343 + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b) 2344 2345 + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a) 2346 2347 - 9)/4 2348 2349 2350 2351File: maxima.info, Node: Funções Especiais, Next: Funções Elípticas, Prev: Trigonometria, Up: Top 2352 235316 Funções Especiais 2354******************** 2355 2356* Menu: 2357 2358* Introdução a Funções Especiais:: 2359* Funções e Variáveis Definidas para Funções Especiais:: 2360 2361 2362File: maxima.info, Node: Introdução a Funções Especiais, Next: Funções e Variáveis Definidas para Funções Especiais, Prev: Funções Especiais, Up: Funções Especiais 2363 236416.1 Introdução a Funções Especiais 2365=================================== 2366 2367A notação de função especial segue adiante: 2368 2369 bessel_j (index, expr) Função de Bessel, primeiro tipo 2370 bessel_y (index, expr) Função de Bessel, segundo tipo 2371 bessel_i (index, expr) Função de Bessel modificada, primeiro tipo 2372 bessel_k (index, expr) Função de Bessel modificada, segundo tipo 2373 %he[n] (z) Polinômio de Hermite (Note bem: he, não h. Veja A&S 22.5.18) 2374 %p[u,v] (z) Função de Legendre 2375 %q[u,v] (z) Função de Legendre, segundo tipo 2376 hstruve[n] (z) Função H de Struve H 2377 lstruve[n] (z) Função L de Struve 2378 %f[p,q] ([], [], expr) Função Hipergeométrica Generalizada 2379 gamma() Função Gamma 2380 gamma_incomplete_lower(a,z) Função gama incompleta inferior 2381 gammaincomplete(a,z) Final da função gama incompleta 2382 slommel 2383 %m[u,k] (z) Função de Whittaker, primeiro tipo 2384 %w[u,k] (z) Função de Whittaker, segundo tipo 2385 erfc (z) Complemento da função erf (função de erros - integral da distribuição normal) 2386 ei (z) Integral de exponencial (?) 2387 kelliptic (z) integral eliptica completa de primeiro tipo (K) 2388 %d [n] (z) Função cilíndrica parabólica 2389 2390 2391File: maxima.info, Node: Funções e Variáveis Definidas para Funções Especiais, Prev: Introdução a Funções Especiais, Up: Funções Especiais 2392 239316.2 Funções e Variáveis Definidas para Funções Especiais 2394========================================================= 2395 2396 -- Função: airy_ai (<x>) 2397 A função de Airy Ai, como definida em Abramowitz e Stegun, Handbook 2398 of Mathematical Functions, Sessão 10.4. 2399 2400 A equação de Airy 'diff (y(x), x, 2) - x y(x) = 0' tem duas 2401 soluções linearmente independentes, 'y = Ai(x)' e 'y = Bi(x)'. A 2402 derivada de 'diff (airy_ai(x), x)' é 'airy_dai(x)'. 2403 2404 Se o argumento 'x' for um número real ou um número complexo 2405 qualquer deles em ponto flutuante , o valor numérico de 'airy_ai' é 2406 retornado quando possível. 2407 2408 Veja também 'airy_bi', 'airy_dai', 'airy_dbi'. 2409 2410 -- Função: airy_dai (<x>) 2411 A derivada da função de Airy Ai 'airy_ai(x)'. 2412 2413 Veja 'airy_ai'. 2414 2415 -- Função: airy_bi (<x>) 2416 A função de Airy Bi, como definida em Abramowitz e Stegun, Handbook 2417 of Mathematical Functions, Sessão 10.4, é a segunda solução da 2418 equação de Airy 'diff (y(x), x, 2) - x y(x) = 0'. 2419 2420 Se o argumento 'x' for um número real ou um número complexo 2421 qualquer deles em ponto flutuante, o valor numérico de 'airy_bi' é 2422 retornado quando possível. Em outros casos a expressão não 2423 avaliada é retornada. 2424 2425 A derivada de 'diff (airy_bi(x), x)' é 'airy_dbi(x)'. 2426 2427 Veja 'airy_ai', 'airy_dbi'. 2428 2429 -- Função: airy_dbi (<x>) 2430 A derivada de função de Airy Bi 'airy_bi(x)'. 2431 2432 Veja 'airy_ai' e 'airy_bi'. 2433 2434 -- Função: asympa 2435 'asympa' é um pacote para análise assintótica. O pacote contém 2436 funções de simplificação para análise assintótica, incluindo as 2437 funções "grande O" e "pequeno o" que são largamente usadas em 2438 análises de complexidade e análise numérica. 2439 2440 'load ("asympa")' chama esse pacote. 2441 2442 -- Função: bessel (<z>, <a>) 2443 A função de Bessel de primeiro tipo. 2444 2445 Essa função está desatualizada. Escreva 'bessel_j (<z>, <a>)' em 2446 lugar dessa. 2447 2448 -- Função: bessel_j (<v>, <z>) 2449 A função de Bessel do primeiro tipo de ordem v e argumento z. 2450 2451 'bessel_j' calcula o array 'besselarray' tal que 'besselarray [i] = 2452 bessel_j [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'. 2453 2454 'bessel_j' é definida como 2455 inf 2456 ==== k - v - 2 k v + 2 k 2457 \ (- 1) 2 z 2458 > -------------------------- 2459 / k! gamma(v + k + 1) 2460 ==== 2461 k = 0 2462 2463 todavia séries infinitas não são usadas nos cálculos. 2464 2465 -- Função: bessel_y (<v>, <z>) 2466 A função de Bessel do segundo tipo de ordem v e argumento z. 2467 2468 'bessel_y' calcula o array 'besselarray' tal que 'besselarray [i] = 2469 bessel_y [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'. 2470 2471 'bessel_y' é definida como 2472 cos(%pi v) bessel_j(v, z) - bessel_j(-v, z) 2473 ------------------------------------------- 2474 sin(%pi v) 2475 2476 quando v não for um inteiro. Quando v for um inteiro n, o limite 2477 com v aprocimando-se de n é tomado. 2478 2479 -- Função: bessel_i (<v>, <z>) 2480 A função de Bessel modificada de primeiro tipo de ordem v e 2481 argumento z. 2482 2483 'bessel_i' calcula o array 'besselarray' tal que 'besselarray [i] = 2484 bessel_i [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'. 2485 2486 'bessel_i' é definida como 2487 inf 2488 ==== - v - 2 k v + 2 k 2489 \ 2 z 2490 > ------------------- 2491 / k! gamma(v + k + 1) 2492 ==== 2493 k = 0 2494 2495 embora séries infinitas não são usadas nos cálculos. 2496 2497 -- Função: bessel_k (<v>, <z>) 2498 A função de Bessel modificada de segundo tipo de ordem v e 2499 argumento z. 2500 2501 'bessel_k' calcula o array 'besselarray' tal que 'besselarray [i] = 2502 bessel_k [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'. 2503 2504 'bessel_k' é definida como 2505 %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z)) 2506 ------------------------------------------------- 2507 2 2508 2509 quando v não for inteiro. Se v for um inteiro n, então o limite 2510 com v aproximando-se de n é tomado. 2511 2512 -- Variável de opção: besselexpand 2513 Valor padrão: 'false' 2514 2515 Expansões de controle de funções de Bessel quando a ordem for a 2516 metade de um inteiro ímpar. Nesse caso, as funções de Bessel podem 2517 ser expandidas em termos de outras funções elementares. Quando 2518 'besselexpand' for 'true', a função de Bessel é expandida. 2519 2520 (%i1) besselexpand: false$ 2521 (%i2) bessel_j (3/2, z); 2522 3 2523 (%o2) bessel_j(-, z) 2524 2 2525 (%i3) besselexpand: true$ 2526 (%i4) bessel_j (3/2, z); 2527 2 z sin(z) cos(z) 2528 (%o4) sqrt(---) (------ - ------) 2529 %pi 2 z 2530 z 2531 2532 -- Função: scaled_bessel_i (<v>, <z>) 2533 2534 A função homotética modificada de Bessel de primeiro tipo de ordem 2535 v e argumento z. Isto é, scaled_bessel_i(v,z) = 2536 exp(-abs(z))*bessel_i(v, z). Essa função é particularmente útil 2537 para calcular bessel_i para grandes valores de z. Todavia, maxima 2538 não conhece outra forma muito mais sobre essa função. Para 2539 computação simbólica, é provavelmete preferível trabalhar com a 2540 expressão 'exp(-abs(z))*bessel_i(v, z)'. 2541 2542 -- Função: scaled_bessel_i0 (<z>) 2543 2544 Idêntica a 'scaled_bessel_i(0,z)'. 2545 2546 -- Função: scaled_bessel_i1 (<z>) 2547 2548 Idêntica a 'scaled_bessel_i(1,z)'. 2549 2550 -- Função: beta (<x>, <y>) 2551 A função beta, definida como 'gamma(x) gamma(y)/gamma(x + y)'. 2552 2553 -- Função: gamma (<x>) 2554 A função gama. 2555 2556 Veja também 'makegamma'. 2557 2558 A variável 'gammalim' controla a simplificação da função gama. 2559 2560 A constante de Euler-Mascheroni é '%gamma'. 2561 2562 -- Variável de opção: gammalim 2563 Valor padrão: 1000000 2564 2565 'gammalim' controla a simplificação da função gama para integral e 2566 argumentos na forma de números racionais. Se o valor absoluto do 2567 argumento não for maior que 'gammalim', então a simplificação 2568 ocorrerá. Note que 'factlim' comuta controle de simplificaçcão do 2569 resultado de 'gamma' de um argumento inteiro também. 2570 2571 -- Função: intopois (<a>) 2572 Converte <a> em um código de Poisson. 2573 2574 -- Função: makefact (<expr>) 2575 Transforma instâncias de funções binomiais, gama, e beta em <expr> 2576 para fatoriais. 2577 2578 Veja também 'makegamma'. 2579 2580 -- Função: makegamma (<expr>) 2581 Transforma instâncias de funções binomiais, fatorial, e beta em 2582 <expr> para funções gama. 2583 2584 Veja também 'makefact'. 2585 2586 -- Função: numfactor (<expr>) 2587 Retorna o fator numérico multiplicando a expressão <expr>, que pode 2588 ser um termo simples. 2589 2590 'content' retorna o máximo divisor comum (mdc) de todos os termos 2591 em uma adição. 2592 2593 (%i1) gamma (7/2); 2594 15 sqrt(%pi) 2595 (%o1) ------------ 2596 8 2597 (%i2) numfactor (%); 2598 15 2599 (%o2) -- 2600 8 2601 2602 -- Função: outofpois (<a>) 2603 Converte <a> de um código de Poisson para uma representação geral. 2604 Se <a> não for uma forma de Poisson, 'outofpois' realiza a 2605 conversão, i.e., o valor de retorno é 'outofpois (intopois (<a>))'. 2606 Essa função é desse modo um simplificador canônico para adições e 2607 potências de termos de seno e cosseno de um tipo particular. 2608 2609 -- Função: poisdiff (<a>, <b>) 2610 Deriva <a> em relação a <b>. <b> deve ocorrer somente nos 2611 argumentos trigonométricos ou somente nos coeficientes. 2612 2613 -- Função: poisexpt (<a>, <b>) 2614 Funcionalmente identica a 'intopois (<a>^<b>)'. <b> deve ser um 2615 inteiro positico. 2616 2617 -- Função: poisint (<a>, <b>) 2618 Integra em um senso restrito similarmente (para 'poisdiff'). 2619 Termos não periódicos em <b> são diminuídos se <b> estiver em 2620 argumentos trigonométricos. 2621 2622 -- Variável de opção: poislim 2623 Valor padrão: 5 2624 2625 'poislim' determina o domínio dos coeficientes nos argumentos de 2626 funções trigonométricas. O valor inicial de 5 corresponde ao 2627 intervalo [-2^(5-1)+1,2^(5-1)], ou [-15,16], mas isso pode ser 2628 alterado para [-2^(n-1)+1, 2^(n-1)]. 2629 2630 -- Função: poismap (<series>, <sinfn>, <cosfn>) 2631 mapeará as funções <sinfn> sobre os termos de seno e <cosfn> ssobre 2632 os termos de cosseno das séries de Poisson dadas. <sinfn> e 2633 <cosfn> são funções de dois argumentos que são um coeficiente e uma 2634 parte trigonométrica de um termo em séries respectivamente. 2635 2636 -- Função: poisplus (<a>, <b>) 2637 É funcionalmente identica a 'intopois (a + b)'. 2638 2639 -- Função: poissimp (<a>) 2640 Converte <a> em séries de Poisson para <a> em representação geral. 2641 2642 -- Símbolo especial: poisson 2643 O símbolo '/P/' segue o rótulo de linha de uma expressão contendo 2644 séries de Poisson. 2645 2646 -- Função: poissubst (<a>, <b>, <c>) 2647 Substitue <a> por <b> em <c>. <c> é uma série de Poisson. 2648 2649 (1) Quando <B> é uma variável <u>, <v>, <w>, <x>, <y>, ou <z>, 2650 então <a> deve ser uma expressão linear nessas variáveis (e.g., 2651 '6*u + 4*v'). 2652 2653 (2) Quando <b> for outra que não essas variáveis, então <a> deve 2654 também ser livre dessas variáveis, e alé disso, livre de senos ou 2655 cossenos. 2656 2657 'poissubst (<a>, <b>, <c>, <d>, <n>)' é um tipo especial d 2658 substituição que opera sobre <a> e <b> como no tipo (1) acima, mas 2659 onde <d> é uma série de Poisson, expande 'cos(<d>)' e 'sin(<d>)' 2660 para a ordem <n> como provendo o resultado da substituição '<a> + 2661 <d>' por <b> em <c>. A idéia é que <d> é uma expansão em termos de 2662 um pequeno parâmetro. Por exemplo, 'poissubst (u, v, cos(v), %e, 2663 3)' retorna 'cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)'. 2664 2665 -- Função: poistimes (<a>, <b>) 2666 É funcionalmente idêntica a 'intopois (<a>*<b>)'. 2667 2668 -- Função: poistrim () 2669 é um nome de função reservado que (se o usuário tiver definido uma 2670 função com esse nome) é aplicada durante multiplicação de Poisson. 2671 Isso é uma função predicada de 6 argumentos que são os coeficientes 2672 de <u>, <v>, ..., <z> em um termo. Termos para os quais 'poistrim' 2673 for 'true' (para os coeficientes daquele termo) são eliminados 2674 durante a multiplicação. 2675 2676 -- Função: printpois (<a>) 2677 Mostra uma série de Poisson em um formato legível. Em comum com 2678 'outofpois', essa função converterá <a> em um código de Poisson 2679 primeiro, se necessário. 2680 2681 -- Função: psi [<n>](<x>) 2682 2683 A derivada de 'log (gamma (<x>))' de ordem '<n>+1'. Dessa forma, 2684 'psi[0](<x>)' é a primeira derivada, 'psi[1](<x>)' é a segunda 2685 derivada, etc. 2686 2687 Maxima não sabe como, em geral, calcular um valor numérico de 2688 'psi', mas Maxima pode calcular alguns valores exatos para 2689 argumentos racionais. Muitas variáveis controlam qual intervalo de 2690 argumentos racionais 'psi' irá retornar um valor exato, se 2691 possível. Veja 'maxpsiposint', 'maxpsinegint', 'maxpsifracnum', e 2692 'maxpsifracdenom'. Isto é, <x> deve localizar-se entre 2693 'maxpsinegint' e 'maxpsiposint'. Se o valor absoluto da parte 2694 facionária de <x> for racional e tiver um numerador menor que 2695 'maxpsifracnum' e tiver um denominador menor que 'maxpsifracdenom', 2696 'psi' irá retornar um valor exato. 2697 2698 A função 'bfpsi' no pacote 'bffac' pode calcular valores numéricos. 2699 2700 -- Variável de opção: maxpsiposint 2701 Valor padrão: 20 2702 2703 'maxpsiposint' é o maior valor positivo para o qual 'psi[n](x)' irá 2704 tentar calcular um valor exato. 2705 2706 -- Variável de opção: maxpsinegint 2707 Valor padrão: -10 2708 2709 'maxpsinegint' é o valor mais negativo para o qual 'psi[n](x)' irá 2710 tentar calcular um valor exato. Isto é, se <x> for menor que 2711 'maxnegint', 'psi[n](<x>)' não irá retornar resposta simplificada, 2712 mesmo se isso for possível. 2713 2714 -- Variável de opção: maxpsifracnum 2715 Valor padrão: 6 2716 2717 Tomemos <x> como sendo um número racional menor que a unidade e da 2718 forma 'p/q'. Se 'p' for menor que 'maxpsifracnum', então 2719 'psi[<n>](<x>)' não irá tentar retornar um valor simplificado. 2720 2721 -- Variável de opção: maxpsifracdenom 2722 Valor padrão: 6 2723 2724 Tomemos <x> como sendo um número racional menor que a unidade e da 2725 forma 'p/q'. Se 'q' for maior que 'maxpsifracdenom', então 2726 'psi[<n>](<x>)' não irá tentar retornar um valor simplificado. 2727 2728 -- Function: specint (exp(- s*<t>) * <expr>, <t>) 2729 2730 Calcula a trasformada de Laplace de <expr> com relação à variável 2731 <t>. O integrando <expr> pode conter funções especiais. 2732 2733 Se 'specint' não puder calcular a integral, o valor de retorno pode 2734 coter vários símbolos do Lisp, incluindo 2735 'other-defint-to-follow-negtest', 'other-lt-exponential-to-follow', 2736 'product-of-y-with-nofract-indices', etc.; isso é um erro. 2737 2738 'demo(hypgeo)' mostra muitos exemplos de tansformadas de Laplace 2739 calculados por meio de 'specint'. 2740 2741 Exemplos: 2742 2743 (%i1) assume (p > 0, a > 0); 2744 (%o1) [p > 0, a > 0] 2745 (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t); 2746 sqrt(%pi) 2747 (%o2) ------------ 2748 a 3/2 2749 2 (p + -) 2750 4 2751 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t); 2752 - a/p 2753 sqrt(a) %e 2754 (%o3) --------------- 2755 2 2756 p 2757 2758 2759File: maxima.info, Node: Funções Elípticas, Next: Limites, Prev: Funções Especiais, Up: Top 2760 276117 Funções Elípticas 2762******************** 2763 2764* Menu: 2765 2766* Introdução a Funções Elípticas e Integrais:: 2767* Funções e Variáveis Definidas para Funções Elípticas:: 2768* Funções e Variáveis Definidas para Integrais Elípticas:: 2769 2770 2771File: maxima.info, Node: Introdução a Funções Elípticas e Integrais, Next: Funções e Variáveis Definidas para Funções Elípticas, Up: Top 2772 277317.1 Introdução a Funções Elípticas e Integrais 2774=============================================== 2775 2776Maxima inclui suporte a funções elípticas Jacobianas e a integrais 2777elípticas completas e incompletas. Isso inclui manipulação simbólica 2778dessas funções e avaliação numérica também. Definições dessas funções e 2779muitas de suas propriedades podem ser encontradas em Abramowitz e 2780Stegun, Capítulos 16-17. Tanto quanto possível, usamos as definições e 2781relações dadas aí. 2782 2783 Em particular, todas as funções elípticas e integrais elípticas usam 2784o parâmetro m em lugar de módulo k ou o ângulo modular \alpha. Isso é 2785uma área onde discordamos de Abramowitz e Stegun que usam o ângulo 2786modular para as funções elípticas. As seguintes relações são 2787verdadeiras: m = k^2 e k = \sin(\alpha) 2788 2789 As funções elípticas e integrais elípticas estão primariamente 2790tencionando suportar computação simbólica. Portanto, a maiora das 2791derivadas de funções e integrais são conhecidas. Todavia, se valores em 2792ponto flutuante forem dados, um resultado em ponto flutuante é 2793retornado. 2794 2795 Suporte para a maioria de outras propriedades das funções elípticas e 2796integrais elípticas além das derivadas não foram ainda escritas. 2797 2798 Alguns exemplos de funções elípticas: 2799 2800 (%i1) jacobi_sn (u, m); 2801 (%o1) jacobi_sn(u, m) 2802 (%i2) jacobi_sn (u, 1); 2803 (%o2) tanh(u) 2804 (%i3) jacobi_sn (u, 0); 2805 (%o3) sin(u) 2806 (%i4) diff (jacobi_sn (u, m), u); 2807 (%o4) jacobi_cn(u, m) jacobi_dn(u, m) 2808 (%i5) diff (jacobi_sn (u, m), m); 2809 (%o5) jacobi_cn(u, m) jacobi_dn(u, m) 2810 2811 elliptic_e(asin(jacobi_sn(u, m)), m) 2812 (u - ------------------------------------)/(2 m) 2813 1 - m 2814 2815 2 2816 jacobi_cn (u, m) jacobi_sn(u, m) 2817 + -------------------------------- 2818 2 (1 - m) 2819 2820 Alguns exemplos de integrais elípticas: 2821 2822 (%i1) elliptic_f (phi, m); 2823 (%o1) elliptic_f(phi, m) 2824 (%i2) elliptic_f (phi, 0); 2825 (%o2) phi 2826 (%i3) elliptic_f (phi, 1); 2827 phi %pi 2828 (%o3) log(tan(--- + ---)) 2829 2 4 2830 (%i4) elliptic_e (phi, 1); 2831 (%o4) sin(phi) 2832 (%i5) elliptic_e (phi, 0); 2833 (%o5) phi 2834 (%i6) elliptic_kc (1/2); 2835 1 2836 (%o6) elliptic_kc(-) 2837 2 2838 (%i7) makegamma (%); 2839 2 1 2840 gamma (-) 2841 4 2842 (%o7) ----------- 2843 4 sqrt(%pi) 2844 (%i8) diff (elliptic_f (phi, m), phi); 2845 1 2846 (%o8) --------------------- 2847 2 2848 sqrt(1 - m sin (phi)) 2849 (%i9) diff (elliptic_f (phi, m), m); 2850 elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m) 2851 (%o9) (----------------------------------------------- 2852 m 2853 2854 cos(phi) sin(phi) 2855 - ---------------------)/(2 (1 - m)) 2856 2 2857 sqrt(1 - m sin (phi)) 2858 2859 Suporte a funções elípticas e integrais elípticas foi escrito por 2860Raymond Toy. Foi colocado sob os termos da Licençã Pública Geral (GPL) 2861que governa a distribuição do Maxima. 2862 2863 2864File: maxima.info, Node: Funções e Variáveis Definidas para Funções Elípticas, Next: Funções e Variáveis Definidas para Integrais Elípticas, Prev: Introdução a Funções Elípticas e Integrais, Up: Top 2865 286617.2 Funções e Variáveis Definidas para Funções Elípticas 2867========================================================= 2868 2869 -- Função: jacobi_sn (<u>, <m>) 2870 A Função elíptica Jacobiana sn(u,m). 2871 2872 -- Função: jacobi_cn (<u>, <m>) 2873 A função elíptica Jacobiana cn(u,m). 2874 2875 -- Função: jacobi_dn (<u>, <m>) 2876 A função elíptica Jacobiana dn(u,m). 2877 2878 -- Função: jacobi_ns (<u>, <m>) 2879 A função elíptica Jacobiana ns(u,m) = 1/sn(u,m). 2880 2881 -- Função: jacobi_sc (<u>, <m>) 2882 A função elíptica Jacobiana sc(u,m) = sn(u,m)/cn(u,m). 2883 2884 -- Função: jacobi_sd (<u>, <m>) 2885 A função elíptica Jacobiana sd(u,m) = sn(u,m)/dn(u,m). 2886 2887 -- Função: jacobi_nc (<u>, <m>) 2888 A função elíptica Jacobiana nc(u,m) = 1/cn(u,m). 2889 2890 -- Função: jacobi_cs (<u>, <m>) 2891 A função elíptica Jacobiana cs(u,m) = cn(u,m)/sn(u,m). 2892 2893 -- Função: jacobi_cd (<u>, <m>) 2894 A função elíptica Jacobiana cd(u,m) = cn(u,m)/dn(u,m). 2895 2896 -- Função: jacobi_nd (<u>, <m>) 2897 A função elíptica Jacobiana nc(u,m) = 1/cn(u,m). 2898 2899 -- Função: jacobi_ds (<u>, <m>) 2900 A função elíptica Jacobiana ds(u,m) = dn(u,m)/sn(u,m). 2901 2902 -- Função: jacobi_dc (<u>, <m>) 2903 A função elíptica Jacobiana dc(u,m) = dn(u,m)/cn(u,m). 2904 2905 -- Função: inverse_jacobi_sn (<u>, <m>) 2906 A inversa da função elíptica Jacobiana sn(u,m). 2907 2908 -- Função: inverse_jacobi_cn (<u>, <m>) 2909 A inversa da função elíptica Jacobiana cn(u,m). 2910 2911 -- Função: inverse_jacobi_dn (<u>, <m>) 2912 A inversa da função elíptica Jacobiana dn(u,m). 2913 2914 -- Função: inverse_jacobi_ns (<u>, <m>) 2915 A inversa da função elíptica Jacobiana ns(u,m). 2916 2917 -- Função: inverse_jacobi_sc (<u>, <m>) 2918 A inversa da função elíptica Jacobiana sc(u,m). 2919 2920 -- Função: inverse_jacobi_sd (<u>, <m>) 2921 A inversa da função elíptica Jacobiana sd(u,m). 2922 2923 -- Função: inverse_jacobi_nc (<u>, <m>) 2924 A inversa da função elíptica Jacobiana nc(u,m). 2925 2926 -- Função: inverse_jacobi_cs (<u>, <m>) 2927 A inversa da função elíptica Jacobiana cs(u,m). 2928 2929 -- Função: inverse_jacobi_cd (<u>, <m>) 2930 A inversa da função elíptica Jacobiana cd(u,m). 2931 2932 -- Função: inverse_jacobi_nd (<u>, <m>) 2933 A inversa da função elíptica Jacobiana nc(u,m). 2934 2935 -- Função: inverse_jacobi_ds (<u>, <m>) 2936 A inversa da função elíptica Jacobiana ds(u,m). 2937 2938 -- Função: inverse_jacobi_dc (<u>, <m>) 2939 A inversa da função elíptica Jacobiana dc(u,m). 2940 2941 2942File: maxima.info, Node: Funções e Variáveis Definidas para Integrais Elípticas, Prev: Funções e Variáveis Definidas para Funções Elípticas, Up: Top 2943 294417.3 Funções e Variáveis Definidas para Integrais Elípticas 2945=========================================================== 2946 2947 -- Função: elliptic_f (<phi>, <m>) 2948 A integral elíptica incompleta de primeiro tipo, definida como 2949 2950 integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi) 2951 2952 Veja também *note elliptic_e:: e *note elliptic_kc::. 2953 2954 -- Função: elliptic_e (<phi>, <m>) 2955 A integral elíptica incompleta de segundo tipo, definida como 2956 2957 elliptic_e(u, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi) Veja 2958 também *note elliptic_e:: e *note elliptic_ec::. 2959 2960 -- Função: elliptic_eu (<u>, <m>) 2961 A integral elíptica incompleta de segundo tipo, definida como 2962 integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), 2963 t, 0, tau) 2964 2965 onde tau = sn(u,m) 2966 2967 Isso é relacionado a elliptic_e através de elliptic_eu(u, m) = 2968 elliptic_e(asin(sn(u,m)),m) Veja também *note elliptic_e::. 2969 2970 -- Função: elliptic_pi (<n>, <phi>, <m>) 2971 A integral elíptica incompleta de terceiro tipo, definida como 2972 2973 integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi) 2974 2975 Somente a derivada em relação a phi é conhecida pelo Maxima. 2976 2977 -- Função: elliptic_kc (<m>) 2978 A integral elíptica completa de primeiro tipo, definida como 2979 2980 integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2) 2981 2982 Para certos valores de m, o valor da integral é conhecido em termos 2983 de funções Gamma. Use 'makegamma' para avaliar esse valor. 2984 2985 -- Função: elliptic_ec (<m>) 2986 A integral elíptica completa de sgundo tipo, definida como 2987 2988 integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2) 2989 2990 Para certos valores de m, o valor da integral é conhecido em termos 2991 de funçõesvGamma. Use 'makegamma' para avaliar esse valor. 2992 2993 2994File: maxima.info, Node: Limites, Next: Diferenciação, Prev: Funções Elípticas, Up: Top 2995 299618 Limites 2997********** 2998 2999* Menu: 3000 3001* Funções e Variáveis Definidas para Limites:: 3002 3003 3004File: maxima.info, Node: Funções e Variáveis Definidas para Limites, Prev: Limites, Up: Limites 3005 300618.1 Funções e Variáveis Definidas para Limites 3007=============================================== 3008 3009 -- Variável de Opção: lhospitallim 3010 Valor padrão: 4 3011 3012 'lhospitallim' é o máximo número de vezes que a regra L'Hospital é 3013 usada em 'limit'. Isso evita ciclos infinitos em casos como 'limit 3014 (cot(x)/csc(x), x, 0)'. 3015 3016 -- Função: limit (<expr>, <x>, <val>, <dir>) 3017 -- Função: limit (<expr>, <x>, <val>) 3018 -- Função: limit (<expr>) 3019 Calcula o limite de <expr> com a variável real <x> aproximando-se 3020 do valor <val> pela direção <dir>. <dir> pode ter o valor 'plus' 3021 para um limite pela direita, 'minus' para um limite pela esquerda, 3022 ou pode ser omitido (implicando em um limite em ambos os lados é 3023 para ser computado). 3024 3025 'limit' usa os seguintes símbolos especiais: 'inf' (infinito 3026 positivo) e 'minf' (infinito negativo). Em saídas essa função pode 3027 também usar 'und' (undefined - não definido), 'ind' (indefinido mas 3028 associado) e 'infinity' (infinito complexo). 3029 3030 'lhospitallim' é o máximo número de vezes que a regra L'Hospital é 3031 usada em 'limit'. Isso evita ciclos infinitos em casos como 'limit 3032 (cot(x)/csc(x), x, 0)'. 3033 3034 'tlimswitch' quando 'true' fará o pacote 'limit' usar série de 3035 Taylor quando possível. 3036 3037 'limsubst' evita que 'limit' tente substituições sobre formas 3038 desconhecidas. Isso é para evitar erros como 'limit (f(n)/f(n+1), 3039 n, inf)' dando igual a 1. Escolhendo 'limsubst' para 'true' 3040 permitirá tais substituições. 3041 3042 'limit' com um argumento é muitas vezes chamado em ocasiões para 3043 simplificar expressões de constantes, por exemplo, 'limit (inf-1)'. 3044 3045 'example (limit)' mostra alguns exemplos. 3046 3047 Para saber sobre o método utilizado veja Wang, P., "Evaluation of 3048 Definite Integrals by Symbolic Manipulation", tese de Ph.D., MAC 3049 TR-92, Outubro de 1971. 3050 3051 -- Variável de Opção: limsubst 3052 valor padrão: 'false' - evita que 'limit' tente substituições sobre 3053 formas desconhecidas. Isso é para evitar erros como 'limit 3054 (f(n)/f(n+1), n, inf)' dando igual a 1. Escolhendo 'limsubst' para 3055 'true' permitirá tais substituições. 3056 3057 -- Função: tlimit (<expr>, <x>, <val>, <dir>) 3058 -- Função: tlimit (<expr>, <x>, <val>) 3059 -- Função: tlimit (<expr>) 3060 Retorna 'limit' com 'tlimswitch' escolhido para 'true'. 3061 3062 -- Variável de Opção: tlimswitch 3063 Valor padrão: 'false' 3064 3065 Quando 'tlimswitch' for 'true', fará o pacote 'limit' usar série de 3066 Taylor quando possível. 3067 3068 3069File: maxima.info, Node: Diferenciação, Next: Integração, Prev: Limites, Up: Top 3070 307119 Diferenciação 3072**************** 3073 3074/Differentiation.texi/1.20/Sat Jun 2 00:12:38 2007/-ko/ 3075* Menu: 3076 3077* Funções e Variáveis Definidas para Diferenciação:: 3078 3079 3080File: maxima.info, Node: Funções e Variáveis Definidas para Diferenciação, Prev: Diferenciação, Up: Diferenciação 3081 308219.1 Funções e Variáveis Definidas para Diferenciação 3083===================================================== 3084 3085 -- Função: antid (<expr>, <x>, <u(x)>) 3086 Retorna uma lista de dois elementos, tais que uma antiderivada de 3087 <expr> com relação a <x> pode ser constuída a partir da lista. A 3088 expressão <expr> pode conter uma função desconhecida <u> e suas 3089 derivadas. 3090 3091 Tome <L>, uma lista de dois elementos, como sendo o valor de 3092 retorno de 'antid'. Então '<L>[1] + 'integrate (<L>[2], <x>)' é 3093 uma antiderivada de <expr> com relação a <x>. 3094 3095 Quando 'antid' obtém sucesso inteiramente, o segundo elemento do 3096 valor de retorno é zero. De outra forma, o segundo elemento é não 3097 zero, e o primeiro elemento não zero ou zero. Se 'antid' não pode 3098 fazer nenhum progresso, o primeiro elemento é zero e o segundo não 3099 zero. 3100 3101 'load ("antid")' chama essa função. O pacote 'antid' também define 3102 as funções 'nonzeroandfreeof' e 'linear'. 3103 3104 'antid' está relacionada a 'antidiff' como segue. Tome <L>, uma 3105 lista de dois elementos, que é o valor de retorno de 'antid'. 3106 Então o valor de retorno de 'antidiff' é igual a '<L>[1] + 3107 'integrate (<L>[2], <x>)' onde <x> é a variável de integração. 3108 3109 Exemplos: 3110 3111 (%i1) load ("antid")$ 3112 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); 3113 z(x) d 3114 (%o2) y(x) %e (-- (z(x))) 3115 dx 3116 (%i3) a1: antid (expr, x, z(x)); 3117 z(x) z(x) d 3118 (%o3) [y(x) %e , - %e (-- (y(x)))] 3119 dx 3120 (%i4) a2: antidiff (expr, x, z(x)); 3121 / 3122 z(x) [ z(x) d 3123 (%o4) y(x) %e - I %e (-- (y(x))) dx 3124 ] dx 3125 / 3126 (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); 3127 (%o5) 0 3128 (%i6) antid (expr, x, y(x)); 3129 z(x) d 3130 (%o6) [0, y(x) %e (-- (z(x)))] 3131 dx 3132 (%i7) antidiff (expr, x, y(x)); 3133 / 3134 [ z(x) d 3135 (%o7) I y(x) %e (-- (z(x))) dx 3136 ] dx 3137 / 3138 3139 -- Função: antidiff (<expr>, <x>, <u>(<x>)) 3140 Retorna uma antiderivada de <expr> com relação a <x>. A expressão 3141 <expr> pode conter uma função desconhecida <u> e suas derivadas. 3142 3143 Quando 'antidiff' obtém sucesso inteiramente, a expressão 3144 resultante é livre do sinal de integral (isto é, livre do 3145 substantivo 'integrate'). De outra forma, 'antidiff' retorna uma 3146 expressão que é parcialmente ou inteiramente dentro de um sinal de 3147 um sinal de integral. Se 'antidiff' não pode fazer qualquer 3148 progresso, o valor de retorno é inteiramente dentro de um sinal de 3149 integral. 3150 3151 'load ("antid")' chama essa função. O pacote 'antid' também define 3152 as funções 'nonzeroandfreeof' e 'linear'. 3153 3154 'antidiff' é relacionada a 'antid' como segue. Tome <L>, uma lista 3155 de dois elementos, como sendo o valor de retorno de 'antid'. Então 3156 o valor de retorno de 'antidiff' é igual a '<L>[1] + 'integrate 3157 (<L>[2], <x>)' onde <x> é a variável de integração. 3158 3159 Exemplos: 3160 3161 (%i1) load ("antid")$ 3162 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); 3163 z(x) d 3164 (%o2) y(x) %e (-- (z(x))) 3165 dx 3166 (%i3) a1: antid (expr, x, z(x)); 3167 z(x) z(x) d 3168 (%o3) [y(x) %e , - %e (-- (y(x)))] 3169 dx 3170 (%i4) a2: antidiff (expr, x, z(x)); 3171 / 3172 z(x) [ z(x) d 3173 (%o4) y(x) %e - I %e (-- (y(x))) dx 3174 ] dx 3175 / 3176 (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); 3177 (%o5) 0 3178 (%i6) antid (expr, x, y(x)); 3179 z(x) d 3180 (%o6) [0, y(x) %e (-- (z(x)))] 3181 dx 3182 (%i7) antidiff (expr, x, y(x)); 3183 / 3184 [ z(x) d 3185 (%o7) I y(x) %e (-- (z(x))) dx 3186 ] dx 3187 / 3188 3189 -- propriedade: atomgrad 3190 3191 'atomgrad' é a propriedade do gradiente atômico de uma expressão. 3192 Essa propriedade é atribuída por 'gradef'. 3193 3194 -- Função: atvalue (<expr>, [<x_1> = <a_1>, ..., <x_m> = <a_m>], <c>) 3195 -- Função: atvalue (<expr>, <x_1> = <a_1>, <c>) 3196 Atribui o valor <c> a <expr> no ponto '<x> = <a>'. Tipicamente 3197 valores de extremidade são estabelecidos por esse mecanismo. 3198 3199 <expr> é a função de avaliação, '<f>(<x_1>, ..., <x_m>)', ou uma 3200 derivada, 'diff (<f>(<x_1>, ..., <x_m>), <x_1>, <n_1>, ..., <x_n>, 3201 <n_m>)' na qual os argumentos da função explicitamente aparecem. 3202 <n_i> é a ordem de diferenciação com relação a <x_i>. 3203 3204 O ponto no qual o 'atvalue' é estabelecido é dado pela lista de 3205 equações '[<x_1> = <a_1>, ..., <x_m> = <a_m>]'. Se existe uma 3206 variável simples <x_1>, uma única equação pode ser dada sem ser 3207 contida em uma lista. 3208 3209 'printprops ([<f_1>, <f_2>, ...], atvalue)' mostra os 'atvalues' 3210 das funções '<f_1>, <f_2>, ...' como especificado por chamadas a 3211 'atvalue'. 'printprops (<f>, atvalue)' mostra os 'atvalues' de uma 3212 função <f>. 'printprops (all, atvalue)' mostra os 'atvalue's de 3213 todas as funções para as quais 'atvalue's são definidos. 3214 3215 Os simbolos '@1', '@2', ... representam as variáveis <x_1>, <x_2>, 3216 ... quando 'atvalue's são mostrados. 3217 3218 'atvalue' avalia seus argumentos. 'atvalue' retorna <c>, o 3219 'atvalue'. 3220 3221 Exemplos: 3222 3223 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 3224 2 3225 (%o1) a 3226 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); 3227 (%o2) @2 + 1 3228 (%i3) printprops (all, atvalue); 3229 ! 3230 d ! 3231 --- (f(@1, @2))! = @2 + 1 3232 d@1 ! 3233 !@1 = 0 3234 3235 2 3236 f(0, 1) = a 3237 3238 (%o3) done 3239 (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x); 3240 d d 3241 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) 3242 dx dx 3243 (%i5) at (%, [x = 0, y = 1]); 3244 ! 3245 2 d ! 3246 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) 3247 dx ! 3248 !x = 0, y = 1 3249 3250 -- Função: cartan - 3251 O cálculo exterior de formas diferenciais é uma ferramenta básica 3252 de geometria diferencial desenvolvida por Elie Cartan e tem 3253 importantes aplicações na teoria das equações diferenciais 3254 parciais. O pacote 'cartan' implementa as funções 'ext_diff' e 3255 'lie_diff', juntamente com os operadores '~' (produto da cunha) e 3256 '|' (contração de uma forma com um vetor.) Digite 'demo (tensor)' 3257 para ver uma breve descrição desses comandos juntamente com 3258 exemplos. 3259 3260 'cartan' foi implementado por F.B. Estabrook e H.D. Wahlquist. 3261 3262 -- Função: del (<x>) 3263 'del (<x>)' representa a diferencial da variável x. 3264 3265 'diff' retorna uma expressão contendo 'del' se uma variável 3266 independente não for especificada. Nesse caso, o valor de retorno 3267 é a então chamada "diferencial total". 3268 3269 Exemplos: 3270 3271 (%i1) diff (log (x)); 3272 del(x) 3273 (%o1) ------ 3274 x 3275 (%i2) diff (exp (x*y)); 3276 x y x y 3277 (%o2) x %e del(y) + y %e del(x) 3278 (%i3) diff (x*y*z); 3279 (%o3) x y del(z) + x z del(y) + y z del(x) 3280 3281 -- Função: delta (<t>) 3282 A função Delta de Dirac. 3283 3284 Correntemente somente 'laplace' sabe sobre a função 'delta'. 3285 3286 Exemplo: 3287 3288 (%i1) laplace (delta (t - a) * sin(b*t), t, s); 3289 Is a positive, negative, or zero? 3290 3291 p; 3292 - a s 3293 (%o1) sin(a b) %e 3294 3295 -- Variável: dependencies 3296 Valor padrão: '[]' 3297 3298 'dependencies' é a lista de átomos que possuem dependências 3299 funcionais, atribuídas por 'depends' ou 'gradef'. A lista 3300 'dependencies' é cumulativa: cada chamada a 'depends' ou a 'gradef' 3301 anexa ítens adicionais. 3302 3303 Veja 'depends' e 'gradef'. 3304 3305 -- Função: depends (<f_1>, <x_1>, ..., <f_n>, <x_n>) 3306 Declara dependêcias funcionais entre variáveis para o propósito de 3307 calcular derivadas. Na ausência de dependêcias declaradas, 'diff 3308 (f, x)' retorna zero. Se 'depends (f, x)' for declarada, 'diff (f, 3309 x)' retorna uma derivada simbólica (isto é, um substantivo 'diff'). 3310 3311 Cada argumento <f_1>, <x_1>, etc., pode ser o nome de uma variável 3312 ou array, ou uma lista de nomes. Todo elemento de <f_i> (talvez 3313 apenas um elemento simples) é declarado para depender de todo 3314 elemento de <x_i> (talvez apenas um elemento simples). Se algum 3315 <f_i> for o nome de um array ou contém o nome de um array, todos os 3316 elementos do array dependem de <x_i>. 3317 3318 'diff' reconhece dependências indiretas estabelecidas por 'depends' 3319 e aplica a regra da cadeia nesses casos. 3320 3321 'remove (<f>, dependency)' remove todas as dependências declaradas 3322 para <f>. 3323 3324 'depends' retorna uma lista de dependências estabelecidas. As 3325 dependências são anexadas à variável global 'dependencies'. 3326 'depends' avalia seus argumentos. 3327 3328 'diff' é o único comando Maxima que reconhece dependências 3329 estabelecidas por 'depends'. Outras funções ('integrate', 3330 'laplace', etc.) somente reconhecem dependências explicitamente 3331 representadas por seus argumentos. Por exemplo, 'integrate' não 3332 reconhece a dependência de 'f' sobre 'x' a menos que explicitamente 3333 representada como 'integrate (f(x), x)'. 3334 3335 (%i1) depends ([f, g], x); 3336 (%o1) [f(x), g(x)] 3337 (%i2) depends ([r, s], [u, v, w]); 3338 (%o2) [r(u, v, w), s(u, v, w)] 3339 (%i3) depends (u, t); 3340 (%o3) [u(t)] 3341 (%i4) dependencies; 3342 (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)] 3343 (%i5) diff (r.s, u); 3344 dr ds 3345 (%o5) -- . s + r . -- 3346 du du 3347 3348 (%i6) diff (r.s, t); 3349 dr du ds du 3350 (%o6) -- -- . s + r . -- -- 3351 du dt du dt 3352 3353 (%i7) remove (r, dependency); 3354 (%o7) done 3355 (%i8) diff (r.s, t); 3356 ds du 3357 (%o8) r . -- -- 3358 du dt 3359 3360 -- Variável de opção: derivabbrev 3361 Valor padrão: 'false' 3362 3363 Quando 'derivabbrev' for 'true', derivadas simbólicas (isto é, 3364 substantivos 'diff') são mostradas como subscritos. De outra 3365 forma, derivadas são mostradas na notação de Leibniz 'dy/dx'. 3366 3367 -- Função: derivdegree (<expr>, <y>, <x>) 3368 Retorna o maior grau de uma derivada da variável dependente <y> com 3369 relação à variável independente <x> ocorrendo em <expr>. 3370 3371 Exemplo: 3372 (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2; 3373 3 2 3374 d y d y 2 dy 3375 (%o1) --- + --- + x -- 3376 3 2 dx 3377 dz dx 3378 (%i2) derivdegree (%, y, x); 3379 (%o2) 2 3380 3381 -- Função: derivlist (<var_1>, ..., <var_k>) 3382 Causa somente diferenciações com relação às variáveis indicadas, 3383 dentro do comando 'ev'. 3384 3385 -- Variável de opção: derivsubst 3386 Valor padrão: 'false' 3387 3388 Quando 'derivsubst' for 'true', uma substiruíção não sintática tais 3389 como 'subst (x, 'diff (y, t), 'diff (y, t, 2))' retorna ''diff (x, 3390 t)'. 3391 3392 -- Função: diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>) 3393 -- Função: diff (<expr>, <x>, <n>) 3394 -- Função: diff (<expr>, <x>) 3395 -- Função: diff (<expr>) 3396 Retorna uma derivada ou diferencial de <expr> com relação a alguma 3397 ou todas as variáveis em <expr>. 3398 3399 'diff (<expr>, <x>, <n>)' retorna a <n>'ésima derivada de <expr> 3400 com relação a <x>. 3401 3402 'diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)' retorna a derivada 3403 parcial mista de <expr> com relação a <x_1>, ..., <x_m>. Isso é 3404 equivalente a 'diff (... (diff (<expr>, <x_m>, <n_m>) ...), <x_1>, 3405 <n_1>)'. 3406 3407 'diff (<expr>, <x>)' retorna a primeira derivada de <expr> com 3408 relação a uma variável <x>. 3409 3410 'diff (<expr>)' retorna a diferencial total de <expr>, isto é, a 3411 soma das derivadas de <expr> com relação a cada uma de suas 3412 variáveis vezes a diferencial 'del' de cada variável. Nenhuma 3413 simplificação adicional de 'del' é oferecida. 3414 3415 A forma substantiva de 'diff' é requerida em alguns contextos, tal 3416 como declarando uma equação diferencial. Nesses casos, 'diff' pode 3417 ser colocado apóstrofo (com ''diff') para retornar a forma 3418 substantiva em lugar da realização da diferenciação. 3419 3420 Quando 'derivabbrev' for 'true', derivadas são mostradas como 3421 subscritos. De outra forma, derivadas são mostradas na notação de 3422 Leibniz, 'dy/dx'. 3423 3424 Exemplos: 3425 3426 (%i1) diff (exp (f(x)), x, 2); 3427 2 3428 f(x) d f(x) d 2 3429 (%o1) %e (--- (f(x))) + %e (-- (f(x))) 3430 2 dx 3431 dx 3432 (%i2) derivabbrev: true$ 3433 (%i3) 'integrate (f(x, y), y, g(x), h(x)); 3434 h(x) 3435 / 3436 [ 3437 (%o3) I f(x, y) dy 3438 ] 3439 / 3440 g(x) 3441 (%i4) diff (%, x); 3442 h(x) 3443 / 3444 [ 3445 (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x) 3446 ] x x x 3447 / 3448 g(x) 3449 3450 Para o pacote tensor, as seguintes modificações foram incorporadas: 3451 3452 (1) As derivadas de quaisquer objetos indexados em <expr> terão as 3453 variáveis <x_i> anexadas como argumentos adicionais. Então todos 3454 os índices de derivada serão ordenados. 3455 3456 (2) As variáveis <x_i> podem ser inteiros de 1 até o valor de uma 3457 variável 'dimension' [valor padrão: 4]. Isso fará com que a 3458 diferenciação seja concluída com relação aos <x_i>'ésimos membros 3459 da lista 'coordinates' que pode ser escolhida para uma lista de 3460 nomes de coordenadas, e.g., '[x, y, z, t]'. Se 'coordinates' for 3461 associada a uma variável atômica, então aquela variável subscrita 3462 por <x_i> será usada para uma variável de diferenciação. Isso 3463 permite um array de nomes de coordenadas ou nomes subscritos como 3464 'X[1]', 'X[2]', ... sejam usados. Se 'coordinates' não foram 3465 atribuídas um valor, então as variáveis seram tratadas como em (1) 3466 acima. 3467 3468 -- Símbolo especial: diff 3469 3470 Quando 'diff' está presente como um 'evflag' em chamadas para 'ev', 3471 Todas as diferenciações indicadas em 'expr' são realizdas. 3472 3473 -- Função: dscalar (<f>) 3474 Aplica o d'Alembertiano escalar para a função escalar <f>. 3475 3476 'load ("ctensor")' chama essa função. 3477 3478 -- Função: express (<expr>) 3479 3480 Expande o substantivo do operador diferencial em expressões em 3481 termos de derivadas parciais. 'express' reconhece os operadores 3482 'grad', 'div', 'curl', 'laplacian'. 'express' também expande o 3483 produto do X '~'. 3484 3485 Derivadas simbólicas (isto é, substantivos 'diff') no valor de 3486 retorno de 'express' podem ser avaliadas incluíndo 'diff' na 3487 chamada à função 'ev' ou na linha de comando. Nesse contexto, 3488 'diff' age como uma 'evfun'. 3489 3490 'load ("vect")' chama essa função. 3491 3492 Exemplos: 3493 3494 (%i1) load ("vect")$ 3495 (%i2) grad (x^2 + y^2 + z^2); 3496 2 2 2 3497 (%o2) grad (z + y + x ) 3498 (%i3) express (%); 3499 d 2 2 2 d 2 2 2 d 2 2 2 3500 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )] 3501 dx dy dz 3502 (%i4) ev (%, diff); 3503 (%o4) [2 x, 2 y, 2 z] 3504 (%i5) div ([x^2, y^2, z^2]); 3505 2 2 2 3506 (%o5) div [x , y , z ] 3507 (%i6) express (%); 3508 d 2 d 2 d 2 3509 (%o6) -- (z ) + -- (y ) + -- (x ) 3510 dz dy dx 3511 (%i7) ev (%, diff); 3512 (%o7) 2 z + 2 y + 2 x 3513 (%i8) curl ([x^2, y^2, z^2]); 3514 2 2 2 3515 (%o8) curl [x , y , z ] 3516 (%i9) express (%); 3517 d 2 d 2 d 2 d 2 d 2 d 2 3518 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )] 3519 dy dz dz dx dx dy 3520 (%i10) ev (%, diff); 3521 (%o10) [0, 0, 0] 3522 (%i11) laplacian (x^2 * y^2 * z^2); 3523 2 2 2 3524 (%o11) laplacian (x y z ) 3525 (%i12) express (%); 3526 2 2 2 3527 d 2 2 2 d 2 2 2 d 2 2 2 3528 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z ) 3529 2 2 2 3530 dz dy dx 3531 (%i13) ev (%, diff); 3532 2 2 2 2 2 2 3533 (%o13) 2 y z + 2 x z + 2 x y 3534 (%i14) [a, b, c] ~ [x, y, z]; 3535 (%o14) [a, b, c] ~ [x, y, z] 3536 (%i15) express (%); 3537 (%o15) [b z - c y, c x - a z, a y - b x] 3538 3539 -- Função: gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>) 3540 -- Função: gradef (<a>, <x>, <expr>) 3541 Define as derivadas parciais (i.e., os componentes do gradiente) da 3542 função <f> ou variável <a>. 3543 3544 'gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)' define 3545 'd<f>/d<x_i>' como <g_i>, onde <g_i> é uma expressão; <g_i> pode 3546 ser uma chamada de função, mas não o nome de uma função. O número 3547 de derivadas parciais <m> pode ser menor que o número de argumentos 3548 <n>, nesses casos derivadas são definidas com relação a <x_1> até 3549 <x_m> somente. 3550 3551 'gradef (<a>, <x>, <expr>)' define uma derivada de variável <a> com 3552 relação a <x> como <expr>. Isso também estabelece a dependência de 3553 <a> sobre <x> (via 'depends (<a>, <x>)'). 3554 3555 O primeiro argumento '<f>(<x_1>, ..., <x_n>)' ou <a> é acompanhado 3556 de apóstrofo, mas os argumentos restantes <g_1>, ..., <g_m> são 3557 avaliados. 'gradef' retorna a função ou variável para as quais as 3558 derivadas parciais são definidas. 3559 3560 'gradef' pode redefinir as derivadas de funções internas do Maxima. 3561 Por exemplo, 'gradef (sin(x), sqrt (1 - sin(x)^2))' redefine uma 3562 derivada de 'sin'. 3563 3564 'gradef' não pode definir derivadas parciais para um função 3565 subscrita. 3566 3567 'printprops ([<f_1>, ..., <f_n>], gradef)' mostra as derivadas 3568 parciais das funções <f_1>, ..., <f_n>, como definidas por 3569 'gradef'. 3570 3571 'printprops ([<a_n>, ..., <a_n>], atomgrad)' mostra as derivadas 3572 parciais das variáveis <a_n>, ..., <a_n>, como definidas por 3573 'gradef'. 3574 3575 'gradefs' é a lista de funções para as quais derivadas parciais 3576 foram definidas por 'gradef'. 'gradefs' não inclui quaisquer 3577 variáveis para quais derivadas parciais foram definidas por 3578 'gradef'. 3579 3580 Gradientes são necessários quando, por exemplo, uma função não é 3581 conhecida explicitamente mas suas derivadas primeiras são e isso é 3582 desejado para obter derivadas de ordem superior. 3583 3584 -- Variável de sistema: gradefs 3585 Valor padrão: '[]' 3586 3587 'gradefs' é a lista de funções para as quais derivadas parciais 3588 foram definidas por 'gradef'. 'gradefs' não inclui quaisquer 3589 variáveis para as quais derivadas parciais foram deinidas por 3590 'gradef'. 3591 3592 -- Função: laplace (<expr>, <t>, <s>) 3593 Tenta calcular a transformada de Laplace de <expr> com relação a 3594 uma variável <t> e parâmetro de transformação <s>. Se 'laplace' 3595 não pode achar uma solução, um substantivo ''laplace' é retornado. 3596 3597 'laplace' reconhece em <expr> as funções 'delta', 'exp', 'log', 3598 'sin', 'cos', 'sinh', 'cosh', e 'erf', também 'derivative', 3599 'integrate', 'sum', e 'ilt'. Se algumas outras funções estiverem 3600 presente, 'laplace' pode não ser habilitada a calcular a 3601 tranformada. 3602 3603 <expr> pode também ser uma equação linear, diferencial de 3604 coeficiente contante no qual caso o 'atvalue' da variável 3605 dependente é usado. O requerido 'atvalue' pode ser fornecido ou 3606 antes ou depois da transformada ser calculada. Uma vez que as 3607 condições iniciais devem ser especificadas em zero, se um teve 3608 condições de limite impostas em qualquer outro lugar ele pode impor 3609 essas sobre a solução geral e eliminar as constantes resolvendo a 3610 solução geral para essas e substituindo seus valores de volta. 3611 3612 'laplace' reconhece integrais de convolução da forma 'integrate 3613 (f(x) * g(t - x), x, 0, t)'; outros tipos de convoluções não são 3614 reconhecidos. 3615 3616 Relações funcionais devem ser explicitamente representadas em 3617 <expr>; relações implícitas, estabelecidas por 'depends', não são 3618 reconhecidas. Isto é, se <f> depende de <x> e <y>, 'f (x, y)' deve 3619 aparecer em <expr>. 3620 3621 Veja também 'ilt', a transformada inversa de Laplace. 3622 3623 Exemplos: 3624 3625 (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s); 3626 a 3627 %e (2 s - 4) 3628 (%o1) --------------- 3629 2 2 3630 (s - 4 s + 5) 3631 (%i2) laplace ('diff (f (x), x), x, s); 3632 (%o2) s laplace(f(x), x, s) - f(0) 3633 (%i3) diff (diff (delta (t), t), t); 3634 2 3635 d 3636 (%o3) --- (delta(t)) 3637 2 3638 dt 3639 (%i4) laplace (%, t, s); 3640 ! 3641 d ! 2 3642 (%o4) - -- (delta(t))! + s - delta(0) s 3643 dt ! 3644 !t = 0 3645 3646 3647File: maxima.info, Node: Integração, Next: Equações, Prev: Diferenciação, Up: Top 3648 364920 Integração 3650************* 3651 3652* Menu: 3653 3654* Introdução a Integração:: 3655* Funções e Variáveis Definidas para Integração:: 3656* Introdução a QUADPACK:: 3657* Funções e Variáveis Definidas para QUADPACK:: 3658 3659 3660File: maxima.info, Node: Introdução a Integração, Next: Funções e Variáveis Definidas para Integração, Prev: Integração, Up: Integração 3661 366220.1 Introdução a Integração 3663============================ 3664 3665Maxima tem muitas rotinas para manusear integração. A função 3666'integrate' faz uso de muitas dessas. Exite também o pacote 'antid', 3667que manuseia uma função não especificada (e suas derivadas, certamente). 3668Para usos numericos, existe um conjunto de integradores adaptativos de 3669QUADPACK, a saber 'quad_qag', 'quad_qags', etc., os quais são descritos 3670sob o tópico 'QUADPACK'. Funções hipergeométricas estão sendo 3671trabalhadas, veja 'specint' para detalhes. Geralmente falando, Maxima 3672somente manuseia integrais que são integráveis em termos de "funções 3673elementares" (funções racionais, trigonometricas, logarítmicas, 3674exponenciais, radicais, etc.) e umas poucas extensões (função de erro, 3675dilogarithm). Isso não manuseia integrais em termos de funções 3676desconhecidas tais como 'g(x)' e 'h(x)'. 3677 3678 3679File: maxima.info, Node: Funções e Variáveis Definidas para Integração, Next: Introdução a QUADPACK, Prev: Introdução a Integração, Up: Integração 3680 368120.2 Funções e Variáveis Definidas para Integração 3682================================================== 3683 3684 -- Função: changevar (<expr>, <f(x,y)>, <y>, <x>) 3685 Faz a mudança de variável dada por '<f(x,y)> = 0' em todas as 3686 integrais que ocorrem em <expr> com integração em relação a <x>. A 3687 nova variável é <y>. 3688 3689 (%i1) assume(a > 0)$ 3690 (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4); 3691 4 3692 / 3693 [ sqrt(a) sqrt(y) 3694 (%o2) I %e dy 3695 ] 3696 / 3697 0 3698 (%i3) changevar (%, y-z^2/a, z, y); 3699 0 3700 / 3701 [ abs(z) 3702 2 I z %e dz 3703 ] 3704 / 3705 - 2 sqrt(a) 3706 (%o3) - ---------------------------- 3707 a 3708 3709 Uma expressão contendo uma forma substantiva, tais como as 3710 instâncias de ''integrate' acima, pode ser avaliada por 'ev' com o 3711 sinalizador 'nouns'. Por exemplo, a expressão retornada por 3712 'changevar' acima pode ser avaliada por 'ev (%o3, nouns)'. 3713 3714 'changevar' pode também ser usada para alterações nos índices de 3715 uma soma ou de um produto. Todavia, isso deve obrigatóriamente ser 3716 realizado de forma que quando uma alteração é feita em uma soma ou 3717 produto, essa mudança deve ser um artifício, i.e., 'i = j+ ...', 3718 não uma função de grau mais alto. E.g., 3719 3720 (%i4) sum (a[i]*x^(i-2), i, 0, inf); 3721 inf 3722 ==== 3723 \ i - 2 3724 (%o4) > a x 3725 / i 3726 ==== 3727 i = 0 3728 (%i5) changevar (%, i-2-n, n, i); 3729 inf 3730 ==== 3731 \ n 3732 (%o5) > a x 3733 / n + 2 3734 ==== 3735 n = - 2 3736 3737 -- Função: dblint (<f>, <r>, <s>, <a>, <b>) 3738 Uma rotina de integral dupla que foi escrita no alto-nível do 3739 Maxima e então traduzida e compilada para linguagem de máquina. 3740 Use 'load (dblint)' para acessar esse pacote. Isso usa o método da 3741 regra de Simpson em ambas as direções x e y para calcular 3742 3743 /b /s(x) 3744 | | 3745 | | f(x,y) dy dx 3746 | | 3747 /a /r(x) 3748 3749 A função <f> deve ser uma função traduzida ou compilada de duas 3750 variáveis, e <r> e <s> devem cada uma ser uma função traduzida ou 3751 compilada de uma variável, enquanto <a> e <b> devem ser números em 3752 ponto flutuante. A rotina tem duas variáveis globais que 3753 determinam o número de divisões dos intervalos x e y: 'dblint_x' e 3754 'dblint_y', ambas as quais são inicialmente 10, e podem ser 3755 alteradas independentemente para outros valores inteiros (existem 3756 '2*dblint_x+1' pontos calculados na direção x , e '2*dblint_y+1' na 3757 direção y). A rotina subdivide o eixo X e então para cada valor de 3758 X isso primeiro calcula '<r>(x)' e '<s>(x)'; então o eixo Y entre 3759 '<r>(x)' e '<s>(x)' é subdividido e a integral ao longo do eixo Y é 3760 executada usando a regra de Simpson; então a integral ao longo do 3761 eixo X é concluída usando a regra de Simpson com os valores da 3762 função sendo as integrais-Y. Esse procedimento pode ser 3763 numericamente instável por uma grande variedade razões, mas 3764 razoávelmente rápido: evite usar isso sobre funções altamente 3765 oscilatórias e funções com singularidades (postes ou pontos de 3766 ramificação na região). As integrais Y dependem de quanto 3767 fragmentados '<r>(x)' e '<s>(x)' são, então se a ditância '<s>(x) - 3768 <r>(x)' varia rapidamente com X, nesse ponto pode ter erros 3769 substanciais provenientes de truncação com diferentes 3770 saltos-tamanhos nas várias integrais Y. Um pode incrementar 3771 'dblint_x' e 'dblint_y' em uma tentativa para melhorar a 3772 convergência da reião, com sacrifício do tempo de computação. Os 3773 valores da função não são salvos, então se a função é muito 3774 desperdiçadora de tempo,você terá de esperar por re-computação se 3775 você mudar qualquer coisa (desculpe). Isso é requerido que as 3776 funções <f>, <r>, e <s> sejam ainda traduzidas ou compiladas 3777 previamente chamando 'dblint'. Isso resultará em ordens de 3778 magnitude de melhoramentos de velocidade sobre o código 3779 interpretado em muitos casos! 3780 3781 'demo (dblint)' executa uma demonstração de 'dblint' aplicado a um 3782 problema exemplo. 3783 3784 -- Função: defint (<expr>, <x>, <a>, <b>) 3785 Tenta calcular uma integral definida. 'defint' é chamada por 3786 'integrate' quando limites de integração são especificados, i.e., 3787 quando 'integrate' é chamado como 'integrate (<expr>, <x>, <a>, 3788 <b>)'. Dessa forma do ponto de vista do usuário, isso é suficiente 3789 para chamar 'integrate'. 3790 3791 'defint' retorna uma expressão simbólica, e executa um dos dois: ou 3792 calcula a integral ou a forma substantiva da integral. Veja 3793 'quad_qag' e funções rellacionadas para aproximação numérica de 3794 integrais definidas. 3795 3796 -- Função: erf (<x>) 3797 Representa a função de erro, cuja derivada é: 3798 '2*exp(-x^2)/sqrt(%pi)'. 3799 3800 -- Variável de opção: erfflag 3801 Valor padrão: 'true' 3802 3803 Quando 'erfflag' é 'false', previne 'risch' da introdução da função 3804 'erf' na resposta se não houver nenhum no integrando para começar. 3805 3806 -- Função: ilt (<expr>, <t>, <s>) 3807 Calcula a transformação inversa de Laplace de <expr> em relação a 3808 <t> e parâmetro <s>. <expr> deve ser uma razão de polinômios cujo 3809 denominador tem somente fatores lineares e quadráticos. Usando a 3810 funções 'laplace' e 'ilt' juntas com as funções 'solve' ou 3811 'linsolve' o usuário pode resolver uma diferencial simples ou uma 3812 equação integral de convolução ou um conjunto delas. 3813 3814 (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2; 3815 t 3816 / 3817 [ 2 3818 (%o1) I f(t - x) sinh(a x) dx + b f(t) = t 3819 ] 3820 / 3821 0 3822 (%i2) laplace (%, t, s); 3823 a laplace(f(t), t, s) 2 3824 (%o2) b laplace(f(t), t, s) + --------------------- = -- 3825 2 2 3 3826 s - a s 3827 (%i3) linsolve ([%], ['laplace(f(t), t, s)]); 3828 2 2 3829 2 s - 2 a 3830 (%o3) [laplace(f(t), t, s) = --------------------] 3831 5 2 3 3832 b s + (a - a b) s 3833 (%i4) ilt (rhs (first (%)), s, t); 3834 Is a b (a b - 1) positive, negative, or zero? 3835 3836 pos; 3837 sqrt(a b (a b - 1)) t 3838 2 cosh(---------------------) 2 3839 b a t 3840 (%o4) - ----------------------------- + ------- 3841 3 2 2 a b - 1 3842 a b - 2 a b + a 3843 3844 2 3845 + ------------------ 3846 3 2 2 3847 a b - 2 a b + a 3848 3849 -- Função: integrate (<expr>, <x>) 3850 -- Função: integrate (<expr>, <x>, <a>, <b>) 3851 Tenta símbolicamente calcular a integral de <expr> em relação a 3852 <x>. 'integrate (<expr>, <x>)' é uma integral indefinida, enquanto 3853 'integrate (<expr>, <x>, <a>, <b>)' é uma integral definida, com 3854 limites de integração <a> e <b>. Os limites não poderam conter 3855 <x>, embora 'integrate' não imponha essa restrição. <a> não 3856 precisa ser menor que <b>. Se <b> é igual a <a>, 'integrate' 3857 retorna zero. 3858 3859 Veja 'quad_qag' e funções relacionadas para aproximação numérica de 3860 integrais definidas. Veja 'residue' para computação de resíduos 3861 (integração complexa). Veja 'antid' para uma forma alternativa de 3862 calcular integrais indefinidas. 3863 3864 A integral (uma expressão livre de 'integrate') é retornada se 3865 'integrate' obtém sucesso. De outra forma o valor de retorno é a 3866 forma substantiva da integral (o operador com apóstrofo 3867 ''integrate') ou uma expressão contendo uma ou mais formas 3868 substantivas. A forma substantiva de 'integrate' é mostrada com um 3869 sinal de integral. 3870 3871 Em algumas circunstâncias isso é útil para construir uma forma 3872 substantiva manualmente, colocando em 'integrate' um apóstrofo, 3873 e.g., ''integrate (<expr>, <x>)'. Por exemplo, a integral pode 3874 depender de alguns parâmetos que não estão ainda calculados. A 3875 forma substantiva pode ser aplicada a seus argumentos por 'ev (<i>, 3876 nouns)' onde <i> é a forma substantiva de interesse. 3877 3878 'integrate' manuseia integrais definidas separadamente das 3879 indefinidas, e utiliza uma gama de heurísticas para manusear cada 3880 caso. Casos especiais de integrais definidas incluem limites de 3881 integração iguais a zero ou infinito ('inf' ou 'minf'), funções 3882 trigonométricas com limites de integração iguais a zero e '%pi' ou 3883 '2 %pi', funções racionais, integrais relacionadas para as 3884 definições de funções 'beta' e 'psi', e algumas integrais 3885 logarítmicas e trigonométricas. Processando funções racionais pode 3886 incluir computação de resíduo. Se um caso especial aplicável não é 3887 encontrado, tentativa será feita para calcular a integra indefinida 3888 e avaliar isso nos limites de integração. Isso pode incluir pegar 3889 um limite como um limite de integração tendendo ao infinito ou a 3890 menos infinito; veja também 'ldefint'. 3891 3892 Casos especiais de integrais indefinidas incluem funções 3893 trigonométricas, exponenciais e funções logarítmicas, e funções 3894 racionais. 'integrate' pode também fazer uso de uma curta tabela 3895 de integais elementares. 3896 3897 'integrate' pode realizar uma mudança de variável se o integrando 3898 tem a forma 'f(g(x)) * diff(g(x), x)'. 'integrate' tenta achar uma 3899 subexpressão 'g(x)' de forma que a derivada de 'g(x)' divida o 3900 integrando. Essa busca pode fazer uso de derivadas definidas pela 3901 função 'gradef'. Veja também 'changevar' e 'antid'. 3902 3903 Se nenhum dos procedimentos heurísticos acha uma integral 3904 indefinida, o algorítmo de Risch é executado. O sinalizador 3905 'risch' pode ser escolhido como um 'evflag', na chamada para 'ev' 3906 ou na linha de comando, e.g., 'ev (integrate (<expr>, <x>), risch)' 3907 ou 'integrate (<expr>, <x>), risch'. Se 'risch' está presente, 3908 'integrate' chama a função 'risch' sem tentar heurísticas primeiro. 3909 Veja também 'risch'. 3910 3911 'integrate' trabalha somente com relações funcionais representadas 3912 explicitamente com a notação 'f(x)'. 'integrate' não respeita 3913 dependências implicitas estabelecidas pela função 'depends'. 3914 'integrate' pode necessitar conhecer alguma propriedade de um 3915 parâmetro no integrando. 'integrate' irá primeiro consultar a base 3916 de dados do 'assume', e , se a variável de interesse não está lá, 3917 'integrate' perguntará ao usuário. Dependendo da pergunta, 3918 respostas adequadas são 'yes;' ou 'no;', ou 'pos;', 'zero;', ou 3919 'neg;'. 3920 3921 'integrate' não é, por padrão, declarada ser linear. Veja 3922 'declare' e 'linear'. 3923 3924 'integrate' tenta integração por partes somente em uns poucos casos 3925 especiais. 3926 3927 Exemplos: 3928 3929 * Integrais definidas e indefinidas elementares. 3930 3931 (%i1) integrate (sin(x)^3, x); 3932 3 3933 cos (x) 3934 (%o1) ------- - cos(x) 3935 3 3936 (%i2) integrate (x/ sqrt (b^2 - x^2), x); 3937 2 2 3938 (%o2) - sqrt(b - x ) 3939 (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi); 3940 %pi 3941 3 %e 3 3942 (%o3) ------- - - 3943 5 5 3944 (%i4) integrate (x^2 * exp(-x^2), x, minf, inf); 3945 sqrt(%pi) 3946 (%o4) --------- 3947 2 3948 3949 * Uso de 'assume' e dúvida interativa. 3950 3951 (%i1) assume (a > 1)$ 3952 (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf); 3953 2 a + 2 3954 Is ------- an integer? 3955 5 3956 3957 no; 3958 Is 2 a - 3 positive, negative, or zero? 3959 3960 neg; 3961 3 3962 (%o2) beta(a + 1, - - a) 3963 2 3964 3965 * Mudança de variável. Existem duas mudanças de variável nesse 3966 exemplo: uma usando a derivada estabelecida por 'gradef', e 3967 uma usando a derivação 'diff(r(x))' de uma função não 3968 especificada 'r(x)'. 3969 3970 (%i3) gradef (q(x), sin(x**2)); 3971 (%o3) q(x) 3972 (%i4) diff (log (q (r (x))), x); 3973 d 2 3974 (-- (r(x))) sin(r (x)) 3975 dx 3976 (%o4) ---------------------- 3977 q(r(x)) 3978 (%i5) integrate (%, x); 3979 (%o5) log(q(r(x))) 3980 3981 * O valor de retorno contém a forma substantiva ''integrate'. 3982 Nesse exemplo, Maxima pode extrair um fator do denominador de 3983 uma função racional, mas não pode fatorar o restante ou de 3984 outra forma achar sua integral. 'grind' mostra a forma 3985 substantiva ''integrate' no resultado. Veja também 3986 'integrate_use_rootsof' para mais sobre integrais de funções 3987 racionais. 3988 3989 (%i1) expand ((x-4) * (x^3+2*x+1)); 3990 4 3 2 3991 (%o1) x - 4 x + 2 x - 7 x - 4 3992 (%i2) integrate (1/%, x); 3993 / 2 3994 [ x + 4 x + 18 3995 I ------------- dx 3996 ] 3 3997 log(x - 4) / x + 2 x + 1 3998 (%o2) ---------- - ------------------ 3999 73 73 4000 (%i3) grind (%); 4001 log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$ 4002 4003 * Definindo uma função em termos de uma integral. O corpo de 4004 uma função não é avaliado quando a função é definida. Dessa 4005 forma o corpo de 'f_1' nesse exemplo contém a forma 4006 substantiva de 'integrate'. O operador apóstrofo-apóstrofo 4007 '''' faz com que a integral seja avaliada, e o resultado 4008 transforme-se no corpo de 'f_2'. 4009 4010 (%i1) f_1 (a) := integrate (x^3, x, 1, a); 4011 3 4012 (%o1) f_1(a) := integrate(x , x, 1, a) 4013 (%i2) ev (f_1 (7), nouns); 4014 (%o2) 600 4015 (%i3) /* Note parentheses around integrate(...) here */ 4016 f_2 (a) := ''(integrate (x^3, x, 1, a)); 4017 4 4018 a 1 4019 (%o3) f_2(a) := -- - - 4020 4 4 4021 (%i4) f_2 (7); 4022 (%o4) 600 4023 4024 -- Variável de sistema: integration_constant_counter 4025 Valor padrão: 0 4026 4027 'integração_constant_counter' é um contador que é atualizado a cada 4028 vez que uma constante de integração (nomeada pelo Maxima, e.g., 4029 'integrationconstant1') é introduzida em uma expressão pela 4030 integração indefinida de uma equação. 4031 4032 -- Variável de opção: integrate_use_rootsof 4033 Valor padrão: 'false' 4034 4035 Quando 'integrate_use_rootsof' é 'true' e o denominador de uma 4036 função racional não pode ser fatorado, 'integrate' retorna a 4037 integral em uma forma que é uma soma sobre as raízes (não 4038 conhecidas ainda) do denominador. 4039 4040 Por exemplo, com 'integrate_use_rootsof' escolhido para 'false', 4041 'integrate' retorna uma integral não resolvida de uma função 4042 racional na forma substantiva: 4043 4044 (%i1) integrate_use_rootsof: false$ 4045 (%i2) integrate (1/(1+x+x^5), x); 4046 / 2 4047 [ x - 4 x + 5 4048 I ------------ dx 2 x + 1 4049 ] 3 2 2 5 atan(-------) 4050 / x - x + 1 log(x + x + 1) sqrt(3) 4051 (%o2) ----------------- - --------------- + --------------- 4052 7 14 7 sqrt(3) 4053 4054 Agora vamos escolher o sinalizador para ser true e a parte não 4055 resolvida da integral será expressa como um somatório sobre as 4056 raízes do denominador da função racional: 4057 4058 (%i3) integrate_use_rootsof: true$ 4059 (%i4) integrate (1/(1+x+x^5), x); 4060 ==== 2 4061 \ (%r4 - 4 %r4 + 5) log(x - %r4) 4062 > ------------------------------- 4063 / 2 4064 ==== 3 %r4 - 2 %r4 4065 3 2 4066 %r4 in rootsof(%r4 - %r4 + 1, %r4) 4067 (%o4) ---------------------------------------------------------- 4068 7 4069 4070 2 x + 1 4071 2 5 atan(-------) 4072 log(x + x + 1) sqrt(3) 4073 - --------------- + --------------- 4074 14 7 sqrt(3) 4075 4076 Alternativamente o usuário pode calcular as raízes do denominador 4077 separadamente, e então expressar o integrando em termos dessas 4078 raízes, e.g., '1/((x - a)*(x - b)*(x - c))' ou '1/((x^2 - (a+b)*x + 4079 a*b)*(x - c))' se o denominador for um polinômio cúbico. Algumas 4080 vezes isso ajudará Maxima a obter resultados mais úteis. 4081 4082 -- Função: ldefint (<expr>, <x>, <a>, <b>) 4083 Tenta calcular a integral definida de <expr> pelo uso de 'limit' 4084 para avaliar a integral indefinida <expr> em relação a <x> no 4085 limite superior <b> e no limite inferior <a>. Se isso falha para 4086 calcular a integral definida, 'ldefint' retorna uma expressão 4087 contendo limites como formas substantivas. 4088 4089 'ldefint' não é chamada por 'integrate', então executando 'ldefint 4090 (<expr>, <x>, <a>, <b>)' pode retornar um resultado diferente de 4091 'integrate (<expr>, <x>, <a>, <b>)'. 'ldefint' sempre usa o mesmo 4092 método para avaliar a integral definida, enquanto 'integrate' pode 4093 utilizar várias heurísticas e pode reconhecer alguns casos 4094 especiais. 4095 4096 -- Função: potential (<givengradient>) 4097 O cálculo faz uso da variável global 'potentialzeroloc[0]' que deve 4098 ser 'nonlist' ou da forma 4099 4100 [indeterminatej=expressãoj, indeterminatek=expressãok, ...] 4101 4102 O formador sendo equivalente para a expressão nonlist para todos os 4103 lados direitos-manuseados mais tarde. Os lados direitos indicados 4104 são usados como o limite inferior de integração. O sucesso das 4105 integrações pode depender de seus valores e de sua ordem. 4106 'potentialzeroloc' é inicialmente escolhido para 0. 4107 4108 -- Função: residue (<expr>, <z>, <z_0>) 4109 Calcula o resíduo no plano complexo da expressão <expr> quando a 4110 variável <z> assumes o valor <z_0>. O resíduo é o coeficiente de 4111 '(<z> - <z_0>)^(-1)' nas séries de Laurent para <expr>. 4112 4113 (%i1) residue (s/(s**2+a**2), s, a*%i); 4114 1 4115 (%o1) - 4116 2 4117 (%i2) residue (sin(a*x)/x**4, x, 0); 4118 3 4119 a 4120 (%o2) - -- 4121 6 4122 4123 -- Função: risch (<expr>, <x>) 4124 Integra <expr> em relação a <x> usando um caso transcendental do 4125 algorítmo de Risch. (O caso algébrico do algorítmo de Risch foi 4126 implementado.) Isso atualmente manuseia os casos de exponenciais 4127 aninhadas e logarítmos que a parte principal de 'integrate' não 4128 pode fazer. 'integrate' irá aplicar automaticamente 'risch' se 4129 dados esses casos. 4130 4131 'erfflag', se 'false', previne 'risch' da introdução da função 4132 'erf' na resposta se não for achado nenhum no integrando para 4133 começar. 4134 4135 (%i1) risch (x^2*erf(x), x); 4136 2 4137 3 2 - x 4138 %pi x erf(x) + (sqrt(%pi) x + sqrt(%pi)) %e 4139 (%o1) ------------------------------------------------- 4140 3 %pi 4141 (%i2) diff(%, x), ratsimp; 4142 2 4143 (%o2) x erf(x) 4144 4145 -- Função: tldefint (<expr>, <x>, <a>, <b>) 4146 Equivalente a 'ldefint' com 'tlimswitch' escolhido para 'true'. 4147 4148 4149File: maxima.info, Node: Introdução a QUADPACK, Next: Funções e Variáveis Definidas para QUADPACK, Prev: Funções e Variáveis Definidas para Integração, Up: Integração 4150 415120.3 Introdução a QUADPACK 4152========================== 4153 4154QUADPACK é uma coleção de funções para aálculo numérico de integrais 4155definidas unidimensionais. O pacote QUADPACK resultou da junção de um 4156projeto de R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), e D. 4157Kahaner (4). 4158 4159 A biblioteca QUADPACK inclída no Maxima é uma tradução automática 4160(feita através do programa 'f2cl') do código fonte em de QUADPACK como 4161aparece na SLATEC Common Mathematical Library, Versão 4.1 (5). A 4162biblioteca Fortran SLATEC é datada de Julho de 1993, mas as funções 4163QUADPACK foram escritas alguns anos antes. Existe outra versão de 4164QUADPACK em Netlib (6); não está claro no que aquela versão difere da 4165versão existente em SLATEC. 4166 4167 As funções QUADPACK incluídas no Maxima são toda automáticas, no 4168sentido de que essas funções tentam calcular um resultado para uma 4169precisão específica, requerendo um número não especificado de avaliações 4170de função. A tradução do Lisp do Maxima da iblioteca QUADPACK também 4171inclui algumas funçe~s não automáticas, mas elas não são expostas a 4172nível de Maxima. 4173 4174 Informação adicionalsobre a bilioteca QUADPACK pode ser encontrada no 4175livro do QUADPACK (7). 4176 417720.3.1 Overview 4178--------------- 4179 4180'quad_qag' 4181 Integração de uma função genérica sobre um intervalo finito. 4182 'quad_qag' implementa um integrador adaptativo globalmente simples 4183 usando a estratégia de Aind (Piessens, 1973). O chamador pode 4184 escolher entre 6 pares de formulas da quadratura de Gauss-Kronrod 4185 para a componente de avaliação da regra. As regras de alto grau 4186 são adequadas para integrandos fortemente oscilantes. 4187 4188'quad_qags' 4189 Integração de uma função genérica sob um intervalo finito. 4190 'quad_qags' implementa subdivisão de intervalos globalmente 4191 adaptativos com extrapolação (de Doncker, 1978) por meio do 4192 algorítmo de Epsilon (Wynn, 1956). 4193 4194'quad_qagi' 4195 Integração de uma função genérica sobre um intervalo finito ou 4196 semi-finito. O intervalo é mapeado sobre um intervalo finito e 4197 então a mesma estratégia de 'quad_qags' é aplicada. 4198 4199'quad_qawo' 4200 Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um 4201 intervalo finito, onde omega é uma constante. A componente de 4202 avaliação da regra é baseada na técnica modificada de 4203 Clenshaw-Curtis. 'quad_qawo' aplica subdivisão adaptativa com 4204 extrapolação, similar a 'quad_qags'. 4205 4206'quad_qawf' 4207 Calcula uma transformação de cosseno de Fourier ou de um seno de 4208 Fourier sobre um intervalo semi-finito. O mesmo aproxima como 4209 'quad_qawo' aplicado sobre intervalos finitos sucessivos, e 4210 aceleração de convergência por meio d algorítimo de Epsilon (Wynn, 4211 1956) aplicado a séries de contribuições de integrais. 4212 4213'quad_qaws' 4214 Integraçào de w(x) f(x) sobre um intervalo finito [a, b], onde w é 4215 uma função da forma (x - a)^alpha (b - x)^beta v(x) e v(x) é 1 ou 4216 log(x - a) ou log(b - x) ou log(x - a) log(b - x), e alpha > -1 e 4217 beta > -1. Auma estratégia de subdivisão adaptativa é aplicada, 4218 com integração modificada de Clenshaw-Curtis sobre os subintervalos 4219 que possuem a ou b. 4220 4221'quad_qawc' 4222 Calcula o valor principal de Cauchy de f(x)/(x - c) sobre um 4223 intervalo finito (a, b) e um c especificado. A estratégia é 4224 globalmente adaptativa, e a integração modificada de 4225 Clenshaw-Curtis é usada sobre subamplitudes que possuírem o ponto x 4226 = c. 4227 4228 ---------- Footnotes ---------- 4229 4230 (1) Applied Mathematics and Programming Division, K.U. Leuven 4231 4232 (2) Applied Mathematics and Programming Division, K.U. Leuven 4233 4234 (3) Institut für Mathematik, T.U. Wien 4235 4236 (4) National Bureau of Standards, Washington, D.C., U.S.A 4237 4238 (5) http://www.netlib.org/slatec 4239 4240 (6) http://www.netlib.org/quadpack 4241 4242 (7) R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, e D.K. 4243Kahaner. QUADPACK: A Subroutine Package for Automatic Integration. 4244Berlin: Springer-Verlag, 1983, ISBN 0387125531. 4245 4246 4247File: maxima.info, Node: Funções e Variáveis Definidas para QUADPACK, Prev: Introdução a QUADPACK, Up: Integração 4248 424920.4 Funções e Variáveis Definidas para QUADPACK 4250================================================ 4251 4252 -- Função: quad_qag (<f(x)>, <x>, <a>, <b>, <chave>, <epsrel>, 4253 <limite>) 4254 -- Função: quad_qag (<f>, <x>, <a>, <b>, <chave>, <epsrel>, <limite>) 4255 4256 Integração de uma função genérica sobre um intervalo finito. 4257 'quad_qag' implementa um integrador adaptativo globalmente simples 4258 usando a estratégia de Aind (Piessens, 1973). O chamador pode 4259 escolher entre 6 pares de fórmulas da quadratura de Gauss-Kronrod 4260 para a componente de avaliação da regra. As regras de alto nível 4261 são adequadas para integrandos fortemente oscilatórios. 4262 4263 'quad_qag' calcula a integral 4264 4265 integrate (f(x), x, a, b) 4266 4267 A função a ser integrada é <f(x)>, com variável dependente <x>, e a 4268 função é para ser integrada entre os limites <a> e <b>. <chave> é 4269 o integrador a ser usado e pode ser um inteiro entre 1 e 6, 4270 inclusive. O valor de <chave> seleciona a ordem da regra de 4271 integração de Gauss-Kronrod. Regra de alta ordem são adequadas 4272 para integrandos fortemente oscilatórios. 4273 4274 O integrando pode ser especidficado como o nome de uma função 4275 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4276 Maxima, ou uma expressão geral do Maxima. 4277 4278 A integração numérica é concluída adaptativamente pela subdivisão a 4279 região de integração até que a precisão desejada for completada. 4280 4281 Os argumentos opcionais <epsrel> e <limite> são o erro relativo 4282 desejado e o número máximo de subintervalos respectivamente. 4283 <epsrel> padrão em 1e-8 e <limite> é 200. 4284 4285 'quad_qag' retorna uma lista de quatro elementos: 4286 4287 * uma aproximação para a integral, 4288 * o erro absoluto estimado da aproximação, 4289 * o número de avaliações do integrando, 4290 * um código de erro. 4291 4292 O código de erro (quarto elemento do valor de retorno) pode ter os 4293 valores: 4294 4295 '0' 4296 se nenhum problema for encontrado; 4297 '1' 4298 se muitos subintervalos foram concluídos; 4299 '2' 4300 se erro excessivo é detectado; 4301 '3' 4302 se ocorre comportamento extremamente ruim do integrando; 4303 '6' 4304 se a entrada é inválida. 4305 4306 Exemplos: 4307 4308 (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3); 4309 (%o1) [.4444444444492108, 3.1700968502883E-9, 961, 0] 4310 (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1); 4311 4 4312 (%o2) - 4313 9 4314 4315 -- Função: quad_qags (<f(x)>, <x>, <a>, <b>, <epsrel>, <limite>) 4316 -- Função: quad_qags (<f>, <x>, <a>, <b>, <epsrel>, <limite>) 4317 4318 Integração de uma função geral sobre um intervalo finito. 4319 'quad_qags' implementa subdivisão de intervalo globalmente 4320 adaptativa com extrapolação (de Doncker, 1978) através do algorítmo 4321 de (Wynn, 1956). 4322 4323 'quad_qags' computes the integral 4324 4325 integrate (f(x), x, a, b) 4326 4327 A função a ser integrada é <f(x)>, com variável dependente <x>, e a 4328 função é para ser integrada entre os limites <a> e <b>. 4329 4330 O integrando pode ser especidficado como o nome de uma função 4331 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4332 Maxima, ou uma expressão geral do Maxima. 4333 4334 Os argumentos opcionais <epsrel> e <limite> são o erro relativo 4335 desejado e o número máximo de subintervalos, respectivamente. 4336 <epsrel> padrão em 1e-8 e <limite> é 200. 4337 4338 'quad_qags' retorna uma lista de quatro elementos: 4339 4340 * uma aproximação para a integral, 4341 * o erro absoluto estimado da aproximação, 4342 * o número de avaliações do integrando, 4343 * um código de erro. 4344 4345 O código de erro (quarto elemento do valor de retorno) pode ter os 4346 valores: 4347 4348 '0' 4349 nenhum problema foi encontrado; 4350 '1' 4351 muitos subintervalos foram concluídos; 4352 '2' 4353 erro excessivo é detectado; 4354 '3' 4355 ocorreu comportamento excessivamente ruim do integrando; 4356 '4' 4357 falhou para convergência 4358 '5' 4359 integral é provavelmente divergente ou lentamente convergente 4360 '6' 4361 se a entrada é inválida. 4362 4363 Exemplos: 4364 4365 (%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1); 4366 (%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0] 4367 4368 Note que 'quad_qags' é mais preciso e eficiente que 'quad_qag' para 4369 esse integrando. 4370 4371 -- Função: quad_qagi (<f(x)>, <x>, <a>, <inftype>, <epsrel>, <limite>) 4372 -- Função: quad_qagi (<f>, <x>, <a>, <inftype>, <epsrel>, <limite>) 4373 4374 Integração de uma função genérica sobre um intervalo finito ou 4375 semi-finito. O intervalo é mapeado sobre um intervalo finito e 4376 então a mesma estratégia que em 'quad_qags' é aplicada. 4377 4378 'quad_qagi' avalia uma das seguintes integrais 4379 4380 integrate (f(x), x, minf, inf) 4381 4382 integrate (f(x), x, minf, a) 4383 4384 integrate (f(x), x, a, minf, inf) 4385 4386 usando a rotina Quadpack QAGI. A função a ser integrada é <f(x)>, 4387 com variável dependente <x>, e a função é para ser integrada sobre 4388 um intervalo infinito. 4389 4390 O integrando pode ser especidficado como o nome de uma função 4391 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4392 Maxima, ou uma expressão geral do Maxima. 4393 4394 O parâmetro <inftype> determina o intervalo de integração como 4395 segue: 4396 4397 'inf' 4398 O intervalo vai de <a> ao infinito positivo. 4399 'minf' 4400 O intervalo vai do infinito negativo até <a>. 4401 'both' 4402 O intervalo corresponde a toda reta real. 4403 4404 Os argumentos opcionais <epsrel> e <limite> são o erro relativo 4405 desejado e o número maximo de subintervalos, respectivamente. 4406 <epsrel> padrão para 1e-8 e <limite> é 200. 4407 4408 'quad_qagi' retorna uma lista de quatro elementos: 4409 4410 * uma aproximação para a integral, 4411 * o erro absoluto estimado da aproximação, 4412 * o número de avaliações do integrando, 4413 * um código de erro. 4414 4415 O código de erro (quarto elemento do valor de retorno) pode ter os 4416 valores: 4417 4418 '0' 4419 nenhum problema foi encontrado; 4420 '1' 4421 muitos subintervalos foram concluídos; 4422 '2' 4423 erro excessivo é detectado; 4424 '3' 4425 ocorreu comportamento excessivamente ruim do integrando; 4426 '4' 4427 falhou para convergência; 4428 '5' 4429 integral é provavelmente divergente ou lentamente convergente; 4430 '6' 4431 se a entrada for inválida. 4432 4433 Exemplos: 4434 4435 (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf); 4436 (%o1) [0.03125, 2.95916102995002E-11, 105, 0] 4437 (%i2) integrate (x^2*exp(-4*x), x, 0, inf); 4438 1 4439 (%o2) -- 4440 32 4441 4442 -- Função: quad_qawc (<f(x)>, <x>, <c>, <a>, <b>, <epsrel>, <limite>) 4443 -- Função: quad_qawc (<f>, <x>, <c>, <a>, <b>, <epsrel>, <limite>) 4444 4445 Calcula o valor principal de Cauchy de f(x)/(x - c) over a finite 4446 interval. A estratégia é globalmente adaptativa, e a integração de 4447 Clenshaw-Curtis modificada é usada sobre as subamplitudes que 4448 possuírem o ponto x = c. 4449 4450 'quad_qawc' calcula o valor principal de Cauchy de 4451 4452 integrate (f(x)/(x - c), x, a, b) 4453 4454 usando a rotina Quadpack QAWC. A função a ser integrada é 4455 '<f(x)>/(<x> - <c>)', com variável dependente <x>, e a função é 4456 para ser integrada sobre o intervalo que vai de <a> até <b>. 4457 4458 O integrando pode ser especidficado como o nome de uma função 4459 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4460 Maxima, ou uma expressão geral do Maxima. 4461 4462 Os argumentos opcionais <epsrel> e <limite> são o erro relativo 4463 desejado e o máximo número de subintervalos, respectivamente. 4464 <epsrel> padrão para 1e-8 e <limite> é 200. 4465 4466 'quad_qawc' retorna uma lista de quatro elementos: 4467 4468 * uma aproximação para a integral, 4469 * o erro absoluto estimado da aproximação, 4470 * o número de avaliações do integrando, 4471 * um código de erro. 4472 4473 O código de erro (quarto elemento do valoor de retorno) pode ter os 4474 valores: 4475 4476 '0' 4477 nenhum problema foi encontrado; 4478 '1' 4479 muitos subintervalos foram concluídos; 4480 '2' 4481 erro excessivo é detectado; 4482 '3' 4483 ocorreu comportamento excessivamente ruim do integrando; 4484 '6' 4485 se a entrada é inválida. 4486 4487 Exemplos: 4488 4489 (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5); 4490 (%o1) [- 3.130120337415925, 1.306830140249558E-8, 495, 0] 4491 (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5); 4492 Principal Value 4493 alpha 4494 alpha 9 4 9 4495 4 log(------------- + -------------) 4496 alpha alpha 4497 64 4 + 4 64 4 + 4 4498 (%o2) (----------------------------------------- 4499 alpha 4500 2 4 + 2 4501 4502 3 alpha 3 alpha 4503 ------- ------- 4504 2 alpha/2 2 alpha/2 4505 2 4 atan(4 4 ) 2 4 atan(4 ) alpha 4506 - --------------------------- - -------------------------)/2 4507 alpha alpha 4508 2 4 + 2 2 4 + 2 4509 (%i3) ev (%, alpha=5, numer); 4510 (%o3) - 3.130120337415917 4511 4512 -- Função: quad_qawf (<f(x)>, <x>, <a>, <omega>, <trig>, <epsabs>, 4513 <limit>, <maxp1>, <limlst>) 4514 -- Função: quad_qawf (<f>, <x>, <a>, <omega>, <trig>, <epsabs>, 4515 <limit>, <maxp1>, <limlst>) 4516 4517 Calcula uma transformação de cosseno de Fourier ou de um seno de 4518 Fourier sobre um intervalo semi-finito. usando a função QAWF do 4519 pacote Quadpack. A mesma aproxima como em 'quad_qawo' quando 4520 aplicada sobre intervalos finitos sucessivos, e aceleração de 4521 convergência por meio d algorítimo de Epsilon (Wynn, 1956) aplicado 4522 a séries de contribuições de integrais. 4523 4524 'quad_qawf' calcula a integral 4525 4526 integrate (f(x)*w(x), x, a, inf) 4527 4528 A função peso w é selecionada por <trig>: 4529 4530 'cos' 4531 w(x) = cos (omega x) 4532 'sin' 4533 w(x) = sin (omega x) 4534 4535 O integrando pode ser especidficado como o nome de uma função 4536 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4537 Maxima, ou uma expressão geral do Maxima. 4538 4539 Os argumentos opcionais são: 4540 4541 'epsabs' 4542 Erro absoluto de aproximação desejado. Padrão é 1d-10. 4543 'limit' 4544 Tamanho de array interno de trabalho. (<limit> - <limlst>)/2 4545 é o maximo número de subintervalos para usar. O Padrão é 200. 4546 'maxp1' 4547 O número máximo dos momentos de Chebyshev. Deve ser maior que 4548 0. O padrão é 100. 4549 'limlst' 4550 Limite superior sobre número de ciclos. Deve ser maior ou 4551 igual a 3. O padrão é 10. 4552 4553 <epsabs> e <limit> são o erro relativo desejado e o número maximo 4554 de subintervalos, respectivamente. <epsrel> padrão para 1e-8 e 4555 <limit> é 200. 4556 4557 'quad_qawf' retorna uma lista de quatro elementos: 4558 4559 * uma aproximação para a integral, 4560 * o erro absoluto estimado da aproximação, 4561 * o número de avaliações do integrando, 4562 * um código de erro. 4563 4564 O código de erro (quarto elemento do valor de retorno) pode ter os 4565 valores: 4566 4567 '0' 4568 nenhum problema foi encontrado; 4569 '1' 4570 muitos subintervalos foram concluídos; 4571 '2' 4572 erro excessivo é detectado; 4573 '3' 4574 ocorreu um comportamento excessivamente ruim do integrando; 4575 '6' 4576 se a entrada é invalida. 4577 4578 Exemplos: 4579 4580 (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos); 4581 (%o1) [.6901942235215714, 2.84846300257552E-11, 215, 0] 4582 (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf); 4583 - 1/4 4584 %e sqrt(%pi) 4585 (%o2) ----------------- 4586 2 4587 (%i3) ev (%, numer); 4588 (%o3) .6901942235215714 4589 4590 -- Função: quad_qawo (<f(x)>, <x>, <a>, <b>, <omega>, <trig>, <epsabs>, 4591 <limite>, <maxp1>, <limlst>) 4592 -- Função: quad_qawo (<f>, <x>, <a>, <b>, <omega>, <trig>, <epsabs>, 4593 <limite>, <maxp1>, <limlst>) 4594 4595 Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um 4596 intervalo finito, onde omega é uma constante. A componente de 4597 avaliação da regra é baseada na técnica modificada de 4598 Clenshaw-Curtis. 'quad_qawo' aplica subdivisão adaptativa com 4599 extrapolação, similar a 'quad_qags'. 4600 4601 'quad_qawo' calcula a integral usando a rotina Quadpack QAWO: 4602 4603 integrate (f(x)*w(x), x, a, b) 4604 4605 A função peso w é selecionada por <trig>: 4606 4607 'cos' 4608 w(x) = cos (omega x) 4609 'sin' 4610 w(x) = sin (omega x) 4611 4612 O integrando pode ser especidficado como o nome de uma função 4613 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4614 Maxima, ou uma expressão geral do Maxima. 4615 4616 Os argumentos opcionais são: 4617 4618 'epsabs' 4619 Erro absoluto desejado de aproximação. O Padrão é 1d-10. 4620 'limite' 4621 Tamanho do array interno de trabalho. (<limite> - <limlst>)/2 4622 é o número máximo de subintervalos a serem usados. Default é 4623 200. 4624 'maxp1' 4625 Número máximo dos momentos de Chebyshev. Deve ser maior que 4626 0. O padrão é 100. 4627 'limlst' 4628 Limite superior sobre o número de ciclos. Deve ser maior que 4629 ou igual a 3. O padrão é 10. 4630 4631 <epsabs> e <limite> são o erro relativo desejado e o número máximo 4632 de subintervalos, respectivamente. <epsrel> o padrão é 1e-8 e 4633 <limite> é 200. 4634 4635 'quad_qawo' retorna uma lista de quatro elementos: 4636 4637 * uma aproximação para a integral, 4638 * o erro absoluto estimado da aproximação, 4639 * o número de avaliações do integrando, 4640 * um código de erro. 4641 4642 O código de erro (quarto elemento do valor de retorno) pode ter os 4643 valores: 4644 4645 '0' 4646 nenhum problema foi encontrado; 4647 '1' 4648 muitos subintervalos foram concluídos; 4649 '2' 4650 erro excessivo é detectado; 4651 '3' 4652 comportamento extremamente ruim do integrando; 4653 '6' 4654 se a entrada é inválida. 4655 4656 Exemplos: 4657 4658 (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos); 4659 (%o1) [1.376043389877692, 4.72710759424899E-11, 765, 0] 4660 (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf)); 4661 alpha/2 - 1/2 2 alpha 4662 sqrt(%pi) 2 sqrt(sqrt(2 + 1) + 1) 4663 (%o2) ----------------------------------------------------- 4664 2 alpha 4665 sqrt(2 + 1) 4666 (%i3) ev (%, alpha=2, numer); 4667 (%o3) 1.376043390090716 4668 4669 -- Função: quad_qaws (<f(x)>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, 4670 <epsabs>, <limite>) 4671 -- Função: quad_qaws (<f>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, 4672 <epsabs>, <limite>) 4673 4674 Integração de w(x) f(x) sobre um intervalo finito, onde w(x) é uma 4675 certa função algébrica ou logarítmica. Uma estratégia de 4676 subdivisão globalmente adaptativa é aplicada, com integração 4677 modificada de Clenshaw-Curtis sobre os subintervalos que possuírem 4678 os pontos finais dos intervalos de integração. 4679 4680 'quad_qaws' calcula a integral usando a rotina Quadpack QAWS: 4681 4682 integrate (f(x)*w(x), x, a, b) 4683 4684 A função peso w é selecionada por <wfun>: 4685 4686 '1' 4687 w(x) = (x - a)^alpha (b - x)^beta 4688 '2' 4689 w(x) = (x - a)^alpha (b - x)^beta log(x - a) 4690 '3' 4691 w(x) = (x - a)^alpha (b - x)^beta log(b - x) 4692 '4' 4693 w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x) 4694 4695 O integrando pode ser especidficado como o nome de uma função 4696 Maxima ou uma função Lisp ou um operador, uma expressão lambda do 4697 Maxima, ou uma expressão geral do Maxima. 4698 4699 O argumentos opcionais são: 4700 4701 'epsabs' 4702 Erro absoluto desejado de aproximação. O padrão é 1d-10. 4703 'limite' 4704 Tamanho do array interno de trabalho. (<limite> - <limlst>)/2 4705 é o número máximo de subintervalos para usar. O padrão é 200. 4706 4707 <epsabs> e <limit> são o erro relativo desejado e o número máximo 4708 de subintervalos, respectivamente. <epsrel> o padrão é 1e-8 e 4709 <limite> é 200. 4710 4711 'quad_qaws' retorna uma lista de quatro elementos: 4712 4713 * uma aproximação para a integral, 4714 * o erro absoluto estimado da aproximação, 4715 * o número de avaliações do integrando, 4716 * um código de erro. 4717 4718 O código de erro (quarto elemento do valor de retorno) pode ter os 4719 valores: 4720 4721 '0' 4722 nenhum problema foi encontrado; 4723 '1' 4724 muitos subintervalos foram concluídos; 4725 '2' 4726 erro excessivo é detectado; 4727 '3' 4728 ocorreu um comportamento excessivamente ruim do integrando; 4729 '6' 4730 se a entrada é invalida. 4731 4732 Exemplos: 4733 4734 (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1); 4735 (%o1) [8.750097361672832, 1.24321522715422E-10, 170, 0] 4736 (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1); 4737 alpha 4738 Is 4 2 - 1 positive, negative, or zero? 4739 4740 pos; 4741 alpha alpha 4742 2 %pi 2 sqrt(2 2 + 1) 4743 (%o2) ------------------------------- 4744 alpha 4745 4 2 + 2 4746 (%i3) ev (%, alpha=4, numer); 4747 (%o3) 8.750097361672829 4748 4749 4750File: maxima.info, Node: Equações, Next: Equações Diferenciais, Prev: Integração, Up: Top 4751 475221 Equações 4753*********** 4754 4755* Menu: 4756 4757* Funções e Variáveis Definidas para Equações:: 4758 4759 4760File: maxima.info, Node: Funções e Variáveis Definidas para Equações, Prev: Equações, Up: Equações 4761 476221.1 Funções e Variáveis Definidas para Equações 4763================================================ 4764 4765 -- Variável: %rnum_list 4766 Valor padrão: '[]' 4767 4768 '%rnum_list' é a lista de variáveis introduzidas em soluções por 4769 'algsys'. '%r' variáveis São adicionadas a '%rnum_list' na ordem 4770 em que forem criadas. Isso é conveniente para fazer substituições 4771 dentro da solução mais tarde. É recomendado usar essa lista em 4772 lugar de fazer 'concat ('%r, j)'. 4773 4774 -- Variável: algexact 4775 Valor padrão: 'false' 4776 4777 'algexact' afeta o comportamento de 'algsys' como segue: 4778 4779 Se 'algexact' é 'true', 'algsys' sempre chama 'solve' e então usa 4780 'realroots' sobre falhas de 'solve'. 4781 4782 Se 'algexact' é 'false', 'solve' é chamada somente se o eliminante 4783 não for de uma variável, ou se for uma quadrática ou uma 4784 biquadrada. 4785 4786 Dessa forma 'algexact: true' não garante somente soluções exatas, 4787 apenas que 'algsys' tentará primeiro pegar soluções exatas, e 4788 somente retorna aproximações quando tudo mais falha. 4789 4790 -- Função: algsys ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>]) 4791 -- Função: algsys ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>]) 4792 Resolve polinômios simultâneos <expr_1>, ..., <expr_m> ou equações 4793 polinômiais <eqn_1>, ..., <eqn_m> para as variáveis <x_1>, ..., 4794 <x_n>. Uma expressão <expr> é equivalente a uma equação '<expr> = 4795 0'. Pode existir mais equações que variáveis ou vice-versa. 4796 4797 'algsys' retorna uma lista de soluções, com cada solução dada com 4798 uma lista de valores de estado das equações das variáveis <x_1>, 4799 ..., <x_n> que satisfazem o sistema de equações. Se 'algsys' não 4800 pode achar uma solução, uma lista vazia '[]' é retornada. 4801 4802 Os símbolos '%r1', '%r2', ..., são introduzidos tantos quantos 4803 forem necessários para representar parâmetros arbitrários na 4804 solução; essas variáveis são também anexadas à lista '%rnum_list'. 4805 4806 O método usado é o seguinte: 4807 4808 (1) Primeiro as equações são fatoradas e quebradas em subsistemas. 4809 4810 (2) Para cada subsistema <S_i>, uma equação <E> e uma variável <x> 4811 são selecionados. A variável é escolhida para ter o menor grau não 4812 zero. Então a resultante de <E> e <E_j> em relação a <x> é 4813 calculada para cada um das equações restantes <E_j> nos subsistemas 4814 <S_i>. Isso retorna um novo subsistema <S_i'> em umas poucas 4815 variáveis, como <x> tenha sido eliminada. O processo agora retorna 4816 ao passo (1). 4817 4818 (3) Eventualmente, um subsistema consistindo de uma equação simples 4819 é obtido. Se a equação é de várias variáveis e aproximações na 4820 forma de números em ponto flutuante nã tenham sido introduzidas, 4821 então 'solve' é chamada para achar uma solução exata. 4822 4823 Em alguns casos, 'solve' não está habilitada a achar uma solução, 4824 ou se isso é feito a solução pode ser uma expressão expressão muito 4825 larga. 4826 4827 Se a equação é de uma única variável e é ou linear, ou quadrática, 4828 ou biquadrada, então novamente 'solve' é chamada se aproximações 4829 não tiverem sido introduzidas. Se aproximações tiverem sido 4830 introduzidas ou a equação não é de uma única variável e nem tão 4831 pouco linear, quadratica, ou biquadrada, então o comutador 4832 'realonly' é 'true', A função 'realroots' é chamada para achar o 4833 valor real das soluções. Se 'realonly' é 'false', então 'allroots' 4834 é chamada a qual procura por soluções reais e complexas. 4835 4836 Se 'algsys' produz uma solução que tem poucos digitos 4837 significativos que o requerido, o usuário pode escolher o valor de 4838 'algepsilon' para um valor maior. 4839 4840 Se 'algexact' é escolhido para 'true', 'solve' será sempre chamada. 4841 4842 (4) Finalmente, as soluções obtidas no passo (3) são substituídas 4843 dentro dos níveis prévios e o processo de solução retorna para (1). 4844 4845 Quando 'algsys' encontrar uma equação de várias variáveis que 4846 contém aproximações em ponto flutuante (usualmente devido a suas 4847 falhas em achar soluções exatas por um estágio mais fácil), então 4848 não tentará aplicar métodos exatos para tais equações e em lugar 4849 disso imprime a mensagem: "'algsys' cannot solve - system too 4850 complicated." 4851 4852 Interações com 'radcan' podem produzir expressões largas ou 4853 complicadas. Naquele caso, pode ser possível isolar partes do 4854 resultado com 'pickapart' ou 'reveal'. 4855 4856 Ocasionalmente, 'radcan' pode introduzir uma unidade imaginária 4857 '%i' dentro de uma solução que é atualmente avaliada como real. 4858 4859 Exemplos: 4860 4861 ++ 4862 (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2; 4863 (%o1) 2 (1 - a1) x - 2 a2 (x - 1) 4864 (%i2) e2: a2 - a1; 4865 (%o2) a2 - a1 4866 (%i3) e3: a1*(-y - x^2 + 1); 4867 2 4868 (%o3) a1 (- y - x + 1) 4869 (%i4) e4: a2*(y - (x - 1)^2); 4870 2 4871 (%o4) a2 (y - (x - 1) ) 4872 (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]); 4873 (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0], 4874 4875 [x = 1, y = 0, a1 = 1, a2 = 1]] 4876 (%i6) e1: x^2 - y^2; 4877 2 2 4878 (%o6) x - y 4879 (%i7) e2: -1 - y + 2*y^2 - x + x^2; 4880 2 2 4881 (%o7) 2 y - y + x - x - 1 4882 (%i8) algsys ([e1, e2], [x, y]); 4883 1 1 4884 (%o8) [[x = - -------, y = -------], 4885 sqrt(3) sqrt(3) 4886 4887 1 1 1 1 4888 [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]] 4889 sqrt(3) sqrt(3) 3 3 4890 4891 -- Função: allroots (<expr>) 4892 -- Função: allroots (<eqn>) 4893 Calcula aproximações numéricas de raízes reais e complexas do 4894 polinômio <expr> ou equação polinômial <eqn> de uma variável. 4895 4896 O sinalizador 'polyfactor' quando 'true' faz com que 'allroots' 4897 fatore o polinômio sobre os números reais se o polinômio for real, 4898 ou sobre os números complexos, se o polinômio for complexo. 4899 4900 'allroots' pode retornar resultados imprecisos no caso de multiplas 4901 raízes. Se o polinômio for real, 'allroots (%i*<p>)') pode 4902 retornar aproximações mais precisas que 'allroots (<p>)', como 4903 'allroots' invoca um algorítmo diferente naquele caso. 4904 4905 'allroots' rejeita não-polinômios. Isso requer que o numerador 4906 após a classificação ('rat''ing) poderá ser um polinômio, e isso 4907 requer que o denominador seja quando muito um número complexo. Com 4908 um resultado disso 'allroots' irá sempre retornar uma expressão 4909 equivalente (mas fatorada), se 'polyfactor' for 'true'. 4910 4911 Para polinômios complexos um algorítmo por Jenkins e Traub é usado 4912 (Algorithm 419, Comm. ACM, vol. 15, (1972), p. 97). Para 4913 polinômios reais o algorítmo usado é devido a Jenkins (Algorithm 4914 493, ACM TOMS, vol. 1, (1975), p.178). 4915 4916 Exemplos: 4917 4918 (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5); 4919 3 5 4920 (%o1) (2 x + 1) = 13.5 (x + 1) 4921 (%i2) soln: allroots (eqn); 4922 (%o2) [x = .8296749902129361, x = - 1.015755543828121, 4923 4924 x = .9659625152196369 %i - .4069597231924075, 4925 4926 x = - .9659625152196369 %i - .4069597231924075, x = 1.0] 4927 (%i3) for e in soln 4928 do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2)))); 4929 - 3.5527136788005E-15 4930 4931 - 5.32907051820075E-15 4932 4933 4.44089209850063E-15 %i - 4.88498130835069E-15 4934 4935 - 4.44089209850063E-15 %i - 4.88498130835069E-15 4936 4937 3.5527136788005E-15 4938 4939 (%o3) done 4940 (%i4) polyfactor: true$ 4941 (%i5) allroots (eqn); 4942 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361) 4943 4944 2 4945 (x + 1.015755543828121) (x + .8139194463848151 x 4946 4947 + 1.098699797110288) 4948 4949 -- Variável: backsubst 4950 Valor padrão: 'true' 4951 4952 Quando 'backsubst' é 'false', evita substituições em expressões 4953 anteriores após as equações terem sido triangularizadas. Isso pode 4954 ser de grande ajuda em problemas muito grandes onde substituição em 4955 expressões anteriores pode vir a causar a geração de expressões 4956 extremamente largas. 4957 4958 -- Variável: breakup 4959 Valor padrão: 'true' 4960 4961 Quando 'breakup' é 'true', 'solve' expressa soluções de equações 4962 cúbicas e quárticas em termos de subexpressões comuns, que são 4963 atribuídas a rótulos de expressões intermediárias ('%t1', '%t2', 4964 etc.). De outra forma, subexpressões comuns não são identificadas. 4965 4966 'breakup: true' tem efeito somente quando 'programmode' é 'false'. 4967 4968 Exemplos: 4969 4970 (%i1) programmode: false$ 4971 (%i2) breakup: true$ 4972 (%i3) solve (x^3 + x^2 - 1); 4973 4974 sqrt(23) 25 1/3 4975 (%t3) (--------- + --) 4976 6 sqrt(3) 54 4977 Solution: 4978 4979 sqrt(3) %i 1 4980 ---------- - - 4981 sqrt(3) %i 1 2 2 1 4982 (%t4) x = (- ---------- - -) %t3 + -------------- - - 4983 2 2 9 %t3 3 4984 4985 sqrt(3) %i 1 4986 - ---------- - - 4987 sqrt(3) %i 1 2 2 1 4988 (%t5) x = (---------- - -) %t3 + ---------------- - - 4989 2 2 9 %t3 3 4990 4991 1 1 4992 (%t6) x = %t3 + ----- - - 4993 9 %t3 3 4994 (%o6) [%t4, %t5, %t6] 4995 (%i6) breakup: false$ 4996 (%i7) solve (x^3 + x^2 - 1); 4997 Solution: 4998 4999 sqrt(3) %i 1 5000 ---------- - - 5001 2 2 sqrt(23) 25 1/3 5002 (%t7) x = --------------------- + (--------- + --) 5003 sqrt(23) 25 1/3 6 sqrt(3) 54 5004 9 (--------- + --) 5005 6 sqrt(3) 54 5006 5007 sqrt(3) %i 1 1 5008 (- ---------- - -) - - 5009 2 2 3 5010 5011 sqrt(23) 25 1/3 sqrt(3) %i 1 5012 (%t8) x = (--------- + --) (---------- - -) 5013 6 sqrt(3) 54 2 2 5014 5015 sqrt(3) %i 1 5016 - ---------- - - 5017 2 2 1 5018 + --------------------- - - 5019 sqrt(23) 25 1/3 3 5020 9 (--------- + --) 5021 6 sqrt(3) 54 5022 5023 sqrt(23) 25 1/3 1 1 5024 (%t9) x = (--------- + --) + --------------------- - - 5025 6 sqrt(3) 54 sqrt(23) 25 1/3 3 5026 9 (--------- + --) 5027 6 sqrt(3) 54 5028 (%o9) [%t7, %t8, %t9] 5029 5030 -- Função: dimension (<eqn>) 5031 -- Função: dimension (<eqn_1>, ..., <eqn_n>) 5032 'dimen' é um pacote de análise dimensional. 'load ("dimen")' chama 5033 esse pacote. 'demo ("dimen")' mostra uma cura demostração. 5034 5035 -- Variável: dispflag 5036 Valor padrão: 'true' 5037 5038 Se escolhida para 'false' dentro de um 'block' inibirá a 5039 visualização da saída gerada pelas funções solve chamadas de dentro 5040 de 'block'. Terminando 'block' com um sinal de dolar, $, escolhe 5041 'dispflag' para 'false'. 5042 5043 -- Função: funcsolve (<eqn>, <g>(<t>)) 5044 Retorna '[<g>(<t>) = ...]' ou '[]', dependendo de existir ou não 5045 uma função racional '<g>(<t>)' satisfazendo <eqn>, que deve ser de 5046 primeira ordem, polinômio linear em (para esse caso) '<g>(<t>)' e 5047 '<g>(<t>+1)' 5048 5049 (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) = (n - 1)/(n + 2); 5050 (n + 3) f(n + 1) n - 1 5051 (%o1) (n + 1) f(n) - ---------------- = ----- 5052 n + 1 n + 2 5053 (%i2) funcsolve (eqn, f(n)); 5054 5055 Equações dependentes eliminadas: (4 3) 5056 n 5057 (%o2) f(n) = --------------- 5058 (n + 1) (n + 2) 5059 5060 Atenção: essa é uma implementação muito rudimentar - muitas 5061 verificações de segurança e obviamente generalizações estão 5062 ausêntes. 5063 5064 -- Variável: globalsolve 5065 Valor padrão: 'false' 5066 5067 When 'globalsolve' for 'true', variáveis para as quais as equações 5068 são resolvidas são atribuidas aos valores da solução encontrados 5069 por 'linsolve', e por 'solve' quando resolvendo duas ou mais 5070 equações lineares. 5071 5072 Quando 'globalsolve' for 'false', soluções encontradas por 5073 'linsolve' e por 'solve' quando resolvendo duas ou mais equações 5074 lineares são espressas como equações, e as variáveis para as quais 5075 a equação foi resolvida não são atribuidas. 5076 5077 Quando resolvendo qualquer coisa outra que não duas equações 5078 lineares ou mais, 'solve' ignora 'globalsolve'. Outras funções que 5079 resolvem equações (e.g., 'algsys') sempre ignoram 'globalsolve'. 5080 5081 Exemplos: 5082 5083 (%i1) globalsolve: true$ 5084 (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]); 5085 Solution 5086 5087 17 5088 (%t2) x : -- 5089 7 5090 5091 1 5092 (%t3) y : - - 5093 7 5094 (%o3) [[%t2, %t3]] 5095 (%i3) x; 5096 17 5097 (%o3) -- 5098 7 5099 (%i4) y; 5100 1 5101 (%o4) - - 5102 7 5103 (%i5) globalsolve: false$ 5104 (%i6) kill (x, y)$ 5105 (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]); 5106 Solution 5107 5108 17 5109 (%t7) x = -- 5110 7 5111 5112 1 5113 (%t8) y = - - 5114 7 5115 (%o8) [[%t7, %t8]] 5116 (%i8) x; 5117 (%o8) x 5118 (%i9) y; 5119 (%o9) y 5120 5121 -- Função: ieqn (<ie>, <unk>, <tech>, <n>, <guess>) 5122 'inteqn' é um pacote para resolver equações com integrais. 'load 5123 ("inteqn")' carrega esse pacote. 5124 5125 <ie> é a equação integral; <unk> é a função desconhecida; <tech> é 5126 a técnica a ser tentada nesses dados acima (<tech> = 'first' 5127 significa: tente a primeira técnica que achar uma solução; <tech> = 5128 'all' significa: tente todas a técnicas aplicáveis); <n> é o número 5129 máximo de termos a serem usados de 'taylor', 'neumann', 5130 'firstkindseries', ou 'fredseries' (isso é também o número máximo 5131 de ciclos de recurssão para o método de diferenciação); <guess> é o 5132 inicial suposto para 'neumann' ou 'firstkindseries'. 5133 5134 Valores padrão do segundo até o quinto parâmetro são: 5135 5136 <unk>: '<p>(<x>)', onde <p> é a primeira função encontrada em um 5137 integrando que é desconhecida para Maxima e <x> é a variável que 5138 ocorre como um argumento para a primeira ocorrência de <p> achada 5139 fora de uma integral no caso de equações 'secondkind' , ou é 5140 somente outra variável ao lado da variável de integração em 5141 equações 'firstkind'. Se uma tentativa de procurar por <x> falha, 5142 o usuário será perguntado para suprir a variável independente. 5143 5144 tech: 'first' 5145 5146 n: 1 5147 5148 guess: 'none' o que fará com que 'neumann' e 'firstkindseries' use 5149 '<f>(<x>)' como uma suposição inicial. 5150 5151 -- Variável de opção: ieqnprint 5152 Valor padrão: 'true' 5153 5154 'ieqnprint' governa o comportamento do resultado retornado pelo 5155 comando 'ieqn'. Quando 'ieqnprint' é 'false', as listas retornadas 5156 pela função 'ieqn' são da forma 5157 5158 [<solução>, <tecnica usada>, <nterms>, <sinalizador>] 5159 5160 onde <sinalizador> é retirado se a solução for exata. 5161 5162 De outra forma, isso é a palavra 'approximate' ou 'incomplete' 5163 correspondendo à forma inexata ou forma aberta de solução, 5164 respectivamente. Se um método de série foi usado, <nterms> fornece 5165 o número de termos usados (que poderá ser menor que os n dados para 5166 'ieqn' se ocorrer um erro evita a geração de termos adicionais). 5167 5168 -- Função: lhs (<expr>) 5169 Retorna o lado esquerdo (isto é, o primeiro argumento) da expressão 5170 <expr>, quando o operador de <expr> for um dos operadores 5171 relacionais '< <= = # equal notequal >= >', um dos operadores de 5172 atribuição ':= ::= : ::', ou um operadro infixo definido pelo 5173 usuário, como declarado por meio de 'infix'. 5174 5175 Quando <expr> for um átomo ou seu operador for alguma coisa que não 5176 esses listados acima, 'lhs' retorna <expr>. 5177 5178 Veja também 'rhs'. 5179 5180 Exemplos: 5181 5182 (%i1) e: aa + bb = cc; 5183 (%o1) bb + aa = cc 5184 (%i2) lhs (e); 5185 (%o2) bb + aa 5186 (%i3) rhs (e); 5187 (%o3) cc 5188 (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb), lhs (aa > bb)]; 5189 (%o4) [aa, aa, aa, aa] 5190 (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), lhs (notequal (aa, bb))]; 5191 (%o5) [aa, aa, aa, aa] 5192 (%i6) e1: '(foo(x) := 2*x); 5193 (%o6) foo(x) := 2 x 5194 (%i7) e2: '(bar(y) ::= 3*y); 5195 (%o7) bar(y) ::= 3 y 5196 (%i8) e3: '(x : y); 5197 (%o8) x : y 5198 (%i9) e4: '(x :: y); 5199 (%o9) x :: y 5200 (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)]; 5201 (%o10) [foo(x), bar(y), x, x] 5202 (%i11) infix ("]["); 5203 (%o11) ][ 5204 (%i12) lhs (aa ][ bb); 5205 (%o12) aa 5206 5207 -- Função: linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>]) 5208 Resolve a lista de equações lineares simultâneas para a lista de 5209 variáveis. As expressões devem ser cada uma polinômios nas 5210 variáveis e podem ser equações. 5211 5212 Quando 'globalsolve' é 'true' então variáveis que foram resolvidas 5213 serão escolhidas para a solução do conjunto de equações 5214 simultâneas. 5215 5216 Quando 'backsubst' é 'false', 'linsolve' não realiza substituição 5217 em equações anteriores após as equações terem sido 5218 triangularizadas. Isso pode ser necessário em problemas muito 5219 grandes onde substituição em equações anteriores poderá causar a 5220 geração de expressões extremamente largas. 5221 5222 Quando 'linsolve_params' for 'true', 'linsolve' também gera 5223 símbolos '%r' usados para representar parâmetros arbitrários 5224 descritos no manual sob 'algsys'. De outra forma, 'linsolve' 5225 resolve um menor-determinado sistema de equações com algumas 5226 variáveis expressas em termos de outras. 5227 5228 Quando 'programmode' for 'false', 'linsolve' mostra a solução com 5229 expressões intermediárias com rótulos ('%t'), e retorna a lista de 5230 rótulos. 5231 5232 (%i1) e1: x + z = y; 5233 (%o1) z + x = y 5234 (%i2) e2: 2*a*x - y = 2*a^2; 5235 2 5236 (%o2) 2 a x - y = 2 a 5237 (%i3) e3: y - 2*z = 2; 5238 (%o3) y - 2 z = 2 5239 (%i4) [globalsolve: false, programmode: true]; 5240 (%o4) [false, true] 5241 (%i5) linsolve ([e1, e2, e3], [x, y, z]); 5242 (%o5) [x = a + 1, y = 2 a, z = a - 1] 5243 (%i6) [globalsolve: false, programmode: false]; 5244 (%o6) [false, false] 5245 (%i7) linsolve ([e1, e2, e3], [x, y, z]); 5246 Solution 5247 5248 (%t7) z = a - 1 5249 5250 (%t8) y = 2 a 5251 5252 (%t9) x = a + 1 5253 (%o9) [%t7, %t8, %t9] 5254 (%i9) ''%; 5255 (%o9) [z = a - 1, y = 2 a, x = a + 1] 5256 (%i10) [globalsolve: true, programmode: false]; 5257 (%o10) [true, false] 5258 (%i11) linsolve ([e1, e2, e3], [x, y, z]); 5259 Solution 5260 5261 (%t11) z : a - 1 5262 5263 (%t12) y : 2 a 5264 5265 (%t13) x : a + 1 5266 (%o13) [%t11, %t12, %t13] 5267 (%i13) ''%; 5268 (%o13) [z : a - 1, y : 2 a, x : a + 1] 5269 (%i14) [x, y, z]; 5270 (%o14) [a + 1, 2 a, a - 1] 5271 (%i15) [globalsolve: true, programmode: true]; 5272 (%o15) [true, true] 5273 (%i16) linsolve ([e1, e2, e3], '[x, y, z]); 5274 (%o16) [x : a + 1, y : 2 a, z : a - 1] 5275 (%i17) [x, y, z]; 5276 (%o17) [a + 1, 2 a, a - 1] 5277 5278 -- Variável: linsolvewarn 5279 Valor padrão: 'true' 5280 5281 Quando 'linsolvewarn' é 'true', 'linsolve' imprime uma mensagem 5282 "Dependent equações eliminated". 5283 5284 -- Variável: linsolve_params 5285 Valor padrão: 'true' 5286 5287 Quando 'linsolve_params' é 'true', 'linsolve' também gera os 5288 símbolos '%r' usados para representar parâmetros arbitrários 5289 descritos no manual sob 'algsys'. De outra forma, 'linsolve' 5290 resolve um menor-determinado sistema de equações com algumas 5291 variáveis expressas em termos e outras. 5292 5293 -- Variável: multiplicities 5294 Valor padrão: 'not_set_yet' 5295 5296 'multiplicities' é escolhida para uma lista de multiplicidades das 5297 soluções individuais retornadas por 'solve' ou 'realroots'. 5298 5299 -- Função: nroots (<p>, <low>, <high>) 5300 Retorna o número de raízes reais do polinômio real de uma única 5301 variável <p> no intervalo semi-aberto '(<low>, <high>]'. Uma 5302 extremidade do intervalo podem ser 'minf' ou 'inf'. infinito e 5303 mais infinito. 5304 5305 'nroots' usa o método das sequüências de Sturm. 5306 5307 (%i1) p: x^10 - 2*x^4 + 1/2$ 5308 (%i2) nroots (p, -6, 9.1); 5309 (%o2) 4 5310 5311 -- Função: nthroot (<p>, <n>) 5312 Onde p é um polinômio com coeficientes inteiros e n é um inteiro 5313 positivo retorna q, um polinômio sobre os inteiros, tal que q^n=p 5314 ou imprime uma mensagem de erro indicando que p não é uma potência 5315 n-ésima perfeita. Essa rotina é mais rápida que 'factor' ou mesmo 5316 'sqfr'. 5317 5318 -- Variável: programmode 5319 Valor padrão: 'true' 5320 5321 Quando 'programmode' é 'true', 'solve', 'realroots', 'allroots', e 5322 'linsolve' retornam soluções como elementos em uma lista. (Exceto 5323 quando 'backsubst' é escolhido para 'false', nesse caso 5324 'programmode: false' é assumido.) 5325 5326 Quando 'programmode' é 'false', 'solve', etc. cria rótulos de 5327 expressões intermediárias '%t1', 't2', etc., e atribui as soluções 5328 para eles. 5329 5330 -- Variável: realonly 5331 Valor padrão: 'false' 5332 5333 Quando 'realonly' é 'true', 'algsys' retorna somente aquelas 5334 soluções que estão livres de '%i'. 5335 5336 -- Função: realroots (<expr>, <bound>) 5337 -- Função: realroots (<eqn>, <bound>) 5338 -- Função: realroots (<expr>) 5339 -- Função: realroots (<eqn>) 5340 Calcula aproximações racionais das raízes reais da expressão 5341 polinomial <expr> ou da equação polinomial <eqn> de uma variável, 5342 dentro de uma tolerância de <bound>. coeficientes de <expr> ou de 5343 <eqn> devem ser números literais; constantes símbolo tais como 5344 '%pi' são rejeitadas. 5345 5346 'realroots' atribui as multiplicidades das raízes que encontrar 5347 para a variável global 'multiplicities'. 5348 5349 'realroots' constrói uma seqüência de Sturm para delimitar cada 5350 raíz, e então palica a bisecção para redefinir as aproximações. 5351 Todos os coeficientes são convertidos para os equivalentes 5352 racionais antes da busca por raízes, e cálculos são realizados por 5353 meio de aritmética racional exata. Mesmo se alguns coeficientes 5354 forem números em ponto flutuante, os resultados são racionais (a 5355 menos que forçados a números em ponto flutuante por 'float' ou por 5356 'numer' flags). 5357 5358 Quando <bound> for menor que 1, todas as raízes inteiras são 5359 encontradas exatamente. Quando <bound> não for especificado, será 5360 assumido como sendo igual à variável globa 'rootsepsilon'. 5361 5362 Quando a varável global 'programmode' for 'true', 'realroots' 5363 retorna uma lista da forma '[x = <x_1>, x = <x_2>, ...]'. Quando 5364 'programmode' for 'false', 'realroots' cria rótulos de expressões 5365 intermediárias '%t1', '%t2', ..., atribui os resultados a eles, e 5366 retorna a lista de rótulos. 5367 5368 Exemplos: 5369 5370 (%i1) realroots (-1 - x + x^5, 5e-6); 5371 612003 5372 (%o1) [x = ------] 5373 524288 5374 (%i2) ev (%[1], float); 5375 (%o2) x = 1.167303085327148 5376 (%i3) ev (-1 - x + x^5, %); 5377 (%o3) - 7.396496210176905E-6 5378 5379 (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20); 5380 (%o1) [x = 1, x = 2, x = 3] 5381 (%i2) multiplicities; 5382 (%o2) [5, 3, 1] 5383 5384 -- Função: rhs (<expr>) 5385 Retorna o lado direito (isto é, o segundo argumento) da expressão 5386 <expr>, quando o operador de <expr> for um dos operadores 5387 relacionais '< <= = # equal notequal >= >', um dos operadores de 5388 atribuição ':= ::= : ::', ou um operador binário infixo definido 5389 pelo usuário, como declarado por meio de 'infix'. 5390 5391 Quando <expr> for um étomo ou seu operadro for alguma coisa que não 5392 esses listados acima, 'rhs' retorna 0. 5393 5394 Veja também 'lhs'. 5395 5396 Exemplos: 5397 5398 (%i1) e: aa + bb = cc; 5399 (%o1) bb + aa = cc 5400 (%i2) lhs (e); 5401 (%o2) bb + aa 5402 (%i3) rhs (e); 5403 (%o3) cc 5404 (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb), rhs (aa > bb)]; 5405 (%o4) [bb, bb, bb, bb] 5406 (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), rhs (notequal (aa, bb))]; 5407 (%o5) [bb, bb, bb, bb] 5408 (%i6) e1: '(foo(x) := 2*x); 5409 (%o6) foo(x) := 2 x 5410 (%i7) e2: '(bar(y) ::= 3*y); 5411 (%o7) bar(y) ::= 3 y 5412 (%i8) e3: '(x : y); 5413 (%o8) x : y 5414 (%i9) e4: '(x :: y); 5415 (%o9) x :: y 5416 (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)]; 5417 (%o10) [2 x, 3 y, y, y] 5418 (%i11) infix ("]["); 5419 (%o11) ][ 5420 (%i12) rhs (aa ][ bb); 5421 (%o12) bb 5422 5423 -- Variável de opção: rootsconmode 5424 Valor padrão: 'true' 5425 5426 'rootsconmode' governa o comportamento do comando 'rootscontract'. 5427 Veja 'rootscontract' para detalhes. 5428 5429 -- Função: rootscontract (<expr>) 5430 Converte produtos de raízes em raízes de produtos. Por exemplo, 5431 'rootscontract (sqrt(x)*y^(3/2))' retorna 'sqrt(x*y^3)'. 5432 5433 Quando 'radexpand' é 'true' e 'domain' é 'real', 'rootscontract' 5434 converte 'abs' em 'sqrt', e.g., 'rootscontract (abs(x)*sqrt(y))' 5435 retorna 'sqrt(x^2*y)'. 5436 5437 Existe uma opção 'rootsconmode' afetando 'rootscontract' como 5438 segue: 5439 5440 Problem Value of Result of applying 5441 rootsconmode rootscontract 5442 5443 x^(1/2)*y^(3/2) false (x*y^3)^(1/2) 5444 x^(1/2)*y^(1/4) false x^(1/2)*y^(1/4) 5445 x^(1/2)*y^(1/4) true (x*y^(1/2))^(1/2) 5446 x^(1/2)*y^(1/3) true x^(1/2)*y^(1/3) 5447 x^(1/2)*y^(1/4) all (x^2*y)^(1/4) 5448 x^(1/2)*y^(1/3) all (x^3*y^2)^(1/6) 5449 5450 Quando 'rootsconmode' é 'false', 'rootscontract' contrai somente 5451 como relação a expoentes de número racional cujos denominadores são 5452 os mesmos. A chave para os exemplos 'rootsconmode: true' é 5453 simplesmente que 2 divides 4 mas não divide 3. 'rootsconmode: all' 5454 envolve pegar o menor multiplo comum dos denominadores dos 5455 expoentes. 5456 5457 'rootscontract' usa 'ratsimp' em uma maneira similar a 5458 'logcontract'. 5459 5460 Exemplos: 5461 5462 (%i1) rootsconmode: false$ 5463 (%i2) rootscontract (x^(1/2)*y^(3/2)); 5464 3 5465 (%o2) sqrt(x y ) 5466 (%i3) rootscontract (x^(1/2)*y^(1/4)); 5467 1/4 5468 (%o3) sqrt(x) y 5469 (%i4) rootsconmode: true$ 5470 (%i5) rootscontract (x^(1/2)*y^(1/4)); 5471 (%o5) sqrt(x sqrt(y)) 5472 (%i6) rootscontract (x^(1/2)*y^(1/3)); 5473 1/3 5474 (%o6) sqrt(x) y 5475 (%i7) rootsconmode: all$ 5476 (%i8) rootscontract (x^(1/2)*y^(1/4)); 5477 2 1/4 5478 (%o8) (x y) 5479 (%i9) rootscontract (x^(1/2)*y^(1/3)); 5480 3 2 1/6 5481 (%o9) (x y ) 5482 (%i10) rootsconmode: false$ 5483 (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x)) 5484 *sqrt(sqrt(1 + x) - sqrt(x))); 5485 (%o11) 1 5486 (%i12) rootsconmode: true$ 5487 (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5))); 5488 (%o13) 0 5489 5490 -- Variável de opção: rootsepsilon 5491 Valor padrão: 1.0e-7 5492 5493 'rootsepsilon' é a tolerância que estabelece o intervalo de 5494 conficência para as raízes achadas pela função 'realroots'. 5495 5496 -- Função: solve (<expr>, <x>) 5497 -- Função: solve (<expr>) 5498 -- Função: solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>]) 5499 Resolve a equação algébrica <expr> para a variável <x> e retorna 5500 uma lista de equações solução em <x>. Se <expr> não é uma equação, 5501 a equação '<expr> = 0' é assumida em seu lugar. <x> pode ser uma 5502 função (e.g. 'f(x)'), ou outra expressão não atômica exceto uma 5503 adição ou um produto. <x> pode ser omitido se <expr> contém 5504 somente uma variável. <expr> pode ser uma expressão racional, e 5505 pode conter funções trigonométricas, exponenciais, etc. 5506 5507 O seguinte método é usado: 5508 5509 Tome <E> sendo a expressão e <X> sendo a variável. Se <E> é linear 5510 em <X> então isso é trivialmente resolvido para <X>. De outra 5511 forma se <E> é da forma 'A*X^N + B' então o resultado é 5512 '(-B/A)^1/N)' vezes as 'N''ésimas raízes da unidade. 5513 5514 Se <E> não é linear em <X> então o máximo divisor comum (mdc) dos 5515 expoentes de <X> em <E> (digamos <N>) é dividido dentro dos 5516 expoentes e a multiplicidade das raízes é multiplicada por <N>. 5517 Então 'solve' é chamada novamente sobre o resultado. Se <E> for 5518 dada em fatores então 'solve' é chamada sobre cada um dos fatores. 5519 Finalmente 'solve' usará as fórmulas quadráticas, cúbicas, ou 5520 quárticas onde necessário. 5521 5522 No caso onde <E> for um polinômio em alguma função de variável a 5523 ser resolvida, digamos 'F(X)', então isso é primeiro resolvida para 5524 'F(X)' (chama o resultado <C>), então a equação 'F(X)=C' pode ser 5525 resolvida para <X> fornecendo o inverso da função <F> que é 5526 conhecida. 5527 5528 'breakup' se 'false' fará com que 'solve' expresse as soluções de 5529 equações cúbicas ou quárticas como expressões simples ao invés de 5530 como feito em cima de várias subexpressões comuns que é o padrão. 5531 5532 'multiplicities' - será escolhido para uma lista de multiplicidades 5533 de soluções individuais retornadas por 'solve', 'realroots', ou 5534 'allroots'. Tente 'apropos (solve)' para os comutadores que afetam 5535 'solve'. 'describe' pode então ser usada sobre o nome do comutador 5536 individual se seu proprósito não é claro. 5537 5538 'solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])' resolve um 5539 sistema de equações polinomiais (lineares ou não-lineares) 5540 simultâneas por chamada a 'linsolve' ou 'algsys' e retorna uma 5541 lista de listas solução nas variáveis. No caso de 'linsolve' essa 5542 lista conterá uma lista simples de soluções. Isso pega duas listas 5543 como argumentos. A primeira lista representa as equações a serem 5544 resolvidas; a segunda lista é a lista de desconhecidos a ser 5545 determinada. Se o número total de variáveis nas equações é igual 5546 ao número de equações, a segunda lista-argumento pode ser omitida. 5547 Para sistemas lineares se as dadas equações não são compatíveis, a 5548 mensagem 'inconsistent' será mostrada (veja o comutador 5549 'solve_inconsistent_error' ); se não existe solução única, então 5550 'singular' será mostrado. 5551 5552 Quando 'programmode' for 'false', 'solve' mostra soluções com 5553 rótulos de expressões intermediárias ('%t'), e retorna a lista de 5554 rótulos. 5555 5556 Quando 'globalsolve' for 'true' e o problema for resolver duas ou 5557 mais equações lineares, cada variável para a qual a equação for 5558 resolvida é associada a seu valor na solução das equações. 5559 5560 Exemplos: 5561 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x); 5562 5563 SOLVE is using arc-trig functions to get a solution. 5564 Some solutions will be lost. 5565 %pi 5566 (%o1) [x = ---, f(x) = 1] 5567 6 5568 (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan); 5569 log(125) 5570 (%o2) [f(x) = --------] 5571 log(5) 5572 (%i3) [4*x^2 - y^2 = 12, x*y - x = 2]; 5573 2 2 5574 (%o3) [4 x - y = 12, x y - x = 2] 5575 (%i4) solve (%, [x, y]); 5576 (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i 5577 5578 - .1331240357358706, y = .0767837852378778 5579 5580 - 3.608003221870287 %i], [x = - .5202594388652008 %i 5581 5582 - .1331240357358706, y = 3.608003221870287 %i 5583 5584 + .0767837852378778], [x = - 1.733751846381093, 5585 5586 y = - .1535675710019696]] 5587 (%i5) solve (1 + a*x + x^3, x); 5588 3 5589 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3 5590 (%o5) [x = (- ---------- - -) (--------------- - -) 5591 2 2 6 sqrt(3) 2 5592 5593 sqrt(3) %i 1 5594 (---------- - -) a 5595 2 2 5596 - --------------------------, x = 5597 3 5598 sqrt(4 a + 27) 1 1/3 5599 3 (--------------- - -) 5600 6 sqrt(3) 2 5601 5602 3 5603 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3 5604 (---------- - -) (--------------- - -) 5605 2 2 6 sqrt(3) 2 5606 5607 sqrt(3) %i 1 5608 (- ---------- - -) a 5609 2 2 5610 - --------------------------, x = 5611 3 5612 sqrt(4 a + 27) 1 1/3 5613 3 (--------------- - -) 5614 6 sqrt(3) 2 5615 5616 3 5617 sqrt(4 a + 27) 1 1/3 a 5618 (--------------- - -) - --------------------------] 5619 6 sqrt(3) 2 3 5620 sqrt(4 a + 27) 1 1/3 5621 3 (--------------- - -) 5622 6 sqrt(3) 2 5623 (%i6) solve (x^3 - 1); 5624 sqrt(3) %i - 1 sqrt(3) %i + 1 5625 (%o6) [x = --------------, x = - --------------, x = 1] 5626 2 2 5627 (%i7) solve (x^6 - 1); 5628 sqrt(3) %i + 1 sqrt(3) %i - 1 5629 (%o7) [x = --------------, x = --------------, x = - 1, 5630 2 2 5631 5632 sqrt(3) %i + 1 sqrt(3) %i - 1 5633 x = - --------------, x = - --------------, x = 1] 5634 2 2 5635 (%i8) ev (x^6 - 1, %[1]); 5636 6 5637 (sqrt(3) %i + 1) 5638 (%o8) ----------------- - 1 5639 64 5640 (%i9) expand (%); 5641 (%o9) 0 5642 (%i10) x^2 - 1; 5643 2 5644 (%o10) x - 1 5645 (%i11) solve (%, x); 5646 (%o11) [x = - 1, x = 1] 5647 (%i12) ev (%th(2), %[1]); 5648 (%o12) 0 5649 5650 -- Variável de opção: solvedecomposes 5651 Valor padrão: 'true' 5652 5653 Quando 'solvedecomposes' é 'true', 'solve' chama 'polydecomp' se 5654 perguntado para resolver polinômios. 5655 5656 -- Variável de opção: solveexplicit 5657 Valor padrão: 'false' 5658 5659 Quando 'solveexplicit' é 'true', inibe 'solve' de retornar soluções 5660 implícitas, isto é, soluções da forma 'F(x) = 0' onde 'F' é alguma 5661 função. 5662 5663 -- Variável de opção: solvefactors 5664 Valor padrão: 'true' 5665 5666 Quando 'solvefactors' é 'false', 'solve' não tenta fatorar a 5667 expressão. O 'false' escolhido pode ser desejado em alguns casos 5668 onde a fatoração não é necessária. 5669 5670 -- Variável de opção: solvenullwarn 5671 Valor padrão: 'true' 5672 5673 Quando 'solvenullwarn' é 'true', 'solve' imprime uma mensagem de 5674 alerta se chamada com ou uma lista equação ou uma variável lista 5675 nula. Por exemplo, 'solve ([], [])' imprimirá duas mensagens de 5676 alerta e retorna '[]'. 5677 5678 -- Variável de opção: solveradcan 5679 Valor padrão: 'false' 5680 5681 Quando 'solveradcan' é 'true', 'solve' chama 'radcan' que faz 5682 'solve' lento mas permitirá certamente que problemas contendo 5683 exponeniais e logarítmos sejam resolvidos. 5684 5685 -- Variável de opção: solvetrigwarn 5686 Valor padrão: 'true' 5687 5688 Quando 'solvetrigwarn' é 'true', 'solve' pode imprimir uma mensagem 5689 dizendo que está usando funções trigonométricas inversas para 5690 resolver a equação, e desse modo perdendo soluções. 5691 5692 -- Variável de opção: solve_inconsistent_error 5693 Valor padrão: 'true' 5694 5695 Quando 'solve_inconsistent_error' for 'true', 'solve' e 'linsolve' 5696 resultam em erro se as equações a serem resolvidas forem 5697 inconsistentes. 5698 5699 Se 'false', 'solve' e 'linsolve' retornam uma lista vazia '[]' se 5700 as equações forem inconsistentes. 5701 5702 Exemplo: 5703 5704 (%i1) solve_inconsistent_error: true$ 5705 (%i2) solve ([a + b = 1, a + b = 2], [a, b]); 5706 Inconsistent equações: (2) 5707 -- an error. Quitting. To debug this try debugmode(true); 5708 (%i3) solve_inconsistent_error: false$ 5709 (%i4) solve ([a + b = 1, a + b = 2], [a, b]); 5710 (%o4) [] 5711 5712 5713File: maxima.info, Node: Equações Diferenciais, Next: Numérico, Prev: Equações, Up: Top 5714 571522 Equações Diferenciais 5716************************ 5717 5718* Menu: 5719 5720* Introdução a Equações Diferenciais:: 5721* Funções e Variáveis Definidas para Equações Diferenciais:: 5722Definições para Equações Diferenciais 5723 5724 5725File: maxima.info, Node: Introdução a Equações Diferenciais, Next: Funções e Variáveis Definidas para Equações Diferenciais, Prev: Equações Diferenciais, Up: Equações Diferenciais 5726 572722.1 Introdução a Equações Diferenciais 5728======================================= 5729 5730Essa seção descreve as funções disponíves no Maxima para obter soluções 5731analíticas para alguns tipos específicos de equações diferencias de 5732primeira ordem e de equações diferencias de segunda ordem. Para obter 5733uma solução numérica para um sistema de equações diferenciais, veja o 5734pacote adicional 'dynamics'. Para representações gráficas em espaço de 5735fase, veja o pacote adicional 'plotdf'. 5736 5737 5738File: maxima.info, Node: Funções e Variáveis Definidas para Equações Diferenciais, Prev: Introdução a Equações Diferenciais, Up: Equações Diferenciais 5739 574022.2 Funções e Variáveis Definidas para Equações Diferenciais 5741============================================================= 5742 5743 -- Função: bc2 (<solução>, <xval1>, <yval1>, <xval2>, <yval2>) 5744 Resolve o problema do valor limite para equações diferenciais de 5745 segunda ordem. Aqui: <solução> é uma solução geral para a equação, 5746 como encontrado por 'ode2', <xval1> especifica o valor da variável 5747 independente em um primeiro ponto, na forma '<x> = <x1>', e <yval1> 5748 fornece o valor da variável dependente naquele ponto, na forma '<y> 5749 = <y1>'. As expressões <xval2> e <yval2> fornecem os valores para 5750 essas variáveis em um segundo ponto, usando a mesma forma. 5751 5752 Veja 'ode2' para um exemplo de sua utilização. 5753 5754 -- Função: desolve (<eqn>, <x>) 5755 -- Função: desolve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>]) 5756 A Função 'dsolve' resolve sistema de equações diferenciais lineares 5757 ordinárias usando a transformada de Laplace. Aqui as <eqn>'s são 5758 equações diferenciais nas variáveis dependentes <x_1>, ..., <x_n>. 5759 A dependência funcional de <x_1>, ..., <x_n> com relação à variável 5760 independente, por exemplo <x>, deve ser explicitamente indicada nas 5761 variáveis e em suas derivadas. Por exemplo, isso pode não ser 5762 caminho correto para definir duas equações: 5763 5764 eqn_1: 'diff(f,x,2) = sin(x) + 'diff(g,x); 5765 eqn_2: 'diff(f,x) + x^2 - f = 2*'diff(g,x,2); 5766 5767 O caminho correto pode ser: 5768 5769 eqn_1: 'diff(f(x),x,2) = sin(x) + 'diff(g(x),x); 5770 eqn_2: 'diff(f(x),x) + x^2 - f(x) = 2*'diff(g(x),x,2); 5771 5772 A chamada à função 'desolve' pode então ser 5773 desolve([eqn_1, eqn_2], [f(x),g(x)]); 5774 5775 Se condições iniciais em 'x=0' forem conhecidas, elas podem ser 5776 fornecidas antes chamando 'desolve' através de 'atvalue'. 5777 5778 (%i1) 'diff(f(x),x)='diff(g(x),x)+sin(x); 5779 d d 5780 (%o1) -- (f(x)) = -- (g(x)) + sin(x) 5781 dx dx 5782 (%i2) 'diff(g(x),x,2)='diff(f(x),x)-cos(x); 5783 2 5784 d d 5785 (%o2) --- (g(x)) = -- (f(x)) - cos(x) 5786 2 dx 5787 dx 5788 (%i3) atvalue('diff(g(x),x),x=0,a); 5789 (%o3) a 5790 (%i4) atvalue(f(x),x=0,1); 5791 (%o4) 1 5792 (%i5) desolve([%o1,%o2],[f(x),g(x)]); 5793 x 5794 (%o5) [f(x) = a %e - a + 1, g(x) = 5795 5796 x 5797 cos(x) + a %e - a + g(0) - 1] 5798 (%i6) [%o1,%o2],%o5,diff; 5799 x x x x 5800 (%o6) [a %e = a %e , a %e - cos(x) = a %e - cos(x)] 5801 5802 5803 Se 'desolve' não pode obter uma solução, retorna 'false'. 5804 5805 -- Função: ic1 (<solução>, <xval>, <yval>) 5806 Resolve problemas de valor inicial para equações diferenciais de 5807 primeira ordem. Aqui <solução> é uma solução geral para a equação, 5808 como encontrado por 'ode2', <xval> fornece um valor inicial para a 5809 variável independente na forma '<x> = <x0>', e <yval> fornece o 5810 valor inicial para a variável dependente na forma '<y> = <y0>'. 5811 5812 Veja 'ode2' para um exemplo de sua utilização. 5813 5814 -- Função: ic2 (<solução>, <xval>, <yval>, <dval>) 5815 Resolve problemas de valor inicial para equações diferenciais de 5816 segunda ordem. Aqui <solução> é uma solução geral para a equação, 5817 como encontrada por 'ode2', <xval> fornece o valor inicial para a 5818 variável independente na forma '<x> = <x0>', <yval> fornece o valor 5819 inicial da veriável dependente na forma '<y> = <y0>', e <dval> 5820 fornece o valor inicial para a primeira derivada da variável 5821 dependente com relação à variável independente, na forma 5822 'diff(<y>,<x>) = <dy0>' ('diff' não precisa receber apóstrofo para 5823 evitar avaliação). 5824 5825 Veja 'ode2' para um exemplo de seu uso. 5826 5827 -- Função: ode2 (<eqn>, <dvar>, <ivar>) 5828 A função 'ode2' resolve uma equação diferencial ordinária (EDO) de 5829 primeira ou de segunda ordem. 'ode2' usa três argumentos: uma EDO 5830 fornecida por <eqn>, a variável dependente <dvar>, e a variável 5831 independente <ivar>. Quando 'ode2' encontra uma solução, 'ode2' 5832 retorna ou uma solução explícita ou uma sulução implícita para a 5833 variável dependente. '%c' é usado para representar a constante de 5834 integração no caso de equações de primeira ordem, e '%k1' e '%k2' 5835 as constantes para equações de segunda ordem. A dependência da 5836 variável dependente com relação à variável independente não tem que 5837 ser escrita explicitamente, como no caso de 'desolve', mas a 5838 variável independente deve sempre ser fornecida como o terceiro 5839 argumento. 5840 5841 Se 'ode2' não conseguir obter uma solução por qualquer razaão, 5842 'ode2' retorna 'false', após talvez imprimir uma mensagem de erro. 5843 Os métodos implementados para equações de primeira ordem na 5844 seqüência em que eles foram testados são: linear, separável, exato 5845 - talvez requerendo um fator de integração, homogêneo, equação de 5846 Bernoulli, e um método homogêneo generalizado. Os tipos de equaçõe 5847 de segunda ordem que podem ser resolvidos são: coeficientes 5848 constantes, exato, linear homogêneo com coeficientes não constantes 5849 que podem ser transformados em coeficientes constantes, o tipo de 5850 equação de Euler também chamado de equação equi-dimensional, 5851 equações resolvíveis pelo método de variação de parâmetros, e 5852 equações as quais são livres ou da variável independente ou da 5853 dependente de modo que elas possam ser reduzidas a duas equações 5854 lineares de primeira ordem para serem resolvidas seqüêncialmente. 5855 5856 Na resolução de EDO's pelo Maxima, muitas variáveis são escolhidas 5857 puramente para propósitos informativos: 'método' denota o método de 5858 solução usado (e.g., 'linear'), 'intfactor' denota qualquer fator 5859 de integração usado, 'odeindex' denota o índice para o método de 5860 Bernoulli ou para o método homogêneo generalizado, e 'yp' denota a 5861 solução particular para a técnica de variação de parâmetros. 5862 5863 Com o objetivo de resolver poblemas de valor inicial (PVI) as 5864 funções 'ic1' e 'ic2' estão disponíveis para equações de primeira e 5865 de segunda ordem, e para resolver problemas do valor de segunda 5866 ordem associado (BVP em inglês) a função 'bc2' pode ser usada. 5867 5868 Exemplo: 5869 5870 (%i1) x^2*'diff(y,x) + 3*y*x = sin(x)/x; 5871 2 dy sin(x) 5872 (%o1) x -- + 3 x y = ------ 5873 dx x 5874 (%i2) ode2(%,y,x); 5875 %c - cos(x) 5876 (%o2) y = ----------- 5877 3 5878 x 5879 (%i3) ic1(%o2,x=%pi,y=0); 5880 cos(x) + 1 5881 (%o3) y = - ---------- 5882 3 5883 x 5884 (%i4) 'diff(y,x,2) + y*'diff(y,x)^3 = 0; 5885 2 5886 d y dy 3 5887 (%o4) --- + y (--) = 0 5888 2 dx 5889 dx 5890 (%i5) ode2(%,y,x); 5891 3 5892 y + 6 %k1 y 5893 (%o5) ------------ = x + %k2 5894 6 5895 (%i6) ratsimp(ic2(%o5,x=0,y=0,'diff(y,x)=2)); 5896 3 5897 2 y - 3 y 5898 (%o6) - ---------- = x 5899 6 5900 (%i7) bc2(%o5,x=0,y=1,x=1,y=3); 5901 3 5902 y - 10 y 3 5903 (%o7) --------- = x - - 5904 6 2 5905 5906 5907 5908File: maxima.info, Node: Numérico, Next: Arrays, Prev: Equações Diferenciais, Up: Top 5909 591023 Numérico 5911*********** 5912 5913* Menu: 5914 5915* Introdução a Numérico:: 5916* Pacotes de Fourier:: 5917* Funções e Variáveis Definidas para Numérico:: 5918* Funções e Variáveis Definidas para Séries de Fourier:: 5919 5920 5921File: maxima.info, Node: Introdução a Numérico, Next: Pacotes de Fourier, Prev: Numérico, Up: Numérico 5922 592323.1 Introdução a Numérico 5924========================== 5925 5926 5927File: maxima.info, Node: Pacotes de Fourier, Next: Funções e Variáveis Definidas para Numérico, Prev: Introdução a Numérico, Up: Numérico 5928 592923.2 Pacotes de Fourier 5930======================= 5931 5932O pacote 'fft' compreende funções para computação numérica (não 5933simbólica) das transformações rápidas de Fourier. 'load ("fft")' chama 5934esse pacote. Veja 'fft'. 5935 5936 O pacote 'fourie' compreende funções para computação simbólica de 5937séries de Fourier. 'load ("fourie")' chama esse pacote. Existem 5938funções no pacote 'fourie' para calcular coeficientes da integral de 5939Fourier e algumas funções para manipulação de expressões. Veja 'Funções 5940e Variáveis Definidas para Séries'. 5941 5942 5943File: maxima.info, Node: Funções e Variáveis Definidas para Numérico, Next: Funções e Variáveis Definidas para Séries de Fourier, Prev: Pacotes de Fourier, Up: Numérico 5944 594523.3 Funções e Variáveis Definidas para Numérico 5946================================================ 5947 5948 -- Função: polartorect (<magnitude_array>, <phase_array>) 5949 5950 Traduz valores complexos da forma 'r %e^(%i t)' para a forma 'a + b 5951 %i'. 'load ("fft")' chama essa função dentro do Maxima. Veja 5952 também 'fft'. 5953 5954 O módulo e a fase, 'r' e 't', São tomados de <magnitude_array> e 5955 <phase_array>, respectivamente. Os valores originais de arrays de 5956 entrada são substituídos pelas partes real e emaginária, 'a' e 'b', 5957 no retorno. As saídas são calculadas como 5958 5959 a: r cos (t) 5960 b: r sin (t) 5961 5962 Os arrays de entrada devem ter o mesmo tamanho e ser 5963 unidimensionais. O tamanho do array não deve ser uma potência de 5964 2. 5965 5966 'polartorect' é a função inversa de 'recttopolar'. 5967 5968 -- Função: recttopolar (<real_array>, <imaginary_array>) 5969 5970 Traduz valores complexos da forma 'a + b %i' para a forma 'r %e^(%i 5971 t)'. 'load ("fft")' chama essa função dentro do Maxima. Veja 5972 também 'fft'. 5973 5974 As partes real e imaginária, 'a' e 'b', são tomadas de <real_array> 5975 e <imaginary_array>, respectivamente. Os valores originais dos 5976 arrays de entrada são substituídos pelo módulo e pelo ângulo, 'r' e 5977 't', no retorno. As saídas são calculadas como 5978 5979 r: sqrt (a^2 + b^2) 5980 t: atan2 (b, a) 5981 5982 O ângulo calculado encontra-se no intervalo de '-%pi' a '%pi'. 5983 5984 Os arrays de entrada devem ter o mesmo tamanho e ser 5985 unidimensionais. O tamanho do array não deve ser uma potência de 5986 2. 5987 5988 'recttopolar' é a função inversa de 'polartorect'. 5989 5990 -- Função: ift (<real_array>, <imaginary_array>) 5991 5992 Transformação rápida inversa discreta de Fourier . 'load ("fft")' 5993 chama essa função dentro do Maxima. 5994 5995 'ift' realiza a transformação rápida complexa de Fourier sobre 5996 arrays em ponto flutuante unidimensionais. A transformação inversa 5997 é definida como 5998 5999 x[j]: sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1) 6000 6001 Veja 'fft' para maiores detalhes. 6002 6003 -- Função: fft (<real_array>, <imaginary_array>) 6004 -- Função: ift (<real_array>, <imaginary_array>) 6005 -- Função: recttopolar (<real_array>, <imaginary_array>) 6006 -- Função: polartorect (<magnitude_array>, <phase_array>) 6007 6008 Transformação rápidada de Fourier e funções relacionadas. 'load 6009 ("fft")' chama essas funções dentro do Maxima. 6010 6011 'fft' e 'ift' realiza transformação rápida complexa de Fourier e a 6012 transformação inversa, respectivamente, sobre arrays em ponto 6013 flutuante unidimensionais. O tamanho de <imaginary_array> deve ser 6014 igual ao tamanho de <real_array>. 6015 6016 'fft' e 'ift' operam in-loco. Isto é, sobre o retorno de 'fft' ou 6017 de 'ift', O conteúdo original dos arrays de entrada é substituído 6018 pela saída. A função 'fillarray' pode fazer uma cópia de um array, 6019 isso pode ser necessário. 6020 6021 A transformação discreta de Fourier e sua transformação inversa são 6022 definidas como segue. Tome 'x' sendo os dados originais, com 6023 6024 x[i]: real_array[i] + %i imaginary_array[i] 6025 6026 Tome 'y' sendo os dados transformados. A transformação normal e 6027 sua transformação inversa são 6028 6029 y[k]: (1/n) sum (x[j] exp (-2 %i %pi j k / n), j, 0, n-1) 6030 6031 x[j]: sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1) 6032 6033 Arrays adequadas podem ser alocadas pela função 'array'. Por 6034 exemplo: 6035 6036 array (my_array, float, n-1)$ 6037 6038 declara um array unidimensional com n elementos, indexado de 0 a 6039 n-1 inclusive. O número de elementos n deve ser igual a 2^m para 6040 algum m. 6041 6042 'fft' pode ser aplicada a dados reais (todos os arrays imaginários 6043 são iguais a zero) para obter coeficientes seno e cosseno. Após 6044 chamar 'fft', os coeficientes seno e cosseno, digamos 'a' e 'b', 6045 podem ser calculados como 6046 6047 a[0]: real_array[0] 6048 b[0]: 0 6049 6050 e 6051 6052 a[j]: real_array[j] + real_array[n-j] 6053 b[j]: imaginary_array[j] - imaginary_array[n-j] 6054 6055 para j variando de 1 a n/2-1, e 6056 6057 a[n/2]: real_array[n/2] 6058 b[n/2]: 0 6059 6060 'recttopolar' traduz valores complexos da forma 'a + b %i' para a 6061 forma 'r %e^(%i t)'. Veja 'recttopolar'. 6062 6063 'polartorect' traduz valores complexos da forma 'r %e^(%i t)' para 6064 a forma 'a + b %i'. Veja 'polartorect'. 6065 6066 'demo ("fft")' exibe uma demonstração do pacote 'fft'. 6067 6068 -- Variável de opção: fortindent 6069 Valor padrão: 0 6070 6071 'fortindent' controla a margem esquerda de indentação de expressões 6072 mostradas pelo comando 'fortran'. 0 fornece indentação normal 6073 (i.e., 6 espaços), e valores positivos farão com que expressões 6074 sejam mostrados mais além para a direita. 6075 6076 -- Função: fortran (<expr>) 6077 Mostra <expr> como uma declaração Fortran. A linha de saída é 6078 indentada com espaços. Se a linha for muito longa, 'fortran' 6079 imprime linhas de continuação. 'fortran' mostra o operador de 6080 exponenciação '^' como '**', e mostra um número complexo 'a + b %i' 6081 na forma '(a,b)'. 6082 6083 <expr> pode ser uma equação. Nesse caso, 'fortran' mostra uma 6084 declaração de atribuição, atribuindo o primeiro membro (esquerda) 6085 da equação ao segundo membro (direita). Em particular, se o 6086 primeiro membro <expr> é um nome de uma matriz, então 'fortran' 6087 mostra uma declaração de atribuição para cada elemento da matriz. 6088 6089 Se <expr> não for alguma coisa reconhecida por 'fortran', a 6090 expressão é mostrada no formato 'grind' sem reclamação. 'fortran' 6091 não conhece listas, arrays ou funções. 6092 6093 'fortindent' controla o margem esquerda das linhas mostradas. 0 é 6094 a margem normal (i.e., indentada 6 espaços). Incrementando 6095 'fortindent' faz com que expressões sejam mostradas adiante para a 6096 direita. 6097 6098 quando 'fortspaces' for 'true', 'fortran' preenche cada linha 6099 mostrada com espaços em branco até completar 80 columas. 6100 6101 'fortran' avalia seus argumentos; colocando um apóstrofo em um 6102 argumento evita avaliação. 'fortran' sempre retorna 'done'. 6103 6104 Exemplos: 6105 6106 (%i1) expr: (a + b)^12$ 6107 (%i2) fortran (expr); 6108 (b+a)**12 6109 (%o2) done 6110 (%i3) fortran ('x=expr); 6111 x = (b+a)**12 6112 (%o3) done 6113 (%i4) fortran ('x=expand (expr)); 6114 x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792 6115 1 *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b 6116 2 **3+66*a**10*b**2+12*a**11*b+a**12 6117 (%o4) done 6118 (%i5) fortran ('x=7+5*%i); 6119 x = (7,5) 6120 (%o5) done 6121 (%i6) fortran ('x=[1,2,3,4]); 6122 x = [1,2,3,4] 6123 (%o6) done 6124 (%i7) f(x) := x^2$ 6125 (%i8) fortran (f); 6126 f 6127 (%o8) done 6128 6129 -- Variável de opção: fortspaces 6130 Valor padrão: 'false' 6131 6132 Quando 'fortspaces' for 'true', 'fortran' preenche cada linha 6133 mostrada com espaços em branco até completar 80 columas. 6134 6135 -- Função: horner (<expr>, <x>) 6136 -- Função: horner (<expr>) 6137 Retorna uma representação rearranjada de <expr> como na regra de 6138 Horner, usando <x> como variável principal se isso for 6139 especificado. 'x' pode ser omitido e nesse caso a variável 6140 principal da forma de expressão racional canônica de <expr> é 6141 usada. 6142 6143 'horner' algumas vezes melhora a estabilidade se 'expr' for ser 6144 numericamente avaliada. Isso também é útil se Maxima é usado para 6145 gerar programas para rodar em Fortran. Veja também 'stringout'. 6146 6147 (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155; 6148 2 6149 (%o1) 1.0E-155 x - 5.5 x + 5.2E+155 6150 (%i2) expr2: horner (%, x), keepfloat: true; 6151 (%o2) (1.0E-155 x - 5.5) x + 5.2E+155 6152 (%i3) ev (expr, x=1e155); 6153 Maxima encountered a Lisp error: 6154 6155 floating point overflow 6156 6157 Automatically continuing. 6158 To reenable the Lisp debugger set *debugger-hook* to nil. 6159 (%i4) ev (expr2, x=1e155); 6160 (%o4) 7.0E+154 6161 6162 -- Função: find_root (<f>(<x>), <x>, <a>, <b>) 6163 -- Função: find_root (<f>, <a>, <b>) 6164 Encontra a raíz da função <f> com a variável <x> percorrendo o 6165 intervalo '[<a>, <b>]'. A função deve ter um sinal diferente em 6166 cada ponto final. Se essa condição não for alcançada, a action of 6167 the function is governed by 'find_root_error'. If 6168 'find_root_error' is 'true' then an error occurs, otherwise the 6169 value of 'find_root_error' is returned (thus for plotting 6170 'find_root_error' might be set to 0.0). De outra forma (dado que 6171 Maxima pode avaliar o primeiro argumento no intervalo especificado, 6172 e que o intervalo é contínuo) 'find_root' é garantido vir para cima 6173 com a raíz (ou um deles se existir mais que uma raíz). A precisão 6174 de 'find_root' é governada por 'intpolabs' e 'intpolrel' os quais 6175 devem ser números em ponto flutuante não negativos. 'find_root' 6176 encerrará quando o primeiro argumento avaliar para alguma coisa 6177 menor que ou igual a 'intpolabs' ou se sucessivas aproximações da 6178 raíz diferirem por não mais que 'intpolrel * <um dos 6179 aproximandos>'. O valor padrão de 'intpolabs' e 'intpolrel' são 6180 0.0 de forma que 'find_root' pega como boa uma resposta como for 6181 possível com a precisão aritmética simples que tivermos. O 6182 primeiro argumento pode ser uma equação. A ordem dos dois últimos 6183 argumentos é irrelevante. Dessa forma 6184 6185 find_root (sin(x) = x/2, x, %pi, 0.1); 6186 6187 é equivalente a 6188 6189 find_root (sin(x) = x/2, x, 0.1, %pi); 6190 6191 O método usado é uma busca binária no intervalo especificado pelos 6192 últimos dois argumentos. Quando o resultado da busca for 6193 encontrado a função é fechada o suficiente para ser linear, isso 6194 inicia usando interpolação linear. 6195 6196 Examples: 6197 (%i1) f(x) := sin(x) - x/2; 6198 x 6199 (%o1) f(x) := sin(x) - - 6200 2 6201 (%i2) find_root (sin(x) - x/2, x, 0.1, %pi); 6202 (%o2) 1.895494267033981 6203 (%i3) find_root (sin(x) = x/2, x, 0.1, %pi); 6204 (%o3) 1.895494267033981 6205 (%i4) find_root (f(x), x, 0.1, %pi); 6206 (%o4) 1.895494267033981 6207 (%i5) find_root (f, 0.1, %pi); 6208 (%o5) 1.895494267033981 6209 6210 -- Variável de opção: find_root_abs 6211 Valor padrão: 0.0 6212 6213 'find_root_abs' é a precisão do comando 'find_root'. A precisão é 6214 governada por 'find_root_abs' e 'find_root_rel' que devem ser 6215 números não negativos em ponto flutuante. 'find_root' terminará 6216 quando o primeiro argumento avaliar para alguma coisa menor que ou 6217 igual a 'find_root_abs' ou se sucessivos aproximandos para a raíz 6218 diferirem por não mais que 'find_root_rel * <um dos aproximandos>'. 6219 Os valores padrão de 'find_root_abs' e 'find_root_rel' são 0.0 de 6220 forma que 'find_root' tome como boa uma resposta que for possível 6221 com a precisão aritmética simples que tivermos. 6222 6223 -- Variável de opção: find_root_error 6224 Valor padrão: 'true' 6225 6226 'find_root_error' governa o comportamento de 'find_root'. Quando 6227 'find_root' for chamada, ela determina se a função a ser resolvida 6228 satisfaz ou não a condição que os valores da função nos pontos 6229 finais do intervalo de interpolação são opostos em sinal. Se eles 6230 forem de sinais opostos, a interpolação prossegue. Se eles forem 6231 de mesmo sinal, e 'find_root_error' for 'true', então um erro é 6232 sinalizado. Se eles forem de mesmo sinal e 'find_root_error' não 6233 for 'true', o valor de 'find_root_error' é retornado. Dessa forma 6234 para montagem de gráfico, 'find_root_error' pode ser escolhida para 6235 0.0. 6236 6237 -- Variável de opção: find_root_rel 6238 Valor padrão: 0.0 6239 6240 'find_root_rel' é a precisão do comando 'find_root' e é governada 6241 por 'find_root_abs' e 'find_root_rel' que devem ser números não 6242 negativos em ponto flutuante. 'find_root' terminará quando o 6243 primeiro argumento avaliar para alguma coisa menor que ou igual a 6244 'find_root_abs' ou se sucessivos aproximandos para a raíz diferirem 6245 de não mais que 'find_root_rel * <um dos aproximandos>'. Os 6246 valores padrão de 'find_root_labs' e 'find_root_rel' é 0.0 de forma 6247 que 'find_root' toma como boa uma resposta que for possível com a 6248 precisão aritmética simples que tivermos. 6249 6250 -- Função: newton (<expr>, <x>, <x_0>, <eps>) 6251 Retorna uma solução aproximada de '<expr> = 0' através do método de 6252 Newton, considerando <expr> como sendo uma função de uma variável, 6253 <x>. A busca pela solução começa com '<x> = <x_0>' e prossegue até 6254 'abs(<expr>) < <eps>' (com <expr> avaliada para o valor corrente de 6255 <x>). 6256 6257 'newton' permite que variáveis indefinidas apareçam em <expr>, 6258 contanto que o teste de terminação 'abs(<expr>) < <eps>' avalie 6259 para 'true' ou 'false'. Dessa forma não é necessário que <expr> 6260 avalie para um número. 6261 6262 'load(newton1)' chama essa função. 6263 6264 Veja também 'realroots', 'allroots', 'find_root', e 'mnewton'. 6265 6266 Exemplos: 6267 6268 (%i1) load (newton1); 6269 (%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac 6270 (%i2) newton (cos (u), u, 1, 1/100); 6271 (%o2) 1.570675277161251 6272 (%i3) ev (cos (u), u = %); 6273 (%o3) 1.2104963335033528E-4 6274 (%i4) assume (a > 0); 6275 (%o4) [a > 0] 6276 (%i5) newton (x^2 - a^2, x, a/2, a^2/100); 6277 (%o5) 1.00030487804878 a 6278 (%i6) ev (x^2 - a^2, x = %); 6279 2 6280 (%o6) 6.098490481853958E-4 a 6281 6282 6283File: maxima.info, Node: Funções e Variáveis Definidas para Séries de Fourier, Prev: Funções e Variáveis Definidas para Numérico, Up: Numérico 6284 628523.4 Funções e Variáveis Definidas para Séries de Fourier 6286========================================================= 6287 6288 -- Função: equalp (<x>, <y>) 6289 Retorna 'true' se 'equal (<x>, <y>)' de outra forma 'false' (não 6290 fornece uma mensagem de erro como 'equal (x, y)' poderia fazer 6291 nesse caso). 6292 6293 -- Função: remfun (<f>, <expr>) 6294 -- Função: remfun (<f>, <expr>, <x>) 6295 'remfun (<f>, <expr>)' substitue todas as ocorrências de '<f> 6296 (<arg>)' por <arg> em <expr>. 6297 6298 'remfun (<f>, <expr>, <x>)' substitue todas as ocorrências de '<f> 6299 (<arg>)' por <arg> em <expr> somente se <arg> contiver a variável 6300 <x>. 6301 6302 -- Função: funp (<f>, <expr>) 6303 -- Função: funp (<f>, <expr>, <x>) 6304 'funp (<f>, <expr>)' retorna 'true' se <expr> contém a função <f>. 6305 6306 'funp (<f>, <expr>, <x>)' retorna 'true' se <expr> contém a função 6307 <f> e a variável <x> em algum lugar no argumento de uma das 6308 instâncias de <f>. 6309 6310 -- Função: absint (<f>, <x>, <halfplane>) 6311 -- Função: absint (<f>, <x>) 6312 -- Função: absint (<f>, <x>, <a>, <b>) 6313 'absint (<f>, <x>, <halfplane>)' retorna a integral indefinida de 6314 <f> com relação a <x> no dado semi-plano ('pos', 'neg', ou 'both'). 6315 <f> pode conter expressões da forma 'abs (x)', 'abs (sin (x))', 6316 'abs (a) * exp (-abs (b) * abs (x))'. 6317 6318 'absint (<f>, <x>)' é equivalente a 'absint (<f>, <x>, pos)'. 6319 6320 'absint (<f>, <x>, <a>, <b>)' retorna a integral definida de <f> 6321 com relação a <x> de <a> até <b>. <f> pode incluir valores 6322 absolutos. 6323 6324 -- Função: fourier (<f>, <x>, <p>) 6325 Retorna uma lista de coeficientes de Fourier de '<f>(<x>)' 6326 definidos sobre o intervalo '[-p, p]'. 6327 6328 -- Função: foursimp (<l>) 6329 Simplifica 'sin (n %pi)' para 0 se 'sinnpiflag' for 'true' e 'cos 6330 (n %pi)' para '(-1)^n' se 'cosnpiflag' for 'true'. 6331 6332 -- Variável de opção: sinnpiflag 6333 Valor padrão: 'true' 6334 6335 Veja 'foursimp'. 6336 6337 -- Variável de opção: cosnpiflag 6338 Valor padrão: 'true' 6339 6340 Veja 'foursimp'. 6341 6342 -- Função: fourexpand (<l>, <x>, <p>, <limit>) 6343 Constrói e retorna a série de Fourier partindo da lista de 6344 coeficientes de Fourier <l> até (up through) <limit> termos 6345 (<limit> pode ser 'inf'). <x> e <p> possuem o mesmo significado 6346 que em 'fourier'. 6347 6348 -- Função: fourcos (<f>, <x>, <p>) 6349 Retorna os coeficientes do cosseno de Fourier para '<f>(<x>)' 6350 definida sobre '[0, %pi]'. 6351 6352 -- Função: foursin (<f>, <x>, <p>) 6353 Retorna os coeficientes do seno de Fourier para '<f>(<x>)' definida 6354 sobre '[0, <p>]'. 6355 6356 -- Função: totalfourier (<f>, <x>, <p>) 6357 Retorna 'fourexpand (foursimp (fourier (<f>, <x>, <p>)), <x>, <p>, 6358 'inf)'. 6359 6360 -- Função: fourint (<f>, <x>) 6361 Constrói e retorna uma lista de coeficientes de integral de Fourier 6362 de '<f>(<x>)' definida sobre '[minf, inf]'. 6363 6364 -- Função: fourintcos (<f>, <x>) 6365 Retorna os coeficientes da integral do cosseno de Fourier para 6366 '<f>(<x>)' on '[0, inf]'. 6367 6368 -- Função: fourintsin (<f>, <x>) 6369 Retorna os coeficientes da integral do seno de Fourier para 6370 '<f>(<x>)' on '[0, inf]'. 6371 6372 6373File: maxima.info, Node: Arrays, Next: Matrizes e Álgebra Linear, Prev: Numérico, Up: Top 6374 637524 Arrays 6376********* 6377 6378* Menu: 6379 6380* Funções e Variáveis Definidas para Arrays:: 6381 6382 6383File: maxima.info, Node: Funções e Variáveis Definidas para Arrays, Prev: Arrays, Up: Arrays 6384 638524.1 Funções e Variáveis Definidas para Arrays 6386============================================== 6387 6388 -- Função: array (<name>, <dim_1>, ..., <dim_n>) 6389 -- Função: array (<name>, <type>, <dim_1>, ..., <dim_n>) 6390 -- Função: array ([<nome_1>, ..., <nome_m>], <dim_1>, ..., <dim_n>) 6391 6392 Cria um array n-dimensional. n pode ser menor ou igual a 5. Os 6393 subscritos para a i'ésima dimensão são inteiros no intervalo de 0 a 6394 <dim_i>. 6395 6396 'array (<name>, <dim_1>, ..., <dim_n>)' cria um array genérico. 6397 6398 'array (<name>, <type>, <dim_1>, ..., <dim_n>)' cria um array, com 6399 elementos de um tipo especificado. <type> pode ser 'fixnum' para 6400 inteiros de tamanho limitado ou 'flonum' para números em ponto 6401 flutuante. 6402 6403 'array ([<nome_1>, ..., <nome_m>], <dim_1>, ..., <dim_n>)' cria m 6404 arrays, todos da mesma dimensão. 6405 6406 Se o usuário atribui a uma variável subscrita antes de declarar o 6407 array correspondente, um array não declarado é criado. Arrays não 6408 declarados, também conhecidos como array desordenado (porque o 6409 codigo desordenado termina nos subscritos), são mais gerais que 6410 arrays declarados. O usuário não declara seu tamanho máximo, e ele 6411 cresce dinamicamente e desordenadamente à medida que são atribuídos 6412 valores a mais elementos. Os subscritos de um array não declarado 6413 não precisam sempre ser números. Todavia, exceto para um array um 6414 tanto quanto esparso, é provavelmente mais eficiente declarar isso 6415 quando possível que deixar não declarado. A função 'array' pode 6416 ser usada para transformar um array não declarado em um array 6417 declarado. 6418 6419 -- Função: arrayapply (<A>, [<i_1>, ..., <i_n>]) 6420 Avalia '<A> [<i_1>, ..., <i_n>]', quando <A> for um array e <i_1>, 6421 ..., <i_n> são inteiros. 6422 6423 Ela é remanescente de 'apply', exceto o primeiro argumento que é um 6424 array ao invés de uma função. 6425 6426 -- Função: arrayinfo (<A>) 6427 Retorna informações sobre o array <A>. O argumento <A> pode ser um 6428 array declarado, uma array não declarado ( que sofreu um hash), uma 6429 função de array, ou uma função que possui subscrito. 6430 6431 Para arrays declarados, 'arrayinfo' retorna uma lista compreendendo 6432 o átomo 'declared', o n;umero de dimensões, e o tamanho de cada 6433 dimensão. Os elementos do array, ambos associados e não 6434 associados, são retornados por 'listarray'. 6435 6436 Para arrays não declarados (arrays que sofreram um hash), 6437 'arrayinfo' retorna uma lista compreendendo o átomo 'hashed', o 6438 número de subscritos, e os subscritos de de todo elemento que tiver 6439 um valor. Os valores são retornados por meio de 'listarray'. 6440 6441 Para funções de array, 'arrayinfo' retretorna uma lista 6442 compreendendo o átomo 'hashed', o número de subscritos, e quaisquer 6443 valores de subscritos para os quais exista valores funcionais 6444 armazenados. Os valores funcionais armazenados são retornados 6445 através de 'listarray'. 6446 6447 Para funções que possuem subscritos, 'arrayinfo' retorna uma lista 6448 compreendendo o átomo 'hashed', o número de subscritos, e qualquer 6449 valores subscritos para os quais existe uma expressões lambda. As 6450 expressões lambda são retornadas por 'listarray'. 6451 6452 Examples: 6453 6454 'arrayinfo' e 'listarray' aplicado a um array declarado. 6455 6456 (%i1) array (aa, 2, 3); 6457 (%o1) aa 6458 (%i2) aa [2, 3] : %pi; 6459 (%o2) %pi 6460 (%i3) aa [1, 2] : %e; 6461 (%o3) %e 6462 (%i4) arrayinfo (aa); 6463 (%o4) [declared, 2, [2, 3]] 6464 (%i5) listarray (aa); 6465 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####, 6466 #####, #####, #####, %pi] 6467 6468 'arrayinfo' e 'listarray' aplicado a um array não declarado (no 6469 qual foi aplicado um hash). 6470 6471 (%i1) bb [FOO] : (a + b)^2; 6472 2 6473 (%o1) (b + a) 6474 (%i2) bb [BAR] : (c - d)^3; 6475 3 6476 (%o2) (c - d) 6477 (%i3) arrayinfo (bb); 6478 (%o3) [hashed, 1, [BAR], [FOO]] 6479 (%i4) listarray (bb); 6480 3 2 6481 (%o4) [(c - d) , (b + a) ] 6482 6483 'arrayinfo' e 'listarray' aplicado a uma função de array. 6484 6485 (%i1) cc [x, y] := y / x; 6486 y 6487 (%o1) cc := - 6488 x, y x 6489 (%i2) cc [u, v]; 6490 v 6491 (%o2) - 6492 u 6493 (%i3) cc [4, z]; 6494 z 6495 (%o3) - 6496 4 6497 (%i4) arrayinfo (cc); 6498 (%o4) [hashed, 2, [4, z], [u, v]] 6499 (%i5) listarray (cc); 6500 z v 6501 (%o5) [-, -] 6502 4 u 6503 6504 'arrayinfo' e 'listarray' aplicadas a funções com subscritos. 6505 6506 (%i1) dd [x] (y) := y ^ x; 6507 x 6508 (%o1) dd (y) := y 6509 x 6510 (%i2) dd [a + b]; 6511 b + a 6512 (%o2) lambda([y], y ) 6513 (%i3) dd [v - u]; 6514 v - u 6515 (%o3) lambda([y], y ) 6516 (%i4) arrayinfo (dd); 6517 (%o4) [hashed, 1, [b + a], [v - u]] 6518 (%i5) listarray (dd); 6519 b + a v - u 6520 (%o5) [lambda([y], y ), lambda([y], y )] 6521 6522 -- Função: arraymake (<A>, [<i_1>, ..., <i_n>]) 6523 Retorna a expressão '<A>[<i_1>, ..., <i_n>]'. O resultado é uma 6524 referência a um array não avaliado. 6525 6526 'arraymake' é remanicência de 'funmake', exceto o valor retornado é 6527 um array de referência não avaliado ao invés de uma chamada de 6528 função não avaliada. 6529 6530 Exemplos: 6531 6532 (%i1) arraymake (A, [1]); 6533 (%o1) A 6534 1 6535 (%i2) arraymake (A, [k]); 6536 (%o2) A 6537 k 6538 (%i3) arraymake (A, [i, j, 3]); 6539 (%o3) A 6540 i, j, 3 6541 (%i4) array (A, fixnum, 10); 6542 (%o4) A 6543 (%i5) fillarray (A, makelist (i^2, i, 1, 11)); 6544 (%o5) A 6545 (%i6) arraymake (A, [5]); 6546 (%o6) A 6547 5 6548 (%i7) ''%; 6549 (%o7) 36 6550 (%i8) L : [a, b, c, d, e]; 6551 (%o8) [a, b, c, d, e] 6552 (%i9) arraymake ('L, [n]); 6553 (%o9) L 6554 n 6555 (%i10) ''%, n = 3; 6556 (%o10) c 6557 (%i11) A2 : make_array (fixnum, 10); 6558 (%o11) {Array: #(0 0 0 0 0 0 0 0 0 0)} 6559 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); 6560 (%o12) {Array: #(1 2 3 4 5 6 7 8 9 10)} 6561 (%i13) arraymake ('A2, [8]); 6562 (%o13) A2 6563 8 6564 (%i14) ''%; 6565 (%o14) 9 6566 6567 -- Variável de sistema: arrays 6568 Valor padrão: '[]' 6569 6570 'arrays' é uma lista dos arrays que tiverem sido alocados. Essa 6571 lista compreende arrays declarados através de 'array', arrays 6572 desordenados (hashed) construídos através de definição implícita 6573 (atribuindo alguma coisa a um elemento de array), e funções de 6574 array definidas por meio de ':=' e 'define'. Arrays definidos por 6575 meio de 'make_array' não estão incluídos. 6576 6577 Veja também 'array', 'arrayapply', 'arrayinfo', 'arraymake', 6578 'fillarray', 'listarray', e 'rearray'. 6579 6580 Exemplos: 6581 6582 (%i1) array (aa, 5, 7); 6583 (%o1) aa 6584 (%i2) bb [FOO] : (a + b)^2; 6585 2 6586 (%o2) (b + a) 6587 (%i3) cc [x] := x/100; 6588 x 6589 (%o3) cc := --- 6590 x 100 6591 (%i4) dd : make_array ('any, 7); 6592 (%o4) {Array: #(NIL NIL NIL NIL NIL NIL NIL)} 6593 (%i5) arrays; 6594 (%o5) [aa, bb, cc] 6595 6596 -- Função: bashindices (<expr>) 6597 Transforma a expressão <expr> dando a cada somatório e a cada 6598 produto um único índice. Isso dá a 'changevar' grande precisão 6599 quando se está trabalhando com somatórios e produtos. A forma do 6600 único índice é 'j<number>'. A quantidade <number> é determindad 6601 por referência a 'gensumnum', que pode ser alterada pelo usuário. 6602 Por exemplo, 'gensumnum:0$' reseta isso. 6603 6604 -- Função: fillarray (<A>, <B>) 6605 Preenche o array <A> com <B>, que é uma lista ou um array. 6606 6607 Se um tipo específico for declarado para <A> no momento de sua 6608 criação, <A> somente porde ser preenchido com elementos do tipo 6609 especificado; Constitui um erro alguma tentativa feita para copiar 6610 um um elemento de um tipo diferente. 6611 6612 Se as dimensões dos arrays <A> e <B> forem diferents, <A> é 6613 preenchido no ordem de maior fileira. Se não existirem elementos 6614 livres em <B> o último elemento é usado para preencher todo o resto 6615 de <A>. Se existirem muitos , esses restantes seram ignorados. 6616 6617 'fillarray' retorna esse primeiro argumento. 6618 6619 Exemplos: 6620 6621 Create an array of 9 elements and fill it from a list. 6622 6623 (%i1) array (a1, fixnum, 8); 6624 (%o1) a1 6625 (%i2) listarray (a1); 6626 (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0] 6627 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]); 6628 (%o3) a1 6629 (%i4) listarray (a1); 6630 (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9] 6631 6632 Quando existirem poucos elementos para preencher o array, o último 6633 elemento é repetido. Quando houverem muitos elementos, os 6634 elementos extras são ignorados. 6635 6636 (%i1) a2 : make_array (fixnum, 8); 6637 (%o1) {Array: #(0 0 0 0 0 0 0 0)} 6638 (%i2) fillarray (a2, [1, 2, 3, 4, 5]); 6639 (%o2) {Array: #(1 2 3 4 5 5 5 5)} 6640 (%i3) fillarray (a2, [4]); 6641 (%o3) {Array: #(4 4 4 4 4 4 4 4)} 6642 (%i4) fillarray (a2, makelist (i, i, 1, 100)); 6643 (%o4) {Array: #(1 2 3 4 5 6 7 8)} 6644 6645 Arrays multi-dimensionais são preenchidos em ordem de maior 6646 fileira. 6647 6648 (%i1) a3 : make_array (fixnum, 2, 5); 6649 (%o1) {Array: #2A((0 0 0 0 0) (0 0 0 0 0))} 6650 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); 6651 (%o2) {Array: #2A((1 2 3 4 5) (6 7 8 9 10))} 6652 (%i3) a4 : make_array (fixnum, 5, 2); 6653 (%o3) {Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))} 6654 (%i4) fillarray (a4, a3); 6655 (%o4) {Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))} 6656 6657 -- Função: listarray (<A>) 6658 Retorna uma lista dos elementos do array <A>. O argumento <A> pode 6659 ser um array declarado, um array não declarado (desordenado - 6660 hashed), uma função de array, ou uma função com subscritos. 6661 6662 Elementos são listados em ordem de linha maior. Isto é, elementos 6663 são ordenados conforme o primeiro índice, en seguida conforme o 6664 segundo índice, e assim sucessivamente. A sequüência de ordenação 6665 por meio dos valores dos índices é a mesma ordem estabelecida por 6666 meio de 'orderless'. 6667 6668 Para arrays não declarados , funções de arrays, e funções com 6669 subscritos, os elementos correspondem aos valores de índice 6670 retornados através de 'arrayinfo'. 6671 6672 Elemetos não associados de arrays genéricos declarados (isto é, não 6673 'fixnum' e não 'flonum') são retornados como '#####'. Elementos 6674 não associados de arrays declarados 'fixnum' ou 'flonum' são 6675 retornados como 0 ou 0.0, respectivamente. Elementos não 6676 associados de arrays não declarados, funções de array, e funções 6677 subscritas não são retornados. 6678 6679 Exemplos: 6680 6681 'listarray' e 'arrayinfo' aplicados a um array declarado. 6682 6683 (%i1) array (aa, 2, 3); 6684 (%o1) aa 6685 (%i2) aa [2, 3] : %pi; 6686 (%o2) %pi 6687 (%i3) aa [1, 2] : %e; 6688 (%o3) %e 6689 (%i4) listarray (aa); 6690 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####, 6691 #####, #####, #####, %pi] 6692 (%i5) arrayinfo (aa); 6693 (%o5) [declared, 2, [2, 3]] 6694 6695 'listarray' e 'arrayinfo' aplicadas a arrays não declarados (hashed 6696 - desordenados). 6697 6698 (%i1) bb [FOO] : (a + b)^2; 6699 2 6700 (%o1) (b + a) 6701 (%i2) bb [BAR] : (c - d)^3; 6702 3 6703 (%o2) (c - d) 6704 (%i3) listarray (bb); 6705 3 2 6706 (%o3) [(c - d) , (b + a) ] 6707 (%i4) arrayinfo (bb); 6708 (%o4) [hashed, 1, [BAR], [FOO]] 6709 6710 'listarray' e 'arrayinfo' aplicada a uma função de array. 6711 6712 (%i1) cc [x, y] := y / x; 6713 y 6714 (%o1) cc := - 6715 x, y x 6716 (%i2) cc [u, v]; 6717 v 6718 (%o2) - 6719 u 6720 (%i3) cc [4, z]; 6721 z 6722 (%o3) - 6723 4 6724 (%i4) listarray (cc); 6725 z v 6726 (%o4) [-, -] 6727 4 u 6728 (%i5) arrayinfo (cc); 6729 (%o5) [hashed, 2, [4, z], [u, v]] 6730 6731 'listarray' e 'arrayinfo' aplicadas a funções com subscritos. 6732 6733 (%i1) dd [x] (y) := y ^ x; 6734 x 6735 (%o1) dd (y) := y 6736 x 6737 (%i2) dd [a + b]; 6738 b + a 6739 (%o2) lambda([y], y ) 6740 (%i3) dd [v - u]; 6741 v - u 6742 (%o3) lambda([y], y ) 6743 (%i4) listarray (dd); 6744 b + a v - u 6745 (%o4) [lambda([y], y ), lambda([y], y )] 6746 (%i5) arrayinfo (dd); 6747 (%o5) [hashed, 1, [b + a], [v - u]] 6748 6749 -- Função: make_array (<type>, <dim_1>, ..., <dim_n>) 6750 Cria e retorna um array de Lisp. <type> pode ser 'any', 'flonum', 6751 'fixnum', 'hashed' ou 'functional'. Existem n indices, e o 6752 i'enésimo indice está no intervalo de 0 a <dim_i> - 1. 6753 6754 A vantagem de 'make_array' sobre 'array' é que o valor de retorno 6755 não tem um nome, e uma vez que um ponteiro a ele vai, ele irá 6756 também. Por exemplo, se 'y: make_array (...)' então 'y' aponta 6757 para um objeto que ocupa espaço, mas depois de 'y: false', 'y' não 6758 mais aponta para aquele objeto, então o objeto pode ser descartado. 6759 6760 Exemplos: 6761 6762 (%i1) A1 : make_array (fixnum, 10); 6763 (%o1) {Array: #(0 0 0 0 0 0 0 0 0 0)} 6764 (%i2) A1 [8] : 1729; 6765 (%o2) 1729 6766 (%i3) A1; 6767 (%o3) {Array: #(0 0 0 0 0 0 0 0 1729 0)} 6768 (%i4) A2 : make_array (flonum, 10); 6769 (%o4) {Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)} 6770 (%i5) A2 [2] : 2.718281828; 6771 (%o5) 2.718281828 6772 (%i6) A2; 6773 (%o6) 6774 {Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)} 6775 (%i7) A3 : make_array (any, 10); 6776 (%o7) {Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)} 6777 (%i8) A3 [4] : x - y - z; 6778 (%o8) - z - y + x 6779 (%i9) A3; 6780 (%o9) {Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\ 6781 -1 $Y) ((MTIMES SIMP) -1 $Z)) 6782 NIL NIL NIL NIL NIL)} 6783 (%i10) A4 : make_array (fixnum, 2, 3, 5); 6784 (%o10) {Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \ 6785 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))} 6786 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5)); 6787 (%o11) {Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15)) 6788 ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))} 6789 (%i12) A4 [0, 2, 1]; 6790 (%o12) 12 6791 6792 -- Função: rearray (<A>, <dim_1>, ..., <dim_n>) 6793 Altera as dimenções de um array. O novo array será preenchido com 6794 os elementos do antigo em ordem da maior linha. Se o array antigo 6795 era muito pequeno, os elementos restantes serão preenchidos com 6796 'false', '0.0' ou '0', dependendo do tipo do array. O tipo do 6797 array não pode ser alterado. 6798 6799 -- Função: remarray (<A_1>, ..., <A_n>) 6800 -- Função: remarray (all) 6801 Remove arrays e funções associadas a arrays e libera o espaço 6802 ocupado. Os argumentos podem ser arrays declarados, arrays não 6803 declarados (dsordenados - hashed), funções de array functions, e 6804 funções com subscritos. 6805 6806 'remarray (all)' remove todos os ítens na lista global 'arrays'. 6807 6808 Isso pode ser necessário para usar essa função se isso é desejado 6809 para redefinir os valores em um array desordenado. 6810 6811 'remarray' retorna a lista dos arrays removidos. 6812 6813 -- Função: subvar (<x>, <i>) 6814 Avalia a expressão subscrita '<x>[<i>]'. 6815 6816 'subvar' avalia seus argumentos. 6817 6818 'arraymake (<x>, [<i>]' constrói a expressão '<x>[<i>]', mas não a 6819 avalia. 6820 6821 Exemplos: 6822 6823 (%i1) x : foo $ 6824 (%i2) i : 3 $ 6825 (%i3) subvar (x, i); 6826 (%o3) foo 6827 3 6828 (%i4) foo : [aa, bb, cc, dd, ee]$ 6829 (%i5) subvar (x, i); 6830 (%o5) cc 6831 (%i6) arraymake (x, [i]); 6832 (%o6) foo 6833 3 6834 (%i7) ''%; 6835 (%o7) cc 6836 6837 -- Variável de pção: use_fast_arrays 6838 - Se 'true' somente dois tipos de arrays são reconhecidos. 6839 6840 1) O array art-q (t no Lisp Comum) que pode ter muitas dimensões 6841 indexadas por inteiros, e pode aceitar qualquer objeto do Lisp ou 6842 do Maxima como uma entrada. Para construir assim um array, insira 6843 'a:make_array(any,3,4);' então 'a' terá como valor, um array com 6844 doze posições, e o índice é baseado em zero. 6845 6846 2) O array Hash_table que é o tipo padrão de array criado se um faz 6847 'b[x+1]:y^2' (e 'b' não é ainda um array, uma lista, ou uma matriz 6848 - se isso ou um desses ocorrer um erro pode ser causado desde 'x+1' 6849 não poderá ser um subscrito válido para um array art-q, uma lista 6850 ou uma matriz). Esses índices (também conhecidos como chaves) 6851 podem ser quaisquer objetos. Isso somente pega uma chave por vez a 6852 cada vez ('b[x+1,u]:y' ignorará o 'u'). A referência termina em 6853 'b[x+1] ==> y^2'. Certamente a chave poe ser uma lista , e.g. 6854 'b[[x+1,u]]:y' poderá ser válido. Isso é incompatível com os 6855 arrays antigos do Maxima, mas poupa recursos. 6856 6857 Uma vantagem de armazenar os arrays como valores de símbolos é que 6858 as convenções usuais sobre variáveis locais de uma função 6859 aplicam-se a arrays também. O tipo Hash_table também usa menos 6860 recursos e é mais eficiente que o velho tipo hashar do Maxima. 6861 Para obter comportamento consistente em códigos traduzidos e 6862 compilados posicione 'translate_fast_arrays' para ser 'true'. 6863 6864