JMath.cc File Reference

Example program to test user class with arithmetic capabilities (based on class JMATH::JMath). More...

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include "TRandom3.h"
#include "JMath/JMath.hh"
#include "Jeep/JPrint.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 user class with arithmetic capabilities (based on class JMATH::JMath).

Author

mdejong

Definition in file JMath.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 116 of file JMath.cc.

{
  using namespace std;
  using namespace JPP;

  double alpha;
  double precision;
  int    debug;

  try {

    JParser<> zap("Example program to test user class with arithmetic capabilities.");

    zap['a'] = make_field(alpha);
    zap['e'] = make_field(precision)      = 1.0e-10;
    zap['d'] = make_field(debug)          = 3;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  gRandom->SetSeed(0);

  const Double_t xmin = -1.0;
  const Double_t xmax = +1.0;
 

  const JObject A(gRandom->Uniform(xmin, xmax),
                  gRandom->Uniform(xmin, xmax),
                  gRandom->Uniform(xmin, xmax));

  const JObject B(gRandom->Uniform(xmin, xmax),
                  gRandom->Uniform(xmin, xmax),
                  gRandom->Uniform(xmin, xmax));

  const JObject C = A + B;
  const JObject D = A * alpha;
  const JObject E = interpolate(A, B, alpha);

  DEBUG("A           " << A << endl);
  DEBUG("B           " << B << endl);
  DEBUG("A + B     = " << C << endl);
  DEBUG("A * alpha = " << D << endl);
  DEBUG("interpolate " << E << endl);

  ASSERT(fabs(C.x - (A.x + B.x)) <= precision, "test of addition");
  ASSERT(fabs(C.y - (A.y + B.y)) <= precision, "test of addition");
  ASSERT(fabs(C.z - (A.z + B.z)) <= precision, "test of addition");

  ASSERT(fabs(D.x - (A.x * alpha)) <= precision, "test of multiplication");
  ASSERT(fabs(D.y - (A.y * alpha)) <= precision, "test of multiplication");
  ASSERT(fabs(D.z - (A.z * alpha)) <= precision, "test of multiplication");

  ASSERT(fabs(E.x - (A.x * (1.0 - alpha) + B.x * alpha)) <= precision, "test of interpolation");
  ASSERT(fabs(E.y - (A.y * (1.0 - alpha) + B.y * alpha)) <= precision, "test of interpolation");
  ASSERT(fabs(E.z - (A.z * (1.0 - alpha) + B.z * alpha)) <= precision, "test of interpolation");

  {
    vector<JObject> buffer;

    double x = 0.0;
    double y = 0.0;
    double z = 0.0;

    const int N = 10;

    for (int i = 0; i != N; ++i) {

      buffer.push_back(JObject(gRandom->Uniform(xmin, xmax),
                               gRandom->Uniform(xmin, xmax),
                               gRandom->Uniform(xmin, xmax)));
                     
      x += buffer.rbegin()->x;
      y += buffer.rbegin()->y;
      z += buffer.rbegin()->z;
    }

    x /= N;
    y /= N;
    z /= N;

    JObject U = getAverage(buffer.begin(), buffer.end());

    DEBUG("U           " << U              << endl);
    DEBUG("U'          " << JObject(x,y,z) << endl);

    ASSERT(fabs(U.x - x) <= precision, "test of averaging");
    ASSERT(fabs(U.y - y) <= precision, "test of averaging");
    ASSERT(fabs(U.z - z) <= precision, "test of averaging");
  }

  {
    double buffer[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };

    ASSERT(fabs(getAverage(buffer) - 5.0) <= precision, "test of averaging");
  }
  
  return 0;
}