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

use super::GenTensor;
use crate::tensor_trait::rand::Random;

use rand::prelude::*;
use rand::Rng;
use rand_distr::{Normal, Uniform, Distribution, StandardNormal};

impl<T> Random for GenTensor<T>
where T: num_traits::Float + rand_distr::uniform::SampleUniform,
      StandardNormal: Distribution<T> {
    type TensorType = GenTensor<T>;
    type ElementType = T;

    fn rand_usize(rng: &mut StdRng,
                dim: &[usize],
                left: usize, right: usize) -> Self::TensorType {
        let elem = dim.iter().product();
        
        let mut dta = Vec::<Self::ElementType>::with_capacity(elem);
        for _i in 0..elem {
            let v: usize = rng.gen_range(left..right);
            dta.push(T::from(v).unwrap());
        }
        GenTensor::new_raw(&dta, dim)
    }

    fn bernoulli() -> Self::TensorType {
        unimplemented!();
    }
    fn cauchy() -> Self::TensorType {
        unimplemented!();
    }
    fn exponential() -> Self::TensorType {
        unimplemented!();
    }
    fn geometric() -> Self::TensorType {
        unimplemented!();
    }
    fn log_normal() -> Self::TensorType {
        unimplemented!();
    }
    fn normal(rng: &mut StdRng,
              dim: &[usize],
              mean: Self::ElementType,
              std: Self::ElementType) -> Self::TensorType {
        let elem = dim.iter().product();
        
        let mut dta = Vec::<Self::ElementType>::with_capacity(elem);
        let normal = Normal::<Self::ElementType>::new(mean, std).expect("");
        for _i in 0..elem {
            dta.push(normal.sample(rng));
        }
        GenTensor::new_raw(&dta, dim)
    }
    fn uniform(rng: &mut StdRng,
               dim: &[usize],
               from: Self::ElementType,
               to: Self::ElementType) -> Self::TensorType {
        let elem: usize = dim.iter().product();

        let mut dta = Vec::<Self::ElementType>::with_capacity(elem);
        let normal = Uniform::<Self::ElementType>::new(from, to);
        for _i in 0..elem {
            dta.push(normal.sample(rng));
        }
        GenTensor::new_raw(&dta, dim)
    }
}


#[cfg(test)]
mod tests {
    use super::*;
    use crate::tensor_trait::compare_tensor::CompareTensor;

    #[test]
    fn normalize_unit() {
        let mut rng = StdRng::seed_from_u64(671);
        let m = GenTensor::<f64>::uniform(&mut rng, &[2,2], 0., 10.);
        assert!(GenTensor::<f64>::fill(10., &[2,2]).sub(&m).all(&|x| x > 0. && x < 10.));
    }
}