Question

我有一个实现最小化算法的函数。我没有包括所有的变量，只是用矩阵来说明类型：

typedef Eigen::SparseMatrix<double> SpMat; 
typedef Eigen::VectorXd Vec;

int lm_solver(void (*f_dz)(Vec* x_, int m, Vec* dz_, SpMat* W_),
              void (*f_H)(Vec* x_, SpMat* jac_,int n_, int m_),
              Vec* x, int nx, int mm, int nnz,
              double tol=1e-9, int max_iter = 100){

    SpMat A(mm, nx);
    SpMat H1(mm, nx);
    SpMat H2(mm, nx);
    SpMat H(mm, nx);
    SpMat W(mm, mm);
    Vec rhs(nx);
    Vec dz(nx);
    Vec dx(nx);
    Vec a(1);
    Vec b(1);

    double f, f_prev, lbmda, rho, nu, tau;
    bool updateH, converged;
    int iter_;

    // reserve matrices memory
    H.reserve(nnz);
    W.reserve(mm);


    while (!converged && iter_ < max_iter){

        // get the system matrices
        if (updateH){ // if the Jacobian computation is not locked...
            f_dz(x, mm, &dz, &W);    // Residual increment (z-h(x)) vector creation or update: fill dz and W
            f_H(x, &H, nx, mm);     // Jacobian matrix creation or update: fill H

            // Start forming the auxiliary matrices of A
            H1 = H.transpose() * W;
            H2 = H1 * H;
        }

        // set the first value of lmbda
        if (iter_ == 1)
            lbmda = tau * H2.diagonal().maxCoeff();

        // form the system matrix A = H^t·W·H + lambda·I
        A = H2 + lbmda * Idn;

        // form the right hand side:  H^t·W·dz
        rhs = H1 * dz;

        // Solve the increment: dx = solve(A, rhs);
        solver.compute(A);
        dx = solver.solve(rhs);

        // calculate the objective function: Least squares function
        a = 0.5 * dz * W * dz; //vector x matrix x vector -> vector of 1 element
        f = a.coeffRef(0);

        // calculate the gain ratio
        b = 0.5 * dx * (lbmda * dx - rhs); //vector x matrix x vector -> vector of 1 element
        rho = (f_prev - f) / b.coeffRef(0);


    }

    return 0;
}

该过程执行以下操作：

声明稀疏矩阵矩阵（SpMat）
保留矩阵记忆
调用外部函数以填充H，dz和W
进行矩阵乘法并将结果存储到中间矩阵中

也很稀疏。

此函数是.h文件中唯一编译为静态库的函数.lib

当我单独编译静态库时，它可以完美地编译。

但是，当我使用其他项目的库项目时，我收到以下错误：

error: C2679: binary '=' : no operator found which takes a right-hand operand of type 'const Eigen::CwiseBinaryOp' (or there is no acceptable conversion)
\eigen\src/Core/Matrix.h(206): could be 'Eigen::Matrix<_Scalar,_Rows,_Cols> &Eigen::Matrix<_Scalar,_Rows,_Cols>::operator =(const Eigen::Matrix<_Scalar,_Rows,_Cols> &)'
with
[
    _Scalar=double,
    _Rows=-1,
    _Cols=1
]
d:\proyectos\proyectos_i+d\ingrid\eigen\eigen_3_3_3\eigen\src/Core/Matrix.h(281): or       'Eigen::Matrix<_Scalar,_Rows,_Cols> &Eigen::Matrix<_Scalar,_Rows,_Cols>::operator =(Eigen::Matrix<_Scalar,_Rows,_Cols> &&)'
with
[
    _Scalar=double,
    _Rows=-1,
    _Cols=1
]
while trying to match the argument list '(Vec, const Eigen::CwiseBinaryOp)'

此错误标记行：

H1 = H.transpose() * W;

H2 = H1 * H;

rhs = H1 * dz;

b = 0.5 * dx * (lbmda * dx - rhs); 

a = 0.5 * dz * W * dz;

据我所知，我无法在新的稀疏矩阵中存储稀疏矩阵乘法的结果。我不知道解决方法。

（我正在使用Eigen 3.3.3）

Answer 1

我不知道哪些行确切地导致了您的错误，但它看起来更像是由计算a和b引起的。您不能将col-vector乘以另一个col-vector而不进行转置，例如。

b = 0.5 * dx.transpose() * (lbmda * dx - rhs);

然而，这实际上是一个点积，所以你应该写

double b = 0.5 * dx.dot(lbmda * dx - rhs);

Answer 2

问题在于我在.h中编写了所有函数。通过将函数的主体放在.cpp上，一切都很顺利。

.h和.cpp的这种双重切断术让我最喜欢c ++。

无论如何，以备将来参考。

将稀疏矩阵作为稀疏矩阵的结果时，“没有操作符找到”

2 个答案: