Not really an improvement, but at least not significantly worse...

src/main.rs

@@ -126,13 +126,7 @@ impl Object {
             .map(
                 |obj_pos|
                     {
-                        obj_pos
-                            .iter()
-                            .zip(&this_pos)
-                            .map(
-                                |(obj, this)|
-                                    { obj - this }
-                            ).collect()
+                        Object::calc_xy_distances(&this_pos, obj_pos)
                     }
             ).collect();
         for dist in distances {
@@ -143,18 +137,48 @@ impl Object {
         }
     }
 
+    fn calc_xy_distances(this_pos: &Vec<f64>, obj_pos: &Vec<f64>) -> Vec<f64> {
+        obj_pos
+            .iter()
+            .zip(this_pos)
+            .map(
+                |(obj, this)|
+                    { obj - this }
+            ).collect()
+    }
+
     fn repel(&mut self, obj_pos: &mut Vec<Vec<f64>>) {
         let this_pos: Vec<f64> = self.get_pos();
-        for pos in obj_pos {
-            let mut dist_vec: Vec<f64> = Vec::new();
-            for i in 0..2 {
-                dist_vec.push(this_pos[i] - pos[i]);
-            }
+        obj_pos
+            .iter()
+            .for_each(
+                |pos|
+                    {
+                        let dist_vec: Vec<f64> = this_pos.iter().zip(pos).map(|(t, p)| {t - p}).collect();
+                        // let mut dist_vec: Vec<f64> = Vec::new();
+                        // for i in 0..2 {
+                        //     dist_vec.push(this_pos[i] - pos[i]);
+                        // }
                         let amount = calc_amount(&dist_vec);
 
-            for (i, d) in dist_vec.iter().enumerate() {
-                self.vel[i] += 1.5 * d.min(150.0).max(-150.0) / (amount).max(0.01);
+                        self.apply_force_to_self(&dist_vec, amount)
                     }
+            )
+        // for pos in obj_pos {
+        //     let mut dist_vec: Vec<f64> = Vec::new();
+        //     for i in 0..2 {
+        //         dist_vec.push(this_pos[i] - pos[i]);
+        //     }
+        //     let amount = calc_amount(&dist_vec);
+        //
+        //     self.apply_force_to_self(&mut dist_vec, amount)
+        // }
+    }
+
+    fn apply_force_to_self(&mut self, dist_vec: &Vec<f64>, amount: f64) {
+        for (i, d) in dist_vec.iter().enumerate() {
+            let repel_force = 1.5 * d.min(150.0).max(-150.0) / (amount).max(0.01);
+            self.vel[i] += repel_force;
         }
     }