| blob | ff7f4cac4acd5a99fe8b43237ad85854d9db1fe7 |
1 @c English version 2011-06-07
2 @menu
3 * Funciones y variables para la diferenciación::
4 @end menu
6 @node Funciones y variables para la diferenciación, , Diferenciación, Diferenciación
7 @section Funciones y variables para la diferenciación
9 @deffn {Función} antid (@var{expr}, @var{x}, @var{u(x)})
10 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.
12 Sea @var{L} la lista con dos elementos que devuelve la función @code{antid}.
13 Entonces, @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
14 es una antiderivada de @var{expr} con respecto a @var{x}.
16 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.
18 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}.
20 La función @code{antid} está relacionada con @code{antidiff} como se indica a continuación.
21 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.
23 Ejemplos:
24 @c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
25 @c load ("antid")$
26 @c expr: exp (z(x)) * diff (z(x), x) * y(x);
27 @c a1: antid (expr, x, z(x));
28 @c a2: antidiff (expr, x, z(x));
29 @c a2 - (first (a1) + 'integrate (second (a1), x));
30 @c antid (expr, x, y(x));
31 @c antidiff (expr, x, y(x));
32 @c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
33 @c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
34 @c MAYBE MERGE IN THE DEMO PROBLEMS LATER
36 @example
37 (%i1) load ("antid")$
38 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
39 z(x) d
40 (%o2) y(x) %e (-- (z(x)))
41 dx
42 (%i3) a1: antid (expr, x, z(x));
43 z(x) z(x) d
44 (%o3) [y(x) %e , - %e (-- (y(x)))]
45 dx
46 (%i4) a2: antidiff (expr, x, z(x));
47 /
48 z(x) [ z(x) d
49 (%o4) y(x) %e - I %e (-- (y(x))) dx
50 ] dx
51 /
52 (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
53 (%o5) 0
54 (%i6) antid (expr, x, y(x));
55 z(x) d
56 (%o6) [0, y(x) %e (-- (z(x)))]
57 dx
58 (%i7) antidiff (expr, x, y(x));
59 /
60 [ z(x) d
61 (%o7) I y(x) %e (-- (z(x))) dx
62 ] dx
63 /
64 @end example
66 @end deffn
69 @deffn {Función} antidiff (@var{expr}, @var{x}, @var{u}(@var{x}))
70 Devuelve la antiderivada de @var{expr} respecto de @var{x}.
71 La expresión @var{expr} puede contener una función no especificada @var{u} y sus derivadas.
73 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.
75 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}.
77 La función @code{antidiff} está relacionada con @code{antid} como se indica a continuación.
78 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.
80 Ejemplos:
81 @c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
82 @c load ("antid")$
83 @c expr: exp (z(x)) * diff (z(x), x) * y(x);
84 @c a1: antid (expr, x, z(x));
85 @c a2: antidiff (expr, x, z(x));
86 @c a2 - (first (a1) + 'integrate (second (a1), x));
87 @c antid (expr, x, y(x));
88 @c antidiff (expr, x, y(x));
89 @c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
90 @c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
91 @c MAYBE MERGE IN THE DEMO PROBLEMS LATER
93 @example
94 (%i1) load ("antid")$
95 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
96 z(x) d
97 (%o2) y(x) %e (-- (z(x)))
98 dx
99 (%i3) a1: antid (expr, x, z(x));
100 z(x) z(x) d
101 (%o3) [y(x) %e , - %e (-- (y(x)))]
102 dx
103 (%i4) a2: antidiff (expr, x, z(x));
104 /
105 z(x) [ z(x) d
106 (%o4) y(x) %e - I %e (-- (y(x))) dx
107 ] dx
108 /
109 (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
110 (%o5) 0
111 (%i6) antid (expr, x, y(x));
112 z(x) d
113 (%o6) [0, y(x) %e (-- (z(x)))]
114 dx
115 (%i7) antidiff (expr, x, y(x));
116 /
117 [ z(x) d
118 (%o7) I y(x) %e (-- (z(x))) dx
119 ] dx
120 /
121 @end example
123 @end deffn
128 @deffn {Función} at (@var{expr}, [@var{eqn_1}, ..., @var{eqn_n}])
129 @deffnx {Función} at (@var{expr}, @var{eqn})
130 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}.
132 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.
134 La función @code{at} realiza múltiples sustituciones en serie, no en paralelo.
136 Véase también @code{atvalue}.
137 Para otras funciones que también llevan a cabo sustituciones, consúltense @code{subst} y @code{ev}.
139 Ejemplos:
140 @c COPIED FROM example(at)
142 @c ===beg===
143 @c atvalue (f(x,y), [x = 0, y = 1], a^2);
144 @c atvalue ('diff (f(x,y), x), x = 0, 1 + y);
145 @c printprops (all, atvalue);
146 @c diff (4*f(x, y)^2 - u(x, y)^2, x);
147 @c at (%, [x = 0, y = 1]);
148 @c ===end===
149 @example
150 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
151 2
152 (%o1) a
153 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
154 (%o2) @@2 + 1
155 (%i3) printprops (all, atvalue);
156 !
157 d !
158 --- (f(@@1, @@2))! = @@2 + 1
159 d@@1 !
160 !@@1 = 0
162 2
163 f(0, 1) = a
165 (%o3) done
166 (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
167 d d
168 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
169 dx dx
170 (%i5) at (%, [x = 0, y = 1]);
171 !
172 2 d !
173 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! )
174 dx !
175 !x = 0, y = 1
176 @end example
178 @end deffn
182 @c I SUSPECT THERE IS MORE TO BE SAID HERE
183 @defvr {Propiedad} atomgrad
185 La propiedad @code{atomgrad} es asignada por @code{gradef}.
187 @c NEED EXAMPLE HERE
188 @end defvr
190 @deffn {Función} atvalue (@var{expr}, [@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}], @var{c})
191 @deffnx {Función} atvalue (@var{expr}, @var{x_1} = @var{a_1}, @var{c})
192 Asigna el valor @var{c} a @var{expr} en el punto @code{@var{x} = @var{a}}.
194 La expresión @var{expr} es una función del tipo
195 @code{@var{f}(@var{x_1}, ..., @var{x_m})},
196 o una derivada,
197 @code{diff (@var{f}(@var{x_1}, ..., @var{x_m}), @var{x_1}, @var{n_1}, ..., @var{x_n}, @var{n_m})}
198 @c HMM, WHAT IS THIS NEXT PHRASE GETTING AT ??
199 @c DOES IT INTEND TO IMPLY THAT IMPLICIT DEPENDENCIES ARE IGNORED ??
200 en la que aparecen los argumentos de la función de forma explícita.
201 Los símbolos @var{n_i} se refieren al orden de diferenciación respecto de @var{x_i}.
203 El punto en el que @code{atvalue} establece el valor se especifica mediante la lista de ecuaciones
204 @code{[@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}]}.
205 Si hay una única variable @var{x_1}, la ecuación puede escribirse sin formar parte de una lista.
207 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}, ...}.
208 La llamada @code{printprops (@var{f}, atvalue)} muestra los valores asignados por @code{atvalue} a la función @var{f}.
209 La llamada @code{printprops (all, atvalue)} muestra los valores asignados por @code{atvalue} a todas las funciones.
211 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}.
213 La función @code{atvalue} evalúa sus argumentos y devuelve @var{c}, el valor asignado.
215 Ejemplos:
216 @c FOLLOWING ADAPTED FROM example (atvalue)
217 @c atvalue (f(x,y), [x = 0, y = 1], a^2);
218 @c atvalue ('diff (f(x,y), x), x = 0, 1 + y);
219 @c printprops (all, atvalue);
220 @c diff (4*f(x,y)^2 - u(x,y)^2, x);
221 @c at (%, [x = 0, y = 1]);
223 @example
224 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
225 2
226 (%o1) a
227 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
228 (%o2) @@2 + 1
229 (%i3) printprops (all, atvalue);
230 !
231 d !
232 --- (f(@@1, @@2))! = @@2 + 1
233 d@@1 !
234 !@@1 = 0
236 2
237 f(0, 1) = a
239 (%o3) done
240 (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
241 d d
242 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
243 dx dx
244 (%i5) at (%, [x = 0, y = 1]);
245 !
246 2 d !
247 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! )
248 dx !
249 !x = 0, y = 1
250 @end example
252 @end deffn
254 @deffn {Función} cartan -
255 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.
256 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.
258 El paquete @code{cartan} fue escrito por F.B. Estabrook y H.D. Wahlquist.
260 @end deffn
262 @deffn {Función} del (@var{x})
263 La expresión @code{del (@var{x})} representa el diferencial de la variable @math{x}.
265 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".
267 Ejemplos:
268 @c GENERATED FROM THE FOLLOWING
269 @c diff (log (x));
270 @c diff (exp (x*y));
271 @c diff (x*y*z);
273 @example
274 (%i1) diff (log (x));
275 del(x)
276 (%o1) ------
277 x
278 (%i2) diff (exp (x*y));
279 x y x y
280 (%o2) x %e del(y) + y %e del(x)
281 (%i3) diff (x*y*z);
282 (%o3) x y del(z) + x z del(y) + y z del(x)
283 @end example
285 @end deffn
287 @deffn {Función} delta (@var{t})
288 Es la función delta de Dirac.
290 En el estado actual de desarrollo de Maxima, sólo @code{laplace} reconoce la función @code{delta}.
292 Ejemplo:
294 @example
295 (%i1) laplace (delta (t - a) * sin(b*t), t, s);
296 Is a positive, negative, or zero?
298 p;
299 - a s
300 (%o1) sin(a b) %e
301 @end example
303 @end deffn
305 @defvr {Variable del sistema} dependencies
306 Valor por defecto: @code{[]}
308 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.
310 Véanse @code{depends} y @code{gradef}.
312 @end defvr
314 @deffn {Función} depends (@var{f_1}, @var{x_1}, ..., @var{f_n}, @var{x_n})
315 Declara dependencias funcionales entre variables con el propósito de calcular derivadas.
316 En ausencia de una dependencia declarada, @code{diff (f, x)} devuelve cero.
317 Si se declara @code{depends (f, x)}, @code{diff (f, x)} devuelve una derivada simbólica (esto es, una expresión con @code{diff}).
319 Cada argumento @var{f_1}, @var{x_1}, etc., puede ser el nombre de una variable, de un arreglo o una lista de nombres.
320 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}.
322 La función @code{diff} reconoce dependencias indirectas establecidas por @code{depends} y aplica la regla de la cadena en tales casos.
324 La instrucción @code{remove (@var{f}, dependency)} borra todas las dependencias declaradas para @var{f}.
326 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.
328 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}
329 a menos que se represente explícitamente como @code{integrate (f(x), x)}.
331 @c GENERATED BY THE FOLLOWING
332 @c depends ([f, g], x);
333 @c depends ([r, s], [u, v, w]);
334 @c depends (u, t);
335 @c dependencies;
336 @c diff (r.s, u);
337 @example
338 (%i1) depends ([f, g], x);
339 (%o1) [f(x), g(x)]
340 (%i2) depends ([r, s], [u, v, w]);
341 (%o2) [r(u, v, w), s(u, v, w)]
342 (%i3) depends (u, t);
343 (%o3) [u(t)]
344 (%i4) dependencies;
345 (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
346 (%i5) diff (r.s, u);
347 dr ds
348 (%o5) -- . s + r . --
349 du du
350 @end example
352 @c GENERATED BY THE FOLLOWING
353 @c diff (r.s, t);
354 @example
355 (%i6) diff (r.s, t);
356 dr du ds du
357 (%o6) -- -- . s + r . -- --
358 du dt du dt
359 @end example
361 @c GENERATED BY THE FOLLOWING
362 @c remove (r, dependency);
363 @c diff (r.s, t);
364 @example
365 (%i7) remove (r, dependency);
366 (%o7) done
367 (%i8) diff (r.s, t);
368 ds du
369 (%o8) r . -- --
370 du dt
371 @end example
373 @end deffn
375 @defvr {Variable optativa} derivabbrev
376 Valor por defecto: @code{false}
378 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}.
380 @c NEED EXAMPLES HERE
381 @end defvr
383 @deffn {Función} derivdegree (@var{expr}, @var{y}, @var{x})
384 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}.
386 Ejemplo:
387 @c GENERATED FROM THE FOLLOWING
388 @c 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
389 @c derivdegree (%, y, x);
390 @example
391 (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
392 3 2
393 d y d y 2 dy
394 (%o1) --- + --- + x --
395 3 2 dx
396 dz dx
397 (%i2) derivdegree (%, y, x);
398 (%o2) 2
399 @end example
401 @end deffn
403 @c I HAVE NO IDEA WHAT THIS DOES
404 @deffn {Función} derivlist (@var{var_1}, ..., @var{var_k})
405 Hace que las derivadas calculadas por la instrucción @code{ev} se calculen respecto de las variables indicadas.
407 @end deffn
409 @defvr {Variable optativa} derivsubst
410 Valor por defecto: @code{false}
412 Si @code{derivsubst} vale @code{true}, una sustitución no sintáctica del estilo
413 @code{subst (x, 'diff (y, t), 'diff (y, t, 2))} devuelve @code{'diff (x, t)}.
415 @end defvr
417 @deffn {Función} diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})
418 @deffnx {Función} diff (@var{expr}, @var{x}, @var{n})
419 @deffnx {Función} diff (@var{expr}, @var{x})
420 @deffnx {Función} diff (@var{expr})
421 Devuelve la derivada o diferencial de @var{expr} respecto de alguna o de todas las variables presentes en @var{expr}.
423 La llamada @code{diff (@var{expr}, @var{x}, @var{n})} devuelve la @var{n}-esima derivada de @var{expr} respecto de @var{x}.
425 La llamada @code{diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})}
426 devuelve la derivada parcial de @var{expr} con respecto de @var{x_1}, ..., @var{x_m}.
427 Equivale a @code{diff (... (diff (@var{expr}, @var{x_m}, @var{n_m}) ...), @var{x_1}, @var{n_1})}.
429 La llamada @code{diff (@var{expr}, @var{x})}
430 devuelve la primera derivada de @var{expr} respecto de la variable @var{x}.
432 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.
433 @c WHAT DOES THIS NEXT STATEMENT MEAN, EXACTLY ??
434 @c FALTA AQUI UNA FRASE.
436 La forma nominal de @code{diff} es necesaria en algunos contextos, como para definir ecuaciones diferenciales.
437 En tales casos, @code{diff} puede ir precedida de un apóstrofo (como @code{'diff}) para evitar el cálculo de la derivada.
439 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}.
441 Ejemplos:
442 @c GENERATED FROM THE FOLLOWING
443 @c diff (exp (f(x)), x, 2);
444 @c derivabbrev: true$
445 @c 'integrate (f(x, y), y, g(x), h(x));
446 @c diff (%, x);
448 @example
449 (%i1) diff (exp (f(x)), x, 2);
450 2
451 f(x) d f(x) d 2
452 (%o1) %e (--- (f(x))) + %e (-- (f(x)))
453 2 dx
454 dx
455 (%i2) derivabbrev: true$
456 (%i3) 'integrate (f(x, y), y, g(x), h(x));
457 h(x)
458 /
459 [
460 (%o3) I f(x, y) dy
461 ]
462 /
463 g(x)
464 (%i4) diff (%, x);
465 h(x)
466 /
467 [
468 (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x)
469 ] x x x
470 /
471 g(x)
472 @end example
474 Para el paquete sobre tensores se han introducido las siguientes modificaciones:
476 (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.
478 (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).
480 @c NEED EXAMPLES FOR TENSOR STUFF
481 @end deffn
483 @defvr {Símbolo especial} diff
485 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}.
487 @c NEED EXAMPLE HERE
488 @end defvr
490 @c FALTA DESCRIPCION DE dscalar
492 @deffn {Función} express (@var{expr})
493 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).
495 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}.
497 Es necesario ejecutar @code{load ("vect")} para cargar esta función.
499 Ejemplos:
500 @c GENERATED FROM THE FOLLOWING
501 @c load ("vect")$
502 @c grad (x^2 + y^2 + z^2);
503 @c express (%);
504 @c ev (%, diff);
505 @c div ([x^2, y^2, z^2]);
506 @c express (%);
507 @c ev (%, diff);
508 @c curl ([x^2, y^2, z^2]);
509 @c express (%);
510 @c ev (%, diff);
511 @c laplacian (x^2 * y^2 * z^2);
512 @c express (%);
513 @c ev (%, diff);
514 @c [a, b, c] ~ [x, y, z];
515 @c express (%);
517 @example
518 (%i1) load ("vect")$
519 (%i2) grad (x^2 + y^2 + z^2);
520 2 2 2
521 (%o2) grad (z + y + x )
522 (%i3) express (%);
523 d 2 2 2 d 2 2 2 d 2 2 2
524 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )]
525 dx dy dz
526 (%i4) ev (%, diff);
527 (%o4) [2 x, 2 y, 2 z]
528 (%i5) div ([x^2, y^2, z^2]);
529 2 2 2
530 (%o5) div [x , y , z ]
531 (%i6) express (%);
532 d 2 d 2 d 2
533 (%o6) -- (z ) + -- (y ) + -- (x )
534 dz dy dx
535 (%i7) ev (%, diff);
536 (%o7) 2 z + 2 y + 2 x
537 (%i8) curl ([x^2, y^2, z^2]);
538 2 2 2
539 (%o8) curl [x , y , z ]
540 (%i9) express (%);
541 d 2 d 2 d 2 d 2 d 2 d 2
542 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
543 dy dz dz dx dx dy
544 (%i10) ev (%, diff);
545 (%o10) [0, 0, 0]
546 (%i11) laplacian (x^2 * y^2 * z^2);
547 2 2 2
548 (%o11) laplacian (x y z )
549 (%i12) express (%);
550 2 2 2
551 d 2 2 2 d 2 2 2 d 2 2 2
552 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z )
553 2 2 2
554 dz dy dx
555 (%i13) ev (%, diff);
556 2 2 2 2 2 2
557 (%o13) 2 y z + 2 x z + 2 x y
558 (%i14) [a, b, c] ~ [x, y, z];
559 (%o14) [a, b, c] ~ [x, y, z]
560 (%i15) express (%);
561 (%o15) [b z - c y, c x - a z, a y - b x]
562 @end example
564 @end deffn
566 @deffn {Función} gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})
567 @deffnx {Función} gradef (@var{a}, @var{x}, @var{expr})
568 Define las derivadas parciales, o componentes del gradiente, de la función @var{f} o variable @var{a}.
570 La llamada @code{gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})}
571 define @code{d@var{f}/d@var{x_i}} como @var{g_i},
572 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.
573 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}.
575 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})}.
577 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.
579 La instrucción @code{gradef} puede redefinir las derivadas de las funciones propias de Maxima.
580 Por ejemplo, @code{gradef (sin(x), sqrt (1 - sin(x)^2))} redefine la derivada de @code{sin}.
582 La instrucción @code{gradef} no puede definir derivadas parciales de funciones subindicadas.
584 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}.
586 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}.
588 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.
590 @c REPHRASE THIS NEXT BIT
591 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.
593 @c NEED EXAMPLES HERE
594 @end deffn
596 @defvr {Variable del sistema} gradefs
597 Valor por defecto: @code{[]}
599 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.
601 @end defvr
603 @deffn {Función} laplace (@var{expr}, @var{t}, @var{s})
604 Calcula la transformada de Laplace de @var{expr} con respecto
605 de la variable @var{t} y parámetro de transformación @var{s}.
607 La función @code{laplace} reconoce en @var{expr} las funciones
608 @code{delta}, @code{exp}, @code{log}, @code{sin}, @code{cos},
609 @code{sinh}, @code{cosh} y @code{erf}, así como
610 @code{derivative}, @code{integrate}, @code{sum} y @code{ilt}.
611 Si @code{laplace} no encuentra una transformada, entonces
612 llama a la función @code{specint}, la cual puede encontrar
613 la transformada de Laplace de expresiones con funciones especiales,
614 tales como las de Bessel. @code{specint} también puede manipular la
615 función @code{unit_step}. Véase @code{specint} para más información.
617 Cuando tampoco @code{specint} sea capaz de encontrar una solución,
618 se devolverá una forma nominal.
621 @c REPHRASE THIS
622 @c FALTA AQUI UN PARRAFO
624 La función @code{laplace} reconoce integrales de convolución
625 de la forma @code{integrate (f(x) * g(t - x), x, 0, t)},
626 no pudiendo reconocer otros tipos de convoluciones.
628 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}.
630 Véase también @code{ilt}, la transformada inversa de Laplace.
632 Ejemplos:
633 @c GENERATED FROM THE FOLLOWING:
634 @c laplace (exp (2*t + a) * sin(t) * t, t, s);
635 @c laplace ('diff (f (x), x), x, s);
636 @c diff (diff (delta (t), t), t);
637 @c laplace (%, t, s);
639 @example
640 (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
641 a
642 %e (2 s - 4)
643 (%o1) ---------------
644 2 2
645 (s - 4 s + 5)
646 (%i2) laplace ('diff (f (x), x), x, s);
647 (%o2) s laplace(f(x), x, s) - f(0)
648 (%i3) diff (diff (delta (t), t), t);
649 2
650 d
651 (%o3) --- (delta(t))
652 2
653 dt
654 (%i4) laplace (%, t, s);
655 !
656 d ! 2
657 (%o4) - -- (delta(t))! + s - delta(0) s
658 dt !
659 !t = 0
660 (%i5) assume(a>0)$
661 (%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true;
662 - a - 1
663 gamma(a) gamma(a) s
664 (%o6) -------- - -----------------
665 s 1 a
666 (- + 1)
667 s
668 (%i7) factor(laplace(gamma_incomplete(1/2,t),t,s));
669 s + 1
670 sqrt(%pi) (sqrt(s) sqrt(-----) - 1)
671 s
672 (%o7) -----------------------------------
673 3/2 s + 1
674 s sqrt(-----)
675 s
676 (%i8) assume(exp(%pi*s)>1)$
677 (%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s),simpsum;
678 %i %i
679 ------------------------ - ------------------------
680 - %pi s - %pi s
681 (s + %i) (1 - %e ) (s - %i) (1 - %e )
682 (%o9) ---------------------------------------------------
683 2
684 (%i9) factor(%);
685 %pi s
686 %e
687 (%o9) -------------------------------
688 %pi s
689 (s - %i) (s + %i) (%e - 1)
691 @end example
693 @end deffn