JPolynome3D+2D.cc File Reference

Example program to test multi-dimensional interpolation with multi-dimensional function objects. More...

#include <string>
#include <iostream>
#include <iomanip>
#include "TRandom3.h"
#include "JTools/JMapList.hh"
#include "JTools/JFunction1D_t.hh"
#include "JTools/JFunctionalMap_t.hh"
#include "JTools/JMultiFunction.hh"
#include "JTools/JQuantile.hh"
#include "Jeep/JTimer.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
double	f5 (const double x0, const double x1, const double x2, const double x3, const double x4)
	5D function.
int	main (int argc, char **argv)

Detailed Description

Example program to test multi-dimensional interpolation with multi-dimensional function objects.

Author

mdejong

Definition in file JPolynome3D+2D.cc.

Function Documentation

f5()

double f5 ( const double x0, const double x1, const double x2, const double x3, const double x4 )

inline

5D function.

Definition at line 22 of file JPolynome3D+2D.cc.

{
  static const double a = 1.0;
  static const double b = 1.0;
  static const double c = 1.0;
 
  return 
    x0 * (a + x0 * (b + c*x0))  *  
    x1 * (a + x1 * (b + c*x1))  *
    x2 * (a + x2 * (b + c*x2))  *
    x3 * (a + x3 * (b + c*x3))  *
    x4 * (a + x4 * (b + c*x4));
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 46 of file JPolynome3D+2D.cc.

{
  using namespace std;
 
  int         numberOfEvents;
  int         numberOfBins;
  int         debug;
 
  try {
 
    JParser<> zap("Example program to test multi-dimensional interpolation with multi-dimensional function objects.");
 
    zap['n'] = make_field(numberOfEvents)   = 1000;
    zap['N'] = make_field(numberOfBins)     = 11;
    zap['d'] = make_field(debug)            = 3;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  using namespace JPP;
 
 
  const double xmin = -1.0;
  const double xmax = +1.0;
  const double dx   = (xmax - xmin) / (numberOfBins - 1);
 
 
  typedef JGridPolint3Function1D_t                          JFunction1D_t;
 
  typedef JMAPLIST<JPolint3FunctionalGridMap>::maplist      JMaplist1D_t;
 
  typedef JMAPLIST<JPolint3FunctionalGridMap,
                   JPolint3FunctionalGridMap,
                   JPolint3FunctionalGridMap>::maplist      JMaplist3D_t;
  
  typedef JMultiFunction<JFunction1D_t, JMaplist1D_t>       JFunction2D_t;
  typedef JMultiFunction<JFunction2D_t, JMaplist3D_t>       JFunction5D_t;
 
  JFunction5D_t g5;
 
 
  for (double x0 = xmin; x0 <= xmax + 0.5*dx; x0 += dx) {
    for (double x1 = xmin; x1 <= xmax + 0.5*dx; x1 += dx) {
      for (double x2 = xmin; x2 <= xmax + 0.5*dx; x2 += dx) {
        for (double x3 = xmin; x3 <= xmax + 0.5*dx; x3 += dx) {
          for (double x4 = xmin; x4 <= xmax + 0.5*dx; x4 += dx) {
            g5[x0][x1][x2][x3][x4] = f5(x0, x1, x2, x3, x4);
          }
        }
      }
    }
  }
    
  g5.compile();
  g5.setExceptionHandler(new JFunction1D_t::JDefaultResult(JMATH::zero));
 
 
  if (numberOfEvents > 0) {
 
    JTimer timer;
 
    JQuantile Q;
    
    for (int i = 0; i != numberOfEvents; ++i) {
      
      const double x0  = gRandom->Uniform(xmin, xmax);
      const double x1  = gRandom->Uniform(xmin, xmax);
      const double x2  = gRandom->Uniform(xmin, xmax);
      const double x3  = gRandom->Uniform(xmin, xmax);
      const double x4  = gRandom->Uniform(xmin, xmax);
      
      const double v   = f5(x0,x1,x2,x3,x4);
 
      timer.start();
 
      const double w   = g5(x0,x1,x2,x3,x4);
 
      timer.stop();
 
      Q.put(v - w);
    }
 
    Q.print(cout);
 
    timer.print(cout, 1.0 / numberOfEvents);
  }
}