oxmera-tensor 0.3.0

The oxmera tensor: strided zero-copy views, broadcasting, multi-device storage (CPU + Apple Metal), the backend registry, and tape-based reverse-mode autograd.
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

//! `std::ops` sugar for tensors.
//!
//! Operators must return a value, not a `Result`, so these impls panic on
//! shape/device/dtype errors. Use the named methods (`Tensor::add`, …)
//! when the failure should be handled instead of being a bug.

use crate::tensor::Tensor;

macro_rules! binary_operator {
    ($trait:ident, $method:ident, $tensor_method:ident) => {
        impl std::ops::$trait<&Tensor> for &Tensor {
            type Output = Tensor;
            fn $method(self, rhs: &Tensor) -> Tensor {
                Tensor::$tensor_method(self, rhs)
                    .unwrap_or_else(|e| panic!(concat!("tensor ", stringify!($method), ": {}"), e))
            }
        }
        impl std::ops::$trait<Tensor> for Tensor {
            type Output = Tensor;
            fn $method(self, rhs: Tensor) -> Tensor {
                std::ops::$trait::$method(&self, &rhs)
            }
        }
        impl std::ops::$trait<&Tensor> for Tensor {
            type Output = Tensor;
            fn $method(self, rhs: &Tensor) -> Tensor {
                std::ops::$trait::$method(&self, rhs)
            }
        }
        impl std::ops::$trait<Tensor> for &Tensor {
            type Output = Tensor;
            fn $method(self, rhs: Tensor) -> Tensor {
                std::ops::$trait::$method(self, &rhs)
            }
        }
        impl std::ops::$trait<f32> for &Tensor {
            type Output = Tensor;
            fn $method(self, rhs: f32) -> Tensor {
                let rhs =
                    Tensor::scalar_on(self, rhs).unwrap_or_else(|e| panic!("scalar operand: {e}"));
                std::ops::$trait::$method(self, &rhs)
            }
        }
        impl std::ops::$trait<f32> for Tensor {
            type Output = Tensor;
            fn $method(self, rhs: f32) -> Tensor {
                std::ops::$trait::$method(&self, rhs)
            }
        }
        impl std::ops::$trait<&Tensor> for f32 {
            type Output = Tensor;
            fn $method(self, rhs: &Tensor) -> Tensor {
                let lhs =
                    Tensor::scalar_on(rhs, self).unwrap_or_else(|e| panic!("scalar operand: {e}"));
                std::ops::$trait::$method(&lhs, rhs)
            }
        }
        impl std::ops::$trait<Tensor> for f32 {
            type Output = Tensor;
            fn $method(self, rhs: Tensor) -> Tensor {
                std::ops::$trait::$method(self, &rhs)
            }
        }
    };
}

binary_operator!(Add, add, add);
binary_operator!(Sub, sub, sub);
binary_operator!(Mul, mul, mul);
binary_operator!(Div, div, div);

impl std::ops::Neg for &Tensor {
    type Output = Tensor;
    fn neg(self) -> Tensor {
        Tensor::neg(self).unwrap_or_else(|e| panic!("tensor neg: {e}"))
    }
}

impl std::ops::Neg for Tensor {
    type Output = Tensor;
    fn neg(self) -> Tensor {
        std::ops::Neg::neg(&self)
    }
}