doc/info/es/solve_rec.texi

   1 @c English version: 2010-11-01
   2 @menu
   3 * Introducción a solve_rec::
   4 * Funciones y variables para solve_rec::
   5 @end menu
   6
   7 @node Introducción a solve_rec, Funciones y variables para solve_rec, solve_rec, solve_rec
   8 @section Introducción a solve_rec
   9
  10 El paquete @code{solve_rec} resuelve expresiones recurrentes lineales con
  11 coeficientes polinomiales.
  12
  13 Ejecútese @code{demo(solve_rec);} para ver una demostración sobre
  14 la utilización de este paquete.
  15
  16 Ejemplo:
  17
  18 @example
  19 (%i1) load("solve_rec")$
  20 (%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]);
  21                                     n
  22                  %k  (2 n + 3) (- 1)          %k
  23                    1                            2
  24 (%o2)       s  = -------------------- + ---------------
  25              n     (n + 1) (n + 2)      (n + 1) (n + 2)
  26 @end example
  27
  28 @node Funciones y variables para solve_rec,  , Introducción a solve_rec, solve_rec
  29
  30 @section Funciones y variables para solve_rec
  31
  32
  33 @deffn {Función} reduce_order (@var{rec}, @var{sol}, @var{var})
  34
  35 Reduce el orden de la expresión recurrente lineal @var{rec} cuando
  36 se conoce una solución particular @var{sol}. La recurrencia
  37 reducida puede utilizarse para obterner más soluciones.
  38
  39 Ejemplo:
  40
  41 @example
  42 (%i3) rec: x[n+2] = x[n+1] + x[n]/n;
  43                                       x
  44                                        n
  45 (%o3)               x      = x      + --
  46                      n + 2    n + 1   n
  47 (%i4) solve_rec(rec, x[n]);
  48 WARNING: found some hypergeometrical solutions!
  49 (%o4)                    x  = %k  n
  50                           n     1
  51 (%i5) reduce_order(rec, n, x[n]);
  52 (%t5)                    x  = n %z
  53                           n       n
  54
  55                            n - 1
  56                            ====
  57                            \
  58 (%t6)                %z  =  >     %u
  59                        n   /        %j
  60                            ====
  61                            %j = 0
  62
  63 (%o6)             (- n - 2) %u     - %u
  64                               n + 1     n
  65 (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
  66                                      n
  67                             %k  (- 1)
  68                               1
  69 (%o6)                 %u  = ----------
  70                         n    (n + 1)!
  71
  72 So the general solution is
  73
  74              n - 1
  75              ====        j
  76              \      (- 1)
  77        %k  n  >    -------- + %k  n
  78          2   /     (j + 1)!     1
  79              ====
  80              j = 0
  81 @end example
  82
  83 @end deffn
  84
  85 @defvr {Variable opcional} simplify_products
  86 Valor por defecto: @code{true}
  87
  88 Si @code{simplify_products} vale @code{true}, @code{solve_rec} intentará
  89 simplificar los productos del resultado.
  90
  91 Véase también @code{solve_rec}.
  92
  93 @end defvr
  94
  95
  96
  97 @deffn {Función} simplify_sum (@var{expr})
  98
  99 Intenta reducir todas las sumas que aparecen en @var{expr} a una forma
 100 cerrada.
 101
 102 Para utilizar esta función cárguese previamente el paquete @code{simplify_sum}
 103 ejecutando la instrucción @code{load("simplify_sum")}.
 104
 105 Ejemplo:
 106
 107 @c ===beg===
 108 @c load("simplify_sum")$
 109 @c sum(binomial(n+k,k)/2^k, k, 1, n) + sum(binomial(2*n, 2*k), k, 1,n);
 110 @c simplify_sum(%);
 111 @c ===end===
 112 @example
 113 (%i1) load("simplify_sum")$
 114 @group
 115 (%i2) sum(binomial(n+k,k)/2^k,k,1,n)+sum(binomial(2*n,2*k),k,1,n);
 116         n                          n
 117        ====                       ====
 118        \     binomial(n + k, k)   \
 119 (%o2)   >    ------------------ +  >    binomial(2 n, 2 k)
 120        /              k           /
 121        ====          2            ====
 122        k = 1                      k = 1
 123 @end group
 124 @group
 125 (%i3) simplify_sum(%);
 126
 127                          2 n - 1    n
 128 (%o3)                   2        + 2  - 2
 129 @end group
 130 @end example
 131
 132
 133 @end deffn
 134
 135
 136 @deffn {Función} solve_rec (@var{eqn}, @var{var}, [@var{init}])
 137
 138 Obtiene las soluciones hipergeométricas de la expresión recurrente @var{eqn}
 139 con coeficientes lineales en la variable @var{var}. Los argumentos opcionales
 140 @var{init} son condiciones iniciales.
 141
 142 La función @code{solve_rec} puede resolver expresiones recurrentes con
 143 coeficientes constantes, encuentra soluciones hipergeométricas de
 144 expresiones recurrentes lineales homogéneas con coeficientes
 145 polinomiales, obtiene soluciones racionales de expresiones recurrentes
 146 lineales con coeficientes lineales y resuelve también expresiones
 147 recurrentes de Ricatti.
 148
 149 Nótese que el tiempo de ejecución del algoritmo para encontrar soluciones
 150 hipergeométricas es exponencial respecto del grado del coeficiente principal.
 151
 152 Para hacer uso de esta función ejecútese previamente @code{load("solve_rec");}.
 153
 154 Ejemplo de recurrencia lineal con coeficientes constantes:
 155
 156 @example
 157 (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
 158                         n          n
 159            (sqrt(5) - 1)  %k  (- 1)
 160                             1           n
 161 (%o2) a  = ------------------------- - ----
 162        n               n                  n
 163                       2                5 2
 164                                                 n
 165                                    (sqrt(5) + 1)  %k
 166                                                     2    2
 167                                  + ------------------ - ----
 168                                             n              n
 169                                            2            5 2
 170 @end example
 171
 172 Ejemplo de recurrencia lineal con coeficientes polinomiales:
 173
 174 @example
 175 (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
 176                          2
 177 (%o7) (x - 1) y      - (x  + 3 x - 2) y      + 2 x (x + 1) y
 178                x + 2                   x + 1                x
 179 (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
 180                               x
 181                            3 2    x!
 182 (%o9)                 y  = ---- - --
 183                        x    4     2
 184 @end example
 185
 186 Ejemplo de recurrencia de Ricatti:
 187
 188 @example
 189 (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
 190                             y         y
 191                              x + 1     x
 192 (%o2)         x y  y      - ------ + ----- = 0
 193                  x  x + 1   x + 2    x - 1
 194 (%i3) solve_rec(%, y[x], y[3]=5)$
 195 (%i4) ratsimp(minfactorial(factcomb(%)));
 196                                    3
 197                                30 x  - 30 x
 198 (%o4) y  = - -------------------------------------------------
 199        x        6      5       4       3       2
 200              5 x  - 3 x  - 25 x  + 15 x  + 20 x  - 12 x - 1584
 201 @end example
 202
 203
 204 Véanse también @code{solve_rec_rat}, @code{simplify_products} y @code{product_use_gamma}.
 205
 206 @end deffn
 207
 208 @deffn {Función} solve_rec_rat (@var{eqn}, @var{var}, [@var{init}])
 209
 210 Calcula las soluciones racionales de las expresiones recurrentes lineales.
 211 Véase @code{solve_rec} para la descripción de sus argumentos.
 212
 213 Para hacer uso de esta función ejecútese previamente @code{load("solve_rec");}.
 214
 215 Ejemplo:
 216
 217 @example
 218 (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
 219 (%o1)  (x + 4) a      + (x + 3) a      - x a
 220                 x + 3            x + 2      x + 1
 221                                                    2
 222                                                + (x  - 1) a
 223                                                             x
 224 (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
 225                        1
 226 (%o2)      a  = ---------------
 227             x   (x - 1) (x + 1)
 228 @end example
 229
 230 Véase también @code{solve_rec}.
 231
 232 @end deffn
 233
 234 @defvr {Variable opcional} product_use_gamma
 235 Valor por defecto:@code{true}
 236
 237 Si @code{product_use_gamma} vale @code{true},  @code{solve_rec}
 238 introduce la función gamma en la expresión del resultado
 239 cuando se simplifican productos.
 240
 241 Véanse también @code{simplify_products} y @code{solve_rec}.
 242
 243 @end defvr
 244
 245 @deffn {Función} summand_to_rec (@var{summand}, @var{k}, @var{n})
 246
 247 Devuelve la expresión recurrente que satisface la suma
 248
 249 @example
 250     inf
 251     ====
 252     \
 253      >     sumando
 254     /
 255     ====
 256   k = minf
 257 @end example
 258
 259 donde el sumando es hipergeométrico en  @var{k} y @var{n}.
 260
 261 Para hacer uso de esta función deben cargarse previamente los paquetes
 262 @code{zeilberger} y @code{solve_rec} mediante la ejecución de las sentencias
 263 @code{load("solve_rec")} y @code{load("zeilberger")}.
 264
 265 @example
 266 (%i17) load("zeilberger")$
 267 (%i18) summand: binom(3*k+1,k)*binom(3*(n-k),n-k)/(3*k+1)$
 268 (%i19) summand_to_rec(summand, k, n);
 269 Dependent equations eliminated:  (3 2)
 270 (%o19) - 4 (n + 2) (2 n + 3) (2 n + 5) sm
 271                                          n + 2
 272                     2
 273  + 12 (2 n + 3) (9 n  + 27 n + 22) sm
 274                                      n + 1
 275  - 81 (n + 1) (3 n + 2) (3 n + 4) sm
 276                                     n
 277 (%i21) sum(''summand, k, 0, n), n=0;
 278 (%o21)                       1
 279 (%i22) sum(''summand, k, 0, n), n=1;
 280 (%o22)                       4
 281 (%i23) product_use_gamma: false$
 282 (%i24) solve_rec(%o19, sm[n], sm[0]=1, sm[1]=4);
 283               n - 1               n - 1
 284               /===\               /===\
 285                ! !                 ! !                n
 286              ( ! !   (3 %j + 2)) ( ! !   (3 %j + 4)) 3
 287                ! !                 ! !
 288               %j = 0              %j = 0
 289 (%o24) sm  = ------------------------------------------
 290          n            n - 1
 291                       /===\
 292                        ! !                n
 293                      ( ! !   (2 %j + 3)) 2  n!
 294                        ! !
 295                       %j = 0
 296 @end example
 297
 298 @end deffn
 299