Perl - 35 bytes
print!map$\-=1/($%+=$.=$%-$.),0..<>
Uso da amostra:
$ echo 10 | perl inv-fib-sum.pl
3.34170499581934
Análise Adicional
É interessante notar que a soma
é convergente. Supondo que desejássemos calcular alguns milhares de dígitos, a abordagem ingênua é quase suficiente. A convergência é bastante lenta no início, mas acelera rapidamente, de modo que 1000 dígitos levam apenas cerca de 4800 termos. Uma implementação de exemplo de Python pode ser:
a=[1,1]
for i in range(4800):a=[a[0]+a[1]]+a
z=10**1000
print sum(map(lambda i:z/i,a))
que após um segundo ou mais produz:
33598856662431775531720113029189271796889051337319684864955538153251303189966833836154162164567900872970453429288539133041367890171008836795913517330771190785803335503325077531875998504871797778970060395645092153758927752656733540240331694417992939346109926262579646476518686594497102165589843608814726932495910794738736733785233268774997627277579468536769185419814676687429987673820969139012177220244052081510942649349513745416672789553444707777758478025963407690748474155579104200675015203410705335285129792635242062267537568055761955669720848843854407983324292851368070827522662579751188646464096737461572387236295562053612203024635409252678424224347036310363201466298040249015578724456176000319551987905969942029178866949174808096746523682654086938399069873211752166957063859411814553647364268782462926166650100098903804823359519893146150108288726392887669917149304053057745574321561167298985617729731395370735291966884327898022165047585028091806291002444277017460241040417786069190065037142832933
(Os últimos quatro dígitos não convergem completamente, mas vamos ignorá-lo por enquanto.)
Vamos tentar acelerar um pouco a convergência. Um truque padrão é usar a transformação de Euler . Após expansão e simplificação, isso produz um resultado melhor:
Deveria ser bastante claro por que isso converge mais rapidamente; cada termo tem 3 termos no denominador em vez de apenas um. O cálculo de 1000 dígitos requer apenas 1600 (um terço do número) de termos:
a=[1,1]
for i in range(1601):a=[a[0]+a[1]]+a
z=10**1000
print sum(map(lambda i:(-1)**i*z/(a[i]*a[i+1]*a[i+2]),range(1601)))
Resultado:
3598856662431775531720113029189271796889051337319684864955538153251303189966833836154162164567900872970453429288539133041367890171008836795913517330771190785803335503325077531875998504871797778970060395645092153758927752656733540240331694417992939346109926262579646476518686594497102165589843608814726932495910794738736733785233268774997627277579468536769185419814676687429987673820969139012177220244052081510942649349513745416672789553444707777758478025963407690748474155579104200675015203410705335285129792635242062267537568055761955669720848843854407983324292851368070827522662579751188646464096737461572387236295562053612203024635409252678424224347036310363201466298040249015578724456176000319551987905969942029178866949174808096746523682654086938399069873211752166957063859411814553647364268782462926166650100098903804823359519893146150108288726392887669917149304053057745574321561167298985617729731395370735291966884327898022165047585028091806291002444277017460241040417786069190065037142834500
(Aqui, novamente, os últimos 4 dígitos não convergem.)
Ainda não terminamos. Se combinarmos termos adjacentes, terminamos com o seguinte:
A fatoração de cada termo do restante da soma fornece a expressão aninhada:
Agora estamos chegando a algum lugar. Observe que os numeradores seguem OEIS A206351 (com exceção do primeiro termo, que é dobrado):
e os denominadores seguem OEIS A081016 (alterado por um termo):
Cada um deles tem relações de recorrência muito simples, a saber:
e
respectivamente. Juntando tudo, descobrimos que precisamos de apenas 800 iterações para 1000 dígitos:
b,c=[16,3,1],[273,40,3]
for i in range(800):b,c=[7*b[0]-b[1]-4]+b,[7*c[0]-c[1]-1]+c
s=z=10**1000
for x,y in zip(b,c):s=(z+s)*x/y
print s
quais saídas:
3598856662431775531720113029189271796889051337319684864955538153251303189966833836154162164567900872970453429288539133041367890171008836795913517330771190785803335503325077531875998504871797778970060395645092153758927752656733540240331694417992939346109926262579646476518686594497102165589843608814726932495910794738736733785233268774997627277579468536769185419814676687429987673820969139012177220244052081510942649349513745416672789553444707777758478025963407690748474155579104200675015203410705335285129792635242062267537568055761955669720848843854407983324292851368070827522662579751188646464096737461572387236295562053612203024635409252678424224347036310363201466298040249015578724456176000319551987905969942029178866949174808096746523682654086938399069873211752166957063859411814553647364268782462926166650100098903804823359519893146150108288726392887669917149304053057745574321561167298985617729731395370735291966884327898022165047585028091806291002444277017460241040417786069190065037142835294
(Aqui, finalmente, os últimos 4 dígitos convergem corretamente.)
Mas isso ainda não é tudo. Se observarmos os valores intermediários para s , descobrimos que ele converge para um valor completamente diferente antes de convergir no ponto de convergência real. O motivo para isso é o seguinte:
Resolvendo para um s estável , descobrimos que:
Como essa é uma raiz simples, podemos usar o Método de Newton para chegar até lá e depois pular em um ponto muito mais tarde na iteração. Apenas cerca de 400 dígitos de precisão são necessários (como as de b e c valores não são maiores do que qualquer que de qualquer forma), que pode ser alcançada com apenas 7 iterações, enquanto poupando 320 iterações do ciclo principal:
b,c=[16,3,1],[273,40,3]
for i in range(480):b,c=[7*b[0]-b[1]-4]+b,[7*c[0]-c[1]-1]+c
z=10**1000;s=z/17
for i in range(7):s-=(s*s+s*z-z*z/16)/(2*s+z)
for x,y in zip(b,c):s=(z+s)*x/y
print s
A saída é idêntica à anterior, o tempo de execução é de cerca de 0,02s no meu sistema usando o PyPy v2.1. Embora precise de um décimo do número de iterações que o original, é significativamente mais rápido que 10x devido à multiplicação e divisão por termos muito menores. Eu não acho que muito mais possa ser alterado, embora eu ficaria feliz em ser mostrado errado.
φestá embutido. (não APL para variar)