restructure

Author: hnlearndev

src/assumptions.rs

@@ -1,2 +1,2 @@
-pub mod assumption_set;
 pub mod assumption;
+pub mod assumption_set;

src/assumptions/.~lock.assumptions.ods#

@@ -0,0 +1 @@
+,NTH-ASUS-CODING/ASUS,NTH-ASUS-CODING-LAPTOP,07.07.2025 02:32,file:///C:/Users/ASUS/AppData/Roaming/LibreOffice/4;

src/assumptions/assumption_set.rs

@@ -63,21 +63,21 @@ impl AssumptionSet {
         Ok(())
     }
 
-    pub fn import(export_file_path_str: &str) -> PolarsResult<Self> {
-        let path = Path::new(export_file_path_str);
+    pub fn import(file_path_str: &str) -> PolarsResult<Self> {
+        let path = Path::new(file_path_str);
 
         // Check if the file path exists
         if !path.exists() {
             return Err(PolarsError::ComputeError(
-                format!("Could not find file: {}", export_file_path_str).into(),
+                format!("Could not find file: {}", file_path_str).into(),
             ));
         }
 
         // Check if the file is a parquet file
         let is_ext_parquet = path.extension().map_or(false, |ext| ext == "parquet");
         if !is_ext_parquet {
             return Err(PolarsError::ComputeError(
-                format!("File is not a parquet file: {}", export_file_path_str).into(),
+                format!("File is not a parquet file: {}", file_path_str).into(),
             ));
         }
 

src/assumptions/assumptions.ods

@@ -5,7 +5,7 @@ mod prem_rate;
 mod projections;
 
 use crate::assumptions::assumption::{
-    Assumption, get_acq_exp_df, get_inf_rate_df, get_lapse_rate_df, get_load_rate_df, get_mort_df,
+    get_acq_exp_df, get_inf_rate_df, get_lapse_rate_df, get_load_rate_df, get_mort_df,
     get_mtn_exp_df, get_spot_rate_df,
 };
 
@@ -17,7 +17,7 @@ use crate::prem_rate::get_avg_prem_rate_by_age_and_term;
 
 use crate::projections::projection_runs::{project_runs_parallel, project_runs_parallel_x2};
 
-use crate::projections::projection_structs::RunSetup;
+use crate::projections::projection_runs::RunSetup;
 
 use polars::prelude::*;
 use std::time::Instant;

src/main.rs

@@ -1,4 +1,4 @@
-use crate::projections::projection_structs::RunResult;
+use crate::projections::projection_runs::RunResult;
 use polars::prelude::*;
 
 //---------------------------------------------------------------------------------------------------------

src/prem_rate.rs

@@ -1,11 +1,3 @@
 mod projection_mp;
 pub mod projection_runs;
 pub mod projection_structs;
-
-//----------------------------------------
-// Export results
-//----------------------------------------
-
-//----------------------------------------
-// Import results
-//----------------------------------------

src/projections.rs

@@ -1,20 +1,150 @@
+use crate::assumptions::assumption_set::AssumptionSet;
 use crate::model_points::{ModelPoint, convert_model_points_df_to_vector};
 use crate::projections::projection_mp::project_single_model_point;
-use crate::projections::projection_structs::{MultipleRunResult, RunResult, RunSetup};
 use polars::prelude::*;
 use rayon::prelude::*;
+use std::fs::{File, read_to_string, write};
+use std::path::Path;
+
+use crate::helpers::create_parent_folder;
+
+//---------------------------------------------------------------------------------------------------------
+// STRUCTS
+//---------------------------------------------------------------------------------------------------------
+#[derive(Clone, Debug)]
+pub struct RunSetup {
+    pub description: String, // Optional description for the run
+    pub model_points_df: DataFrame,
+    pub assumptions: AssumptionSet,
+}
+
+impl RunSetup {
+    pub fn export(&self, folder_path_str: &str) -> PolarsResult<()> {
+        // Create the folder for the run result - if not given a name, use a UUID
+        let path = Path::new(&folder_path_str);
+
+        // Create the folder if it does not exist
+        create_parent_folder(&path);
+
+        // Export description
+        let description_path = path.join("description.md");
+        let description_content = format!("{}", self.description);
+        write(&description_path, description_content)?;
+
+        // Export model points DataFrame
+        let model_points_path = path.join("model_points.parquet");
+        let mut model_points_file = File::create(model_points_path)?;
+        let mut model_points_df = self.model_points_df.clone();
+        ParquetWriter::new(&mut model_points_file).finish(&mut model_points_df)?;
+
+        // Export assumptions DataFrame
+        let assumptions_path = path.join("assumptions.parquet");
+        self.assumptions
+            .export(assumptions_path.to_str().unwrap())?;
+
+        Ok(())
+    }
+
+    pub fn import(folder_path_str: &str) -> PolarsResult<Self> {
+        let path = Path::new(folder_path_str);
+
+        // Check if the folder exists
+        if !path.exists() || !path.is_dir() {
+            return Err(PolarsError::ComputeError(
+                format!("Folder does not exist: {}", folder_path_str).into(),
+            ));
+        }
+
+        // Import description
+        let description_path = path.join("description.md");
+        let description = read_to_string(description_path)?.trim().to_string();
+
+        // Import model points DataFrame
+        let model_points_path = path.join("model_points.parquet");
+        let mut model_points_file = File::open(model_points_path)?;
+        let model_points_df = ParquetReader::new(&mut model_points_file).finish()?;
+
+        // Import assumptions DataFrame
+        let assumptions_path = path.join("assumptions.parquet");
+        let assumptions = AssumptionSet::import(assumptions_path.to_str().unwrap())?;
+
+        // Create the RunSetup instance
+        let result = RunSetup {
+            description,
+            model_points_df,
+            assumptions,
+        };
+
+        Ok(result)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct RunResult {
+    pub setup: RunSetup,
+    pub projected_df: DataFrame,
+}
+
+impl RunResult {
+    pub fn export(&self, folder_path_str: &str) -> PolarsResult<()> {
+        // Create the folder for the run result - if not given a name, use a UUID
+        let path = Path::new(&folder_path_str);
+
+        // Create the folder if it does not exist
+        create_parent_folder(&path);
+
+        // Export run_setup
+        let setup_path = path.join("run_setup");
+        self.setup.export(setup_path.to_str().unwrap())?;
+
+        // Export projected DataFrame
+        let projected_df_path = path.join("projected_df.parquet");
+        let mut projected_df_file = File::create(projected_df_path)?;
+        let mut projected_df = self.projected_df.clone();
+        ParquetWriter::new(&mut projected_df_file).finish(&mut projected_df)?;
+
+        Ok(())
+    }
+
+    pub fn import(folder_path_str: &str) -> PolarsResult<Self> {
+        let path = Path::new(folder_path_str);
+
+        // Check if the folder exists
+        if !path.exists() || !path.is_dir() {
+            return Err(PolarsError::ComputeError(
+                format!("Folder does not exist: {}", folder_path_str).into(),
+            ));
+        }
+
+        // Import run setup
+        let setup_path = path.join("run_setup");
+        let setup = RunSetup::import(setup_path.to_str().unwrap())?;
+
+        // Import projected DataFrame
+        let projected_df_path = path.join("projected_df.parquet");
+        let mut projected_df_file = File::open(projected_df_path)?;
+        let projected_df = ParquetReader::new(&mut projected_df_file).finish()?;
+
+        let result = RunResult {
+            setup: setup,
+            projected_df: projected_df,
+        };
+
+        Ok(result)
+    }
+}
 
 //---------------------------------------------------------------------------------------------------------
 // PRIVATE
 //---------------------------------------------------------------------------------------------------------
-fn _project_single_run(run_setup: &RunSetup) -> PolarsResult<RunResult> {
+fn _project_single_run(setup: &RunSetup) -> PolarsResult<RunResult> {
     // Convert model points DataFrame to vector
-    let model_points_vec = convert_model_points_df_to_vector(&run_setup.model_points_df)?;
+    let model_points_vec = convert_model_points_df_to_vector(&setup.model_points_df)?;
 
     let mut all_lfs = Vec::with_capacity(model_points_vec.len());
 
     for (_, mp) in model_points_vec.iter().enumerate() {
-        let lf = project_single_model_point(mp, &run_setup.assumptions)?;
+        let lf = project_single_model_point(mp, &setup.assumptions)?;
         all_lfs.push(lf);
     }
 
@@ -24,7 +154,7 @@ fn _project_single_run(run_setup: &RunSetup) -> PolarsResult<RunResult> {
 
     // Return the result with run setup and projected DataFrame
     let result = RunResult {
-        run_setup: run_setup.clone(),
+        setup: setup.clone(),
         projected_df: final_df,
     };
 
@@ -37,9 +167,9 @@ fn _project_single_run(run_setup: &RunSetup) -> PolarsResult<RunResult> {
 // Process data in chunks to avoid stack overflow
 const CHUNK_SIZE: usize = 100;
 
-fn _project_single_run_parallel(run_setup: &RunSetup) -> PolarsResult<RunResult> {
+fn _project_single_run_parallel(setup: &RunSetup) -> PolarsResult<RunResult> {
     // Convert model points DataFrame to vector
-    let model_points_vec = convert_model_points_df_to_vector(&run_setup.model_points_df)?;
+    let model_points_vec = convert_model_points_df_to_vector(&setup.model_points_df)?;
 
     // Process chunks of model points in parallel with limited threads
     let chunks = model_points_vec
@@ -52,7 +182,7 @@ fn _project_single_run_parallel(run_setup: &RunSetup) -> PolarsResult<RunResult>
             // Process each chunk sequentially (no nested parallelism)
             let all_lfs = chunk
                 .iter()
-                .map(|mp| project_single_model_point(mp, &run_setup.assumptions))
+                .map(|mp| project_single_model_point(mp, &setup.assumptions))
                 .collect::<PolarsResult<Vec<LazyFrame>>>()?;
 
             // Concatenate LazyFrames within the chunk and collect to DataFrame
@@ -68,7 +198,7 @@ fn _project_single_run_parallel(run_setup: &RunSetup) -> PolarsResult<RunResult>
 
     // Return the result with run setup and projected DataFrame
     let result = RunResult {
-        run_setup: run_setup.clone(),
+        setup: setup.clone(),
         projected_df: final_df,
     };
 
@@ -78,20 +208,15 @@ fn _project_single_run_parallel(run_setup: &RunSetup) -> PolarsResult<RunResult>
 //---------------------------------------------------------------------------------------------------------
 // PUBLIC
 //---------------------------------------------------------------------------------------------------------
-pub fn project_runs(run_setups: &Vec<RunSetup>) -> PolarsResult<MultipleRunResult> {
-    let mut run_results: Vec<RunResult> = Vec::with_capacity(run_setups.len()); // To collect run results
+pub fn project_runs(setups: &Vec<RunSetup>) -> PolarsResult<Vec<RunResult>> {
+    let mut results: Vec<RunResult> = Vec::with_capacity(setups.len()); // To collect run results
 
-    for (_, setup) in run_setups.iter().enumerate() {
+    for (_, setup) in setups.iter().enumerate() {
         let single_run_result = _project_single_run(setup)?;
-        run_results.push(single_run_result);
+        results.push(single_run_result);
     }
 
-    let result = MultipleRunResult {
-        run_setups: run_setups.clone(),
-        run_results: run_results,
-    };
-
-    Ok(result)
+    Ok(results)
 }
 
 //----------------------------------------
@@ -102,32 +227,22 @@ Using the below command to run the code in parallel with limited threads finish
 The test is not exhaustive, but it shows that parallel processing can significantly speed up the projection of model points.
 $env:RAYON_NUM_THREADS = 8; $env:RUST_MIN_STACK = 33554432; cargo run
 */
-pub fn project_runs_parallel(run_setups: &Vec<RunSetup>) -> PolarsResult<MultipleRunResult> {
-    let mut run_results: Vec<RunResult> = Vec::with_capacity(run_setups.len()); // To collect run results
+pub fn project_runs_parallel(setups: &Vec<RunSetup>) -> PolarsResult<Vec<RunResult>> {
+    let mut results: Vec<RunResult> = Vec::with_capacity(setups.len()); // To collect run results
 
-    for (_, setup) in run_setups.iter().enumerate() {
-        let single_run_result = _project_single_run_parallel(setup)?;
-        run_results.push(single_run_result);
+    for (_, setup) in setups.iter().enumerate() {
+        let result = _project_single_run_parallel(setup)?;
+        results.push(result);
     }
 
-    let result = MultipleRunResult {
-        run_setups: run_setups.clone(),
-        run_results: run_results,
-    };
-
-    Ok(result)
+    Ok(results)
 }
 
-pub fn project_runs_parallel_x2(run_setups: &Vec<RunSetup>) -> PolarsResult<MultipleRunResult> {
-    let run_results = run_setups
+pub fn project_runs_parallel_x2(setups: &Vec<RunSetup>) -> PolarsResult<Vec<RunResult>> {
+    let results = setups
         .par_iter()
         .map(|setup| _project_single_run_parallel(setup))
         .collect::<PolarsResult<Vec<RunResult>>>()?;
 
-    let result = MultipleRunResult {
-        run_setups: run_setups.clone(),
-        run_results: run_results,
-    };
-
-    Ok(result)
+    Ok(results)
 }