你会如何在Clojure中编写这个C++循环？

Question

虽然我之前在函数式语言中做过少量的编程，但我刚开始使用Clojure。由于在学习一门新语言时做同样的“Hello World”程序会变老，所以我决定通过Cinder“Hello，Cinder”教程，将它翻译成Clojure和Quil。在本教程的Chapter 5，你碰到过这样的C++代码段来计算加速粒子的列表：

void ParticleController::repulseParticles() { 
    for(list<Particle>::iterator p1 = mParticles.begin(); p1 != mParticles.end(); ++p1) { 
     list<Particle>::iterator p2 = p1; 
     for(++p2; p2 != mParticles.end(); ++p2) { 
      Vec2f dir = p1->mLoc - p2->mLoc; 
      float distSqrd = dir.lengthSquared(); 

      if(distSqrd > 0.0f){ 
       dir.normalize(); 
       float F = 1.0f/distSqrd; 

       p1->mAcc += dir * (F/p1->mMass); 
       p2->mAcc -= dir * (F/p2->mMass); 
      } 
     } 
    } 
} 

在我眼里，这个代码有一个非常重要的特性：它是对颗粒和更新之间做比较这两个粒子，然后在未来跳过相同的组合。这对于性能的原因非常重要，因为这段代码每帧执行一次，并且在任何给定时间屏幕上可能有成千上万个粒子（比我更了解大O的人可能会告诉您这种方法之间的差异并多次迭代每个组合）。

作为参考，我会展示我想出的。你应该注意到下面的代码一次只更新一个粒子，所以我做了很多“额外”的工作，比较两次相同的粒子。 （注：为简洁留下了一些方法，如“规范”）：

(defn calculate-acceleration [particle1 particle2] 
    (let [x-distance-between (- (:x particle1) (:x particle2)) 
     y-distance-between (- (:y particle1) (:y particle2)) 
     distance-squared (+ (* x-distance-between x-distance-between) (* y-distance-between y-distance-between)) 
     normalized-direction (normalize x-distance-between y-distance-between) 
     force (if (> distance-squared 0) (/ (/ 1.0 distance-squared) (:mass particle1)) 0)] 
    {:x (+ (:x (:accel particle1)) (* (first normalized-direction) force)) :y (+ (:y (:accel particle1)) (* (second normalized-direction) force))})) 

(defn update-acceleration [particle particles] 
    (assoc particle :accel (reduce #(do {:x (+ (:x %) (:x %2)) :y (+ (:y %) (:y %2))}) {:x 0 :y 0} (for [p particles :when (not= particle p)] (calculate-acceleration particle p))))) 

(def particles (map #(update-acceleration % particles) particles)) 

更新：所以这就是我最终来到了，如果有人有兴趣：

(defn get-new-accelerations [particles] 
    (let [particle-combinations (combinations particles 2) 
     new-accelerations (map #(calculate-acceleration (first %) (second %)) particle-combinations) 
     new-accelerations-grouped (for [p particles] 
            (filter #(not (nil? %)) 
              (map 
               #(cond (= (first %) p) %2 
                (= (second %) p) (vec-scale %2 -1)) 
               particle-combinations new-accelerations)))] 
    (map #(reduce (fn [accum accel] (if (not (nil? accel)) (vec-add accel accum))) {:x 0 :y 0} %) 
     new-accelerations-grouped))) 

从本质上讲，过程是这样的：

1. 颗粒组合：计算使用组合数学“组合”粒子的所有组合功能
2. 新加速度：计算基于组合的列表
3. 新加速度-分组上的加速度的列表：组向上通过遍历每个粒子和检查组合的列表每个粒子的加速度（按顺序），建立列表，其中每个子列表是所有单个加速度;还有一点微妙之处在于，如果粒子是组合列表中的第一个输入项，它将获得原始加速度，但如果它是第二个，则会得到相反的加速度。然后，它过滤掉尼尔斯
4. 减少加速度的每个子列表的加速度

现在的问题的总和，这是任何速度比我在做什么之前？ （我还没有测试过，但我最初的猜测是没有办法的）。

更新2： 下面是另一个版本，我想出了。我认为这个版本在所有方面比我上面发布的版本好得多：它使用瞬态数据结构来实现新列表的性能/易变性，并使用循环/重复。它应该比我在上面发布的例子快得多，但我还没有测试过要验证。

(defn transient-particle-accelerations [particles] 
    (let [num-of-particles (count particles)] 
    (loop [i 0 new-particles (transient particles)] 
     (if (< i (- num-of-particles 1)) 
     (do 
      (loop [j (inc i)] 
      (if (< j num-of-particles) 
       (let [p1 (nth particles i) 
        p2 (nth particles j) 
        new-p1 (nth new-particles i) 
        new-p2 (nth new-particles j) 
        new-acceleration (calculate-acceleration p1 p2)] 
       (assoc! new-particles i (assoc new-p1 :accel (vec-add (:accel new-p1) new-acceleration))) 
       (assoc! new-particles j (assoc new-p2 :accel (vec-add (:accel new-p2) (vec-scale new-acceleration -1)))) 
       (recur (inc j))))) 
      (recur (inc i) new-particles)) 
     (persistent! new-particles))))) 

Answer 1

重新def -ing颗粒，当你想更新他们似乎并不完全正确 - 我猜，使用一个裁判存储世界的状态，然后更新周期之间的裁判，会更有意义。

至于算法问题，对我来说这是clojure.math.combinatorics的用例。像下面这样：

(require '[clojure.math.combinatorics :as combinatorics]) 

(defn update-particles [particles] 
    (apply concat 
    (for [[p1 p2] (combinatorics/combinations particles 2) 
      :let [x-distance-between (- (:x p1) (:x p2)) 
       y-distance-between (- (:y p1) (:y p2)) 
       distance-squared (+ (* x-distance-between x-distance-between) 
            (* y-distance-between y-distance-between)) 
       normalized-direction (normalize x-distance-between y-distance-between) 
       p1-force (if (> distance-squared 0) 
          (/ (/ 1.0 distance-squared) (:mass p1)) 
          0)]] 
    [{:x (+ (:x (:accel p1)) (* (first normalized-direction) p1-force)) 
     :y (+ (:y (:accel p1)) (* (first normalized-direction) p1-force))} 
     {:x (+ (:x (:accel p2)) (* (first normalized-direction) p2-force)) 
     :y (+ (:y (:accel p2)) (* (first normalized-direction) p2-force))}])) 

...你仍然需要降低，但这样一来我们两个粒子拉动更新值圈外。

Answer 2

所以，基本上，你想要选择所有大小为2的子集，然后在每个这样的对上进行操作？

这里是一个组合数学库http://richhickey.github.com/clojure-contrib/combinatorics-api.html与

combinations 
function 
Usage: (combinations items n) All the unique 
ways of taking n different elements from items 

用它来生成列表，然后遍历这一点。