#ifndef utils_h
#define utils_h
#include <iostream>
#include <fstream>
#include "TH1F.h"
#include "TH1D.h"
#include <stdio.h>
#include <string>
#include <sstream>
#include <vector>
#include <float.h>
#include <time.h>

static bool debug;
/*
template <typename T>
std::vector<T> arrtovec(T *arr)
{
 int size = sizeof(arr)/sizeof(*arr);
 cout<<"SIZE = "<<sizeof(arr)<<" / "<<sizeof(*arr)<<endl;
 std::vector<T> result;

 for(int i=0; i<size;i++) {result.push_back(arr[i]); cout<<arr[i]<<endl;}

 return result;
}
*/

static clock_t bef_counter=0;
static std::ofstream operf_file;

void time(int i=1)
{
 if(i==0) {operf_file.open("./performance.txt",std::ios::app);bef_counter=0; return;}
 clock_t dif_counter = clock() - bef_counter;
 bef_counter = clock();
 operf_file<<"Time "<<i<<" elapsed "<<((float)dif_counter)/CLOCKS_PER_SEC<<" seconds"<<std::endl;
 std::cout<<"Time "<<i<<" elapsed "<<((float)dif_counter)/CLOCKS_PER_SEC<<" seconds"<<std::endl;
 if(i== -1) operf_file.close();
}

template <class T>
T AddH(T A, T B, double a=1, double b=1)
{
 A = a*A;
 B = b*B;

 int size = A.GetSize()-2;
 double low = A.GetBinLowEdge(1);
 double high= A.GetBinLowEdge(size+1);

 std::string name = string( A.GetName() )+string( B.GetName() );
 T C(name.c_str(),"",size,low,high);

 for(int bin=1;bin<=size;bin++) C.SetBinContent(bin, A.GetBinContent(bin)+B.GetBinContent(bin) );

 return C;
}

template <class T>
std::vector<T> vmerge ( std::vector<T> a, std::vector<T> b)
{
 std::vector<T> c;
 for(int i=0;i<(int)a.size();i++) c.push_back(a[i]);
 for(int i=0;i<(int)b.size();i++) c.push_back(b[i]);
 return c;
}

template <class T>
T f_min(T a, T b)
{
      if(a <  b) return a;
 else if(a == b) return a;
 else           return b;
}

template <class T>
T f_max(T a, T b)
{
      if(a > b) return a;
 else if(a == b) return a;
 else           return b;
}

void pr(double f)
{
 if(debug) printf("marker %f \n",f);
}

std::string parse(std::string input, std::string init, std::string end)
{
 //A B C D E
 size_t B_pos = input.find(init.c_str());
 std::string CDE = input.substr(B_pos+init.size());
 size_t C_size = CDE.find( end.c_str() );
 std::string C = CDE.substr(0,C_size);

 return C;
}


std::string substring(std::string line,int word)
{
  std::istringstream get(line);
  std::string out;
  for(int i=0;i < word; i++) get >> out;
  return out;
}

std::string character(int i)
{
 std::stringstream s;
 s << i;

 return s.str();
}


std::string character(double f)
{
 std::stringstream s;
 s << f;

 return s.str();
}

double Maximum(std::vector<double> input)
{
 double maximum=-1e10;

 for(int i=0;i<(int)input.size();i++)
 {
  if(input.at(i) >= maximum ) maximum=input.at(i);
 }

 return maximum;
}

double Minimum(std::vector<double> input)
{
 double minimum=1e10;

 for(int i=0;i<(int)input.size();i++)
 {
  if(input.at(i) <= minimum ) minimum=input.at(i);
 }

 return minimum;
}

///////////////////////////////////////////////////////////////////////////////////
class POINT_MAX
{
  public:

  double max_dep,max_x,max_y,max_z;
  POINT_MAX();
  void GetPoint(double dep,double x=0,double y=0, double z=0);
};

POINT_MAX::POINT_MAX()
{
   max_dep=-DBL_MAX; max_x=-111; max_y=-111;
}

void POINT_MAX::GetPoint(double dep,double x,double y, double z)
{
 if(dep > max_dep) {max_dep=dep; max_x=x; max_y=y; max_z=z;}
}
///////////////////////////////////////////////////////////////////////////////////
class POINT_MIN
{
  public:

  double min_dep,min_x,min_y,min_z;
  POINT_MIN();
  void GetPoint(double dep,double x=0,double y=0, double z=0);
};

POINT_MIN::POINT_MIN()
{
   min_dep=-DBL_MIN; min_x=-111; min_y=-111;
}

void POINT_MIN::GetPoint(double dep,double x,double y, double z)
{
 if(dep > min_dep) {min_dep=dep; min_x=x; min_y=y; min_z=z;}
}
///////////////////////////////////////////////////////////////////////////////////
#endif