Definicedilhaões para Diferenciacedilhaão
=========================================

 -- Funcedilhaão: antid (EXPR, X, U(X))
     Retorna uma lista de dois elementos, tais que uma antiderivada de EXPR com relacedilhaão a X pode ser constuída a partir da lista. A expressão EXPR pode conter uma funcedilhaão desconhecida U e suas derivadas.

     Tome L, uma lista de dois elementos, como sendo o valor de retorno de antid. Então L[1] + 'integrate (L[2], X) é uma antiderivada de EXPR com relacedilhaão a X.

     Quando antid obtém sucesso inteiramente, o segundo elemento do valor de retorno é zero. De outra forma, o segundo elemento é não zero, e o primeiro elemento não zero ou zero. Se antid não pode fazer nenhum progresso, o primeiro elemento é zero e o segundo não zero.

     load ("antid") chama essa funcedilhaão. O pacote antid também define as funcedilhaões nonzeroandfreeof e linear.

     antid está relacionada a antidiff como segue. Tome L, uma lista de dois elementos, que é o valor de retorno de antid. Então o valor de retorno de antidiff é igual a L[1] + 'integrate (L[2], X) onde X é a variável de integracedilhaão.

     Exemplos:

          (%i1) load ("antid")$
          (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                      z(x)  d
          (%o2)                y(x) %e     (-- (z(x)))
                                            dx
          (%i3) a1: antid (expr, x, z(x));
                                 z(x)      z(x)  d
          (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                                 dx
          (%i4) a2: antidiff (expr, x, z(x));
                                      /
                               z(x)   [   z(x)  d
          (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                      ]         dx
                                      /
          (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
          (%o5)                           0
          (%i6) antid (expr, x, y(x));
                                       z(x)  d
          (%o6)             [0, y(x) %e     (-- (z(x)))]
                                             dx
          (%i7) antidiff (expr, x, y(x));
                            /
                            [        z(x)  d
          (%o7)             I y(x) %e     (-- (z(x))) dx
                            ]              dx
                            /

 -- Funcedilhaão: antidiff (EXPR, X, U(X))
     Retorna uma antiderivada de EXPR com relacedilhaão a X. A expressão EXPR pode conter uma funcedilhaão desconhecida U e suas derivadas.

     Quando antidiff obtém sucesso inteiramente, a expressão resultante é livre do sinal de integral (isto é, livre do substantivo integrate). De outra forma, antidiff retorna uma expressão que é parcialmente ou inteiramente dentro de um sinal de um sinal de integral. Se antidiff não pode fazer qualquer progresso, o valor de retorno é inteiramente dentro de um sinal de integral.

     load ("antid") chama essa funcedilhaão. O pacote antid também define as funcedilhaões nonzeroandfreeof e linear.

     antidiff é relacionada a antid como segue. Tome L, uma lista de dois elementos, como sendo o valor de retorno de antid. Então o valor de retorno de antidiff é igual a L[1] + 'integrate (L[2], X) onde X é a variável de integracedilhaão.

     Exemplos:

          (%i1) load ("antid")$
          (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                      z(x)  d
          (%o2)                y(x) %e     (-- (z(x)))
                                            dx
          (%i3) a1: antid (expr, x, z(x));
                                 z(x)      z(x)  d
          (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                                 dx
          (%i4) a2: antidiff (expr, x, z(x));
                                      /
                               z(x)   [   z(x)  d
          (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                      ]         dx
                                      /
          (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
          (%o5)                           0
          (%i6) antid (expr, x, y(x));
                                       z(x)  d
          (%o6)             [0, y(x) %e     (-- (z(x)))]
                                             dx
          (%i7) antidiff (expr, x, y(x));
                            /
                            [        z(x)  d
          (%o7)             I y(x) %e     (-- (z(x))) dx
                            ]              dx
                            /

 -- propriedade: atomgrad

     atomgrad é a propriedade do gradiente atômico de uma expressão. Essa propriedade é atribuída por gradef.

 -- Funcedilhaão: atvalue (EXPR, [X_1 = A_1, ..., X_M = A_M], C)
 -- Funcedilhaão: atvalue (EXPR, X_1 = A_1, C)
     Atribui o valor C a EXPR no ponto X = A. Tipicamente valores de extremidade são estabelecidos por esse mecanismo.

     EXPR é a funcedilhaão de avaliacedilhaão, F(X_1, ..., X_M), ou uma derivada, diff (F(X_1, ..., X_M), X_1, N_1, ..., X_N, N_M) na qual os argumentos da funcedilhaão explicitamente aparecem. N_I é a ordem de diferenciacedilhaão com relacedilhaão a X_I.

     O ponto no qual o atvalue é estabelecido é dado pela lista de equacedilhaões [X_1 = A_1, ..., X_M = A_M]. Se existe uma variável simples X_1, uma única equacedilhaão pode ser dada sem ser contida em uma lista.

     printprops ([F_1, F_2, ...], atvalue) mostra os atvalues das funcedilhaões F_1, F_2, ... como especificado por chamadas a atvalue. printprops (F, atvalue) mostra os atvalues de uma funcedilhaão F. printprops (all, atvalue) mostra os atvalues de todas as funcedilhaões para as quais atvalues são definidos.

     Os simbolos @1, @2, ... representam as variáveis X_1, X_2, ... quando atvalues são mostrados.

     atvalue avalia seus argumentos. atvalue retorna C, o atvalue.

     Exemplos:

          (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                          2
          (%o1)                          a
          (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
          (%o2)                        @2 + 1
          (%i3) printprops (all, atvalue);
                                          !
                            d             !
                           --- (f(@1, @2))!       = @2 + 1
                           d@1            !
                                          !@1 = 0

                                               2
                                    f(0, 1) = a

          (%o3)                         done
          (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
                            d                          d
          (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                            dx                         dx
          (%i5) at (%, [x = 0, y = 1]);
                                                   !
                        2              d           !
          (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                       dx          !
                                                   !x = 0, y = 1

 -- Funcedilhaão: cartan -
     O cálculo exterior de formas diferenciais é uma ferramenta básica de geometria diferencial desenvolvida por Elie Cartan e tem importantes aplicacedilhaões na teoria das equacedilhaões diferenciais parciais. O pacote cartan implementa as funcedilhaões ext_diff e lie_diff, juntamente com os operadores ~ (produto da cunha) e | (contracedilhaão de uma forma com um vector.) Digite demo (tensor) para ver uma breve descricedilhaão desses comandos juntamente com exemplos.

     cartan foi implementado por F.B. Estabrook e H.D. Wahlquist.

 -- Funcedilhaão: del (X)
     del (X) representa a diferencial da variável x.

     diff retorna uma expressão contendo del se uma variável independente não for especificada. Nesse caso, o valor de retorno é a então chamada "diferencial total".

     Exemplos:

          (%i1) diff (log (x));
                                       del(x)
          (%o1)                        ------
                                         x
          (%i2) diff (exp (x*y));
                               x y              x y
          (%o2)            x %e    del(y) + y %e    del(x)
          (%i3) diff (x*y*z);
          (%o3)         x y del(z) + x z del(y) + y z del(x)

 -- Funcedilhaão: delta (T)
     A funcedilhaão Delta de Dirac.

     Correntemente somente laplace sabe sobre a funcedilhaão delta.

     Exemplo:

          (%i1) laplace (delta (t - a) * sin(b*t), t, s);
          Is  a  positive, negative, or zero?

          p;
                                             - a s
          (%o1)                   sin(a b) %e

 -- Variável: dependencies
     Valor por omissão: []

     dependencies é a lista de átomos que possuem dependências funcionais, atribuídas por depends ou gradef. A lista dependencies é cumulativa: cada chamada a depends ou a gradef anexa ítens adicionais.

     Veja depends e gradef.

 -- Funcedilhaão: depends (F_1, X_1, ..., F_N, X_N)
     Declara dependêcias funcionais entre variáveis para o propósito de calcular derivadas. Na ausência de dependêcias declaradas, diff (f, x) retorna zero. Se depends (f, x) for declarada, diff (f, x) retorna uma derivada simbólica (isto é, um substantivo diff).

     Cada argumento F_1, X_1, etc., pode ser o nome de uma variável ou array, ou uma lista de nomes. Todo elemento de F_I (talvez apenas um elemento simples) é declarado para depender de todo elemento de X_I (talvez apenas um elemento simples). Se algum F_I for o nome de um array ou contém o nome de um array, todos os elementos do array dependem de X_I.

     diff reconhece dependências indirectas estabelecidas por depends e aplica a regra da cadeia nesses casos.

     remove (F, dependency) remove todas as dependências declaradas para F.

     depends retorna uma lista de dependências estabelecidas. As dependências são anexadas à variável global dependencies. depends avalia seus argumentos.

     diff é o único comando Maxima que reconhece dependências estabelecidas por depends. Outras funcedilhaões (integrate, laplace, etc.) somente reconhecem dependências explicitamente representadas por seus argumentos. Por exemplo, integrate não reconhece a dependência de f sobre x a menos que explicitamente representada como integrate (f(x), x).

          (%i1) depends ([f, g], x);
          (%o1)                     [f(x), g(x)]
          (%i2) depends ([r, s], [u, v, w]);
          (%o2)               [r(u, v, w), s(u, v, w)]
          (%i3) depends (u, t);
          (%o3)                        [u(t)]
          (%i4) dependencies;
          (%o4)      [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
          (%i5) diff (r.s, u);
                                   dr           ds
          (%o5)                    -- . s + r . --
                                   du           du

          (%i6) diff (r.s, t);
                                dr du           ds du
          (%o6)                 -- -- . s + r . -- --
                                du dt           du dt

          (%i7) remove (r, dependency);
          (%o7)                         done
          (%i8) diff (r.s, t);
                                          ds du
          (%o8)                       r . -- --
                                          du dt

 -- Variável de opcedilhaão: derivabbrev
     Valor por omissão: false

     Quando derivabbrev for true, derivadas simbólicas (isto é, substantivos diff) são mostradas como subscritos. De outra forma, derivadas são mostradas na notacedilhaão de Leibniz dy/dx.

 -- Funcedilhaão: derivdegree (EXPR, Y, X)
     Retorna o maior grau de uma derivada da variável dependente Y com relacedilhaão à variável independente X ocorrendo em EXPR.

     Exemplo:

          (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
                                   3     2
                                  d y   d y    2 dy
          (%o1)                   --- + --- + x  --
                                    3     2      dx
                                  dz    dx
          (%i2) derivdegree (%, y, x);
          (%o2)                           2

 -- Funcedilhaão: derivlist (VAR_1, ..., VAR_K)
     Causa somente diferenciacedilhaões com relacedilhaão às variáveis indicadas, dentro do comando ev.

 -- Variável de opcedilhaão: derivsubst
     Valor por omissão: false

     Quando derivsubst for true, uma substiruícedilhaão não sintática tais como subst (x, 'diff (y, t), 'diff (y, t, 2)) retorna 'diff (x, t).

 -- Funcedilhaão: diff (EXPR, X_1, N_1, ..., X_M, N_M)
 -- Funcedilhaão: diff (EXPR, X, N)
 -- Funcedilhaão: diff (EXPR, X)
 -- Funcedilhaão: diff (EXPR)
     Retorna uma derivada ou diferencial de EXPR com relacedilhaão a alguma ou todas as variáveis em EXPR.

     diff (EXPR, X, N) retorna a N'ésima derivada de EXPR com relacedilhaão a X.

     diff (EXPR, X_1, N_1, ..., X_M, N_M) retorna a derivada parcial mista de EXPR com relacedilhaão a X_1, ..., X_M. Isso é equivalente a diff (... (diff (EXPR, X_M, N_M) ...), X_1, N_1).

     diff (EXPR, X) retorna a primeira derivada de EXPR com relacedilhaão a uma variável X.

     diff (EXPR) retorna a diferencial total de EXPR, isto é, a soma das derivadas de EXPR com relacedilhaão a cada uma de suas variáveis vezes a diferencial del de cada variável. Nenhuma simplificacedilhaão adicional de del é oferecida.

     A forma substantiva de diff é requerida em alguns contextos, tal como declarando uma equacedilhaão diferencial. Nesses casos, diff pode ser colocado apóstrofo (com 'diff) para retornar a forma substantiva em lugar da realizacedilhaão da diferenciacedilhaão.

     Quando derivabbrev for true, derivadas são mostradas como subscritos. De outra forma, derivadas são mostradas na notacedilhaão de Leibniz, dy/dx.

     Exemplos:

          (%i1) diff (exp (f(x)), x, 2);
                               2
                        f(x)  d               f(x)  d         2
          (%o1)       %e     (--- (f(x))) + %e     (-- (f(x)))
                                2                   dx
                              dx
          (%i2) derivabbrev: true$
          (%i3) 'integrate (f(x, y), y, g(x), h(x));
                                   h(x)
                                  /
                                  [
          (%o3)                   I     f(x, y) dy
                                  ]
                                  /
                                   g(x)
          (%i4) diff (%, x);
                 h(x)
                /
                [
          (%o4) I     f(x, y)  dy + f(x, h(x)) h(x)  - f(x, g(x)) g(x)
                ]            x                     x                  x
                /
                 g(x)

     Para o pacote tensor, as seguintes modificacedilhaões foram incorporadas:

     (1) As derivadas de quaisquer objectos indexados em EXPR terão as variáveis X_I anexadas como argumentos adicionais.  Então todos os índices de derivada serão ordenados.

     (2) As variáveis X_I podem ser inteiros de 1 até o valor de uma variável dimension [valor padrão: 4].  Isso fará com que a diferenciacedilhaão seja concluída com relacedilhaão aos X_I'ésimos membros da lista coordinates que pode ser escolhida para uma lista de nomes de coordenadas, e.g., [x, y, z, t]. Se coordinates for associada a uma variável atômica, então aquela variável subscrita por X_I será usada para uma variável de diferenciacedilhaão.  Isso permite um array de nomes de coordenadas ou nomes subscritos como X[1], X[2], ... sejam usados.  Se coordinates não foram atribuídas um valor, então as variáveis seram tratadas como em (1) acima.

 -- Símbolo especial: diff

     Quando diff está presente como um evflag em chamadas para ev, Todas as diferenciacedilhaões indicadas em expr são realizdas.

 -- Funcedilhaão: dscalar (F)
     Aplica o d'Alembertiano escalar para a funcedilhaão escalar F.

     load ("ctensor") chama essa funcedilhaão.

 -- Funcedilhaão: express (EXPR)

     Expande o substantivo do operador diferencial em expressões em termos de derivadas parciais. express reconhece os operadores grad, div, curl, laplacian. express também expande o produto do X ~.

     Derivadas simbólicas (isto é, substantivos diff) no valor de retorno de express podem ser avaliadas incluíndo diff na chamada à funcedilhaão ev ou na linha de comando. Nesse contexto, diff age como uma evfun.

     load ("vect") chama essa funcedilhaão.

     Exemplos:

          (%i1) load ("vect")$
          (%i2) grad (x^2 + y^2 + z^2);
                                        2    2    2
          (%o2)                  grad (z  + y  + x )
          (%i3) express (%);
                 d    2    2    2   d    2    2    2   d    2    2    2
          (%o3) [-- (z  + y  + x ), -- (z  + y  + x ), -- (z  + y  + x )]
                 dx                 dy                 dz
          (%i4) ev (%, diff);
          (%o4)                    [2 x, 2 y, 2 z]
          (%i5) div ([x^2, y^2, z^2]);
                                        2   2   2
          (%o5)                   div [x , y , z ]
          (%i6) express (%);
                             d    2    d    2    d    2
          (%o6)              -- (z ) + -- (y ) + -- (x )
                             dz        dy        dx
          (%i7) ev (%, diff);
          (%o7)                    2 z + 2 y + 2 x
          (%i8) curl ([x^2, y^2, z^2]);
                                         2   2   2
          (%o8)                   curl [x , y , z ]
          (%i9) express (%);
                 d    2    d    2   d    2    d    2   d    2    d    2
          (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
                 dy        dz       dz        dx       dx        dy
          (%i10) ev (%, diff);
          (%o10)                      [0, 0, 0]
          (%i11) laplacian (x^2 * y^2 * z^2);
                                            2  2  2
          (%o11)                laplacian (x  y  z )
          (%i12) express (%);
                   2                2                2
                  d     2  2  2    d     2  2  2    d     2  2  2
          (%o12)  --- (x  y  z ) + --- (x  y  z ) + --- (x  y  z )
                    2                2                2
                  dz               dy               dx
          (%i13) ev (%, diff);
                                2  2      2  2      2  2
          (%o13)             2 y  z  + 2 x  z  + 2 x  y
          (%i14) [a, b, c] ~ [x, y, z];
          (%o14)                [a, b, c] ~ [x, y, z]
          (%i15) express (%);
          (%o15)          [b z - c y, c x - a z, a y - b x]

 -- Funcedilhaão: gradef (F(X_1, ..., X_N), G_1, ..., G_M)
 -- Funcedilhaão: gradef (A, X, EXPR)
     Define as derivadas parciais (i.e., os componentes do gradiente) da funcedilhaão F ou variável A.

     gradef (F(X_1, ..., X_N), G_1, ..., G_M) define dF/dX_I como G_I, onde G_I é uma expressão; G_I pode ser uma chamada de funcedilhaão, mas não o nome de uma funcedilhaão. O número de derivadas parciais M pode ser menor que o número de argumentos N, nesses casos derivadas são definidas com relacedilhaão a X_1 até X_M somente.

     gradef (A, X, EXPR) define uma derivada de variável A com relacedilhaão a X como EXPR. Isso também estabelece a dependência de A sobre X (via depends (A, X)).

     O primeiro argumento F(X_1, ..., X_N) ou A é acompanhado de apóstrofo, mas os argumentos restantes G_1, ..., G_M são avaliados. gradef retorna a funcedilhaão ou variável para as quais as derivadas parciais são definidas.

     gradef pode redefinir as derivadas de funcedilhaões internas do Maxima. Por exemplo, gradef (sin(x), sqrt (1 - sin(x)^2)) redefine uma derivada de sin.

     gradef não pode definir derivadas parciais para um funcedilhaão subscrita.

     printprops ([F_1, ..., F_N], gradef) mostra as derivadas parciais das funcedilhaões F_1, ..., F_N, como definidas por gradef.

     printprops ([A_N, ..., A_N], atomgrad) mostra as derivadas parciais das variáveis A_N, ..., A_N, como definidas por gradef.

     gradefs é a lista de funcedilhaões para as quais derivadas parciais foram definidas por gradef. gradefs não inclui quaisquer variáveis para quais derivadas parciais foram definidas por gradef.

     Gradientes são necessários quando, por exemplo, uma funcedilhaão não é conhecida explicitamente mas suas derivadas primeiras são e isso é desejado para obter derivadas de ordem superior.

 -- Variável de sistema: gradefs
     Valor por omissão: []

     gradefs é a lista de funcedilhaões para as quais derivadas parciais foram definidas por gradef. gradefs não inclui quaisquer variáveis para as quais derivadas parciais foram deinidas por gradef.

 -- Funcedilhaão: laplace (EXPR, T, S)
     Tenta calcular a transformada de Laplace de EXPR com relacedilhaão a uma variável T e parâmetro de transformacedilhaão S. Se laplace não pode achar uma solucedilhaão, um substantivo 'laplace é retornado.

     laplace reconhece em EXPR as funcedilhaões delta, exp, log, sin, cos, sinh, cosh, e erf, também derivative, integrate, sum, e ilt. Se algumas outras funcedilhaões estiverem presente, laplace pode não ser habilitada a calcular a tranformada.

     EXPR pode também ser uma equacedilhaão linear, diferencial de coeficiente contante no qual caso o atvalue da variável dependente é usado. O requerido atvalue pode ser fornecido ou antes ou depois da transformada ser calculada. Uma vez que as condicedilhaões iniciais devem ser especificadas em zero, se um teve condicedilhaões de limite impostas em qualquer outro lugar ele pode impor essas sobre a solucedilhaão geral e eliminar as constantes resolvendo a solucedilhaão geral para essas e substituindo seus valores de volta.

     laplace reconhece integrais de convolucedilhaão da forma integrate (f(x) * g(t - x), x, 0, t); outros tipos de convolucedilhaões não são reconhecidos.

     Relacedilhaões funcionais devem ser explicitamente representadas em EXPR; relacedilhaões implícitas, estabelecidas por depends, não são reconhecidas. Isto é, se F depende de X e Y, f (x, y) deve aparecer em EXPR.

     Veja também ilt, a transformada inversa de Laplace.

     Exemplos:

          (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
                                      a
                                    %e  (2 s - 4)
          (%o1)                    ---------------
                                     2           2
                                   (s  - 4 s + 5)
          (%i2) laplace ('diff (f (x), x), x, s);
          (%o2)             s laplace(f(x), x, s) - f(0)
          (%i3) diff (diff (delta (t), t), t);
                                    2
                                   d
          (%o3)                    --- (delta(t))
                                     2
                                   dt
          (%i4) laplace (%, t, s);
                                      !
                         d            !         2
          (%o4)        - -- (delta(t))!      + s  - delta(0) s
                         dt           !
                                      !t = 0