@c English version 2013-08-03
@menu
* Introducción a simplification::
* Paquete absimp::
* Paquete facexp::
* Paquete functs::
* Paquete ineq::
* Paquete rducon::
* Paquete scifac::
* Paquete sqdnst::
@end menu

@node Introducción a simplification, Paquete absimp, simplification, simplification
@section Introducción a simplification

El directorio @code{maxima/share/simplification} contiene programas que
implementan algunas reglas y funciones para simplificar expresiones, 
así como ciertas funciones no relacionadas con la simplificación.






@node Paquete absimp, Paquete facexp, Introducción a simplification, simplification
@section Paquete absimp

El paquete @code{absimp} contiene reglas para aplicar patrones que extienden
el sistema de reglas nativo de Maxima para las funciones @code{abs} y
@code{signum}, respetando las relaciones establecidas con la función
@code{assume} o con declaraciones tales como @code{modedeclare (m, even, n, odd)}
para enteros pares o impares.

En el paquete @code{absimp} se definen las funciones @code{unitramp} y
@code{unitstep} en términos de @code{abs} y @code{signum}.

La instrucción @code{load (absimp)} carga este paquete y @code{demo (absimp)}
desarrolla una demostración sobre el uso del mismo.

Ejemplos:

@c ===beg===
@c load (absimp)$
@c (abs (x))^2;
@c diff (abs (x), x);
@c cosh (abs (x));
@c ===end===
@example
(%i1) load (absimp)$
(%i2) (abs (x))^2;
                                       2
(%o2)                                 x
(%i3) diff (abs (x), x);
                                      x
(%o3)                               ------
                                    abs(x)
(%i4) cosh (abs (x));
(%o4)                               cosh(x)
@end example







@node Paquete facexp, Paquete functs, Paquete absimp, simplification
@section Paquete facexp

@c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
El paquete @code{facexp} contiene varias funciones que le aportan al
usuario la posibilidad de estructurar expresiones controlando su
expansión. Esta capacidad es especialmente útil cuando la 
expresión contiene variables con significado físico,
ya que se suele dar el caso de que la forma más sencilla para estas
expresiones se obtiene cuando se expanden respecto de estas variables
y luego se factoriza respecto de sus coeficientes. Si bien es cierto que
este procedimiento no es difícil de llevar a cabo con las 
funciones estándar de Maxima, pueden ser necesarios algunos retoques
adicionales que sí pueden ser más difíciles
de hacer.

La función @code{facsum} y sus formas relacionadas proporcionan un 
método para controlar la estructura de expresiones. La función 
@code{collectterms} puede usarse para añadir dos o más 
expresiones que ya hayan sido simplificadas de la forma indicada,
sin necesidad de volver a simplificar la expresión completa.
Esta función puede ser útil cuando las expresiones sean
largas.

@c CAN'T FIND ANY SUCH FILE "DIAGEVAL".
@c THERE ARE COMMENTED-OUT DEFNS OF FACTENEXPAND, FACEXPTEN, AND FACTORFACEXPTEN
@c IN FACEXP (AND NOWHERE ELSE).
@c COMMENTING OUT THIS TEXT FOR NOW.
@c Note:  @code{factenexpand}, @code{facexpten}, and @code{factorfacexpten}  are available  only
@c after loading @code{diageval}. They are special functions used for  tensor
@c manipulation.

La instrucción @code{load (facexp)} carga este paquete y @code{demo (facexp)}
hace una demostración sobre su uso.

@c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
@c SOME EXAMPLES WOULD HELP HERE


@deffn {Función} facsum (@var{expr}, @var{arg_1}, ..., @var{arg_n})

Devuelve una expresión equivalente a @var{expr}, la cual
depende de los argumentos @var{arg_1}, ..., @var{arg_n}, y 
éstos pueden ser de cualquiera de las formas aceptables
para @code{ratvars}, o listas de estas formas. Si los
argumentos no son listas, la forma devuelta se expande
completamente con respecto de los argumentos, siendo los
coeficientes de tales argumentos factorizados. Estos
coeficientes no contienen a ninguno de los argumentos,
excepto quizás de una forma no racional.

En caso de que cualquiera de los argumentos sea una lista, entonces
todos ellos se combinan en una única lista, y en lugar de llamar
a @code{factor} para los coeficientes de los argumentos, @code{facsum}
se llama a sí misma utilizando esta nueva lista única
como lista de argumentos.

Es posible que se quiera utilizar @code{facsum} con respecto a
expresiones más complicadas, tales como @code{log (x + y)}. Estos
argumentos son también admisibles.

En ocasiones puede ser necesario obtener cualquiera de las formas
anteriores especificadas por sus operadores principales. Por ejemplo,
se puede querer aplicar @code{facsum} con respecto a todos los 
@code{log}; en este caso, se puede incluir entre los argumentos bien
los @code{log} específicos que se quieran tratar de esta
manera, bien la expresión @code{operator (log)} o @code{'operator (log)}.
Si se quiere aplicar @code{facsum} a @var{expr} con respecto a los 
operadores @var{op_1}, ..., @var{op_n}, se debe evaluar 
@code{facsum (@var{expr}, operator (@var{op_1}, ..., @var{op_n}))}.
La forma @code{operator} puede aparecer también dentro de las
listas de argumentos.

Además, dándole valores a las variables opcionales @code{facsum_combine}
y @code{nextlayerfactor} se puede controlar el resultado de @code{facsum}.
@end deffn

@defvr {Variable global} nextlayerfactor
Valor por defecto: @code{false}

Si @code{nextlayerfactor} vale @code{true}, las llamadas recursivas de
@code{facsum} se aplican a los factores de la forma factorizada de los
coeficientes de los argumentos.

Si vale @code{false}, @code{facsum} se aplica a cada coeficiente como
un todo cada vez que se efectúen llamadas recursivas a @code{facsum}.

La inclusión del átomo @code{nextlayerfactor} en la lista de 
argumentos de @code{facsum} tiene el mismo efecto que 
@code{nextlayerfactor: true}, pero @i{solamente} para el siguiente
nivel de la expresión. Puesto que @code{nextlayerfactor} toma
siempre uno de los valores @code{true} o  @code{false}, debe aparecer
comentado (comilla simple) cada vez que aparezca en la lista de 
argumentos de @code{facsum}.
@end defvr

@defvr {Variable global} facsum_combine
Valor por defecto: @code{true}

La variable @code{facsum_combine} controla la forma del resultado final
devuelto por @code{facsum} si su argumento es un cociente de polinomios.
Si @code{facsum_combine} vale @code{false}, el resultado será una suma
completamente expandida, pero si vale @code{true}, la expresión devuelta
es un cociente de polinomios.

@c aqu'i falta un p'arrafo.

@end defvr

@deffn {Función} factorfacsum (@var{expr}, @var{arg_1}, ... @var{arg_n})
Devuelve una expresión equivalente a @var{expr} obtenida aplicando
@code{facsum} a los factores de @var{expr}, de argumentos
@var{arg_1}, ... @var{arg_n}. Si alguno de los factores de @var{expr} se 
eleva a una potencia, tanto el factor como el exponente se procesarán de
esta manera.
@end deffn

@deffn {Función} collectterms (@var{expr}, @var{arg_1}, @dots{}, @var{arg_n})
Si algunas expresiones fueron ya simplificadas con @code{facsum}, @code{factorfacsum},
@code{factenexpand},  @code{facexpten} o @code{factorfacexpten}, debiendo ser 
luego sumadas, puede ser conveniente combinarlas utilizando la función
@code{collecterms}, la cual admite como argumentos todos aquéllos que se
puedan pasar a las anteriormente citadas funciones, con la excepción de
@code{nextlayerfactor}, que no tiene efecto alguno sobre @code{collectterms}.
La ventaja de @code{collectterms} es que devuelve una forma similar a la de
@code{facsum}, pero debido a que suma expresiones que ya han sido previamente
procesadas, no necesita repetir esta operación, lo cual 
resulta ser especialmente útil cuando las expresiones a sumar son muy
grandes.
@end deffn









@node Paquete functs, Paquete ineq, Paquete facexp, simplification
@section Paquete functs

@deffn {Función} rempart (@var{expr}, @var{n})
Elimina la parte @var{n} de la expresión @var{expr}.

Si @var{n} es una lista de la forma @code{[@var{l}, @var{m}]}, entonces
las partes desde @var{l} a @var{m} serán eliminadas.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} wronskian ([@var{f_1}, ..., @var{f_n}], @var{x})
Devuelve la matriz wronskiana de las expresiones @var{f_1}, ..., @var{f_n}
dependeientes de la variable @var{x}.
El determinante de la matriz wronskiana es el determinante wronskiano de
la lista de expresiones.

Para hacer uso de esta función ejecutar @code{load(functs)}.

Ejemplo:

@c ===beg===
@c load (functs)$
@c wronskian([f(x), g(x)],x);
@c ===end===
@example
(%i1) load(functs)$
(%i2) wronskian([f(x), g(x)],x);
(%o2) matrix([f(x),g(x)],['diff(f(x),x,1),'diff(g(x),x,1)])
@end example
@end deffn

@c adjoint already described in doc/info/Matrices.texi

@deffn {Función} tracematrix (@var{M})
Devuelve la traza (suma de los elementos de la diagonal) de la matriz @var{M}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} rational (@var{z})
Multiplica el numerador y denominador de @var{z} por el complejo conjugado
del denominador, racionalizando así el denominador.
Devuelve la expresión canónica racional (canonical rational expression,
CRE) si el argumento @var{z} es de esta forma, en caso contrario devuelve una
expresión en formato común.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@c uprobe calls ?uprobe and assumes file is a list => obsolete, not common lisp

@c kronecker superseded by kron_delta in src/nset.lisp

@deffn {Función} nonzeroandfreeof (@var{x}, @var{expr})
Devuelve @code{true} si @var{expr} es diferente de cero y 
@code{freeof (@var{x}, @var{expr})} devuelve @code{true}.
En caso contrario devuelve @code{false}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} linear (@var{expr}, @var{x})
Si @var{expr} es una expresión de la forma @code{@var{a}*@var{x} + @var{b}},
siendo @var{a} no nulo y los argumentos @var{a} y @var{b} no contienen a @var{x},
@code{linear} devuelve una lista con tres ecuaciones, una por cada variable
@var{b}, @var{a} y @var{x}. Si no se cumple la condición anterior, 
@code{linear} devuelve @code{false}.

Para hacer uso de esta función ejecutar @code{load(functs)}.

Ejemplo:

@c ===beg===
@c load (antid);
@c linear ((1 - w)*(1 - x)*z, z);
@c linear (cos(u - v) + cos(u + v), u);
@c ===end===
@example
(%i1) load (antid);
(%o1)        /usr/share/maxima/5.29.1/share/integration/antid.mac
(%i2) linear ((1 - w)*(1 - x)*z, z);
(%o2)  [bargumentb = 0, aargumenta = (w - 1) x - w + 1, xargumentx = z]
(%i3) linear (cos(u - v) + cos(u + v), u);
(%o3)                                false
@end example
@end deffn

@deffn {Función} gcdivide (@var{p}, @var{q})
Si la variable opcional @code{takegcd} vale @code{true}, que es su valor por defecto, 
@code{gcdivide} divide los polinomios @var{p} y @var{q} por su
máximo común divisor y devuelve el cociente de los resultados.
@code{gcdivide} hace una llamada a la función @code{ezgcd} para
dividir los polinomios por su máximo común divisor.

Si @code{takegcd} vale @code{false}, @code{gcdivide} devuelve
el cociente @code{@var{p}/@var{q}}.

Para hacer uso de esta función ejecutar @code{load(functs)}.

Véanse también  @code{ezgcd}, @code{gcd}, @code{gcdex} y
@code{poly_gcd}.

Ejemplos:

@example
(%i1) load(functs)$

(%i2) p1:6*x^3+19*x^2+19*x+6; 
                        3       2
(%o2)                6 x  + 19 x  + 19 x + 6
(%i3) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                  5       4       3       2
(%o3)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
(%i4) gcdivide(p1, p2);
                             x + 1
(%o4)                        ------
                              3
                             x  + x
(%i5) takegcd:false;
(%o5)                         false
(%i6) gcdivide(p1, p2);
                       3       2
                    6 x  + 19 x  + 19 x + 6
(%o6)          ----------------------------------
                  5       4       3       2
               6 x  + 13 x  + 12 x  + 13 x  + 6 x
(%i7) ratsimp(%);
                             x + 1
(%o7)                        ------
                              3
                             x  + x
@end example
@end deffn


@deffn {Función} arithmetic (@var{a}, @var{d}, @var{n})
Devuelve el @var{n}-ésimo término de la progresión aritmética
@code{@var{a}, @var{a} + @var{d}, @var{a} + 2*@var{d}, ..., @var{a} + (@var{n} - 1)*@var{d}}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} geometric (@var{a}, @var{r}, @var{n})
Devuelve el @var{n}-ésimo término de la progresión geométrica
@code{@var{a}, @var{a}*@var{r}, @var{a}*@var{r}^2, ..., @var{a}*@var{r}^(@var{n} - 1)}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} harmonic (@var{a}, @var{b}, @var{c}, @var{n})
Devuelve el @var{n}-ésimo término de la progresión armónica
@code{@var{a}/@var{b}, @var{a}/(@var{b} + @var{c}), @var{a}/(@var{b} + 2*@var{c}), ..., @var{a}/(@var{b} + (@var{n} - 1)*@var{c})}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} arithsum (@var{a}, @var{d}, @var{n})
Devuelve la suma de la progresión aritmética desde hasta el @var{n}-ésimo término.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} geosum (@var{a}, @var{r}, @var{n})
Devuelve la suma de la sucesión geométrica hasta el @var{n}-ésimo término.
Si @var{n} es infinito (@code{inf}) la suma será finita sólo si el valor absoluto de 
@var{r} es menor que 1.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} gaussprob (@var{x})
Devuelve la función de densidad de probabilidad,
normal @code{%e^(-@var{x}^2/2) / sqrt(2*%pi)}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} gd (@var{x})
Devuelve la función de Gudermann,
@code{2*atan(%e^x)-%pi/2}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} agd (@var{x})
Devuelve la inversa de la función de Gudermann,
@code{log (tan (%pi/4 + x/2))}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} vers (@var{x})
Devuelve @code{1 - cos (x)}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} covers (@var{x})
Devuelve @code{1 - sin (@var{x})}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} exsec (@var{x})
Devuelve @code{sec (@var{x}) - 1}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@deffn {Función} hav (@var{x})
Devuelve @code{(1 - cos(x))/2}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@c REDUNDANT WITH BINOMIAL COEFFICIENT; CUT IT ??
@deffn {Función} combination (@var{n}, @var{r})
Calcula el número de combinaciones de @var{n} objetos
tomados de @var{r} en @var{r}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn

@c REDUNDANT WITH PERMUTATIONS FUNCTION IN NSET; CUT IT ??
@deffn {Función} permutation (@var{n}, @var{r})
Calcula el número de permutaciones de @var{r}, seleccionados
de un conjunto de @var{n}.

Para hacer uso de esta función ejecutar @code{load(functs)}.
@end deffn









@node Paquete ineq, Paquete rducon, Paquete functs, simplification
@section Paquete ineq

El paquete @code{ineq} contiene reglas de simplificación para desigualdades

Una sesión de ejemplo:

@c ===beg===
@c load(ineq)$
@c a>=4;  /* a sample inequality */
@c (b>c)+%; /* add a second, strict inequality */
@c 7*(x<y); /* multiply by a positive number */
@c -2*(x>=3*z); /* multiply by a negative number */
@c (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
@c assume(x>0)$ x*(2<3); /* assuming x>0 */
@c a>=b; /* another inequality */
@c 3+%; /* add something */
@c %-3; /* subtract it out */
@c a>=c-b; /* yet another inequality */
@c b+%; /* add b to both sides */
@c %-c; /* subtract c from both sides */
@c -%;  /* multiply by -1 */
@c (z-1)^2>-2*z; /* determining truth of assertion */
@c expand(%)+2*z; /* expand this and add 2*z to both sides */
@c %,pred;
@c ===end===
@example
(%i1) load(ineq)$
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
(%i2) a>=4;  /* a sample inequality */
(%o2)                               a >= 4
(%i3) (b>c)+%; /* add a second, strict inequality */
(%o3)                            b + a > c + 4
(%i4) 7*(x<y); /* multiply by a positive number */
(%o4)                              7 x < 7 y
(%i5) -2*(x>=3*z); /* multiply by a negative number */
(%o5)                           - 2 x <= - 6 z
(%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
                                        2
(%o6)                             1 <= a  + 1
(%i7) assume(x>0)$ x*(2<3); /* assuming x>0 */
(%o7)                              2 x < 3 x
(%i8) a>=b; /* another inequality */
(%o8)                               a >= b
(%i9) 3+%; /* add something */
(%o9)                           a + 3 >= b + 3
(%i10) %-3; /* subtract it out */
(%o10)                              a >= b
(%i11) a>=c-b; /* yet another inequality */
(%o11)                            a >= c - b
(%i12) b+%; /* add b to both sides */
(%o12)                            b + a >= c
(%i13) %-c; /* subtract c from both sides */
(%o13)                         - c + b + a >= 0
(%i14) -%;  /* multiply by -1 */
(%o14)                          c - b - a <= 0
(%i15) (z-1)^2>-2*z; /* determining truth of assertion */
                                      2
(%o15)                         (z - 1)  > - 2 z
(%i16) expand(%)+2*z; /* expand this and add 2*z to both sides */
                                   2
(%o16)                            z  + 1 > 0
(%i17) %,pred;
(%o17)                               true
@end example

Debe tenerse cuidado con el uso de paréntesis que incluyan desigualdades;
si se escribe @code{(A > B) + (C = 5)} el resultado es @code{A + C > B + 5},
pero @code{A > B + C = 5} es un error sintáctico y @code{(A > B + C) = 5}
es una cosa completamente diferente.

Ejecútese @code{disprule (all)} para ver la lista completa de las
reglas definidas.

Maxima preguntará al usuario cuando desconozca el signo de una cantidad que
multiplica a una desigualdad.

Los fallos más comunes son:

@example
eq: a > b;
2*eq;
% - eq;
@end example

Otro problema es el producto de una desigualdad por cero.
Si se escribe @code{x*@var{some_inequality}} y Maxima pregunta por
el signo de @code{x} y se responde que vale @code{zero} (o @code{z}),
el programa devuelve @code{x*@var{some_inequality}} sin hacer uso de la
información de que @code{x} es 0. En tal caso se debería
escribir @code{ev (%, x: 0)}, ya que la base de datos sólo será utilizada 
para fines comparativos y no para evaluar @code{x}.

El usuario puede apreciar que las respuestas son más lentas al cargarse este paquete,
ya que el simplificador deberá examinar más reglas que cuando no se hace uso del 
paquete, por lo que puede ser conveniente borrar estas reglas cuando ya no se haga
uso de ellas. Ejecútese @code{kill (rules)} para eliminar todas las reglas 
(incluidas las definidas por el usuario); también es posible eliminar
parte de ellas o utilizar @code{remrule} sobre una reglas específica.

Nótese que si se carga este paquete después de haber definido otras reglas
de igual nombre,se borrarán las antiguas. Las reglas de este paquete son:
@code{*rule1}, ..., @code{*rule8},
@code{+rule1}, ..., @code{+rule18},
debiéndose encerrar entre comillas el nombre de la reglas para referenciarse a ellas,
como en @code{remrule ("+", "+rule1")} para eliminar la primera regla sobre @code{"+"},
o @code{disprule ("*rule2")} para mostrar la definición de la segunda regla
multiplicativa.









@node Paquete rducon, Paquete scifac, Paquete ineq, simplification
@section Paquete rducon



@deffn {Función} reduce_consts (@var{expr})
Sustituye subexpresiones constantes de @var{expr} por átomos,
guardando la definición de todos ellos en la lista de ecuaciones
 @code{const_eqns} y devolviendo el expresión @var{expr} ya
modificada. Se consideran partes constantes de @var{expr} aquellas
que devuelven @code{true} cuando se les aplica la función @code{constantp},
por lo que antes de llamar a @code{reduce_consts} se debe ejecutar

@example
declare ([@var{objetos a los que se quiera dar la propiedad de ser constantes}], constant)$
@end example

para crear la base de datos de las cantidades constantes presentes en
la expresión.

Si se pretende generar código Fortran después de estos cálculos
simbólicos, una de las primeras secciones del código debe ser el
cálculo de las constantes. Para generar este segmento de código hacer

@example
map ('fortran, const_eqns)$
@end example

Junto a @code{const_eqns}, otras variables que afectan a @code{reduce_consts} son:

@code{const_prefix} (Valor por defecto: @code{xx}) es la cadena de caracteres utilizada como
prefijo para todos los símbolos generados por @code{reduce_consts} para
representar subexpresiones constantes.

@code{const_counter} (Valor por defecto: 1) es el índice entero utilizado
para generar los símbolos que representen a las subexpresiones
constantes encontradas por @code{reduce_consts}.

La instrucción @code{load (rducon)} carga esta función y @code{demo (rducon)}
hace una demostración sobre su uso.
@end deffn







@node Paquete scifac, Paquete sqdnst, Paquete rducon, simplification
@section Paquete scifac


@deffn {Función} gcfac (@var{expr})
Es una función de factorización que intenta aplicar la misma heurística
que los humanos cuando tratan de hacer las expresiones más simples, limitándose
a la factorización de monomios. En caso de sumas, @code{gcfac} hace lo siguiente:

@enumerate
@item
Factoriza los enteros.
@item
Factoriza las potencias mayores de los términos que aparecen como
coeficientes, independientemente de su complejidad.
@item
Utiliza (1) y (2) en la factorización de pares de términos adyacentes.
@item
Aplica estas técnicas repetida y recursivamente hasta que la
expresión deje de sufrir cambios.
@end enumerate

En general, el apartado (3) no hace una factorización óptima debido a la
naturaleza combinatoria y compleja de encontrar cuál de todas las ordenaciones
posibles de los pares da lugar a la expresión más compacta.

La instrucción @code{load (scifac)} carga esta función y @code{demo (scifac)}
hace una demostración sobre su uso.
@end deffn






@node Paquete sqdnst,  , Paquete scifac, simplification
@section Paquete sqdnst

@deffn {Función} sqrtdenest (@var{expr})
Reduce expresiones en las que se encuentren raíces cuadradas anidadas,
siempre que sea posible

Ejemplo:

@c ===beg===
@c load (sqdnst)$
@c sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
@c sqrtdenest(%);
@c ===end===
@example
(%i1) load (sqdnst)$
(%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
                                    sqrt(3)
                               sqrt(------- + 1)
                                       2
(%o2)                        ---------------------
                             sqrt(11 sqrt(2) - 12)
(%i3) sqrtdenest(%);
                                  sqrt(3)   1
                                  ------- + -
                                     2      2
(%o3)                            -------------
                                    1/4    3/4
                                 3 2    - 2
@end example

A veces conviene aplicar @code{sqrtdenest} más de una vez, como en el caso
@code{(19601-13860 sqrt(2))^(7/4)}.

La sentencia @code{load (sqdnst)} carga esta función.
@end deffn


