Unbekannter Fehler mit mingw Eigen mit Libary

Question

Hintergrund:

Ich bin der Algorithmus der kleinsten Quadrate in eine Klasse in C schreiben ++ und ich möchte sicherstellen, dass das, was ich tue, die am effizientesten ist und hoffentlich schnell. Ich benutzte die Eigenbibliothek, um alle Subroutinen zu schreiben, um die amerikanischen Optionskontrakte zu preisen. Ich habe den Algorithmus noch nicht abgeschlossen, aber ich habe die Mehrheit der Unterroutinen erledigt und getestet, um sicherzustellen, dass sie richtig funktionieren.

Frage:

Ich erhalte diesen unbekannten Fehler von Eigen, wenn ich es auf Eclipse bauen:

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, 

Ich bin nicht sicher, was das Problem ist.

Hier ist meine Header-Datei:

#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 

Hier ist die zugehörige CPP-Datei:

#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

Sie müssen nur Ihre Compiler-Fehlermeldung folgen Sie dem Codezeile in Ihrem Code zu finden, das ist in der Funktion LSM::timepaths, wo Sie ein Doppel geben, um ein VectorXd zu konstruieren:

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

werden soll:

VectorXd m(int(N) + 1); 

Für die Aufzeichnung nach dem Code innerhalb einer CPP-Datei zu kopieren, sagt der Compiler:

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

Das ist nicht mehr explizit sein kann.

bearbeiten: Es gibt mehr Fragen, wie mit Doppel eine VectorXd Indizierung:

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

Bitte benutzen Sie oder std::vector<int> Indizes zu halten.