extendr_api/optional/
faer.rs

1use faer::{mat, Mat, MatRef};
2
3use crate::scalar::Rfloat;
4use crate::*;
5
6/// Convert a `faer::Mat<f64>` into an `RMatrix<f64>` which is not `NA` aware.
7impl From<Mat<f64>> for RMatrix<f64> {
8    fn from(value: Mat<f64>) -> Self {
9        RMatrix::new_matrix(value.nrows(), value.ncols(), |i, j| value.read(i, j))
10    }
11}
12
13impl From<Mat<f64>> for Robj {
14    fn from(value: Mat<f64>) -> Self {
15        RMatrix::<f64>::from(value).into()
16    }
17}
18
19/// Convert a `faer::Mat<f64>` into an `RMatrix<f64>` which is not `NA` aware.
20impl From<MatRef<'_, f64>> for RMatrix<f64> {
21    /// Convert a faer `MatRef<f64>` into [`Robj`][robj]
22    /// [robj]: crate::Robj.
23    fn from(value: MatRef<'_, f64>) -> Self {
24        RMatrix::new_matrix(value.nrows(), value.ncols(), |i, j| value.read(i, j))
25    }
26}
27
28impl From<MatRef<'_, f64>> for Robj {
29    fn from(value: MatRef<'_, f64>) -> Self {
30        RMatrix::<f64>::from(value).into_robj()
31    }
32}
33
34impl From<Mat<f64>> for RMatrix<Rfloat> {
35    fn from(value: Mat<f64>) -> Self {
36        RMatrix::new_matrix(value.nrows(), value.ncols(), |i, j| value.read(i, j).into())
37    }
38}
39
40impl From<MatRef<'_, f64>> for RMatrix<Rfloat> {
41    fn from(value: MatRef<f64>) -> Self {
42        RMatrix::new_matrix(value.nrows(), value.ncols(), |i, j| {
43            Rfloat::from(value.read(i, j))
44        })
45    }
46}
47
48impl From<RMatrix<f64>> for Mat<f64> {
49    fn from(value: RMatrix<f64>) -> Self {
50        let nrow = value.nrows();
51        let ncol = value.ncols();
52        let slice = value.as_real_slice().expect("RMatrix should be doubles");
53        Mat::from_fn(nrow, ncol, |i, j| slice[i + j * nrow])
54    }
55}
56
57impl From<&'_ RMatrix<f64>> for MatRef<'_, f64> {
58    fn from(value: &RMatrix<f64>) -> Self {
59        let nrow = value.nrows();
60        let ncol = value.ncols();
61        let slice = value.as_typed_slice().expect("RMatrix should be doubles");
62        let mat_ref = faer::mat::from_column_major_slice(slice, nrow, ncol);
63        mat_ref
64    }
65}
66
67impl TryFrom<&Robj> for Mat<f64> {
68    type Error = Error;
69
70    fn try_from(robj: &Robj) -> Result<Self> {
71        let rmat = &RMatrix::<f64>::try_from(robj)?;
72        let nrow = rmat.nrows();
73        let ncol = rmat.ncols();
74
75        if let Some(slice) = robj.as_real_slice() {
76            let fmat = Mat::from_fn(nrow, ncol, |i, j| slice[i + j * nrow]);
77            Ok(fmat)
78        } else {
79            Err(Error::ExpectedReal(robj.clone()))
80        }
81    }
82}
83
84impl TryFrom<&'_ Robj> for MatRef<'_, f64> {
85    type Error = Error;
86
87    fn try_from(robj: &Robj) -> Result<Self> {
88        let rmat = &RMatrix::<f64>::try_from(robj)?;
89        let nrows = rmat.nrows();
90        let ncols = rmat.ncols();
91
92        if let Some(slice) = robj.as_typed_slice() {
93            let fmat = mat::from_column_major_slice(slice, nrows, ncols);
94            Ok(fmat)
95        } else {
96            Err(Error::ExpectedReal(robj.clone()))
97        }
98    }
99}
100
101impl TryFrom<Robj> for Mat<f64> {
102    type Error = crate::Error;
103
104    fn try_from(robj: Robj) -> Result<Self> {
105        Self::try_from(&robj)
106    }
107}
108
109impl TryFrom<Robj> for MatRef<'_, f64> {
110    type Error = crate::Error;
111
112    fn try_from(robj: Robj) -> Result<Self> {
113        Self::try_from(&robj)
114    }
115}
116
117impl From<RMatrix<i32>> for Mat<f64> {
118    fn from(value: RMatrix<i32>) -> Self {
119        let nrow = value.nrows();
120        let ncol = value.ncols();
121        let slice = value
122            .as_integer_slice()
123            .expect("RMatrix should be integers");
124        Mat::from_fn(nrow, ncol, |i, j| slice[i + j * nrow] as f64)
125    }
126}
127
128#[cfg(test)]
129mod test {
130    use crate::*;
131    use faer::{mat, Mat, MatRef};
132
133    #[test]
134    fn test_rmatrix_to_faer_mat() {
135        test! {
136            let values = [
137                [1.0, 5.0, 9.0],
138                [2.0, 6.0, 10.0],
139                [3.0, 7.0, 11.0],
140                [4.0, 8.0, 12.0f64]
141            ];
142            let a = Mat::<f64>::from_fn(4, 3, |i, j| values[i][j]);
143
144            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
145            let b = Mat::<f64>::from(rmatrix);
146            assert_eq!(a, b);
147        }
148    }
149
150    #[test]
151    fn test_rmatrix_to_faer_mat_with_nan() {
152        test! {
153            let values = [
154                [1.0, 5.0, 9.0],
155                [2.0, 6.0, 10.0],
156                [3.0, 7.0, 11.0],
157                [f64::NAN, 8.0, 12.0f64]
158            ];
159
160            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
161            let b = Mat::<f64>::from(rmatrix);
162            assert!(b.read(3, 0).is_nan());
163        }
164    }
165
166    #[test]
167    fn test_rmatrix_to_faer_mat_ref() {
168        test! {
169            let values = [
170                [1.0, 5.0, 9.0],
171                [2.0, 6.0, 10.0],
172                [3.0, 7.0, 11.0],
173                [4.0, 8.0, 12.0f64]
174            ];
175            let mat = Mat::<f64>::from_fn(4, 3, |i, j| values[i][j]);
176            let a = mat.as_ref();
177
178            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
179            let b = MatRef::<f64>::from(&rmatrix);
180            assert_eq!(a, b);
181        }
182    }
183
184    #[test]
185    fn test_faer_mat_to_rmatrix() {
186        test! {
187            let vec: Vec<f64> = (1..13).map(f64::from).collect();
188            let a = mat![
189                [1.0, 5.0, 9.0],
190                [2.0, 6.0, 10.0],
191                [3.0, 7.0, 11.0],
192                [4.0, 8.0, 12.0f64],
193            ];
194            let rmatrix: RMatrix<f64> = a.into();
195            assert_eq!(rmatrix.as_real_slice().expect("slice"), &vec);
196        }
197    }
198
199    #[test]
200    fn test_faer_mat_ref_to_rmatrix() {
201        test! {
202            let vec: Vec<f64> = (1..13).map(f64::from).collect();
203            let a = mat![
204                [1.0, 5.0, 9.0],
205                [2.0, 6.0, 10.0],
206                [3.0, 7.0, 11.0],
207                [4.0, 8.0, 12.0f64],
208            ];
209            let rmatrix: RMatrix<f64> = a.as_ref().into();
210            assert_eq!(rmatrix.as_real_slice().expect("slice"), &vec);
211        }
212    }
213
214    #[test]
215    fn test_try_from_robj_to_faer_mat() {
216        test! {
217            let values = [
218                [1.0, 5.0, 9.0],
219                [2.0, 6.0, 10.0],
220                [3.0, 7.0, 11.0],
221                [4.0, 8.0, 12.0f64]
222            ];
223            let a = Mat::<f64>::from_fn(4, 3, |i, j| values[i][j]);
224
225            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
226            let b = Mat::<f64>::try_from(&Robj::from(rmatrix));
227            assert_eq!(a, b.expect("matrix to be converted"));
228        }
229    }
230
231    #[test]
232    fn test_try_from_robj_to_faer_mat_ref() {
233        test! {
234            let values = [
235                [1.0, 5.0, 9.0],
236                [2.0, 6.0, 10.0],
237                [3.0, 7.0, 11.0],
238                [4.0, 8.0, 12.0f64]
239            ];
240            let mat = Mat::<f64>::from_fn(4, 3, |i, j| values[i][j]);
241            let a = mat.as_ref();
242
243            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
244            let robj = Robj::from(rmatrix);
245            let b = MatRef::<f64>::try_from(&robj);
246            assert_eq!(a, b.expect("matrix to be converted"));
247        }
248    }
249
250    #[test]
251    fn test_int_rmatrix_to_faer_mat() {
252        test! {
253            let values = [
254                [1, 5, 9],
255                [2, 6, 10],
256                [3, 7, 11],
257                [4, 8, 12]
258            ];
259            let a = Mat::<f64>::from_fn(4, 3, |i, j| values[i][j] as f64);
260
261            let rmatrix = RMatrix::new_matrix(4, 3, |i, j| values[i][j]);
262            let b = Mat::<f64>::from(rmatrix);
263            assert_eq!(a, b);
264        }
265    }
266}
extendr_api/optional/faer.rs

extendr_api/optional/
faer.rs
