PseudoInverse.h

Go to the documentation of this file.

 
#ifndef INCLUDE_RML_PSEUDOINVERSE_H_
#define INCLUDE_RML_PSEUDOINVERSE_H_
 
#include <eigen3/Eigen/Dense>
 
#include "SVD.h"
#include "Types.h"
 
namespace rml {
 
struct RegularizationParameters {
    double threshold; 
    double lambda; 
 
    RegularizationParameters()
        : threshold(0.01)
        , lambda(0.01)
    {
    }
};
 
struct RegularizationResults {
    double mu; 
    int flag; 
 
    RegularizationResults()
        : mu(0.0)
        , flag(0)
    {
    }
};
 
struct RegularizationData {
    RegularizationParameters params;
    RegularizationResults results;
 
    RegularizationData() = default;
};
 
void RegPinv(const double* J, int m, int n, double* JPInv, double treshold, double lambda, double* prod, int* flag);
 
template <class MatT>
Eigen::Matrix<typename MatT::Scalar, MatT::ColsAtCompileTime, MatT::RowsAtCompileTime> RegularizedPseudoInverse(
    const MatT& mat, RegularizationData& regData) // choose appropriately
{
 
    int m = mat.rows(), n = mat.cols();
    double J[m * n]; // NULL pointer
    double JPInv[n * m];
 
    //Here we convert the input type to a double array which is the type used by the GT_RegPinv
    Eigen::Map<MatT>(J, m, n) = mat;
 
    RegPinv(J, m, n, JPInv, regData.params.threshold, regData.params.lambda, &(regData.results.mu), &(regData.results.flag));
 
    //Here the results of the GT_RegPinv algorithm are mapped back to the input type
    MatT eigenPinv = Eigen::Map<MatT>(JPInv, n, m);
 
    return eigenPinv;
}
 
} //namespace rml
 
#endif /* INCLUDE_RML_PSEUDOINVERSE_H_ */