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