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的人可能会告诉你这个方法之间的区别并多次迭代每个组合。）

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

(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)))

基本上，这个过程是这样的：

粒子组合：使用组合“组合”功能
新加速：根据组合列表计算加速度列表
new-accelerations-grouped：通过循环每个粒子并检查组合列表，建立列表列表，其中每个子列表是所有单独的加速度，从而对每个粒子的加速度（按顺序）进行分组;还有一个微妙之处在于，如果粒子是组合列表中的第一个条目，它将获得原始加速度，但如果它是第二个，则获得相反的加速度。然后过滤掉nils
将每个加速度子列表减少为这些加速度的总和

现在的问题是，这比我之前做的更快吗？（我还没有测试过，但我最初的猜测是没办法的。）

更新2： 这是我提出的另一个版本。我认为这个版本在各个方面都比我上面发布的版本好得多：它使用瞬态数据结构来提高新列表的性能/易变性，并使用loop / recur。它应该比我上面发布的示例快得多，但我还没有测试过验证。

(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 - 粒子似乎不太正确 - 我猜测使用ref存储世界状态，然后在循环之间更新ref ，会更有意义。

对于算法问题，对我来说这是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

使用它来生成列表，然后迭代它。

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

2 个答案: