[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20. Ecuaciones


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.1 Funciones y variable para las ecuaciones

Variable del sistema: %rnum_list

Valor por defecto: []

La variable %rnum_list es la lista de variables introducidas en las soluciones por la funciones solve y algsys. Las variables %r se añaden a %rnum_list en su orden de creación. Esto es útil para hacer sustituciones en la solución a posteriori.

(%i1) solve ([x + y = 3], [x,y]);
(%o1)              [[x = 3 - %r1, y = %r1]]
(%i2) %rnum_list;
(%o2)                       [%r1]
(%i3) sol : solve ([x + 2*y + 3*z = 4], [x,y,z]);
(%o3)   [[x = - 2 %r3 - 3 %r2 + 4, y = %r3, z = %r2]]
(%i4) %rnum_list;
(%o4)                     [%r2, %r3]
(%i5) for i : 1 thru length (%rnum_list) do
        sol : subst (t[i], %rnum_list[i], sol)$
(%i6) sol;
(%o6)     [[x = - 2 t  - 3 t  + 4, y = t , z = t ]]
                     2      1           2       1
Variable opcional: algepsilon

Valor por defecto: 10^8

La variable algepsilon es utilizada por algsys.

Variable opcional: algexact

Valor por defecto: false

El contenido de la variable algexact afecta al comportamiento de algsys de la siguiente forma:

Si algexact vale true, algsys llamará siempre a solve y luego utilizará realroots.

Si algexact vale false, solve será llamada sólo si la ecuación no es univariante, o si es cuadrática o bicuadrática.

Sin embargo, algexact: true no garantiza que únicamente se obtengan soluciones exactas, ya que aunque algsys intente siempre dar soluciones exactas, dará resultados aproximados si no encuentra una solución mejor.

Función: algsys ([expr_1, ..., expr_m], [x_1, ..., x_n])
Función: algsys ([eqn_1, ..., eqn_m], [x_1, ..., x_n])

Resuelve el sistema de ecuaciones polinómicas expr_1, ..., expr_m o las ecuaciones eqn_1, ..., eqn_m para las variables x_1, ..., x_n. La expresión expr equivale a la ecuación expr = 0. Puede haber más ecuaciones que variables o viceversa.

La función 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 x_1, ..., x_n que satisfacen el sistema de ecuaciones. Si algsys no puede encontrar soluciones devuelve la lista vacía [].

Si es necesario se introducen en la solución los símbolos %r1, %r2, ..., para representar parámetros arbitrarios; estas variables también se añaden a la lista %rnum_list.

El proceso que se sigue es el siguiente:

(1) Primero se factorizan las ecuaciones y se reparten en subsistemas.

(2) Para cada subsistema S_i, se seleccionan una ecuación E y una variable x. Se elige la variable que tenga grado menor. Entonces se calcula el resultado de E y E_j respecto de x, siendo las E_j el resto de ecuaciones del subsistema S_i. De aquí se obtiene otro subsistema S_i' con una incógnita menos, ya que x ha sido eliminada. El proceso ahora vuelve al paso (1).

(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 solve para tratar de encontrar una solución exacta.

En algunos casos, solve no puede encontrar la solución, o si lo consigue puede que el resultado tenga una expresión muy grande.

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 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 realonly vale true, entonces se llama a la función realroots para calcular las soluciones reales. Si realonly vale false, entonces se llama a allroots para obtener las soluciones reales y complejas.

Si algsys devuelve una solución que tiene menos dígitos significativos de los requeridos, el usuario puede cambiar a voluntad el valor de algepsilon para obtener mayor precisión.

Si algexact vale true, se llamará siempre a solve.

Cuando 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: "algsys cannot solve - system too complicated."

Las interacciones con radcan pueden dar lugar a expresiones grandes o complicadas. En tal caso, puede ser posible aislar partes del resultado con pickapart o reveal.

Ocasionalmente, radcan puede introducir la unidad imaginaria %i en una solución que de hecho es real.

Ejemplos:

(%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
(%o1)              2 (1 - a1) x - 2 a2 (x - 1)
(%i2) e2: a2 - a1; 
(%o2)                        a2 - a1
(%i3) e3: a1*(-y - x^2 + 1); 
                                   2
(%o3)                   a1 (- y - x  + 1)
(%i4) e4: a2*(y - (x - 1)^2);
                                       2
(%o4)                   a2 (y - (x - 1) )
(%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
(%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0], 

                                  [x = 1, y = 0, a1 = 1, a2 = 1]]
(%i6) e1: x^2 - y^2;
                              2    2
(%o6)                        x  - y
(%i7) e2: -1 - y + 2*y^2 - x + x^2;
                         2        2
(%o7)                 2 y  - y + x  - x - 1
(%i8) algsys ([e1, e2], [x, y]);
                 1            1
(%o8) [[x = - -------, y = -------], 
              sqrt(3)      sqrt(3)

        1              1             1        1
[x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
     sqrt(3)        sqrt(3)          3        3
Función: allroots (expr)
Función: allroots (eqn)

Calcula aproximaciones numéricas de las raíces reales y complejas del polinomio expr o ecuación polinómica eqn de una variable.

Si la variable polyfactor vale true hace que la función allroots factorice el polinomio para números reales si el polinomio es real, o para números complejos si el polinomio es complejo.

La función allroots puede dar resultados inexactos en caso de que haya raíces múltiples. Si el polinomio es real, allroots (%i*p)) puede alcanzar mejores aproximaciones que allroots (p), ya que allroots ejecuta entonces un algoritmo diferente.

La función 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.

Para polinomios complejos se utiliza el algoritmo de Jenkins y Traub descrito en (Algorithm 419, Comm. ACM, vol. 15, (1972), p. 97). Para polinomios reales se utiliza el algoritmo de Jenkins descrito en (Algorithm 493, ACM TOMS, vol. 1, (1975), p.178).

Ejemplos:

(%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                            3          5
(%o1)              (2 x + 1)  = 13.5 (x  + 1)
(%i2) soln: allroots (eqn);
(%o2) [x = .8296749902129361, x = - 1.015755543828121, 

x = .9659625152196369 %i - .4069597231924075, 

x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
(%i3) for e in soln
        do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
                      - 3.5527136788005E-15

                     - 5.32907051820075E-15

         4.44089209850063E-15 %i - 4.88498130835069E-15

        - 4.44089209850063E-15 %i - 4.88498130835069E-15

                       3.5527136788005E-15

(%o3)                         done
(%i4) polyfactor: true$
(%i5) allroots (eqn);
(%o5) - 13.5 (x - 1.0) (x - .8296749902129361)

                           2
 (x + 1.015755543828121) (x  + .8139194463848151 x

 + 1.098699797110288)
Función: bfallroots (expr)
Función: bfallroots (eqn)

Calcula aproximaciones numéricas de las raíces reales y complejas del polinomio expr o de la ecuación polinómica eqn de una variable.

En todos los aspectos, bfallroots es idéntica a allroots, excepto que bfallroots calcula las raíces en formato bigfloat (números decimales de precisión arbitraria).

Véase allroots para más información.

Variable opcional: backsubst

Valor por defecto: true

Si backsubst vale false, evita la retrosustitución en linsolve tras la triangularización de las ecuaciones. Esto puede ser de utilidad en problemas muy grandes, en los que la retrosustitución puede provocar la generación de expresiones extremadamente largas.

(%i1) eq1 : x + y + z = 6$
(%i2) eq2 : x - y + z = 2$
(%i3) eq3 : x + y - z = 0$
(%i4) backsubst : false$
(%i5) linsolve ([eq1, eq2, eq3], [x,y,z]);
(%o5)             [x = z - y, y = 2, z = 3]
(%i6) backsubst : true$
(%i7) linsolve ([eq1, eq2, eq3], [x,y,z]);
(%o7)               [x = 1, y = 2, z = 3]
Variable opcional: breakup

Valor por defecto: true

Si breakup vale true, 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 %t1, %t2, etc. En otro caso, no se identifican subexpresiones comunes.

La asignación breakup: true sólo tiene efecto cuando programmode vale false.

Ejemplos:

(%i1) programmode: false$
(%i2) breakup: true$
(%i3) solve (x^3 + x^2 - 1);

                        sqrt(23)    25 1/3
(%t3)                  (--------- + --)
                        6 sqrt(3)   54
Solution:

                                      sqrt(3) %i   1
                                      ---------- - -
                sqrt(3) %i   1            2        2   1
(%t4)    x = (- ---------- - -) %t3 + -------------- - -
                    2        2            9 %t3        3

                                      sqrt(3) %i   1
                                    - ---------- - -
              sqrt(3) %i   1              2        2   1
(%t5)    x = (---------- - -) %t3 + ---------------- - -
                  2        2             9 %t3         3

                                   1     1
(%t6)                  x = %t3 + ----- - -
                                 9 %t3   3
(%o6)                    [%t4, %t5, %t6]
(%i6) breakup: false$
(%i7) solve (x^3 + x^2 - 1);
Solution:

             sqrt(3) %i   1
             ---------- - -
                 2        2        sqrt(23)    25 1/3
(%t7) x = --------------------- + (--------- + --)
             sqrt(23)    25 1/3    6 sqrt(3)   54
          9 (--------- + --)
             6 sqrt(3)   54

                                              sqrt(3) %i   1    1
                                           (- ---------- - -) - -
                                                  2        2    3

           sqrt(23)    25 1/3  sqrt(3) %i   1
(%t8) x = (--------- + --)    (---------- - -)
           6 sqrt(3)   54          2        2

                                            sqrt(3) %i   1
                                          - ---------- - -
                                                2        2      1
                                      + --------------------- - -
                                           sqrt(23)    25 1/3   3
                                        9 (--------- + --)
                                           6 sqrt(3)   54

            sqrt(23)    25 1/3             1             1
(%t9)  x = (--------- + --)    + --------------------- - -
            6 sqrt(3)   54          sqrt(23)    25 1/3   3
                                 9 (--------- + --)
                                    6 sqrt(3)   54
(%o9)                    [%t7, %t8, %t9]
Función: dimension (eqn)
Función: dimension (eqn_1, ..., eqn_n)

El paquete dimen es para análisis dimensional. La instrucción load ("dimen") carga el paquete y demo ("dimen") presenta una pequeña demostración.

Variable opcional: dispflag

Valor por defecto: true

Si dispflag vale false, entonces se inhibirá que Maxima muestre resultados de las funciones que resuelven ecuaciones cuando éstas son llamadas desde dentro de un bloque (block). Cuando un bloque termina con el signo del dólar, $, a la variable dispflag se le asigna false.

Función: funcsolve (eqn, g(t))

Devuelve [g(t) = ...] o [], dependiendo de que exista o no una función racional g(t) que satisfaga eqn, la cual debe ser un polinomio de primer orden, lineal para g(t) y g(t+1)

(%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1)
                 = (n - 1)/(n + 2);
                            (n + 3) f(n + 1)   n - 1
(%o1)        (n + 1) f(n) - ---------------- = -----
                                 n + 1         n + 2
(%i2) funcsolve (eqn, f(n));

Dependent equations eliminated:  (4 3)
                                   n
(%o2)                f(n) = ---------------
                            (n + 1) (n + 2)

Aviso: esta es una implemetación rudimentaria, por lo que debe ser utilizada con cautela.

Variable opcional: globalsolve

Valor por defecto: false

Si globalsolve vale true, a las incógnitas de las ecuaciones se les asignan las soluciones encontradas por linsolve y por solve cuando se resuelven sistemas de dos o más ecuaciones lineales.

Si globalsolve vale false, las soluciones encontradas por linsolve y por 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.

Cuando se resuelven ecuaciones que no son sistemas de dos o más ecuaciones lineales, solve ignora el valor de globalsolve. Otras funciones que resuelven ecuaciones (como algsys) ignoran siempre el valor de globalsolve.

Ejemplos:

(%i1) globalsolve: true$
(%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
Solution

                                 17
(%t2)                        x : --
                                 7

                                   1
(%t3)                        y : - -
                                   7
(%o3)                     [[%t2, %t3]]
(%i3) x;
                               17
(%o3)                          --
                               7
(%i4) y;
                                 1
(%o4)                          - -
                                 7
(%i5) globalsolve: false$
(%i6) kill (x, y)$
(%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
Solution

                                 17
(%t7)                        x = --
                                 7

                                   1
(%t8)                        y = - -
                                   7
(%o8)                     [[%t7, %t8]]
(%i8) x;
(%o8)                           x
(%i9) y;
(%o9)                           y
Función: ieqn (ie, unk, tech, n, guess)

El paquete inteqn se dedica a la resolución de ecuaciones integrales. Para hacer uso de él, ejecutar la instrucción load ("inteqn").

El argumento ie es la ecuación integral; unk es la función incógnita; tech es el método a aplicar para efectuar la resolución del problema (tech = first significa: aplica el primer método que encuentre una solución; tech = all significa: aplica todos los métodos posibles); n es el número máximo de términos que debe tomar taylor, neumann, firstkindseries o fredseries (también es el máximo nivel de recursión para el método de diferenciación); guess es la solución candidata inicial para neumann o firstkindseries.

Valores por defecto para los argumentos segundo a quinto son:

unk: p(x), donde p es la primera función desconocida que Maxima encuentra en el integrando y x es la variable que actúa como argumento en la primera aparición de p encontrada fuera de una integral en el caso de ecuaciones de segunda especie (secondkind), o es la única variable aparte de la de integración en el caso de ecuaciones de primera especie (firstkind). Si el intento de encontrar x falla, el usuario será consultado para suministrar una variable independiente.

Variable opcional: ieqnprint

Valor por defecto: true

La variable ieqnprint controla el comportamiento del resultado retornado por la instrucción ieqn. Si ieqnprint vale false, la lista devuelta por la función ieqn tiene el formato

[solución, método utilizado, nterms, variable]

donde variable estará ausente si la solución es exacta; en otro caso, será la palabra approximate o 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, nterms es el número de términos utilizado, que puede ser menor que el n dado a ieqn.

Función: lhs (expr)

Devuelve el miembro izquierdo (es decir, el primer argumento) de la expresión expr, cuando el operador de expr es uno de los operadores de relación < <= = # equal notequal >= >, o un operadores de asignación := ::= : ::, o un operador infijo binario definido por el usuario mediante infix.

Si expr es un átomo o si su operador es diferente de los citados más arriba, lhs devuelve expr.

Véase también rhs.

Ejemplo:

(%i1) e: aa + bb = cc;
(%o1)                     bb + aa = cc
(%i2) lhs (e);
(%o2)                        bb + aa
(%i3) rhs (e);
(%o3)                          cc
(%i4) [lhs (aa < bb), lhs (aa <= bb), 
       lhs (aa >= bb), lhs (aa > bb)];
(%o4)                   [aa, aa, aa, aa]
(%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)),
       lhs (notequal (aa, bb))];
(%o5)                   [aa, aa, aa, aa]
(%i6) e1: '(foo(x) := 2*x);
(%o6)                     foo(x) := 2 x
(%i7) e2: '(bar(y) ::= 3*y);
(%o7)                    bar(y) ::= 3 y
(%i8) e3: '(x : y);
(%o8)                         x : y
(%i9) e4: '(x :: y);
(%o9)                        x :: y
(%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
(%o10)               [foo(x), bar(y), x, x]
(%i11) infix ("][");
(%o11)                         ][
(%i12) lhs (aa ][ bb);
(%o12)                         aa
Función: linsolve ([expr_1, ..., expr_m], [x_1, ..., x_n])

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.

Si globalsolve vale true, a cada incógnita se le asigna el valor de la solución encontrada.

Si backsubst vale false, linsolve no hace la sustitución tras la triangulariación de las ecuaciones. Esto puede ser necesario en problemas muy grandes en los que la sustitución puede dar lugar a la generación de expresiones enormes.

Si linsolve_params vale true, linsolve también genera símbolos %r para representar parámetros arbitrarios como los descritos para la función algsys. Si vale false, el resultado devuelto por linsolve expresará, si es el sistema es indeterminado, unas variables en función de otras.

Si programmode vale false, linsolve muestra la solución con etiquetas de expresiones intermedias (%t) y devuelve las lista de etiquetas.

(%i1) e1: x + z = y;
(%o1)                       z + x = y
(%i2) e2: 2*a*x - y = 2*a^2;
                                       2
(%o2)                   2 a x - y = 2 a
(%i3) e3: y - 2*z = 2;
(%o3)                      y - 2 z = 2
(%i4) [globalsolve: false, programmode: true];
(%o4)                     [false, true]
(%i5) linsolve ([e1, e2, e3], [x, y, z]);
(%o5)            [x = a + 1, y = 2 a, z = a - 1]
(%i6) [globalsolve: false, programmode: false];
(%o6)                    [false, false]
(%i7) linsolve ([e1, e2, e3], [x, y, z]);
Solution

(%t7)                       z = a - 1

(%t8)                        y = 2 a

(%t9)                       x = a + 1
(%o9)                    [%t7, %t8, %t9]
(%i9) ''%;
(%o9)            [z = a - 1, y = 2 a, x = a + 1]
(%i10) [globalsolve: true, programmode: false];
(%o10)                    [true, false]
(%i11) linsolve ([e1, e2, e3], [x, y, z]);
Solution

(%t11)                      z : a - 1

(%t12)                       y : 2 a

(%t13)                      x : a + 1
(%o13)                 [%t11, %t12, %t13]
(%i13) ''%;
(%o13)           [z : a - 1, y : 2 a, x : a + 1]
(%i14) [x, y, z];
(%o14)                 [a + 1, 2 a, a - 1]
(%i15) [globalsolve: true, programmode: true];
(%o15)                    [true, true]
(%i16) linsolve ([e1, e2, e3], '[x, y, z]);
(%o16)           [x : a + 1, y : 2 a, z : a - 1]
(%i17) [x, y, z];
(%o17)                 [a + 1, 2 a, a - 1]
Variable opcional: linsolvewarn

Valor por defecto: true

Si linsolvewarn vale true, linsolve mostrará el mensaje: "Dependent equations eliminated".

Variable opcional: linsolve_params

Valor por defecto: true

Si linsolve_params vale true, linsolve también genera símbolos %r para representar parámetros arbitrarios como los descritos para la función algsys. Si vale false, el resultado devuelto por linsolve expresará, si es el sistema es indeterminado, unas variables en función de otras.

System variable: multiplicities

Valor por defecto: not_set_yet

La variable multiplicities es una con las multiplicidades de las soluciones encontradas por solve o realroots.

Función: nroots (p, low, high)

Devuelve el número de raíces reales del polinomio real univariante p en el intervalo semiabierto (low, high]. Los extremos del intervalo pueden ser minf o inf, menos y más infinito.

La función nroots utiliza el método de las secuencias de Sturm.

(%i1) p: x^10 - 2*x^4 + 1/2$
(%i2) nroots (p, -6, 9.1);
(%o2)                           4
Función: nthroot (p, n)

Siendo p un polinomio de coeficientes enteros y n un entero positivo, nthroot devuelve un polinomio q, también de coeficientes enteros, tal que q^n=p, o un mensaje de error indicando que p no es una n-potencia exacta. Esta función es bastante más rápida que factor y que sqfr.

Variable opcional: polyfactor

Valor por defecto: false

Cuando polyfactor vale true, las funciones allroots y bfallroots factorizan el polinomio sobre los números reales si el polinomio es real, o factoriza sobre los complejos si el polinomio es complejo.

Véase un ejemplo en allroots.

Variable opcional: programmode

Valor por defecto: true

Si programmode vale true, solve, realroots, allroots y linsolve devuelve sus soluciones como elementos de una lista.

Si programmode vale false, solve y las demás crean expresiones intermedias etiquetadas %t1, t2, etc., y les asinan las soluciones.

(%i1) solve(x^2+x+1);
                    sqrt(3) %i + 1      sqrt(3) %i - 1
(%o1)        [x = - --------------, x = --------------]
                          2                   2
(%i2) programmode:false$
(%i3) solve(x^2+x+1);
Solution:

                              sqrt(3) %i + 1
(%t3)                   x = - --------------
                                    2

                             sqrt(3) %i - 1
(%t4)                    x = --------------
                                   2
(%o4)                        [%t4, %t5]
Variable opcional: realonly

Valor por defecto: false

Si realonly vale true, algsys sólo devuelve aquellas soluciones exentas de la constante %i.

Función: realroots (expr, bound)
Función: realroots (eqn, bound)
Función: realroots (expr)
Función: realroots (eqn)

Calcula aproximaciones racionales de las raíces reales del polinomio expr o de la ecuación polinómica eqn de una variable, dentro de la tolerancia especificada por bound. Los coeficientes de expr o de eqn deben ser números literales, por lo que las constantes simbólicas como %pi no son aceptadas.

La función realroots guarda las multiplicidades de las raíces encontradas en la variable global multiplicities.

La función realroots genera una secuencia de Sturm para acotar cada raíz, aplicando después el método de bisección para afinar las aproximaciones. Todos los coeficientes se convierten a formas racionales equivalentes antes de comenzar la búsqueda de las raíces, de modo que los cálculos se realizan con aritmética exacta racional. Incluso en el caso de que algunos coeficientes sean números decimales en coma flotante, los resultados son racionales, a menos que se les fuerce a ser decimales con las variables float o numer.

Si bound es menor que la unidad, todas las raíces enteras se expresan en forma exacta. Si no se especifica bound, se le supone igual al valor de la variable global rootsepsilon.

Si la variable global programmode vale true, la función realroots devuelve una lista de la forma [x = x_1, x = x_2, ...]. Si programmode vale false, realroots crea etiquetas %t1, %t2, ... para las expresiones intermedias, les asigna valores y, finalmente, devuelve la lista de etiquetas.

Ejemplos:

(%i1) realroots (-1 - x + x^5, 5e-6);
                               612003
(%o1)                     [x = ------]
                               524288
(%i2) ev (%[1], float);
(%o2)                 x = 1.167303085327148
(%i3) ev (-1 - x + x^5, %);
(%o3)                - 7.396496210176905E-6
(%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
(%o1)                 [x = 1, x = 2, x = 3]
(%i2) multiplicities;
(%o2)                       [5, 3, 1]
Función: rhs (expr)

Devuelve el miembro derecho (es decir, el segundo argumento) de la expresión expr, cuando el operador de expr es uno de los operadores de relación < <= = # equal notequal >= >, o un operadores de asignación := ::= : ::, o un operador infijo binario definido por el usuario mediante infix.

Si expr es un átomo o si su operador es diferente de los citados más arriba, rhs devuelve expr.

Véase también lhs.

Ejemplo:

(%i1) e: aa + bb = cc;
(%o1)                     bb + aa = cc
(%i2) lhs (e);
(%o2)                        bb + aa
(%i3) rhs (e);
(%o3)                          cc
(%i4) [rhs (aa < bb), rhs (aa <= bb),
       rhs (aa >= bb), rhs (aa > bb)];
(%o4)                   [bb, bb, bb, bb]
(%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)),
       rhs (notequal (aa, bb))];
(%o5)                   [bb, bb, bb, bb]
(%i6) e1: '(foo(x) := 2*x);
(%o6)                     foo(x) := 2 x
(%i7) e2: '(bar(y) ::= 3*y);
(%o7)                    bar(y) ::= 3 y
(%i8) e3: '(x : y);
(%o8)                         x : y
(%i9) e4: '(x :: y);
(%o9)                        x :: y
(%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
(%o10)                  [2 x, 3 y, y, y]
(%i11) infix ("][");
(%o11)                         ][
(%i12) rhs (aa ][ bb);
(%o12)                         bb
Variable opcional: rootsconmode

Valor por defecto: true

La variable rootsconmode controla el comportamiento de la instrucción rootscontract. Véase rootscontract para más detalles.

Función: rootscontract (expr)

Convierte productos de raíces en raíces de productos. Por ejemplo, rootscontract (sqrt(x)*y^(3/2)) devuelve sqrt(x*y^3).

Si radexpand vale true y domain vale real, rootscontract convierte abs en sqrt, por ejemplo, rootscontract (abs(x)*sqrt(y)) devuelve sqrt(x^2*y).

La opción rootsconmode afecta el resultado de rootscontract como sigue:

Problema            Valor de         Resultadod de
                  rootsconmode        rootscontract
      
x^(1/2)*y^(3/2)      false          (x*y^3)^(1/2)
x^(1/2)*y^(1/4)      false          x^(1/2)*y^(1/4)
x^(1/2)*y^(1/4)      true           (x*y^(1/2))^(1/2)
x^(1/2)*y^(1/3)      true           x^(1/2)*y^(1/3)
x^(1/2)*y^(1/4)      all            (x^2*y)^(1/4)
x^(1/2)*y^(1/3)      all            (x^3*y^2)^(1/6)

Si rootsconmode vale false, rootscontract contrae sólamente respecto de exponentes racionales cuyos denominadores sean iguales. La clave para los ejemplos rootsconmode: true es simplemente que 2 divide a 4 pero no a 3. La asignación rootsconmode: all hace que se calcule el mínimo común múltiplo de los denominadores de los exponentes.

La función rootscontract utiliza ratsimp de forma similar a como lo hace logcontract.

Ejemplos:

(%i1) rootsconmode: false$
(%i2) rootscontract (x^(1/2)*y^(3/2));
                                   3
(%o2)                      sqrt(x y )
(%i3) rootscontract (x^(1/2)*y^(1/4));
                                   1/4
(%o3)                     sqrt(x) y
(%i4) rootsconmode: true$
(%i5) rootscontract (x^(1/2)*y^(1/4));
(%o5)                    sqrt(x sqrt(y))
(%i6) rootscontract (x^(1/2)*y^(1/3));
                                   1/3
(%o6)                     sqrt(x) y
(%i7) rootsconmode: all$
(%i8) rootscontract (x^(1/2)*y^(1/4));
                              2   1/4
(%o8)                       (x  y)
(%i9) rootscontract (x^(1/2)*y^(1/3));
                             3  2 1/6
(%o9)                      (x  y )
(%i10) rootsconmode: false$
(%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                    *sqrt(sqrt(1 + x) - sqrt(x)));
(%o11)                          1
(%i12) rootsconmode: true$
(%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
(%o13)                          0
Variable opcional: rootsepsilon

Valor por defecto: 1.0e-7

La variable rootsepsilon es la tolerancia que establece el intervalo de confianza para las raíces calculadas por la función realroots.

Función: solve (expr, x)
Función: solve (expr)
Función: solve ([eqn_1, ..., eqn_n], [x_1, ..., x_n])

Resuelve la ecuación algebraica expr de incógnita x y devuelve una lista de igualdades con la x despejada. Si expr no es una igualdad, se supone que se quiere resolver la ecuación expr = 0. El argumento x puede ser una función (por ejemplo, f(x)), u otra expresión no atómica, excepto una suma o producto. Puede omitirse x si expr contiene solamente una variable. El argumento expr puede ser una expresión racional y puede contener funciones trigonométricas, exponenciales, etc.

Se utiliza el siguiente método de resolución:

Sea E la expresión y X la incógnita. Si E es lineal respecto de X entonces X se resuelve de forma trivial. En caso contrario, si E es de la forma A*X^N + B entonces el resultado es (-B/A)^1/N) multiplicado por las N-ésimas raíces de la unidad.

Si E no es lineal respecto de X entonces el máximo común divisor de los exponentes de X en E (supóngase que es N) se divide entre los exponentes y la multiplicidad de las raíces se multiplica por N. Entonces es llamado recursivamente solve para este resultado. Si E es factorizable entonces solve es invocado para cada uno de los factores. Finalmente, solve usará, según sea necesario, las fórmulas cuadrática, cúbica o cuártica.

En caso de que E sea un polinomio respecto de una función de la incógnita, por ejemplo F(X), entonces se calcula primero para F(X) (sea C el resultado obtenido), entonces la ecuación F(X)=C se resuelve para X en el supuesto que se conozca la inversa de la función F.

Si la variable breakup vale false hará que 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.

A la variable multiplicities se le asignará una lista con las multiplicidades de las soluciones individuales devueltas por solve, realroots o allroots. La instrucción apropos (solve) hará que se muestren las variables optativas que de algún modo afectan al comportamiento de solve. Se podrá luego utilizar la función describe para aquellas variables cuyo objeto no esté claro.

La llamada solve ([eqn_1, ..., eqn_n], [x_1, ..., x_n]) resuelve un sistema de ecuaciones polinómicas simultáneas (lineales o no) llamando a linsolve o algsys y devuelve una lista de listas con soluciones para las incógnitas. En caso de haberse llamado a linsolve esta lista contendrá una única lista de soluciones. La llamada a 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.

Si programmode vale false, solve muestra la solución con etiquetas de expresiones intermedias (%t) y devuelve las lista de etiquetas.

Si globalsolve vale 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.

Ejemplos:

(%i1) solve (asin (cos (3*x))*(f(x) - 1), x);

SOLVE is using arc-trig functions to get a solution.
Some solutions will be lost.
                            %pi
(%o1)                  [x = ---, f(x) = 1]
                             6
(%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
                                log(125)
(%o2)                   [f(x) = --------]
                                 log(5)
(%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
                      2    2
(%o3)             [4 x  - y  = 12, x y - x = 2]
(%i4) solve (%, [x, y]);
(%o4) [[x = 2, y = 2], [x = .5202594388652008 %i

 - .1331240357358706, y = .0767837852378778

 - 3.608003221870287 %i], [x = - .5202594388652008 %i

 - .1331240357358706, y = 3.608003221870287 %i

 + .0767837852378778], [x = - 1.733751846381093, 

y = - .1535675710019696]]
(%i5) solve (1 + a*x + x^3, x);
                                       3
              sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
(%o5) [x = (- ---------- - -) (--------------- - -)
                  2        2      6 sqrt(3)      2

        sqrt(3) %i   1
       (---------- - -) a
            2        2
 - --------------------------, x = 
              3
      sqrt(4 a  + 27)   1 1/3
   3 (--------------- - -)
         6 sqrt(3)      2

                          3
 sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
(---------- - -) (--------------- - -)
     2        2      6 sqrt(3)      2

         sqrt(3) %i   1
      (- ---------- - -) a
             2        2
 - --------------------------, x = 
              3
      sqrt(4 a  + 27)   1 1/3
   3 (--------------- - -)
         6 sqrt(3)      2

         3
 sqrt(4 a  + 27)   1 1/3               a
(--------------- - -)    - --------------------------]
    6 sqrt(3)      2                  3
                              sqrt(4 a  + 27)   1 1/3
                           3 (--------------- - -)
                                 6 sqrt(3)      2
(%i6) solve (x^3 - 1);
             sqrt(3) %i - 1        sqrt(3) %i + 1
(%o6)   [x = --------------, x = - --------------, x = 1]
                   2                     2
(%i7) solve (x^6 - 1);
           sqrt(3) %i + 1      sqrt(3) %i - 1
(%o7) [x = --------------, x = --------------, x = - 1, 
                 2                   2

                     sqrt(3) %i + 1        sqrt(3) %i - 1
               x = - --------------, x = - --------------, x = 1]
                           2                     2
(%i8) ev (x^6 - 1, %[1]);
                                      6
                      (sqrt(3) %i + 1)
(%o8)                 ----------------- - 1
                             64
(%i9) expand (%);
(%o9)                           0
(%i10) x^2 - 1;
                              2
(%o10)                       x  - 1
(%i11) solve (%, x);
(%o11)                  [x = - 1, x = 1]
(%i12) ev (%th(2), %[1]);
(%o12)                          0

Los í %r se utilizan para indicar parámetros en las soluciones.

(%i1) solve([x+y=1,2*x+2*y=2],[x,y]);

solve: dependent equations eliminated: (2)
(%o1)                      [[x = 1 - %r1, y = %r1]]

Véanse algsys y %rnum_list para más información.

Variable opcional: solvedecomposes

Valor por defecto: true

Si solvedecomposes vale true, solve llama a polydecomp en caso de que se le pida resolver ecuaciones polinómicas.

Variable opcional: solveexplicit

Valor por defecto: false

Si solveexplicit vale true, le inhibe a solve devolver soluciones implícitas, esto es, soluciones de la forma F(x) = 0, donde F es cierta función.

Variable opcional: solvefactors

Valor por defecto: true

Si solvefactors vale false, solve no intenta factorizar la expresión. Este valor false puede ser útil en algunos casos en los que la factorización no es necesaria.

Variable opcional: solvenullwarn

Valor por defecto: true

Si solvenullwarn vale true, 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, solve ([], []) imprimirá dos mensajes de aviso y devolverá [].

Variable opcional: solveradcan

Valor por defecto: false

Si solveradcan vale true, solve llama a radcan, lo que hará que solve se ejecute de forma más lenta, pero permitirá que se resuelvan ciertas ecuaciones que contengan exponenciales y logaritmos.

Variable opcional: solvetrigwarn

Valor por defecto: true

Si solvetrigwarn vale true, 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.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on agosto, 12 2012 using texi2html 1.76.