本征中的自定义标量类型 [英] Custom scalar type in Eigen
本文介绍了本征中的自定义标量类型的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我目前正在尝试设置一个定制标量类型，以用于特征3库(ATM它是double的一个简单包装器)。据我所知，我已经遵循了https://eigen.tuxfamily.org/dox/TopicCustomizing_CustomScalar.html，基本的事情运行得很好。
我需要用我的定制类型解决矩阵的特征值问题，而这正是事情开始崩溃的地方。我的编译器向我发出以下错误消息：
/Eigen3/Eigen/src/Householder/Householder.h:131:18: error: no viable overloaded '-='
this->row(0) -= tau * tmp;
~~~~~~~~~~~~ ^ ~~~~~~~~~
/Eigen3/Eigen/src/Eigenvalues/HessenbergDecomposition.h:314:10: note: in instantiation of function template specialization 'Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<MyDouble, 2,
2, 0, 2, 2>, -1, -1, false> >::applyHouseholderOnTheLeft<Eigen::VectorBlock<Eigen::Block<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>, 2, 1, true>, -1> >' requested here
.applyHouseholderOnTheLeft(matA.col(i).tail(remainingSize-1), h, &temp.coeffRef(0));
^
/Eigen3/Eigen/src/Eigenvalues/HessenbergDecomposition.h:161:7: note: in instantiation of member function 'Eigen::HessenbergDecomposition<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>
>::_compute' requested here
_compute(m_matrix, m_hCoeffs, m_temp);
^
/Eigen3/Eigen/src/Eigenvalues/./RealSchur.h:271:10: note: in instantiation of function template specialization 'Eigen::HessenbergDecomposition<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>
>::compute<Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<MyDouble, MyDouble>, const Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>, const Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<MyDouble>, const
Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2> > > >' requested here
m_hess.compute(matrix.derived()/scale);
^
/Eigen3/Eigen/src/Eigenvalues/EigenSolver.h:389:15: note: in instantiation of function template specialization 'Eigen::RealSchur<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>
>::compute<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2> >' requested here
m_realSchur.compute(matrix.derived(), computeEigenvectors);
^
/Eigen3/Eigen/src/Eigenvalues/EigenSolver.h:156:7: note: in instantiation of function template specialization 'Eigen::EigenSolver<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2>
>::compute<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2> >' requested here
compute(matrix.derived(), computeEigenvectors);
^
/home/adam/Documents/Git/spin_phonon_coupling/src/test.cpp:205:52: note: in instantiation of function template specialization 'Eigen::EigenSolver<Eigen::Matrix<MyDouble, 2, 2, 0, 2, 2> >::EigenSolver<Eigen::Matrix<MyDouble, 2, 2, 0, 2,
2> >' requested here
Eigen::EigenSolver<Eigen::Matrix<MyDouble, 2, 2>> solver(test);
^
/Eigen3/Eigen/src/Core/DenseBase.h:298:14: note: candidate template ignored: could not match 'EigenBase<type-parameter-0-0>' against 'MyDouble'
Derived& operator-=(const EigenBase<OtherDerived> &other);
^
/Eigen3/Eigen/src/Core/MatrixBase.h:161:14: note: candidate template ignored: could not match 'MatrixBase<type-parameter-0-0>' against 'MyDouble'
Derived& operator-=(const MatrixBase<OtherDerived>& other);
^
/Eigen3/Eigen/src/Core/MatrixBase.h:495:46: note: candidate template ignored: could not match 'ArrayBase<type-parameter-0-0>' against 'MyDouble'
template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
因此，基本问题似乎是-=运算符缺少重载。问题是我不知道为什么。就我所能看到的，我已经为我的类型定义了重载操作符，但如果我正确理解了错误，似乎内部的Eigen-type缺少那个重载...
有没有人知道这里可能出了什么问题？
以下是产生上述错误的代码：
#include <iostream>
#include <cmath>
#include <Eigen/Dense>
class MyDouble {
public:
double value;
MyDouble() : value() {};
MyDouble(double val) : value(val) {};
template<typename T>
MyDouble operator+(T other) const {
return value + other;
}
template<>
MyDouble operator+(MyDouble other) const {
return MyDouble(value + other.value);
}
template<typename T>
MyDouble operator-(T other) const {
return value - other;
}
template<>
MyDouble operator-(MyDouble other) const {
return MyDouble(value - other.value);
}
template<typename T>
MyDouble operator*(T other) const {
return value * other;
}
template<>
MyDouble operator*(MyDouble other) const {
return MyDouble(value * other.value);
}
template<typename T>
MyDouble operator/(T other) const {
return value / other;
}
template<>
MyDouble operator/(MyDouble other) const {
return MyDouble(value / other.value);
}
template<typename T>
MyDouble& operator+=(T other) {
value += other;
return *this;
}
template<>
MyDouble& operator+=(MyDouble other) {
value += other.value;
return *this;
}
template<typename T>
MyDouble& operator-=(const T &other) {
value -= other;
return *this;
}
template<>
MyDouble& operator-=(const MyDouble &other) {
value -= other.value;
return *this;
}
template<typename T>
MyDouble& operator*=(T other) {
value *= other.value;
return *this;
}
template<>
MyDouble& operator*=(MyDouble other) {
value *= other.value;
return *this;
}
template<typename T>
MyDouble& operator/=(T other) {
value /= other;
return *this;
}
template<>
MyDouble& operator/=(MyDouble other) {
value /= other.value;
return *this;
}
MyDouble operator-() const {
return -value;
}
template<typename T>
bool operator<(T other) const {
return value < other;
}
template<>
bool operator<(MyDouble other) const {
return value < other.value;
}
template<typename T>
bool operator>(T other) const {
return value > other;
}
template<>
bool operator>(MyDouble other) const {
return value > other.value;
}
template<typename T>
bool operator<=(T other) const {
return value <= other;
}
template<>
bool operator <=(MyDouble other) const {
return value <= other.value;
}
template<typename T>
bool operator>=(T other) const {
return value >= other;
}
template<>
bool operator>=(MyDouble other) const {
return value >= other.value;
}
template<typename T>
bool operator==(T other) const {
return value == other;
}
template<>
bool operator==(MyDouble other) const {
return value == other.value;
}
template<typename T>
bool operator!=(T other) const {
return value != other;
}
template<>
bool operator!=(MyDouble other) const {
return value != other.value;
}
friend std::ostream& operator<<(std::ostream& out, const MyDouble& val) {
out << val.value << " m";
return out;
}
operator double() {
return value;
}
};
MyDouble sqrt(MyDouble val) {
return std::sqrt(val.value);
}
MyDouble abs(MyDouble val) {
return std::abs(val.value);
}
MyDouble abs2(MyDouble val) {
return val * val;
}
namespace Eigen {
template<> struct NumTraits<MyDouble>
: NumTraits<double> // permits to get the epsilon, dummy_precision, lowest, highest functions
{
typedef MyDouble Real;
typedef MyDouble NonInteger;
typedef MyDouble Nested;
enum {
IsComplex = 0,
IsInteger = 0,
IsSigned = 1,
RequireInitialization = 1,
ReadCost = 1,
AddCost = 3,
MulCost = 3
};
};
template<typename BinaryOp>
struct ScalarBinaryOpTraits<MyDouble,double,BinaryOp> { typedef MyDouble ReturnType; };
template<typename BinaryOp>
struct ScalarBinaryOpTraits<double,MyDouble,BinaryOp> { typedef MyDouble ReturnType; };
}
int main() {
Eigen::Matrix<MyDouble, 2, 2> test;
test << 1, 2, 3, 4;
Eigen::Matrix<double, 2, 2> test2;
test2 << 5, 6, 7, 8;
MyDouble a = 3;
a -= 2;
a -= MyDouble(3);
Eigen::EigenSolver<Eigen::Matrix<MyDouble, 2, 2>> solver(test);
std::cout << test.trace() << std::endl;
std::cout << solver.eigenvalues() << std::endl;
}
推荐答案
Marc Glisse指出，我的操作符重载看起来有点奇怪，所以我重写了它们，最初的问题已经消失了。不过，我不知道为什么会出现这种情况。
然后我只有一个问题，即Eigen的isfinite函数没有为我的定制类型定义，所以我继续添加了它的一个实现(尽管我不确定这是否真的是一个可靠的实现)。
我的代码现在可以编译了。以下是我的代码的修改版本：
#include <iostream>
#include <cmath>
#include <complex>
#include <Eigen/Dense>
class MyDouble {
public:
double value;
MyDouble() : value() {};
MyDouble(double val) : value(val) {};
template<typename T>
MyDouble& operator+=(T rhs) {
value = static_cast<double>(value + rhs);
return *this;
}
template<typename T>
MyDouble& operator-=(const T &rhs) {
value = static_cast<double>(value - rhs);
return *this;
}
template<typename T>
MyDouble& operator*=(T rhs) {
value = static_cast<double>(value * rhs);
return *this;
}
template<typename T>
MyDouble& operator/=(T rhs) {
value = static_cast<double>(value / rhs);
return *this;
}
MyDouble operator-() const {
return -value;
}
friend std::ostream& operator<<(std::ostream& out, const MyDouble& val) {
out << val.value << " m";
return out;
}
explicit operator double() {
return value;
}
};
#define OVERLOAD_OPERATOR(op,ret) ret operator op(const MyDouble &lhs, const MyDouble &rhs) {
return lhs.value op rhs.value;
}
OVERLOAD_OPERATOR(+, MyDouble)
OVERLOAD_OPERATOR(-, MyDouble)
OVERLOAD_OPERATOR(*, MyDouble)
OVERLOAD_OPERATOR(/, MyDouble)
OVERLOAD_OPERATOR(>, bool)
OVERLOAD_OPERATOR(<, bool)
OVERLOAD_OPERATOR(>=, bool)
OVERLOAD_OPERATOR(<=, bool)
OVERLOAD_OPERATOR(==, bool)
OVERLOAD_OPERATOR(!=, bool)
MyDouble sqrt(MyDouble val) {
return std::sqrt(val.value);
}
MyDouble abs(MyDouble val) {
return std::abs(val.value);
}
MyDouble abs2(MyDouble val) {
return val * val;
}
bool isfinite(const MyDouble &) { return true; }
namespace Eigen {
template<> struct NumTraits<MyDouble>
: NumTraits<double> // permits to get the epsilon, dummy_precision, lowest, highest functions
{
typedef MyDouble Real;
typedef MyDouble NonInteger;
typedef MyDouble Nested;
enum {
IsComplex = 0,
IsInteger = 0,
IsSigned = 1,
RequireInitialization = 0,
ReadCost = 1,
AddCost = 3,
MulCost = 3
};
};
template<typename BinaryOp>
struct ScalarBinaryOpTraits<MyDouble,double,BinaryOp> { typedef MyDouble ReturnType; };
template<typename BinaryOp>
struct ScalarBinaryOpTraits<double,MyDouble,BinaryOp> { typedef MyDouble ReturnType; };
}
int main() {
Eigen::Matrix<MyDouble, 2, 2> test;
test << 1, 2, 3, 4;
Eigen::Matrix<double, 2, 2> reference;
reference << 1, 2, 3, 4;
MyDouble a = 3;
a += 2;
a = 2 + a;
a = a + 2;
a -= 2;
a -= MyDouble(3);
a = a / a;
std::complex<MyDouble> complexTest(3,4);
complexTest *= 2;
Eigen::EigenSolver<Eigen::Matrix<MyDouble, 2, 2>> solver(test);
Eigen::EigenSolver<Eigen::Matrix<double, 2, 2>> refSolver(reference);
std::cout << "MyDouble:" << std::endl;
std::cout << test.trace() << std::endl;
std::cout << solver.eigenvalues() << std::endl;
std::cout << "
Refernce:" << std::endl;
std::cout << reference.trace() << std::endl;
std::cout << refSolver.eigenvalues() << std::endl;
}
这篇关于本征中的自定义标量类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
