| blob | 3f8b2a8bb39b840d9d553366fbf42b2b3843e042 |
1 @c /Differentiation.texi/1.19/Sun Jun 12 19:13:47 2005/-ko/
2 @c end concepts Differentiation
3 @menu
4 * Definições para Diferenciação::
5 @end menu
7 @node Definições para Diferenciação, , Diferenciação, Diferenciação
8 @section Definições para Diferenciação
10 @deffn {Função} antid (@var{expr}, @var{x}, @var{u(x)})
11 Retorna uma lista de dois elementos,
12 tais que uma antiderivada de @var{expr} com relação a @var{x}
13 pode ser constuída a partir da lista.
14 A expressão @var{expr} pode conter uma função desconhecida @var{u} e suas derivadas.
16 Tome @var{L}, uma lista de dois elementos, como sendo o valor de retorno de @code{antid}.
17 Então @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
18 é uma antiderivada de @var{expr} com relação a @var{x}.
20 Quando @code{antid} obtém sucesso inteiramente,
21 o segundo elemento do valor de retorno é zero.
22 De outra forma, o segundo elemento é não zero,
23 e o primeiro elemento não zero ou zero.
24 Se @code{antid} não pode fazer nenhum progresso,
25 o primeiro elemento é zero e o segundo não zero.
27 @code{load ("antid")} chama essa função.
28 O pacote @code{antid} também define as funções @code{nonzeroandfreeof} e @code{linear}.
30 @code{antid} está relacionada a @code{antidiff} como segue.
31 Tome @var{L}, uma lista de dois elementos, que é o valor de retorno de @code{antid}.
32 Então o valor de retorno de @code{antidiff} é igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
33 onde @var{x} é a variável de integração.
35 Exemplos:
36 @c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
37 @c load ("antid")$
38 @c expr: exp (z(x)) * diff (z(x), x) * y(x);
39 @c a1: antid (expr, x, z(x));
40 @c a2: antidiff (expr, x, z(x));
41 @c a2 - (first (a1) + 'integrate (second (a1), x));
42 @c antid (expr, x, y(x));
43 @c antidiff (expr, x, y(x));
44 @c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
45 @c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
46 @c MAYBE MERGE IN THE DEMO PROBLEMS LATER
48 @example
49 (%i1) load ("antid")$
50 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
51 z(x) d
52 (%o2) y(x) %e (-- (z(x)))
53 dx
54 (%i3) a1: antid (expr, x, z(x));
55 z(x) z(x) d
56 (%o3) [y(x) %e , - %e (-- (y(x)))]
57 dx
58 (%i4) a2: antidiff (expr, x, z(x));
59 /
60 z(x) [ z(x) d
61 (%o4) y(x) %e - I %e (-- (y(x))) dx
62 ] dx
63 /
64 (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
65 (%o5) 0
66 (%i6) antid (expr, x, y(x));
67 z(x) d
68 (%o6) [0, y(x) %e (-- (z(x)))]
69 dx
70 (%i7) antidiff (expr, x, y(x));
71 /
72 [ z(x) d
73 (%o7) I y(x) %e (-- (z(x))) dx
74 ] dx
75 /
76 @end example
78 @end deffn
80 @deffn {Função} antidiff (@var{expr}, @var{x}, @var{u}(@var{x}))
81 Retorna uma antiderivada de @var{expr} com relação a @var{x}.
82 A expressão @var{expr} pode conter uma função desconhecida @var{u} e suas derivadas.
84 Quando @code{antidiff} obtém sucesso inteiramente,
85 a expressão resultante é livre do sinal de integral (isto é, livre do substantivo @code{integrate}).
86 De outra forma, @code{antidiff} retorna uma expressão
87 que é parcialmente ou inteiramente dentro de um sinal de um sinal de integral.
88 Se @code{antidiff} não pode fazer qualquer progresso,
89 o valor de retorno é inteiramente dentro de um sinal de integral.
91 @code{load ("antid")} chama essa função.
92 O pacote @code{antid} também define as funções @code{nonzeroandfreeof} e @code{linear}.
94 @code{antidiff} é relacionada a @code{antid} como segue.
95 Tome @var{L}, uma lista de dois elementos, como sendo o valor de retorno de @code{antid}.
96 Então o valor de retorno de @code{antidiff} é igual a @code{@var{L}[1] + 'integrate (@var{L}[2], @var{x})}
97 onde @var{x} é a variável de integração.
99 Exemplos:
100 @c FOLLOWING EXAMPLES GENERATED FROM THESE INPUTS
101 @c load ("antid")$
102 @c expr: exp (z(x)) * diff (z(x), x) * y(x);
103 @c a1: antid (expr, x, z(x));
104 @c a2: antidiff (expr, x, z(x));
105 @c a2 - (first (a1) + 'integrate (second (a1), x));
106 @c antid (expr, x, y(x));
107 @c antidiff (expr, x, y(x));
108 @c THERE IS A DEMO FILE share/integration/antid.dem, EXECUTED BY demo('antid)
109 @c BUT I THINK THE FOLLOWING ILLUSTRATES THE BASIC FUNCTIONALITY MORE CLEARLY
110 @c MAYBE MERGE IN THE DEMO PROBLEMS LATER
112 @example
113 (%i1) load ("antid")$
114 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
115 z(x) d
116 (%o2) y(x) %e (-- (z(x)))
117 dx
118 (%i3) a1: antid (expr, x, z(x));
119 z(x) z(x) d
120 (%o3) [y(x) %e , - %e (-- (y(x)))]
121 dx
122 (%i4) a2: antidiff (expr, x, z(x));
123 /
124 z(x) [ z(x) d
125 (%o4) y(x) %e - I %e (-- (y(x))) dx
126 ] dx
127 /
128 (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
129 (%o5) 0
130 (%i6) antid (expr, x, y(x));
131 z(x) d
132 (%o6) [0, y(x) %e (-- (z(x)))]
133 dx
134 (%i7) antidiff (expr, x, y(x));
135 /
136 [ z(x) d
137 (%o7) I y(x) %e (-- (z(x))) dx
138 ] dx
139 /
140 @end example
142 @end deffn
144 @c I SUSPECT THERE IS MORE TO BE SAID HERE
145 @defvr propriedade atomgrad
147 @code{atomgrad} é a propriedade do gradiente at@^omico de uma expressão.
148 Essa propriedade é atribuída por @code{gradef}.
150 @c NEED EXAMPLE HERE
151 @end defvr
153 @deffn {Função} atvalue (@var{expr}, [@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}], @var{c})
154 @deffnx {Função} atvalue (@var{expr}, @var{x_1} = @var{a_1}, @var{c})
155 Atribui o valor @var{c} a @var{expr} no ponto @code{@var{x} = @var{a}}.
156 Tipicamente valores de extremidade são estabelecidos por esse mecanismo.
158 @var{expr} é a função de avaliação,
159 @code{@var{f}(@var{x_1}, ..., @var{x_m})},
160 ou uma derivada,
161 @code{diff (@var{f}(@var{x_1}, ..., @var{x_m}), @var{x_1}, @var{n_1}, ..., @var{x_n}, @var{n_m})}
162 @c HMM, WHAT IS THIS NEXT PHRASE GETTING AT ??
163 @c DOES IT INTEND TO IMPLY THAT IMPLICIT DEPENDENCIES ARE IGNORED ??
164 na qual os argumentos da função explicitamente aparecem.
165 @var{n_i} é a ordem de diferenciação com relação a @var{x_i}.
167 O ponto no qual o @code{atvalue} é estabelecido é dado pela lista de equações
168 @code{[@var{x_1} = @var{a_1}, ..., @var{x_m} = @var{a_m}]}.
169 Se existe uma variável simples @var{x_1},
170 uma única equação pode ser dada sem ser contida em uma lista.
172 @code{printprops ([@var{f_1}, @var{f_2}, ...], atvalue)} mostra os @code{atvalues} das
173 funções @code{@var{f_1}, @var{f_2}, ...}
174 como especificado por chamadas a @code{atvalue}.
175 @code{printprops (@var{f}, atvalue)} mostra os @code{atvalues} de uma função @var{f}.
176 @code{printprops (all, atvalue)} mostra os @code{atvalue}s de todas as funções para as quais @code{atvalue}s são definidos.
178 Os simbolos @code{@@1}, @code{@@2}, ... representam as
179 variáveis @var{x_1}, @var{x_2}, ... quando @code{atvalue}s são mostrados.
181 @code{atvalue} avalia seus argumentos.
182 @code{atvalue} retorna @var{c}, o @code{atvalue}.
184 Exemplos:
185 @c FOLLOWING ADAPTED FROM example (atvalue)
186 @c atvalue (f(x,y), [x = 0, y = 1], a^2);
187 @c atvalue ('diff (f(x,y), x), x = 0, 1 + y);
188 @c printprops (all, atvalue);
189 @c diff (4*f(x,y)^2 - u(x,y)^2, x);
190 @c at (%, [x = 0, y = 1]);
192 @example
193 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
194 2
195 (%o1) a
196 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
197 (%o2) @@2 + 1
198 (%i3) printprops (all, atvalue);
199 !
200 d !
201 --- (f(@@1, @@2))! = @@2 + 1
202 d@@1 !
203 !@@1 = 0
205 2
206 f(0, 1) = a
208 (%o3) done
209 (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
210 d d
211 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
212 dx dx
213 (%i5) at (%, [x = 0, y = 1]);
214 !
215 2 d !
216 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! )
217 dx !
218 !x = 0, y = 1
219 @end example
221 @end deffn
223 @c LOOKS LIKE cartan IS THE NAME OF A PACKAGE AND NOT A FUNCTION OR VARIABLE
224 @c PROBABLY SHOULD SPLIT OUT cartan AND ITS CONTENTS INTO ITS OWN TEXINFO FILE
225 @c ext_diff AND lie_diff NOT DOCUMENTED (OTHER THAN HERE)
226 @deffn {Função} cartan -
227 O cálculo exterior de formas diferenciais é uma ferramenta básica
228 de geometria diferencial desenvolvida por Elie Cartan e tem importantes
229 aplicações na teoria das equações diferenciais parciais.
230 O pacote @code{cartan}
231 implementa as funções @code{ext_diff} e @code{lie_diff},
232 juntamente com os operadores @code{~} (produto da cunha) e @code{|} (contração
233 de uma forma com um vector.)
234 Digite @code{demo (tensor)} para ver uma breve
235 descrição desses comandos juntamente com exemplos.
237 @code{cartan} foi implementado por F.B. Estabrook e H.D. Wahlquist.
239 @end deffn
241 @deffn {Função} del (@var{x})
242 @code{del (@var{x})} representa a diferencial da variável @math{x}.
244 @code{diff} retorna uma expressão contendo @code{del}
245 se uma variável independente não for especificada.
246 Nesse caso, o valor de retorno é a então chamada "diferencial total".
248 Exemplos:
249 @c GENERATED FROM THE FOLLOWING
250 @c diff (log (x));
251 @c diff (exp (x*y));
252 @c diff (x*y*z);
254 @example
255 (%i1) diff (log (x));
256 del(x)
257 (%o1) ------
258 x
259 (%i2) diff (exp (x*y));
260 x y x y
261 (%o2) x %e del(y) + y %e del(x)
262 (%i3) diff (x*y*z);
263 (%o3) x y del(z) + x z del(y) + y z del(x)
264 @end example
266 @end deffn
268 @deffn {Função} delta (@var{t})
269 A função Delta de Dirac.
271 Correntemente somente @code{laplace} sabe sobre a função @code{delta}.
273 Exemplo:
275 @example
276 (%i1) laplace (delta (t - a) * sin(b*t), t, s);
277 Is a positive, negative, or zero?
279 p;
280 - a s
281 (%o1) sin(a b) %e
282 @end example
284 @end deffn
286 @defvr {Variável} dependencies
287 Valor por omissão: @code{[]}
289 @code{dependencies} é a lista de átomos que possuem dependências
290 funcionais, atribuídas por @code{depends} ou @code{gradef}.
291 A lista @code{dependencies} é cumulativa:
292 cada chamada a @code{depends} ou a @code{gradef} anexa ítens adicionais.
294 Veja @code{depends} e @code{gradef}.
296 @end defvr
298 @deffn {Função} depends (@var{f_1}, @var{x_1}, ..., @var{f_n}, @var{x_n})
299 Declara dependêcias funcionais entre variáveis para o propósito de calcular derivadas.
300 Na ausência de dependêcias declaradas,
301 @code{diff (f, x)} retorna zero.
302 Se @code{depends (f, x)} for declarada,
303 @code{diff (f, x)} retorna uma derivada simbólica (isto é, um substantivo @code{diff}).
305 Cada argumento @var{f_1}, @var{x_1}, etc., pode ser o nome de uma variável ou array,
306 ou uma lista de nomes.
307 Todo elemento de @var{f_i} (talvez apenas um elemento simples)
308 é declarado para depender
309 de todo elemento de @var{x_i} (talvez apenas um elemento simples).
310 Se algum @var{f_i} for o nome de um array ou contém o nome de um array,
311 todos os elementos do array dependem de @var{x_i}.
313 @code{diff} reconhece dependências indirectas estabelecidas por @code{depends}
314 e aplica a regra da cadeia nesses casos.
316 @code{remove (@var{f}, dependency)} remove todas as dependências declaradas para @var{f}.
318 @code{depends} retorna uma lista de dependências estabelecidas.
319 As dependências são anexadas à variável global @code{dependencies}.
320 @code{depends} avalia seus argumentos.
322 @code{diff} é o único comando Maxima que reconhece dependências estabelecidas por @code{depends}.
323 Outras funções (@code{integrate}, @code{laplace}, etc.)
324 somente reconhecem dependências explicitamente representadas por seus argumentos.
325 Por exemplo, @code{integrate} não reconhece a dependência de @code{f} sobre @code{x}
326 a menos que explicitamente representada como @code{integrate (f(x), x)}.
328 @c GENERATED BY THE FOLLOWING
329 @c depends ([f, g], x);
330 @c depends ([r, s], [u, v, w]);
331 @c depends (u, t);
332 @c dependencies;
333 @c diff (r.s, u);
334 @example
335 (%i1) depends ([f, g], x);
336 (%o1) [f(x), g(x)]
337 (%i2) depends ([r, s], [u, v, w]);
338 (%o2) [r(u, v, w), s(u, v, w)]
339 (%i3) depends (u, t);
340 (%o3) [u(t)]
341 (%i4) dependencies;
342 (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
343 (%i5) diff (r.s, u);
344 dr ds
345 (%o5) -- . s + r . --
346 du du
347 @end example
349 @c GENERATED BY THE FOLLOWING
350 @c diff (r.s, t);
351 @example
352 (%i6) diff (r.s, t);
353 dr du ds du
354 (%o6) -- -- . s + r . -- --
355 du dt du dt
356 @end example
358 @c GENERATED BY THE FOLLOWING
359 @c remove (r, dependency);
360 @c diff (r.s, t);
361 @example
362 (%i7) remove (r, dependency);
363 (%o7) done
364 (%i8) diff (r.s, t);
365 ds du
366 (%o8) r . -- --
367 du dt
368 @end example
370 @end deffn
372 @defvr {Variável de opção} derivabbrev
373 Valor por omissão: @code{false}
375 Quando @code{derivabbrev} for @code{true},
376 derivadas simbólicas (isto é, substantivos @code{diff}) são mostradas como subscritos.
377 De outra forma, derivadas são mostradas na notação de Leibniz @code{dy/dx}.
379 @c NEED EXAMPLES HERE
380 @end defvr
382 @c SEEMS LIKE THIS STATEMENT COULD BE LESS CLUMSY
383 @deffn {Função} derivdegree (@var{expr}, @var{y}, @var{x})
384 Retorna o maior grau de uma derivada
385 da variável dependente @var{y} com relação à variável independente
386 @var{x} ocorrendo em @var{expr}.
388 Exemplo:
389 @c GENERATED FROM THE FOLLOWING
390 @c 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
391 @c derivdegree (%, y, x);
392 @example
393 (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
394 3 2
395 d y d y 2 dy
396 (%o1) --- + --- + x --
397 3 2 dx
398 dz dx
399 (%i2) derivdegree (%, y, x);
400 (%o2) 2
401 @end example
403 @end deffn
405 @c I HAVE NO IDEA WHAT THIS DOES
406 @deffn {Função} derivlist (@var{var_1}, ..., @var{var_k})
407 Causa somente diferenciações com relação às
408 variáveis indicadas, dentro do comando @code{ev}.
410 @end deffn
412 @defvr {Variável de opção} derivsubst
413 Valor por omissão: @code{false}
415 Quando @code{derivsubst} for @code{true}, uma substiruíção não sintática tais como
416 @code{subst (x, 'diff (y, t), 'diff (y, t, 2))} retorna @code{'diff (x, t)}.
418 @end defvr
420 @deffn {Função} diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})
421 @deffnx {Função} diff (@var{expr}, @var{x}, @var{n})
422 @deffnx {Função} diff (@var{expr}, @var{x})
423 @deffnx {Função} diff (@var{expr})
424 Retorna uma derivada ou diferencial de @var{expr} com relação a alguma ou todas as variáveis em @var{expr}.
426 @code{diff (@var{expr}, @var{x}, @var{n})} retorna a @var{n}'ésima derivada de @var{expr}
427 com relação a @var{x}.
429 @code{diff (@var{expr}, @var{x_1}, @var{n_1}, ..., @var{x_m}, @var{n_m})}
430 retorna a derivada parcial mista de @var{expr} com relação a @var{x_1}, ..., @var{x_m}.
431 Isso é equivalente a @code{diff (... (diff (@var{expr}, @var{x_m}, @var{n_m}) ...), @var{x_1}, @var{n_1})}.
433 @code{diff (@var{expr}, @var{x})}
434 retorna a primeira derivada de @var{expr} com relação a
435 uma variável @var{x}.
437 @code{diff (@var{expr})} retorna a diferencial total de @var{expr},
438 isto é, a soma das derivadas de @var{expr} com relação a cada uma de suas variáveis
439 vezes a diferencial @code{del} de cada variável.
440 @c WHAT DOES THIS NEXT STATEMENT MEAN, EXACTLY ??
441 Nenhuma simplificação adicional de @code{del} é oferecida.
443 A forma substantiva de @code{diff} é requerida em alguns contextos,
444 tal como declarando uma equação diferencial.
445 Nesses casos, @code{diff} pode ser colocado apóstrofo (com @code{'diff}) para retornar a forma substantiva
446 em lugar da realização da diferenciação.
448 Quando @code{derivabbrev} for @code{true}, derivadas são mostradas como subscritos.
449 De outra forma, derivadas são mostradas na notação de Leibniz, @code{dy/dx}.
451 Exemplos:
452 @c GENERATED FROM THE FOLLOWING
453 @c diff (exp (f(x)), x, 2);
454 @c derivabbrev: true$
455 @c 'integrate (f(x, y), y, g(x), h(x));
456 @c diff (%, x);
458 @example
459 (%i1) diff (exp (f(x)), x, 2);
460 2
461 f(x) d f(x) d 2
462 (%o1) %e (--- (f(x))) + %e (-- (f(x)))
463 2 dx
464 dx
465 (%i2) derivabbrev: true$
466 (%i3) 'integrate (f(x, y), y, g(x), h(x));
467 h(x)
468 /
469 [
470 (%o3) I f(x, y) dy
471 ]
472 /
473 g(x)
474 (%i4) diff (%, x);
475 h(x)
476 /
477 [
478 (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x)
479 ] x x x
480 /
481 g(x)
482 @end example
484 Para o pacote tensor, as seguintes modificações foram
485 incorporadas:
487 (1) As derivadas de quaisquer objectos indexados em @var{expr} terão as
488 variáveis @var{x_i} anexadas como argumentos adicionais. Então todos os
489 índices de derivada serão ordenados.
491 (2) As variáveis @var{x_i} podem ser inteiros de 1 até o valor de uma variável
492 @code{dimension} [valor padrão: 4]. Isso fará com que a diferenciação
493 seja concluída com relação aos @var{x_i}'ésimos membros da lista @code{coordinates} que
494 pode ser escolhida para uma lista de nomes de coordenadas, e.g.,
495 @code{[x, y, z, t]}. Se @code{coordinates} for associada a uma variável at@^omica, então aquela
496 variável subscrita por @var{x_i} será usada para uma variável de
497 diferenciação. Isso permite um array de nomes de coordenadas ou
498 nomes subscritos como @code{X[1]}, @code{X[2]}, ... sejam usados. Se @code{coordinates} não
499 foram atribuídas um valor, então as variáveis seram tratadas como em (1)
500 acima.
502 @c NEED EXAMPLES FOR TENSOR STUFF
503 @end deffn
505 @c MERGE THIS INTO @defun diff
506 @defvr {Símbolo especial} diff
508 Quando @code{diff} está presente como um @code{evflag} em chamadas para @code{ev},
509 Todas as diferenciações indicadas em @code{expr} são realizdas.
511 @c NEED EXAMPLE HERE
512 @end defvr
514 @c NOT SURE HOW THIS IS SUPPOSED TO WORK
515 @deffn {Função} dscalar (@var{f})
516 Aplica o d'Alembertiano escalar para a função escalar @var{f}.
518 @c APPARENTLY dscalar DOESN'T EXIST IN THE CORE FILES ANYMORE
519 @c ctensor HAS THE ONLY DEFN I FOUND (OUTSIDE OF archive/)
520 @code{load ("ctensor")} chama essa função.
522 @c FOLLOWING EXAMPLE DOESN'T WORK; I GET dscalar (field) ==> 0
523 @c (I GET 0 FOR THE ctensor VERSION OF dscalar, AND SAME FOR
524 @c THE DEFN OF dscalar GIVEN IN archive/share/lisp/ctensr.trl)
525 @c INCIDENTALLY dependencies IS DOCUMENTED ONLY AS A VARIABLE
527 @c @example
528 @c (%i41) dependencies(field(r));
529 @c (%o41) [field(r)]
530 @c (%i42) dscalar(field);
531 @c (%o43)
532 @c -m
533 @c %e ((field n - field m + 2 field ) r + 4 field )
534 @c r r r r r r r
535 @c
536 @c - -----------------------------------------------------
537 @c 2 r
538 @c @end example
540 @end deffn
542 @deffn {Função} express (@var{expr})
543 @c HERE IS THE PREVIOUS TEXT. WHAT IS THE POINT ABOUT depends ?? I'M NOT GETTING IT
544 @c The result uses the noun form of any
545 @c derivadas arising from expansion of the vector differential
546 @c operators. To force evaluation of these derivadas, the built-in @code{ev}
547 @c função can be used together with the @code{diff} evflag, after using the
548 @c built-in @code{depends} função to establish any new implicit dependências.
550 Expande o substantivo do operador diferencial em expressões em termos de derivadas parciais.
551 @code{express} reconhece os operadores @code{grad}, @code{div}, @code{curl}, @code{laplacian}.
552 @code{express} também expande o produto do X @code{~}.
554 Derivadas simbólicas (isto é, substantivos @code{diff})
555 no valor de retorno de @code{express} podem ser avaliadas incluíndo @code{diff}
556 na chamada à função @code{ev} ou na linha de comando.
557 Nesse contexto, @code{diff} age como uma @code{evfun}.
559 @code{load ("vect")} chama essa função.
560 @c IN POINT OF FACT, express IS A SIMPLIFICATION RULE, AND express1 IS THE FCN WHICH DOES ALL THE WORK
562 Exemplos:
563 @c GENERATED FROM THE FOLLOWING
564 @c load ("vect")$
565 @c grad (x^2 + y^2 + z^2);
566 @c express (%);
567 @c ev (%, diff);
568 @c div ([x^2, y^2, z^2]);
569 @c express (%);
570 @c ev (%, diff);
571 @c curl ([x^2, y^2, z^2]);
572 @c express (%);
573 @c ev (%, diff);
574 @c laplacian (x^2 * y^2 * z^2);
575 @c express (%);
576 @c ev (%, diff);
577 @c [a, b, c] ~ [x, y, z];
578 @c express (%);
580 @example
581 (%i1) load ("vect")$
582 (%i2) grad (x^2 + y^2 + z^2);
583 2 2 2
584 (%o2) grad (z + y + x )
585 (%i3) express (%);
586 d 2 2 2 d 2 2 2 d 2 2 2
587 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )]
588 dx dy dz
589 (%i4) ev (%, diff);
590 (%o4) [2 x, 2 y, 2 z]
591 (%i5) div ([x^2, y^2, z^2]);
592 2 2 2
593 (%o5) div [x , y , z ]
594 (%i6) express (%);
595 d 2 d 2 d 2
596 (%o6) -- (z ) + -- (y ) + -- (x )
597 dz dy dx
598 (%i7) ev (%, diff);
599 (%o7) 2 z + 2 y + 2 x
600 (%i8) curl ([x^2, y^2, z^2]);
601 2 2 2
602 (%o8) curl [x , y , z ]
603 (%i9) express (%);
604 d 2 d 2 d 2 d 2 d 2 d 2
605 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
606 dy dz dz dx dx dy
607 (%i10) ev (%, diff);
608 (%o10) [0, 0, 0]
609 (%i11) laplacian (x^2 * y^2 * z^2);
610 2 2 2
611 (%o11) laplacian (x y z )
612 (%i12) express (%);
613 2 2 2
614 d 2 2 2 d 2 2 2 d 2 2 2
615 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z )
616 2 2 2
617 dz dy dx
618 (%i13) ev (%, diff);
619 2 2 2 2 2 2
620 (%o13) 2 y z + 2 x z + 2 x y
621 (%i14) [a, b, c] ~ [x, y, z];
622 (%o14) [a, b, c] ~ [x, y, z]
623 (%i15) express (%);
624 (%o15) [b z - c y, c x - a z, a y - b x]
625 @end example
627 @end deffn
629 @c COMMENTING OUT THIS TEXT PENDING RESOLUTION OF BUG REPORT # 836704:
630 @c "gendiff is all bugs: should be deprecated"
631 @c @defun gendiff
632 @c Sometimes @code{diff(e,x,n)} can be reduced even though N is
633 @c symbolic.
634 @c
635 @c @example
636 @c batch("gendif")$
637 @c @end example
638 @c
639 @c and you can try, for example,
640 @c
641 @c @example
642 @c diff(%e^(a*x),x,q)
643 @c @end example
644 @c
645 @c by using @code{gendiff} rather than @code{diff}. Unevaluable
646 @c items come out quoted. Some items are in terms of @code{genfact}, which
647 @c see.
648 @c
649 @c @end defun
651 @deffn {Função} gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})
652 @deffnx {Função} gradef (@var{a}, @var{x}, @var{expr})
653 Define as derivadas parciais (i.e., os componentes do gradiente) da função @var{f}
654 ou variável @var{a}.
656 @code{gradef (@var{f}(@var{x_1}, ..., @var{x_n}), @var{g_1}, ..., @var{g_m})}
657 define @code{d@var{f}/d@var{x_i}} como @var{g_i},
658 onde @var{g_i} é uma expressão; @var{g_i} pode ser uma chamada de função, mas não o nome de uma função.
659 O número de derivadas parciais @var{m} pode ser menor que o número de argumentos @var{n},
660 nesses casos derivadas são definidas com relação a @var{x_1} até @var{x_m} somente.
662 @code{gradef (@var{a}, @var{x}, @var{expr})} define uma derivada de variável @var{a}
663 com relação a @var{x} como @var{expr}.
664 Isso também estabelece a dependência de @var{a} sobre @var{x} (via @code{depends (@var{a}, @var{x})}).
666 O primeiro argumento @code{@var{f}(@var{x_1}, ..., @var{x_n})} ou @var{a} é acompanhado de apóstrofo,
667 mas os argumentos restantes @var{g_1}, ..., @var{g_m} são avaliados.
668 @code{gradef} retorna a função ou variável para as quais as derivadas parciais são definidas.
670 @code{gradef} pode redefinir as derivadas de funções internas do Maxima.
671 Por exemplo, @code{gradef (sin(x), sqrt (1 - sin(x)^2))} redefine uma derivada de @code{sin}.
673 @code{gradef} não pode definir derivadas parciais para um função subscrita.
675 @code{printprops ([@var{f_1}, ..., @var{f_n}], gradef)} mostra as derivadas parciais
676 das funções @var{f_1}, ..., @var{f_n}, como definidas por @code{gradef}.
678 @code{printprops ([@var{a_n}, ..., @var{a_n}], atomgrad)} mostra as derivadas parciais
679 das variáveis @var{a_n}, ..., @var{a_n}, como definidas por @code{gradef}.
681 @code{gradefs} é a lista de funções
682 para as quais derivadas parciais foram definidas por @code{gradef}.
683 @code{gradefs} não inclui quaisquer variáveis
684 para quais derivadas parciais foram definidas por @code{gradef}.
686 @c REPHRASE THIS NEXT BIT
687 Gradientes são necessários quando, por exemplo, uma função não é conhecida
688 explicitamente mas suas derivadas primeiras são e isso é desejado para obter
689 derivadas de ordem superior.
691 @c NEED EXAMPLES HERE
692 @end deffn
694 @defvr {Variável de sistema} gradefs
695 Valor por omissão: @code{[]}
697 @code{gradefs} é a lista de funções
698 para as quais derivadas parciais foram definidas por @code{gradef}.
699 @code{gradefs} não inclui quaisquer variáveis
700 para as quais derivadas parciais foram deinidas por @code{gradef}.
702 @end defvr
704 @deffn {Função} laplace (@var{expr}, @var{t}, @var{s})
705 Tenta calcular a transformada de Laplace de @var{expr} com relação a uma variável @var{t}
706 e parâmetro de transformação @var{s}.
707 Se @code{laplace} não pode achar uma solução, um substantivo @code{'laplace} é retornado.
709 @code{laplace} reconhece em @var{expr} as funções
710 @code{delta}, @code{exp}, @code{log}, @code{sin}, @code{cos}, @code{sinh}, @code{cosh}, e @code{erf},
711 também @code{derivative}, @code{integrate}, @code{sum}, e @code{ilt}.
712 Se algumas outras funções estiverem presente,
713 @code{laplace} pode não ser habilitada a calcular a tranformada.
715 @c REPHRASE THIS
716 @var{expr} pode também ser uma equação linear, diferencial de coeficiente contante no
717 qual caso o @code{atvalue} da variável dependente é usado.
718 @c "used" -- USED HOW ??
719 O requerido @code{atvalue} pode ser fornecido ou antes ou depois da transformada ser calculada.
720 Uma vez que as condições iniciais devem ser especificadas em zero, se um teve condições
721 de limite impostas em qualquer outro lugar ele pode impor essas sobre a solução
722 geral e eliminar as constantes resolvendo a solução geral
723 para essas e substituindo seus valores de volta.
725 @code{laplace} reconhece integrais de convolução da forma
726 @code{integrate (f(x) * g(t - x), x, 0, t)};
727 outros tipos de convoluções não são reconhecidos.
729 Relações funcionais devem ser explicitamente representadas em @var{expr};
730 relações implícitas, estabelecidas por @code{depends}, não são reconhecidas.
731 Isto é, se @var{f} depende de @var{x} e @var{y},
732 @code{f (x, y)} deve aparecer em @var{expr}.
734 Veja também @code{ilt}, a transformada inversa de Laplace.
736 Exemplos:
737 @c GENERATED FROM THE FOLLOWING:
738 @c laplace (exp (2*t + a) * sin(t) * t, t, s);
739 @c laplace ('diff (f (x), x), x, s);
740 @c diff (diff (delta (t), t), t);
741 @c laplace (%, t, s);
743 @example
744 (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
745 a
746 %e (2 s - 4)
747 (%o1) ---------------
748 2 2
749 (s - 4 s + 5)
750 (%i2) laplace ('diff (f (x), x), x, s);
751 (%o2) s laplace(f(x), x, s) - f(0)
752 (%i3) diff (diff (delta (t), t), t);
753 2
754 d
755 (%o3) --- (delta(t))
756 2
757 dt
758 (%i4) laplace (%, t, s);
759 !
760 d ! 2
761 (%o4) - -- (delta(t))! + s - delta(0) s
762 dt !
763 !t = 0
764 @end example
766 @end deffn