@c /Differentiation.texi/1.19/Sun Jun 12 19:13:47 2005/-ko/
@c end concepts Differentiation
@menu
* Definições para Diferenciação::  
@end menu

@node Definições para Diferenciação,  , Diferenciação, Diferenciação
@section Definições para Diferenciação

@deffn {Função} antid (@var{expr}, @var{x}, @var{u(x)}) 
Retorna uma lista de dois elementos,
tais que uma antiderivada de @var{expr} com relação a @var{x}
pode ser constuída a partir da lista.
A expressão @var{expr} pode conter uma função desconhecida @var{u} e suas derivadas.

Tome @var{L}, uma lista de dois elementos, como sendo o valor de retorno de @code{antid}.
Então @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
é uma antiderivada de @var{expr} com relação a @var{x}.

Quando @code{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 @code{antid} não pode fazer nenhum progresso,
o primeiro elemento é zero e o segundo não zero.

@code{load ("antid")} chama essa função.
O pacote @code{antid} também define as funções @code{nonzeroandfreeof} e @code{linear}.

@code{antid} está relacionada a @code{antidiff} como segue.
Tome @var{L}, uma lista de dois elementos, que é o valor de retorno de @code{antid}.
Então o valor de retorno de @code{antidiff} é igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
onde @var{x} é a variável de integração.

Exemplos:
@c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
@c load ("antid")$
@c expr: exp (z(x)) * diff (z(x), x) * y(x);
@c a1: antid (expr, x, z(x));
@c a2: antidiff (expr, x, z(x));
@c a2 - (first (a1) + 'integrate (second (a1), x));
@c antid (expr, x, y(x));
@c antidiff (expr, x, y(x));
@c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
@c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
@c MAYBE MERGE IN THE DEMO PROBLEMS LATER

@example
(%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
                  /
@end example

@end deffn

@deffn {Função} antidiff (@var{expr}, @var{x}, @var{u}(@var{x}))
Retorna uma antiderivada de @var{expr} com relação a @var{x}.
A expressão @var{expr} pode conter uma função desconhecida @var{u} e suas derivadas.

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

@code{load ("antid")} chama essa função.
O pacote @code{antid} também define as funções @code{nonzeroandfreeof} e @code{linear}.

@code{antidiff} é relacionada a @code{antid} como segue.
Tome @var{L}, uma lista de dois elementos, como sendo o valor de retorno de @code{antid}.
Então o valor de retorno de @code{antidiff} é igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
onde @var{x} é a variável de integração.

Exemplos:
@c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
@c load ("antid")$
@c expr: exp (z(x)) * diff (z(x), x) * y(x);
@c a1: antid (expr, x, z(x));
@c a2: antidiff (expr, x, z(x));
@c a2 - (first (a1) + 'integrate (second (a1), x));
@c antid (expr, x, y(x));
@c antidiff (expr, x, y(x));
@c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
@c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
@c MAYBE MERGE IN THE DEMO PROBLEMS LATER

@example
(%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
                  /
@end example

@end deffn

@c I SUSPECT THERE IS MORE TO BE SAID HERE
@defvr propriedade atomgrad

@code{atomgrad} é a propriedade do gradiente at@^omico de uma expressão.
Essa propriedade é atribuída por @code{gradef}.

@c NEED EXAMPLE HERE
@end defvr

@deffn {Função} atvalue (@var{expr}, [@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}], @var{c})
@deffnx {Função} atvalue (@var{expr}, @var{x_1} = @var{a_1}, @var{c})
Atribui o valor @var{c} a @var{expr} no ponto @code{@var{x} = @var{a}}.
Tipicamente valores de extremidade são estabelecidos por esse mecanismo.

@var{expr} é a função de avaliação,
@code{@var{f}(@var{x_1}, ..., @var{x_m})},
ou uma derivada,
@code{diff (@var{f}(@var{x_1}, ..., @var{x_m}), @var{x_1}, @var{n_1}, ..., @var{x_n}, @var{n_m})}
@c HMM, WHAT IS THIS NEXT PHRASE GETTING AT ??
@c DOES IT INTEND TO IMPLY THAT IMPLICIT DEPENDENCIES ARE IGNORED ??
na qual os argumentos da função explicitamente aparecem.
@var{n_i} é a ordem de diferenciação com relação a @var{x_i}.

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

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

Os simbolos @code{@@1}, @code{@@2}, ... representam as 
variáveis @var{x_1}, @var{x_2}, ... quando @code{atvalue}s são mostrados.

@code{atvalue} avalia seus argumentos.
@code{atvalue} retorna @var{c}, o @code{atvalue}.

Exemplos:
@c FOLLOWING ADAPTED FROM example (atvalue)
@c atvalue (f(x,y), [x = 0, y = 1], a^2);
@c atvalue ('diff (f(x,y), x), x = 0, 1 + y);
@c printprops (all, atvalue);
@c diff (4*f(x,y)^2 - u(x,y)^2, x);
@c at (%, [x = 0, y = 1]);

@example
(%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
@end example

@end deffn

@c LOOKS LIKE cartan IS THE NAME OF A PACKAGE AND NOT A FUNCTION OR VARIABLE
@c PROBABLY SHOULD SPLIT OUT cartan AND ITS CONTENTS INTO ITS OWN TEXINFO FILE
@c ext_diff AND lie_diff NOT DOCUMENTED (OTHER THAN HERE)
@deffn {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 @code{cartan}
implementa as funções @code{ext_diff} e @code{lie_diff},
juntamente com os operadores @code{~} (produto da cunha) e @code{|} (contração
de uma forma com um vector.)
Digite @code{demo (tensor)} para ver uma breve
descrição desses comandos juntamente com exemplos.

@code{cartan} foi implementado por F.B. Estabrook e H.D. Wahlquist.

@end deffn

@deffn {Função} del (@var{x})
@code{del (@var{x})} representa a diferencial da variável @math{x}.

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

Exemplos:
@c GENERATED FROM THE FOLLOWING
@c diff (log (x));
@c diff (exp (x*y));
@c diff (x*y*z);

@example
(%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)
@end example

@end deffn

@deffn {Função} delta (@var{t})
A função Delta de Dirac.

Correntemente somente @code{laplace} sabe sobre a função @code{delta}.

Exemplo:

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

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

@end deffn

@defvr {Variável} dependencies
Valor por omissão: @code{[]}

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

Veja @code{depends} e @code{gradef}.

@end defvr

@deffn {Função} depends (@var{f_1}, @var{x_1}, ..., @var{f_n}, @var{x_n})
Declara dependêcias funcionais entre variáveis para o propósito de calcular derivadas.
Na ausência de dependêcias declaradas,
@code{diff (f, x)} retorna zero.
Se @code{depends (f, x)} for declarada,
@code{diff (f, x)} retorna uma derivada simbólica (isto é, um substantivo @code{diff}).

Cada argumento @var{f_1}, @var{x_1}, etc., pode ser o nome de uma variável ou array,
ou uma lista de nomes.
Todo elemento de @var{f_i} (talvez apenas um elemento simples)
é declarado para depender
de todo elemento de @var{x_i} (talvez apenas um elemento simples).
Se algum @var{f_i} for o nome de um array ou contém o nome de um array,
todos os elementos do array dependem de @var{x_i}.

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

@code{remove (@var{f}, dependency)} remove todas as dependências declaradas para @var{f}.

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

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

@c GENERATED BY THE FOLLOWING
@c depends ([f, g], x);
@c depends ([r, s], [u, v, w]);
@c depends (u, t);
@c dependencies;
@c diff (r.s, u);
@example
(%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
@end example

@c GENERATED BY THE FOLLOWING
@c diff (r.s, t);
@example
(%i6) diff (r.s, t);
                      dr du           ds du
(%o6)                 -- -- . s + r . -- --
                      du dt           du dt
@end example

@c GENERATED BY THE FOLLOWING
@c remove (r, dependency);
@c diff (r.s, t);
@example
(%i7) remove (r, dependency);
(%o7)                         done
(%i8) diff (r.s, t);
                                ds du
(%o8)                       r . -- --
                                du dt
@end example

@end deffn

@defvr {Variável de opção} derivabbrev
Valor por omissão: @code{false}

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

@c NEED EXAMPLES HERE
@end defvr

@c SEEMS LIKE THIS STATEMENT COULD BE LESS CLUMSY
@deffn {Função} derivdegree (@var{expr}, @var{y}, @var{x})
Retorna o maior grau de uma derivada
da variável dependente @var{y} com relação à variável independente
@var{x} ocorrendo em @var{expr}.

Exemplo:
@c GENERATED FROM THE FOLLOWING
@c 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
@c derivdegree (%, y, x);
@example
(%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
@end example

@end deffn

@c I HAVE NO IDEA WHAT THIS DOES
@deffn {Função} derivlist (@var{var_1}, ..., @var{var_k})
Causa somente diferenciações com relação às
variáveis indicadas, dentro do comando @code{ev}.

@end deffn

@defvr {Variável de opção} derivsubst
Valor por omissão: @code{false}

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

@end defvr

@deffn {Função} diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})
@deffnx {Função} diff (@var{expr}, @var{x}, @var{n})
@deffnx {Função} diff (@var{expr}, @var{x})
@deffnx {Função} diff (@var{expr})
Retorna uma derivada ou diferencial de @var{expr} com relação a alguma ou todas as variáveis em @var{expr}.

@code{diff (@var{expr}, @var{x}, @var{n})} retorna a @var{n}'ésima derivada de @var{expr}
com relação a @var{x}.

@code{diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})}
retorna a derivada parcial mista de @var{expr} com relação a @var{x_1}, ..., @var{x_m}.
Isso é equivalente a @code{diff (... (diff (@var{expr}, @var{x_m}, @var{n_m}) ...), @var{x_1}, @var{n_1})}.

@code{diff (@var{expr}, @var{x})}
retorna a primeira derivada de @var{expr} com relação a
uma variável @var{x}.

@code{diff (@var{expr})} retorna a diferencial total de @var{expr},
isto é, a soma das derivadas de @var{expr} com relação a cada uma de suas variáveis
vezes a diferencial @code{del} de cada variável.
@c WHAT DOES THIS NEXT STATEMENT MEAN, EXACTLY ??
Nenhuma simplificação adicional de @code{del} é oferecida.

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

Quando @code{derivabbrev} for @code{true}, derivadas são mostradas como subscritos.
De outra forma, derivadas são mostradas na notação de Leibniz, @code{dy/dx}.

Exemplos:
@c GENERATED FROM THE FOLLOWING
@c diff (exp (f(x)), x, 2);
@c derivabbrev: true$
@c 'integrate (f(x, y), y, g(x), h(x));
@c diff (%, x);

@example
(%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)
@end example

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

(1) As derivadas de quaisquer objectos indexados em @var{expr} terão as
variáveis @var{x_i} anexadas como argumentos adicionais.  Então todos os
índices de derivada serão ordenados.

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

@c NEED EXAMPLES FOR TENSOR STUFF
@end deffn

@c MERGE THIS INTO @defun diff
@defvr {Símbolo especial} diff

Quando @code{diff} está presente como um @code{evflag} em chamadas para @code{ev},
Todas as diferenciações indicadas em @code{expr} são realizdas.

@c NEED EXAMPLE HERE
@end defvr

@c NOT SURE HOW THIS IS SUPPOSED TO WORK
@deffn {Função} dscalar (@var{f})
Aplica o d'Alembertiano escalar para a função escalar @var{f}.

@c APPARENTLY dscalar DOESN'T EXIST IN THE CORE FILES ANYMORE
@c ctensor HAS THE ONLY DEFN I FOUND (OUTSIDE OF archive/)
@code{load ("ctensor")} chama essa função.

@c FOLLOWING EXAMPLE DOESN'T WORK; I GET dscalar (field) ==> 0
@c (I GET 0 FOR THE ctensor VERSION OF dscalar, AND SAME FOR
@c THE DEFN OF dscalar GIVEN IN archive/share/lisp/ctensr.trl)
@c INCIDENTALLY dependencies IS DOCUMENTED ONLY AS A VARIABLE

@c @example
@c (%i41) dependencies(field(r));
@c (%o41)                           [field(r)]
@c (%i42) dscalar(field);
@c (%o43)
@c     -m
@c   %e  ((field  n - field  m + 2 field   ) r + 4 field )
@c              r  r       r  r         r r             r
@c 
@c - -----------------------------------------------------
@c                              2 r
@c @end example

@end deffn

@deffn {Função} express (@var{expr})
@c HERE IS THE PREVIOUS TEXT. WHAT IS THE POINT ABOUT depends ?? I'M NOT GETTING IT
@c The result uses the noun form of any
@c derivadas arising from expansion of the vector differential
@c operators.  To force evaluation of these derivadas, the built-in @code{ev}
@c função can be used together with the @code{diff} evflag, after using the
@c built-in @code{depends} função to establish any new implicit dependências.

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

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

@code{load ("vect")} chama essa função.
@c IN POINT OF FACT, express IS A SIMPLIFICATION RULE, AND express1 IS THE FCN WHICH DOES ALL THE WORK

Exemplos:
@c GENERATED FROM THE FOLLOWING
@c load ("vect")$
@c grad (x^2 + y^2 + z^2);
@c express (%);
@c ev (%, diff);
@c div ([x^2, y^2, z^2]);
@c express (%);
@c ev (%, diff);
@c curl ([x^2, y^2, z^2]);
@c express (%);
@c ev (%, diff);
@c laplacian (x^2 * y^2 * z^2);
@c express (%);
@c ev (%, diff);
@c [a, b, c] ~ [x, y, z];
@c express (%);

@example
(%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]
@end example

@end deffn

@c COMMENTING OUT THIS TEXT PENDING RESOLUTION OF BUG REPORT # 836704:
@c "gendiff is all bugs: should be deprecated"
@c @defun gendiff
@c Sometimes @code{diff(e,x,n)} can be reduced even though N is
@c symbolic.
@c 
@c @example
@c batch("gendif")$
@c @end example
@c 
@c and you can try, for example,
@c 
@c @example
@c diff(%e^(a*x),x,q)
@c @end example
@c 
@c by using @code{gendiff} rather than @code{diff}.  Unevaluable
@c items come out quoted.  Some items are in terms of @code{genfact}, which
@c see.
@c
@c @end defun

@deffn {Função} gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})
@deffnx {Função} gradef (@var{a}, @var{x}, @var{expr})
Define as derivadas parciais (i.e., os componentes do gradiente) da função @var{f}
ou variável @var{a}.

@code{gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})}
define @code{d@var{f}/d@var{x_i}} como @var{g_i}, 
onde @var{g_i} é uma expressão; @var{g_i} pode ser uma chamada de função, mas não o nome de uma função.
O número de derivadas parciais @var{m} pode ser menor que o número de argumentos @var{n},
nesses casos derivadas são definidas com relação a @var{x_1} até @var{x_m} somente.

@code{gradef (@var{a}, @var{x}, @var{expr})} define uma derivada de variável @var{a}
com relação a @var{x} como @var{expr}.
Isso também estabelece a dependência de @var{a} sobre @var{x} (via @code{depends (@var{a}, @var{x})}).

O primeiro argumento @code{@var{f}(@var{x_1}, ..., @var{x_n})} ou @var{a} é acompanhado de apóstrofo,
mas os argumentos restantes @var{g_1}, ..., @var{g_m} são avaliados.
@code{gradef} retorna a função ou variável para as quais as derivadas parciais são definidas.

@code{gradef} pode redefinir as derivadas de funções internas do Maxima.
Por exemplo, @code{gradef (sin(x), sqrt (1 - sin(x)^2))} redefine uma derivada de @code{sin}.

@code{gradef} não pode definir derivadas parciais para um função subscrita.

@code{printprops ([@var{f_1}, ..., @var{f_n}], gradef)} mostra as derivadas parciais
das funções @var{f_1}, ..., @var{f_n}, como definidas por @code{gradef}.

@code{printprops ([@var{a_n}, ..., @var{a_n}], atomgrad)} mostra as derivadas parciais
das variáveis @var{a_n}, ..., @var{a_n}, como definidas por @code{gradef}.

@code{gradefs} é a lista de funções
para as quais derivadas parciais foram definidas por @code{gradef}.
@code{gradefs} não inclui quaisquer variáveis
para quais derivadas parciais foram definidas por @code{gradef}.

@c REPHRASE THIS NEXT BIT
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.

@c NEED EXAMPLES HERE
@end deffn

@defvr {Variável de sistema} gradefs
Valor por omissão: @code{[]}

@code{gradefs} é a lista de funções
para as quais derivadas parciais foram definidas por @code{gradef}.
@code{gradefs} não inclui quaisquer variáveis
para as quais derivadas parciais foram deinidas por @code{gradef}.

@end defvr

@deffn {Função} laplace (@var{expr}, @var{t}, @var{s})
Tenta calcular a transformada de Laplace de @var{expr} com relação a uma variável @var{t}
e parâmetro de transformação @var{s}.
Se @code{laplace} não pode achar uma solução, um substantivo @code{'laplace} é retornado.

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

@c REPHRASE THIS
@var{expr} pode também ser uma equação linear, diferencial de coeficiente contante no
qual caso o @code{atvalue} da variável dependente é usado.
@c "used" -- USED HOW ??
O requerido @code{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.

@code{laplace} reconhece integrais de convolução da forma
@code{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 @var{expr};
relações implícitas, estabelecidas por @code{depends}, não são reconhecidas.
Isto é, se @var{f} depende de @var{x} e @var{y},
@code{f (x, y)} deve aparecer em @var{expr}.

Veja também @code{ilt}, a transformada inversa de Laplace.

Exemplos:
@c GENERATED FROM THE FOLLOWING:
@c laplace (exp (2*t + a) * sin(t) * t, t, s);
@c laplace ('diff (f (x), x), x, s);
@c diff (diff (delta (t), t), t);
@c laplace (%, t, s);

@example
(%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
@end example

@end deffn

