complete revise the architecture

Author: hnlearndev

src/assumptions/assumption.rs

@@ -14,7 +14,7 @@ fn _get_assumption_df(
     new_col_names: Option<&[&str]>,
 ) -> PolarsResult<DataFrame> {
     // If new_col_names is provided, ensure it matches the length of col_names
-    if let Some(ref new_names) = new_col_names {
+    if let Some(new_names) = new_col_names {
         if col_names.len() != new_names.len() {
             return Err(PolarsError::ComputeError(
                 "Length of col_names and new_col_names must match".into(),
@@ -51,8 +51,8 @@ fn _get_assumption_df(
 //---------------------------------------------------------------------------------------------------------
 // Mortality assumption: The schema is slightly different from other since it is based on gender
 pub fn get_mort_rate_df(mort_name: &str) -> PolarsResult<DataFrame> {
-    let col1 = format!("{}_m", mort_name);
-    let col2 = format!("{}_f", mort_name);
+    let col1 = format!("{mort_name}_m");
+    let col2 = format!("{mort_name}_f");
     let col_names = [col1.as_str(), col2.as_str()];
     let df = _get_assumption_df("mort_rate", &col_names, Some(&["mort_m", "mort_f"]))?;
     Ok(df)
@@ -104,7 +104,7 @@ mod tests {
         // Test reading data from the lapse_rate sheet
         let df = get_mort_rate_df("cso80");
 
-        println!("{:?}", df);
+        println!("{df:?}");
 
         assert!(true, "Assumption DataFrame should be created successfully");
     }

src/assumptions/assumption_scenario.rs

@@ -131,7 +131,7 @@ mod tests {
         // Test reading data from the mort_rate sheet
         let df = _get_assumption_scenario_df("pricing");
 
-        println!("{:?}", df);
+        println!("{df:?}");
 
         assert!(true, "Mortality DataFrame should be created successfully");
     }
@@ -142,17 +142,17 @@ mod tests {
         let df = _get_assumption_scenario_df("pricing").unwrap();
         let vec = _dataframe_to_vec_of_tuples(&df).unwrap();
 
-        println!("{:?}", vec);
+        println!("{vec:?}");
 
         assert!(!vec.is_empty(), "Vec should not be empty");
     }
 
     #[test]
-    fn test_method_AssumptionScenario_new_by_name() {
+    fn test_method_assumption_scenario_new_by_name() {
         // Test reading data from the lapse_rate sheet
         let df = AssumptionScenario::new_by_name("pricing");
 
-        println!("{:?}", df);
+        println!("{df:?}");
 
         assert!(true, "AssumptionScenario should be created successfully");
     }

src/assumptions/helpers.rs

@@ -28,15 +28,12 @@ fn _parse_cell_text(cell_str: &str) -> String {
 fn _get_header_rows(sheet: &spreadsheet_ods::Sheet) -> Vec<String> {
     let mut header: Vec<String> = Vec::new();
     let mut col_idx = 0;
-    loop {
-        if let Some(cell) = sheet.cell(0, col_idx) {
-            let cell_str = format!("{:?}", cell);
-            let name = _parse_cell_text(&cell_str);
-            header.push(name);
-            col_idx += 1;
-        } else {
-            break;
-        }
+
+    while let Some(cell) = sheet.cell(0, col_idx) {
+        let cell_str = format!("{cell:?}");
+        let name = _parse_cell_text(&cell_str);
+        header.push(name);
+        col_idx += 1;
     }
 
     header
@@ -57,7 +54,7 @@ pub fn get_indices_names_hashmap(
     let header = _get_header_rows(sheet);
 
     // Always include the first column (index 0)
-    if let Some(first_col_name) = header.get(0) {
+    if let Some(first_col_name) = header.first() {
         indices.insert(0, (first_col_name.clone(), first_col_name.clone()));
     }
 
@@ -81,7 +78,7 @@ pub fn get_indices_names_hashmap(
         }
         if !found {
             return Err(PolarsError::ComputeError(
-                format!("Column '{}' not found in sheet header", col_name).into(),
+                format!("Column '{col_name}' not found in sheet header").into(),
             ));
         }
     }
@@ -91,7 +88,7 @@ pub fn get_indices_names_hashmap(
 
 pub fn get_sheet_by_name(sheet_name: &str) -> PolarsResult<Sheet> {
     let doc = read_ods("src/assumptions/assumptions.ods")
-        .map_err(|e| PolarsError::ComputeError(format!("Failed to read ODS file: {}", e).into()))?;
+        .map_err(|e| PolarsError::ComputeError(format!("Failed to read ODS file: {e}").into()))?;
 
     for idx in 0..doc.num_sheets() {
         let wsh = doc.sheet(idx);
@@ -101,7 +98,7 @@ pub fn get_sheet_by_name(sheet_name: &str) -> PolarsResult<Sheet> {
     }
 
     Err(PolarsError::ComputeError(
-        format!("Sheet '{}' not found", sheet_name).into(),
+        format!("Sheet '{sheet_name}' not found").into(),
     ))
 }
 
@@ -115,23 +112,21 @@ pub fn parse_col_by_index_to_f64(
     let mut row_idx = 1; // Skip header
 
     let mut col_data = Vec::new();
-    loop {
-        if let Some(cell_content) = sheet.cell(row_idx, col_idx as u32) {
-            let cell_str = format!("{:?}", cell_content);
-
-            let val = if cell_str.contains("Number(") {
-                let start = cell_str.find("Number(").unwrap_or(0) + 7;
-                let end = cell_str.rfind(")").unwrap_or(cell_str.len());
-                cell_str[start..end].parse::<f64>().unwrap_or(0.0)
-            } else {
-                0.0
-            };
-            col_data.push(val);
-            row_idx += 1;
+
+    while let Some(cell_content) = sheet.cell(row_idx, col_idx as u32) {
+        let cell_str = format!("{cell_content:?}");
+
+        let val = if cell_str.contains("Number(") {
+            let start = cell_str.find("Number(").unwrap_or(0) + 7;
+            let end = cell_str.rfind(")").unwrap_or(cell_str.len());
+            cell_str[start..end].parse::<f64>().unwrap_or(0.0)
         } else {
-            break;
-        }
+            0.0
+        };
+        col_data.push(val);
+        row_idx += 1;
     }
+
     Ok(col_data)
 }
 
@@ -146,36 +141,34 @@ pub fn parse_col_by_index_to_string(sheet: &Sheet, col_idx: usize) -> PolarsResu
     let mut row_idx = 1; // Skip header
 
     let mut col_data = Vec::new();
-    loop {
-        if let Some(cell_content) = sheet.cell(row_idx, col_idx as u32) {
-            let cell_str = format!("{:?}", cell_content);
 
-            // Extract the text value from the cell string
-            let val = if cell_str.contains("Text(") {
-                let start = cell_str.find("Text(").unwrap_or(0) + 5;
+    while let Some(cell_content) = sheet.cell(row_idx, col_idx as u32) {
+        let cell_str = format!("{cell_content:?}");
 
-                let end = if let Some(style_pos) = cell_str.find("), style:") {
-                    style_pos
-                } else {
-                    cell_str.rfind(")").unwrap_or(cell_str.len())
-                };
-
-                let extracted = &cell_str[start..end];
+        // Extract the text value from the cell string
+        let val = if cell_str.contains("Text(") {
+            let start = cell_str.find("Text(").unwrap_or(0) + 5;
 
-                // Remove quotes if present
-                if extracted.starts_with('"') && extracted.ends_with('"') {
-                    extracted[1..extracted.len() - 1].to_string()
-                } else {
-                    extracted.to_string()
-                }
+            let end = if let Some(style_pos) = cell_str.find("), style:") {
+                style_pos
             } else {
-                cell_str
+                cell_str.rfind(")").unwrap_or(cell_str.len())
             };
-            col_data.push(val);
-            row_idx += 1;
+
+            let extracted = &cell_str[start..end];
+
+            // Remove quotes if present
+            if extracted.starts_with('"') && extracted.ends_with('"') {
+                extracted[1..extracted.len() - 1].to_string()
+            } else {
+                extracted.to_string()
+            }
         } else {
-            break;
-        }
+            cell_str
+        };
+        col_data.push(val);
+        row_idx += 1;
     }
+
     Ok(col_data)
 }

src/main.rs

@@ -5,8 +5,7 @@ mod projections;
 
 use crate::assumptions::assumption_scenario::AssumptionScenario;
 use crate::model_points::generate_model_points;
-use crate::prem_rate::get_avg_prem_rate_by_age_and_term;
-use crate::projections::projection_multi_runs::{RunsResult, RunsSetup};
+use crate::projections::projection_multi_runs::RunsSetup;
 use crate::projections::projection_single_run::SingleRunSetup;
 
 use polars::prelude::*;

src/model_points.rs

@@ -43,15 +43,15 @@ pub fn generate_model_points(mp_size: usize, seed: usize) -> PolarsResult<DataFr
     // Sum insured (Float): Random values between 100,000 and 1,000,000 (multiple of 1000)
     let sum_insured =
         Array1::random_using(mp_size, Uniform::new(0.0f64, 1.0f64), &mut rng) // Random floats between 0 and 1
-            .mapv(|x| (((900_000.0 * x + 100_000.0) / 1000.0).round() * 1000.0) as f64);
+            .mapv(|x| (((900_000.0 * x + 100_000.0) / 1000.0).round() * 1000.0));
 
     // Create a DataFrame with the generated data
     let model_points_df = df![
         "id"  => (1..(mp_size+1) as i32).collect::<Vec<i32>>(),
         "entry_age" => entry_age.to_vec(),
         "gender" => gender,
         "term" => term.to_vec(),
-        "policy_count" => policy_count.to_vec().into_iter().map(|x| x as f64).collect::<Vec<f64>>(),
+        "policy_count" => policy_count.to_vec().into_iter().collect::<Vec<f64>>(),
         "sum_insured" => sum_insured.to_vec(),
     ]?;
 

src/prem_rate.rs

@@ -4,6 +4,7 @@ use polars::prelude::*;
 //---------------------------------------------------------------------------------------------------------
 // PUBLIC
 //---------------------------------------------------------------------------------------------------------
+#[allow(dead_code)]
 pub fn get_avg_prem_rate_by_age_and_term(run_result: &SingleRunResult) -> PolarsResult<DataFrame> {
     let proj_df = run_result.projected_df.clone();
 

src/projections/helpers.rs

@@ -13,11 +13,9 @@ pub fn create_folder(path: &Path) {
                 }
             }
         }
-    } else {
-        if !path.exists() {
-            if let Err(e) = create_dir_all(path) {
-                panic!("Failed to create folder {}: {}", path.display(), e);
-            }
+    } else if !path.exists() {
+        if let Err(e) = create_dir_all(path) {
+            panic!("Failed to create folder {}: {}", path.display(), e);
         }
     }
 }

src/projections/projection_mp.rs

@@ -48,7 +48,7 @@ fn __map_mort_assumption(
         .find(|&col| col.ends_with(&suffix))
         .ok_or_else(|| {
             PolarsError::ComputeError(
-                format!("Mortality column with suffix '{}' not found", suffix).into(),
+                format!("Mortality column with suffix '{suffix}' not found").into(),
             )
         })?
         .as_str();

src/projections/projection_multi_runs.rs

@@ -19,6 +19,7 @@ pub struct RunsSetup {
     pub setups: Vec<SingleRunSetup>, // Vector of run setups
 }
 
+#[allow(dead_code)]
 impl RunsSetup {
     pub fn get_run_setup_count(&self) -> usize {
         self.setups.len()
@@ -42,6 +43,7 @@ pub struct RunsResult {
     pub results: Vec<SingleRunResult>, // Vector of run results
 }
 
+#[allow(dead_code)]
 impl RunsResult {
     pub fn get_run_result_count(&self) -> usize {
         self.results.len()
@@ -78,7 +80,7 @@ impl RunsResult {
         let path = Path::new(&folder_path_str);
 
         // Create the folder if it does not exist
-        create_folder(&path);
+        create_folder(path);
 
         // Export description
         let description_content = serde_json::json!({
@@ -93,7 +95,7 @@ impl RunsResult {
 
         // Loop over each run result and export it
         for (i, result) in self.results.iter().enumerate() {
-            let run_path = path.join(format!("run_{}", i)); // Export each run result
+            let run_path = path.join(format!("run_{i}")); // Export each run result
             create_folder(&run_path); // Create the folder for the run
             result.export(run_path.to_str().unwrap())?; // Export run setup
         }
@@ -107,7 +109,7 @@ impl RunsResult {
         // Check if the folder exists
         if !path.exists() || !path.is_dir() {
             return Err(PolarsError::ComputeError(
-                format!("Folder does not exist: {}", folder_path_str).into(),
+                format!("Folder does not exist: {folder_path_str}").into(),
             ));
         }
 
@@ -117,7 +119,7 @@ impl RunsResult {
         let info_content = read_to_string(info)?;
 
         let info_json: serde_json::Value = serde_json::from_str(&info_content)
-            .map_err(|e| PolarsError::ComputeError(format!("serde_json error: {}", e).into()))?;
+            .map_err(|e| PolarsError::ComputeError(format!("serde_json error: {e}").into()))?;
 
         let description = info_json["description"]
             .as_str()
@@ -130,14 +132,14 @@ impl RunsResult {
         let mut results: Vec<SingleRunResult> = Vec::with_capacity(vec_len); // Preallocate capacity for results
 
         for i in 0..vec_len {
-            let run_path = path.join(format!("run_{}", i));
+            let run_path = path.join(format!("run_{i}"));
             let result = SingleRunResult::import(run_path.to_str().unwrap())?;
             results.push(result);
         }
 
         let result = RunsResult {
-            description: description,
-            results: results,
+            description,
+            results,
         };
 
         Ok(result)
@@ -163,7 +165,7 @@ fn _project_runs(
 
     let runs = RunsResult {
         description: description.unwrap_or_default().to_string(),
-        results: results,
+        results,
     };
 
     Ok(runs)