hpt-common 0.1.3

An internal library for common utilities for hpt
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
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::{
    shape::shape::Shape, strides::strides::Strides, strides::strides_utils::shape_to_strides,
};

/// `Layout` stores the `shape` and `strides` of a tensor
///
/// this struct is being used `internally` by the library
///
/// it is also widely being used to perform shape and strides related operations such as `reshape`, `permute`, `broadcast`, `reduce`, etc.
#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
pub struct Layout {
    /// the shape of the tensor
    pub(crate) shape: Shape,
    /// the strides of the tensor
    pub(crate) strides: Strides,
}

impl Layout {
    /// create a new `Layout` instance
    ///
    /// # Arguments
    ///
    /// * `shape` - any type implemented `Into<Shape> for T` or `From<T> for Shape`
    /// * `strides` - any type implemented `Into<Strides> for T` or `From<T> for Strides`
    ///
    /// # Panics
    ///
    /// if the length of `shape` and `strides` is not equal
    pub fn new<A: Into<Shape>, B: Into<Strides>>(shape: A, strides: B) -> Self {
        let shape = shape.into();
        let strides = strides.into();
        assert_eq!(shape.len(), strides.len());
        Layout { shape, strides }
    }

    /// Returns the shape of the layout
    pub fn shape(&self) -> &Shape {
        &self.shape
    }

    /// Set the shape of the layout
    pub fn set_shape(&mut self, shape: Shape) {
        self.shape = shape;
    }

    /// Returns the strides of the layout
    pub fn strides(&self) -> &Strides {
        &self.strides
    }

    /// Set the strides of the layout
    pub fn set_strides(&mut self, strides: Strides) {
        self.strides = strides;
    }

    /// Returns the number of dimensions of the layout
    pub fn ndim(&self) -> usize {
        self.shape.len()
    }
}

// Implementing the From trait for the `Layout` struct, when the user pass any of the following types, it will be converted to `Layout` automatically

impl From<Shape> for Layout {
    /// internally, it will call `shape_to_strides` to calculate the strides
    ///
    /// # See Also
    /// - [shape_to_strides](crate::strides::strides_utils::shape_to_strides)
    fn from(shape: Shape) -> Self {
        let strides = shape_to_strides(&shape);
        Layout { shape, strides }
    }
}

impl From<&Shape> for Layout {
    /// internally, it will call `shape_to_strides` to calculate the strides
    ///
    /// # See Also
    /// - [shape_to_strides](crate::strides::strides_utils::shape_to_strides)
    fn from(shape: &Shape) -> Self {
        let strides = shape_to_strides(shape);
        Layout {
            shape: shape.clone(),
            strides,
        }
    }
}

impl From<(Shape, Strides)> for Layout {
    fn from((shape, strides): (Shape, Strides)) -> Self {
        Layout { shape, strides }
    }
}

impl From<(Shape, Vec<i64>)> for Layout {
    fn from((shape, strides): (Shape, Vec<i64>)) -> Self {
        Layout {
            shape,
            strides: strides.into(),
        }
    }
}

impl From<(&Shape, Vec<i64>)> for Layout {
    fn from((shape, strides): (&Shape, Vec<i64>)) -> Self {
        Layout {
            shape: shape.into(),
            strides: strides.into(),
        }
    }
}

impl From<(&Shape, &[i64])> for Layout {
    fn from((shape, strides): (&Shape, &[i64])) -> Self {
        Layout {
            shape: shape.into(),
            strides: strides.into(),
        }
    }
}

impl From<&(Shape, Strides)> for Layout {
    fn from((shape, strides): &(Shape, Strides)) -> Self {
        Layout {
            shape: shape.clone(),
            strides: strides.clone(),
        }
    }
}

impl From<&Layout> for Layout {
    fn from(layout: &Layout) -> Self {
        Layout {
            shape: layout.shape.clone(),
            strides: layout.strides.clone(),
        }
    }
}

impl From<(&Shape, &Strides)> for Layout {
    fn from((shape, strides): (&Shape, &Strides)) -> Self {
        Layout {
            shape: shape.clone(),
            strides: strides.clone(),
        }
    }
}