tf_idf_vectorizer/utils/
normalizer.rs

1use num::Num;
2
3/// 数値をMAX - min もしくは0.0 - 1.0に正規化するためのトレイト
4pub trait IntoNormalizer<N> 
5where N: Num
6{
7    /// MAX - 0 もしくは0.0 - 1.0の範囲で変換
8    fn into_normalized(self) -> N;
9}
10
11pub trait NormalizedMultiply
12where Self: Num
13{
14    /// 正規化された値を計算するメソッド
15    ///
16    /// # Arguments
17    /// * `self` - 自身の値
18    /// * `other` - 他の値
19    /// 
20    /// # Returns
21    /// * `N` - 正規化された値
22    fn mul_normalized(self, other: Self) -> Self;
23
24}
25
26pub trait NormalizedBounded
27where Self: Num
28{
29    /// 正規化された最小値を計算するメソッド
30    ///     
31    /// # Arguments
32    /// * `self` - 自身の値
33    ///
34    /// # Returns
35    /// * `N` - 正規化された最小値
36    fn min_normalized() -> Self;
37
38    /// 正規化された最大値を計算するメソッド
39    /// 
40    /// # Arguments
41    /// * `self` - 自身の値
42    /// 
43    /// # Returns
44    /// * `N` - 正規化された最大値
45    fn max_normalized() -> Self;
46}
47
48impl IntoNormalizer<u16> for f64 {
49    #[inline]
50    fn into_normalized(self) -> u16 {
51        (self * u16::MAX as f64) as u16
52    }
53}
54
55impl IntoNormalizer<u8> for f64 {
56    #[inline]
57    fn into_normalized(self) -> u8 {
58        (self * u8::MAX as f64) as u8
59    }
60}
61
62impl IntoNormalizer<u32> for f64 {
63    #[inline]
64    fn into_normalized(self) -> u32 {
65        (self * u32::MAX as f64) as u32
66    }
67}
68
69impl IntoNormalizer<u64> for f64 {
70    #[inline]
71    fn into_normalized(self) -> u64 {
72        (self * u64::MAX as f64) as u64
73    }
74}
75
76impl IntoNormalizer<u128> for f64 {
77    #[inline]
78    fn into_normalized(self) -> u128 {
79        (self * u128::MAX as f64) as u128
80    }
81}
82
83impl IntoNormalizer<f32> for f64 {
84    #[inline]
85    fn into_normalized(self) -> f32 {
86        self as f32
87    }
88}
89
90impl IntoNormalizer<f64> for f64 {
91    #[inline]
92    fn into_normalized(self) -> f64 {
93        self
94    }
95}
96
97impl IntoNormalizer<i8> for f64 {
98    #[inline]
99    fn into_normalized(self) -> i8 {
100        (self * i8::MAX as f64) as i8
101    }
102}
103
104impl IntoNormalizer<i16> for f64 {
105    #[inline]
106    fn into_normalized(self) -> i16 {
107        (self * i16::MAX as f64) as i16
108    }
109}
110
111impl IntoNormalizer<i32> for f64 {
112    #[inline]
113    fn into_normalized(self) -> i32 {
114        (self * i32::MAX as f64) as i32
115    }
116}
117
118impl IntoNormalizer<i64> for f64 {
119    #[inline]
120    fn into_normalized(self) -> i64 {
121        (self * i64::MAX as f64) as i64
122    }
123}
124
125impl IntoNormalizer<i128> for f64 {
126    #[inline]
127    fn into_normalized(self) -> i128 {
128        (self * i128::MAX as f64) as i128
129    }
130}
131
132impl IntoNormalizer<isize> for f64 {
133    #[inline]
134    fn into_normalized(self) -> isize {
135        (self * isize::MAX as f64) as isize
136    }
137}
138
139impl IntoNormalizer<usize> for f64 {
140    #[inline]
141    fn into_normalized(self) -> usize {
142        (self * usize::MAX as f64) as usize
143    }
144}
145
146impl NormalizedMultiply for f64 {
147    #[inline]
148    fn mul_normalized(self, other: Self) -> Self {
149        self * other
150    }
151}
152
153impl NormalizedMultiply for f32 {
154    #[inline]
155    fn mul_normalized(self, other: Self) -> Self {
156        self * other
157    }
158}
159
160impl NormalizedMultiply for u8 {
161    #[inline]
162    fn mul_normalized(self, other: Self) -> Self {
163        const U8_UNITUP: u16 = u8::MAX as u16 - 1;
164        let prod: u16 = self as u16 * other as u16;
165        ((prod + U8_UNITUP) >> 8) as u8
166    }
167}
168
169impl NormalizedMultiply for u16 {
170    #[inline]
171    fn mul_normalized(self, other: Self) -> Self {
172        const U16_UNITUP: u32 = u16::MAX as u32 - 1;
173        let prod: u32 = self as u32 * other as u32;
174        ((prod + U16_UNITUP) >> 16) as u16
175    }
176}
177
178impl NormalizedMultiply for u32 {
179    #[inline]
180    fn mul_normalized(self, other: Self) -> Self {
181        const U32_UNITUP: u64 = u32::MAX as u64 - 1;
182        let prod: u64 = self as u64 * other as u64;
183        ((prod + U32_UNITUP) >> 32) as u32
184    }
185}
186
187impl NormalizedMultiply for u64 {
188    #[inline]
189    fn mul_normalized(self, other: Self) -> Self {
190        const U64_UNITUP: u128 = u64::MAX as u128 - 1;
191        let prod: u128 = self as u128 * other as u128;
192        ((prod + U64_UNITUP) >> 64) as u64
193    }
194}
195
196impl NormalizedBounded for f64 {
197    #[inline]
198    fn min_normalized() -> Self {
199        0.0
200    }
201
202    #[inline]
203    fn max_normalized() -> Self {
204        1.0
205    }
206}
207
208impl NormalizedBounded for f32 {
209    #[inline]
210    fn min_normalized() -> Self {
211        0.0
212    }
213
214    #[inline]
215    fn max_normalized() -> Self {
216        1.0
217    }
218}
219
220impl NormalizedBounded for u8 {
221    #[inline]
222    fn min_normalized() -> Self {
223        0
224    }
225
226    #[inline]
227    fn max_normalized() -> Self {
228        u8::MAX
229    }
230}
231
232impl NormalizedBounded for u16 {
233    #[inline]
234    fn min_normalized() -> Self {
235        0
236    }
237
238    #[inline]
239    fn max_normalized() -> Self {
240        u16::MAX
241    }
242}
243
244impl NormalizedBounded for u32 {
245    #[inline]
246    fn min_normalized() -> Self {
247        0
248    }
249
250    #[inline]
251    fn max_normalized() -> Self {
252        u32::MAX
253    }
254}
255
256impl NormalizedBounded for u64 {
257    #[inline]
258    fn min_normalized() -> Self {
259        0
260    }
261
262    #[inline]
263    fn max_normalized() -> Self {
264        u64::MAX
265    }
266}
tf_idf_vectorizer/utils/normalizer.rs

tf_idf_vectorizer/utils/
normalizer.rs
