使用extendr整合R与Rust实现矩阵运算遇类型转换错误求助

原R函数foo实现的是将n×n矩阵x的每一列除以向量y对应的元素，代码如下：

'# @param x A nxn matrix
'# @param y A 1xn matrix (vector)
foo = function(x, y) {
  return(x %*% diag(1 / y))
}

为提升大矩阵（如5000×5000）的处理速度，尝试用Rust结合{rextendr}重写该函数，初始的lib.rs代码如下：

use extendr_api::prelude::*;
use nalgebra as na;

/// Calculates ratio x/y.
/// @param x A nxn matrix.
/// @param y A 1xn vector.
/// @return A nxn matrix.
/// @export
#[extendr]
fn foo(
  x: na::DMatrix<f64>,
  y: na::DVector<f64>,
) -> na::DMatrix<f64> {
  let inv_y = y.map(|y| 1.0 / y);
  let m = x * na::Matrix::from_diagonal(&inv_y);
  m
}

// Macro to generate exports.
// This ensures exported functions are registered with R.
// See corresponding C code in `entrypoint.c`.
extendr_module! {
  mod package_name;
  fn foo;
}

这段Rust代码编译无错，但与R集成时出现错误：

no function or associated item named 'from_robj' found for struct 'Matrix' in the current scope

后续尝试修改返回类型为RArray，代码如下，但仍出现相同错误：

use extendr_api::prelude::*;
use nalgebra as na;

/// Calculates ratio x/y.
/// @param x A nxn matrix.
/// @param y A 1xn vector.
/// @return A nxn matrix.
/// @export
#[extendr]
fn foo(
  x: na::DMatrix<f64>,
  y: na::DVector<f64>,
  // change output to RArray
) -> RArray<f64, [usize;2]> {
  let inv_y = y.map(|y| 1.0 / y);
  // add .clone for I'll use x again later
  let m = x.clone() * na::Matrix::from_diagonal(&inv_y);

  // Convert m to R matrix
  let m_r = RArray::new_matrix(x.nrows() as usize, y.len() as usize, |r, c| m[(r, c)]);
  m_r
}

// Macro to generate exports.
// This ensures exported functions are registered with R.
// See corresponding C code in `entrypoint.c`.
extendr_module! {
  mod package_name;
  fn foo;
}

错误核心原因是：extendr默认没有为nalgebra的DMatrix/DVector类型实现FromRobj trait（即R对象到Rust类型的转换逻辑），无法直接将R传入的矩阵/向量自动转为nalgebra的类型。

解决方法是改用extendr原生类型作为函数参数，在函数内部手动转换为nalgebra类型处理，最后再转换回R可识别的类型。具体修改后的lib.rs代码如下：

use extendr_api::prelude::*;
use nalgebra as na;

/// Calculates ratio x/y.
/// @param x A nxn matrix.
/// @param y A 1xn vector.
/// @return A nxn matrix.
/// @export
#[extendr]
fn foo(x: RArray<f64, [usize; 2]>, y: RArray<f64, [usize; 1]>) -> RArray<f64, [usize; 2]> {
    // 将RArray转换为nalgebra的DMatrix和DVector
    let na_x = na::DMatrix::from_row_slice(x.nrows(), x.ncols(), x.as_slice());
    let na_y = na::DVector::from_slice(y.as_slice());

    // 执行核心计算逻辑
    let inv_y = na_y.map(|val| 1.0 / val);
    let result_matrix = na_x * na::DMatrix::from_diagonal(&inv_y);

    // 将nalgebra的DMatrix转换回RArray矩阵
    RArray::new_matrix(
        result_matrix.nrows(),
        result_matrix.ncols(),
        |r, c| result_matrix[(r, c)],
    )
}

extendr_module! {
    mod package_name;
    fn foo;
}

关键修改点说明 #

• 函数参数改用extendr的RArray类型：RArray<f64, [usize;2]>对应R中的矩阵，RArray<f64, [usize;1]>对应R中的向量。
• 手动完成类型转换：
  • 使用na::DMatrix::from_row_slice将RArray的切片转为nalgebra矩阵；
  • 使用na::DVector::from_slice将向量切片转为nalgebra向量；
  • 计算完成后，用RArray::new_matrix将结果矩阵转回R可识别的类型。
• 这种方式既保留了nalgebra的高性能矩阵运算能力，又符合extendr的类型转换规则，不会出现from_robj相关错误。

性能优化版 #

因为x %*% diag(1/y)本质是每一列除以y的对应元素，不需要显式构造对角矩阵，可直接对每一列做元素除法，减少内存占用并提升速度：

use extendr_api::prelude::*;
use nalgebra as na;

/// Calculates ratio x/y.
/// @param x A nxn matrix.
/// @param y A 1xn vector.
/// @return A nxn matrix.
/// @export
#[extendr]
fn foo(x: RArray<f64, [usize; 2]>, y: RArray<f64, [usize; 1]>) -> RArray<f64, [usize; 2]> {
    let na_x = na::DMatrix::from_row_slice(x.nrows(), x.ncols(), x.as_slice());
    let na_y = na::DVector::from_slice(y.as_slice());

    // 直接对每一列做元素除法，避免构造大对角矩阵
    let result_matrix = na_x.column_iter()
        .zip(na_y.iter())
        .map(|(col, &y_val)| col / y_val)
        .collect::<na::DMatrix<f64>>();

    RArray::new_matrix(
        result_matrix.nrows(),
        result_matrix.ncols(),
        |r, c| result_matrix[(r, c)],
    )
}

extendr_module! {
    mod package_name;
    fn foo;
}

内容的提问来源于stack exchange，提问作者Alberson Miranda