example_Intp.txt

The following source file shows several calc::Mtx and calc::Intp objects applied. The source and output files demonstrate that data can be defined in an array of matrices calc::Mtx, and that this array of matrix data points can be interpolated between by calc::Intp interpolation objects. The objective in this example is to show that, when oscillating data is interpolated, interpolation error increases with data frequency.

Initially, an array of tabulated data points is generated which aids in forming the calc::Mtx matrix objects and the calc::Intp interpolation objects. Each matrix has 1 row and 3 columns. The first matrix column contains data at the lowest frequency. The frequency of the data is incremented for the other columns. Each matrix contains wave interpolation data for a specific location, there are 10 matrices which span the location space of the wave data.

The array of 10 calc::Mtx matrices are passed to one-dimensional interpolation objects which construct wave curves for each of the 3 frequencies. Three different interpolation methods are used: (1) calc::Cube (cubic splines); (2) calc::Nurb (non-uniform rational Bezier splines); (3) calc::Poly (polynomial curve-fit splines). Each interpolation object is evaluated at the same data point.

 #include "Mtx.h"                                      // matrix definitions
 #include "Intp.h"                                     // function interpolation objects

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

 typedef Mtx<float> MTXf;                              // alias for <yType>

 // results print function
 void results(ostream &ostr, const char *cDat, MTXf mtx)
    {ostr<<"   "<<cDat<<"  "<<mtx<<endl;}              // print out text and values

 int main(void)
 {
    // determine matrix size
    const int NPTS=10;                                 // number of data points to curve-fit
    const int NROW=1;                                  // number of rows in matrix
    const int NCOL=3;                                  // number of columns in matrix

    // set parameters
    float aFrq[NCOL];                                  // frequency of data in each column
    float xLoc[NPTS];                                  // distance data of waves across interpolation
    float aMtx[NPTS][NCOL];                            // matrix array for data

    // determine input data
    for(int iCol=0; iCol<NCOL; iCol++)
       aFrq[iCol]=2.0*Base::PI*(float)(iCol+1);        // frequency data across columns
    for(int iPt=0; iPt<NPTS; iPt++)
       xLoc[iPt]=(float)(iPt)/(float)(NPTS-1);         // location data across interpolation points
    for(int iPt=0; iPt<NPTS; iPt++)
       for(int iCol=0; iCol<NCOL; iCol++)
          aMtx[iPt][iCol]=sin(aFrq[iCol]*xLoc[iPt]);   // determine array data

    // initialize array of matrices for each interpolation point
    MTXf yMtx[NPTS];
    for(int iPt=0; iPt<NPTS; iPt++)
       yMtx[iPt]=MTXf(aMtx[iPt],NROW,NCOL); 

    // initialize interpolation objects with matrix data
    Cube< float,MTXf > cube(xLoc,yMtx,NPTS);
    Nurb< float,MTXf > nurb=cube;
    Poly< float,MTXf > poly=nurb;

    // calculate test point values for comparison
    const float xTst=0.38f;                            // test evaluation location for comparison
    float aTst[NCOL];                                  // test evaluation points for comparison
    for(int iCol=0; iCol<NCOL; iCol++)
       aTst[iCol]=std::sin(aFrq[iCol]*xTst);           // determine exact value of test point
    MTXf yTst(aTst,NROW,NCOL);                         // put test data in matrix object
    MTXf xFrq(aFrq,NROW,NCOL);                         // put frequency data in matrix object

    // compare polynomial evaluations at same point
    cout.precision(5);
    cout.setf(ios::showpoint,ios::showpoint);
    try {
       cout<<endl<<"   calc::Intp Class Example Application"<<endl<<endl;
       results(cout,"Wave function data frequencies:  ",xFrq); cout<<endl;
       results(cout,"calc::Cube interpolation Errors: ",cube.eval(xTst)-yTst);
       results(cout,"calc::Nurb interpolation Errors: ",nurb.eval(xTst)-yTst);
       results(cout,"calc::Poly interpolation Errors: ",poly.eval(xTst)-yTst);
       cout<<endl<<flush;
    }
    catch(IntpErr& intpErr) {cout<<intpErr<<endl; return 1;}
    catch(MtxErr& mtxErr) {cout<<mtxErr<<endl; return 1;}
    catch(...) {cout<<"Unknown execution error..."<<endl; return 1;}

    return 0;
 }

The following output file shows the error between the interpolation calculations and and the exact calculations. The input frequency values used in the calculations are given on the first line. Interpolation errors are then shown for eacn of the 3 interpolation objects at each of the 3 frequencies. As the data shows, interpolation error increases with data frequency.

   calc::Intp Class Example Application

   Wave function data frequencies:    {        6.2832,        12.566,        18.850}

   calc::Cube interpolation Errors:   {   -0.00040424,      0.014513,      -0.10721}
   calc::Nurb interpolation Errors:   {   -0.00048798,      0.012479,      -0.11576}
   calc::Poly interpolation Errors:   {    -0.0033833,      0.072701,      -0.25700}

---