burn-tensor 0.1.0

This library provides multiple tensor implementations hidden behind an easy to use API that supports reverse mode automatic differentiation. 
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

use crate::tensor::{backend::ndarray::NdArrayTensor, ops::*, Data, Distribution, Shape};
use ndarray::{Dim, Dimension};
use rand::distributions::{uniform::SampleUniform, Standard};

impl<P, const D: usize> TensorCreationLike<P, D> for NdArrayTensor<P, D>
where
    P: std::fmt::Debug + SampleUniform + Default + Clone + Zeros<P> + Ones<P>,
    Standard: rand::distributions::Distribution<P>,
{
    fn new_like_empty(&self) -> Self {
        self.new_like_zeros()
    }

    fn new_like_random(&self, distribution: Distribution<P>) -> Self {
        let data = Data::<P, D>::random(self.shape.clone(), distribution);
        Self::from_data(data)
    }

    fn new_like_data(&self, data: Data<P, D>) -> Self {
        Self::from_data(data)
    }

    fn new_like_zeros(&self) -> Self {
        self.zeros()
    }

    fn new_like_ones(&self) -> Self {
        self.ones()
    }
}

impl<P, const D: usize, const D2: usize> TensorCreationFork<P, D, D2, NdArrayTensor<P, D2>>
    for NdArrayTensor<P, D>
where
    P: std::fmt::Debug + SampleUniform + Default + Clone + Zeros<P> + Ones<P>,
    Dim<[usize; D2]>: Dimension,
    Standard: rand::distributions::Distribution<P>,
{
    fn new_fork_empty(&self, shape: Shape<D2>) -> NdArrayTensor<P, D2> {
        self.new_fork_zeros(shape)
    }

    fn new_fork_random(
        &self,
        shape: Shape<D2>,
        distribution: Distribution<P>,
    ) -> NdArrayTensor<P, D2> {
        let data = Data::<P, D2>::random(shape, distribution);
        NdArrayTensor::from_data(data)
    }

    fn new_fork_data(&self, data: Data<P, D2>) -> NdArrayTensor<P, D2> {
        NdArrayTensor::from_data(data)
    }

    fn new_fork_zeros(&self, shape: Shape<D2>) -> NdArrayTensor<P, D2> {
        let data = Data::<P, D2>::zeros(shape);
        NdArrayTensor::from_data(data)
    }

    fn new_fork_ones(&self, shape: Shape<D2>) -> NdArrayTensor<P, D2> {
        let data = Data::<P, D2>::ones(shape);
        NdArrayTensor::from_data(data)
    }
}

impl<P, const D: usize> Zeros<NdArrayTensor<P, D>> for NdArrayTensor<P, D>
where
    P: Default + Clone + Zeros<P> + std::fmt::Debug,
{
    fn zeros(&self) -> NdArrayTensor<P, D> {
        let data = Data::<P, D>::zeros(self.shape.clone());
        Self::from_data(data)
    }
}

impl<P, const D: usize> Ones<NdArrayTensor<P, D>> for NdArrayTensor<P, D>
where
    P: Default + Clone + Ones<P> + std::fmt::Debug,
{
    fn ones(&self) -> NdArrayTensor<P, D> {
        let data = Data::<P, D>::ones(self.shape.clone());
        Self::from_data(data)
    }
}