/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2007

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #ifndef LEMON_RANDOM_H

 #define LEMON_RANDOM_H

 #include<iostream>

 #include<fstream>

 #include<string>

 #include <lemon/dim2.h>

 ///\ingroup misc

 ///\file

 ///\brief Measure a Distribution

 ///

 ///\todo Needs lot more docs

 ///

 namespace lemon {

   ///Measure a distribution

   class DistLog

   {

     std::vector<int> _dist;

     double _lo,_up;

     int _count;

     bool _cut;

   public:

     ///\e

     Dist(double lo,double up,int gr,bool cut=true) 

       : _dist(gr,0),_lo(lo),_up(up),_count(0),_cut(cut) {}

     ///\e

     void operator()(double v)

     {

       if(_cut) {

 	if(_lo<=v && v<_up)

 	  _dist[int((v-_lo)/(_up-_lo)*_dist.size())]++;

       }

       else {

 	_dist[std::max(0,std::min(int(_dist.size())-1,

 				  int((v-_lo)/(_up-_lo)*_dist.size())

 				  ))]++;

       }

       _count++;

     }

     ///\e

     void dump(std::ostream& os=std::cout)

     {

       for(int i=0;i<_dist.size();i++)

 	os << _lo+(i+0.5)*(_up-_lo)/_dist.size() << ' '

 	   << double(_dist[i])/_count << std::endl;

     }

     ///\e

     void dump(const std::string& file_name)

     {

       dump(std::ofstream(file_name.c_str()));

     }

   };

   ///Measure a two dimensional distribution

   class DistLog2

   {

   public:

     typedef dim2::Point<double> Point;

   private:

     std::vector<int> _dist;

     int _gr;

     Point _lo,_up;

     int _count;

     bool _cut;

   public:  

     ///\e

     Dist2(Point a,Point b,int gr,bool cut=true) :

       _dist(gr*gr,0),_gr(gr),

       _lo(a),_up(b),_count(0),_cut(cut) {}

     ///\e

     Dist2(double lox,double upx,double loy,double upy,int gr,bool cut=true) :

       _dist(gr*gr,0),_gr(gr),

       _lo(Point(lox,loy)),_up(Point(upx,upy)),_count(0),_cut(cut) {}

     ///\e

     void operator()(Point v)

     {

       if(_cut)

 	{

 	  if(v.x>=_lo.x && v.x<_up.x && v.y>=_lo.y && v.y<_up.y)

 	    _dist[int((v.x-_lo.x)/(_up.x-_lo.x)*_gr)*_gr+

 		  int((v.y-_lo.y)/(_up.y-_lo.y)*_gr)]++;

 	}

       else {

 	_dist[std::max(0,std::min(_gr-1,

 				  int((v.x-_lo.x)/(_up.x-_lo.x)*_gr)

 				  ))*_gr+

 	      std::max(0,std::min(_gr-1,

 				  int((v.y-_lo.y)/(_up.y-_lo.y)*_gr)

 				  ))

 	      ]++;

       }

       _count++;

     }

     ///\e

     void dump(std::ostream& os=std::cout)

     {

       for(int i=0;i<_gr;i++)

 	{

 	  for(int j=0;j<_gr;j++)

 	    os << _lo.x+(i+0.5)*(_up.x-_lo.x)/_gr << ' '

 	       << _lo.y+(j+0.5)*(_up.y-_lo.y)/_gr << ' '

 	       << double(_dist[i*_gr+j])/_count << std::endl;

 	  os << std::endl;

 	}

     }

     ///\e

     void dump(const std::string& file_name)

     {

       dump(std::ofstream(file_name.c_str()));

     }

   };

 }

 #endif