// These are my template function to work with containers. Always pass iterators, never containers directly !                                   
//
// courtesy of orsone.mi.inf.it

using namespace std;

namespace mySTD {

  template<typename _ForwardIterator> void print(_ForwardIterator __first, _ForwardIterator __last)
    {
      unsigned int i = 0;
      for (_ForwardIterator __i = ++__first; __i != __last; ++__i)
	{
	  cout << "Element " << i << " = " << (*__i) << endl;
	  i++;
	}
    }

  template<typename _ForwardIterator> double myVar(_ForwardIterator __first, _ForwardIterator __last)
    {
      double result=0.;
      if (__first == __last) return result;

      double old_average, average=0.;
      double sumx  = 0;
      double sumx2 = 0;

      for (_ForwardIterator __i = __first; __i != __last; ++__i)
	{
	  sumx  += static_cast<double>(*__i);
	  sumx2 += static_cast<double>(*__i)*static_cast<double>(*__i);
	}

      result = 1./static_cast<double>(__last-__first) * ( sumx2 - (sumx*sumx/static_cast<double>(__last-__first)))  ;
      return result;
    }

  template<typename _ForwardIterator> double myAve(_ForwardIterator __first, _ForwardIterator __last)
    {
      double result=0.;
      if (__first == __last) return result;

      for (_ForwardIterator __i = __first; __i != __last; ++__i)
	{
	  result  += static_cast<double>(*__i);
	}

      result = result/static_cast<double>(__last-__first)  ;

      return result ;

    }
  
  // this is an improved version of the average calculation. Avoid large sums

  template<typename _ForwardIterator> double myAve_improved(_ForwardIterator __first, _ForwardIterator __last)
    {
      double result=0.;
      if (__first == __last) return result;
      
      double average=0.;
      unsigned int i =0 ;
      for (_ForwardIterator __i = __first; __i != __last; ++__i)
	{
	  average = static_cast<double>(i)/static_cast<double>(i+1)*average +
	    1./static_cast<double>(i+1)*static_cast<double>(*__i);
	  i++;
	}

      return average;

    }

  // this is an improved version of the Variance calculation. Avoid large sums

  template<typename _ForwardIterator> double myVar_improved(_ForwardIterator __first, _ForwardIterator __last)
    {
      double result=0.;
      if (__first == __last) return result;
  
      double old_average, average=0.;
      unsigned int i =0 ;
      for (_ForwardIterator __i = __first; __i != __last; ++__i)
	{
	  old_average = average;
	  average = static_cast<double>(i)/static_cast<double>(i+1)*average +
	    1./static_cast<double>(i+1)*static_cast<double>(*__i);
      
	  result = 1./static_cast<double>(i+1) *
	    (static_cast<double>(i) * result +
	     static_cast<double>(*__i)*static_cast<double>(*__i) +
	     static_cast<double>(i) * old_average*old_average -
	     static_cast<double>(i+1) * average*average );
	  i++;
	}
      
      return result;
    }

  template<class T> void ReadVector( string filename  , unsigned int n , T &  data)
    {
      double temp;
      ifstream inputFile(filename);
      
      if ( !inputFile ) {
	cout << "Cannot open file " << filename << endl;
      } else {
	for (unsigned int i=0; i<n; i++) {
	  inputFile >> temp;
	  data.push_back( static_cast<double> (temp) );
	  if ( inputFile.eof() ) {
	    cout << "Stop reading after " << i << " entries!" << endl;
	    break;
	  }
	}
      }      
    }
  

}