Math 烘焙Pi挑战-了解与管理；改善

昨天我花了一些时间为写解决方案，并且能够在没有作弊的情况下通过，但我还有几个问题要问

这是我的密码

(ns baking-pi.core
  (:import java.math.MathContext))

(defn modpow [n e m]
  (.modPow (biginteger n) (biginteger e) (biginteger m)))

(defn div [top bot]
  (with-precision 34 :rounding HALF_EVEN 
    (/ (bigdec top) (bigdec bot))))

(defn pow [n e]
  (.pow (bigdec n) (bigdec e) MathContext/DECIMAL128))

(defn round
  ([n] (.round (bigdec n) MathContext/DECIMAL128))
  ([n & args] (->> [n args] (flatten) (map round))))

(defn left [n d]
  (letfn [(calc [k] (let [bot (+' (*' 8 k) d)
                          top (modpow 16 (-' n k) bot)]
                      (div top bot)))]
    (->> (inc' n)
         (range 0)
         (map calc)
         (reduce +'))))

(defn right [n d]
  (letfn [(calc [[sum'' sum' k]]
                (let [sum' (if (nil? sum') 0M sum')
                      top (pow 16 (-' n k))
                      bot (+' (*' k 8) d)
                      delta (div top bot)]
                  [sum' (+' sum' delta) (inc' k)]))
          (pred [[sum'' sum' k]]
                (cond (or (nil? sum'') (nil? sum')) true
                      (apply == (round sum'' sum')) false
                      :else true))]
    (->> [nil nil (inc' n)]
         (iterate calc)
         (drop-while pred)
         (first)
         (second))))

(defn bbp [n]
  (letfn [(part [m d] (*' m (+' (left n d) (right n d))))]
    (let [sum (-' (part 4 1) (part 2 4) (part 1 5) (part 1 6))]
      (-> sum
          (-' (long sum))
          (*' 16)
          (mod 16)
          (Long/toHexString)))))

我有两个问题

维基发表了以下声明。由于我的计算精确到小数点后34位，我如何利用它在每次bbp调用中生成更多的十六进制PI数字

理论上，接下来的几个数字取决于计算的准确性 使用也将是准确的

我的算法依赖于biginger的modPow进行模幂运算（基于下面的引文），其他地方则依赖于bigdecimal。它也很慢。请记住，我不想让每个问题1失去有意义的准确性，加快这个程序并使其成为有效的clojurescript和clojure的最佳方法是什么

计算16 n− k mod（8k+1）快速有效地使用 模幂算法

编辑：从3个问题改为2个问题。我自己设法回答了第一个问题

如果希望每个bpp调用计算更多位

然后你必须把你的方程从

1/（16^k）

base改为更大的一个。您可以通过求和

2

迭代（

k

和

k+1

）来实现这一点，因此

(...)/16^k  + (...)/16^(k+1)
(...)/256^k

但是在这种情况下，您需要更精确的

int

操作。使用精度较低的迭代通常更快

如果你看一下基本方程，你会发现你根本不需要

bigint

进行计算

这就是为什么会使用此迭代，但输出编号当然是

bigint

。因此，您不需要在

bigint

上计算模块算术

我不知道你用的那个有多优化。。。但这里是我的：

如果您想要的只是速度而不是无限精度，则使用其他PSLQ方程

我的理解是，它是一种寻找实数和整数迭代之间关系的算法

这是我到目前为止最喜欢的内容，这是从中提取的代码，以防链接出现故障：

//以下由CWI的Dik T.Winter编写的160个字符的C程序将pi计算为800个十进制数字。
INTA=10000，b，c=2800，d，e，f[2801]，g；main（）{for（；b-c；）f[b++]=a/5；
对于（；d=0，g=c*2；c-=14，printf（“%.4d”，e+d/a），e=d%a）对于（b=c；d+=f[b]*a，f[b]=d%--g，d/=g--，--b；d*=b）；}

对两个运算求和得到的公分母为16^（k+1）=16*16^k，而不是32^k=（2^k）*（16^k）。幂键比乘法强，16*16^k是16*（16^k）而不是（16*16）^k。当然，如果将k或k+1的项相加为2k，则公分母为16^（2k）=256^k。

16^（2*k）=256^k

和

16^（2*k+1）=16*（256^k）

。因此，利用连续项的奇数/均匀性，您可以得到一个分母为

256^n

的表达式。好了，您附带的C代码根本不是PSLQ算法。母版文章讨论了不同的方法，最后附加了简短的C程序只是因为它是一个很酷的程序，而不是因为它是PSLQ。从那以后我可以肯定。该代码在32位定点算术中使用了老式的arctan（）系列，每次迭代计算4位十进制数字，请参阅。