Templates aufrufen!

[hunter1670a]

Moin an allen,

ich schreibe gerade ein Template mit dem ich numerische Operationen durchführe, leider weiß ich nicht wie man ein Template von einem "Testerprogramm" aufruf. Kann mir da jemand helfen, weil ich sonst meine Algorithmen nicht testen kann.

hier ein Auszug aus meinem Template:

typedef (*func)(const T&, f) function;

Template <class T> bool simpson(T a, T b, function f, unsigned long max_iter){

T s,s1,s2,s4,h,q,I,n;

n=1;

h=(b-a)/2;

s=f(a)+f(;

s2=0;

q=0;

s4=f(a+h);

s1=h*(s+4*s4);

//if Abfrage --> mit isequal ...

do{

I=s1-q;

if (I <= numeric_limits <T>::epsilon())

max_iter=0;

else

{

h=h/2;

n=2*n;

q=S1;

s4=0;

s2+=s4;

x=a+h;

for(i=1;i=n;i++) {

s4+=f(x);

x+=2*h;

}

s1=(s+2*s2+4*s4)*h;

}

max_iter--;

}while(max_iter != 0);

//Ende der If-Abfrage

s=s1/3;

return s;

Wie kann ich die den simpson von eine Testerprogramm aufrufen ?? Problem ist auch wie versteht das Templet das er die Wert aus der Funktion wie f(x)=x^2 nehmen soll ??

[Klotzkopp]

Original geschrieben von hunter1670a

Wie kann ich die den simpson von eine Testerprogramm aufrufen ??

Es gibt keine spezielle Syntax für den Aufruf von Template-Funktionen. Ruf sie einfach auf wie eine normale Funktion.

Problem ist auch wie versteht das Templet das er die Wert aus der Funktion wie f(x)=x^2 nehmen soll ??

Die Funktion übergibst Du doch offenbar als Parameter. Kannst Du ein wenig verständlicher formulieren, wo das Problem liegt?

[hunter1670a]

Das Template soll wie alle möglichen Funktionen wie sin(x) oder Polynome den Flächeninhalt mit den verschiedenen Verfahren ausrechnen.

Das ist mein bisheriges Testprogramm:

#include <iostream.h>

#include <stdio.h>

#include "Integral.h"

void main()

{

double a =-1;

double b =5;

unsigned long max = 15;

printf ("%.15f\n",Numerik::trapez(a,b,max));

printf ("%.15f\n",Numerik::simpson(a,b,max));

max = 4;

printf ("%.15f\n",Numerik::romberg(a,b,max));

}

Diese Funktion habe ich jetzt in mein Template hingeschrieben um meine Algorithmen wenigstens zu testen.

double f (double x)

{

double g = ((x*x)+(2*x)-1);

return g;

}

Diese Funktion darf aber gar nicht in dem Template stehen sondern im Testprogramm, und da ist mein Problem wie findet mein Template die Funktion aus dem Test Programm

[Klotzkopp]

Original geschrieben von hunter1670a

Diese Funktion darf aber gar nicht in dem Template stehen sondern im Testprogramm, und da ist mein Problem wie findet mein Template die Funktion aus dem Test Programm

Indem Du den Funktionszeiger übergibst.

[Orffi]

Ich habe vor langer Zeit auch mal so ein Programm geschrieben. Ist nicht besonders hübsch, aber wen es stört, kann es ja ändern. Heute morgen hatte ich jedenfalls keine Lust dazu. Ich habe meine Funktion, die berechnet werden soll als Klasse implementiert und dann an das Template übergeben.

# include <iostream>

# include <math>


class TIntervall

{

    private:

        double FIntervall[2];

        int FIntervallSwitch;

    public:

        TIntervall ( void );

        TIntervall ( double, double );

        void setIntervall ( double, double );

        double getLowerBorder ( void );

        double getHigherBorder ( void );

};


TIntervall :: TIntervall ( void )

{

    FIntervallSwitch = 0;


    FIntervall[0] = 0.0;

    FIntervall[1] = 0.0;

}


TIntervall :: TIntervall ( double a, double b )

{

    setIntervall ( a, b );

}


void TIntervall :: setIntervall ( double a, double b )

{

    if ( a < b )

        FIntervallSwitch = 0;

    else

        FIntervallSwitch = 1;


    FIntervall[FIntervallSwitch%2] = a;

    FIntervall[FIntervallSwitch%2+1] = b;

}


double TIntervall :: getLowerBorder ( void )

{

    return FIntervall[FIntervallSwitch%2];

}


double TIntervall :: getHigherBorder ( void )

{

    return FIntervall[FIntervallSwitch%2+1];

}


//---------------------------------------------------------------------------


template <class Function> class TTrapez

{

    public:

        double integrate ( TIntervall, int );

};


template <class Function>

double TTrapez <Function> :: integrate ( TIntervall inter, int n )

{

    Function f;

    double ret = f ( inter.getLowerBorder () ) + f ( inter.getHigherBorder () );

    double step = ( inter.getHigherBorder () - inter.getLowerBorder () ) / n;


    for ( int i = 1; i < n; i++ )

        ret += 2 * f ( inter.getLowerBorder () + i * step );


    return ret * ( step / 2 );

}


//---------------------------------------------------------------------------


template <class Function> class TSimpson

{

    public:

        double integrate ( TIntervall, int );

};


template <class Function>

double TSimpson <Function> :: integrate ( TIntervall inter, int n )

{

    Function f;

    double ret = f ( inter.getLowerBorder () ) + f ( inter.getHigherBorder () );

    double step = ( inter.getHigherBorder () - inter.getLowerBorder () ) /

                    ( 2 * n );


    for ( int i = 1; i < ( 2 * n ); i++ )

        ret += ( 2 * ( i % 2 ) + 2 ) * f ( inter.getLowerBorder () + i * step );


    return ret * ( step / 3 );

}


//---------------------------------------------------------------------------


class TSinus

{

    public:

        double operator() ( double );

};


double TSinus :: operator () ( double x )

{

    return std::sin ( x );

}


//---------------------------------------------------------------------------


int main ( void )

{

    TTrapez <TSinus> TrapezIntegral;

    TSimpson <TSinus> SimpsonIntegral;

    TIntervall intervall ( 0, 1 );


    std::cout.precision ( 20 );

    std::cout << "Ergebnisse fuer f(x) = sin(x) mit Trapezregel: " << std::endl;


    for ( int i = 1; i < 11; i++ )

    {

	std::cout << "Fuer n = ";

        std::cout.width ( 2 );

        std::cout << i << ": " << TrapezIntegral.integrate ( intervall, i ) << std::endl;

    }


	std::cout << std::endl << "Ergebnisse fuer f(x) = sin(x) mit Simpson-Regel: " << std::endl;


    for ( int i = 1; i < 11; i++ )

    {

	std::cout << "Fuer n = ";

        std::cout.width ( 2 );

        std::cout << i << ": " << SimpsonIntegral.integrate ( intervall, i ) << std::endl;

    }


    return 0;

}

HTH

Jan