example_Ode.txt

The following source file shows some calc::Ode functions applied with calc::Cpx variables. Initially, a test function along with its first and and second derivatives are defined (fn(x), dfn(x), ddfn(x)). Parameters are set indicating the integration interval and the accuracy of the intergration. The calc::Ode objects are given initial values of fn(x) and dfn(x) at the start of the boundary. The second derivative is supplied to the calc::Ode objects through the call back function fnOde(dy,y,x). The solution of the test function fn(x) evaluated at the upper bound along with its derivative are produced as output overwriting the initial conditions in the y array by the call to Ode::eval().

 #include "Cpx.h"                                      // complex variable definitions
 #include "Ode.h"                                      // differential equation objects

 using namespace std;                                  // standard C++ library namespace
 using namespace calc;                                 // CalcLib namespace

 typedef Cpx<float> CPXf;                              // alias for <yType>

 // test function data
 const CPXf C1(-1.0f,-1.0f);                           // test function constant
 const CPXf C2(-1.0f, 1.0f);                           // test function constant
 CPXf   fn(float x) {return  sin(C2*x)*C1;}            // test function
 CPXf  dfn(float x) {return  cos(C2*x)*C1*C2;}         // test function 1st derivative
 CPXf ddfn(float x) {return -sin(C2*x)*C1*C2*C2;}      // test function 2nd derivative

 // 2nd derivative callback function
 void fnOde(CPXf *dy, CPXf *y, float x)                // derivative identifier function
 {
    dy[0]=y[1];                                        // 0th derivative in dy is 1st derivative in y 
    dy[1]=ddfn(x);                                     // 1st derivative in dy is derived function ddfn(x)
 }

 // results print function
 void results(ostream &ostr, const char *cDat, CPXf cpf, int nCnt)
 {
    ostr<<"   "<<cDat<<" = ";                          // print out title
    cpf.stream(ostr)<<"  ("<<nCnt<<" steps)";          // print data values
    ostr<<endl;                                        // end the text line
 }

 int main(void)
 {
    // set parameters
    const int nVar=2;                                  // integration array count
    const float xLo   =0.0f;                           // integration lower bound
    const float xHi   =0.25f*Base::PI;                 // integration upper bound
    const float yError=0.05f;                          // integration error
    const CPXf y0=fn(xHi);                             // final answer
    CPXf y1[2],y4[2],y8[2];                            // evaluation arrays

    // initialize data
    Ode<float,CPXf> ode1(fnOde,yError,nVar);           // initialize differential equation objects
    Ode<float,CPXf> ode4=ode1;                         // initialize differential equation objects
    Ode<float,CPXf> ode8=ode4;                         // initialize differential equation objects
    y1[0]=y4[0]=y8[0]= fn(xLo);                        // set evaluation array[0] at start value
    y1[1]=y4[1]=y8[1]=dfn(xLo);                        // set evaluation array[1] at start derivative

    // evaluate ordinary differential equation
    try {
       ode1.eval(y1,xLo,xHi,(xHi-xLo)/1.0f);           // integrate from xLo to xHi in about 1 step
       ode4.eval(y4,xLo,xHi,(xHi-xLo)/4.0f);           // integrate from xLo to xHi in about 4 steps
       ode8.eval(y8,xLo,xHi,(xHi-xLo)/8.0f);           // integrate from xLo to xHi in about 8 steps
    }
    catch(OdeErr& odeErr) {cout<<odeErr<<endl; return 1;}
    catch(...) {cout<<"Unknown execution error..."<<endl; return 1;}

    // print out evaluations comparing the functions
    cout.precision(5);
    cout.setf(ios::showpoint,ios::showpoint);
    cout<<endl<<"   calc::Ode Class Example Application"<<endl<<endl;
    cout<<"   exact evaluation of fn(x)        fn(x) = "; y0.stream(cout)<<"  (exact)"<<endl;
    results(cout,"Runge-Kutta estimate of fn(x)  ode1(x)",y1[0],ode1.getCount(ode1.CURRENT));
    results(cout,"Runge-Kutta estimate of fn(x)  ode4(x)",y4[0],ode4.getCount(ode4.CURRENT));
    results(cout,"Runge-Kutta estimate of fn(x)  ode8(x)",y8[0],ode8.getCount(ode8.CURRENT));
    cout<<endl<<flush;

    return 0;
 }

The following output file shows the approximate agreement among the test function fn(x), the calc::Ode objects (ode1,ode4,ode8) applying different initial step sizes (1,4,8). To start initial calculations, the calc::Ode object should have a step size supplied (guessed) by the user. The calc::Ode objects use variable step sizes and monitor the increment values based on the supplied error limit. As shown in the output (8 steps to 3 steps), calc::Ode objects lower the suggested step size quickly if the one supplied is too high. From the output data, only one step is needed for the desired accuracy.

   calc::Ode Class Example Application

   exact evaluation of fn(x)        fn(x) = 1.5509+i0.32240  (exact)
   Runge-Kutta estimate of fn(x)  ode1(x) = 1.5509+i0.32231  (1 steps)
   Runge-Kutta estimate of fn(x)  ode4(x) = 1.5509+i0.32238  (2 steps)
   Runge-Kutta estimate of fn(x)  ode8(x) = 1.5509+i0.32239  (3 steps)

---