| blob | d65d1f69db7670d7eb1c02cd0e37d52cd94085d9 |
1 @c English version 2011-07-09
2 @menu
3 * Funciones y variable para las ecuaciones::
4 @end menu
6 @node Funciones y variable para las ecuaciones, , Ecuaciones, Ecuaciones
8 @section Funciones y variable para las ecuaciones
10 @defvr {Variable del sistema} %rnum_list
11 Valor por defecto: @code{[]}
13 La variable @code{%rnum_list} es la lista de variables introducidas en las
14 soluciones por la funciones @code{solve} y @code{algsys}.
15 Las variables @code{%r} se añaden a @code{%rnum_list} en su orden de creación.
16 Esto es útil para hacer sustituciones en la solución a posteriori.
18 @c ===beg===
19 @c solve ([x + y = 3], [x,y]);
20 @c %rnum_list;
21 @c sol : solve ([x + 2*y + 3*z = 4], [x,y,z]);
22 @c %rnum_list;
23 @c for i : 1 thru length (%rnum_list) do
24 @c sol : subst (t[i], %rnum_list[i], sol)$
25 @c sol;
26 @c ===end===
27 @example
28 @group
29 (%i1) solve ([x + y = 3], [x,y]);
30 (%o1) [[x = 3 - %r1, y = %r1]]
31 @end group
32 @group
33 (%i2) %rnum_list;
34 (%o2) [%r1]
35 @end group
36 @group
37 (%i3) sol : solve ([x + 2*y + 3*z = 4], [x,y,z]);
38 (%o3) [[x = - 2 %r3 - 3 %r2 + 4, y = %r3, z = %r2]]
39 @end group
40 @group
41 (%i4) %rnum_list;
42 (%o4) [%r2, %r3]
43 @end group
44 @group
45 (%i5) for i : 1 thru length (%rnum_list) do
46 sol : subst (t[i], %rnum_list[i], sol)$
47 @end group
48 @group
49 (%i6) sol;
50 (%o6) [[x = - 2 t - 3 t + 4, y = t , z = t ]]
51 2 1 2 1
52 @end group
53 @end example
54 @end defvr
57 @defvr {Variable opcional} algepsilon
58 Valor por defecto: 10^8
60 La variable @code{algepsilon} es utilizada por @code{algsys}.
62 @end defvr
65 @defvr {Variable opcional} algexact
66 Valor por defecto: @code{false}
68 El contenido de la variable @code{algexact} afecta al comportamiento de @code{algsys} de la siguiente forma:
70 Si @code{algexact} vale @code{true}, @code{algsys} llamará siempre a @code{solve} y luego utilizará @code{realroots}.
72 Si @code{algexact} vale @code{false}, @code{solve} será llamada sólo si la ecuación no es univariante, o si es cuadrática o bicuadrática.
74 Sin embargo, @code{algexact: true} no garantiza que únicamente se obtengan soluciones exactas, ya que aunque @code{algsys} intente siempre dar soluciones exactas, dará resultados aproximados si no encuentra una solución mejor.
76 @c ABOVE DESCRIPTION NOT TOO CLEAR -- MAYBE EXAMPLES WILL HELP
77 @end defvr
79 @deffn {Función} algsys ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}])
80 @deffnx {Función} algsys ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
82 Resuelve el sistema de ecuaciones polinómicas @var{expr_1}, ..., @var{expr_m}
83 o las ecuaciones @var{eqn_1}, ..., @var{eqn_m} para las variables @var{x_1}, ..., @var{x_n}.
84 La expresión @var{expr} equivale a la ecuación @code{@var{expr} = 0}. Puede haber más ecuaciones que variables o viceversa.
86 La función @code{algsys} devuelve una lista de soluciones, cada una de las cuales consistente a su vez en una lista de ecuaciones asociando valores a las variables @var{x_1}, ..., @var{x_n} que satisfacen el sistema de ecuaciones.
87 Si @code{algsys} no puede encontrar soluciones devuelve la lista vacía @code{[]}.
89 Si es necesario se introducen en la solución los símbolos @code{%r1}, @code{%r2}, ..., para representar parámetros arbitrarios; estas variables también se añaden a la lista @code{%rnum_list}.
91 El proceso que se sigue es el siguiente:
93 (1) Primero se factorizan las ecuaciones y se reparten en subsistemas.
95 (2) Para cada subsistema @var{S_i}, se seleccionan una ecuación @var{E} y una variable @var{x}. Se elige la variable que tenga grado menor. Entonces se calcula el resultado de @var{E} y @var{E_j} respecto de @var{x}, siendo las @var{E_j} el resto de ecuaciones del subsistema @var{S_i}. De aquí se obtiene otro subsistema @var{S_i'} con una incógnita menos, ya que @var{x} ha sido eliminada. El proceso ahora vuelve al paso (1).
97 (3) En ocasiones se obtiene un subsistema consistente en una única ecuación. Si la ecuación es multivariante y no se han introducido aproximaciones en formato decimal de coma flotante, entonces se llama a @code{solve} para tratar de encontrar una solución exacta.
99 En algunos casos, @code{solve} no puede encontrar la solución, o si lo consigue puede que el resultado tenga una expresión muy grande.
101 Si la ecuación tiene una sóla incógnita y es lineal, o cuadrática o bicuadrática, entonces se llama a la función @code{solve} si no se han introducido aproximaciones en formato decimal. Si se han introducido aproximaciones, o si hay más de una incógnita, o si no es lineal, ni cuadrática ni bicuadrática, y si la variables @code{realonly} vale @code{true}, entonces se llama a la función @code{realroots} para calcular las soluciones reales. Si
102 @code{realonly} vale @code{false}, entonces se llama a @code{allroots} para obtener las soluciones reales y complejas.
104 Si @code{algsys} devuelve una solución que tiene menos dígitos significativos de los requeridos, el usuario puede cambiar a voluntad el valor de @code{algepsilon} para obtener mayor precisión.
106 Si @code{algexact} vale @code{true}, se llamará siempre a @code{solve}.
108 Cuando @code{algsys} encuentra una ecuación con múltiples incógnitas y que contiene aproximaciones en coma flotante (normalmente debido a la imposibilidad de encontrar soluciones exactas en pasos anteriores), entonces no intenta aplicar los métodos exactos a estas ecuaciones y presenta el mensaje:
109 "@code{algsys} cannot solve - system too complicated."
111 Las interacciones con @code{radcan} pueden dar lugar a expresiones grandes o complicadas. En tal caso, puede ser posible aislar partes del resultado con @code{pickapart} o @code{reveal}.
113 Ocasionalmente, @code{radcan} puede introducir la unidad imaginaria @code{%i} en una solución que de hecho es real.
115 Ejemplos:
117 @c ===beg===
118 @c e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
119 @c e2: a2 - a1;
120 @c e3: a1*(-y - x^2 + 1);
121 @c e4: a2*(y - (x - 1)^2);
122 @c algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
123 @c e1: x^2 - y^2;
124 @c e2: -1 - y + 2*y^2 - x + x^2;
125 @c algsys ([e1, e2], [x, y]);
126 @c ===end===
127 @example
128 (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
129 (%o1) 2 (1 - a1) x - 2 a2 (x - 1)
130 (%i2) e2: a2 - a1;
131 (%o2) a2 - a1
132 (%i3) e3: a1*(-y - x^2 + 1);
133 2
134 (%o3) a1 (- y - x + 1)
135 (%i4) e4: a2*(y - (x - 1)^2);
136 2
137 (%o4) a2 (y - (x - 1) )
138 (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
139 (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],
141 [x = 1, y = 0, a1 = 1, a2 = 1]]
142 (%i6) e1: x^2 - y^2;
143 2 2
144 (%o6) x - y
145 (%i7) e2: -1 - y + 2*y^2 - x + x^2;
146 2 2
147 (%o7) 2 y - y + x - x - 1
148 (%i8) algsys ([e1, e2], [x, y]);
149 1 1
150 (%o8) [[x = - -------, y = -------],
151 sqrt(3) sqrt(3)
153 1 1 1 1
154 [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
155 sqrt(3) sqrt(3) 3 3
156 @end example
158 @end deffn
160 @deffn {Función} allroots (@var{expr})
161 @deffnx {Función} allroots (@var{eqn})
163 Calcula aproximaciones numéricas de las raíces reales y complejas del polinomio @var{expr} o ecuación polinómica @var{eqn} de una variable.
165 @c polyfactor IS NOT OTHERWISE DOCUMENTED
166 Si la variable @code{polyfactor} vale @code{true} hace que la función
167 @code{allroots} factorice el polinomio para números reales si el polinomio es real, o para números complejos si el polinomio es complejo.
169 La función @code{allroots} puede dar resultados inexactos en caso de que haya raíces múltiples.
170 Si el polinomio es real, @code{allroots (%i*@var{p})}) puede alcanzar mejores aproximaciones que @code{allroots (@var{p})},
171 ya que @code{allroots} ejecuta entonces un algoritmo diferente.
173 La función @code{allroots} no opera sobre expresiones no polinómicas, pues requiere que el numerador sea reducible a un polinomio y el denominador sea, como mucho, un número complejo.
175 Para polinomios complejos se utiliza el algoritmo de Jenkins y Traub descrito
176 en (Algorithm 419, @i{Comm. ACM}, vol. 15, (1972), p. 97). Para polinomios
177 reales se utiliza el algoritmo de Jenkins descrito en
178 (Algorithm 493, @i{ACM TOMS}, vol. 1, (1975), p.178).
180 Ejemplos:
181 @c EXAMPLES GENERATED BY THESE INPUTS:
182 @c eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
183 @c soln: allroots (eqn);
184 @c for e in soln
185 @c do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
186 @c polyfactor: true$
187 @c allroots (eqn);
189 @example
190 (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
191 3 5
192 (%o1) (2 x + 1) = 13.5 (x + 1)
193 (%i2) soln: allroots (eqn);
194 (%o2) [x = .8296749902129361, x = - 1.015755543828121,
196 x = .9659625152196369 %i - .4069597231924075,
198 x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
199 (%i3) for e in soln
200 do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
201 - 3.5527136788005E-15
203 - 5.32907051820075E-15
205 4.44089209850063E-15 %i - 4.88498130835069E-15
207 - 4.44089209850063E-15 %i - 4.88498130835069E-15
209 3.5527136788005E-15
211 (%o3) done
212 (%i4) polyfactor: true$
213 (%i5) allroots (eqn);
214 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)
216 2
217 (x + 1.015755543828121) (x + .8139194463848151 x
219 + 1.098699797110288)
220 @end example
222 @end deffn
225 @deffn {Función} bfallroots (@var{expr})
226 @deffnx {Función} bfallroots (@var{eqn})
227 Calcula aproximaciones numéricas de las raíces
228 reales y complejas del polinomio @var{expr} o de la ecuación
229 polinómica @var{eqn} de una variable.
231 En todos los aspectos, @code{bfallroots} es idéntica a @code{allroots},
232 excepto que @code{bfallroots} calcula las raíces en
233 formato bigfloat (números decimales de precisión arbitraria).
235 Véase @code{allroots} para más información.
236 @end deffn
239 @defvr {Variable opcional} backsubst
240 Valor por defecto: @code{true}
242 @c --- According to the documentation, to linsolve
243 Si @code{backsubst} vale @code{false}, evita la retrosustitución
244 en @code{linsolve} tras la triangularización de las ecuaciones.
245 Esto puede ser de utilidad en problemas muy grandes, en los que la
246 retrosustitución puede provocar la generación de expresiones
247 extremadamente largas.
249 @example
250 (%i1) eq1 : x + y + z = 6$
251 (%i2) eq2 : x - y + z = 2$
252 (%i3) eq3 : x + y - z = 0$
253 (%i4) backsubst : false$
254 @group
255 (%i5) linsolve ([eq1, eq2, eq3], [x,y,z]);
256 (%o5) [x = z - y, y = 2, z = 3]
257 @end group
258 (%i6) backsubst : true$
259 @group
260 (%i7) linsolve ([eq1, eq2, eq3], [x,y,z]);
261 (%o7) [x = 1, y = 2, z = 3]
262 @end group
263 @end example
265 @end defvr
268 @defvr {Variable opcional} breakup
269 Valor por defecto: @code{true}
271 Si @code{breakup} vale @code{true}, @code{solve} expresa sus soluciones a las ecuaciones cúbicas y cuárticas en términos de subexpresiones comunes, las cuales son asignadas a etiquetas del tipo @code{%t1}, @code{%t2}, etc.
272 En otro caso, no se identifican subexpresiones comunes.
274 La asignación @code{breakup: true} sólo tiene efecto cuando @code{programmode} vale @code{false}.
276 Ejemplos:
278 @example
279 (%i1) programmode: false$
280 (%i2) breakup: true$
281 (%i3) solve (x^3 + x^2 - 1);
283 sqrt(23) 25 1/3
284 (%t3) (--------- + --)
285 6 sqrt(3) 54
286 Solution:
288 sqrt(3) %i 1
289 ---------- - -
290 sqrt(3) %i 1 2 2 1
291 (%t4) x = (- ---------- - -) %t3 + -------------- - -
292 2 2 9 %t3 3
294 sqrt(3) %i 1
295 - ---------- - -
296 sqrt(3) %i 1 2 2 1
297 (%t5) x = (---------- - -) %t3 + ---------------- - -
298 2 2 9 %t3 3
300 1 1
301 (%t6) x = %t3 + ----- - -
302 9 %t3 3
303 (%o6) [%t4, %t5, %t6]
304 (%i6) breakup: false$
305 (%i7) solve (x^3 + x^2 - 1);
306 Solution:
308 sqrt(3) %i 1
309 ---------- - -
310 2 2 sqrt(23) 25 1/3
311 (%t7) x = --------------------- + (--------- + --)
312 sqrt(23) 25 1/3 6 sqrt(3) 54
313 9 (--------- + --)
314 6 sqrt(3) 54
316 sqrt(3) %i 1 1
317 (- ---------- - -) - -
318 2 2 3
320 sqrt(23) 25 1/3 sqrt(3) %i 1
321 (%t8) x = (--------- + --) (---------- - -)
322 6 sqrt(3) 54 2 2
324 sqrt(3) %i 1
325 - ---------- - -
326 2 2 1
327 + --------------------- - -
328 sqrt(23) 25 1/3 3
329 9 (--------- + --)
330 6 sqrt(3) 54
332 sqrt(23) 25 1/3 1 1
333 (%t9) x = (--------- + --) + --------------------- - -
334 6 sqrt(3) 54 sqrt(23) 25 1/3 3
335 9 (--------- + --)
336 6 sqrt(3) 54
337 (%o9) [%t7, %t8, %t9]
338 @end example
340 @end defvr
342 @deffn {Función} dimension (@var{eqn})
343 @deffnx {Función} dimension (@var{eqn_1}, ..., @var{eqn_n})
345 El paquete @code{dimen} es para análisis dimensional. La instrucción @code{load ("dimen")} carga el paquete y
346 @code{demo ("dimen")} presenta una pequeña demostración.
347 @c I GUESS THIS SHOULD BE EXPANDED TO COVER EACH FUNCTION IN THE PACKAGE
349 @end deffn
351 @defvr {Variable opcional} dispflag
352 Valor por defecto: @code{true}
354 @c WHAT DOES THIS MEAN ??
355 Si @code{dispflag} vale @code{false}, entonces se inhibirá que Maxima muestre resultados de las funciones que resuelven ecuaciones cuando éstas son llamadas desde dentro de un bloque (@code{block}). Cuando un bloque termina con el signo del dólar, $, a la variable @code{dispflag} se le asigna @code{false}.
357 @end defvr
359 @deffn {Función} funcsolve (@var{eqn}, @var{g}(@var{t}))
361 Devuelve @code{[@var{g}(@var{t}) = ...]} o @code{[]}, dependiendo de que exista o no una función racional @code{@var{g}(@var{t})} que satisfaga @var{eqn}, la cual debe ser un polinomio de primer orden, lineal para @code{@var{g}(@var{t})} y @code{@var{g}(@var{t}+1)}
363 @example
364 (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1)
365 = (n - 1)/(n + 2);
366 (n + 3) f(n + 1) n - 1
367 (%o1) (n + 1) f(n) - ---------------- = -----
368 n + 1 n + 2
369 (%i2) funcsolve (eqn, f(n));
371 Dependent equations eliminated: (4 3)
372 n
373 (%o2) f(n) = ---------------
374 (n + 1) (n + 2)
375 @end example
377 Aviso: esta es una implemetación rudimentaria, por lo que debe ser utilizada con cautela.
379 @end deffn
381 @defvr {Variable opcional} globalsolve
382 Valor por defecto: @code{false}
384 Si @code{globalsolve} vale @code{true},
385 a las incógnitas de las ecuaciones se les asignan las soluciones encontradas por @code{linsolve} y
386 por @code{solve} cuando se resuelven sistemas de dos o más ecuaciones lineales.
388 Si @code{globalsolve} vale @code{false},
389 las soluciones encontradas por @code{linsolve} y por @code{solve} cuando se resuelven sistemas de dos o más ecuaciones lineales se expresan como ecuaciones y a las incógnitas no se le asignan valores.
391 Cuando se resuelven ecuaciones que no son sistemas de dos o más ecuaciones lineales, @code{solve} ignora el valor de @code{globalsolve}. Otras funciones que resuelven ecuaciones (como @code{algsys}) ignoran siempre el valor de @code{globalsolve}.
393 Ejemplos:
395 @example
396 (%i1) globalsolve: true$
397 (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
398 Solution
400 17
401 (%t2) x : --
402 7
404 1
405 (%t3) y : - -
406 7
407 (%o3) [[%t2, %t3]]
408 (%i3) x;
409 17
410 (%o3) --
411 7
412 (%i4) y;
413 1
414 (%o4) - -
415 7
416 (%i5) globalsolve: false$
417 (%i6) kill (x, y)$
418 (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
419 Solution
421 17
422 (%t7) x = --
423 7
425 1
426 (%t8) y = - -
427 7
428 (%o8) [[%t7, %t8]]
429 (%i8) x;
430 (%o8) x
431 (%i9) y;
432 (%o9) y
433 @end example
435 @end defvr
437 @deffn {Función} ieqn (@var{ie}, @var{unk}, @var{tech}, @var{n}, @var{guess})
438 El paquete @code{inteqn} se dedica a la resolución de ecuaciones integrales. Para hacer uso de él, ejecutar la instrucción @code{load ("inteqn")}.
440 El argumento @var{ie} es la ecuación integral; @var{unk} es la función incógnita; @var{tech} es el método a aplicar para efectuar la resolución del problema (@var{tech} = @code{first} significa: aplica el primer método que encuentre una solución; @var{tech} = @code{all} significa: aplica todos los métodos posibles); @var{n} es el número máximo de términos que debe tomar @code{taylor}, @code{neumann}, @code{firstkindseries} o @code{fredseries} (también es el máximo nivel de recursión para el método de diferenciación); @var{guess} es la solución candidata inicial para @code{neumann} o @code{firstkindseries}.
442 Valores por defecto para los argumentos segundo a quinto son:
444 @var{unk}: @code{@var{p}(@var{x})}, donde @var{p} es la primera función desconocida que Maxima encuentra en el integrando y @var{x} es la variable que actúa como argumento en la primera aparición de @var{p} encontrada fuera de una integral en el caso de ecuaciones de segunda especie (@code{secondkind}), o es la única variable aparte de la de integración en el caso de ecuaciones de primera especie (@code{firstkind}). Si el intento de encontrar @var{x} falla, el usuario será consultado para suministrar una variable independiente.
446 @c FALTAN AQUI ALGUNAS LINEAS
448 @end deffn
451 @defvr {Variable opcional} ieqnprint
452 Valor por defecto: @code{true}
454 La variable @code{ieqnprint} controla el comportamiento del resultado retornado por la instrucción @code{ieqn}. Si @code{ieqnprint} vale @code{false}, la lista devuelta por la función @code{ieqn} tiene el formato
456 [@var{solución}, @var{método utilizado}, @var{nterms}, @var{variable}]
458 donde @var{variable} estará ausente si la solución es exacta; en otro caso, será la palabra @code{approximate} o @code{incomplete} según que la solución sea inexacta o que no tenga forma explícita, respectivamente. Si se ha utilizado un método basado en series, @var{nterms} es el número de términos utilizado, que puede ser menor que el @code{n} dado a @code{ieqn}.
460 @end defvr
462 @deffn {Función} lhs (@var{expr})
463 Devuelve el miembro izquierdo (es decir, el primer argumento)
464 de la expresión @var{expr},
465 cuando el operador de @var{expr} es uno de los operadores
466 de relación @code{< <= = # equal notequal >= >},
467 o un operadores de asignación @code{:= ::= : ::},
468 o un operador infijo binario definido por el usuario mediante @code{infix}.
470 Si @var{expr} es un átomo o si su operador es diferente de los
471 citados más arriba, @code{lhs} devuelve @var{expr}.
473 Véase también @code{rhs}.
475 Ejemplo:
477 @c ===beg===
478 @c e: aa + bb = cc;
479 @c lhs (e);
480 @c rhs (e);
481 @c [lhs (aa < bb), lhs (aa <= bb),
482 @c lhs (aa >= bb), lhs (aa > bb)];
483 @c [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)),
484 @c lhs (notequal (aa, bb))];
485 @c e1: '(foo(x) := 2*x);
486 @c e2: '(bar(y) ::= 3*y);
487 @c e3: '(x : y);
488 @c e4: '(x :: y);
489 @c [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
490 @c infix ("][");
491 @c lhs (aa ][ bb);
492 @c ===end===
493 @example
494 (%i1) e: aa + bb = cc;
495 (%o1) bb + aa = cc
496 (%i2) lhs (e);
497 (%o2) bb + aa
498 (%i3) rhs (e);
499 (%o3) cc
500 (%i4) [lhs (aa < bb), lhs (aa <= bb),
501 lhs (aa >= bb), lhs (aa > bb)];
502 (%o4) [aa, aa, aa, aa]
503 (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)),
504 lhs (notequal (aa, bb))];
505 (%o5) [aa, aa, aa, aa]
506 (%i6) e1: '(foo(x) := 2*x);
507 (%o6) foo(x) := 2 x
508 (%i7) e2: '(bar(y) ::= 3*y);
509 (%o7) bar(y) ::= 3 y
510 (%i8) e3: '(x : y);
511 (%o8) x : y
512 (%i9) e4: '(x :: y);
513 (%o9) x :: y
514 (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
515 (%o10) [foo(x), bar(y), x, x]
516 (%i11) infix ("][");
517 (%o11) ][
518 (%i12) lhs (aa ][ bb);
519 (%o12) aa
520 @end example
522 @end deffn
524 @deffn {Función} linsolve ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}])
525 Resuelve la lista de ecuaciones lineales simultáneas para la lista de variables. Las expresiones deben ser polinomios lineales respecto de las variables o ecuaciones.
527 Si @code{globalsolve} vale @code{true},
528 a cada incógnita se le asigna el valor de la solución encontrada.
530 Si @code{backsubst} vale @code{false}, @code{linsolve}
531 no hace la sustitución tras la triangulariación de las ecuaciones.
532 Esto puede ser necesario en problemas muy grandes en los que la
533 sustitución puede dar lugar a la generación de expresiones
534 enormes.
536 Si @code{linsolve_params} vale @code{true}, @code{linsolve} también genera símbolos @code{%r} para representar parámetros arbitrarios como los descritos para la función @code{algsys}. Si vale @code{false}, el resultado devuelto por @code{linsolve} expresará, si es el sistema es indeterminado, unas variables en función de otras.
538 Si @code{programmode} vale @code{false},
539 @code{linsolve} muestra la solución con etiquetas de expresiones
540 intermedias (@code{%t}) y devuelve las lista de etiquetas.
542 @c ===beg===
543 @c e1: x + z = y;
544 @c e2: 2*a*x - y = 2*a^2;
545 @c e3: y - 2*z = 2;
546 @c [globalsolve: false, programmode: true];
547 @c linsolve ([e1, e2, e3], [x, y, z]);
548 @c [globalsolve: false, programmode: false];
549 @c linsolve ([e1, e2, e3], [x, y, z]);
550 @c ''%;
551 @c [globalsolve: true, programmode: false];
552 @c linsolve ([e1, e2, e3], [x, y, z]);
553 @c ''%;
554 @c [x, y, z];
555 @c [globalsolve: true, programmode: true];
556 @c linsolve ([e1, e2, e3], '[x, y, z]);
557 @c [x, y, z];
558 @c ===end===
559 @example
560 (%i1) e1: x + z = y;
561 (%o1) z + x = y
562 (%i2) e2: 2*a*x - y = 2*a^2;
563 2
564 (%o2) 2 a x - y = 2 a
565 (%i3) e3: y - 2*z = 2;
566 (%o3) y - 2 z = 2
567 (%i4) [globalsolve: false, programmode: true];
568 (%o4) [false, true]
569 (%i5) linsolve ([e1, e2, e3], [x, y, z]);
570 (%o5) [x = a + 1, y = 2 a, z = a - 1]
571 (%i6) [globalsolve: false, programmode: false];
572 (%o6) [false, false]
573 (%i7) linsolve ([e1, e2, e3], [x, y, z]);
574 Solution
576 (%t7) z = a - 1
578 (%t8) y = 2 a
580 (%t9) x = a + 1
581 (%o9) [%t7, %t8, %t9]
582 (%i9) ''%;
583 (%o9) [z = a - 1, y = 2 a, x = a + 1]
584 (%i10) [globalsolve: true, programmode: false];
585 (%o10) [true, false]
586 (%i11) linsolve ([e1, e2, e3], [x, y, z]);
587 Solution
589 (%t11) z : a - 1
591 (%t12) y : 2 a
593 (%t13) x : a + 1
594 (%o13) [%t11, %t12, %t13]
595 (%i13) ''%;
596 (%o13) [z : a - 1, y : 2 a, x : a + 1]
597 (%i14) [x, y, z];
598 (%o14) [a + 1, 2 a, a - 1]
599 (%i15) [globalsolve: true, programmode: true];
600 (%o15) [true, true]
601 (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
602 (%o16) [x : a + 1, y : 2 a, z : a - 1]
603 (%i17) [x, y, z];
604 (%o17) [a + 1, 2 a, a - 1]
605 @end example
607 @end deffn
609 @defvr {Variable opcional} linsolvewarn
610 Valor por defecto: @code{true}
612 Si @code{linsolvewarn} vale @code{true}, @code{linsolve} mostrará el mensaje: "Dependent equations eliminated".
614 @end defvr
616 @defvr {Variable opcional} linsolve_params
617 Valor por defecto: @code{true}
619 Si @code{linsolve_params} vale @code{true}, @code{linsolve} también genera símbolos @code{%r} para representar parámetros arbitrarios como los descritos para la función @code{algsys}. Si vale @code{false}, el resultado devuelto por @code{linsolve} expresará, si es el sistema es indeterminado, unas variables en función de otras.
621 @end defvr
623 @defvr {System variable} multiplicities
624 Valor por defecto: @code{not_set_yet}
626 La variable @code{multiplicities} es una con las multiplicidades de las soluciones encontradas por @code{solve} o
627 @code{realroots}.
628 @c NEED AN EXAMPLE HERE
630 @end defvr
632 @deffn {Función} nroots (@var{p}, @var{low}, @var{high})
633 Devuelve el número de raíces reales del polinomio real univariante @var{p} en el intervalo semiabierto
634 @code{(@var{low}, @var{high}]}. Los extremos del intervalo pueden ser @code{minf} o @code{inf}, menos y más infinito.
636 La función @code{nroots} utiliza el método de las secuencias de Sturm.
638 @example
639 (%i1) p: x^10 - 2*x^4 + 1/2$
640 (%i2) nroots (p, -6, 9.1);
641 (%o2) 4
642 @end example
644 @end deffn
646 @deffn {Función} nthroot (@var{p}, @var{n})
648 Siendo @code{p} un polinomio de coeficientes enteros y @code{n} un entero positivo, @code{nthroot} devuelve un polinomio @code{q}, también de coeficientes enteros, tal que @code{q^n=p}, o un mensaje de error indicando que @code{p} no es una @code{n}-potencia exacta. Esta función es bastante más rápida que @code{factor} y que @code{sqfr}.
650 @end deffn
654 @defvr {Variable opcional} polyfactor
655 Valor por defecto: @code{false}
657 Cuando @code{polyfactor} vale @code{true}, las funciones
658 @code{allroots} y @code{bfallroots} factorizan el polinomio
659 sobre los números reales si el polinomio es real, o
660 factoriza sobre los complejos si el polinomio es complejo.
662 Véase un ejemplo en @code{allroots}.
663 @end defvr
667 @defvr {Variable opcional} programmode
668 Valor por defecto: @code{true}
670 Si @code{programmode} vale @code{true}, @code{solve}, @code{realroots}, @code{allroots} y @code{linsolve}
671 devuelve sus soluciones como elementos de una lista. @c FALTAN AQUI ALGUNAS FRASES
673 Si @code{programmode} vale @code{false}, @code{solve} y las demás crean expresiones intermedias etiquetadas @code{%t1}, @code{t2}, etc., y les asinan las soluciones.
675 @example
676 (%i1) solve(x^2+x+1);
677 sqrt(3) %i + 1 sqrt(3) %i - 1
678 (%o1) [x = - --------------, x = --------------]
679 2 2
680 (%i2) programmode:false$
681 (%i3) solve(x^2+x+1);
682 Solution:
684 sqrt(3) %i + 1
685 (%t3) x = - --------------
686 2
688 sqrt(3) %i - 1
689 (%t4) x = --------------
690 2
691 (%o4) [%t4, %t5]
692 @end example
694 @end defvr
696 @defvr {Variable opcional} realonly
697 Valor por defecto: @code{false}
699 Si @code{realonly} vale @code{true}, @code{algsys} sólo devuelve aquellas soluciones exentas de la constante @code{%i}.
701 @end defvr
704 @deffn {Función} realroots (@var{expr}, @var{bound})
705 @deffnx {Función} realroots (@var{eqn}, @var{bound})
706 @deffnx {Función} realroots (@var{expr})
707 @deffnx {Función} realroots (@var{eqn})
708 Calcula aproximaciones racionales de las raíces reales del
709 polinomio @var{expr} o de la ecuación polinómica @var{eqn} de una variable,
710 dentro de la tolerancia especificada por @var{bound}.
711 Los coeficientes de @var{expr} o de @var{eqn} deben ser números literales,
712 por lo que las constantes simbólicas como @code{%pi} no son aceptadas.
714 La función @code{realroots} guarda las multiplicidades de las
715 raíces encontradas en la variable global @code{multiplicities}.
717 La función @code{realroots} genera una secuencia de Sturm para acotar cada
718 raíz, aplicando después el método de bisección para
719 afinar las aproximaciones. Todos los coeficientes se convierten a formas
720 racionales equivalentes antes de comenzar la búsqueda de las raíces,
721 de modo que los cálculos se realizan con aritmética exacta racional. Incluso en
722 el caso de que algunos coeficientes sean números decimales en coma flotante, los
723 resultados son racionales, a menos que se les fuerce a ser decimales con las variables
724 @code{float} o @code{numer}.
726 Si @var{bound} es menor que la unidad, todas las raíces enteras se expresan
727 en forma exacta. Si no se especifica @var{bound}, se le supone igual al valor de la
728 variable global @code{rootsepsilon}.
730 Si la variable global @code{programmode} vale @code{true}, la función
731 @code{realroots} devuelve una lista de la forma @code{[x = @var{x_1}, x = @var{x_2}, ...]}.
732 Si @code{programmode} vale @code{false}, @code{realroots} crea etiquetas
733 @code{%t1}, @code{%t2}, ... para las expresiones intermedias, les asigna valores y, finalmente,
734 devuelve la lista de etiquetas.
736 Ejemplos:
737 @c ===beg===
738 @c realroots (-1 - x + x^5, 5e-6);
739 @c ev (%[1], float);
740 @c ev (-1 - x + x^5, %);
741 @c ===end===
743 @example
744 (%i1) realroots (-1 - x + x^5, 5e-6);
745 612003
746 (%o1) [x = ------]
747 524288
748 (%i2) ev (%[1], float);
749 (%o2) x = 1.167303085327148
750 (%i3) ev (-1 - x + x^5, %);
751 (%o3) - 7.396496210176905E-6
752 @end example
754 @c ===beg===
755 @c realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
756 @c multiplicities;
757 @c ===end===
759 @example
760 (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
761 (%o1) [x = 1, x = 2, x = 3]
762 (%i2) multiplicities;
763 (%o2) [5, 3, 1]
764 @end example
766 @end deffn
770 @deffn {Función} rhs (@var{expr})
771 Devuelve el miembro derecho (es decir, el segundo argumento)
772 de la expresión @var{expr},
773 cuando el operador de @var{expr} es uno de los operadores
774 de relación @code{< <= = # equal notequal >= >},
775 o un operadores de asignación @code{:= ::= : ::},
776 o un operador infijo binario definido por el usuario mediante @code{infix}.
778 Si @var{expr} es un átomo o si su operador es diferente de los
779 citados más arriba, @code{rhs} devuelve @var{expr}.
781 Véase también @code{lhs}.
783 Ejemplo:
785 @c ===beg===
786 @c e: aa + bb = cc;
787 @c lhs (e);
788 @c rhs (e);
789 @c [rhs (aa < bb), rhs (aa <= bb),
790 @c rhs (aa >= bb), rhs (aa > bb)];
791 @c [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)),
792 @c rhs (notequal (aa, bb))];
793 @c e1: '(foo(x) := 2*x);
794 @c e2: '(bar(y) ::= 3*y);
795 @c e3: '(x : y);
796 @c e4: '(x :: y);
797 @c [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
798 @c infix ("][");
799 @c rhs (aa ][ bb);
800 @c ===end===
801 @example
802 (%i1) e: aa + bb = cc;
803 (%o1) bb + aa = cc
804 (%i2) lhs (e);
805 (%o2) bb + aa
806 (%i3) rhs (e);
807 (%o3) cc
808 (%i4) [rhs (aa < bb), rhs (aa <= bb),
809 rhs (aa >= bb), rhs (aa > bb)];
810 (%o4) [bb, bb, bb, bb]
811 (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)),
812 rhs (notequal (aa, bb))];
813 (%o5) [bb, bb, bb, bb]
814 (%i6) e1: '(foo(x) := 2*x);
815 (%o6) foo(x) := 2 x
816 (%i7) e2: '(bar(y) ::= 3*y);
817 (%o7) bar(y) ::= 3 y
818 (%i8) e3: '(x : y);
819 (%o8) x : y
820 (%i9) e4: '(x :: y);
821 (%o9) x :: y
822 (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
823 (%o10) [2 x, 3 y, y, y]
824 (%i11) infix ("][");
825 (%o11) ][
826 (%i12) rhs (aa ][ bb);
827 (%o12) bb
828 @end example
830 @end deffn
832 @defvr {Variable opcional} rootsconmode
833 Valor por defecto: @code{true}
835 La variable @code{rootsconmode} controla el comportamiento de la instrucción @code{rootscontract}. Véase @code{rootscontract} para más detalles.
837 @end defvr
839 @deffn {Función} rootscontract (@var{expr})
840 Convierte productos de raíces en raíces de productos. Por ejemplo, @code{rootscontract (sqrt(x)*y^(3/2))} devuelve @code{sqrt(x*y^3)}.
842 Si @code{radexpand} vale @code{true} y @code{domain} vale @code{real},
843 @code{rootscontract} convierte @code{abs} en @code{sqrt}, por ejemplo,
844 @code{rootscontract (abs(x)*sqrt(y))} devuelve @code{sqrt(x^2*y)}.
846 La opción @code{rootsconmode} afecta el resultado de @code{rootscontract} como sigue:
848 @example
849 Problema Valor de Resultadod de
850 rootsconmode rootscontract
852 x^(1/2)*y^(3/2) false (x*y^3)^(1/2)
853 x^(1/2)*y^(1/4) false x^(1/2)*y^(1/4)
854 x^(1/2)*y^(1/4) true (x*y^(1/2))^(1/2)
855 x^(1/2)*y^(1/3) true x^(1/2)*y^(1/3)
856 x^(1/2)*y^(1/4) all (x^2*y)^(1/4)
857 x^(1/2)*y^(1/3) all (x^3*y^2)^(1/6)
858 @end example
860 Si @code{rootsconmode} vale @code{false}, @code{rootscontract} contrae sólamente respecto de exponentes racionales cuyos denominadores sean iguales. La clave para los ejemplos @code{rootsconmode: true} es simplemente que 2 divide a 4 pero no a 3. La asignación @code{rootsconmode: all} hace que se calcule el mínimo común múltiplo de los denominadores de los exponentes.
862 La función @code{rootscontract} utiliza @code{ratsimp} de forma similar a como lo hace @code{logcontract}.
864 Ejemplos:
865 @c FOLLOWING ADAPTED FROM example (rootscontract)
866 @c rootsconmode: false$
867 @c rootscontract (x^(1/2)*y^(3/2));
868 @c rootscontract (x^(1/2)*y^(1/4));
869 @c rootsconmode: true$
870 @c rootscontract (x^(1/2)*y^(1/4));
871 @c rootscontract (x^(1/2)*y^(1/3));
872 @c rootsconmode: all$
873 @c rootscontract (x^(1/2)*y^(1/4));
874 @c rootscontract (x^(1/2)*y^(1/3));
875 @c rootsconmode: false$
876 @c rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
877 @c *sqrt(sqrt(1 + x) - sqrt(x)));
878 @c rootsconmode: true$
879 @c rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
881 @example
882 (%i1) rootsconmode: false$
883 (%i2) rootscontract (x^(1/2)*y^(3/2));
884 3
885 (%o2) sqrt(x y )
886 (%i3) rootscontract (x^(1/2)*y^(1/4));
887 1/4
888 (%o3) sqrt(x) y
889 (%i4) rootsconmode: true$
890 (%i5) rootscontract (x^(1/2)*y^(1/4));
891 (%o5) sqrt(x sqrt(y))
892 (%i6) rootscontract (x^(1/2)*y^(1/3));
893 1/3
894 (%o6) sqrt(x) y
895 (%i7) rootsconmode: all$
896 (%i8) rootscontract (x^(1/2)*y^(1/4));
897 2 1/4
898 (%o8) (x y)
899 (%i9) rootscontract (x^(1/2)*y^(1/3));
900 3 2 1/6
901 (%o9) (x y )
902 (%i10) rootsconmode: false$
903 (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
904 *sqrt(sqrt(1 + x) - sqrt(x)));
905 (%o11) 1
906 (%i12) rootsconmode: true$
907 (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
908 (%o13) 0
909 @end example
911 @end deffn
913 @defvr {Variable opcional} rootsepsilon
914 Valor por defecto: 1.0e-7
916 La variable @code{rootsepsilon} es la tolerancia que establece el intervalo de confianza para las raíces calculadas por la función @code{realroots}.
917 @c IS IT GUARANTEED THAT |ACTUAL - ESTIMATE| < rootepsilon OR IS IT SOME OTHER NOTION ??
918 @c NEED EXAMPLE HERE
920 @end defvr
922 @deffn {Función} solve (@var{expr}, @var{x})
923 @deffnx {Función} solve (@var{expr})
924 @deffnx {Función} solve ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_n}])
926 Resuelve la ecuación algebraica @var{expr} de incógnita @var{x} y devuelve una lista de igualdades con la @var{x} despejada. Si @var{expr} no es una igualdad, se supone que se quiere resolver la ecuación @code{@var{expr} = 0}.
927 El argumento @var{x} puede ser una función (por ejemplo, @code{f(x)}), u otra expresión no atómica, excepto una suma o producto. Puede omitirse @var{x} si @var{expr} contiene solamente una variable. El argumento @var{expr} puede ser una expresión racional y puede contener funciones trigonométricas, exponenciales, etc.
929 Se utiliza el siguiente método de resolución:
931 Sea @var{E} la expresión y @var{X} la incógnita. Si @var{E} es lineal respecto de @var{X} entonces @var{X} se resuelve de forma trivial. En caso contrario, si @var{E} es de la forma @code{A*X^N + B} entonces el resultado es @code{(-B/A)^1/N)} multiplicado por las @code{N}-ésimas raíces de la unidad.
933 Si @var{E} no es lineal respecto de @var{X} entonces el máximo común divisor de los exponentes de @var{X} en @var{E} (supóngase que es @var{N}) se divide entre los exponentes y la multiplicidad de las raíces se multiplica por @var{N}. Entonces es llamado recursivamente @code{solve} para este resultado. Si @var{E} es factorizable entonces @code{solve} es invocado para cada uno de los factores. Finalmente, @code{solve} usará, según sea necesario, las fórmulas cuadrática, cúbica o cuártica.
935 En caso de que @var{E} sea un polinomio respecto de una función de la incógnita, por ejemplo @code{F(X)}, entonces se calcula primero para @code{F(X)} (sea @var{C} el resultado obtenido), entonces la ecuación @code{F(X)=C} se resuelve para @var{X} en el supuesto que se conozca la inversa de la función @var{F}.
937 Si la variable @code{breakup} vale @code{false} hará que @code{solve} muestre las soluciones de las ecuaciones cúbicas o cuárticas como expresiones únicas, en lugar de utilizar varias subexpresiones comunes, que es el formato por defecto.
939 A la variable @code{multiplicities} se le asignará una lista con las multiplicidades de las soluciones individuales devueltas por @code{solve}, @code{realroots} o @code{allroots}. La instrucción @code{apropos (solve)} hará que se muestren las variables optativas que de algún modo afectan al comportamiento de @code{solve}. Se podrá luego utilizar la función @code{describe} para aquellas variables cuyo objeto no esté claro.
941 La llamada @code{solve ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_n}])}
942 resuelve un sistema de ecuaciones polinómicas simultáneas (lineales o no) llamando a @code{linsolve} o @code{algsys} y devuelve una lista de listas con soluciones para las incógnitas. En caso de haberse llamado a @code{linsolve} esta lista contendrá una única lista de soluciones. La llamada a @code{solve} tiene dos listas como argumentos. La primera lista tiene las ecuaciones a resolver y la segunda son las incógnitas cuyos valores se quieren calcular. Si el número de variables en las ecuaciones es igual al número de incógnitas, el segundo argumento puede omitirse.
944 Si @code{programmode} vale @code{false},
945 @code{solve} muestra la solución con etiquetas de expresiones
946 intermedias (@code{%t}) y devuelve las lista de etiquetas.
949 Si @code{globalsolve} vale @code{true} y el problema consiste en resolver un sistema de dos o más ecuaciones lineales, a cada incógnita se le asigna el valor encontrado en la resolución del sistema.
951 Ejemplos:
952 @c FOLLOWING ADAPTED FROM example (solve)
953 @c ===beg===
954 @c solve (asin (cos (3*x))*(f(x) - 1), x);
955 @c ev (solve (5^f(x) = 125, f(x)), solveradcan);
956 @c [4*x^2 - y^2 = 12, x*y - x = 2];
957 @c solve (%, [x, y]);
958 @c solve (1 + a*x + x^3, x);
959 @c solve (x^3 - 1);
960 @c solve (x^6 - 1);
961 @c ev (x^6 - 1, %[1]);
962 @c expand (%);
963 @c x^2 - 1;
964 @c solve (%, x);
965 @c ev (%th(2), %[1]);
966 @c ===end===
967 @example
968 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);
970 SOLVE is using arc-trig functions to get a solution.
971 Some solutions will be lost.
972 %pi
973 (%o1) [x = ---, f(x) = 1]
974 6
975 (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
976 log(125)
977 (%o2) [f(x) = --------]
978 log(5)
979 (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
980 2 2
981 (%o3) [4 x - y = 12, x y - x = 2]
982 (%i4) solve (%, [x, y]);
983 (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i
985 - .1331240357358706, y = .0767837852378778
987 - 3.608003221870287 %i], [x = - .5202594388652008 %i
989 - .1331240357358706, y = 3.608003221870287 %i
991 + .0767837852378778], [x = - 1.733751846381093,
993 y = - .1535675710019696]]
994 (%i5) solve (1 + a*x + x^3, x);
995 3
996 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3
997 (%o5) [x = (- ---------- - -) (--------------- - -)
998 2 2 6 sqrt(3) 2
1000 sqrt(3) %i 1
1001 (---------- - -) a
1002 2 2
1003 - --------------------------, x =
1004 3
1005 sqrt(4 a + 27) 1 1/3
1006 3 (--------------- - -)
1007 6 sqrt(3) 2
1009 3
1010 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3
1011 (---------- - -) (--------------- - -)
1012 2 2 6 sqrt(3) 2
1014 sqrt(3) %i 1
1015 (- ---------- - -) a
1016 2 2
1017 - --------------------------, x =
1018 3
1019 sqrt(4 a + 27) 1 1/3
1020 3 (--------------- - -)
1021 6 sqrt(3) 2
1023 3
1024 sqrt(4 a + 27) 1 1/3 a
1025 (--------------- - -) - --------------------------]
1026 6 sqrt(3) 2 3
1027 sqrt(4 a + 27) 1 1/3
1028 3 (--------------- - -)
1029 6 sqrt(3) 2
1030 (%i6) solve (x^3 - 1);
1031 sqrt(3) %i - 1 sqrt(3) %i + 1
1032 (%o6) [x = --------------, x = - --------------, x = 1]
1033 2 2
1034 (%i7) solve (x^6 - 1);
1035 sqrt(3) %i + 1 sqrt(3) %i - 1
1036 (%o7) [x = --------------, x = --------------, x = - 1,
1037 2 2
1039 sqrt(3) %i + 1 sqrt(3) %i - 1
1040 x = - --------------, x = - --------------, x = 1]
1041 2 2
1042 (%i8) ev (x^6 - 1, %[1]);
1043 6
1044 (sqrt(3) %i + 1)
1045 (%o8) ----------------- - 1
1046 64
1047 (%i9) expand (%);
1048 (%o9) 0
1049 (%i10) x^2 - 1;
1050 2
1051 (%o10) x - 1
1052 (%i11) solve (%, x);
1053 (%o11) [x = - 1, x = 1]
1054 (%i12) ev (%th(2), %[1]);
1055 (%o12) 0
1056 @end example
1058 Los í @code{%r} se utilizan para indicar parámetros en
1059 las soluciones.
1061 @example
1062 (%i1) solve([x+y=1,2*x+2*y=2],[x,y]);
1064 solve: dependent equations eliminated: (2)
1065 (%o1) [[x = 1 - %r1, y = %r1]]
1066 @end example
1068 Véanse @code{algsys} y @code{%rnum_list} para más información.
1070 @end deffn
1072 @defvr {Variable opcional} solvedecomposes
1073 Valor por defecto: @code{true}
1075 Si @code{solvedecomposes} vale @code{true}, @code{solve} llama a @code{polydecomp} en caso de que se le pida resolver ecuaciones polinómicas.
1076 @c OTHERWISE WHAT HAPPENS -- CAN'T SOLVE POLYNOMIALS, OR SOME OTHER METHOD IS USED ??
1078 @end defvr
1080 @defvr {Variable opcional} solveexplicit
1081 Valor por defecto: @code{false}
1083 Si @code{solveexplicit} vale @code{true}, le inhibe a @code{solve} devolver soluciones implícitas, esto es, soluciones de la forma @code{F(x) = 0}, donde @code{F} es cierta función.
1084 @c NEED AN EXAMPLE HERE
1086 @end defvr
1088 @defvr {Variable opcional} solvefactors
1089 Valor por defecto: @code{true}
1091 @c WHAT IS THIS ABOUT EXACTLY ??
1092 Si @code{solvefactors} vale @code{false}, @code{solve} no intenta factorizar la expresión. Este valor @code{false} puede ser útil en algunos casos en los que la factorización no es necesaria.
1093 @c NEED AN EXAMPLE HERE
1095 @end defvr
1097 @defvr {Variable opcional} solvenullwarn
1098 Valor por defecto: @code{true}
1100 Si @code{solvenullwarn} vale @code{true}, @code{solve} muestra un mensaje de aviso si es llamado con una lista de ecuaciones vacía o con una lista de incógnitas vacía. Por ejemplo, @code{solve ([], [])} imprimirá dos mensajes de aviso y devolverá @code{[]}.
1102 @end defvr
1104 @defvr {Variable opcional} solveradcan
1105 Valor por defecto: @code{false}
1107 Si @code{solveradcan} vale @code{true}, @code{solve} llama a @code{radcan}, lo que hará que @code{solve} se ejecute de forma más lenta, pero permitirá que se resuelvan ciertas ecuaciones que contengan exponenciales y logaritmos.
1108 @c NEED AN EXAMPLE HERE
1110 @end defvr
1112 @defvr {Variable opcional} solvetrigwarn
1113 Valor por defecto: @code{true}
1115 @c MAYBE THIS CAN BE CLARIFIED
1116 Si @code{solvetrigwarn} vale @code{true}, @code{solve} puede presentar un mensaje diciendo que está utilizando funciones trigonométricas inversas para resolver la ecuación, y que por lo tanto puede estar ignorando algunas soluciones.
1117 @c NEED AN EXAMPLE HERE
1119 @end defvr