C++ 使用特征库的mingw未知错误
背景： 我把最小二乘算法写进C++中的一个类，我想确保我所做的是最有效的，而且希望是快速的。我使用Egen库编写了所有为美式期权合同定价的子程序。我还没有完成算法，但我已经完成了大部分子例程，并对它们进行了测试，以确保它们正常工作 问题： 当我在Eclipse上构建Eigen时，我从Eigen得到了这个未知错误：C++ 使用特征库的mingw未知错误,c++,eigen,C++,Eigen,背景： 我把最小二乘算法写进C++中的一个类，我想确保我所做的是最有效的，而且希望是快速的。我使用Egen库编写了所有为美式期权合同定价的子程序。我还没有完成算法，但我已经完成了大部分子例程，并对它们进行了测试，以确保它们正常工作 问题： 当我在Eclipse上构建Eigen时，我从Eigen得到了这个未知错误： c:\mingw\include\c++\6.2.0\eigen\src/Core/PlainObjectBase.h:774:7: error: static assertion f
c:\mingw\include\c++\6.2.0\eigen\src/Core/PlainObjectBase.h:774:7: error: static assertion failed: FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED
EIGEN_STATIC_ASSERT(is_integer,
#include <vector>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#ifndef LSM_H
#define LSM_H
class LSM {
public:
// Overload Constructor
LSM(const double, const double, const double, const int, const int, const double, const double, const int, const int);
// Destructor
~LSM();
// Generate the Laguerre Polynomials
Eigen::MatrixXd Laguerre(Eigen::VectorXd, const int);
// Generate Gaussian noise
// Generate M paths of stock prices (Geometric Brownian Motion)
Eigen::VectorXd GBM(const int, const int, const double, const double, const double, const double, const double);
// Generate time paths
Eigen::VectorXd timepaths(const double, const double, const double);
// Payoff of call option
Eigen::VectorXd callPayoff(Eigen::VectorXd, const double);
// Payoff of put option
Eigen::VectorXd putPayoff(Eigen::VectorXd, const double);
// Find function for finding the paths that are in the money (call option)
Eigen::VectorXd Findcallpath(Eigen::VectorXd, const double);
// Find function for finding the paths that are in the money (put option)
Eigen::VectorXd Findputpath(Eigen::VectorXd, const double);
// Find price of call given path
Eigen::VectorXd Findcallprices(Eigen::VectorXd, Eigen::VectorXd);
// Find price of put given path
Eigen::VectorXd Findputprices(Eigen::VectorXd, Eigen::VectorXd);
// Find return of call (stock price - strike price)
Eigen::VectorXd Findcallreturn(Eigen::VectorXd, const double);
// Find return of put (strike price - stock price)
Eigen::VectorXd Findputreturn(Eigen::VectorXd, const double);
// Using Two-sided Jacobi SVD decomposition of a rectangular matrix
Eigen::VectorXd Jacobi(Eigen::MatrixXd, Eigen::VectorXd);
private:
// Member variables
double new_r;
double new_q;
double new_sigma;
int new_T;
int new_N;
double new_K;
double new_S0;
int new_M;
int new_R;
};
#endif
#包括
#包括
#包括
#ifndef LSM_H
#定义LSM_H
类LSM{
公众：
//重载构造函数
LSM（常数双精度、常数双精度、常数双精度、常数内精度、常数内精度、常数双精度、常数双精度、常数内精度、常数内精度）；
//析构函数
~LSM（）；
//生成拉盖尔多项式
本征：：矩阵xxd拉盖尔（本征：：向量xd，常数int）；
//产生高斯噪声
//生成股票价格的M条路径（几何布朗运动）
本征：：矢量xd GBM（常量int，常量int，常量double，常量double，常量double，常量double，常量double）；
//生成时间路径
特征：：矢量xd时间路径（常数双精度、常数双精度、常数双精度）；
//看涨期权的报酬
Eigen:：VectorXd callPayoff（Eigen:：VectorXd，const double）；
//看跌期权的收益
特征：：向量xd putPayoff（特征：：向量xd，常数double）；
//查找函数，用于查找货币中的路径（看涨期权）
特征：：VectorXd Findcallpath（特征：：VectorXd，常数double）；
//查找函数，用于查找货币中的路径（看跌期权）
特征：：VectorXd Findputpath（特征：：VectorXd，const double）；
//查找给定路径的调用价格
Eigen:：VectorXd Findcallprices（Eigen:：VectorXd，Eigen:：VectorXd）；
//找到给定路径的看跌期权价格
Eigen:：VectorXd Findputprices（Eigen:：VectorXd，Eigen:：VectorXd）；
//查找回叫（股票价格-履约价格）
Eigen:：VectorXd Findcallreturn（Eigen:：VectorXd，const double）；
//查找卖出回报（执行价-股票价格）
特征：：VectorXd Findputreturn（特征：：VectorXd，const double）；
//矩形矩阵的双侧Jacobi-SVD分解
特征：：向量xd雅可比（特征：：矩阵xd，特征：：向量xd）；
私人：
//成员变量
双新r；
双新(q),；
双新西格玛；
国际新闻界;；
国际新闻网,；
双新K ;；
双新_S0；
国际新墨西哥州；
int new_R；
};
#恩迪夫
#include <iostream>
#include <vector>
#include <random>
#include <time.h>
#include <math.h>
#include "LSM.h"
#include <Eigen/Dense>
#include <Eigen/Geometry>
LSM::LSM( const double r, const double q, const double sigma, const int T, const int N, const double K, const double S0, const int M, const int R){
new_r = r;
new_q = q;
new_sigma = sigma;
new_T = T;
new_N = N;
new_K = K;
new_S0 = S0;
new_M = M;
new_R = R;
/* Eigen::VectorXd V(4);
V(0) = 100;
V(1) = 102;
V(2) = 103;
V(3) = 104;
Eigen::MatrixXd A = Laguerre(2,V);
std::cout << A << std::endl;*/
/* Eigen::VectorXd v;
v = GBM(new_M, new_N, new_T, new_r, new_q, new_sigma, new_S0);
std::cout << v << std::endl;*/
/* Eigen::VectorXd S(3);
S(0) = 101;
S(1) = 102;
S(2) = 105;
S = Findcallpath(S,102);
std::cout << S << std::endl;*/
Eigen::VectorXd S = GBM(new_M, new_N, new_T, new_r, new_q, new_sigma, new_S0);
Eigen::VectorXd t = timepaths(0,new_T,new_N);
Eigen::VectorXd P = putPayoff(S,new_K); // Payoff at time T
for(int i = new_N; i >= 2; i--){
}
}
LSM::~LSM(){
}
Eigen::MatrixXd LSM::Laguerre(Eigen::VectorXd X, const int R){
int n = X.rows();
int m = R + 1;
Eigen::MatrixXd value(n, m);
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(R == 1){
value(i,0) = 1.0;
value(i,1) = -X(i) + 1.0;
}
else if(R == 2){
value(i,0) = 1.0;
value(i,1) = -X(i) + 1.0;
value(i,2) = 1.0/2.0*(2 - 4*X(i) + X(i)*X(i));
}
else if(R == 3){
value(i,0) = 1.0;
value(i,1) = -X(i) + 1.0;
value(i,2) = 1.0/2.0*(2 - 4*X(i) + X(i)*X(i));
value(i,3) = 1.0/6.0*(6.0 - 18.0*X(i,0) + 9.0*X(i)*X(i) - pow((double)X(i,0),3.0));
}
}
}
return value;
}
Eigen::VectorXd LSM::timepaths(const double min, const double max, const double N){
Eigen::VectorXd m(N + 1);
double delta = (max-min)/N;
for(int i = 0; i <= N; i++){
m(i) = min + i*delta;
}
return m;
}
Eigen::VectorXd LSM::GBM(const int M, const int N, const double T, const double r, const double q, const double sigma, const double S0){
double dt = T/N;
Eigen::VectorXd Z(M);
Eigen::VectorXd S(M);
S(0) = S0;
std::mt19937 e2(time(0));
std::normal_distribution<double> dist(0.0, 1.0);
for(int i = 0; i < M; i++){
Z(i) = dist(e2);
}
double drift = exp(dt*((r - q)-0.5*sigma*sigma));
double vol = sqrt(sigma*sigma*dt);
for(int i = 1; i < M; i++){
S(i) = S(i-1) * drift * exp(vol * Z(i));
}
return S;
}
Eigen::VectorXd LSM::callPayoff(Eigen::VectorXd S, const double K){
Eigen::VectorXd C(S.size());
for(int i = 0; i < S.size(); i++){
if(S(i) - K > 0){
C(i) = S(i) - K;
}else{
C(i) = 0.0;
}
}
return C;
}
Eigen::VectorXd LSM::putPayoff(Eigen::VectorXd S, const double K){
Eigen::VectorXd P(S.size());
for(int i = 0; i < S.size(); i++){
if(K - S(i) > 0){
P(i) = K - S(i);
}else{
P(i) = 0.0;
}
}
return P;
}
Eigen::VectorXd LSM::Findcallpath(Eigen::VectorXd S, const double K){
Eigen::VectorXd path(S.size());
int count = 0;
for(int i = 0; i < S.size(); i++){
if(S(i) - K > 0){
path(count) = i;
count++;
}
}
path.conservativeResize(count);
return path;
}
Eigen::VectorXd LSM::Findputpath(Eigen::VectorXd S, const double K){
Eigen::VectorXd path(S.size());
int count = 0;
for(int i = 0; i < S.size(); i++){
if(K - S(i) > 0){
path(count) = i;
count++;
}
}
path.conservativeResize(count);
return path;
}
Eigen::VectorXd Findcallprices(Eigen::VectorXd path, Eigen::VectorXd S){
Eigen::VectorXd C(path.size());
for(int i = 0; i < path.size(); i++){
C(i) = S(path(i));
}
return C;
}
Eigen::VectorXd Findputprices(Eigen::VectorXd path, Eigen::VectorXd S){
Eigen::VectorXd P(path.size());
for(int i = 0; i < path.size(); i++){
P(i) = S(path(i));
}
return P;
}
Eigen::VectorXd LSM::Jacobi(Eigen::MatrixXd L, Eigen::VectorXd Y){
Eigen::VectorXd reg(L.rows());
return reg = L.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(Y);
}
Eigen::VectorXd LSM::Findcallreturn(Eigen::VectorXd S, const double K){
Eigen::VectorXd C_return(S.size());
for(int i = 0; i < S.size(); i++){
C_return(i) = (S(i) - K);
}
return C_return;
}
Eigen::VectorXd LSM::Findputreturn(Eigen::VectorXd S, const double K){
Eigen::VectorXd P_return(S.size());
for(int i = 0; i < S.size(); i++){
P_return(i) = (K - S(i));
}
return P_return;
}
#包括
#包括
#包括
#包括
#包括
#包括“LSM.h”
#包括
#包括
LSM:：LSM（常数双r、常数双q、常数双西格玛、常数双T、常数双N、常数双K、常数双S0、常数双M、常数双r）{
新的r=r；
新的_q=q；
新西格玛=西格玛；
新T=T；
新的N=N；
新K=K；
新的_S0=S0；
新的M=M；
新的R=R；
/*本征：：矢量xd V（4）；
V（0）=100；
V（1）=102；
V（2）=103；
V（3）=104；
本征矩阵A=Laguerre（2，V）；
std:：cout您只需按照编译器错误消息查找代码中有问题的行，该行位于函数LSM:：timepath
中，在该函数中，您将传递一个double来构造VectorXd
：
VectorXd LSM::timepaths(const double min, const double max, const double N)
{
VectorXd m(N + 1);
[...]
应该是：
VectorXd m(int(N) + 1);
作为记录，在.cpp文件中复制代码后，编译器会说：
../eigen/Eigen/src/Core/PlainObjectBase.h:779:27: error: no member named 'FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED' in 'Eigen::internal::static_assertion<false>'
FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
^
../eigen/Eigen/src/Core/Matrix.h:296:22: note: in instantiation of function template specialization 'Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >::_init1<double>' requested here
Base::template _init1<T>(x);
^
foo.cpp:166:21: note: in instantiation of function template specialization 'Eigen::Matrix<double, -1, 1, 0, -1, 1>::Matrix<double>' requested here
Eigen::VectorXd m(N + 1);
^
请使用Eigen:：VectorXi
或std:：vector
来保存索引。它在代码中引用了哪一行？？？它没有指定它只是在我在Eclipse中创建的文件上有一个红色的x框，而.cpp和.h文件中没有任何错误。错误消息上方或下方的行告诉您错误在y中的位置我们的文件，写着“from”，“in”或类似的东西。这是我所有的，c:\mingw\include\c++\6.2.0\eigen\src/Core/Matrix.h:296:31:需要自'eigen:：Matrix:：Matrix（const T&）[with T=double；\u Scalar=double；int\u Rows=-1；int\u Cols=1；int\u Options=0；int\u MaxRows=-1；int\u MaxCols=1]'..\LSM.cpp:92:23:此处需要c:\mingw\include\c++\6.2.0\eigen\src/Core/PlainObjectBase.h:774:7:错误：静态断言失败：浮点\参数\传递\整数\是\预期的特征\静态\断言（是整数，^问题似乎很简单，在某个地方你用了一个双精度，你应该用一个整数，但我找不到那个地方。
Eigen::VectorXd C, S, path;
C(i) = S(path(i));