Saturday, September 15, 2012

[woctlwvh] Iterated n log n

let f = product . map floor . takeWhile (1<) . iterate log_2
let g = product . map ceiling . takeWhile (1<) . iterate log_2
(Haskell syntax)

nff productgg product
11= 11= 1
22= 2 * 12= 2 * 1
33= 3 * 16= 3 * 2 * 1
48= 4 * 2 * 18= 4 * 2 * 1
510= 5 * 2 * 130= 5 * 3 * 2 * 1
612= 6 * 2 * 136= 6 * 3 * 2 * 1
714= 7 * 2 * 142= 7 * 3 * 2 * 1
824= 8 * 3 * 148= 8 * 3 * 2 * 1
927= 9 * 3 * 172= 9 * 4 * 2 * 1
1030= 10 * 3 * 180= 10 * 4 * 2 * 1
1133= 11 * 3 * 188= 11 * 4 * 2 * 1
1236= 12 * 3 * 196= 12 * 4 * 2 * 1
1339= 13 * 3 * 1104= 13 * 4 * 2 * 1
1442= 14 * 3 * 1112= 14 * 4 * 2 * 1
1545= 15 * 3 * 1120= 15 * 4 * 2 * 1
16128= 16 * 4 * 2 * 1128= 16 * 4 * 2 * 1
17136= 17 * 4 * 2 * 1510= 17 * 5 * 3 * 2 * 1
18144= 18 * 4 * 2 * 1540= 18 * 5 * 3 * 2 * 1
19152= 19 * 4 * 2 * 1570= 19 * 5 * 3 * 2 * 1
20160= 20 * 4 * 2 * 1600= 20 * 5 * 3 * 2 * 1
21168= 21 * 4 * 2 * 1630= 21 * 5 * 3 * 2 * 1
22176= 22 * 4 * 2 * 1660= 22 * 5 * 3 * 2 * 1
23184= 23 * 4 * 2 * 1690= 23 * 5 * 3 * 2 * 1
24192= 24 * 4 * 2 * 1720= 24 * 5 * 3 * 2 * 1
25200= 25 * 4 * 2 * 1750= 25 * 5 * 3 * 2 * 1
26208= 26 * 4 * 2 * 1780= 26 * 5 * 3 * 2 * 1
27216= 27 * 4 * 2 * 1810= 27 * 5 * 3 * 2 * 1
28224= 28 * 4 * 2 * 1840= 28 * 5 * 3 * 2 * 1
29232= 29 * 4 * 2 * 1870= 29 * 5 * 3 * 2 * 1
30240= 30 * 4 * 2 * 1900= 30 * 5 * 3 * 2 * 1
31248= 31 * 4 * 2 * 1930= 31 * 5 * 3 * 2 * 1
32320= 32 * 5 * 2 * 1960= 32 * 5 * 3 * 2 * 1
33330= 33 * 5 * 2 * 11188= 33 * 6 * 3 * 2 * 1
34340= 34 * 5 * 2 * 11224= 34 * 6 * 3 * 2 * 1
35350= 35 * 5 * 2 * 11260= 35 * 6 * 3 * 2 * 1
655342949030= 65534 * 15 * 3 * 18388352= 65534 * 16 * 4 * 2 * 1
655352949075= 65535 * 15 * 3 * 18388480= 65535 * 16 * 4 * 2 * 1
655368388608= 65536 * 16 * 4 * 2 * 18388608= 65536 * 16 * 4 * 2 * 1
655378388736= 65537 * 16 * 4 * 2 * 133423870= 65537 * 17 * 5 * 3 * 2 * 1
655388388864= 65538 * 16 * 4 * 2 * 133424380= 65538 * 17 * 5 * 3 * 2 * 1

OEIS A216761 and A216762.

The reciprocals form a very slowly diverging series, perhaps slower than any other integer sequence.

A fibonacci sequence version, which is essentially logarithms base phi?

A real-valued version using natural logarithms is: product . takeWhile (1<) . iterate log, which is continuous but defined piecewise. Is there a non piecewise function?

No comments: