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

Question

Although I've done some small amount of programming in functional languages before, I've just started playing with Clojure. Since doing the same kind of "Hello World" programs gets old when learning a new language, I decided to go through the Cinder "Hello, Cinder" tutorial, translating it to Clojure and Quil along the way. In Chapter 5 of the tutorial, you come across this C++ snippet to calculate acceleration for a list of particles:

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 );
            }
        }
    }
}

In my eyes, this code has one very important characteristic: it is doing comparisons between pairs of particles and updating both particles and then skipping the same combination in the future. This is very important for performance reasons, since this piece of code is executed once every frame and there are potentially thousands of particles on screen at any given time (someone who understands big O better than I do can probably tell you the difference between this method and iterating over every combination multiple times).

For reference, I'll show what I came up with. You should notice that the code below only updates one particle at a time, so I'm doing a lot of "extra" work comparing the same particles twice. (Note: some methods left out for brevity, such as "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))

Update : So here's what I ultimately came up with, in case anyone is interested:

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

Essentially, the process goes something like this:

1. particle-combinations: Calculate all combinations of particles using the combinatorics "combinations" function
2. new-accelerations: Calculate a list of accelerations based on the list of combinations
3. new-accelerations-grouped: Group up the accelerations for each particle (in order) by looping over every particle and checking the list of combinations, building a list of lists where each sub-list is all of the individual accelerations; there's also the subtlety that if the particle is the first entry in the combination list, it gets the original acceleration, but if it's the second, it gets the opposite acceleration. It then filters out nils
4. Reduce each sub-list of accelerations to the sum of those accelerations

The question now is, is this any faster than what I was doing before? (I haven't tested it yet, but my initial guess is no way).

Update 2: Here's another version I came up with. I think this version is much better in all respects than the one I posted above: it uses a transient data structure for performance/easy mutability of the new list, and uses loop/recur. It should be much faster than the example I posted above but I haven't tested yet to verify.

(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

Re- def -ing particles when you want to update them doesn't seem quite right -- I'm guessing that using a ref to store the state of the world, and then updating that ref between cycles, would make more sense.

Down to the algorithmic issue, to me like this is a use case for clojure.math.combinatorics . Something like the following:

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

...you'll still need the reduce, but this way we're pulling updated values for both particles out of the loop.

Answer 2

So, essentially, you want to select all subsets of size two, then operate on each such pair?

Here's a combinatorics library http://richhickey.github.com/clojure-contrib/combinatorics-api.html with

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

Use that to generate your list, then iterate over that.