使用Eigen库的mingw发生未知错误

Question

Background :

I am writing the least squares algorithm into a class in C++ and I want to make sure that what I am doing is the most efficient and hopefully fast. I used the Eigen library to write all the sub-routines to price the American option contracts. I have not completed the algorithm yet but I have a majority of the sub-routines done, and tested them to make sure they are working correctly.

Question:

I am getting this unknown error from Eigen when I build it on Eclipse:

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,

I am not sure what the problem is.

Here is my header file:

#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

Here is the associated .cpp file:

#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;
}

Answer 1

You just have to follow your compiler error message to find the offending line in your code, which is in the function LSM::timepaths where you are passing a double to construct a VectorXd :

VectorXd LSM::timepaths(const double min, const double max, const double N)
{
   VectorXd m(N + 1);
   [...] 

Should be:

VectorXd m(int(N) + 1);

For the record, after copying your code within a .cpp file, the compiler says:

../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);
                    ^

This cannot be more explicit.

Edit : there are more issues, like indexing a VectorXd with double:

Eigen::VectorXd C, S, path;
C(i) = S(path(i));

Please use Eigen::VectorXi or std::vector<int> to hold indexes.