@@ 48,21 48,21 @@ pub struct Aggregate {
adds: Vec<(usize, usize)>,
/// The number of adds required to reduce a simplex, by dimension.
- adds_required_by_dim: HashMap<isize, f64>,
+ adds_required: HashMap<isize, f64>,
/// The average number of additions required to reduce a simplex, by dimension.
avg_adds_required: HashMap<isize, f64>,
/// The size of a simplex when we add them to reduce the first.
- add_size_by_dim: HashMap<isize, Vec<(usize, usize)>>,
+ add_size: HashMap<isize, Vec<(usize, usize)>>,
/// Average of the sizes.
- avg_add_size_by_dim: HashMap<isize, (f64, f64)>,
+ avg_add_size: HashMap<isize, (f64, f64)>,
/// Histogram of the sizes
- histogram_add_size_by_dim: HashMap<isize, HashMap<usize, (usize, usize)>>,
+ histogram_add_size: HashMap<isize, HashMap<usize, (usize, usize)>>,
/// The sum of sizes of simplices when we reduce
- add_cost_by_dim: HashMap<isize, Vec<usize>>,
- avg_add_cost_by_dim: HashMap<isize, f64>,
- histogram_add_cost_by_dim: HashMap<isize, HashMap<usize, usize>>,
+ add_cost: HashMap<isize, Vec<usize>>,
+ avg_add_cost: HashMap<isize, f64>,
+ histogram_add_cost: HashMap<isize, HashMap<usize, usize>>,
num_simplices: HashMap<isize, usize>,
}
@@ 86,7 86,7 @@ impl<'a> Reduction<'a> {
}
let mut num_simplices = HashMap::new();
- for (&j, &dim) in simplices2dim.iter() {
+ for &dim in simplices2dim.values() {
*num_simplices.entry(dim).or_insert(0) += 1;
}
@@ 97,45 97,45 @@ impl<'a> Reduction<'a> {
}
}
- let mut adds_required_by_dim = HashMap::new();
+ let mut adds_required = HashMap::new();
let mut count = HashMap::new();
for r in self.reductions.iter() {
- *adds_required_by_dim.entry(r.dim).or_insert(0.0) += r.adds.len() as f64;
+ *adds_required.entry(r.dim).or_insert(0.0) += r.adds.len() as f64;
*count.entry(r.dim).or_insert(0) += 1;
}
let mut avg_adds_required = HashMap::new();
for (&k, &c) in count.iter() {
- avg_adds_required.insert(k, adds_required_by_dim.get(&k).unwrap() / c as f64);
+ avg_adds_required.insert(k, adds_required.get(&k).unwrap() / c as f64);
}
- let mut add_size_by_dim = HashMap::<isize, Vec<(usize, usize)>>::new();
+ let mut add_size = HashMap::<isize, Vec<(usize, usize)>>::new();
for r in self.reductions.iter() {
if r.adds.len() == 0 {
continue;
}
- let v = add_size_by_dim.entry(r.dim).or_insert(Vec::new());
+ let v = add_size.entry(r.dim).or_insert(Vec::new());
for a in r.adds.iter() {
v.push((a.this_size, a.other_size));
}
}
- let mut avg_add_size_by_dim = HashMap::new();
- for (&dim, adds) in add_size_by_dim.iter() {
+ let mut avg_add_size = HashMap::new();
+ for (&dim, adds) in add_size.iter() {
if adds.len() == 0 {
continue;
}
let avg_f = adds.iter().map(|(f, _s)| *f).sum::<usize>() as f64 / adds.len() as f64;
let avg_s = adds.iter().map(|(_f, s)| *s).sum::<usize>() as f64 / adds.len() as f64;
- avg_add_size_by_dim.insert(dim, (avg_f, avg_s));
+ avg_add_size.insert(dim, (avg_f, avg_s));
}
- let mut histogram_add_size_by_dim = HashMap::new();
+ let mut histogram_add_size = HashMap::new();
for r in self.reductions.iter() {
if r.adds.len() == 0 {
continue;
}
- let histogram: &mut HashMap<usize, (usize, usize)> = histogram_add_size_by_dim
+ let histogram: &mut HashMap<usize, (usize, usize)> = histogram_add_size
.entry(r.dim)
.or_insert(HashMap::new());
for add in r.adds.iter() {
@@ 144,32 144,32 @@ impl<'a> Reduction<'a> {
}
}
- let mut add_cost_by_dim = HashMap::<isize, Vec<usize>>::new();
+ let mut add_cost = HashMap::<isize, Vec<usize>>::new();
for r in self.reductions.iter() {
if r.adds.len() == 0 {
continue;
}
- let v = add_cost_by_dim.entry(r.dim).or_insert(Vec::new());
+ let v = add_cost.entry(r.dim).or_insert(Vec::new());
for a in r.adds.iter() {
v.push(a.this_size + a.other_size);
}
}
- let mut avg_add_cost_by_dim = HashMap::new();
- for (&dim, adds) in add_cost_by_dim.iter() {
+ let mut avg_add_cost = HashMap::new();
+ for (&dim, adds) in add_cost.iter() {
if adds.len() == 0 {
continue;
}
let avg = adds.iter().map(|f| *f).sum::<usize>() as f64 / adds.len() as f64;
- avg_add_cost_by_dim.insert(dim, avg);
+ avg_add_cost.insert(dim, avg);
}
- let mut histogram_add_cost_by_dim = HashMap::new();
+ let mut histogram_add_cost = HashMap::new();
for r in self.reductions.iter() {
if r.adds.len() == 0 {
continue;
}
- let histogram: &mut HashMap<usize, usize> = histogram_add_cost_by_dim
+ let histogram: &mut HashMap<usize, usize> = histogram_add_cost
.entry(r.dim)
.or_insert(HashMap::new());
for add in r.adds.iter() {
@@ 179,14 179,14 @@ impl<'a> Reduction<'a> {
Aggregate {
adds,
- adds_required_by_dim,
+ adds_required,
avg_adds_required,
- add_size_by_dim,
- avg_add_size_by_dim,
- histogram_add_size_by_dim,
- add_cost_by_dim,
- avg_add_cost_by_dim,
- histogram_add_cost_by_dim,
+ add_size,
+ avg_add_size,
+ histogram_add_size,
+ add_cost,
+ avg_add_cost,
+ histogram_add_cost,
num_simplices,
}
}