RayBNN_DataLoader 2.0.3

Read CSV, numpy, and binary files to Rust vectors of f16, f32, f64, u8, u16, u32, u64, i8, i16, i32, i64
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
126
127
128
129
130
131
132
133
134
135
136
137

use arrayfire;


use rayon::prelude::*;


use std::fs;

use std::collections::HashMap;

use std::fs::File;
use std::io::Write;



use std::io::{self, BufRead};
use std::path::Path;


fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
where P: AsRef<Path>, {
    let file = File::open(filename)?;
    Ok(io::BufReader::new(file).lines())
}






pub fn read(
	filename: &str,

    modeldata_string: &mut HashMap<String, String>,
	modeldata_float: &mut HashMap<String, f64>,
    modeldata_int: &mut HashMap<String, u64>,
	)
{

	if let Ok(lines) = read_lines(filename) {
        // Consumes the iterator, returns an (Optional) String
        for line in lines {
            if let Ok(data) = line {
				if data.contains("#")
				{
					continue;
				}

				if data.contains(":") == false
				{
					continue;
				}

				if data.contains("'")
				{
					let datasplit: Vec<&str> = data.split(":").collect();
					let key = datasplit[0].clone().to_string();

					let mut value = datasplit[1].clone().to_string();

					let datasplit: Vec<&str> = value.split("'").collect();

					value = datasplit[1].clone().to_string();

					//println!("key V{}V",key);
					//println!("value V{}V",value);
					modeldata_string.insert(key.clone(), value.clone());
				}
				else if data.contains(".")
				{
					let datasplit: Vec<&str> = data.split(":").collect();
					let key = datasplit[0].clone().to_string();

					let mut value = datasplit[1].clone().to_string();
					value = value.replace(" ", "");

					let value = value.parse::<f64>().unwrap();

					modeldata_float.insert(key.clone(), value.clone());
				}
				else 
				{
					let datasplit: Vec<&str> = data.split(":").collect();
					let key = datasplit[0].clone().to_string();

					let mut value = datasplit[1].clone().to_string();
					value = value.replace(" ", "");

					let value = value.parse::<u64>().unwrap();

					modeldata_int.insert(key.clone(), value.clone());
				}


            }
        }
    }

}





pub fn write(
	filename: &str,

    modeldata_string: &HashMap<String, String>,
	modeldata_float: &HashMap<String, f64>,
    modeldata_int: &HashMap<String, u64>,
	)
{
	let mut strvec: Vec<String> = Vec::new();

	for (key, value) in modeldata_int {
		let tmp = format!("{}: {}\n", key.clone(), value.clone());
		strvec.push(tmp.clone());
	}

	for (key, value) in modeldata_float {
		let tmp = format!("{}: {}\n", key.clone(), value.clone());
		strvec.push(tmp.clone());
	}

	for (key, value) in modeldata_string {
		let tmp = format!("{}: '{}'\n", key.clone(), value.clone());
		strvec.push(tmp.clone());
	}

	let tmpstr: String = strvec.into_par_iter().collect::<String>();


	let mut file0 = File::create(filename).unwrap();
	writeln!(file0, "{}", tmpstr);
}