Próximo: Índice de Funções e Variáveis, Anterior: unit [Conteúdo][Índice]
Próximo: Definições para zeilberger, Anterior: zeilberger, Acima: zeilberger [Conteúdo][Índice]
zeilberger é uma implementação do algoritmo de Zeilberger
para somatório hipergeométricos definidos, e também
para o algoritmo de Gosper para somatórios hipergeométricos
indefinidos.
zeilberger faz uso do método de optimização "filtering" desenvolvido por Axel Riese.
zeilberger foi desenvolvido por Fabrizio Caruso.
load ("zeilberger") torna esse pacote disponível para uso.
zeilberger implementa o algoritmo de Gosper
para somatório hipergeométrico indefinido.
Dado um termo hipergeométrico F_k em k queremos encontrar sua anti-diferença
hipergeométrica, isto é, um termo hipergeométrico f_k tal que F_k = f_(k+1) - f_k.
zeilberger implementa o algoritmo de Zeilberger
para somatório hipergeométrico definido.
Dado um termo hipergeométrico apropriado (em n e k) F_(n,k) e um
inteiro positivo d queremos encontrar um d-ésima ordem de recorrência
linear com coeficientes polinomiais (em n) para F_(n,k)
e uma função racional R em n e k tal que
a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))
onde Delta_k é o k-seguinte operador de diferença, i.e., Delta_k(t_k) := t_(k+1) - t_k.
Existe também versões de níveis de detalhe fornecidos pelos comandos que são chamados (os níveis) através da adição de um dos seguintes prefixos:
SummaryApenas um sumário é mostrado no final
VerboseAlgumas informações nos passos intermédios
VeryVerboseMuita informação
ExtraMuito mais informação incluindo informação sobre o sistema linear no algoritmo de Zeilberger
Por exemplo:
GosperVerbose, parGosperVeryVerbose,
ZeilbergerExtra, AntiDifferenceSummary.
Anterior: Introdução a zeilberger, Acima: zeilberger [Conteúdo][Índice]
Retorna a anti-diferença hipergeométrica
de F_k, se essa anti-diferença.
De outra forma AntiDifference retorna no_hyp_antidifference.
Retorna o certificado racional R(k) para F_k, isto é, uma função racional tal que
F_k = R(k+1) F_(k+1) - R(k) F_k
se essa função racional exitir.
De outra forma, Gosper retorna no_hyp_sol.
Retorna o somatório de F_k de k = a a k = b
se F_k tiver ma diferença hipergeométrica.
De outra forma, GosperSum retorna nongosper_summable.
Exemplos:
(%i1) load ("zeilberger");
(%o1) /usr/share/maxima/share/contrib/Zeilberger/zeilberger.mac
(%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
Dependent equations eliminated: (1)
3 n + 1
(n + -) (- 1)
2 1
(%o2) - ------------------ - -
2 4
2 (4 (n + 1) - 1)
(%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
3
- n - -
2 1
(%o3) -------------- + -
2 2
4 (n + 1) - 1
(%i4) GosperSum (x^k, k, 1, n);
n + 1
x x
(%o4) ------ - -----
x - 1 x - 1
(%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
n + 1
a! (n + 1) (- 1) a!
(%o5) - ------------------------- - ----------
a (- n + a - 1)! (n + 1)! a (a - 1)!
(%i6) GosperSum (k*k!, k, 1, n);
Dependent equations eliminated: (1)
(%o6) (n + 1)! - 1
(%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
(n + 1) (n + 2) (n + 1)!
(%o7) ------------------------ - 1
(n + 2)!
(%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
(%o8) nonGosper_summable
Tenta encontrar uma recorrência de d-ésima ordem para F_{n,k}.
O algoritmo retorna uma sequência [s_1, s_2, ..., s_m] de soluções. Cada solução tem a forma
[R(n, k), [a_0, a_1, ..., a_d]]
parGosper retorna [] caso não consiga encontrar uma recorrência.
Tenta calcular o somatório hipergeométrico indefinido de F_{n,k}.
Zeilberger primeiro invoca Gosper, e se Gosper não conseguir encontrar uma solução, então Zeilberger invoca
parGospercom ordem 1, 2, 3, ..., acima de MAX_ORD.
Se Zeilberger encontrar uma solução antes de esticar MAX_ORD,
Zeilberger para e retorna a solução.
O algoritmo retorna uma sequência [s_1, s_2, ..., s_m] de soluções. Cada solução tem a forma
[R(n,k), [a_0, a_1, ..., a_d]]
Zeilberger retorna [] se não conseguir encontrar uma solução.
Zeilberger invoca Gosper somente se gosper_in_zeilberger for true.
Valor por omissão: 5
MAX_ORD é a ordem máxima de recorrência tentada por Zeilberger.
Valor por omissão: false
Quando simplified_output for true,
funções no pacote zeilberger tentam
simplificação adicional da solução.
Valor por omissão: linsolve
linear_solver nomeia o resolvedor que é usado para resolver o sistema
de equações no algoritmo de Zeilberger.
Valor por omissão: true
Quando warnings for true,
funções no pacote zeilberger imprimem
mensagens de alerta durante a execução.
Valor por omissão: true
Quando gosper_in_zeilberger for true,
a função Zeilberger chama Gosper antes de chamar parGosper.
De outra forma, Zeilberger vai imediatamente para parGosper.
Valor por omissão: true
Quando trivial_solutions for true,
Zeilberger retorna soluções
que possuem certificado igual a zero, ou todos os coeficientes iguais a zero.
Valor por omissão: false
Quando mod_test for true,
parGosper executa um
teste modular discartando sistemas sem solução.
Valor por omissão: linsolve
modular_linear_solver nomeia o resolvedor linear usado pelo teste modular em parGosper.
Valor por omissão: big_primes[10]
ev_point é o valor no qual a variável n é avaliada
no momento da execução do teste modular em parGosper.
Valor por omissão: big_primes[1]
mod_big_prime é o módulo usado pelo teste modular em parGosper.
Valor por omissão: 4
mod_threshold is the
maior ordem para a qual o teste modular em parGosper é tentado.
Próximo: Índice de Funções e Variáveis, Anterior: unit [Conteúdo][Índice]