Funciones y variables para la diferenciación
============================================

 -- Función: antid (EXPR, X, U(X))
     Devuelve una lista con dos elementos, de manera que se pueda calcular la antiderivada de EXPR respecto de  X a partir de la lista. La expresión EXPR puede contener una función no especificada U y sus derivadas.

     Sea L la lista con dos elementos que devuelve la función antid. Entonces, L[1] + 'integrate (L[2], X) es una antiderivada de EXPR con respecto a X.

     Si la ejecución de 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 antid no es capaz de hacer ningún progreso, el primer elemento es nulo y el segundo no nulo.

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

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

     Ejemplos:

          (%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
                            /

 -- Función: antidiff (EXPR, X, U(X))
     Devuelve la antiderivada de EXPR respecto de X. La expresión EXPR puede contener una función no especificada U y sus derivadas.

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

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

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

     Ejemplos:

          (%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
                            /

 -- Propiedad: atomgrad

     La propiedad atomgrad es asignada por gradef.

 -- Función: atvalue (EXPR, [X_1 = A_1, ..., X_M = A_M], C)
 -- Función: atvalue (EXPR, X_1 = A_1, C)
     Asigna el valor C a EXPR en el punto X = A.

     La expresión EXPR es una función del tipo F(X_1, ..., X_M), o una derivada, diff (F(X_1, ..., X_M), X_1, N_1, ..., X_N, N_M) en la que aparecen los argumentos de la función de forma explícita. Los símbolos N_I se refieren al orden de diferenciación respecto de X_I.

     El punto en el que atvalue establece el valor se especifica mediante la lista de ecuaciones [X_1 = A_1, ..., X_M = A_M]. Si hay una única variable X_1, la ecuación puede escribirse sin formar parte de una lista.

     La llamada printprops ([F_1, F_2, ...], atvalue) muestra los valores asignados por atvalue a las funciones F_1, F_2, .... La llamada  printprops (F, atvalue) muestra los valores asignados por atvalue a la función F. La llamada  printprops (all, atvalue) muestra los valores asignados por atvalue a todas las funciones.

     Los símbolos @1, @2, ... representan las variables X_1, X_2, ... cuando se muestran los valores asignados por atvalue.

     La función atvalue evalúa sus argumentos y devuelve C, el valor asignado.

     Ejemplos:

          (%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

 -- 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 cartan dispone de las funciones ext_diff y lie_diff, así como de los operadores ~ (producto exterior) y | (contracción de una forma con un vector). La orden demo (tensor) permite ver una breve descripción de estas instrucciones, junto con ejemplos.

     El paquete cartan fue escrito por F.B. Estabrook y H.D. Wahlquist.

 -- Función: del (X)
     La expresión del (X) representa el diferencial de la variable x.

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

     Ejemplos:

          (%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)

 -- Función: delta (T)
     Es la función delta de Dirac.

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

     Ejemplo:

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

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

 -- Variable del sistema: dependencies
     Valor por defecto: []

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

     Véanse depends y gradef.

 -- Función: depends (F_1, X_1, ..., F_N, X_N)
     Declara dependencias funcionales entre variables con el propósito de calcular derivadas. En ausencia de una dependencia declarada, diff (f, x) devuelve cero. Si se declara depends (f, x), diff (f, x) devuelve una derivada simbólica (esto es, una expresión con diff).

     Cada argumento  F_1, X_1, etc., puede ser el nombre de una variable, de un arreglo o una lista de nombres. Cada elemento de F_I (quizás un único elemento) se declara como dependiente de cada elemento de X_I (quizás también un único elemento). Si alguno de los  F_I es el nombre de un arreglo o contiene el nombre de un arreglo, todos los elemento del arregl dependen de X_I.

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

     La instrucción remove (F, dependency) borra todas las dependencias declaradas para F.

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

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

 -- Variable optativa: derivabbrev
     Valor por defecto: false

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

 -- Función: derivdegree (EXPR, Y, X)
     Devuelve el mayor grado de la derivada de la variable dependiente Y respecto de la variable independiente X que aparece en EXPR.

     Ejemplo:

          (%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

 -- Función: derivlist (VAR_1, ..., VAR_K)
     Hace que las derivadas calculadas por la instrucción ev se calculen respecto de las variables indicadas.

 -- Variable optativa: derivsubst
     Valor por defecto: false

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

 -- Función: diff (EXPR, X_1, N_1, ..., X_M, N_M)
 -- Función: diff (EXPR, X, N)
 -- Función: diff (EXPR, X)
 -- Función: diff (EXPR)
     Devuelve la derivada o diferencial de  EXPR respecto de alguna o de todas las variables presentes en EXPR.

     La llamada diff (EXPR, X, N) devuelve la N-esima derivada de EXPR respecto de X.

     La llamada diff (EXPR, X_1, N_1, ..., X_M, N_M) devuelve la derivada parcial de EXPR con respecto de X_1, ..., X_M. Equivale a diff (... (diff (EXPR, X_M, N_M) ...), X_1, N_1).

     La llamada diff (EXPR, X) devuelve la primera derivada de EXPR respecto de la variable X.

     La llamada diff (EXPR) devuelve el diferencial total de EXPR, esto es, la suma de las derivadas de EXPR respecto de cada una de sus variables, multiplicadas por el diferencial del de cada una de ellas.

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

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

     Ejemplos:

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

     (1) Las derivadas de los objetos indexados en EXPR tendrán las variables X_I añadidas como argumentos adicionales. Entonces se ordenarán todos los índices de derivadas.

     (2) Las X_I pueden ser enteros entre 1 hasta el valor de la variable dimension [valor por defecto: 4].  Esto hará que la diferenciación sea llevada a cabo con respecto al X_I-ésimo número de la lista coordinates, la cual debería contener una lista con los nombres de las coordenadas, por ejemplo, [x, y, z, t]. Si 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 X[1], X[2], ... to be used.  Si a coordinates no se le ha asignado ningún valor, entonces las variables serán tratadas como se ha indicado en (1).

 -- Símbolo especial: diff

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

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

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

     Es necesario ejecutar load ("vect") para cargar esta función.

     Ejemplos:

          (%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]

 -- Función: gradef (F(X_1, ..., X_N), G_1, ..., G_M)
 -- Función: gradef (A, X, EXPR)
     Define las derivadas parciales, o componentes del gradiente, de la función F o variable A.

     La llamada gradef (F(X_1, ..., X_N), G_1, ..., G_M) define dF/dX_I como G_I, donde G_I es una expresión; G_I puede ser una llamada a función, pero no el nombre de una función. El número de derivadas parciales M puede ser menor que el número de argumentos N, en cuyo caso las derivadas se definen solamente con respecto a  X_1, ...., X_M.

     La llamada gradef (A, X, EXPR) define la derivada de la variable A respecto de X en EXPR. Con esto se establece la dependencia de A respecto de X a través de depends (A, X).

     El primer argumento F(X_1, ..., X_N) o A no se evalúa, pero sí lo hacen el resto de argumentos G_1, ..., G_M.  La llamada a gradef devuelve la función o variable para la que se define la derivada parcial.

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

     La instrucción gradef no puede definir derivadas parciales de funciones subindicadas.

     La llamada printprops ([F_1, ..., F_N], gradef) muestra las derivadas parciales de las funciones F_1, ..., F_N, tal como las definió gradef.

     La llamada printprops ([A_N, ..., A_N], atomgrad) muestra las derivadas parciales de las variables A_N, ..., A_N, tal como las definió gradef.

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

     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.

 -- Variable del sistema: gradefs
     Valor por defecto: []

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

 -- Función: laplace (EXPR, T, S)
     Calcula la transformada de Laplace de EXPR con respecto de la variable T y parámetro de transformación S. Si laplace no puede encontrar la solución, se devuelve la forma nominal 'laplace.

     La función laplace reconoce en EXPR las funciones delta, exp, log, sin, cos, sinh, cosh y erf, así como derivative, integrate, sum y ilt. Bajo la presencia de otras funciones, laplace puede que no sea capaz de calcular la transformada.

     La función laplace reconoce integrales de convolución de la forma 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 EXPR; las relaciones implícitas establecidas por depends no son reconocidas. Así, si F depende de X y Y, f (x, y) debe aparecer en EXPR.

     Véase también ilt, la transformada inversa de Laplace.

     Ejemplos:

          (%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