<functional> problèmes avec MSVC 2010

Question

(bind imbriquée) Je le code suivant (je suis désolé pour la longueur):

double primeValue(const func1D &func, 
        const double lowerBound, const double upperBound, 
        const double pole) 
{ 
    // check bounds 
    if(lowerBound >= upperBound) 
     throw runtime_error("lowerBound must be smaller than upperBound!"); 

    // C++0x way of writing: fullFunc(x) = func(x)/(x-a) 
    func1D fullFunc = 
      bind(divides<double>(),    // division of 
        bind(func, _1),     // f(x), with _1 = x 
        bind(minus<double>(), _1, pole)); // by x-a, with _1 = x 

    // pole not in domain 
    if(pole<lowerBound || pole>upperBound) 
    { 
     cout << "Case 1" << endl; 
     return integrateSimpson(fullFunc, 1000, lowerBound, upperBound); 
    } 
    // pole closer to upper bound 
    else if(upperBound-pole < pole-lowerBound ) 
    { 
     cout << "Case 2" << endl; 
     // C++0x way of writing g(x) := [f(x)-f(2a-x)]/(x-a) 
     func1D specialFirstFunc = 
       bind(std::divides<double>(),        // division of 
         bind(minus<double>(),         // numerator: 
          bind(func, _1),         // f(x) minus 
          bind(func, bind(minus<double>(), 2.*pole, _1))), //f(2a-x) 
         bind(minus<double>(), _1, pole));     // denominator: x-a 
     const double trickyPart = integrateSimpson(specialFirstFunc, 1000, pole+.000001, upperBound); 

     const double normalPart = integrateSimpson(fullFunc, 1000, lowerBound, 2.*pole-upperBound); 
     cout << "Tricky part: " << trickyPart << endl; 
     cout << "Normal part: " << normalPart << endl; 
     return trickyPart + normalPart; 
    } 
    else // pole closer to lower bound 
    { 
     cout << "Case 3" << endl; 
     // C++0x way of writing g(x) := [f(x)-f(2a-x)]/(x-a) 
     func1D specialFirstFunc = 
       bind(std::divides<double>(),        // division of 
         bind(minus<double>(),         // numerator: 
          bind(func, _1),         // f(x) minus 
          bind(func, bind(minus<double>(), 2.*pole, _1))), //f(2a-x) 
         bind(minus<double>(), _1, pole));     // denominator: x-a 
     const double trickyPart = integrateSimpson(specialFirstFunc, 1000, lowerBound, pole-.00001); 

     const double normalPart = integrateSimpson(fullFunc, 1000, 2.*pole-lowerBound, upperBound); 
     cout << "Tricky part: " << trickyPart << endl; 
     cout << "Normal part: " << normalPart << endl; 
     return trickyPart + normalPart; 
    } 
} 

Il intègre des fonctions sur l'axe réel qui contient une singularité (pôle) en utilisant la concept de valeurs principales du domaine mathématique de l'analyse complexe. Les bind et function parties modifient la fonction originale f (x) à

(f (x) -f (2 * pôle-x))/(xa)

Il donne même il corriger résultat pour ma fonction de test simple. Détails supplémentaires que je peux fournir si nécessaire:

typedef std::function<double (double)> func1D; 
double integrateSimpson(func1D, const size_t nSteps, const double lowerBound, const double upperBound); 

Ce dernier s'intègre en utilisant la simple règle d'intégration de Simpson. Le code peut être fourni, mais n'est pas très pertinent pour le problème en question. Ceci compile avec GCC 4.4+ (testé avec les versions préliminaires 4.4.5 et 4.5.2, CFLAGS = "- O2 -std = C++ 0x -pedantic -Wall -Wextra"), mais produit des erreurs d'en-tête internes (C2664) sur MSVC 2010. (Je peux fournir une sortie d'erreur si nécessaire, il n'y a aucune référence à mon code (!)).

Ai-je trouvé un bogue dans MSVC?

Merci!

Answer 1

Pourquoi ne pas simplement utiliser un lambda? Tout le matériel de liaison a été déprécié pour ce genre de but.

double primeValue(const func1D &func, 
        const double lowerBound, const double upperBound, 
        const double pole) 
{ 
    // check bounds 
    if(lowerBound >= upperBound) 
     throw runtime_error("lowerBound must be smaller than upperBound!"); 

    // C++0x way of writing: fullFunc(x) = func(x)/(x-a) 
    auto fullFunc = [=](double d) { 
     return func(d)/(d - pole); 
    }; 

    // pole not in domain 
    if(pole<lowerBound || pole>upperBound) 
    { 
     cout << "Case 1" << endl; 
     return integrateSimpson(fullFunc, 1000, lowerBound, upperBound); 
    } 
    // pole closer to upper bound 
    else if(upperBound-pole < pole-lowerBound ) 
    { 
     cout << "Case 2" << endl; 
     // C++0x way of writing g(x) := [f(x)-f(2a-x)]/(x-a) 
     auto specialFirstFunc = [=](double x) -> double { 
      double numerator = func(x) - func(2*pole - x); 
      return numerator/(x - pole); 
     }; 
     const double trickyPart = integrateSimpson(specialFirstFunc, 1000, pole+.000001, upperBound); 

     const double normalPart = integrateSimpson(fullFunc, 1000, lowerBound, 2.*pole-upperBound); 
     cout << "Tricky part: " << trickyPart << endl; 
     cout << "Normal part: " << normalPart << endl; 
     return trickyPart + normalPart; 
    } 
    else // pole closer to lower bound 
    { 
     cout << "Case 3" << endl; 
     // C++0x way of writing g(x) := [f(x)-f(2a-x)]/(x-a) 
     auto specialFirstFunc = [=](double x) -> double { 
      double numerator = func(x) - func(2*pole - x); 
      return numerator/(x - pole); 
     }; 
     const double trickyPart = integrateSimpson(specialFirstFunc, 1000, lowerBound, pole-.00001); 

     const double normalPart = integrateSimpson(fullFunc, 1000, 2.*pole-lowerBound, upperBound); 
     cout << "Tricky part: " << trickyPart << endl; 
     cout << "Normal part: " << normalPart << endl; 
     return trickyPart + normalPart; 
    } 
} 

Pour ce que vous avez réellement trouvé si oui ou non un bogue dans MSVC, je ne sais pas, mais votre solution est certainement moyen inutile - ce code est beaucoup plus propre et plus facile à entretenir.