doc/info/pt/solve_rec.texi

   1 /solve_rec.texi/1.7/Tue Jan 16 15:15:10 2007//
   2 @c /solve_rec.texi/1.7/Tue Jan 16 15:15:10 2007//
   3 @menu
   4 * Introdução a solve_rec::
   5 * Definições para solve_rec::
   6 @end menu
   7
   8 @node Introdução a solve_rec, Definições para solve_rec, solve_rec, solve_rec
   9 @section Introdução a solve_rec
  10
  11 @code{solve_rec} é um pacote para resolver recorrências lineares com coeficientes
  12 polinomiais.
  13
  14 Um ficheiro de domostração está disponivel com @code{demo(solve_rec);}.
  15
  16 Exemplo:
  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 Definições para solve_rec,  , Introdução a solve_rec, solve_rec
  29 @section Definições para solve_rec
  30
  31 @deffn {Função} reduce_order (@var{rec}, @var{sol}, @var{var})
  32
  33 Reduz a ordem de recorrência linear @var{rec} quando uma solução particular
  34 @var{sol} for conhecida. A recorrência reduzida pode ser usada para pegar outras soluções.
  35
  36 Exemplo:
  37
  38 @example
  39 (%i3) rec: x[n+2] = x[n+1] + x[n]/n;
  40                                       x
  41                                        n
  42 (%o3)               x      = x      + --
  43                      n + 2    n + 1   n
  44 (%i4) solve_rec(rec, x[n]);
  45 WARNING: found some hypergeometrical solutions!
  46 (%o4)                    x  = %k  n
  47                           n     1
  48 (%i5) reduce_order(rec, n, x[n]);
  49 (%t5)                    x  = n %z
  50                           n       n
  51
  52                            n - 1
  53                            ====
  54                            \
  55 (%t6)                %z  =  >     %u
  56                        n   /        %j
  57                            ====
  58                            %j = 0
  59
  60 (%o6)             (- n - 2) %u     - %u
  61                               n + 1     n
  62 (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
  63                                      n
  64                             %k  (- 1)
  65                               1
  66 (%o6)                 %u  = ----------
  67                         n    (n + 1)!
  68
  69 So the general solution is
  70
  71              n - 1
  72              ====        n
  73              \      (- 1)
  74        %k  n  >    -------- + %k  n
  75          2   /     (n + 1)!     1
  76              ====
  77              n = 0
  78 @end example
  79
  80 @end deffn
  81
  82 @defvr {Variável de opção} simplify_products
  83 Valor por omissão: @code{true}
  84
  85 Se @code{simplify_products} for @code{true}, @code{solve_rec} irá tentar
  86 simplificar produtos no resultado.
  87
  88 Veja também: @code{solve_rec}.
  89
  90 @end defvr
  91
  92 @deffn {Função} simplify_sum (@var{expr})
  93
  94 Tenta simplificar todos os somatórios que aparecem na @var{expr} para uma forma a mais simplificada possível.
  95
  96 @code{simplify_sum} usa os algoritmos de Gosper e de Zeilberger para simplificar somatórios.
  97
  98 Para usar essa função primeiramente chame o pacote @code{simplify_sum} com
  99 @code{load(simplify_sum)}.
 100
 101 Exemplo:
 102
 103 @example
 104 (%i1) load("simplify_sum")$
 105 (%i2) sum(binom(n+k,k)/2^k, k, 0, n) + sum(binom(2*n, 2*k), k, 0, n);
 106          n                            n
 107         ====                         ====
 108         \      binomial(n + k, k)    \
 109 (%o2)    >     ------------------ +   >    binomial(2 n, 2 k)
 110         /               k            /
 111         ====           2             ====
 112         k = 0                        k = 0
 113 (%i3) simplify_sum(%);
 114                                n
 115                               4     n
 116 (%o3)                         -- + 2
 117                               2
 118 @end example
 119
 120 @end deffn
 121
 122 @deffn {Função} solve_rec (@var{eqn}, @var{var}, [@var{init}])
 123 Encontra soluções hipergeométricas para a recorrência linear @var{eqn} com
 124 coeficientes polinomiais na variável @var{var}. Argumentos opcionais @var{init}
 125 são as condições iniciais.
 126
 127 @code{solve_rec} pode resolver recorrências lineares com coeficientes constantes,
 128 encontrando soluções hipergeométricas para recorrências lineares homogêneas com
 129 coeficientes polinomiais, soluções racionais para recorrências lineares com
 130 coeficientes polinomiais e pode resolver recorrências do tipo de Ricatti.
 131
 132 Note que o tempo de execução do algoritmo usado para encontrar soluções
 133 hipergeométricas aumenta exponencialmente com o grau do coeficiente lider e
 134 guia.
 135
 136 Para usar essa função primeiramente chame o pacote @code{solve_rec} com
 137 @code{load(solve_rec);}.
 138
 139 Exemplo de recorrência linear com coeficientes constantes:
 140
 141 @example
 142 (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
 143                         n          n
 144            (sqrt(5) - 1)  %k  (- 1)
 145                             1           n
 146 (%o2) a  = ------------------------- - ----
 147        n               n                  n
 148                       2                5 2
 149                                                 n
 150                                    (sqrt(5) + 1)  %k
 151                                                     2    2
 152                                  + ------------------ - ----
 153                                             n              n
 154                                            2            5 2
 155 @end example
 156
 157 Exemplo de recorrência linear com coeficientes polinomiais:
 158
 159 @example
 160 (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
 161                          2
 162 (%o7) (x - 1) y      - (x  + 3 x - 2) y      + 2 x (x + 1) y
 163                x + 2                   x + 1                x
 164 (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
 165                               x
 166                            3 2    x!
 167 (%o9)                 y  = ---- - --
 168                        x    4     2
 169 @end example
 170
 171 Exemplo de recorrência do tipo de Ricatti:
 172
 173 @example
 174 (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
 175                             y         y
 176                              x + 1     x
 177 (%o2)         x y  y      - ------ + ----- = 0
 178                  x  x + 1   x + 2    x - 1
 179 (%i3) solve_rec(%, y[x], y[3]=5)$
 180 (%i4) ratsimp(minfactorial(factcomb(%)));
 181                                    3
 182                                30 x  - 30 x
 183 (%o4) y  = - -------------------------------------------------
 184        x        6      5       4       3       2
 185              5 x  - 3 x  - 25 x  + 15 x  + 20 x  - 12 x - 1584
 186 @end example
 187
 188
 189 Veja também: @code{solve_rec_rat}, @code{simplify_products}, e @code{product_use_gamma}.
 190
 191 @end deffn
 192
 193 @deffn {Função} solve_rec_rat (@var{eqn}, @var{var}, [@var{init}])
 194
 195 Encontra soluções racionais para recorrências lineares. Veja solve_rec para
 196 uma descrição dos argumentos.
 197
 198 Para usar essa função primeirametne chame o pacote @code{solve_rec} com
 199 @code{load(solve_rec);}.
 200
 201 Exemplo:
 202
 203 @example
 204 (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
 205 (%o1)  (x + 4) a      + (x + 3) a      - x a
 206                 x + 3            x + 2      x + 1
 207                                                    2
 208                                                + (x  - 1) a
 209                                                             x
 210 (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
 211                        1
 212 (%o2)      a  = ---------------
 213             x   (x - 1) (x + 1)
 214 @end example
 215
 216
 217 Veja também: @code{solve_rec}.
 218
 219 @end deffn
 220
 221 @defvr {Variável de opção} product_use_gamma
 222 Valor por omissão: @code{true}
 223
 224 Quando simplificando produtos, @code{solve_rec} introduz a função gama
 225 dentro da expressão se @code{product_use_gamma} for @code{true}.
 226
 227 Veja também: @code{simplify_products}, @code{solve_rec}.
 228
 229 @end defvr
 230
 231 @deffn {Função} summand_to_rec (@var{summand}, @var{k}, @var{n})
 232 @deffnx {Função} summand_to_rec (@var{summand}, [@var{k}, @var{lo}, @var{hi}], @var{n})
 233
 234 Retorna a recorrência satisfeita pelo somatório
 235
 236 @example
 237      sup
 238     ====
 239     \
 240      >     x
 241     /
 242     ====
 243   k = inf
 244 @end example
 245
 246 onde x é hipergeométrico em @var{k} e @var{n}. SE @var{inf} e @var{sup}
 247 forem omitidos, são assumidos como sendo @code{inf = -inf} e @code{sup = inf}.
 248
 249 Para usar essa função primeiro chame o pacote @code{simplify_sum} com
 250 @code{load(simplify_sum)}.
 251
 252 Exemplo:
 253
 254 @example
 255 (%i1) load("simplify_sum")$
 256 (%i2) summand: binom(n,k);
 257 (%o2)                           binomial(n, k)
 258 (%i3) summand_to_rec(summand,k,n);
 259 (%o3)                      2 sm  - sm      = 0
 260                                n     n + 1
 261 (%i7) summand: binom(n, k)/(k+1);
 262                                 binomial(n, k)
 263 (%o7)                           --------------
 264                                     k + 1
 265 (%i8) summand_to_rec(summand, [k, 0, n], n);
 266 (%o8)               2 (n + 1) sm  - (n + 2) sm      = - 1
 267                                 n             n + 1
 268 @end example
 269
 270 @end deffn
 271