example_Cheb.txt

The following source file shows several calc::Cheb functions applied with calc::Cpx variables. Initially, a test function along with its derivative and integral are defined (dfn(x), fn(x), ifn(x)). Parameters are set indicating the interpolation interval of the function and the accuracy of the interpolation. The class calc::Interp uses the test functions (dfn(x), fn(x), ifn(x)) to derive a set of objects with Chebyshev polynomial coefficients. These calc::Interp objects (fn0, ifn1, dfn2) should approximate the corresponding function within the specified error limits and interval. The class calc::Differ takes the derivative of calc::Interp ifn1 which should approximate the test function fn(x) and its interpolated equivalent fn0. The class calc::Integr takes the integral of calc::Differ dfn2 which should also approximate the test function fn(x) and its interpolated equivalent fn0.

 #include "Cpx.h"                                      // complex variable definitions
 #include "Cheb.h"                                     // Chebyshev polynomial objects
 #include "PrtC.h"                                     // auxiliary print stream object

 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 C1*sin(C2*x);}              // test function
 CPXf dfn(float x) {return C1*C2*cos(C2*x);}           // test function derivative
 CPXf ifn(float x) {return C1/C2*(1.0f-cos(C2*x));}    // test function integral

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

 int main(void)
 {
    // set parameters
    const float xLo   =0.0f;                           // domain lower value
    const float xHi   =0.5f*Base::PI;                  // domain upper value
    const float yError=0.05f;                          // polynomial curve-fit error
    CPXf y,y0,y1,y2;                                   // evaluation variables

    // determine interpolation coefficients
    Interp<float,CPXf>  fn0( fn,xLo,xHi,yError);       // curve-fit test function
    Interp<float,CPXf> ifn1(ifn,xLo,xHi,yError);       // curve-fit integral test function
    Interp<float,CPXf> dfn2(dfn,xLo,xHi,yError);       // curve-fit derivative test function

    // Integrate or differentiate to get the same function
    Differ<float,CPXf> fn1=ifn1;                       // differentiate integral test function
    Integr<float,CPXf> fn2=dfn2;                       // integrate derivative test function

    // evaluate equivalent function at same point
    const float xEval =0.25f*Base::PI;                 // evaluation point
    try {
       y=fn(xEval);                                    // test function
       y0=fn0.eval(xEval);                             // interpolated function
       y1=fn1.eval(xEval);                             // differentiated function
       y2=fn2.eval(xEval);                             // integrated function
    }
    catch(ChebErr& chebErr) {cout<<chebErr<<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::Cheb Class Example Application"<<endl<<endl;
    cout<<"   exact evaluation of fn(x)          fn(x) = "; y.stream(cout)<<"  (exact)"<<endl;
    results(cout,"interpolate fn(x)                 fn0(x)",y0,fn0.getCount());
    results(cout,"interpolate derivative of ifn(x)  fn1(x)",y1,fn1.getCount());
    results(cout,"interpolate integral of dfn(x)    fn2(x)",y2,fn2.getCount());
    cout<<endl;

    // print defining Chebyshev data in "C style" format
    PrtC pr;                                           // create print object
    pr.setFormat("float","CPXf");                      // identify labels for <xType,yType>
    pr.setFormat(pr.LABEL,"fn1(x)");                   // set variable label
    pr.setFormat(pr.WIDTH,10);                         // set data field width
    pr.stream(cout,fn1);                               // send the Cheb data to the output stream
    cout<<flush;                                       // clear print buffer

    return 0;
 }

The following output file shows the approximate agreement among the test function fn(x), the calc::Interp Chebyshev polynomial object fn0.eval(x), the calc::Differ Chebyshev polynomial object fn1.eval(x), and the calc::Integr Chebyshev polynomial object fn2.eval(x). The output file includes an output using a "C style" format of a calc::Differ object through the calc::PrtC object. All information required to duplicate the object fn1 is included in the "C style" printout.

   calc::Cheb Class Example Application

   exact evaluation of fn(x)          fn(x) = 1.5509+i0.32240  (exact)
   interpolate fn(x)                 fn0(x) = 1.5630+i0.32558  (4 coefficients)
   interpolate derivative of ifn(x)  fn1(x) = 1.5570+i0.32393  (3 coefficients)
   interpolate integral of dfn(x)    fn2(x) = 1.5502+i0.32159  (5 coefficients)


   // fn1(x) Cheb Function Interpolation Parameters

   // fn1(x) Low,High Interval Boundary Data Array
   const float      xBound    [ 2]={ float(0.00000e+00), float(1.57080e+00)};

   // fn1(x) (-1,+1) Chebyshev Interval Transformation Values
   const float      xScale        =  float(1.27324e+00);
   const float      xOffset       =  float(-1.00000e+00);

   // fn1(x) Characteristic Data Point Count
   const int        nPoints       =  int(         3);

   // fn1(x) Polynomial Coefficient Data Array
   const CPXf       arC       [ 3]={ CPXf(2.84182e+00,1.58692e+00), CPXf(1.36633e+00,1.11217e+00), CPXf(-1.36061e-01,4.69531e-01)};

---