| blob | 2631d2bb1f91d99503cd6a2ec5a831e487c1d0be |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Rules.texi/1.26/Sat Jun 2 00:13:06 2007/-ko/
3 @menu
4 * Introduç@~{a}o a Regras e Modelos::
5 * Funç@~{o}es e Vari@'{a}veis Definidas para Regras e Modelos::
6 @end menu
8 @node Introduç@~{a}o a Regras e Modelos, Funç@~{o}es e Vari@'{a}veis Definidas para Regras e Modelos, Regras e Modelos, Regras e Modelos
9 @section Introduç@~{a}o a Regras e Modelos
11 Essa seç@~{a}o descreve coincid@^{e}ncias de modelos definidos pelo usu@'{a}rio e
12 regras de simplificaç@~{a}o.
13 Existem dois grupos de funç@~{o}es que implementam at@'{e} certo ponto diferentes esquemas de coincid@^{e}ncia de modelo.
14 Em um grupo est@~{a}o @code{tellsimp}, @code{tellsimpafter}, @code{defmatch}, @code{defrule},
15 @code{apply1}, @code{applyb1}, e @code{apply2}.
16 Em outro grupo est@~{a}o @code{let} e @code{letsimp}.
17 Ambos os esquemas definem modelos em termos de vari@'{a}veis de modelo declaradas por @code{matchdeclare}.
19 Regras de coincid@^{e}ncia de modelos definidas por @code{tellsimp} e @code{tellsimpafter} s@~{a}o aplicadas automaticamente
20 atrav@'{e}s do simplificador do Maxima.
21 Regras definidas atrav@'{e}s de @code{defmatch}, @code{defrule}, e @code{let} s@~{a}o aplicadas
22 atrav@'{e}s de uma chamada expl@'{i}cita de funç@~{a}o.
24 Existe mecanismos adicionais para regras aplicadas a polin@^{o}mios atrav@'{e}s de @code{tellrat},
25 e para @'{a}lgebra comutativa e n@~{a}o comutativa no pacote @code{affine}.
27 @c end concepts Rules and Patterns
28 @node Funç@~{o}es e Vari@'{a}veis Definidas para Regras e Modelos, , Introduç@~{a}o a Regras e Modelos, Regras e Modelos
29 @section Funç@~{o}es e Vari@'{a}veis Definidas para Regras e Modelos
31 @c NEEDS CLARIFICATION AND EXAMPLES
32 @deffn {Funç@~{a}o} apply1 (@var{expr}, @var{rule_1}, ..., @var{rule_n})
33 Repetidamente aplica @var{rule_1} a
34 @var{expr} at@'{e} que isso falhe, ent@~{a}o repetidamente aplica a mesma regra a todas
35 as subexpress@~{o}es de @var{expr}, da esquerda para a direita, at@'{e} que @var{rule_1} tenha falhado
36 sobre todas as subexpress@~{o}es. Chama o resultado da transformaç@~{a}o de @var{expr} dessa
37 maneira de @var{expr_2}. Ent@~{a}o @var{rule_2} @'{e} aplicada no mesmo estilo
38 iniciando no topo de @var{expr_2}. Quando @var{rule_n} falhar na subexpress@~{a}o
39 final, o resultado @'{e} retornado.
41 @code{maxapplydepth} @'{e} a intensidade de n@'{i}vel mais distante de subexpress@~{o}es processadas por
42 @code{apply1} e @code{apply2}.
44 Veja tamb@'{e}m @code{applyb1}, @code{apply2}, e @code{let}.
46 @end deffn
48 @c NEEDS CLARIFICATION AND EXAMPLES
49 @deffn {Funç@~{a}o} apply2 (@var{expr}, @var{rule_1}, ..., @var{rule_n})
50 Se @var{rule_1} falhar sobre uma dada subexpress@~{a}o, ent@~{a}o @var{rule_2} @'{e}
51 repetidamente aplicada, etc. Somente se todas as regras falharem sobre uma dada
52 subexpress@~{a}o @'{e} que o conjunto completo de regras @'{e} repetidamente aplicada @`a pr@'{o}xima
53 subexpress@~{a}o. Se uma das regras obt@'{e}m sucesso, ent@~{a}o a mesma
54 subexpress@~{a}o @'{e} reprocessada, iniciando com a primeira regra.
56 @code{maxapplydepth} @'{e} a intensidade do n@'{i}vel mais distante de subexpress@~{o}es processadas atrav@'{e}s de
57 @code{apply1} e @code{apply2}.
59 Veja tamb@'{e}m @code{apply1} e @code{let}.
61 @end deffn
63 @c NEEDS CLARIFICATION AND EXAMPLES
64 @deffn {Funç@~{a}o} applyb1 (@var{expr}, @var{rule_1}, ..., @var{rule_n})
65 Repetidamente aplica @var{rule_1} para a subexpress@~{a}o mais distante de @var{expr} at@'{e} falhar,
66 ent@~{a}o repetidamente aplica a mesma regra um n@'{i}vel mais acima (i.e., subexpress@~{a}os mais larga),
67 at@'{e} que @var{rule_1} tenha falhado sobre a express@~{a}o de n@'{i}vel mais alto.
68 Ent@~{a}o @var{rule_2} @'{e} aplicada com o mesmo estilo para o resultado de @var{rule_1}.
69 ap@'{o}s @var{rule_n} ter sido aplicada @`a express@~{a}o de n@'{i}vel mais elevado,
70 o resultado @'{e} retornado.
72 @code{applyb1} @'{e} similar a @code{apply1} mas trabalha da
73 base para cima em lugar de do topo para baixo.
75 @code{maxapplyheight} @'{e} o @'{a}pice que @code{applyb1} encontra
76 antes de interromper.
78 Veja tamb@'{e}m @code{apply1}, @code{apply2}, e @code{let}.
80 @end deffn
82 @defvr {Vari@'{a}vel de opç@~{a}o} current_let_rule_package
83 Valor padr@~{a}o: @code{default_let_rule_package}
85 @code{current_let_rule_package} @'{e} o nome do pacote de regras que est@'{a} sendo usado por
86 funç@~{o}es no pacote @code{let} (@code{letsimp}, etc.) @c NEED TO GIVE AN EXPLICIT LIST HERE (NOT "ETC")
87 se nenhum outro pacote de regras for especificado.
88 A essa vari@'{a}vel pode ser atribu@'{i}do o nome de qualquer pacote de regras definido
89 via comando @code{let}.
91 Se uma chamada tal como @code{letsimp (expr, nome_pct_regras)} for feita,
92 o pacote de regras @code{nome_pct_regras} @'{e} usado para aquela chamada de funç@~{a}o somente,
93 e o valor de @code{current_let_rule_package} n@~{a}o @'{e} alterado.
95 @end defvr
97 @defvr {Vari@'{a}vel de opç@~{a}o} default_let_rule_package
98 @c DEFAULT BINDING OF default_let_rule_package IS default_let_rule_package (BOUND TO ITSELF)
99 Valor padr@~{a}o: @code{default_let_rule_package}
101 @c THIS IS SORT OF CONFUSING. PROBABLY NEED TO GIVE MORE DETAIL HERE
102 @code{default_let_rule_package} @'{e} o nome do pacote de regras usado quando um
103 n@~{a}o for explicitamente escolhido pelo usu@'{a}rio com @code{let} ou atrav@'{e}s de alteraç@~{a}o do valor de
104 @code{current_let_rule_package}.
106 @end defvr
108 @deffn {Funç@~{a}o} defmatch (@var{prognome}, @var{modelo}, @var{x_1}, ..., @var{x_n})
109 @deffnx {Funç@~{a}o} defmatch (@var{prognome}, @var{modelo})
110 Define uma funç@~{a}o @code{@var{prognome}(@var{expr}, @var{x_1}, ..., @var{x_n})}
111 que testa @var{expr} para ver se essa express@~{a}o coincide com @var{modelo}.
113 @var{modelo} @'{e} uma express@~{a}o contendo os argumentos modelo @var{x_1}, ..., @var{x_n} (se existir algum)
114 e alguns modelos de vari@'{a}veis (se existir algum).
115 os argumentos modelo s@~{a}o fornecidos explicitamente como argumentos para @code{defmatch} enquanto os modelos de vari@'{a}veis
116 s@~{a}o declarados atrav@'{e}s da funç@~{a}o @code{matchdeclare}.
117 Qualquer vari@'{a}vel n@~{a}o declarada como modelo em @code{matchdeclare}
118 ou como um argumento modelo em @code{defmatch} coincide somente com si mesma.
120 O primeiro argumento para a funç@~{a}o criada @var{prognome} @'{e} uma express@~{a}o
121 a serem comparadas contra o modelo e os outros argumentos s@~{a}o os atuais argumetnos
122 que correspondem @`as vari@'{a}veis respectivas @var{x_1}, ..., @var{x_n} no modelo.
124 Se a tentativa de coincid@^{e}ncia obtiver sucesso, @var{prognome} retorna
125 uma lista de equaç@~{o}es cujos lados esquerdos s@~{a}o os
126 argumetnos de modelo e vari@'{a}veis de modelo, e cujo lado direito forem as subexpress@~{o}es
127 cujos argumentos de modelo e as vari@'{a}veis coincidem.
128 Os modelos de vari@'{a}veis, mas n@~{a}o tos argumentos de modelo, s@~{a}o atribu@'{i}dos @`as subexpress@~{o}es que coincidirem.
129 Se a coincid@^{e}ncia falhar, @var{prognome} retorna @code{false}.
131 Um modelo literal
132 (isto @'{e}, um modelo que n@~{a}o contiver nem argumentos de modelo nem vari@'{a}veis de modelo)
133 retorna @code{true} se a coincid@^{e}ncia ocorrer.
135 Veja tamb@'{e}m @code{matchdeclare}, @code{defrule}, @code{tellsimp}, e @code{tellsimpafter}.
137 Exemplos:
139 Define uma funç@~{a}o @code{linearp(expr, x)} que
140 testa @code{expr} para ver se essa express@~{a}o da forma @code{a*x + b}
141 tal que @code{a} e @code{b} n@~{a}o contenham @code{x} e @code{a} seja n@~{a}o nulo.
142 Essa funç@~{a}o de coincid@^{e}ncia coincide com express@~{o}es que sejam lineares em qualquer vari@'{a}vel,
143 por que o argumento de modelo @code{x} @'{e} fornecido para @code{defmatch}.
144 @c HOW HARD WILL MAXIMA TRY TO COLLECT TERMS AND DO OTHER MUNGEING TO FIT THE PATTERN ??
146 @c ===beg===
147 @c matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
148 @c defmatch (linearp, a*x + b, x);
149 @c linearp (3*z + (y + 1)*z + y^2, z);
150 @c a;
151 @c b;
152 @c x;
153 @c ===end===
154 @example
155 (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
156 (%o1) done
157 (%i2) defmatch (linearp, a*x + b, x);
158 (%o2) linearp
159 (%i3) linearp (3*z + (y + 1)*z + y^2, z);
160 2
161 (%o3) [b = y , a = y + 4, x = z]
162 (%i4) a;
163 (%o4) y + 4
164 (%i5) b;
165 2
166 (%o5) y
167 (%i6) x;
168 (%o6) x
169 @end example
171 Define uma funç@~{a}o @code{linearp(expr)} que testa @code{expr}
172 para ver se essa express@~{a}o @'{e} da forma @code{a*x + b}
173 tal que @code{a} e @code{b} n@~{a}o contenham @code{x} e @code{a} seja n@~{a}o nulo.
174 Essa funç@~{a}o de coincid@^{e}ncia somente coincide com express@~{o}es lineares em @code{x},
175 n@~{a}o em qualquer outra vari@'{a}vel, porque nenhum argumento de modelo @'{e} fornecido a @code{defmatch}.
177 @c ===beg===
178 @c matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
179 @c defmatch (linearp, a*x + b);
180 @c linearp (3*z + (y + 1)*z + y^2);
181 @c linearp (3*x + (y + 1)*x + y^2);
182 @c ===end===
183 @example
184 (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
185 (%o1) done
186 (%i2) defmatch (linearp, a*x + b);
187 (%o2) linearp
188 (%i3) linearp (3*z + (y + 1)*z + y^2);
189 (%o3) false
190 (%i4) linearp (3*x + (y + 1)*x + y^2);
191 2
192 (%o4) [b = y , a = y + 4]
193 @end example
195 Define uma funç@~{a}o @code{checklimits(expr)} que testa @code{expr}
196 para ver se essa express@~{a}o @'{e} uma integral definida.
198 @c ===beg===
199 @c matchdeclare ([a, f], true);
200 @c constinterval (l, h) := constantp (h - l);
201 @c matchdeclare (b, constinterval (a));
202 @c matchdeclare (x, atom);
203 @c simp : false;
204 @c defmatch (checklimits, 'integrate (f, x, a, b));
205 @c simp : true;
206 @c 'integrate (sin(t), t, %pi + x, 2*%pi + x);
207 @c checklimits (%);
208 @c ===end===
209 @example
210 (%i1) matchdeclare ([a, f], true);
211 (%o1) done
212 (%i2) constinterval (l, h) := constantp (h - l);
213 (%o2) constinterval(l, h) := constantp(h - l)
214 (%i3) matchdeclare (b, constinterval (a));
215 (%o3) done
216 (%i4) matchdeclare (x, atom);
217 (%o4) done
218 (%i5) simp : false;
219 (%o5) false
220 (%i6) defmatch (checklimits, 'integrate (f, x, a, b));
221 (%o6) checklimits
222 (%i7) simp : true;
223 (%o7) true
224 (%i8) 'integrate (sin(t), t, %pi + x, 2*%pi + x);
225 x + 2 %pi
226 /
227 [
228 (%o8) I sin(t) dt
229 ]
230 /
231 x + %pi
232 (%i9) checklimits (%);
233 (%o9) [b = x + 2 %pi, a = x + %pi, x = t, f = sin(t)]
234 @end example
236 @end deffn
238 @c NEEDS CLARIFICATION AND EXAMPLES
239 @deffn {Funç@~{a}o} defrule (@var{nomeregra}, @var{modelo}, @var{substituiç@~{a}o})
240 Define e nomeia uma
241 regra de substituiç@~{a}o para o modelo dado. Se a regra nomeada @var{nomeregra} for
242 aplicada a uma express@~{a}o (atrav@'{e}s de @code{apply1}, @code{applyb1}, ou @code{apply2}), toda
243 subexpress@~{a}o coincidindo com o modelo ser@'{a} substitu@'{i}da por
244 @code{substituiç@~{a}o}. Todas as vari@'{a}veis em @code{substituiç@~{a}o} que tiverem sido
245 atribuidos valores pela coincid@^{e}ncia com o modelo s@~{a}o atribuidas esses valores na
246 @code{substituiç@~{a}o} que @'{e} ent@~{a}o simplificado.
248 As regras por si mesmas podem ser
249 tratadas como funç@~{o}es que transforma uma express@~{a}o atrav@'{e}s de uma
250 operaç@~{a}o de coincid@^{e}ncia de modelo e substituiç@~{a}o.
251 Se a coincid@^{e}ncia falhar, a funç@~{a}o da regra retorna @code{false}.
253 @end deffn
255 @c NEEDS EXAMPLES
256 @deffn {Funç@~{a}o} disprule (@var{nomeregra_1}, ..., @var{nomeregra_2})
257 @deffnx {Funç@~{a}o} disprule (all)
258 Mostra regras com os nomes @var{nomeregra_1}, ..., @var{nomeregra_n},
259 como retornado por @code{defrule}, @code{tellsimp}, ou @code{tellsimpafter},
260 ou um modelo definido por meio de @code{defmatch}.
261 Cada regra @'{e} mostrada com um r@'{o}tulo de express@~{a}o intermedi@'{a}ria (@code{%t}).
263 @code{disprule (all)} mostra todas as regras.
265 @code{disprule} n@~{a}o avalia seus argumentos.
266 @code{disprule} retorna a lista de r@'{o}tulos de express@~{o}es intermed@'{a}irias correspondendo @`as regras mostradas.
268 Veja tamb@'{e}m @code{letrules}, que mostra regras definidas atrav@'{e}s de @code{let}.
270 Examples:
272 @c ===beg===
273 @c tellsimpafter (foo (x, y), bar (x) + baz (y));
274 @c tellsimpafter (x + y, special_add (x, y));
275 @c defmatch (quux, mumble (x));
276 @c disprule (foorule1, "+rule1", quux);
277 @c ''%;
278 @c ===end===
279 @example
280 (%i1) tellsimpafter (foo (x, y), bar (x) + baz (y));
281 (%o1) [foorule1, false]
282 (%i2) tellsimpafter (x + y, special_add (x, y));
283 (%o2) [+rule1, simplus]
284 (%i3) defmatch (quux, mumble (x));
285 (%o3) quux
286 (%i4) disprule (foorule1, "+rule1", quux);
287 (%t4) foorule1 : foo(x, y) -> baz(y) + bar(x)
289 (%t5) +rule1 : y + x -> special_add(x, y)
291 (%t6) quux : mumble(x) -> []
293 (%o6) [%t4, %t5, %t6]
294 (%i6) ''%;
295 (%o6) [foorule1 : foo(x, y) -> baz(y) + bar(x),
296 +rule1 : y + x -> special_add(x, y), quux : mumble(x) -> []]
297 @end example
299 @end deffn
301 @deffn {Funç@~{a}o} let (@var{prod}, @var{repl}, @var{prednome}, @var{arg_1}, ..., @var{arg_n})
302 @deffnx {Funç@~{a}o} let ([@var{prod}, @var{repl}, @var{prednome}, @var{arg_1}, ..., @var{arg_n}], @var{nome_pacote})
303 Define uma regra de substituiç@~{a}o para @code{letsimp} tal que @var{prod} @'{e} substitu@'{i}do por @var{repl}.
304 @var{prod} @'{e} um produto de expoentes positivos ou negativos dos seguintes termos:
306 @itemize @bullet
307 @item
308 Atomos que @code{letsimp} ir@'{a} procurar literalmente a menos que previamente
309 chamando @code{letsimp} a funç@~{a}o @code{matchdeclare} @'{e} usada para associar um
310 predicado com o @'{a}tomo. Nesse caso @code{letsimp} ir@'{a} coincidir com o @'{a}tomo para
311 qualquer termo de um produto satisfazendo o predicado.
312 @item
313 N@'{u}cleos tais como @code{sin(x)}, @code{n!}, @code{f(x,y)}, etc. Como com @'{a}tomos acima
314 @code{letsimp} ir@'{a} olhar um literal coincidente a menos que @code{matchdeclare} seja usada para
315 associar um predicado com o argumento do n@'{u}cleo.
316 @end itemize
318 Um termo para um expoente positivo ir@'{a} somente coincidir com um termo tendo ao menos aquele
319 expoente. Um termo para um expoente negativo
320 por outro lado ir@'{a} somente coincidir com um termo com um expoente ao menos j@'{a}
321 negativo. o caso de expentes negativos em @var{prod} o comutador
322 @code{letrat} deve ser escolhido para @code{true}.
323 Veja tamb@'{e}m @code{letrat}.
325 Se um predicado for inclu@'{i}do na funç@~{a}o @code{let} seguido por uma lista de
326 argumentos, uma tentativa de coincid@^{e}ncia (i.e. uma que pode ser aceita se o
327 predicado fosse omitido) @'{e} aceita somente se
328 @code{prednome (arg_1', ..., arg_n')} avaliar para @code{true} onde @var{arg_i'} @'{e} o valor
329 coincidente com @var{arg_i}. O @var{arg_i} pode ser o nome de qualquer @'{a}tomo ou o argumento
330 de qualquer n@'{u}cleo aparecendo em @var{prod}.
331 @var{repl} pode ser qualquer express@~{a}o racional. @c ONLY RATIONAL -- REALLY ??
332 Se quaisquer dos @'{a}tomos ou argumentos de @var{prod} aparecer em @var{repl} a
333 substituiç@~{a}o @'{e} feita. @c SPELL OUT "APPROPRIATE" IN THIS CONTEXT
335 O sinalizador global @code{letrat} controla a simplificaç@~{a}o dos quocientes atrav@'{e}s de @code{letsimp}.
336 Quando @code{letrat} for @code{false},
337 @code{letsimp} simplifica o numerador e o
338 denominador de @var{expr} separadamente, e n@~{a}o simplifica o quociente.
339 Substituiç@~{o}es tais como @code{n!/n} v@~{a}o para @code{(n-1)!} ent@~{a}o falham quando @code{letrat} for @code{false}.
340 Quando @code{letrat} for @code{true}, ent@~{a}o o numerador,
341 o denominador, e o quociente s@~{a}o simplificados nessa ordem.
343 Essas funç@~{o}es de substituiç@~{a}o permitem a voc@^{e} trabalhar com muitos pacotes de regras.
344 Cada pacote de regras pode conter qualquer n@'{u}mero de regras
345 @code{let} e @'{e} referenciado atrav@'{e}s de um nome definido pelo usu@'{a}rio.
346 @code{let ([@var{prod}, @var{repl}, @var{prednome}, @var{arg_1}, ..., @var{arg_n}], @var{nome_pacote})}
347 adiciona a regra @var{prednome} ao pacote de regras @var{nome_pacote}.
348 @code{letsimp (@var{expr}, @var{nome_pacote})}
349 aplica as regras em @var{nome_pacote}.
350 @code{letsimp (@var{expr}, @var{nome_pacote1}, @var{nome_pacote2}, ...)}
351 @'{e} equivalente a @code{letsimp (@var{expr}, @var{nome_pacote1})}
352 seguido por @code{letsimp (%, @var{nome_pacote2})}, ....
354 @code{current_let_rule_package} @'{e} o nome do pacote de regras que est@'{a}
355 atualmente sendo usando.
356 Essa vari@'{a}vel pode receber o nome de
357 qualquer pacote de regras definidos via o comando @code{let}.
358 Quando qualquer das funç@~{o}es compreendidas no pacote @code{let} s@~{a}o chamadas sem o nome do pacote,
359 o pacote nomeado por @code{current_let_rule_package} @'{e} usado.
360 Se uma chamada tal como @code{letsimp (@var{expr}, @var{nome_pct_regras})} @'{e} feita,
361 o pacote de regras @var{nome_pct_regras} @'{e} usado somente para aquele comando @code{letsimp},
362 e @code{current_let_rule_package} n@~{a}o @'{e} alterada.
363 Se n@~{a}o especificado de outra forma,
364 @code{current_let_rule_package} avalia de forma padronizada para @code{default_let_rule_package}.
366 @example
367 (%i1) matchdeclare ([a, a1, a2], true)$
368 (%i2) oneless (x, y) := is (x = y-1)$
369 (%i3) let (a1*a2!, a1!, oneless, a2, a1);
370 (%o3) a1 a2! --> a1! where oneless(a2, a1)
371 (%i4) letrat: true$
372 (%i5) let (a1!/a1, (a1-1)!);
373 a1!
374 (%o5) --- --> (a1 - 1)!
375 a1
376 (%i6) letsimp (n*m!*(n-1)!/m);
377 (%o6) (m - 1)! n!
378 (%i7) let (sin(a)^2, 1 - cos(a)^2);
379 2 2
380 (%o7) sin (a) --> 1 - cos (a)
381 (%i8) letsimp (sin(x)^4);
382 4 2
383 (%o8) cos (x) - 2 cos (x) + 1
384 @end example
386 @c NEEDS ADDITIONAL EXAMPLES
387 @end deffn
389 @defvr {Vari@'{a}vel de opç@~{a}o} letrat
390 Valor padr@~{a}o: @code{false}
392 Quando @code{letrat} for @code{false}, @code{letsimp} simplifica o
393 numerador e o denominador de uma raz@~{a}o separadamente,
394 e n@~{a}o simplifica o quociente.
396 Quando @code{letrat} for @code{true},
397 o numerador, o denominador, e seu quocienten s@~{a}o simplificados nessa ordem.
399 @example
400 (%i1) matchdeclare (n, true)$
401 (%i2) let (n!/n, (n-1)!);
402 n!
403 (%o2) -- --> (n - 1)!
404 n
405 (%i3) letrat: false$
406 (%i4) letsimp (a!/a);
407 a!
408 (%o4) --
409 a
410 (%i5) letrat: true$
411 (%i6) letsimp (a!/a);
412 (%o6) (a - 1)!
413 @end example
415 @end defvr
417 @c NEEDS EXAMPLES
418 @deffn {Funç@~{a}o} letrules ()
419 @deffnx {Funç@~{a}o} letrules (@var{nome_pacote})
420 Mostra as regras em um pacote de regras.
421 @code{letrules ()} mostra as regras no pacote de regras corrente.
422 @code{letrules (@var{nome_pacote})} mostra as regras em @code{nome_pacote}.
424 O pacote de regras corrente @'{e} nomeado por @code{current_let_rule_package}.
425 Se n@~{a}o especificado de outra forma, @code{current_let_rule_package}
426 avalia de forma padr@~{a}o para @code{default_let_rule_package}.
428 Veja tamb@'{e}m @code{disprule}, que mostra regras defindas por @code{tellsimp} e @code{tellsimpafter}.
429 @c WHAT ABOUT defmatch AND defrule ??
431 @end deffn
433 @deffn {Funç@~{a}o} letsimp (@var{expr})
434 @deffnx {Funç@~{a}o} letsimp (@var{expr}, @var{nome_pacote})
435 @deffnx {Funç@~{a}o} letsimp (@var{expr}, @var{nome_pacote_1}, ..., @var{nome_pacote_n})
436 Repetidamente aplica a substituiç@~{a}o definida por @code{let}
437 at@'{e} que nenhuma mudança adicional seja feita para @var{expr}.
439 @code{letsimp (@var{expr})} usa as regras de @code{current_let_rule_package}.
441 @code{letsimp (@var{expr}, @var{nome_pacote})} usa as regras de @var{nome_pacote}
442 sem alterar @code{current_let_rule_package}.
444 @code{letsimp (@var{expr}, @var{nome_pacote_1}, ..., @var{nome_pacote_n})}
445 @'{e} equivalente a @code{letsimp (@var{expr}, @var{nome_pacote_1}},
446 seguido por @code{letsimp (%, @var{nome_pacote_2})}, e assim sucessivamente.
448 @c NEEDS EXAMPLES
449 @end deffn
451 @defvr {Vari@'{a}vel de opç@~{a}o} let_rule_packages
452 Valor padr@~{a}o: @code{[default_let_rule_package]}
454 @code{let_rule_packages} @'{e} uma lista de todos os pacotes de regras @code{let} definidos pelo usu@'{a}rio
455 mais o pacote padr@~{a}o @code{default_let_rule_package}.
457 @end defvr
459 @deffn {Funç@~{a}o} matchdeclare (@var{a_1}, @var{pred_1}, ..., @var{a_n}, @var{pred_n})
460 Associa um predicado @var{pred_k}
461 com uma vari@'{a}vel ou lista de vari@'{a}veis @var{a_k}
462 de forma que @var{a_k} coincida com express@~{o}es
463 para as quais o predicado retorne qualquer coisa que n@~{a}o @code{false}.
465 Umpredicado @'{e} o nome de uma funç@~{a}o,
466 ou de uma express@~{a}o lambda,
467 ou uma chamada de funç@~{a}o ou chamada de funç@~{a}o lambda iomitindo o @'{u}lltimo argumento,
468 ou @code{true} ou @code{all}.
469 Qualquer express@~{a}o coincide com @code{true} ou @code{all}.
470 Se o predicado for especificado como uma chamada de funç@~{a}o ou chamada de funç@~{a}o lambda,
471 a express@~{a}o a ser testada @'{e} anexada ao final da lista de argumentos;
472 os argumentos s@~{a}o avaliados ao mesmo tempo que a coincid@^{e}ncia @'{e} avaliada.
473 De outra forma, o predicado @'{e} especificado como um nome de funç@~{a}o ou express@~{a}o lambda,
474 e a express@~{a}o a ser testada @'{e} o argumento sozinho.
475 Uma funç@~{a}o predicado n@~{a}o precisa ser definida quando @code{matchdeclare} for chamada;
476 o predicado n@~{a}o @'{e} avaliado at@'{e} que uma coincid@^{e}ncia seja tentada.
478 Um predicado pode retornar uma express@~{a}o Booleana al@'{e}m de @code{true} ou @code{false}.
479 Express@~{o}es Booleanas s@~{a}o avaliadas por @code{is} dentro da funç@~{a}o da regra constru@'{i}da,
480 de forma que n@~{a}o @'{e} necess@'{a}rio chamar @code{is} dentro do predicado.
482 Se uma express@~{a}o satisfaz uma coincid@^{e}ncia de predicado,
483 a vari@'{a}vel de coincid@^{e}ncia @'{e} atribu@'{i}da @`a express@~{a}o,
484 exceto para vari@'{a}veis de coincid@^{e}ncia que s@~{a}o operandos de adiç@~{a}o @code{+} ou multiplicaç@~{a}o @code{*}.
485 Somente adiç@~{a}o e multiplicaç@~{a}o s@~{a}o manuseadas de forma especial;
486 outros operadores en@'{a}rios (ambos os definidos internamente e os definidos pelo usu@'{a}rio) s@~{a}o tratados como funç@~{o}es comuns.
487 @c WOULD BE GREAT TO EXTEND PART+/PART* PROCESSING TO ALL N-ARY OPERATORS
489 No caso de adiç@~{a}o e multiplicaç@~{a}o,
490 a vari@'{a}vel de coincid@^{e}ncia pode ser atribuida a uma express@~{a}o simples que satisfaz o predicado de coincid@^{e}ncia,
491 ou uma adiç@~{a}o ou um produto (respectivamente) de tais express@~{o}es.
492 Tal coincid@^{e}ncia de termo multiplo @'{e} gulosa:
493 predicados s@~{a}o avaliados na ordem em que suas vari@'{a}veis associadas
494 aparecem no modelo de coincid@^{e}ncia,
495 e o termo que satisfizer mais que um predicado @'{e} tomado pelo primeiro
496 predicado que satisfizer.
497 Cada predicado @'{e} testado contra todos os operandos de adiç@~{a}o ou produto antes que o pr@'{o}ximo predicado seja avaliado.
498 Adicionalmente,
499 se 0 ou 1 (respectivamente) satisfazem um predicado de coincid@^{e}ncia,
500 e n@~{a}o existe outros termos que satisfaçam o predicado,
501 0 ou 1 @'{e} atribu@'{i}do para a vari@'{a}vel de coincid@^{e}ncia associada com o predicado.
503 O algor@'{i}tmo para processar modelos contendo adiç@~{a}o e multiplicaç@~{a}o faz alguns resultados de coincid@^{e}ncia
504 (por exemplo, um modelo no qual uma vari@'{a}vel "coincida com qualquer coisa" aparecer)
505 dependerem da ordem dos termos no modelo de coincid@^{e}ncia e na express@~{a}o a ser testada a coincid@^{e}ncia.
506 Todavia,
507 se todos os predicados de coincid@^{e}ncia s@~{a}o mutuamente exclusivos,
508 o resultado de coincid@^{e}ncia @'{e} insens@'{i}vel a ordenaç@~{a}o,
509 como um predicado de coincid@^{e}ncia n@~{a}o pode aceitar termos de coincid@^{e}ncia de outro.
511 Chamado @code{matchdeclare} com uma vari@'{a}vel @var{a} como um argumento
512 muda a propriedade @code{matchdeclare} para @var{a}, se a vari@'{a}vel @var{a} tiver sido declarada anteriormente;
513 somente o @code{matchdeclare} mais recente est@'{a} em efeito quando uma regra @'{e} definida,
514 mudanças posteriores para a propriedade @code{matchdeclare}
515 (via @code{matchdeclare} ou @code{remove})
516 n@~{a}o afetam regras existentes.
518 @code{propvars (matchdeclare)} retorna a lista de todas as vari@'{a}veis
519 para as quais exista uma propriedade @code{matchdeclare}.
520 @code{printprops (@var{a}, matchdeclare)} retorna o predicado para a vari@'{a}vel @code{a}.
521 @code{printprops (all, matchdeclare)} retorna a lista de predicados para todas as vari@'{a}veis @code{matchdeclare}.
522 @code{remove (@var{a}, matchdeclare)} remove a propriedade @code{matchdeclare} da vari@'{a}vel @var{a}.
524 As funç@~{o}es
525 @code{defmatch}, @code{defrule}, @code{tellsimp}, @code{tellsimpafter}, e @code{let}
526 constroem regras que testam express@~{o}es contra modelos.
528 @code{matchdeclare} coloca ap@'{o}strofo em seus argumentos.
529 @code{matchdeclare} sempre retorna @code{done}.
531 Exemplos:
533 Um predicado @'{e} o nome de uma funç@~{a}o,
534 ou uma express@~{a}o lambda,
535 ou uma chamada de funç@~{a}o ou chamada a funç@~{a}o lambda omitindo o @'{u}ltimo argumento,
536 or @code{true} or @code{all}.
538 @c ===beg===
539 @c matchdeclare (aa, integerp);
540 @c matchdeclare (bb, lambda ([x], x > 0));
541 @c matchdeclare (cc, freeof (%e, %pi, %i));
542 @c matchdeclare (dd, lambda ([x, y], gcd (x, y) = 1) (1728));
543 @c matchdeclare (ee, true);
544 @c matchdeclare (ff, all);
545 @c ===end===
546 @example
547 (%i1) matchdeclare (aa, integerp);
548 (%o1) done
549 (%i2) matchdeclare (bb, lambda ([x], x > 0));
550 (%o2) done
551 (%i3) matchdeclare (cc, freeof (%e, %pi, %i));
552 (%o3) done
553 (%i4) matchdeclare (dd, lambda ([x, y], gcd (x, y) = 1) (1728));
554 (%o4) done
555 (%i5) matchdeclare (ee, true);
556 (%o5) done
557 (%i6) matchdeclare (ff, all);
558 (%o6) done
559 @end example
561 Se uma express@~{a}o satisfaz um predicado de coincid@^{e}ncia,
562 a vari@'{a}vel de coincid@^{e}ncia @'{e} atribu@'{i}da @`a express@~{a}o.
564 @c ===beg===
565 @c matchdeclare (aa, integerp, bb, atom);
566 @c defrule (r1, bb^aa, ["integer" = aa, "atom" = bb]);
567 @c r1 (%pi^8);
568 @c ===end===
569 @example
570 (%i1) matchdeclare (aa, integerp, bb, atom);
571 (%o1) done
572 (%i2) defrule (r1, bb^aa, ["integer" = aa, "atom" = bb]);
573 aa
574 (%o2) r1 : bb -> [integer = aa, atom = bb]
575 (%i3) r1 (%pi^8);
576 (%o3) [integer = 8, atom = %pi]
577 @end example
579 No caso de adiç@~{a}o e multiplicaç@~{a}o,
580 @`a vari@'{a}vel de coincid@^{e}ncia pode ser atribu@'{i}da uma express@~{a}o simples que satisfaz o predicado de coincid@^{e}ncia,
581 ou um somat@'{o}rio ou produt@'{o}rio (respectivamente) de tais express@~{o}es.
583 @c ===beg===
584 @c matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
585 @c defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
586 @c r1 (8 + a*b + sin(x));
587 @c defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
588 @c r2 (8 * (a + b) * sin(x));
589 @c ===end===
590 @example
591 (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
592 (%o1) done
593 (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
594 bb + aa partitions `sum'
595 (%o2) r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
596 (%i3) r1 (8 + a*b + sin(x));
597 (%o3) [all atoms = 8, all nonatoms = sin(x) + a b]
598 (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
599 bb aa partitions `product'
600 (%o4) r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
601 (%i5) r2 (8 * (a + b) * sin(x));
602 (%o5) [all atoms = 8, all nonatoms = (b + a) sin(x)]
603 @end example
605 Quando coincidindo argumentos de @code{+} e @code{*},
606 se todos os predicados de coincid@^{e}ncia forem mutuamente exclusivos,
607 o resultado da coincid@^{e}ncia @'{e} insens@'{i}ve @`a ordenaç@~{a}o,
608 como um predicado de coincid@^{e}ncia n@~{a}o pode aceitar termos que coincidiram com outro.
610 @c ===beg===
611 @c matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
612 @c defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
613 @c r1 (8 + a*b + %pi + sin(x) - c + 2^n);
614 @c defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
615 @c r2 (8 * (a + b) * %pi * sin(x) / c * 2^n);
616 @c ===end===
617 @example
618 (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
619 (%o1) done
620 (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
621 bb + aa partitions `sum'
622 (%o2) r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
623 (%i3) r1 (8 + a*b + %pi + sin(x) - c + 2^n);
624 n
625 (%o3) [all atoms = %pi + 8, all nonatoms = sin(x) + 2 - c + a b]
626 (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
627 bb aa partitions `product'
628 (%o4) r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
629 (%i5) r2 (8 * (a + b) * %pi * sin(x) / c * 2^n);
630 n
631 (b + a) 2 sin(x)
632 (%o5) [all atoms = 8 %pi, all nonatoms = -----------------]
633 c
634 @end example
636 As funç@~{o}es @code{propvars} e @code{printprops} retornam informaç@~{o}es sobre vari@'{a}vels de coincid@^{e}ncia.
638 @c ===beg===
639 @c matchdeclare ([aa, bb, cc], atom, [dd, ee], integerp);
640 @c matchdeclare (ff, floatnump, gg, lambda ([x], x > 100));
641 @c propvars (matchdeclare);
642 @c printprops (ee, matchdeclare);
643 @c printprops (gg, matchdeclare);
644 @c printprops (all, matchdeclare);
645 @c ===end===
646 @example
647 (%i1) matchdeclare ([aa, bb, cc], atom, [dd, ee], integerp);
648 (%o1) done
649 (%i2) matchdeclare (ff, floatnump, gg, lambda ([x], x > 100));
650 (%o2) done
651 (%i3) propvars (matchdeclare);
652 (%o3) [aa, bb, cc, dd, ee, ff, gg]
653 (%i4) printprops (ee, matchdeclare);
654 (%o4) [integerp(ee)]
655 (%i5) printprops (gg, matchdeclare);
656 (%o5) [lambda([x], x > 100, gg)]
657 (%i6) printprops (all, matchdeclare);
658 (%o6) [lambda([x], x > 100, gg), floatnump(ff), integerp(ee),
659 integerp(dd), atom(cc), atom(bb), atom(aa)]
660 @end example
662 @end deffn
664 @deffn {Funç@~{a}o} matchfix (@var{delimitador_e}, @var{delimitador_d})
665 @deffnx {Funç@~{a}o} matchfix (@var{delimitador_e}, @var{delimitador_d}, @var{arg_pos}, @var{pos})
666 Declara um operador @code{matchfix} com delimitadores esquerdo e direito @var{delimitador_e} e @var{delimitador_d}.
667 Os delimitadores s@~{a}o especificados como seq@"{u}@^{e}cias de caracteres.
669 Um operador "matchfix" @'{e} uma funç@~{a}o que aceita qualquer n@'{u}mero de argumentos,
670 tal que os argumentos ocorram entre os delimitadores correspondentes esquerdo e direito.
671 Os delimitadores podem ser quaisquer seq@"{u}@^{e}cias de caracteres, contanto que o analisador de express@~{o}es do Maxima possa
672 disting@"{u}ir os delimitadores dos operandos
673 e de outras express@~{o}es e operadores.
674 Na pr@'{a}tica essas regras excluem delimitadores n@~{a}o analis@'{a}veis tais como
675 @code{%}, @code{,}, @code{$} e @code{;},
676 e pode ser necess@'{a}rio isolar os delimitadores com espaços em branco.
677 O delimitador da direita pode ser o mesmo ou diferente do delimitador da esquerda.
679 Um delimitador esquerdo pode ser associado com somente um delimitador direito;
680 dois diferentes operadores @code{matchfix} n@~{a}o podem ter o mesmo delimitador esquerdo.
682 Um operador existente pode ser redeclarado com um operador @code{matchfix}
683 sem alterar suas outras propriedades.
684 Particularmente, operadores internos tais como adiç@~{a}o @code{+} podem
685 ser declarados @code{matchfix},
686 mas funç@~{o}es operadores n@~{a}o podem ser definidas para operadores internos.
688 @code{matchfix (@var{delimitador_e}, @var{delimitador_d}, @var{arg_pos}, @var{pos})}
689 declara o argumento @var{arg_pos} como sendo um entre: express@~{a}o l@'{o}gica,
690 express@~{a}o comum do Maxima mas que n@~{a}o seja do tipo anterior, e qualquer outro
691 tipo de express@~{a}o que n@~{a}o esteja inclu@'{i}da nos dois primeiros tipos.
692 Essa declaraç@~{a}o resulta em @var{pos} sendo um entre: express@~{a}o l@'{o}gica,
693 express@~{a}o comum do Maxima mas que n@~{a}o seja do tipo anterior, e qualquer outro
694 tipo de express@~{a}o que n@~{a}o esteja inclu@'{i}da nos dois primeiros tipos
695 e os delimitadores @var{delimitador_e} e @var{delimitador_d}.
697 @c DUNNO IF WE REALLY NEED TO MENTION BINDING POWER HERE -- AS NOTED IT'S IRRELEVANT
698 @c An operator declared by @code{matchfix} is assigned a low binding power.
699 @c Since a matchfix operator must be evaluated before any expression
700 @c which contains it,
701 @c binding power is effectively irrelevant
702 @c to the declaration of a matchfix operator.
704 A funç@~{a}o para realizar uma operaç@~{a}o @code{matchfix} @'{e} uma funç@~{a}o
705 comum definida pelo usu@'{a}rio.
706 A funç@~{a}o operador @'{e} definida
707 da forma usual
708 com o operador de definiç@~{a}o de funç@~{a}o @code{:=} ou @code{define}.
709 Os argumentos podem ser escritos entre os delimitadores,
710 ou com o delimitador esquerdo com uma seq@"{u}@^{e}ncia de caracteres com ap@'{o}strofo e os argumentos
711 seguindo entre par@^{e}ntesis.
712 @code{dispfun (@var{delimitador_e})} mostra a definiç@~{a}o da funç@~{a}o operador.
714 O @'{u}nico operador interno @code{matchfix} @'{e} o construtor de listas @code{[ ]}.
715 Par@^{e}ntesis @code{( )} e aspas duplas @code{" "}
716 atuam como operadores @code{matchfix},
717 mas n@~{a}o s@~{a}o tratados como tal pelo analisador do Maxima.
719 @code{matchfix} avalia seus argumentos.
720 @code{matchfix} retorna seu primeiro argumento, @var{delimitador_e}.
721 @c HOW TO TAKE AWAY THE MATCHFIX PROPERTY ??
723 Exemplos:
725 @itemize @bullet
726 @item
727 Delimitadores podem ser quase quaisquer seq@"{u}@^{e}ncia de caracteres.
728 @end itemize
729 @c ===beg===
730 @c matchfix ("@@", "~");
731 @c @@ a, b, c ~;
732 @c matchfix (">>", "<<");
733 @c >> a, b, c <<;
734 @c matchfix ("foo", "oof");
735 @c foo a, b, c oof;
736 @c >> w + foo x, y oof + z << / @@ p, q ~;
737 @c ===end===
738 @example
739 (%i1) matchfix ("@@@@", "~");
740 (%o1) @@@@
741 (%i2) @@@@ a, b, c ~;
742 (%o2) @@@@a, b, c~
743 (%i3) matchfix (">>", "<<");
744 (%o3) >>
745 (%i4) >> a, b, c <<;
746 (%o4) >>a, b, c<<
747 (%i5) matchfix ("foo", "oof");
748 (%o5) foo
749 (%i6) foo a, b, c oof;
750 (%o6) fooa, b, coof
751 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
752 >>z + foox, yoof + w<<
753 (%o7) ----------------------
754 @@@@p, q~
755 @end example
757 @itemize @bullet
758 @item
759 Operadores @code{matchfix} s@~{a}o funç@~{o}es comuns definidas pelo usu@'{a}rio.
760 @end itemize
761 @example
762 (%i1) matchfix ("!-", "-!");
763 (%o1) "!-"
764 (%i2) !- x, y -! := x/y - y/x;
765 x y
766 (%o2) !-x, y-! := - - -
767 y x
768 (%i3) define (!-x, y-!, x/y - y/x);
769 x y
770 (%o3) !-x, y-! := - - -
771 y x
772 (%i4) define ("!-" (x, y), x/y - y/x);
773 x y
774 (%o4) !-x, y-! := - - -
775 y x
776 (%i5) dispfun ("!-");
777 x y
778 (%t5) !-x, y-! := - - -
779 y x
781 (%o5) done
782 (%i6) !-3, 5-!;
783 16
784 (%o6) - --
785 15
786 (%i7) "!-" (3, 5);
787 16
788 (%o7) - --
789 15
790 @end example
792 @end deffn
794 @c NEEDS CLARIFICATION AND EXAMPLES
795 @deffn {Funç@~{a}o} remlet (@var{prod}, @var{nome})
796 @deffnx {Funç@~{a}o} remlet ()
797 @deffnx {Funç@~{a}o} remlet (all)
798 @deffnx {Funç@~{a}o} remlet (all, @var{nome})
799 Apaga a regra de substituiçao, prod --> repl, mais
800 recentemente definida atrav@'{e}s dea funç@~{a}o @code{let}. Se @code{nome} for fornecido a regra @'{e}
801 apagada do pacote de regras chamado @code{nome}.
803 @code{remlet()} e @code{remlet(all)} apagam todas as regras de substituiç@~{a}o do pacote de regras corrente.
804 Se o nome de um pacote de regras for fornecido,
805 e.g. @code{remlet (all, @var{nome})}, o pacote de regras @var{nome} @'{e} tamb@'{e}m apagado.
807 Se uma substituiç@~{a}o @'{e} para ser mudada usando o mesmo
808 produto, @code{remlet} n@~{a}o precisa ser chamada, apenas redefina a substituiç@~{a}o
809 usando o mesmo produto (literalmente) com a funç@~{a}o @code{let} e a nova
810 substituiç@~{a}o e/ou nome de predicado. Pode agora @code{remlet (@var{prod})} ser
811 chamada e a regra de substituiç@~{a}o original @'{e} ressuscitada.
813 Veja tamb@'{e}m @code{remrule}, que remove uma regra definida atrav@'{e}s de @code{tellsimp} ou de @code{tellsimpafter}.
815 @end deffn
817 @deffn {Funç@~{a}o} remrule (@var{op}, @var{nomeregra})
818 @deffnx {Funç@~{a}o} remrule (@var{op}, all)
819 Remove regras definidas por @code{tellsimp}, ou @code{tellsimpafter}.
821 @code{remrule (@var{op}, @var{nomeregra})}
822 remove a regra com o nome @code{nomeregra} do operador @var{op}.
823 Quando @var{op} for um operador interno ou um operador definido pelo usu@'{a}rio
824 (como definido por @code{infix}, @code{prefix}, etc.),
825 @var{op} e @var{rulename} devem ser colocados entre aspas duplas.
827 @code{remrule (@var{op}, all)} remove todas as regras para o operador @var{op}.
829 Veja tamb@'{e}m @code{remlet}, que remove uma regra definida atrav@'{e}s de @code{let}.
831 Examples:
833 @c ===beg===
834 @c tellsimp (foo (aa, bb), bb - aa);
835 @c tellsimpafter (aa + bb, special_add (aa, bb));
836 @c infix ("@@");
837 @c tellsimp (aa @@ bb, bb/aa);
838 @c tellsimpafter (quux (%pi, %e), %pi - %e);
839 @c tellsimpafter (quux (%e, %pi), %pi + %e);
840 @c [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
841 @c quux (%e, %pi)];
842 @c remrule (foo, foorule1);
843 @c remrule ("+", "+rule1");
844 @c remrule ("@@", "@@rule1");
845 @c remrule (quux, all);
846 @c [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
847 @c quux (%e, %pi)];
848 @c ===end===
849 @example
850 (%i1) tellsimp (foo (aa, bb), bb - aa);
851 (%o1) [foorule1, false]
852 (%i2) tellsimpafter (aa + bb, special_add (aa, bb));
853 (%o2) [+rule1, simplus]
854 (%i3) infix ("@@@@");
855 (%o3) @@@@
856 (%i4) tellsimp (aa @@@@ bb, bb/aa);
857 (%o4) [@@@@rule1, false]
858 (%i5) tellsimpafter (quux (%pi, %e), %pi - %e);
859 (%o5) [quuxrule1, false]
860 (%i6) tellsimpafter (quux (%e, %pi), %pi + %e);
861 (%o6) [quuxrule2, quuxrule1, false]
862 (%i7) [foo (aa, bb), aa + bb, aa @@@@ bb, quux (%pi, %e),
863 quux (%e, %pi)];
864 bb
865 (%o7) [bb - aa, special_add(aa, bb), --, %pi - %e, %pi + %e]
866 aa
867 (%i8) remrule (foo, foorule1);
868 (%o8) foo
869 (%i9) remrule ("+", "+rule1");
870 (%o9) +
871 (%i10) remrule ("@@@@", "@@@@rule1");
872 (%o10) @@@@
873 (%i11) remrule (quux, all);
874 (%o11) quux
875 (%i12) [foo (aa, bb), aa + bb, aa @@@@ bb, quux (%pi, %e),
876 quux (%e, %pi)];
877 (%o12) [foo(aa, bb), bb + aa, aa @@@@ bb, quux(%pi, %e),
878 quux(%e, %pi)]
879 @end example
881 @end deffn
883 @c NEEDS EXPANSION OR MAYBE JUST APPROPRIATE REFS TO tellsimpafter
884 @deffn {Funç@~{a}o} tellsimp (@var{pattern}, @var{replacement})
885 @'{e} similar a @code{tellsimpafter} mas coloca
886 nova informaç@~{a}o antes da antiga de forma que essa nova regra seja aplicada antes das regras
887 de simplificaç@~{a}o internas.
889 @code{tellsimp} @'{e} usada quando for importante modificar
890 a express@~{a}o antes que o simplificador trabalhe sobre ela, por exemplo se o
891 simplificador "sabe" alguma coisa sobre a express@~{a}o, mas o que ele retorna
892 n@~{a}o @'{e} para sua apreciaç@~{a}o.
893 Se o simplificador "sabe" alguma coisa sobre o
894 principal operador da express@~{a}o, mas est@'{a} simplesmente escondendo de
895 voc@^{e}, voc@^{e} provavelmente quer usar @code{tellsimpafter}.
897 O modelo pode n@~{a}o ser uma
898 adiç@~{a}o, um produto, vari@'{a}vel simples, ou n@'{u}mero.
900 @code{rules} @'{e} a lista de regras definidas por
901 @code{defrule}, @code{defmatch}, @code{tellsimp}, e @code{tellsimpafter}.
903 Exemplos:
905 @example
906 (%i1) matchdeclare (x, freeof (%i));
907 (%o1) done
908 (%i2) %iargs: false$
909 (%i3) tellsimp (sin(%i*x), %i*sinh(x));
910 (%o3) [sinrule1, simp-%sin]
911 (%i4) trigexpand (sin (%i*y + x));
912 (%o4) sin(x) cos(%i y) + %i cos(x) sinh(y)
913 (%i5) %iargs:true$
914 (%i6) errcatch(0^0);
915 0
916 0 has been generated
917 (%o6) []
918 (%i7) ev (tellsimp (0^0, 1), simp: false);
919 (%o7) [^rule1, simpexpt]
920 (%i8) 0^0;
921 (%o8) 1
922 (%i9) remrule ("^", %th(2)[1]);
923 (%o9) ^
924 (%i10) tellsimp (sin(x)^2, 1 - cos(x)^2);
925 (%o10) [^rule2, simpexpt]
926 (%i11) (1 + sin(x))^2;
927 2
928 (%o11) (sin(x) + 1)
929 (%i12) expand (%);
930 2
931 (%o12) 2 sin(x) - cos (x) + 2
932 (%i13) sin(x)^2;
933 2
934 (%o13) 1 - cos (x)
935 (%i14) kill (rules);
936 (%o14) done
937 (%i15) matchdeclare (a, true);
938 (%o15) done
939 (%i16) tellsimp (sin(a)^2, 1 - cos(a)^2);
940 (%o16) [^rule3, simpexpt]
941 (%i17) sin(y)^2;
942 2
943 (%o17) 1 - cos (y)
944 @end example
946 @end deffn
948 @deffn {Funç@~{a}o} tellsimpafter (@var{modelo}, @var{substituiç@~{a}o})
949 Define a uma regra de simplificaç@~{a}o que o simplificador do Maxima
950 aplica ap@'{o}s as regras de simplificaç@~{a}o internas.
951 @var{modelo} @'{e} uma express@~{a}o, compreendendo vari@'{a}veis de modelo (declaradas atrav@'{e}s de @code{matchdeclare})
952 e outros @'{a}tomos e operaç@~{o}es, considerados literais para o prop@'{o}sito de coincid@^{e}ncia de modelos.
953 @var{substituiç@~{a}o} @'{e} substitu@'{i}da para uma express@~{a}o atual que coincide com @var{modelo};
954 vari@'{a}veis de modelo em @var{substituiç@~{a}o} s@~{a}o atribuidas a valores coincidentes na express@~{a}o atual.
956 @var{modelo} pode ser qualquer express@~{a}o n@~{a}o at@^{o}mica
957 na qual o principal operador n@~{a}o @'{e} uma vari@'{a}vel de modelo;
958 a regra de simplificaç@~{a}o est@'{a} associada com o operador principal.
959 Os nomes de funç@~{o}es (com uma excess@~{a}o, descrita abaixo), listas, e arrays
960 podem aparecer em @var{modelo} como o principal operador somente como literais (n@~{a}o vari@'{a}veis de modelo);
961 essas regras fornecem express@~{o}es tais como @code{aa(x)} e @code{bb[y]} como modelos,
962 se @code{aa} e @code{bb} forem vari@'{a}veis de modelo.
963 Nomes de funç@~{o}es, listas, e arrays que s@~{a}o vari@'{a}veis de modelo podem aparecer como operadores
964 outros que n@~{a}o o operador principal em @var{modelo}.
966 Existe uma excess@~{a}o para o que foi dito acima com relaç@~{a}o a regras e nomes de funç@~{o}es.
967 O nome de uma funç@~{a}o subscrita em uma express@~{a}o tal como @code{aa[x](y)}
968 pode ser uma vari@'{a}vel de modelo,
969 porque o operador principal n@~{a}o @'{e} @code{aa} mas ao contr@'{a}rio o @'{a}tomo Lisp @code{mqapply}.
970 Isso @'{e} uma conseq@"{u}@^{e}ncia da representaç@~{a}o de express@~{o}es envolvendo funç@~{o}es subscritas.
972 @c LET'S NOT GO INTO DETAILS ABOUT MAIN OPERATORS HERE; BUT PRESERVE THIS FOR REFERENCE
973 @c The main operator of an expression @code{expr} is @code{caar $expr}.
974 @c For most kinds of expressions,
975 @c the main operator is the operator returned by @code{op (@var{pattern})};
976 @c the sole exception is the operator @code{mqapply},
977 @c which appears in indexed function expressions (e.g., @code{foo[i](x)}).
979 @c NEED TO REVIEW THIS PARAGRAPH FOR ACCURACY
980 Regras de simplificaç@~{a}o s@~{a}o aplicadas ap@'{o}s avaliaç@~{a}o
981 (se n@~{a}o suprimida atrav@'{e}s de colocaç@~{a}o de ap@'{o}strofo ou do sinalizador @code{noeval}).
982 Regras estabelecidas por @code{tellsimpafter} s@~{a}o aplicadas na ordem em que forem definidas,
983 e ap@'{o}s quaisquer regras internas.
984 Regras s@~{a}o aplicadas de baixo para cima, isto @'{e},
985 aplicadas primeiro a subexpress@~{o}es antes de ser aplicada @`a express@~{a}o completa.
986 @c NO IT IS MORE COMPLICATED THAN THIS, ALTHOUGH IN SOME CIRCUMSTANCE IT APPEARS TO BE THE CASE:
987 @c For a given expression, at most one rule per operator is applied.
988 Isso pode ser necess@'{a}rio para repetidamente simplificar um resultado
989 (por exemplo, via o operador ap@'{o}strofo-ap@'{o}strofo @code{'@w{}'} ou o sinalizador @code{infeval})
990 para garantir que todas as regras s@~{a}o aplicadas.
992 Vari@'{a}veis de modelo s@~{a}o tratadas como vari@'{a}veis locais em regras de simplificaç@~{a}o.
993 Assim que uma regra @'{e} definida, o valor de uma vari@'{a}vel de modelo
994 n@~{a}o afeta a regra, e n@~{a}o @'{e} afetado pela regra.
995 Uma atribuiç@~{a}o para uma vari@'{a}vel de modelo que resulta em uma coincid@^{e}ncia de regra com sucesso
996 n@~{a}o afeta a atribuiç@~{a}o corrente (ou necessita disso) da vari@'{a}vel de modelo.
997 Todavia,
998 como com todos os @'{a}tomos no Maxima,
999 as propriedades de vari@'{a}veis de modelo (como declarado por @code{put} e funç@~{o}es relacionadas) s@~{a}o globais.
1001 A regra constru@'{i}da por @code{tellsimpafter} @'{e} nomeada ap@'{o}s o operador principal de @code{modelo}.
1002 Regras para operadores internos,
1003 e operadores definidos pelo usu@'{a}rio
1004 definidos por meio de @code{infix}, @code{prefix}, @code{postfix}, @code{matchfix}, e @code{nofix},
1005 possuem nomes que s@~{a}o seq@"{u}@^{e}ncias de caracteres do Maxima.
1006 @c SLIGHTLY TOO MUCH DETAIL
1007 @c (that is, the name begins with ampersand @code{&}).
1008 Regras para outras funç@~{o}es possuem nomes que s@~{a}o identificadores comuns do Maxima.
1009 @c SLIGHTLY TOO MUCH DETAIL
1010 @c (that is, the name begins with dollar sign @code{$}).
1012 O tratamento de substantivos e formas verbais @'{e} desprez@'{i}velmente confuso. @c THIS IS A BUG.
1013 Se uma regra @'{e} definida para uma forma substantiva (ou verbal)
1014 e uma regra para o verbo correspondente (ou substantivo) j@'{a} existe,
1015 ent@~{a}o a nova regra definida aplica-se a ambas as formas (substantiva e verbal).
1016 Se uma regra para a correspondente forma verbal (ou substantiva) n@~{a}o existe,
1017 a nova regra definida aplicar-se-@'{a} somente para a forma substantiva (ou verbal).
1019 A regra constru@'{i}da atrav@'{e}s de @code{tellsimpafter} @'{e} uma funç@~{a}o Lisp comum.
1020 Se o nome da regra for @code{$foorule1},
1021 a construç@~{a}o @code{:lisp (trace $foorule1)} rastreia a funç@~{a}o,
1022 e @code{:lisp (symbol-function '$foorule1} mostra sua definiç@~{a}o.
1024 @code{tellsimpafter} n@~{a}o avalia seus argumentos.
1025 @code{tellsimpafter} retorna a lista de regras para o operador principal de @var{modelo},
1026 incluindo a mais recente regra estabelecia.
1027 @c WHAT IS simpfoo THAT SOMETIMES APPEARS, AND WHY DOES false SOMETIMES APPEAR IN RETURN VALUE ??
1029 Veja tamb@'{e}m @code{matchdeclare}, @code{defmatch}, @code{defrule}, @code{tellsimp}, @code{let},
1030 @code{kill}, @code{remrule}, e @code{clear_rules}.
1032 Exemplos:
1034 @var{modelo} pode ser qualquer express@~{a}o n@~{a}o at@^{o}mica na qual o
1035 principal operador n@~{a}o @'{e} uma vari@'{a}vel de modelo.
1037 @c ===beg===
1038 @c matchdeclare (aa, atom, [ll, mm], listp, xx, true)$
1039 @c tellsimpafter (sin (ll), map (sin, ll));
1040 @c sin ([1/6, 1/4, 1/3, 1/2, 1]*%pi);
1041 @c tellsimpafter (ll^mm, map ("^", ll, mm));
1042 @c [a, b, c]^[1, 2, 3];
1043 @c tellsimpafter (foo (aa (xx)), aa (foo (xx)));
1044 @c foo (bar (u - v));
1045 @c ===end===
1046 @example
1047 (%i1) matchdeclare (aa, atom, [ll, mm], listp, xx, true)$
1048 (%i2) tellsimpafter (sin (ll), map (sin, ll));
1049 (%o2) [sinrule1, simp-%sin]
1050 (%i3) sin ([1/6, 1/4, 1/3, 1/2, 1]*%pi);
1051 1 sqrt(2) sqrt(3)
1052 (%o3) [-, -------, -------, 1, 0]
1053 2 2 2
1054 (%i4) tellsimpafter (ll^mm, map ("^", ll, mm));
1055 (%o4) [^rule1, simpexpt]
1056 (%i5) [a, b, c]^[1, 2, 3];
1057 2 3
1058 (%o5) [a, b , c ]
1059 (%i6) tellsimpafter (foo (aa (xx)), aa (foo (xx)));
1060 (%o6) [foorule1, false]
1061 (%i7) foo (bar (u - v));
1062 (%o7) bar(foo(u - v))
1063 @end example
1065 Regras s@~{a}o aplicadas na ordem em que forem definidas.
1066 Se duas regras podem coincidir com uma express@~{a}o,
1067 a regra que foi primeiro definida @'{e} a que ser@'{a} aplicada.
1069 @c ===beg===
1070 @c matchdeclare (aa, integerp);
1071 @c tellsimpafter (foo (aa), bar_1 (aa));
1072 @c tellsimpafter (foo (aa), bar_2 (aa));
1073 @c foo (42);
1074 @c ===end===
1075 @example
1076 (%i1) matchdeclare (aa, integerp);
1077 (%o1) done
1078 (%i2) tellsimpafter (foo (aa), bar_1 (aa));
1079 (%o2) [foorule1, false]
1080 (%i3) tellsimpafter (foo (aa), bar_2 (aa));
1081 (%o3) [foorule2, foorule1, false]
1082 (%i4) foo (42);
1083 (%o4) bar_1(42)
1084 @end example
1086 vari@'{a}veis de modelo s@~{a}o tratadas como vari@'{a}veis locais em regras de simplificaç@~{a}o.
1087 (Compare a @code{defmatch}, que trata vari@'{a}veis de modelo como vari@'{a}veis globais.)
1089 @c ===beg===
1090 @c matchdeclare (aa, integerp, bb, atom);
1091 @c tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
1092 @c bb: 12345;
1093 @c foo (42, %e);
1094 @c bb;
1095 @c ===end===
1096 @example
1097 (%i1) matchdeclare (aa, integerp, bb, atom);
1098 (%o1) done
1099 (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
1100 (%o2) [foorule1, false]
1101 (%i3) bb: 12345;
1102 (%o3) 12345
1103 (%i4) foo (42, %e);
1104 (%o4) bar(aa = 42, bb = %e)
1105 (%i5) bb;
1106 (%o5) 12345
1107 @end example
1109 Como com todos os @'{a}tomos, propriedades de vari@'{a}veis de modelo s@~{a}o globais embora valores sejam locais.
1110 Nesse exemplo, uma propriedade de atribuiç@~{a}o @'{e} declarada via @code{define_variable}.
1111 Essa @'{e} a propriedade do @'{a}tomo @code{bb} atrav@'{e}s de todo o Maxima.
1113 @c ===beg===
1114 @c matchdeclare (aa, integerp, bb, atom);
1115 @c tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
1116 @c foo (42, %e);
1117 @c define_variable (bb, true, boolean);
1118 @c foo (42, %e);
1119 @c ===end===
1120 @example
1121 (%i1) matchdeclare (aa, integerp, bb, atom);
1122 (%o1) done
1123 (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
1124 (%o2) [foorule1, false]
1125 (%i3) foo (42, %e);
1126 (%o3) bar(aa = 42, bb = %e)
1127 (%i4) define_variable (bb, true, boolean);
1128 (%o4) true
1129 (%i5) foo (42, %e);
1130 Error: bb was declared mode boolean, has value: %e
1131 -- an error. Quitting. To debug this try debugmode(true);
1132 @end example
1134 Regras s@~{a}o nomeadas ap@'{o}s operadores principais.
1135 Nomes de regras para operadores internos e operadores definidos pelo usu@'{a}rio s@~{a}o seq@"{u}@^{e}ncias de caracteres,
1136 enquanto nomes para outras funç@~{o}es s@~{a}o identificadores comuns.
1138 @c ===beg===
1139 @c tellsimpafter (foo (%pi + %e), 3*%pi);
1140 @c tellsimpafter (foo (%pi * %e), 17*%e);
1141 @c tellsimpafter (foo (%i ^ %e), -42*%i);
1142 @c tellsimpafter (foo (9) + foo (13), quux (22));
1143 @c tellsimpafter (foo (9) * foo (13), blurf (22));
1144 @c tellsimpafter (foo (9) ^ foo (13), mumble (22));
1145 @c rules;
1146 @c foorule_name: first (%o1);
1147 @c plusrule_name: first (%o4);
1148 @c [?mstringp (foorule_name), symbolp (foorule_name)];
1149 @c [?mstringp (plusrule_name), symbolp (plusrule_name)];
1150 @c remrule (foo, foorule1);
1151 @c remrule ("^", "^rule1");
1152 @c ===end===
1153 @example
1154 (%i1) tellsimpafter (foo (%pi + %e), 3*%pi);
1155 (%o1) [foorule1, false]
1156 (%i2) tellsimpafter (foo (%pi * %e), 17*%e);
1157 (%o2) [foorule2, foorule1, false]
1158 (%i3) tellsimpafter (foo (%i ^ %e), -42*%i);
1159 (%o3) [foorule3, foorule2, foorule1, false]
1160 (%i4) tellsimpafter (foo (9) + foo (13), quux (22));
1161 (%o4) [+rule1, simplus]
1162 (%i5) tellsimpafter (foo (9) * foo (13), blurf (22));
1163 (%o5) [*rule1, simptimes]
1164 (%i6) tellsimpafter (foo (9) ^ foo (13), mumble (22));
1165 (%o6) [^rule1, simpexpt]
1166 (%i7) rules;
1167 (%o7) [trigrule0, trigrule1, trigrule2, trigrule3, trigrule4,
1168 htrigrule1, htrigrule2, htrigrule3, htrigrule4, foorule1,
1169 foorule2, foorule3, +rule1, *rule1, ^rule1]
1170 (%i8) foorule_name: first (%o1);
1171 (%o8) foorule1
1172 (%i9) plusrule_name: first (%o4);
1173 (%o9) +rule1
1174 (%i10) [?mstringp (foorule_name), symbolp (foorule_name)];
1175 (%o10) [false, true]
1176 (%i11) [?mstringp (plusrule_name), symbolp (plusrule_name)];
1177 (%o11) [true, true]
1178 (%i12) remrule (foo, foorule1);
1179 (%o12) foo
1180 (%i13) remrule ("^", "^rule1");
1181 (%o13) ^
1182 @end example
1184 Um exemplo trabalhado: multiplicaç@~{a}o anticomutativa.
1186 @c ===beg===
1187 @c gt (i, j) := integerp(j) and i < j;
1188 @c matchdeclare (i, integerp, j, gt(i));
1189 @c tellsimpafter (s[i]^^2, 1);
1190 @c tellsimpafter (s[i] . s[j], -s[j] . s[i]);
1191 @c s[1] . (s[1] + s[2]);
1192 @c expand (%);
1193 @c factor (expand (sum (s[i], i, 0, 9)^^5));
1194 @c ===end===
1195 @example
1196 (%i1) gt (i, j) := integerp(j) and i < j;
1197 (%o1) gt(i, j) := integerp(j) and i < j
1198 (%i2) matchdeclare (i, integerp, j, gt(i));
1199 (%o2) done
1200 (%i3) tellsimpafter (s[i]^^2, 1);
1201 (%o3) [^^rule1, simpncexpt]
1202 (%i4) tellsimpafter (s[i] . s[j], -s[j] . s[i]);
1203 (%o4) [.rule1, simpnct]
1204 (%i5) s[1] . (s[1] + s[2]);
1205 (%o5) s . (s + s )
1206 1 2 1
1207 (%i6) expand (%);
1208 (%o6) 1 - s . s
1209 2 1
1210 (%i7) factor (expand (sum (s[i], i, 0, 9)^^5));
1211 (%o7) 100 (s + s + s + s + s + s + s + s + s + s )
1212 9 8 7 6 5 4 3 2 1 0
1213 @end example
1215 @end deffn
1217 @deffn {Funç@~{a}o} clear_rules ()
1218 Executa @code{kill (rules)} e ent@~{a}o re-escolhe o pr@'{o}ximo n@'{u}mero de regra para 1
1219 para adiç@~{a}o @code{+}, multiplicaç@~{a}o @code{*}, e exponenciaç@~{a}o @code{^}.
1221 @end deffn