@c English version 2011-06-07
@menu
* Funciones y variables para la diferenciación::  
@end menu

@node Funciones y variables para la diferenciación,  , Diferenciación, Diferenciación
@section Funciones y variables para la diferenciación

@deffn {Función} antid (@var{expr}, @var{x}, @var{u(x)}) 
Devuelve una lista con dos elementos, de manera que se pueda calcular la antiderivada de @var{expr} respecto de  @var{x} a partir de la lista. La expresión @var{expr} puede contener una función no especificada @var{u} y sus derivadas.

Sea @var{L} la lista con dos elementos que devuelve la función @code{antid}.
Entonces, @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
es una antiderivada de @var{expr} con respecto a @var{x}.

Si la ejecución de @code{antid} resulta exitosa, el segundo elemento de la lista retornada es cero. En caso contrario, el segundo elemento es distinto de cero y el primero puede ser nulo o no. Si @code{antid} no es capaz de hacer ningún progreso, el primer elemento es nulo y el segundo no nulo.

Es necesario ejecutar @code{load ("antid")} para cargar esta función. El paquete @code{antid} define también las funciones @code{nonzeroandfreeof} y @code{linear}.

La función @code{antid} está relacionada con @code{antidiff} como se indica a continuación.
Sea @var{L} la lista devuelta por la función @code{antid}. Entonces, el resultado de @code{antidiff} es igual a  @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}, donde @var{x} es la variable de integración.

Ejemplos:
@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 {Función} antidiff (@var{expr}, @var{x}, @var{u}(@var{x}))
Devuelve la antiderivada de @var{expr} respecto de @var{x}.
La expresión @var{expr} puede contener una función no especificada @var{u} y sus derivadas.

Cuando @code{antidiff} se ejecuta con éxito, la expresión resultante no tiene símbolos integrales (esto es, no tiene referencias a la función @code{integrate}). En otro caso, @code{antidiff} devuelve una expresión que se encuentra total o parcialmente bajo el signo de integración. Si @code{antidiff} no puede ralizar ningún progreso, el valor devuelto se encuentra completamente bajo la integral.

Es necesario ejecutar @code{load ("antid")} para cargar esta función. El paquete @code{antid} define también las funciones @code{nonzeroandfreeof} y @code{linear}.

La función @code{antidiff} está relacionada con @code{antid} como se indica a continuación.
Sea @var{L} la lista de dos elementos que devuelve @code{antid}. Entonces, el valor retornado por @code{antidiff} es igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}, donde @var{x} es la variable de integración.

Ejemplos:
@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 {Función} at (@var{expr}, [@var{eqn_1}, ..., @var{eqn_n}])
@deffnx {Función} at (@var{expr}, @var{eqn})
Evalúa la expresión @var{expr} asignando a las variables los valores especificados para ellas en la lista de ecuaciones @code{[@var{eqn_1}, ..., @var{eqn_n}]} o en la ecuación simple @var{eqn}.

Si una subexpresión depende de cualquiera de las variables para la cual se especifica un valor, pero  no puede ser evaluado, entonces @code{at} devuelve una forma nominal.

La función @code{at} realiza múltiples sustituciones en serie, no en paralelo.

Véase también @code{atvalue}.
Para otras funciones que también llevan a cabo sustituciones, consúltense @code{subst} y @code{ev}.

Ejemplos:
@c COPIED FROM example(at)

@c ===beg===
@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]);
@c ===end===
@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 I SUSPECT THERE IS MORE TO BE SAID HERE
@defvr {Propiedad} atomgrad

La propiedad @code{atomgrad} es asignada por @code{gradef}.

@c NEED EXAMPLE HERE
@end defvr

@deffn {Función} atvalue (@var{expr}, [@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}], @var{c})
@deffnx {Función} atvalue (@var{expr}, @var{x_1} = @var{a_1}, @var{c})
Asigna el valor @var{c} a @var{expr} en el punto @code{@var{x} = @var{a}}.

La expresión @var{expr} es una función del tipo 
@code{@var{f}(@var{x_1}, ..., @var{x_m})},
o una 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 ??
en la que aparecen los argumentos de la función de forma explícita.
Los símbolos @var{n_i} se refieren al orden de diferenciación respecto de @var{x_i}.

El punto en el que @code{atvalue} establece el valor se especifica mediante la lista de ecuaciones
@code{[@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}]}.
Si hay una única variable @var{x_1}, la ecuación puede escribirse sin formar parte de una lista.

La llamada @code{printprops ([@var{f_1}, @var{f_2}, ...], atvalue)} muestra los valores asignados por @code{atvalue} a las funciones @code{@var{f_1}, @var{f_2}, ...}.
La llamada  @code{printprops (@var{f}, atvalue)} muestra los valores asignados por @code{atvalue} a la función @var{f}.
La llamada  @code{printprops (all, atvalue)} muestra los valores asignados por @code{atvalue} a todas las funciones.

Los símbolos @code{@@1}, @code{@@2}, ... representan las variables @var{x_1}, @var{x_2}, ... cuando se muestran los valores asignados por @code{atvalue}.

La función @code{atvalue} evalúa sus argumentos y devuelve @var{c}, el valor asignado.

Ejemplos:
@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

@deffn {Función} cartan  -
El cálculo exterior de formas diferenciales es una herramienta básica de la geometría diferencial desarrollada por Elie Cartan, teniendo importantes aplicaciones en la teoría de ecuaciones diferenciales en derivadas parciales.
El paquete @code{cartan} dispone de las funciones @code{ext_diff} y @code{lie_diff}, así como de los operadores @code{~} (producto exterior) y @code{|} (contracción de una forma con un vector). La orden @code{demo (tensor)} permite ver una breve descripción de estas instrucciones, junto con ejemplos.

El paquete @code{cartan} fue escrito por F.B. Estabrook y H.D. Wahlquist.

@end deffn

@deffn {Función} del (@var{x})
La expresión @code{del (@var{x})} representa el diferencial de la variable @math{x}.

La función @code{diff} devuelve una expresión que contiene a @code{del} si no se ha especificado una variable independiente. En este caso, el valor retornado es el llamado "diferencial total".

Ejemplos:
@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 {Función} delta (@var{t})
Es la función delta de Dirac.

En el estado actual de desarrollo de Maxima, sólo @code{laplace} reconoce la función @code{delta}.

Ejemplo:

@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 {Variable del sistema} dependencies
Valor por defecto: @code{[]}

La variable @code{dependencies} es la lista de átomos que tienen algún tipo de dependencia funcional, asignada por @code{depends} o @code{gradef}. La lista @code{dependencies} es acumulativa: cada llamada a @code{depends} o @code{gradef} añade elementos adicionales.

Véanse @code{depends} y @code{gradef}.

@end defvr

@deffn {Función} depends (@var{f_1}, @var{x_1}, ..., @var{f_n}, @var{x_n})
Declara dependencias funcionales entre variables con el propósito de calcular derivadas.
En ausencia de una dependencia declarada, @code{diff (f, x)} devuelve cero.
Si se declara @code{depends (f, x)}, @code{diff (f, x)} devuelve una derivada simbólica (esto es, una expresión con @code{diff}).

Cada argumento  @var{f_1}, @var{x_1}, etc., puede ser el nombre de una variable, de un arreglo o una lista de nombres.
Cada elemento de @var{f_i} (quizás un único elemento) se declara como dependiente de cada elemento de @var{x_i} (quizás también un único elemento). Si alguno de los  @var{f_i} es el nombre de un arreglo o contiene el nombre de un arreglo, todos los elemento del arregl dependen de @var{x_i}.

La función @code{diff} reconoce dependencias indirectas establecidas por @code{depends} y aplica la regla de la cadena en tales casos.

La instrucción @code{remove (@var{f}, dependency)} borra todas las dependencias declaradas para @var{f}.

La función @code{depends} devuelve una lista con las dependencias que han sido establecidas. Las dependencias se añaden a la variable global @code{dependencies}. La función @code{depends} evalúa sus argumentos.

La función @code{diff} es la única instrucción de Maxima que reconoce las dependencias establecidas por @code{depends}. Otras funciones (@code{integrate}, @code{laplace}, etc.) solamente reconocen dependencias explícitamente representadas por sus argumentos. Por ejemplo, @code{integrate} no reconoce la dependencia de @code{f} respecto de @code{x}
a menos que se represente explícitamente 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 {Variable optativa} derivabbrev
Valor por defecto: @code{false}

Si @code{derivabbrev} vale @code{true}, las derivadas simbólicas (esto es, expresiones con @code{diff}) se muestran como subíndices. En otro caso, las derivadas se muestran en la notación de Leibniz, @code{dy/dx}.

@c NEED EXAMPLES HERE
@end defvr

@deffn {Función} derivdegree (@var{expr}, @var{y}, @var{x})
Devuelve el mayor grado de la derivada de la variable dependiente @var{y} respecto de la variable independiente @var{x} que aparece en @var{expr}.

Ejemplo:
@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 {Función} derivlist (@var{var_1}, ..., @var{var_k})
Hace que las derivadas calculadas por la instrucción @code{ev} se calculen respecto de las variables indicadas.

@end deffn

@defvr {Variable optativa} derivsubst
Valor por defecto: @code{false}

Si @code{derivsubst} vale @code{true}, una sustitución no sintáctica del estilo 
@code{subst (x, 'diff (y, t), 'diff (y, t, 2))} devuelve @code{'diff (x, t)}.

@end defvr

@deffn {Función} diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})
@deffnx {Función} diff (@var{expr}, @var{x}, @var{n})
@deffnx {Función} diff (@var{expr}, @var{x})
@deffnx {Función} diff (@var{expr})
Devuelve la derivada o diferencial de  @var{expr} respecto de alguna o de todas las variables presentes en @var{expr}.

La llamada @code{diff (@var{expr}, @var{x}, @var{n})} devuelve la @var{n}-esima derivada de @var{expr} respecto de @var{x}.

La llamada @code{diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})}
devuelve la derivada parcial de @var{expr} con respecto de @var{x_1}, ..., @var{x_m}.
Equivale a @code{diff (... (diff (@var{expr}, @var{x_m}, @var{n_m}) ...), @var{x_1}, @var{n_1})}.

La llamada @code{diff (@var{expr}, @var{x})}
devuelve la primera derivada de @var{expr} respecto de la variable @var{x}.

La llamada @code{diff (@var{expr})} devuelve el diferencial total de @var{expr}, esto es, la suma de las derivadas de @var{expr} respecto de cada una de sus variables, multiplicadas por el diferencial @code{del} de cada una de ellas.
@c WHAT DOES THIS NEXT STATEMENT MEAN, EXACTLY ??
@c FALTA AQUI UNA FRASE.

La forma nominal de @code{diff} es necesaria en algunos contextos, como para definir ecuaciones diferenciales.
En tales casos, @code{diff} puede ir precedida de un apóstrofo (como @code{'diff}) para evitar el cálculo de la derivada.

Si @code{derivabbrev} vale @code{true}, las derivadas se muestran como subíndices. En otro caso, se muestran en la notación de Leibniz, @code{dy/dx}.

Ejemplos:
@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 el paquete sobre tensores se han introducido las siguientes modificaciones:

(1) Las derivadas de los objetos indexados en @var{expr} tendrán las variables @var{x_i} añadidas como argumentos adicionales. Entonces se ordenarán todos los índices de derivadas.

(2) Las @var{x_i} pueden ser enteros entre 1 hasta el valor de la variable @code{dimension} [valor por defecto: 4].  Esto hará que la diferenciación sea llevada a cabo con respecto al @var{x_i}-ésimo número de la lista @code{coordinates}, la cual debería contener una lista con los nombres de las coordenadas, por ejemplo, @code{[x, y, z, t]}. Si @code{coordinates} es una variableis atómica, entonces esa variable será utilizada como variable de diferenciación. Se permite la utilización de arreglos con los nombres de las coordenadas o nombres con subíndices, como @code{X[1]}, @code{X[2]}, ... to be used.  Si a @code{coordinates} no se le ha asignado ningún valor, entonces las variables serán tratadas como se ha indicado en (1).

@c NEED EXAMPLES FOR TENSOR STUFF
@end deffn

@defvr {Símbolo especial} diff

Si el nombre @code{diff} está presente en una llamada a la función @code{ev} en modo @code{evflag}, entonces se calculan todas las derivadas presentes en @code{expr}.

@c NEED EXAMPLE HERE
@end defvr

@c FALTA DESCRIPCION DE dscalar

@deffn {Función} express (@var{expr})
Transforma los nombres de los operadores diferenciales en expresiones que contienen derivadas parciales. Los operadores reconocidos por la función @code{express} son: @code{grad} (gradiente), @code{div} (divergencia), @code{curl} (rotacional), @code{laplacian} (laplaciano) y @code{~} (producto vectorial).

Las derivadas simbólicas (es decir, las que incluyen la forma nominal @code{diff}) que aparecen en la expresión devuelta por @code{express}, se pueden calcular pasándole a @code{ev} el argumento @code{diff}, o escribiéndolo directamente en la línea de comandos. En este contexto, @code{diff} actúa como @code{evfun}.

Es necesario ejecutar @code{load ("vect")} para cargar esta función.

Ejemplos:
@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

@deffn {Función} gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})
@deffnx {Función} gradef (@var{a}, @var{x}, @var{expr})
Define las derivadas parciales, o componentes del gradiente, de la función @var{f} o variable @var{a}.

La llamada @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}, 
donde @var{g_i} es una expresión; @var{g_i} puede ser una llamada a función, pero no el nombre de una función.
El número de derivadas parciales @var{m} puede ser menor que el número de argumentos @var{n}, en cuyo caso las derivadas se definen solamente con respecto a  @var{x_1}, ...., @var{x_m}.

La llamada @code{gradef (@var{a}, @var{x}, @var{expr})} define la derivada de la variable @var{a} respecto de @var{x} en @var{expr}. Con esto se establece la dependencia de @var{a} respecto de @var{x} a través de @code{depends (@var{a}, @var{x})}.

El primer argumento @code{@var{f}(@var{x_1}, ..., @var{x_n})} o @var{a} no se evalúa, pero sí lo hacen el resto de argumentos @var{g_1}, ..., @var{g_m}.  La llamada a @code{gradef} devuelve la función o variable para la que se define la derivada parcial.

La instrucción @code{gradef} puede redefinir las derivadas de las funciones propias de Maxima.
Por ejemplo, @code{gradef (sin(x), sqrt (1 - sin(x)^2))} redefine la derivada de @code{sin}.

La instrucción @code{gradef} no puede definir derivadas parciales de funciones subindicadas.

La llamada @code{printprops ([@var{f_1}, ..., @var{f_n}], gradef)} muestra las derivadas parciales de las funciones @var{f_1}, ..., @var{f_n}, tal como las definió @code{gradef}.

La llamada @code{printprops ([@var{a_n}, ..., @var{a_n}], atomgrad)} muestra las derivadas parciales de las variables @var{a_n}, ..., @var{a_n}, tal como las definió @code{gradef}.

La variable @code{gradefs} contiene la lista de las funciones para las que se han definido derivadas parciales con la instrucción @code{gradef}, pero no incluye las variables para las que se han definido las derivadas parciales.

@c REPHRASE THIS NEXT BIT
Los gradientes son necesarios cuando una función no se conoce explícitamente pero sí sus primeras derivadas y es necesario calcular las derivadas de orden mayor.

@c NEED EXAMPLES HERE
@end deffn

@defvr {Variable del sistema} gradefs
Valor por defecto: @code{[]}

La variable @code{gradefs} contiene la lista de las funciones para las que se han definido derivadas parciales con la instrucción @code{gradef}, pero no incluye las variables para las que se han definido las derivadas parciales.

@end defvr

@deffn {Función} laplace (@var{expr}, @var{t}, @var{s})
Calcula la transformada de Laplace de @var{expr} con respecto
de la variable @var{t} y parámetro de transformación @var{s}.

La función @code{laplace} reconoce en @var{expr} las funciones
@code{delta}, @code{exp}, @code{log}, @code{sin}, @code{cos},
@code{sinh}, @code{cosh} y @code{erf}, así como 
@code{derivative}, @code{integrate}, @code{sum} y @code{ilt}. 
Si @code{laplace} no encuentra una transformada, entonces
llama a la función @code{specint}, la cual puede encontrar
la transformada de Laplace de expresiones con funciones especiales,
tales como las de Bessel. @code{specint} también puede manipular la 
función @code{unit_step}. Véase @code{specint} para más información.

Cuando tampoco @code{specint} sea capaz de encontrar una solución,
se devolverá una forma nominal.


@c REPHRASE THIS
@c FALTA AQUI UN PARRAFO

La función @code{laplace} reconoce integrales de convolución 
de la forma @code{integrate (f(x) * g(t - x), x, 0, t)},
no pudiendo reconocer otros tipos de convoluciones.

Las relaciones funcionales se deben representar explícitamente en @var{expr}; las relaciones implícitas establecidas por @code{depends} no son reconocidas. Así, si @var{f} depende de @var{x} y @var{y}, @code{f (x, y)} debe aparecer en @var{expr}.

Véase también @code{ilt}, la transformada inversa de Laplace.

Ejemplos:
@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
(%i5) assume(a>0)$
(%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true;
                                              - a - 1
                         gamma(a)   gamma(a) s
(%o6)                    -------- - -----------------
                            s            1     a
                                        (- + 1)
                                         s
(%i7) factor(laplace(gamma_incomplete(1/2,t),t,s));
                                              s + 1
                      sqrt(%pi) (sqrt(s) sqrt(-----) - 1)
                                                s
(%o7)                 -----------------------------------
                                3/2      s + 1
                               s    sqrt(-----)
                                           s
(%i8) assume(exp(%pi*s)>1)$
(%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s),simpsum;
                         %i                         %i
              ------------------------ - ------------------------
                              - %pi s                    - %pi s
              (s + %i) (1 - %e       )   (s - %i) (1 - %e       )
(%o9)         ---------------------------------------------------
                                       2
(%i9) factor(%);
                                      %pi s
                                    %e
(%o9)                   -------------------------------
                                             %pi s
                        (s - %i) (s + %i) (%e      - 1)

@end example

@end deffn


