doc/info/es/simplifications.texi

   1 @c English version 2013-08-03
   2 @menu
   3 * Introducción a simplification::
   4 * Paquete absimp::
   5 * Paquete facexp::
   6 * Paquete functs::
   7 * Paquete ineq::
   8 * Paquete rducon::
   9 * Paquete scifac::
  10 * Paquete sqdnst::
  11 @end menu
  12
  13 @node Introducción a simplification, Paquete absimp, simplification, simplification
  14 @section Introducción a simplification
  15
  16 El directorio @code{maxima/share/simplification} contiene programas que
  17 implementan algunas reglas y funciones para simplificar expresiones,
  18 así como ciertas funciones no relacionadas con la simplificación.
  19
  20
  21
  22
  23
  24
  25 @node Paquete absimp, Paquete facexp, Introducción a simplification, simplification
  26 @section Paquete absimp
  27
  28 El paquete @code{absimp} contiene reglas para aplicar patrones que extienden
  29 el sistema de reglas nativo de Maxima para las funciones @code{abs} y
  30 @code{signum}, respetando las relaciones establecidas con la función
  31 @code{assume} o con declaraciones tales como @code{modedeclare (m, even, n, odd)}
  32 para enteros pares o impares.
  33
  34 En el paquete @code{absimp} se definen las funciones @code{unitramp} y
  35 @code{unitstep} en términos de @code{abs} y @code{signum}.
  36
  37 La instrucción @code{load ("absimp")} carga este paquete y @code{demo (absimp)}
  38 desarrolla una demostración sobre el uso del mismo.
  39
  40 Ejemplos:
  41
  42 @c ===beg===
  43 @c load ("absimp")$
  44 @c (abs (x))^2;
  45 @c diff (abs (x), x);
  46 @c cosh (abs (x));
  47 @c ===end===
  48 @example
  49 (%i1) load ("absimp")$
  50 (%i2) (abs (x))^2;
  51                                        2
  52 (%o2)                                 x
  53 (%i3) diff (abs (x), x);
  54                                       x
  55 (%o3)                               ------
  56                                     abs(x)
  57 (%i4) cosh (abs (x));
  58 (%o4)                               cosh(x)
  59 @end example
  60
  61
  62
  63
  64
  65
  66
  67 @node Paquete facexp, Paquete functs, Paquete absimp, simplification
  68 @section Paquete facexp
  69
  70 @c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
  71 El paquete @code{facexp} contiene varias funciones que le aportan al
  72 usuario la posibilidad de estructurar expresiones controlando su
  73 expansión. Esta capacidad es especialmente útil cuando la
  74 expresión contiene variables con significado físico,
  75 ya que se suele dar el caso de que la forma más sencilla para estas
  76 expresiones se obtiene cuando se expanden respecto de estas variables
  77 y luego se factoriza respecto de sus coeficientes. Si bien es cierto que
  78 este procedimiento no es difícil de llevar a cabo con las
  79 funciones estándar de Maxima, pueden ser necesarios algunos retoques
  80 adicionales que sí pueden ser más difíciles
  81 de hacer.
  82
  83 La función @code{facsum} y sus formas relacionadas proporcionan un
  84 método para controlar la estructura de expresiones. La función
  85 @code{collectterms} puede usarse para añadir dos o más
  86 expresiones que ya hayan sido simplificadas de la forma indicada,
  87 sin necesidad de volver a simplificar la expresión completa.
  88 Esta función puede ser útil cuando las expresiones sean
  89 largas.
  90
  91 @c CAN'T FIND ANY SUCH FILE "DIAGEVAL".
  92 @c THERE ARE COMMENTED-OUT DEFNS OF FACTENEXPAND, FACEXPTEN, AND FACTORFACEXPTEN
  93 @c IN FACEXP (AND NOWHERE ELSE).
  94 @c COMMENTING OUT THIS TEXT FOR NOW.
  95 @c Note:  @code{factenexpand}, @code{facexpten}, and @code{factorfacexpten}  are available  only
  96 @c after loading @code{diageval}. They are special functions used for  tensor
  97 @c manipulation.
  98
  99 La instrucción @code{load ("facexp")} carga este paquete y @code{demo (facexp)}
 100 hace una demostración sobre su uso.
 101
 102 @c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
 103 @c SOME EXAMPLES WOULD HELP HERE
 104
 105
 106 @deffn {Función} facsum (@var{expr}, @var{arg_1}, ..., @var{arg_n})
 107
 108 Devuelve una expresión equivalente a @var{expr}, la cual
 109 depende de los argumentos @var{arg_1}, ..., @var{arg_n}, y
 110 éstos pueden ser de cualquiera de las formas aceptables
 111 para @code{ratvars}, o listas de estas formas. Si los
 112 argumentos no son listas, la forma devuelta se expande
 113 completamente con respecto de los argumentos, siendo los
 114 coeficientes de tales argumentos factorizados. Estos
 115 coeficientes no contienen a ninguno de los argumentos,
 116 excepto quizás de una forma no racional.
 117
 118 En caso de que cualquiera de los argumentos sea una lista, entonces
 119 todos ellos se combinan en una única lista, y en lugar de llamar
 120 a @code{factor} para los coeficientes de los argumentos, @code{facsum}
 121 se llama a sí misma utilizando esta nueva lista única
 122 como lista de argumentos.
 123
 124 Es posible que se quiera utilizar @code{facsum} con respecto a
 125 expresiones más complicadas, tales como @code{log (x + y)}. Estos
 126 argumentos son también admisibles.
 127
 128 En ocasiones puede ser necesario obtener cualquiera de las formas
 129 anteriores especificadas por sus operadores principales. Por ejemplo,
 130 se puede querer aplicar @code{facsum} con respecto a todos los
 131 @code{log}; en este caso, se puede incluir entre los argumentos bien
 132 los @code{log} específicos que se quieran tratar de esta
 133 manera, bien la expresión @code{operator (log)} o @code{'operator (log)}.
 134 Si se quiere aplicar @code{facsum} a @var{expr} con respecto a los
 135 operadores @var{op_1}, ..., @var{op_n}, se debe evaluar
 136 @code{facsum (@var{expr}, operator (@var{op_1}, ..., @var{op_n}))}.
 137 La forma @code{operator} puede aparecer también dentro de las
 138 listas de argumentos.
 139
 140 Además, dándole valores a las variables opcionales @code{facsum_combine}
 141 y @code{nextlayerfactor} se puede controlar el resultado de @code{facsum}.
 142 @end deffn
 143
 144 @defvr {Variable global} nextlayerfactor
 145 Valor por defecto: @code{false}
 146
 147 Si @code{nextlayerfactor} vale @code{true}, las llamadas recursivas de
 148 @code{facsum} se aplican a los factores de la forma factorizada de los
 149 coeficientes de los argumentos.
 150
 151 Si vale @code{false}, @code{facsum} se aplica a cada coeficiente como
 152 un todo cada vez que se efectúen llamadas recursivas a @code{facsum}.
 153
 154 La inclusión del átomo @code{nextlayerfactor} en la lista de
 155 argumentos de @code{facsum} tiene el mismo efecto que
 156 @code{nextlayerfactor: true}, pero @i{solamente} para el siguiente
 157 nivel de la expresión. Puesto que @code{nextlayerfactor} toma
 158 siempre uno de los valores @code{true} o  @code{false}, debe aparecer
 159 comentado (comilla simple) cada vez que aparezca en la lista de
 160 argumentos de @code{facsum}.
 161 @end defvr
 162
 163 @defvr {Variable global} facsum_combine
 164 Valor por defecto: @code{true}
 165
 166 La variable @code{facsum_combine} controla la forma del resultado final
 167 devuelto por @code{facsum} si su argumento es un cociente de polinomios.
 168 Si @code{facsum_combine} vale @code{false}, el resultado será una suma
 169 completamente expandida, pero si vale @code{true}, la expresión devuelta
 170 es un cociente de polinomios.
 171
 172 @c aqu'i falta un p'arrafo.
 173
 174 @end defvr
 175
 176 @deffn {Función} factorfacsum (@var{expr}, @var{arg_1}, ... @var{arg_n})
 177 Devuelve una expresión equivalente a @var{expr} obtenida aplicando
 178 @code{facsum} a los factores de @var{expr}, de argumentos
 179 @var{arg_1}, ... @var{arg_n}. Si alguno de los factores de @var{expr} se
 180 eleva a una potencia, tanto el factor como el exponente se procesarán de
 181 esta manera.
 182 @end deffn
 183
 184 @deffn {Función} collectterms (@var{expr}, @var{arg_1}, @dots{}, @var{arg_n})
 185 Si algunas expresiones fueron ya simplificadas con @code{facsum}, @code{factorfacsum},
 186 @code{factenexpand},  @code{facexpten} o @code{factorfacexpten}, debiendo ser
 187 luego sumadas, puede ser conveniente combinarlas utilizando la función
 188 @code{collecterms}, la cual admite como argumentos todos aquéllos que se
 189 puedan pasar a las anteriormente citadas funciones, con la excepción de
 190 @code{nextlayerfactor}, que no tiene efecto alguno sobre @code{collectterms}.
 191 La ventaja de @code{collectterms} es que devuelve una forma similar a la de
 192 @code{facsum}, pero debido a que suma expresiones que ya han sido previamente
 193 procesadas, no necesita repetir esta operación, lo cual
 194 resulta ser especialmente útil cuando las expresiones a sumar son muy
 195 grandes.
 196 @end deffn
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206 @node Paquete functs, Paquete ineq, Paquete facexp, simplification
 207 @section Paquete functs
 208
 209 @deffn {Función} rempart (@var{expr}, @var{n})
 210 Elimina la parte @var{n} de la expresión @var{expr}.
 211
 212 Si @var{n} es una lista de la forma @code{[@var{l}, @var{m}]}, entonces
 213 las partes desde @var{l} a @var{m} serán eliminadas.
 214
 215 Para hacer uso de esta función ejecutar @code{load("functs")}.
 216 @end deffn
 217
 218 @deffn {Función} wronskian ([@var{f_1}, ..., @var{f_n}], @var{x})
 219 Devuelve la matriz wronskiana de las expresiones @var{f_1}, ..., @var{f_n}
 220 dependeientes de la variable @var{x}.
 221 El determinante de la matriz wronskiana es el determinante wronskiano de
 222 la lista de expresiones.
 223
 224 Para hacer uso de esta función ejecutar @code{load("functs")}.
 225
 226 Ejemplo:
 227
 228 @c ===beg===
 229 @c load ("functs")$
 230 @c wronskian([f(x), g(x)],x);
 231 @c ===end===
 232 @example
 233 (%i1) load("functs")$
 234 (%i2) wronskian([f(x), g(x)],x);
 235 (%o2) matrix([f(x),g(x)],['diff(f(x),x,1),'diff(g(x),x,1)])
 236 @end example
 237 @end deffn
 238
 239 @c adjoint already described in doc/info/Matrices.texi
 240
 241 @deffn {Función} tracematrix (@var{M})
 242 Devuelve la traza (suma de los elementos de la diagonal) de la matriz @var{M}.
 243
 244 Para hacer uso de esta función ejecutar @code{load("functs")}.
 245 @end deffn
 246
 247 @deffn {Función} rational (@var{z})
 248 Multiplica el numerador y denominador de @var{z} por el complejo conjugado
 249 del denominador, racionalizando así el denominador.
 250 Devuelve la expresión canónica racional (canonical rational expression,
 251 CRE) si el argumento @var{z} es de esta forma, en caso contrario devuelve una
 252 expresión en formato común.
 253
 254 Para hacer uso de esta función ejecutar @code{load("functs")}.
 255 @end deffn
 256
 257 @c uprobe calls ?uprobe and assumes file is a list => obsolete, not common lisp
 258
 259 @c kronecker superseded by kron_delta in src/nset.lisp
 260
 261 @deffn {Función} nonzeroandfreeof (@var{x}, @var{expr})
 262 Devuelve @code{true} si @var{expr} es diferente de cero y
 263 @code{freeof (@var{x}, @var{expr})} devuelve @code{true}.
 264 En caso contrario devuelve @code{false}.
 265
 266 Para hacer uso de esta función ejecutar @code{load("functs")}.
 267 @end deffn
 268
 269 @deffn {Función} linear (@var{expr}, @var{x})
 270 Si @var{expr} es una expresión de la forma @code{@var{a}*@var{x} + @var{b}},
 271 siendo @var{a} no nulo y los argumentos @var{a} y @var{b} no contienen a @var{x},
 272 @code{linear} devuelve una lista con tres ecuaciones, una por cada variable
 273 @var{b}, @var{a} y @var{x}. Si no se cumple la condición anterior,
 274 @code{linear} devuelve @code{false}.
 275
 276 Para hacer uso de esta función ejecutar @code{load("functs")}.
 277
 278 Ejemplo:
 279
 280 @c ===beg===
 281 @c load ("antid");
 282 @c linear ((1 - w)*(1 - x)*z, z);
 283 @c linear (cos(u - v) + cos(u + v), u);
 284 @c ===end===
 285 @example
 286 (%i1) load ("antid");
 287 (%o1)        /usr/share/maxima/5.29.1/share/integration/antid.mac
 288 (%i2) linear ((1 - w)*(1 - x)*z, z);
 289 (%o2)  [bargumentb = 0, aargumenta = (w - 1) x - w + 1, xargumentx = z]
 290 (%i3) linear (cos(u - v) + cos(u + v), u);
 291 (%o3)                                false
 292 @end example
 293 @end deffn
 294
 295 @deffn {Función} gcdivide (@var{p}, @var{q})
 296 Si la variable opcional @code{takegcd} vale @code{true}, que es su valor por defecto,
 297 @code{gcdivide} divide los polinomios @var{p} y @var{q} por su
 298 máximo común divisor y devuelve el cociente de los resultados.
 299 @code{gcdivide} hace una llamada a la función @code{ezgcd} para
 300 dividir los polinomios por su máximo común divisor.
 301
 302 Si @code{takegcd} vale @code{false}, @code{gcdivide} devuelve
 303 el cociente @code{@var{p}/@var{q}}.
 304
 305 Para hacer uso de esta función ejecutar @code{load("functs")}.
 306
 307 Véanse también  @code{ezgcd}, @code{gcd}, @code{gcdex} y
 308 @code{poly_gcd}.
 309
 310 Ejemplos:
 311
 312 @example
 313 (%i1) load("functs")$
 314
 315 (%i2) p1:6*x^3+19*x^2+19*x+6;
 316                         3       2
 317 (%o2)                6 x  + 19 x  + 19 x + 6
 318 (%i3) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
 319                   5       4       3       2
 320 (%o3)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
 321 (%i4) gcdivide(p1, p2);
 322                              x + 1
 323 (%o4)                        ------
 324                               3
 325                              x  + x
 326 (%i5) takegcd:false;
 327 (%o5)                         false
 328 (%i6) gcdivide(p1, p2);
 329                        3       2
 330                     6 x  + 19 x  + 19 x + 6
 331 (%o6)          ----------------------------------
 332                   5       4       3       2
 333                6 x  + 13 x  + 12 x  + 13 x  + 6 x
 334 (%i7) ratsimp(%);
 335                              x + 1
 336 (%o7)                        ------
 337                               3
 338                              x  + x
 339 @end example
 340 @end deffn
 341
 342
 343 @deffn {Función} arithmetic (@var{a}, @var{d}, @var{n})
 344 Devuelve el @var{n}-ésimo término de la progresión aritmética
 345 @code{@var{a}, @var{a} + @var{d}, @var{a} + 2*@var{d}, ..., @var{a} + (@var{n} - 1)*@var{d}}.
 346
 347 Para hacer uso de esta función ejecutar @code{load("functs")}.
 348 @end deffn
 349
 350 @deffn {Función} geometric (@var{a}, @var{r}, @var{n})
 351 Devuelve el @var{n}-ésimo término de la progresión geométrica
 352 @code{@var{a}, @var{a}*@var{r}, @var{a}*@var{r}^2, ..., @var{a}*@var{r}^(@var{n} - 1)}.
 353
 354 Para hacer uso de esta función ejecutar @code{load("functs")}.
 355 @end deffn
 356
 357 @deffn {Función} harmonic (@var{a}, @var{b}, @var{c}, @var{n})
 358 Devuelve el @var{n}-ésimo término de la progresión armónica
 359 @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})}.
 360
 361 Para hacer uso de esta función ejecutar @code{load("functs")}.
 362 @end deffn
 363
 364 @deffn {Función} arithsum (@var{a}, @var{d}, @var{n})
 365 Devuelve la suma de la progresión aritmética desde hasta el @var{n}-ésimo término.
 366
 367 Para hacer uso de esta función ejecutar @code{load("functs")}.
 368 @end deffn
 369
 370 @deffn {Función} geosum (@var{a}, @var{r}, @var{n})
 371 Devuelve la suma de la sucesión geométrica hasta el @var{n}-ésimo término.
 372 Si @var{n} es infinito (@code{inf}) la suma será finita sólo si el valor absoluto de
 373 @var{r} es menor que 1.
 374
 375 Para hacer uso de esta función ejecutar @code{load("functs")}.
 376 @end deffn
 377
 378 @deffn {Función} gaussprob (@var{x})
 379 Devuelve la función de densidad de probabilidad,
 380 normal @code{%e^(-@var{x}^2/2) / sqrt(2*%pi)}.
 381
 382 Para hacer uso de esta función ejecutar @code{load("functs")}.
 383 @end deffn
 384
 385 @deffn {Función} gd (@var{x})
 386 Devuelve la función de Gudermann,
 387 @code{2*atan(%e^x)-%pi/2}.
 388
 389 Para hacer uso de esta función ejecutar @code{load("functs")}.
 390 @end deffn
 391
 392 @deffn {Función} agd (@var{x})
 393 Devuelve la inversa de la función de Gudermann,
 394 @code{log (tan (%pi/4 + x/2))}.
 395
 396 Para hacer uso de esta función ejecutar @code{load("functs")}.
 397 @end deffn
 398
 399 @deffn {Función} vers (@var{x})
 400 Devuelve @code{1 - cos (x)}.
 401
 402 Para hacer uso de esta función ejecutar @code{load("functs")}.
 403 @end deffn
 404
 405 @deffn {Función} covers (@var{x})
 406 Devuelve @code{1 - sin (@var{x})}.
 407
 408 Para hacer uso de esta función ejecutar @code{load("functs")}.
 409 @end deffn
 410
 411 @deffn {Función} exsec (@var{x})
 412 Devuelve @code{sec (@var{x}) - 1}.
 413
 414 Para hacer uso de esta función ejecutar @code{load("functs")}.
 415 @end deffn
 416
 417 @deffn {Función} hav (@var{x})
 418 Devuelve @code{(1 - cos(x))/2}.
 419
 420 Para hacer uso de esta función ejecutar @code{load("functs")}.
 421 @end deffn
 422
 423 @c REDUNDANT WITH BINOMIAL COEFFICIENT; CUT IT ??
 424 @deffn {Función} combination (@var{n}, @var{r})
 425 Calcula el número de combinaciones de @var{n} objetos
 426 tomados de @var{r} en @var{r}.
 427
 428 Para hacer uso de esta función ejecutar @code{load("functs")}.
 429 @end deffn
 430
 431 @c REDUNDANT WITH PERMUTATIONS FUNCTION IN NSET; CUT IT ??
 432 @deffn {Función} permutation (@var{n}, @var{r})
 433 Calcula el número de permutaciones de @var{r}, seleccionados
 434 de un conjunto de @var{n}.
 435
 436 Para hacer uso de esta función ejecutar @code{load("functs")}.
 437 @end deffn
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447 @node Paquete ineq, Paquete rducon, Paquete functs, simplification
 448 @section Paquete ineq
 449
 450 El paquete @code{ineq} contiene reglas de simplificación para desigualdades
 451
 452 Una sesión de ejemplo:
 453
 454 @c ===beg===
 455 @c load("ineq")$
 456 @c a>=4;  /* a sample inequality */
 457 @c (b>c)+%; /* add a second, strict inequality */
 458 @c 7*(x<y); /* multiply by a positive number */
 459 @c -2*(x>=3*z); /* multiply by a negative number */
 460 @c (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
 461 @c assume(x>0)$ x*(2<3); /* assuming x>0 */
 462 @c a>=b; /* another inequality */
 463 @c 3+%; /* add something */
 464 @c %-3; /* subtract it out */
 465 @c a>=c-b; /* yet another inequality */
 466 @c b+%; /* add b to both sides */
 467 @c %-c; /* subtract c from both sides */
 468 @c -%;  /* multiply by -1 */
 469 @c (z-1)^2>-2*z; /* determining truth of assertion */
 470 @c expand(%)+2*z; /* expand this and add 2*z to both sides */
 471 @c %,pred;
 472 @c ===end===
 473 @example
 474 (%i1) load("ineq")$
 475 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 476 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 477 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 478 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 479 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 480 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 481 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 482 Warning: Putting rules on '+' or '*' is inefficient, and may not work.
 483 (%i2) a>=4;  /* a sample inequality */
 484 (%o2)                               a >= 4
 485 (%i3) (b>c)+%; /* add a second, strict inequality */
 486 (%o3)                            b + a > c + 4
 487 (%i4) 7*(x<y); /* multiply by a positive number */
 488 (%o4)                              7 x < 7 y
 489 (%i5) -2*(x>=3*z); /* multiply by a negative number */
 490 (%o5)                           - 2 x <= - 6 z
 491 (%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
 492                                         2
 493 (%o6)                             1 <= a  + 1
 494 (%i7) assume(x>0)$ x*(2<3); /* assuming x>0 */
 495 (%o7)                              2 x < 3 x
 496 (%i8) a>=b; /* another inequality */
 497 (%o8)                               a >= b
 498 (%i9) 3+%; /* add something */
 499 (%o9)                           a + 3 >= b + 3
 500 (%i10) %-3; /* subtract it out */
 501 (%o10)                              a >= b
 502 (%i11) a>=c-b; /* yet another inequality */
 503 (%o11)                            a >= c - b
 504 (%i12) b+%; /* add b to both sides */
 505 (%o12)                            b + a >= c
 506 (%i13) %-c; /* subtract c from both sides */
 507 (%o13)                         - c + b + a >= 0
 508 (%i14) -%;  /* multiply by -1 */
 509 (%o14)                          c - b - a <= 0
 510 (%i15) (z-1)^2>-2*z; /* determining truth of assertion */
 511                                       2
 512 (%o15)                         (z - 1)  > - 2 z
 513 (%i16) expand(%)+2*z; /* expand this and add 2*z to both sides */
 514                                    2
 515 (%o16)                            z  + 1 > 0
 516 (%i17) %,pred;
 517 (%o17)                               true
 518 @end example
 519
 520 Debe tenerse cuidado con el uso de paréntesis que incluyan desigualdades;
 521 si se escribe @code{(A > B) + (C = 5)} el resultado es @code{A + C > B + 5},
 522 pero @code{A > B + C = 5} es un error sintáctico y @code{(A > B + C) = 5}
 523 es una cosa completamente diferente.
 524
 525 Ejecútese @code{disprule (all)} para ver la lista completa de las
 526 reglas definidas.
 527
 528 Maxima preguntará al usuario cuando desconozca el signo de una cantidad que
 529 multiplica a una desigualdad.
 530
 531 Los fallos más comunes son:
 532
 533 @example
 534 eq: a > b;
 535 2*eq;
 536 % - eq;
 537 @end example
 538
 539 Otro problema es el producto de una desigualdad por cero.
 540 Si se escribe @code{x*@var{some_inequality}} y Maxima pregunta por
 541 el signo de @code{x} y se responde que vale @code{zero} (o @code{z}),
 542 el programa devuelve @code{x*@var{some_inequality}} sin hacer uso de la
 543 información de que @code{x} es 0. En tal caso se debería
 544 escribir @code{ev (%, x: 0)}, ya que la base de datos sólo será utilizada
 545 para fines comparativos y no para evaluar @code{x}.
 546
 547 El usuario puede apreciar que las respuestas son más lentas al cargarse este paquete,
 548 ya que el simplificador deberá examinar más reglas que cuando no se hace uso del
 549 paquete, por lo que puede ser conveniente borrar estas reglas cuando ya no se haga
 550 uso de ellas. Ejecútese @code{kill (rules)} para eliminar todas las reglas
 551 (incluidas las definidas por el usuario); también es posible eliminar
 552 parte de ellas o utilizar @code{remrule} sobre una reglas específica.
 553
 554 Nótese que si se carga este paquete después de haber definido otras reglas
 555 de igual nombre,se borrarán las antiguas. Las reglas de este paquete son:
 556 @code{*rule1}, ..., @code{*rule8},
 557 @code{+rule1}, ..., @code{+rule18},
 558 debiéndose encerrar entre comillas el nombre de la reglas para referenciarse a ellas,
 559 como en @code{remrule ("+", "+rule1")} para eliminar la primera regla sobre @code{"+"},
 560 o @code{disprule ("*rule2")} para mostrar la definición de la segunda regla
 561 multiplicativa.
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571 @node Paquete rducon, Paquete scifac, Paquete ineq, simplification
 572 @section Paquete rducon
 573
 574
 575
 576 @deffn {Función} reduce_consts (@var{expr})
 577 Sustituye subexpresiones constantes de @var{expr} por átomos,
 578 guardando la definición de todos ellos en la lista de ecuaciones
 579  @code{const_eqns} y devolviendo el expresión @var{expr} ya
 580 modificada. Se consideran partes constantes de @var{expr} aquellas
 581 que devuelven @code{true} cuando se les aplica la función @code{constantp},
 582 por lo que antes de llamar a @code{reduce_consts} se debe ejecutar
 583
 584 @example
 585 declare ([@var{objetos a los que se quiera dar la propiedad de ser constantes}], constant)$
 586 @end example
 587
 588 para crear la base de datos de las cantidades constantes presentes en
 589 la expresión.
 590
 591 Si se pretende generar código Fortran después de estos cálculos
 592 simbólicos, una de las primeras secciones del código debe ser el
 593 cálculo de las constantes. Para generar este segmento de código hacer
 594
 595 @example
 596 map ('fortran, const_eqns)$
 597 @end example
 598
 599 Junto a @code{const_eqns}, otras variables que afectan a @code{reduce_consts} son:
 600
 601 @code{const_prefix} (Valor por defecto: @code{xx}) es la cadena de caracteres utilizada como
 602 prefijo para todos los símbolos generados por @code{reduce_consts} para
 603 representar subexpresiones constantes.
 604
 605 @code{const_counter} (Valor por defecto: 1) es el índice entero utilizado
 606 para generar los símbolos que representen a las subexpresiones
 607 constantes encontradas por @code{reduce_consts}.
 608
 609 La instrucción @code{load ("rducon")} carga esta función y @code{demo (rducon)}
 610 hace una demostración sobre su uso.
 611 @end deffn
 612
 613
 614
 615
 616
 617
 618
 619 @node Paquete scifac, Paquete sqdnst, Paquete rducon, simplification
 620 @section Paquete scifac
 621
 622
 623 @deffn {Función} gcfac (@var{expr})
 624 Es una función de factorización que intenta aplicar la misma heurística
 625 que los humanos cuando tratan de hacer las expresiones más simples, limitándose
 626 a la factorización de monomios. En caso de sumas, @code{gcfac} hace lo siguiente:
 627
 628 @enumerate
 629 @item
 630 Factoriza los enteros.
 631 @item
 632 Factoriza las potencias mayores de los términos que aparecen como
 633 coeficientes, independientemente de su complejidad.
 634 @item
 635 Utiliza (1) y (2) en la factorización de pares de términos adyacentes.
 636 @item
 637 Aplica estas técnicas repetida y recursivamente hasta que la
 638 expresión deje de sufrir cambios.
 639 @end enumerate
 640
 641 En general, el apartado (3) no hace una factorización óptima debido a la
 642 naturaleza combinatoria y compleja de encontrar cuál de todas las ordenaciones
 643 posibles de los pares da lugar a la expresión más compacta.
 644
 645 La instrucción @code{load ("scifac")} carga esta función y @code{demo (scifac)}
 646 hace una demostración sobre su uso.
 647 @end deffn
 648
 649
 650
 651
 652
 653
 654 @node Paquete sqdnst,  , Paquete scifac, simplification
 655 @section Paquete sqdnst
 656
 657 @deffn {Función} sqrtdenest (@var{expr})
 658 Reduce expresiones en las que se encuentren raíces cuadradas anidadas,
 659 siempre que sea posible
 660
 661 Ejemplo:
 662
 663 @c ===beg===
 664 @c load ("sqdnst")$
 665 @c sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
 666 @c sqrtdenest(%);
 667 @c ===end===
 668 @example
 669 (%i1) load ("sqdnst")$
 670 (%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
 671                                     sqrt(3)
 672                                sqrt(------- + 1)
 673                                        2
 674 (%o2)                        ---------------------
 675                              sqrt(11 sqrt(2) - 12)
 676 (%i3) sqrtdenest(%);
 677                                   sqrt(3)   1
 678                                   ------- + -
 679                                      2      2
 680 (%o3)                            -------------
 681                                     1/4    3/4
 682                                  3 2    - 2
 683 @end example
 684
 685 A veces conviene aplicar @code{sqrtdenest} más de una vez, como en el caso
 686 @code{(19601-13860 sqrt(2))^(7/4)}.
 687
 688 La sentencia @code{load ("sqdnst")} carga esta función.
 689 @end deffn
 690
 691