Simplificación (Manual de Maxima 5.50.0)

## 9 Simplificación ¶

### 9.1 Introducción a la simplificación ¶

Tras la evaluación de una expresión se procede a su simplificación. Las funciones matemáticas que involucran cálculos simbólicos y las expresiones con operadores aritméticos no son evaluadas, sino simplificadas, para lo cual Maxima las representa internamente en forma nominal; de ahí que el cálculo numérico de una suma o de una multiplicación no se considera una evaluación, sino una simplificación. La evaluación de una expresión puede inhibirse con el operador de comilla simple (`'`) y su simplificación se puede controlar con el valor asignado a la variable opcional `simp`.

En el siguiente ejemplo, se evita la simplificación con el operador de comilla simple, siendo el resultado una expresión nominal. A continuación, se inhibe la simplificación tras la evaluación de la derivada, dejando sin reducir el resultado a `2*x`.

    (%i1) 'diff(x*x,x);
                                 d    2
    (%o1)                        -- (x )
                                 dx
    (%i2) simp:false;
    (%o2)                         false
    (%i3) diff(x*x,x);
    (%o3)                       1 x + 1 x

Para cada función u operador matemático dispone Maxima de una rutina interna que será utilizada para su simplificación siempre que se la encuentre en una expresión. Estas rutinas implementan propiedades simétricas, valores especiales de las funciones y otras propiedades y reglas. La gran cantidad de variables opcionales permiten mantener bajo control la simplificación de funciones y operadores.

Veamos un ejemplo. La simplificación de la función exponencial `exp` se controla con las siguientes variables opcionales: `%enumer`, `%emode`, `%e_to_numlog`, `code`, `logsimp` y `demoivre`. En el primer caso la expresión con la función exponencial no se simplifica, pero en el segundo se reduce a `%i*%pi/2`.

    (%i1) exp(x+%i*%pi/2), %emode:false;
                                    %i %pi
                                x + ------
                                      2
    (%o1)                     %e
    (%i2) exp(x+%i*%pi/2), %emode:true;
                                      x
    (%o2)                        %i %e

Junto con la simplificación aislada de funciones y operadores que Maxima realiza de forma automática, existen también funciones como `expand` o `radcan` que realizan sobre las expresiones simplificaciones especiales. Sigue un ejemplo:

    (%i1) (log(x+x^2)-log(x))^a/log(1+x)^(a/2);
                               2               a
                         (log(x  + x) - log(x))
    (%o1)                -----------------------
                                        a/2
                              log(x + 1)
    (%i2) radcan(%);
                                        a/2
    (%o2)                     log(x + 1)

A un operador o función se le pueden asignar propiedades tales como la linealidad, la simetría u otras. Maxima tiene en cuenta estas propiedades durante la simplificación. Por ejemplo, la instrucción `declare(f, oddfun)` declara la función como impar, con lo que Maxima sabrá que las formas `f(-x)` y `-f(x)` son equivalentes, llevando a cabo la reducción oportuna.

Las siguientes propiedades están en la lista `opproperties` y controlan la simplificación de funciones y operadores:

       additive        lassociative     oddfun
       antisymmetric   linear           outative
       commutative     multiplicative   rassociative
       evenfun         nary             symmetric

Tanto las propiedades como los hechos (o hipótesis) establecidos por el usuario dentro de un contexto influyen sobre el proceso de simplificación. Para más detalles véase el capítulo sobre la base de datos de Maxima.

La función seno reduce los múltiplos enteros de `%pi` al valor cero. En este ejemplo se muestra cómo al dotar al símbolo `n` de la propiedad de ser entero, la función se simplifica de la forma apropiada.

    (%i1) sin(n*%pi);
    (%o1)                      sin(%pi n)
    (%i2) declare(n, integer);
    (%o2)                         done
    (%i3) sin(n*%pi);
    (%o3)                           0

Si las técnicas anteriores no devuelven el resultado esperado por el usuario, éste puede extender a voluntad las reglas que pueda aplicar Maxima; para más información al respecto, véase el capítulo dedicado a las reglas y patrones.

### 9.2 Funciones y variables para simplificación ¶

Propiedad: additive ¶

  Si `declare(f,additive)` ha sido ejecutado, entonces:

  (1) Si `f` es univariado, cada vez que el simplificador encuentre `f` aplicada a una suma, `f` será distribuida bajo esta suma. Por ejemplo, `f(x+y)` se simplificará a `f(x)+f(y)`.

  (2) Si `f` es una función de 2 o más argumentos, aditivamente es definida como aditiva en el primer argumento de `f`, como en el caso de `sum` o `integrate`. Por ejemplo, `f(h(x)+g(x),x)` se simplificará a `f(h(x),x)+f(g(x),x)`. Esta simplificación no ocurre cuando `f` se aplica a expresiones de la forma `sum(x[i],i,lower-limit,upper-limit)`.

  Ejemplo:

      (%i1) F3 (a + b + c);
      (%o1)                     F3(c + b + a)
      (%i2) declare (F3, additive);
      (%o2)                         done
      (%i3) F3 (a + b + c);
      (%o3)                 F3(c) + F3(b) + F3(a)

Propiedad: antisymmetric ¶

  Si `declare(h,antisymmetric)` es ejecutado, esto dice al simplificador que `h` es antisimétrico. E.g. `h(x,z,y)` será simplificado a `-h(x,y,z)`. Que es, el producto de (-1)^n por el resultado dado por `symmetric` o `commutative`, donde n es el número de intercambios necesarios de dos argumentos para convertirle a esta forma.

  Ejemplos:

      (%i1) S (b, a);
      (%o1)                        S(b, a)
      (%i2) declare (S, symmetric);
      (%o2)                         done
      (%i3) S (b, a);
      (%o3)                        S(a, b)
      (%i4) S (a, c, e, d, b);
      (%o4)                   S(a, b, c, d, e)
      (%i5) T (b, a);
      (%o5)                        T(b, a)
      (%i6) declare (T, antisymmetric);
      (%o6)                         done
      (%i7) T (b, a);
      (%o7)                       - T(a, b)
      (%i8) T (a, c, e, d, b);
      (%o8)                   T(a, b, c, d, e)

Función: combine (expr) ¶

  Simplifica la suma expr combinando términos de con igual denominador reduciéndolos a un único término.

Propiedad: commutative ¶

  Si `declare(h,commutative)` es ejecutado, le dice al simplificador que `h` es una función conmutaiva. Por ejemplo, `h(x,z,y)` se simplificará a `h(x,y,z)`. Esto es lo mismo que `symmetric`.

Función: demoivre (expr) ¶
Variable opcional: demoivre ¶

  La función `demoivre (expr)` convierte una expresión sin modificar la variable global `demoivre`.

  Cuando `demoivre` vale `true`, los exponenciales complejos se convierten en expresiones equivalentes pero en términos de las funciones trigonométricas: `exp (a + b*%i)` se reduce a `%e^a * (cos(b) + %i*sin(b))` si `b` no contiene a `%i`. Las expresiones `a` y `b` no se expanden.

  El valor por defecto de `demoivre` es `false`.

  La función `exponentialize` convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que `demoivre` y `exponentialize` no pueden valer `true` al mismo tiempo.

Función: distrib (expr) ¶

  Distribuye sumas sobre productos. Difiere de `expand` en que trabaja sólo al nivel superior de una expresión, siendo más rápida que `expand`. Difiere de `multthru` en que expande todas las sumas del nivel superior.

  Ejemplos:

      (%i1) distrib ((a+b) * (c+d));
      (%o1)                 b d + a d + b c + a c
      (%i2) multthru ((a+b) * (c+d));
      (%o2)                 (b + a) d + (b + a) c
      (%i3) distrib (1/((a+b) * (c+d)));
                                      1
      (%o3)                    ---------------
                               (b + a) (d + c)
      (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                      1
      (%o4)                 ---------------------
                            b d + a d + b c + a c

Variable opcional: distribute_over ¶

  Valor por defecto: `true`

  `distribute_over` controla la distribución de funciones sobre estructuras como listas, matrices y ecuaciones. Actualmente, no todas las funciones de Maxima tienen esta propiedad. Es posible consultar si una función tiene esta propiedad con la instrucción `properties`.

  La propiedad distributiva se desactiva asignándole a `distribute_over` el valor `false`.

  Ejemplos:

  La función `sin` se distribuye sobre una lista:

      (%i1) sin([x,1,1.0]);
      (%o1)                 [sin(x), sin(1), .8414709848078965]

  `mod` es una función de dos argumentos que se distribuye sobre listas. La distribución sobre listas anidadas también es posible.

      (%i2) mod([x,11,2*a],10);
      (%o2)                    [mod(x, 10), 1, 2 mod(a, 5)]
      (%i3) mod([[x,y,z],11,2*a],10);
      (%o3)       [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]

  Distribución de la función `floor` sobre una matriz y una ecuación.

      (%i4) floor(matrix([a,b],[c,d]));
                                  [ floor(a)  floor(b) ]
      (%o4)                       [                    ]
                                  [ floor(c)  floor(d) ]
      (%i5) floor(a=b);
      (%o5)                         floor(a) = floor(b)

  Funciones con más de un argumento se distribuyen sobre cualquiera de sus argumentos, o sobre todos ellos.

      (%i6) expintegral_e([1,2],[x,y]);
      (%o6) [[expintegral_e(1, x), expintegral_e(1, y)],
             [expintegral_e(2, x), expintegral_e(2, y)]]

  Comprueba si una función tiene la propiedad `distribute_over`:

      (%i7) properties(abs);
      (%o7) [integral, distributes over bags, noun, rule, gradef]

Variable opcional: domain ¶

  Valor por defecto: `real`

  Si `domain` vale `complex`, `sqrt (x^2)` permanecerá como `sqrt (x^2)` en lugar de devolver `abs(x)`.

Propiedad: evenfun ¶
Propiedad: oddfun ¶

  `declare(f, evenfun` o `declare(f, oddfun)` indican a Maxima que reconozca la función `f` como par o impar, respectivamente.

  Ejemplos:

      (%i1) o (- x) + o (x);
      (%o1)                     o(x) + o(- x)
      (%i2) declare (o, oddfun);
      (%o2)                         done
      (%i3) o (- x) + o (x);
      (%o3)                           0
      (%i4) e (- x) - e (x);
      (%o4)                     e(- x) - e(x)
      (%i5) declare (e, evenfun);
      (%o5)                         done
      (%i6) e (- x) - e (x);
      (%o6)                           0

Función: expand (expr) ¶
Función: expand (expr, p, n) ¶

  Expande la expresión expr. Los productos de sumas y de sumas con exponentes se multiplican, los numeradores de las expresiones racionales que son sumas se separan en sus respectivos términos, y las multiplicaciones (tanto las que son conmutativas como las que no) se distribuyen sobre las sumas en todos los niveles de expr.

  En el caso de los polinomios es más aconsejable utilizar `ratexpand`, que utiliza un algoritmo más eficiente.

  Las variables `maxnegex` y `maxposex` controlan los máximos exponentes negativos y positivos que se van a expandir.

  La llamada `expand (expr, p, n)` expande expr asignando a `maxposex` el valor p y a `maxnegex` el n. Esto es útil para expandir sólo parte de la expresión.

  La variable `expon` guarda el mayor exponente negativo que será expandido automáticamente, independientemente de `expand`. Por ejemplo, si `expon` vale 4 entonces `(x+1)^(-5)` no se expandirá automáticamente.

  La variable `expop` guarda el mayor exponente positivo que será expandido automáticamente. Así, `(x+1)^3` se expandirá automáticamente sólo si `expop` es mayor o igual que 3. Si se quiere expandir `(x+1)^n`, siendo `n` mayor que `expop`, entonces `expand ((x+1)^n)` se desarrollará sólo si `maxposex` no es menor que `n`.

  `expand(expr, 0, 0)` provoca que se vuelva a simplificar `expr`. `expr` no se vuelve a evaluar. A diferencia de `ev(expr, noeval)`, se elimina la representación canónica de la expresión. Véase también `ev`.

  La variable `expand` utilizada con `ev` provocará una expansión.

  El fichero `share/simplification/facexp.mac` contiene algunas funciones relacionadas con `expand` (en concreto, `facsum`, `factorfacsum` y `collectterms`, que se cargan automáticamente) y variables (`nextlayerfactor` y `facsum_combine`) que permiten al usuario estructurar las expresiones controlando la expansión. En `simplification/facexp.usg` se pueden encontrar breves descripciones de estas funciones. Se accederá a una demostración con la instrucción `demo("facexp")`.

  Ejemplo:

      (%i1) expr:(x+1)^2*(y+1)^3;
                                            2        3
      (%o1)                          (x + 1)  (y + 1)
      (%i2) expand(expr);
             2  3        3    3      2  2        2      2      2
      (%o2) x  y  + 2 x y  + y  + 3 x  y  + 6 x y  + 3 y  + 3 x  y
                                                       2
                                      + 6 x y + 3 y + x  + 2 x + 1

      (%i3) expand(expr,2);
                            2        3              3          3
      (%o3)                x  (y + 1)  + 2 x (y + 1)  + (y + 1)

      (%i4) expr:(x+1)^-2*(y+1)^3;
                                                3
                                         (y + 1)
      (%o4)                              --------
                                                2
                                         (x + 1)
      (%i5) expand(expr);
                       3               2
                      y             3 y            3 y             1
      (%o5)      ------------ + ------------ + ------------ + ------------
                  2              2              2              2
                 x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1

      (%i6) expand(expr,2,2);
                                                3
                                         (y + 1)
      (%o6)                            ------------
                                        2
                                       x  + 2 x + 1

  Vuelve a simplificar una expresión pero sin expansión:

      (%i7) expr:(1+x)^2*sin(x);
                                             2
      (%o7)                           (x + 1)  sin(x)
      (%i8) exponentialize:true;
      (%o8)                                true
      (%i9) expand(expr,0,0);
                                         2    %i x     - %i x
                               %i (x + 1)  (%e     - %e      )
      (%o9)                  - -------------------------------
                                              2

Función: expandwrt (expr, x_1, ..., x_n) ¶

  Expande la expresión `expr` con respecto a las variables x_1, ..., x_n. Todos los productos que contengan a las variables aparecen explícitamente. El resultado que se obtenga no tendr’a productos de sumas de expresiones que contengan a las variables. Los argumentos x_1, ..., x_n pueden ser variables, operadores o expresiones.

  Por defecto, no se expanden los denominadores, pero esto puede cambiarse mediante el uso de la variable `expandwrt_denom`.

  Esta función se carga automáticamente de `simplification/stopex.mac`.

Variable opcional: expandwrt_denom ¶

  Valor por defecto: `false`

  La variable `expandwrt_denom` controla el tratamiento de las expresiones racinales por parte de `expandwrt`. Si vale `true`, se expandirán tanto el numerador como el denominador de la expresión respecto de los argumentos de `expandwrt`, pero si `expandwrt_denom` vale `false`, sólo se expandirá el numerador.

Función: expandwrt_factored (expr, x_1, ..., x_n) ¶

  Es similar a `expandwrt`, pero trata a las expresiones que son productos de una forma algo diferente. La función `expandwrt_factored` expande sólo aquellos factores de `expr` que contienen a las variables x_1, ..., x_n.

  Esta función se carga automáticamente de `simplification/stopex.mac`.

Variable opcional: expon ¶

  Valor por defecto: 0

  La variable `expon` guarda el mayor exponente negativo que será expandido automáticamente, independientemente de `expand`. Por ejemplo, si `expon` vale 4 entonces `(x+1)^(-5)` no se expandirá automáticamente.

Función: exponentialize (expr) ¶
Variable opcional: exponentialize ¶

  La función `exponentialize (expr)` convierte las funciones trigonométricas e hiperbólicas de expr a exponenciales, sin alterar la variable global `exponentialize`.

  Cuando la variable `exponentialize` vale `true`, todas las funciones trigonométricas e hiperbólicas se convierten a forma exponencial. El valor por defecto es `false`.

  La función `demoivre` convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que `demoivre` y `exponentialize` no pueden valer `true` al mismo tiempo.

Variable opcional: expop ¶

  Valor por defecto: 0

  La variable `expop` guarda el mayor exponente positivo que será expandido automáticamente. Así, `(x+1)^3` se expandirá automáticamente sólo si `expop` es mayor o igual que 3. Si se quiere expandir `(x+1)^n`, siendo `n` mayor que `expop`, entonces `expand ((x+1)^n)` se desarrollará sólo si `maxposex` no es menor que `n`.

Propiedad: lassociative ¶

  La instrucción `declare (g, lassociative)` le indica al simplificador de Maxima que `g` es asociativo por la izquierda. Por ejemplo, `g (g (a, b), g (c, d))`se reduce a `g (g (g (a, b), c), d)`.

Propiedad: linear ¶

  Es una de las propiedades de operadores de Maxima. Si la función univariante `f` se declara lineal, la expansión de `f(x + y)` produce `f(x) + f(y)`, `f(a*x)` produce `a*f(x)` si `a` es una constante. Si la función tiene dos o más argumentos, la linealidad se interpreta como la de `sum` o `integrate`, esto es, `f (a*x + b, x)` produce `a*f(x,x) + b*f(1,x)` si `a` y `b` no contienen a `x`.

  `linear` equivale a `additive` y `outative`. Véase también `opproperties`.

  Ejemplo:

      (%i1) 'sum (F(k) + G(k), k, 1, inf);
                             inf
                             ====
                             \
      (%o1)                   >    (G(k) + F(k))
                             /
                             ====
                             k = 1
      (%i2) declare (nounify (sum), linear);
      (%o2)                         done
      (%i3) 'sum (F(k) + G(k), k, 1, inf);

                           inf          inf
                           ====         ====
                           \            \
      (%o3)                 >    G(k) +  >    F(k)
                           /            /
                           ====         ====
                           k = 1        k = 1

Variable opcional: maxnegex ¶

  Valor por defecto: 1000

  La variable `maxnegex` es el mayor exponente negativo que expandirá la función `expand`. Véase también `maxposex`.

Variable opcional: maxposex ¶

  Valor por defecto: 1000

  La variable `maxposex` es el mayor exponenteque expandirá la función `expand`. Véase también `maxnegex`.

Propiedad: multiplicative ¶

  La instrucción `declare (f, multiplicative)` indica al simplificador de Maxima que `f` is multiplicativa.

  1. Si `f` es univariante, cada vez que el simplificador encuentre a `f` aplicad a un producto, `f` se distribuirá sobre ese producto. Por ejemplo, `f(x*y)` se reduciría a `f(x)*f(y)`.
  2. Si `f` es una función de 2 o más argumentos, la multiplicabilidad se define como multiplicabilidad para el primer argumento de `f`, de modo que `f (g(x) * h(x), x)` se reduciría a `f (g(x) ,x) * f (h(x), x)`.

  Esta transformación no se realiza cuando `f` se aplica a expresiones de la forma `product (x[i], i, m, n)`.

  Ejemplo:

      (%i1) F2 (a * b * c);
      (%o1)                       F2(a b c)
      (%i2) declare (F2, multiplicative);
      (%o2)                         done
      (%i3) F2 (a * b * c);
      (%o3)                   F2(a) F2(b) F2(c)

Función: multthru (expr) ¶
Función: multthru (expr_1, expr_2) ¶

  Multiplica un factor (que debería ser una suma) de expr por los otros factores de expr. Esto es, expr es `f_1 f_2 ... f_n`, donde al menos un factor, por ejemplo f_i, es una suma de términos. Cada término en esta suma se multiplica por los otros factores del producto, excepto el propio f_i. La función `multthru` no expande sumas elevadas a exponentes, siendo el método más rápido para distribuir productos (sean o no conmutativos) sobre sumas. Puesto que los cocientes se representan como productos, puede utilizarse`multthru` para dividir sumas entre productos.

  La llamada `multthru (expr_1, expr_2)` multiplica cada término de expr_2 (que debería ser una suma o una ecuación) por expr_1. Si expr_1 no es ella misma una suma, entonces la llamada es equivalente a `multthru (expr_1*expr_2)`.

      (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                            1        x         f(x)
      (%o1)             - ----- + -------- - --------
                          x - y          2          3
                                  (x - y)    (x - y)
      (%i2) multthru ((x-y)^3, %);
                                 2
      (%o2)             - (x - y)  + x (x - y) - f(x)
      (%i3) ratexpand (%);
                                 2
      (%o3)                   - y  + x y - f(x)
      (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                              10  2              2  2
                       (b + a)   s  + 2 a b s + a  b
      (%o4)            ------------------------------
                                        2
                                   a b s
      (%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                              10
                             2   a b   (b + a)
      (%o5)                  - + --- + ---------
                             s    2       a b
                                 s
      (%i6) multthru (a.(b+c.(d+e)+f));
      (%o6)            a . f + a . c . (e + d) + a . b
      (%i7) expand (a.(b+c.(d+e)+f));
      (%o7)         a . f + a . c . e + a . c . d + a . b

Propiedad: nary ¶

  `declare(f, nary)` le indica a Maxima que reconozca la función `f` como n-aria.

  La declaración `nary` no equivale a invocar la función `function_nary, nary`. El único efecto de `declare(f, nary)` es indicar al simplificador de Maxima que aplane expresiones anidadas, como simplificar `foo(x, foo(y, z))` a `foo(x, y, z)`. Véase también `declare`.

  Ejemplo:

      (%i1) H (H (a, b), H (c, H (d, e)));
      (%o1)               H(H(a, b), H(c, H(d, e)))
      (%i2) declare (H, nary);
      (%o2)                         done
      (%i3) H (H (a, b), H (c, H (d, e)));
      (%o3)                   H(a, b, c, d, e)

Variable opcional: negdistrib ¶

  Valor por defecto: `true`

  Si `negdistrib` vale `true`, -1 se distribuye sobre una expresión. Por ejemplo, `-(x + y)` se transforma en `- y - x`. Dándole el valor `false` se mostrará `- (x + y)` tal cual. Esto puede ser útil, pero también peligroso; al igual que el indicador `simp`, no conviene asignarle el valor `false`.

Variable del sistema: opproperties ¶

  La variable `opproperties` es la lista con las propiedades especiales de los operadores reconocidas por el simplificador de Maxima: `linear`, `additive`, `multiplicative`, `outative`, `evenfun`, `oddfun`, `commutative`, `symmetric`, `antisymmetric`, `nary`, `lassociative`, `rassociative`.

Propiedad: outative ¶

  La instrucción `declare (f, outative)` le indica al simplificador de Maxima que los factores constantes del argumento de la función `f` pueden ser extraídos.

  1. Si `f` es univariante, cada vez que el simplificador se encuentra con `f` aplicada a un producto, éste será particionado en factores que son constantes y factores que no lo son, siendo entonces los constantes extraídos de la función. Por ejemplo, `f(a*x)` se reducirá a `a*f(x)` siendo `a` una constante. Las constantes no atómicas no serán extraídas.
  2. Si `f` es una función de 2 o más argumentos, esta propiedad se define como en `sum` o `integrate`, esto es, `f (a*g(x), x)` se reducirá a `a * f(g(x), x)` si `a` no contiene a `x`.

  Las funciones `sum`, `integrate` y `limit` han sido todas declaradas con la propiedad `outative`.

  Ejemplo:

      (%i1) F1 (100 * x);
      (%o1)                       F1(100 x)
      (%i2) declare (F1, outative);
      (%o2)                         done
      (%i3) F1 (100 * x);
      (%o3)                       100 F1(x)
      (%i4) declare (zz, constant);
      (%o4)                         done
      (%i5) F1 (zz * y);
      (%o5)                       zz F1(y)

Función: radcan (expr) ¶

  Simplifica la expresión expr, que puede contener logaritmos, exponenciales y radicales, convirtiéndola a una forma canónica, lo que significa que todas las expresiones funcionalmente equivalentes se reducen a una forma única. Ciertas expresiones, sin embargo, son reducidas por `radcan` a una forma regular, lo que significa que dos expresiones equivalentes no tienen necesariamente el mismo aspecto, pero su diferencia puede ser reducida por `radcan` a cero.

  Con algunas expresiones `radcan` puede consunir mucho tiempo. Este es el coste por explorar ciertas relaciones entre las componentes de la expresión para simplificaciones basadas en factorizaciones y expansiones parciales de fracciones de exponentes.

  Ejemplos:

      (%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
                                                 a/2
      (%o1)                            log(x + 1)

      (%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
      (%o2)                                  2

      (%i3) radcan((%e^x-1)/(1+%e^(x/2)));
                                           x/2
      (%o3)                              %e    - 1

Variable opcional: radexpand ¶

  Valor por defecto: `true`

  La variable `radexpand` controla algunas simplificaciones de radicales.

  Si `radexpand` vale `all`, las raíces n-ésimas de los factores de un producto que sean potencias de n se extraen del símbolo radical. Por ejemplo, si `radexpand` vale `all`, `sqrt (16*x^2)` se reduce a `4*x`.

  Más concretamente, considérese `sqrt (x^2)`.

  - Si `radexpand` vale `all` o se ha ejecutado `assume (x > 0)`, `sqrt(x^2)` se reduce a `x`.
  - Si `radexpand` vale `true` y `domain` es `real` (su valor por defecto), `sqrt(x^2)` se reduce a `abs(x)`.
  - Si `radexpand` vale `false` o `radexpand` vale `true` y `domain` es `complex`, `sqrt(x^2)` no se simplifica.

  Nótese que `domain` sólo se tiene en cuenta si `radexpand` vale `true`.

Propiedad: rassociative ¶

  La instrucción `declare (g, rassociative)` le indica al simplificador de Maxima que `g` es asociativa por la derecha. Por ejemplo, `g(g(a, b), g(c, d))` se reduce a `g(a, g(b, g(c, d)))`.

Función: scsimp (expr, rule_1, ..., rule_n) ¶

  Es el "Sequential Comparative Simplification" (método debido a Stoute). La función `scsimp` intenta simplificar expr de acuerdo con las reglas rule_1, ..., rule_n. Si se obtiene una expresión más pequeña, el proceso se repite. En caso contrario, después de que se hayan intentado todas las simplificaciones, devuelve la respuesta original.

  La instrucción `example (scsimp)` muestra algunos ejemplos.

Variable opcional: simp ¶

  Valor por defecto: `true`

  La variable `simp` activa y desactiva la simplificación. La simplificación está activada por defecto. La variable `simp` también es reconocida por la función `ev` como variable de entorno. Véase también `ev`.

  Cuando `simp` se utiliza en un entorno `ev` con el valor `false`, la simplificación se evita sólo durante la fase de evaluación de una expresión. La variable no evita la simplificación que sigue a la fase de evaluación.

  Ejemplos:

  La simplificación se suspende globalmente. La expresión `sin(1.0)` no se simplifica a su valor numérico. La variable de entorno `simp` conmuta el estado de la simplificación.

      (%i1) simp:false;
      (%o1)                                false
      (%i2) sin(1.0);
      (%o2)                              sin(1.0)
      (%i3) sin(1.0),simp;
      (%o3)                          .8414709848078965

  La simplificación se vuelve a activar. La variable de entorno `simp` no puede suprimir totalmente la simplificación. El resultado muestra una expresión simplificada, pero la variable `x` guarda como valor una expresión sin simplificar, porque la asignación se realizó durante la fase de evaluación de la expresión.

      (%i4) simp:true;
      (%o4)                                true
      (%i5) x:sin(1.0),simp:false;
      (%o5)                          .8414709848078965
      (%i6) :lisp $X
      ((%SIN) 1.0)

Propiedad: symmetric ¶

  La instrucción `declare (h, symmetric)` le indica al simplificador de Maxima que `h` es una función simétrica. Por ejemplo, `h (x, z, y)` se reduce a `h (x, y, z)`.

  El nombre `commutative` es sinónimo de `symmetric`.

Función: xthru (expr) ¶

  Combina todos los términos de expr (la cual debe ser una suma) sobre un común denominador sin expandir productos ni sumas elevadas a exponentes al modo que lo hace `ratsimp`. La función `xthru` cancela factores comunes en el numerador y denominador de expresiones racionales, pero sólo si los factores son explícitos.

  En ocasiones puede ser útil el uso de `xthru` antes de la llamada a `ratsimp` a fin de cancelar factores explícitos del máximo común divisor del numerador y denominador y así simplificar la expresión a la que se va a aplicar `ratsimp`.

      (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
       xthru (%);
                                      20
                       1       (x + 2)   - 2 y       x
      (%o1)        --------- + --------------- - ---------
                          19             20             20
                   (y + x)        (y + x)        (y + x)