Functions object verschachteln



  • Hallo zusammen!

    Kann man die folgenden "transform" Anweisungen irgendwie ineinander verschachteln:

    #include <algorithm>
    #include <functional>
    
    using namespace std;
    
    void myFunction() {
        double radius = 0.0;
        double center[3] = { 0, 0, 0 };
        double direction[3] = { -1, 1, 1 };
    
        double newCenter[3];
    
        transform(
              direction, 
              direction + 3, 
              newCenter, 
              bind2nd(multiplies<double> (), radius));
        transform(
              center, 
              center + 3, 
              newCenter,
              newCounds.center, 
              plus<double> ());
    }
    

    Die Anweisung sollte

    $\vec{x}_{new} = \vec{x}_{old} + r \cdot \vec{d}$

    implementieren.

    Danke fuer eure Hilfe.



  • Mit der Standardbibliothek geht das, soweit ich weiß, nicht. Mit boost::bind bzw std::tr1::bind sollte es gehen. Ich würde mir aber einfach eine eigene Funktion für diese Operation schreiben.


  • Mod

    Möglicherweise kann man das irgendwie geschickt schachteln, aber ich finde folgendes einfacher, wenn du alles in einem Schritt haben willst:

    class multiply_and_add
    {
    private:
      double radius;
    public:
      multiply_and_add(double radius): radius(radius){}
      double operator()(double lhs, double rhs)
      {
        return lhs + radius * rhs;
      }
    };
    
    void myFunction() {
        double radius = 0.0;
        double center[3] = { 0, 0, 0 };
        double direction[3] = { -1, 1, 1 };
    
        transform(
              center,
              center + 3,
              direction,
              newCounds.center,
              multiply_and_add(radius));
    }
    

    Ungetestet, sollte aber hoffentlich richtig sein.


  • Mod

    Der Form halber hier noch die verschachtelte Version, man beachte das -3 nach dem inneren transform:

    transform(
                  center,
                  center + 3,
                  transform(
                            direction,
                            direction + 3,
                            direction,
                            bind2nd(multiplies<double> (), radius)) -3,
                  newCounds.center,
                  plus<double> ());
    

    Zwischenergebnisse werden hier in direction gespeichert, falls dies nicht erwünscht ist, einfach was anderes einsetzen.



  • Cool. Vielen Dank.


Anmelden zum Antworten