Parallelize the Packer

Cargo.toml

@@ -19,6 +19,7 @@ nalgebra = "0.13"
 float-cmp = "0.2"
 serde = { version = "1.0", optional = true }
 clippy = {version = "0.0.180", optional = true}
+rayon = "0.9.0"
 
 [dev-dependencies]
 kiss3d = "0.12"

src/lib.rs

@@ -59,9 +59,10 @@
 #![warn(missing_docs)]
 #![feature(vec_remove_item)]
 
+extern crate float_cmp;
 extern crate nalgebra;
 extern crate rand;
-extern crate float_cmp;
+extern crate rayon;
 #[cfg(feature = "serde-1")]
 extern crate serde;
 
@@ -79,6 +80,7 @@ use std::iter::repeat;
 use shapes::Sphere;
 use float_cmp::ApproxEqRatio;
 use errors::SphericalCowError as Error;
+use rayon::prelude::*;
 
 /// The `Container` trait must be implemented for all shapes you wish to pack spheres into.
 /// Standard shapes such as spheres and cuboids already derrive this trait. More complicated
@@ -249,22 +251,36 @@ pub fn pack_spheres<C: Container, R: IndependentSample<f64>>(
  // Radius of new sphere to be added to the current front, taken from the input distribution
  let mut new_radius = size_distribution.ind_sample(&mut rng) as f32;
 
+ let mut set_v = Vec::new();
+ let mut set_f = Vec::new();
+
  'outer: while !front.is_empty() {
  // s₀ := s(c₀, r₀) picked at random from F
  let curr_sphere = rng.choose(&front).ok_or(Error::NoneFront)?.clone();
  // V := {s(c', r') ∈ S : d(c₀, c') ≤ r₀ + r' + 2r}
- let set_v = spheres
- .iter()
- .cloned()
- .filter(|s_dash| {
- s_dash != &curr_sphere &&
- nalgebra::distance(&curr_sphere.center, &s_dash.center) <=
- curr_sphere.radius + s_dash.radius + 2. * new_radius
- })
- .collect::<Vec<_>>();
+ set_v.clear();
+ set_v.par_extend(
+ spheres
+ .par_iter()
+ .filter(|&s_dash| {
+ s_dash != &curr_sphere
+ && nalgebra::distance(&curr_sphere.center, &s_dash.center)
+ <= curr_sphere.radius + s_dash.radius + 2. * new_radius
+ })
+ .cloned(),
+ );
 
  for (s_i, s_j) in pairs(&set_v) {
- let mut set_f = identify_f(&curr_sphere, s_i, s_j, container, &set_v, new_radius)?;
+ set_f.clear();
+ identify_f(
+ &curr_sphere,
+ s_i,
+ s_j,
+ container,
+ &mut set_f,
+ &set_v,
+ new_radius,
+ )?;
  if !set_f.is_empty() {
  // Found at least one position to place the sphere,
  // choose one and move on
@@ -351,10 +367,10 @@ fn identify_f<C: Container>(
  s_2: &Sphere,
  s_3: &Sphere,
  container: &C,
+ set_f: &mut Vec<Sphere>,
  set_v: &[Sphere],
  radius: f32,
-) -> Result<Vec<Sphere>, Error> {
-
+) -> Result<(), Error> {
  //The center points of s_1, s_2, s_3 are verticies of a tetrahedron,
  //and the distances d_1, d_2, d_3 can be defined as the distances from these points to
  //a fourth vertex s_4, whose coordinates x,y,z must be found. This satisfies the equations
@@ -410,7 +426,6 @@ fn identify_f<C: Container>(
  let dot_wt_2 = dot_wt.powi(2);
  let value_4d = 4. * value_d;
 
- let mut f = Vec::new();
  // There is a possiblity of obtaining imaginary solutions in gamma,
  // so we must check this comparison. TODO: Would be nice to have
  // some quick way of verifying this configuration and deny it early.
@@ -433,13 +448,13 @@ fn identify_f<C: Container>(
 
  // Make sure the spheres are bounded by the containing geometry and do not overlap any spheres in V
  if container.contains(&s_4_positive) && !set_v.iter().any(|v| v.overlaps(&s_4_positive)) {
- f.push(s_4_positive);
+ set_f.push(s_4_positive);
  }
  if container.contains(&s_4_negative) && !set_v.iter().any(|v| v.overlaps(&s_4_negative)) {
- f.push(s_4_negative);
+ set_f.push(s_4_negative);
  }
  }
- Ok(f)
+ Ok(())
 }
 
 /// Calculates all possible pairs of a `set` of values.
@@ -482,7 +497,8 @@ fn identify_f_known() {
  let four_p = Sphere::new(Point3::new(0.06666667, 0.12316024, 0.6773287), 0.4).unwrap();
  let four_n = Sphere::new(Point3::new(0.06666667, 0.12316024, -0.6773287), 0.4).unwrap();
 
- let found = identify_f::<Sphere>(&one, &two, &three, &container, &Vec::new(), 0.4).unwrap();
+ let mut found = Vec::new();
+ identify_f::<Sphere>(&one, &two, &three, &container, &mut found, &Vec::new(), 0.4).unwrap();
 
  println!("{:?}", found);
  assert!(found.contains(&four_p));