Erreur inconnue avec MinGW en utilisant Eigen Libary

Contexte:Erreur inconnue avec MinGW en utilisant Eigen Libary

Je vous écris algorithme des moindres carrés dans une classe en C++ et je veux vous assurer que ce que je fais est le plus efficace et nous espérons rapidement. J'ai utilisé la bibliothèque Eigen pour écrire toutes les sous-routines afin de tarifer les contrats d'option américains. Je n'ai pas encore terminé l'algorithme mais j'ai fait la majorité des sous-routines, et les ai testées pour m'assurer qu'elles fonctionnent correctement.

Question:

Je reçois cette erreur inconnue de Eigen quand je construis sur 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,

Je ne sais pas quel est le problème.

Voici mon fichier d'en-tête:

#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

Voici le fichier .cpp associé:

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

Source

2017-10-16 Anonymous

À quelle ligne fait-il référence dans votre code ??? – Surt

Il ne spécifie pas qu'il a juste un x rouge encadré sur le fichier que j'ai créé dans Eclipse, les fichiers .cpp et .h ne contiennent aucune erreur. –

Les lignes juste au-dessus ou au-dessous des messages d'erreur vous indiquent où se trouve l'erreur dans votre fichier, en disant "from", "in" ou quelque chose comme ça. – Surt

Il vous suffit de suivre votre message d'erreur du compilateur pour trouver la ligne incriminée dans votre code, qui est dans la fonction LSM::timepaths où vous passez un double pour construire un VectorXd:

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

devrait être:

VectorXd m(int(N) + 1);

Pour mémoire, après avoir copié votre code dans un fichier cpp, le compilateur dit:

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

Ce ne peut pas être plus explicite.

Modifier: il y a plus de problèmes, comme l'indexation d'un VectorXd double:

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

S'il vous plaît utiliser ou std::vector<int> pour tenir les index.

Source

2017-10-16 20:39:48 ggael

Erreur inconnue avec MinGW en utilisant Eigen Libary

Répondre

Questions connexes