/Differentiation.texi/1.20/Sat Jun  2 00:12:38 2007/-ko/
@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Differentiation.texi/1.20/Sat Jun  2 00:12:38 2007/-ko/
@c end concepts Differentiation
@menu
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Diferencia@value{cedilha}@~{a}o::  
@end menu

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Diferencia@value{cedilha}@~{a}o,  , Diferencia@value{cedilha}@~{a}o, Diferencia@value{cedilha}@~{a}o
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Diferencia@value{cedilha}@~{a}o

@deffn {Fun@value{cedilha}@~{a}o} antid (@var{expr}, @var{x}, @var{u(x)}) 
Retorna uma lista de dois elementos,
tais que uma antiderivada de @var{expr} com rela@value{cedilha}@~{a}o a @var{x}
pode ser constu@'{i}da a partir da lista.
A express@~{a}o @var{expr} pode conter uma fun@value{cedilha}@~{a}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@~{a}o @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
@'{e} uma antiderivada de @var{expr} com rela@value{cedilha}@~{a}o a @var{x}.

Quando @code{antid} obt@'{e}m sucesso inteiramente,
o segundo elemento do valor de retorno @'{e} zero.
De outra forma, o segundo elemento @'{e} n@~{a}o zero,
e o primeiro elemento n@~{a}o zero ou zero.
Se @code{antid} n@~{a}o pode fazer nenhum progresso,
o primeiro elemento @'{e} zero e o segundo n@~{a}o zero.

@code{load ("antid")} chama essa fun@value{cedilha}@~{a}o.
O pacote @code{antid} tamb@'{e}m define as fun@value{cedilha}@~{o}es @code{nonzeroandfreeof} e @code{linear}.

@code{antid} est@'{a} relacionada a @code{antidiff} como segue.
Tome @var{L}, uma lista de dois elementos, que @'{e} o valor de retorno de @code{antid}.
Ent@~{a}o o valor de retorno de @code{antidiff} @'{e} igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
onde @var{x} @'{e} a vari@'{a}vel de integra@value{cedilha}@~{a}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@value{cedilha}@~{a}o} antidiff (@var{expr}, @var{x}, @var{u}(@var{x}))
Retorna uma antiderivada de @var{expr} com rela@value{cedilha}@~{a}o a @var{x}.
A express@~{a}o @var{expr} pode conter uma fun@value{cedilha}@~{a}o desconhecida @var{u} e suas derivadas.

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

@code{load ("antid")} chama essa fun@value{cedilha}@~{a}o.
O pacote @code{antid} tamb@'{e}m define as fun@value{cedilha}@~{o}es @code{nonzeroandfreeof} e @code{linear}.

@code{antidiff} @'{e} relacionada a @code{antid} como segue.
Tome @var{L}, uma lista de dois elementos, como sendo o valor de retorno de @code{antid}.
Ent@~{a}o o valor de retorno de @code{antidiff} @'{e} igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
onde @var{x} @'{e} a vari@'{a}vel de integra@value{cedilha}@~{a}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} @'{e} a propriedade do gradiente at@^{o}mico de uma express@~{a}o.
Essa propriedade @'{e} atribu@'{i}da por @code{gradef}.

@c NEED EXAMPLE HERE
@end defvr

@deffn {Fun@value{cedilha}@~{a}o} atvalue (@var{expr}, [@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}], @var{c})
@deffnx {Fun@value{cedilha}@~{a}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@~{a}o estabelecidos por esse mecanismo.

@var{expr} @'{e} a fun@value{cedilha}@~{a}o de avalia@value{cedilha}@~{a}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@value{cedilha}@~{a}o explicitamente aparecem.
@var{n_i} @'{e} a ordem de diferencia@value{cedilha}@~{a}o com rela@value{cedilha}@~{a}o a @var{x_i}.

O ponto no qual o @code{atvalue} @'{e} estabelecido @'{e} dado pela lista de equa@value{cedilha}@~{o}es
@code{[@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}]}.
Se existe uma vari@'{a}vel simples @var{x_1},
uma @'{u}nica equa@value{cedilha}@~{a}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@value{cedilha}@~{o}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@value{cedilha}@~{a}o @var{f}.
@code{printprops (all, atvalue)} mostra os @code{atvalue}s de todas as fun@value{cedilha}@~{o}es para as quais @code{atvalue}s s@~{a}o definidos.

Os simbolos @code{@@1}, @code{@@2}, ... representam as 
vari@'{a}veis @var{x_1}, @var{x_2}, ... quando @code{atvalue}s s@~{a}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@value{cedilha}@~{a}o} cartan  -
O c@'{a}lculo exterior de formas diferenciais @'{e} uma ferramenta b@'{a}sica
de geometria diferencial desenvolvida por Elie Cartan e tem importantes
aplica@value{cedilha}@~{o}es na teoria das equa@value{cedilha}@~{o}es diferenciais parciais.
O pacote @code{cartan}
implementa as fun@value{cedilha}@~{o}es @code{ext_diff} e @code{lie_diff},
juntamente com os operadores @code{~} (produto da cunha) e @code{|} (contra@value{cedilha}@~{a}o
de uma forma com um vetor.)
Digite @code{demo (tensor)} para ver uma breve
descri@value{cedilha}@~{a}o desses comandos juntamente com exemplos.

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

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} del (@var{x})
@code{del (@var{x})} representa a diferencial da vari@'{a}vel @math{x}.

@code{diff} retorna uma express@~{a}o contendo @code{del}
se uma vari@'{a}vel independente n@~{a}o for especificada.
Nesse caso, o valor de retorno @'{e} a ent@~{a}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@value{cedilha}@~{a}o} delta (@var{t})
A fun@value{cedilha}@~{a}o Delta de Dirac.

Correntemente somente @code{laplace} sabe sobre a fun@value{cedilha}@~{a}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@'{a}vel} dependencies
Valor padr@~{a}o: @code{[]}

@code{dependencies} @'{e} a lista de @'{a}tomos que possuem depend@^{e}ncias
funcionais, atribu@'{i}das por @code{depends} ou @code{gradef}.
A lista @code{dependencies} @'{e} cumulativa:
cada chamada a @code{depends} ou a @code{gradef} anexa @'{i}tens adicionais.

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

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} depends (@var{f_1}, @var{x_1}, ..., @var{f_n}, @var{x_n})
Declara depend@^{e}cias funcionais entre vari@'{a}veis para o prop@'{o}sito de calcular derivadas.
Na aus@^{e}ncia de depend@^{e}cias declaradas,
@code{diff (f, x)} retorna zero.
Se @code{depends (f, x)} for declarada,
@code{diff (f, x)} retorna uma derivada simb@'{o}lica (isto @'{e}, um substantivo @code{diff}).

Cada argumento @var{f_1}, @var{x_1}, etc., pode ser o nome de uma vari@'{a}vel ou array,
ou uma lista de nomes.
Todo elemento de @var{f_i} (talvez apenas um elemento simples)
@'{e} 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@'{e}m o nome de um array,
todos os elementos do array dependem de @var{x_i}.

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

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

@code{depends} retorna uma lista de depend@^{e}ncias estabelecidas.
As depend@^{e}ncias s@~{a}o anexadas @`a vari@'{a}vel global @code{dependencies}.
@code{depends} avalia seus argumentos.

@code{diff} @'{e} o @'{u}nico comando Maxima que reconhece depend@^{e}ncias estabelecidas por @code{depends}.
Outras fun@value{cedilha}@~{o}es (@code{integrate}, @code{laplace}, etc.)
somente reconhecem depend@^{e}ncias explicitamente representadas por seus argumentos.
Por exemplo, @code{integrate} n@~{a}o reconhece a depend@^{e}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@'{a}vel de op@value{cedilha}@~{a}o} derivabbrev
Valor padr@~{a}o: @code{false}

Quando @code{derivabbrev} for @code{true},
derivadas simb@'{o}licas (isto @'{e}, substantivos @code{diff}) s@~{a}o mostradas como subscritos.
De outra forma, derivadas s@~{a}o mostradas na nota@value{cedilha}@~{a}o de Leibniz @code{dy/dx}.

@c NEED EXAMPLES HERE
@end defvr

@c SEEMS LIKE THIS STATEMENT COULD BE LESS CLUMSY
@deffn {Fun@value{cedilha}@~{a}o} derivdegree (@var{expr}, @var{y}, @var{x})
Retorna o maior grau de uma derivada
da vari@'{a}vel dependente @var{y} com rela@value{cedilha}@~{a}o @`a vari@'{a}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@value{cedilha}@~{a}o} derivlist (@var{var_1}, ..., @var{var_k})
Causa somente diferencia@value{cedilha}@~{o}es com rela@value{cedilha}@~{a}o @`as
vari@'{a}veis indicadas, dentro do comando @code{ev}.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} derivsubst
Valor padr@~{a}o: @code{false}

Quando @code{derivsubst} for @code{true}, uma substiru@'{i}@value{cedilha}@~{a}o n@~{a}o sint@'{a}tica tais como
@code{subst (x, 'diff (y, t), 'diff (y, t, 2))} retorna @code{'diff (x, t)}.

@end defvr

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

@code{diff (@var{expr}, @var{x}, @var{n})} retorna a @var{n}'@'{e}sima derivada de @var{expr}
com rela@value{cedilha}@~{a}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@value{cedilha}@~{a}o a @var{x_1}, ..., @var{x_m}.
Isso @'{e} 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@value{cedilha}@~{a}o a
uma vari@'{a}vel @var{x}.

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

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

Quando @code{derivabbrev} for @code{true}, derivadas s@~{a}o mostradas como subscritos.
De outra forma, derivadas s@~{a}o mostradas na nota@value{cedilha}@~{a}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@value{cedilha}@~{o}es foram
incorporadas:

(1) As derivadas de quaisquer objetos indexados em @var{expr} ter@~{a}o as
vari@'{a}veis @var{x_i} anexadas como argumentos adicionais.  Ent@~{a}o todos os
@'{i}ndices de derivada ser@~{a}o ordenados.

(2) As vari@'{a}veis @var{x_i} podem ser inteiros de 1 at@'{e} o valor de uma vari@'{a}vel
@code{dimension} [valor padr@~{a}o: 4].  Isso far@'{a} com que a diferencia@value{cedilha}@~{a}o
seja conclu@'{i}da com rela@value{cedilha}@~{a}o aos @var{x_i}'@'{e}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@'{a}vel at@^{o}mica, ent@~{a}o aquela
vari@'{a}vel subscrita por @var{x_i} ser@'{a} usada para uma vari@'{a}vel de
diferencia@value{cedilha}@~{a}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@~{a}o
foram atribu@'{i}das um valor, ent@~{a}o as vari@'{a}veis seram tratadas como em (1)
acima.

@c NEED EXAMPLES FOR TENSOR STUFF
@end deffn

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

Quando @code{diff} est@'{a} presente como um @code{evflag} em chamadas para @code{ev},
Todas as diferencia@value{cedilha}@~{o}es indicadas em @code{expr} s@~{a}o realizdas.

@c NEED EXAMPLE HERE
@end defvr

@c NOT SURE HOW THIS IS SUPPOSED TO WORK
@deffn {Fun@value{cedilha}@~{a}o} dscalar (@var{f})
Aplica o d'Alembertiano escalar para a fun@value{cedilha}@~{a}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@value{cedilha}@~{a}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@value{cedilha}@~{a}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@value{cedilha}@~{a}o can be used together with the @code{diff} evflag, after using the
@c built-in @code{depends} fun@value{cedilha}@~{a}o to establish any new implicit depend@^{e}ncias.

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

Derivadas simb@'{o}licas (isto @'{e}, substantivos @code{diff})
no valor de retorno de @code{express} podem ser avaliadas inclu@'{i}ndo @code{diff}
na chamada @`a fun@value{cedilha}@~{a}o @code{ev} ou na linha de comando.
Nesse contexto, @code{diff} age como uma @code{evfun}.

@code{load ("vect")} chama essa fun@value{cedilha}@~{a}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@value{cedilha}@~{a}o} gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})
@deffnx {Fun@value{cedilha}@~{a}o} gradef (@var{a}, @var{x}, @var{expr})
Define as derivadas parciais (i.e., os componentes do gradiente) da fun@value{cedilha}@~{a}o @var{f}
ou vari@'{a}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} @'{e} uma express@~{a}o; @var{g_i} pode ser uma chamada de fun@value{cedilha}@~{a}o, mas n@~{a}o o nome de uma fun@value{cedilha}@~{a}o.
O n@'{u}mero de derivadas parciais @var{m} pode ser menor que o n@'{u}mero de argumentos @var{n},
nesses casos derivadas s@~{a}o definidas com rela@value{cedilha}@~{a}o a @var{x_1} at@'{e} @var{x_m} somente.

@code{gradef (@var{a}, @var{x}, @var{expr})} define uma derivada de vari@'{a}vel @var{a}
com rela@value{cedilha}@~{a}o a @var{x} como @var{expr}.
Isso tamb@'{e}m estabelece a depend@^{e}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} @'{e} acompanhado de ap@'{o}strofo,
mas os argumentos restantes @var{g_1}, ..., @var{g_m} s@~{a}o avaliados.
@code{gradef} retorna a fun@value{cedilha}@~{a}o ou vari@'{a}vel para as quais as derivadas parciais s@~{a}o definidas.

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

@code{gradef} n@~{a}o pode definir derivadas parciais para um fun@value{cedilha}@~{a}o subscrita.

@code{printprops ([@var{f_1}, ..., @var{f_n}], gradef)} mostra as derivadas parciais
das fun@value{cedilha}@~{o}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@'{a}veis @var{a_n}, ..., @var{a_n}, como definidas por @code{gradef}.

@code{gradefs} @'{e} a lista de fun@value{cedilha}@~{o}es
para as quais derivadas parciais foram definidas por @code{gradef}.
@code{gradefs} n@~{a}o inclui quaisquer vari@'{a}veis
para quais derivadas parciais foram definidas por @code{gradef}.

@c REPHRASE THIS NEXT BIT
Gradientes s@~{a}o necess@'{a}rios quando, por exemplo, uma fun@value{cedilha}@~{a}o n@~{a}o @'{e} conhecida
explicitamente mas suas derivadas primeiras s@~{a}o e isso @'{e} desejado para obter
derivadas de ordem superior.

@c NEED EXAMPLES HERE
@end deffn

@defvr {Vari@'{a}vel de sistema} gradefs
Valor padr@~{a}o: @code{[]}

@code{gradefs} @'{e} a lista de fun@value{cedilha}@~{o}es
para as quais derivadas parciais foram definidas por @code{gradef}.
@code{gradefs} n@~{a}o inclui quaisquer vari@'{a}veis
para as quais derivadas parciais foram deinidas por @code{gradef}.

@end defvr

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

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

@c REPHRASE THIS
@var{expr} pode tamb@'{e}m ser uma equa@value{cedilha}@~{a}o linear, diferencial de coeficiente contante no
qual caso o @code{atvalue} da vari@'{a}vel dependente @'{e} 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@value{cedilha}@~{o}es iniciais devem ser especificadas em zero, se um teve condi@value{cedilha}@~{o}es
de limite impostas em qualquer outro lugar ele pode impor essas sobre a solu@value{cedilha}@~{a}o
geral e eliminar as constantes resolvendo a solu@value{cedilha}@~{a}o geral
para essas e substituindo seus valores de volta.

@code{laplace} reconhece integrais de convolu@value{cedilha}@~{a}o da forma
@code{integrate (f(x) * g(t - x), x, 0, t)};
outros tipos de convolu@value{cedilha}@~{o}es n@~{a}o s@~{a}o reconhecidos.

Rela@value{cedilha}@~{o}es funcionais devem ser explicitamente representadas em @var{expr};
rela@value{cedilha}@~{o}es impl@'{i}citas, estabelecidas por @code{depends}, n@~{a}o s@~{a}o reconhecidas.
Isto @'{e}, se @var{f} depende de @var{x} e @var{y},
@code{f (x, y)} deve aparecer em @var{expr}.

Veja tamb@'{e}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
