acyclib 0.3.0

ML library for directed acyclic tensor graphs.
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

use std::fmt;

#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub struct Shape {
    rows: usize,
    cols: usize,
}

impl fmt::Display for Shape {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} x {}", self.rows, self.cols)
    }
}

impl fmt::Debug for Shape {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}x{}", self.rows, self.cols)
    }
}

impl std::ops::Mul<Shape> for Shape {
    type Output = Shape;
    fn mul(self, rhs: Shape) -> Self::Output {
        self.matmul(rhs).unwrap()
    }
}

impl Shape {
    pub fn matmul(self, rhs: Shape) -> Option<Self> {
        let shape = Self { cols: rhs.cols, rows: self.rows };
        (self.cols == rhs.rows).then_some(shape)
    }

    pub fn new(rows: usize, cols: usize) -> Self {
        assert!(cols > 0, "Cannot have 0 columns!");
        assert!(rows > 0, "Cannot have 0 rows!");
        Self { cols, rows }
    }

    pub fn transpose(&self) -> Self {
        Self { cols: self.rows, rows: self.cols }
    }

    pub fn maybe_transpose(&self, trans: bool) -> Self {
        if trans { self.transpose() } else { *self }
    }

    pub fn cols(&self) -> usize {
        self.cols
    }

    pub fn rows(&self) -> usize {
        self.rows
    }

    pub fn size(&self) -> usize {
        self.cols * self.rows
    }
}