[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 19. Diferenciação

/Differentiation.texi/1.20/Sat Jun 2 00:12:38 2007/-ko/

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 19.1 Funções e Variáveis Definidas para Diferenciação

Função: antid (expr, x, u(x))

  Retorna uma lista de dois elementos, tais que uma antiderivada de expr com relação a x pode ser constuída a partir da lista. A expressão expr pode conter uma funçã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 relaçã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 função. O pacote `antid` também define as funçõ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 integraçã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
                        /

Função: antidiff (expr, x, u(x))

  Retorna uma antiderivada de expr com relação a x. A expressão expr pode conter uma funçã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 função. O pacote `antid` também define as funçõ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 integraçã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`.

Função: atvalue (expr, [x_1 = a_1, ..., x_m = a_m], c)
Funçã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 função de avaliaçã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 função explicitamente aparecem. n_i é a ordem de diferenciação com relação a x_i.

  O ponto no qual o `atvalue` é estabelecido é dado pela lista de equações `[x_1 = a_1, ..., x_m = a_m]`. Se existe uma variável simples x_1, uma única equação pode ser dada sem ser contida em uma lista.

  `printprops ([f_1, f_2, ...], atvalue)` mostra os `atvalues` das funções `f_1, f_2, ...` como especificado por chamadas a `atvalue`. `printprops (f, atvalue)` mostra os `atvalues` de uma função f. `printprops (all, atvalue)` mostra os `atvalue`s de todas as funções para as quais `atvalue`s são definidos.

  Os simbolos `@1`, `@2`, ... representam as variáveis x_1, x_2, ... quando `atvalue`s 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

Função: cartan -

  O cálculo exterior de formas diferenciais é uma ferramenta básica de geometria diferencial desenvolvida por Elie Cartan e tem importantes aplicações na teoria das equações diferenciais parciais. O pacote `cartan` implementa as funções `ext_diff` e `lie_diff`, juntamente com os operadores `~` (produto da cunha) e `|` (contração de uma forma com um vetor.) Digite `demo (tensor)` para ver uma breve descrição desses comandos juntamente com exemplos.

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

Funçã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)

Função: delta (t)

  A função Delta de Dirac.

  Correntemente somente `laplace` sabe sobre a funçã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 padrã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`.

Funçã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 indiretas 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 funçõ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 opção: derivabbrev

  Valor padrã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 notação de Leibniz `dy/dx`.

Função: derivdegree (expr, y, x)

  Retorna o maior grau de uma derivada da variável dependente y com relaçã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

Função: derivlist (var_1, ..., var_k)

  Causa somente diferenciações com relação às variáveis indicadas, dentro do comando `ev`.

Variável de opção: derivsubst

  Valor padrão: `false`

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

Função: diff (expr, x_1, n_1, ..., x_m, n_m)
Função: diff (expr, x, n)
Função: diff (expr, x)
Função: diff (expr)

  Retorna uma derivada ou diferencial de expr com relação a alguma ou todas as variáveis em expr.

  `diff (expr, x, n)` retorna a n'ésima derivada de expr com relação a x.

  `diff (expr, x_1, n_1, ..., x_m, n_m)` retorna a derivada parcial mista de expr com relaçã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 relação a uma variável x.

  `diff (expr)` retorna a diferencial total de expr, isto é, a soma das derivadas de expr com relação a cada uma de suas variáveis vezes a diferencial `del` de cada variável. Nenhuma simplificação adicional de `del` é oferecida.

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

  Quando `derivabbrev` for `true`, derivadas são mostradas como subscritos. De outra forma, derivadas são mostradas na notaçã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 modificações foram incorporadas:

  (1) As derivadas de quaisquer objetos 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 diferenciação seja concluída com relaçã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 diferenciaçã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 diferenciações indicadas em `expr` são realizdas.

Função: dscalar (f)

  Aplica o d'Alembertiano escalar para a função escalar f.

  `load ("ctensor")` chama essa função.

Funçã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 à função `ev` ou na linha de comando. Nesse contexto, `diff` age como uma `evfun`.

  `load ("vect")` chama essa funçã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]

Função: gradef (f(x_1, ..., x_n), g_1, ..., g_m)
Função: gradef (a, x, expr)

  Define as derivadas parciais (i.e., os componentes do gradiente) da funçã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 função, mas não o nome de uma funçã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 relação a x_1 até x_m somente.

  `gradef (a, x, expr)` define uma derivada de variável a com relaçã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 função ou variável para as quais as derivadas parciais são definidas.

  `gradef` pode redefinir as derivadas de funçõ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 função subscrita.

  `printprops ([f_1, ..., f_n], gradef)` mostra as derivadas parciais das funçõ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 funçõ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 funçã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 padrão: `[]`

  `gradefs` é a lista de funçõ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`.

Função: laplace (expr, t, s)

  Tenta calcular a transformada de Laplace de expr com relação a uma variável t e parâmetro de transformação s. Se `laplace` não pode achar uma solução, um substantivo `'laplace` é retornado.

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

  expr pode também ser uma equaçã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 condições iniciais devem ser especificadas em zero, se um teve condições de limite impostas em qualquer outro lugar ele pode impor essas sobre a solução geral e eliminar as constantes resolvendo a solução geral para essas e substituindo seus valores de volta.

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

  Relações funcionais devem ser explicitamente representadas em expr; relaçõ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

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Setembro, 27 2018 using texi2html 1.76.