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

#![allow(unused_parens)]
#![allow(non_snake_case)]

use arrayfire;
use RayBNN_DataLoader;

const BACK_END: arrayfire::Backend = arrayfire::Backend::CUDA;
const DEVICE: i32 = 0;


use rayon::prelude::*;

use std::collections::HashMap;


#[test]
fn test_round() {
    arrayfire::set_backend(BACK_END);
    arrayfire::set_device(DEVICE);


    let value =  RayBNN_DataLoader::Dataset::Round::rscalar(31.12356234, 4);

    assert_eq!(value, 31.1236);








    let value =  RayBNN_DataLoader::Dataset::Round::rscalar(0.231543275, 6);

    assert_eq!(value, 0.231543);







    let value =  RayBNN_DataLoader::Dataset::Round::rscalar(254123.21232, 2);

    assert_eq!(value, 254123.21);














    let vec0: Vec<f64> = vec![324.34156354, 7.34398734, 0.231243538, -0.3412443];
    let vec1 =  RayBNN_DataLoader::Dataset::Round::rvector(&vec0, 4);

    let vec2: Vec<f64> = vec![324.3416, 7.344, 0.2312, -0.3412];
    assert_eq!(vec1, vec2 );






    let max_iter = 1000000;
    let mut total_sum = 0.0;
    for zz in 0..max_iter
    {
        let rand_number = RayBNN_DataLoader::Dataset::Random::single_random_uniform();

        assert!(rand_number >= 0.0 );
        assert!(1.0 >= rand_number);

        total_sum = total_sum + rand_number;
    }

    assert!( (max_iter as f64)/1.8  >= total_sum);
    assert!(total_sum >= (max_iter as f64)/2.2 );

    //println!("total_sum {}", total_sum);








    let max_num = 6;
    let max_iter = max_num*10000;

    let mut  zero_vec = vec![0u64; max_num as usize];

    for qq in 0..max_iter
    {

        let rand_num =  RayBNN_DataLoader::Dataset::Random::random_uniform_range(max_num);

        zero_vec[rand_num as usize] = zero_vec[rand_num as usize] + 1;
        //println!("rand_num {}",rand_num);

        assert!( rand_num <  max_num  );
        assert!( 0 <= max_num );
    }

    for vv in 0..max_num
    {
        assert!( zero_vec[vv as usize]  >  3000 );
        //println!("vv {}  {}",vv, zero_vec[vv as usize]);
    }

}