特征中的自定义标量类型
Custom scalar type in Eigen
我目前正在尝试设置一个自定义标量类型以用于 Eigen3 库(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>& )
因此，基本问题似乎是-=运算符缺少重载。问题是我不知道为什么。据我所知，我已经为我的类型定义了重载运算符，但是如果我正确理解错误，似乎内部特征类型缺少该重载......
有没有人有想法，这里可能有什么问题？
这是产生上述错误的代码：
#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 << "nRefernce:" << std::endl;
std::cout << reference.trace() << std::endl;
std::cout << refSolver.eigenvalues() << std::endl;
}
相关文章：
- 有关插入适配器的错误。[错误]请求从 'back_insert_iterator<vector<>>' 类型转换为非标量类型
- 为什么 std：：optional：：operator=(U&&) 要求你是非标量类型？
- 错误:请求从"常量字符 [5]"转换为非标量类型"字符串"
- 特征中的自定义标量类型
- 标量类型的特征模板无法编译固定大小的子矩阵操作
- 请求从"点*"转换为非标量类型"点"
- 标量类型上的特征模板
- 错误：在 C++ 中从 'Counter' 转换为非标量类型'CountDn'
- 特征:从数组类型中获取标量类型是否记录?
- 错误：请求从"Mstream"转换为非标量类型"std：：string {aka std：：basic_string<char>}"
- Arduino trim() 和 replace() 方法返回从 'void' 到非标量类型'String'请求的转换
- 错误：移动文件时'QString'为非标量类型"std：：__cxx11：：字符串"
- 标量类型附加C++
- 复制初始化 - 从 'int' 类型转换为非标量类型
- 在 opencv 上将 vec 类型转换为标量类型
- 为矢量对象请求转换为非标量类型
- 错误:请求从 std::chrono::time_point 浮点数转换为非标量类型长整型
- 此错误的含义是什么：从 'char* [40] 转换为非标量类型 'std：：string
- 小标量类型和谷歌协议缓冲区
- 我可以强制执行标量类型通过 int{} 初始化为零吗?
