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

use std::{
    ops::{Deref, DerefMut},
    sync::Arc,
};

/// Represents the strides of a multi-dimensional structure, such as a tensor or an array.
///
/// Strides are used to calculate the memory offset of an element in a multi-dimensional structure.
///
/// for a strides of `[1, 2, 3]`, we can access the 1st dimension element by adding 1 memory offset,
///
/// the 2nd dimension element by adding 2 memory offset, and the 3rd dimension element by adding 3 memory offset.
///
/// # Example
/// ```
/// use hpt_common::strides::strides::Strides;
/// let strides = strides::strides::from(&[1, 2, 3]);
/// assert_eq!(strides.inner(), &[1, 2, 3]);
/// ```
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Strides {
    /// inner data of the strides
    pub(crate) inner: Arc<Vec<i64>>,
}

impl Strides {
    /// Returns inner reference of the inner vector
    ///
    /// # Returns
    ///
    /// `&Vec<i64>`
    pub fn inner(&self) -> &Vec<i64> {
        &self.inner
    }
    /// Returns inner reference of the inner vector
    ///
    /// # Returns
    ///
    /// `&Arc<Vec<i64>>`
    pub fn inner_(&self) -> &Arc<Vec<i64>> {
        &self.inner
    }

    /// Returns a pointer to the inner data
    pub fn as_ptr(&self) -> *const i64 {
        self.inner.as_ptr()
    }
}

impl std::fmt::Debug for Strides {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("strides({:?})", self.inner))
    }
}

impl std::fmt::Display for Strides {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("strides({:?})", self.inner))
    }
}

impl From<Arc<Vec<i64>>> for Strides {
    fn from(v: Arc<Vec<i64>>) -> Self {
        Strides { inner: v }
    }
}

impl From<Vec<i64>> for Strides {
    fn from(v: Vec<i64>) -> Self {
        Strides { inner: Arc::new(v) }
    }
}

impl From<&[i64]> for Strides {
    fn from(v: &[i64]) -> Self {
        Strides {
            inner: Arc::new(v.to_vec()),
        }
    }
}

impl<const N: usize> From<[i64; N]> for Strides {
    fn from(v: [i64; N]) -> Self {
        Strides {
            inner: Arc::new(v.to_vec()),
        }
    }
}

impl<'a, const N: usize> From<&'a [i64; N]> for Strides {
    fn from(v: &'a [i64; N]) -> Self {
        Strides {
            inner: Arc::new(v.to_vec()),
        }
    }
}

impl<'a> From<&'a Vec<i64>> for Strides {
    fn from(v: &'a Vec<i64>) -> Self {
        Strides {
            inner: Arc::new(v.clone()),
        }
    }
}

impl<'a> From<&'a Arc<Vec<i64>>> for Strides {
    fn from(v: &'a Arc<Vec<i64>>) -> Self {
        Strides {
            inner: Arc::clone(v),
        }
    }
}

impl<const N: usize> From<Arc<[i64; N]>> for Strides {
    fn from(v: Arc<[i64; N]>) -> Self {
        Strides {
            inner: Arc::new(v.to_vec()),
        }
    }
}

impl Default for Strides {
    fn default() -> Self {
        Strides {
            inner: Arc::new(Vec::new()),
        }
    }
}

impl Deref for Strides {
    type Target = Vec<i64>;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl DerefMut for Strides {
    fn deref_mut(&mut self) -> &mut Self::Target {
        Arc::make_mut(&mut self.inner)
    }
}