closure-core 1.0.0

CLOSURE: complete listing of original samples of underlying raw evidence
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125


// mod write_csv;
// use write_csv::write_closure_csv;

use std::io::Result;
use std::fs::File;
use std::env;
use std::io;

use csv::WriterBuilder;
use indicatif::{ProgressBar, ProgressStyle};

use closure_core::{dfs_parallel, count_initial_combinations};


fn main() -> std::io::Result<()> {
    println!("Running test harness...");
    
    // Call library function to test
    write_closure_csv(
        3.5,
        0.5,
        52,
        1,
        5,
        0.05,
        0.05,
        "parallel_results.csv"
    )?;
    
    println!("Test completed successfully");
    Ok(())
}



/// Write CLOSURE results to disk with progress tracking
fn write_closure_csv(
    mean: f64,
    sd: f64,
    n: usize,
    scale_min: i32,
    scale_max: i32,
    rounding_error_mean: f64,
    rounding_error_sd: f64,
    output_file: &str,
) -> Result<()> {

    let mut cwd = String::new();

    // Record working directory
    match get_current_dir() {
        Ok(path) => cwd = path,
        Err(e) => {
            eprintln!("Error getting current directory: {}", e);
        }
    }

    // Setup progress bar
    let initial_count = count_initial_combinations(scale_min, scale_max);
    let bar = ProgressBar::new(initial_count as u64);
    bar.set_style(
        ProgressStyle::default_bar()
            .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} Computing...")
            .unwrap()
            .progress_chars("=>-")
    );

    // Compute results (only this part is timed)
    let result = dfs_parallel(
        mean,
        sd,
        n,
        scale_min.try_into().unwrap(),
        scale_max.try_into().unwrap(),
        rounding_error_mean,
        rounding_error_sd,
    );
    
    // Initialize CSV file
    let file = File::create(output_file)?;
    let mut writer = WriterBuilder::new()
        .has_headers(true)
        .from_writer(file);

    // Write header
    let header: Vec<String> = (1..=n).map(|i| format!("n{}", i)).collect();
    writer.write_record(&header)?;

    // Write combinations with progress updates
    let chunk_size = if result.len() >= 100 {
        result.len() / 100  // Update every 1%
    } else {
        1  // Update for every combination if fewer than 100
    };
    
    for (i, combination) in result.iter().enumerate() {
        writer.write_record(
            &combination
                .iter()
                .map(|x| x.to_string())
                .collect::<Vec<String>>()
        )?;
        
        if i % chunk_size == 0 {
            bar.inc(1);
        }
    }

    bar.finish_with_message("Done!");
    
    println!("Number of valid combinations: {}", result.len());
    println!("Wrote result file: {}", cwd.clone() + "/" + output_file);

    Ok(())
}



fn get_current_dir() -> io::Result<String> {
    let path = env::current_dir()?;
    path.into_os_string()
        .into_string()
        .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Invalid UTF-8 in path"))
}