Shorten track ids.

tig-challenges/src/hypergraph/mod.rs

@@ -7,7 +7,7 @@ use std::sync::Arc;
 
 impl_kv_string_serde! {
     Track {
-        num_hyperedges: u32,
+        n_h_edges: u32,
     }
 }
 
@@ -59,8 +59,8 @@ impl Challenge {
         _prop: &cudaDeviceProp,
     ) -> Result<Self> {
         let mut rng = StdRng::from_seed(seed.clone());
-        let num_hyperedges = track.num_hyperedges;
-        let target_num_nodes = track.num_hyperedges; // actual number may be around 8% less
+        let num_hyperedges = track.n_h_edges;
+        let target_num_nodes = track.n_h_edges; // actual number may be around 8% less
         let depth = 6;
         let num_parts = 1 << depth; // 2^6 = 64 partitions
         let level_weights: Vec<f32> = vec![
@@ -354,7 +354,7 @@ impl Challenge {
 
         Ok(Self {
             seed: *seed,
-            num_hyperedges: track.num_hyperedges,
+            num_hyperedges: track.n_h_edges,
             num_nodes: target_num_nodes - num_prune,
             num_parts,
             max_part_size,

tig-challenges/src/knapsack/mod.rs

@@ -8,7 +8,7 @@ use std::collections::HashSet;
 
 impl_kv_string_serde! {
     Track {
-        num_items: usize,
+        n_items: usize,
         density: u32,
     }
 }
@@ -42,12 +42,10 @@ impl Challenge {
         let density = track.density as f64 / 100.0;
 
         // Generate weights w_i in the range [1, 50]
-        let weights: Vec<u32> = (0..track.num_items)
-            .map(|_| rng.gen_range(1..=50))
-            .collect();
+        let weights: Vec<u32> = (0..track.n_items).map(|_| rng.gen_range(1..=50)).collect();
 
         // Generate values v_i in the range [1, 100] with density probability, 0 otherwise
-        let values: Vec<u32> = (0..track.num_items)
+        let values: Vec<u32> = (0..track.n_items)
             .map(|_| {
                 if rng.gen_bool(density) {
                     rng.gen_range(1..=100)
@@ -61,10 +59,10 @@ impl Challenge {
         // - V_ij == V_ji (symmetric matrix)
         // - V_ii == 0 (diagonal is zero)
         // - Values are in range [1, 100] with density probability, 0 otherwise
-        let mut interaction_values: Vec<Vec<i32>> = vec![vec![0; track.num_items]; track.num_items];
+        let mut interaction_values: Vec<Vec<i32>> = vec![vec![0; track.n_items]; track.n_items];
 
-        for i in 0..track.num_items {
-            for j in (i + 1)..track.num_items {
+        for i in 0..track.n_items {
+            for j in (i + 1)..track.n_items {
                 let value = if rng.gen_bool(density) {
                     rng.gen_range(1..=100)
                 } else {
@@ -81,7 +79,7 @@ impl Challenge {
 
         Ok(Challenge {
             seed: seed.clone(),
-            num_items: track.num_items.clone(),
+            num_items: track.n_items.clone(),
             weights,
             values,
             interaction_values,

tig-challenges/src/neuralnet_optimizer/mod.rs

@@ -16,7 +16,7 @@ const THREADS_PER_BLOCK: u32 = 1024;
 
 impl_kv_string_serde! {
     Track {
-        num_hidden_layers: usize,
+        n_hidden: usize,
     }
 }
 
@@ -208,7 +208,7 @@ impl Challenge {
 
         Ok(Self {
             seed: *seed,
-            num_hidden_layers: track.num_hidden_layers.clone(),
+            num_hidden_layers: track.n_hidden.clone(),
             hidden_layers_dims: 256,
             batch_size: 128,
             max_epochs: 1000,

tig-challenges/src/satisfiability/mod.rs

@@ -10,8 +10,8 @@ use serde::{Deserialize, Serialize};
 
 impl_kv_string_serde! {
     Track {
-        num_variables: usize,
-        clauses_to_variables_ratio: u32
+        n_vars: usize,
+        ratio: u32
     }
 }
 
@@ -39,11 +39,9 @@ pub struct Challenge {
 impl Challenge {
     pub fn generate_instance(seed: &[u8; 32], track: &Track) -> Result<Self> {
         let mut rng = SmallRng::from_seed(StdRng::from_seed(seed.clone()).gen());
-        let num_clauses = (track.num_variables as f64 * track.clauses_to_variables_ratio as f64
-            / 1000.0)
-            .floor() as usize;
+        let num_clauses = (track.n_vars as f64 * track.ratio as f64 / 1000.0).floor() as usize;
 
-        let var_distr = Uniform::new(1, track.num_variables as i32 + 1);
+        let var_distr = Uniform::new(1, track.n_vars as i32 + 1);
         // Create a uniform distribution for negations.
         let neg_distr = Uniform::new(0, 2);
 
@@ -70,7 +68,7 @@ impl Challenge {
 
         Ok(Self {
             seed: seed.clone(),
-            num_variables: track.num_variables.clone(),
+            num_variables: track.n_vars.clone(),
             clauses,
         })
     }

tig-challenges/src/vector_search/mod.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 impl_kv_string_serde! {
     Track {
-        num_queries: u32,
+        n_queries: u32,
     }
 }
 
@@ -48,7 +48,7 @@ impl Challenge {
     ) -> Result<Self> {
         let mut rng = StdRng::from_seed(seed.clone());
         let vector_dims = 250;
-        let database_size = 100 * track.num_queries;
+        let database_size = 100 * track.n_queries;
         let avg_cluster_size: f32 = 700.0;
         let num_clusters: u32 = ((1.0 + rng.gen::<f32>() * 0.05)
             + database_size as f32 / avg_cluster_size)
@@ -105,14 +105,14 @@ impl Challenge {
         let mut d_database_vectors =
             stream.alloc_zeros::<f32>((database_size * vector_dims) as usize)?;
         let mut d_query_vectors =
-            stream.alloc_zeros::<f32>((track.num_queries * vector_dims) as usize)?;
+            stream.alloc_zeros::<f32>((track.n_queries * vector_dims) as usize)?;
 
         unsafe {
             stream
                 .launch_builder(&generate_vectors_kernel)
                 .arg(&d_seed)
                 .arg(&database_size)
-                .arg(&track.num_queries)
+                .arg(&track.n_queries)
                 .arg(&vector_dims)
                 .arg(&num_clusters)
                 .arg(&d_cluster_cum_prob)
@@ -130,7 +130,7 @@ impl Challenge {
 
         return Ok(Self {
             seed: seed.clone(),
-            num_queries: track.num_queries.clone(),
+            num_queries: track.n_queries.clone(),
             vector_dims,
             database_size,
             d_database_vectors,

tig-challenges/src/vehicle_routing/mod.rs

@@ -9,7 +9,7 @@ use std::collections::{HashMap, HashSet};
 
 impl_kv_string_serde! {
     Track {
-        num_nodes: usize,
+        n_nodes: usize,
     }
 }
 
@@ -49,13 +49,13 @@ impl Challenge {
         let max_capacity = 200;
 
         let num_clusters = rng.gen_range(3..=8);
-        let mut node_positions: Vec<(i32, i32)> = Vec::with_capacity(track.num_nodes);
-        let mut node_positions_set: HashSet<(i32, i32)> = HashSet::with_capacity(track.num_nodes);
+        let mut node_positions: Vec<(i32, i32)> = Vec::with_capacity(track.n_nodes);
+        let mut node_positions_set: HashSet<(i32, i32)> = HashSet::with_capacity(track.n_nodes);
         node_positions.push((500, 500)); // Depot is node 0, and in the center
         node_positions_set.insert((500, 500));
 
         let mut cluster_assignments = HashMap::new();
-        while node_positions.len() < track.num_nodes {
+        while node_positions.len() < track.n_nodes {
             let node = node_positions.len();
             if node <= num_clusters || rng.gen::<f64>() < 0.5 {
                 let pos = (rng.gen_range(0..=1000), rng.gen_range(0..=1000));
@@ -93,9 +93,7 @@ impl Challenge {
             }
         }
 
-        let mut demands: Vec<i32> = (0..track.num_nodes)
-            .map(|_| rng.gen_range(1..=35))
-            .collect();
+        let mut demands: Vec<i32> = (0..track.n_nodes).map(|_| rng.gen_range(1..=35)).collect();
         demands[0] = 0;
 
         let distance_matrix: Vec<Vec<i32>> = node_positions
@@ -112,22 +110,22 @@ impl Challenge {
             })
             .collect();
 
-        let average_demand = demands.iter().sum::<i32>() as f64 / track.num_nodes as f64;
+        let average_demand = demands.iter().sum::<i32>() as f64 / track.n_nodes as f64;
         let average_route_size = max_capacity as f64 / average_demand;
         let average_distance = (1000.0 / 4.0) * 0.5214;
-        let furthest_node = (1..track.num_nodes)
+        let furthest_node = (1..track.n_nodes)
             .max_by_key(|&node| distance_matrix[0][node])
             .unwrap();
 
         let service_time = 10;
-        let mut ready_times = vec![0; track.num_nodes];
-        let mut due_times = vec![0; track.num_nodes];
+        let mut ready_times = vec![0; track.n_nodes];
+        let mut due_times = vec![0; track.n_nodes];
 
         // time to return to depot
         due_times[0] = distance_matrix[0][furthest_node]
             + ((average_distance + service_time as f64) * average_route_size).ceil() as i32;
 
-        for node in 1..track.num_nodes {
+        for node in 1..track.n_nodes {
             let min_due_time = distance_matrix[0][node];
             let max_due_time = due_times[0] - distance_matrix[0][node] - service_time;
             due_times[node] = rng.gen_range(min_due_time..=max_due_time);
@@ -145,7 +143,7 @@ impl Challenge {
 
         let mut c = Challenge {
             seed: seed.clone(),
-            num_nodes: track.num_nodes.clone(),
+            num_nodes: track.n_nodes.clone(),
             demands,
             node_positions,
             distance_matrix,