JPolynome1P.cc File Reference

Example program to test 1D interpolation of a polynome. More...

#include <string>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include "TRandom3.h"
#include "JLang/JException.hh"
#include "JMath/JPolynome.hh"
#include "JTools/JFunction1D_t.hh"
#include "JTools/JGrid.hh"
#include "JTools/JQuantile.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Example program to test 1D interpolation of a polynome.

Author

mdejong

Definition in file JPolynome1P.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 25 of file JPolynome1P.cc.

{
  using namespace std;
  using namespace JPP;
 
  unsigned int  numberOfEvents;
  unsigned int  numberOfBins;
  JPolynome     f1;
  double        x0;
  int           debug;
 
  try {
 
    JParser<> zap("Example program to test 1D interpolation of a polynome.");
 
    zap['n'] = make_field(numberOfEvents)   =  0;
    zap['N'] = make_field(numberOfBins)     = 21;
    zap['P'] = make_field(f1);
    zap['x'] = make_field(x0)               =  0.0;
    zap['d'] = make_field(debug)            =  1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  if (f1.empty()) {
    FATAL("Invalid polynomial.");
  }
 
 
  const int N = 3;                      // degree of polynomial interpolation
  
  typedef JResultPolynome<N, double>                                                JResult_t;
  typedef JPolintFunction1D<N, JElement2D<double, double>, JCollection, JResult_t>  JFunction1D_t;
 
 
  JFunction1D_t  polint;
 
 
  const double xmin = -1.0;
  const double xmax = +1.0;  
 
  polint.configure(JGrid<double>(numberOfBins, xmin, xmax), f1);
  
  polint.compile();
  
  polint.setExceptionHandler(new JFunction1D_t::JDefaultResult(JMATH::zero));
    
 
  vector<JPolynome> fp(1, f1);
 
  for (int i = 1; i != (int) f1.size(); ++i) {
    fp.push_back(fp.rbegin()->getDerivative());
  }
 
  DEBUG("polynome: ");
 
  for (int i = 0; i != (int) f1.size(); ++i) {
    DEBUG(' ' << fp[i](x0));
  }
  DEBUG(endl);
 
  DEBUG("result:   ");
 
  JResult_t result = polint(x0);
 
  for (int i = 0; i != N+1; ++i) {
    DEBUG(' ' << result.y[i]);
  }
  DEBUG(endl);
 
 
  if (numberOfEvents != 0) {
 
    JQuantile Q[N+1];
 
    for (int j = 0; j != sizeof(Q)/sizeof(Q[0]); ++j) {
 
      ostringstream os;
 
      os << "f^" << j;
 
      Q[j].setTitle(os.str());
    }
 
    const int M = min(fp.size(), sizeof(Q)/sizeof(Q[0]));
 
    for (unsigned int i = 0; i != numberOfEvents; ++i) {
 
      const double x   = gRandom->Uniform(xmin, xmax);
      
      JResult_t result = polint(x);
 
      for (int j = 0; j != M; ++j) {
        Q[j].put(fp[j](x) - result.y[j]);
      }
    }
 
    for (int j = 0; j != M; ++j) {
      Q[j].print(cout, j == 0);
    }
  }
}