//  boost timer.hpp header file  ---------------------------------------------//

 //  Copyright Beman Dawes 1994-99.  Distributed under the Boost

 //  Software License, Version 1.0. (See accompanying file

 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 //  See http://www.boost.org/libs/timer for documentation.

 //  Revision History

 //  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)

 //  12 Jan 01  Change to inline implementation to allow use without library

 //             builds. See docs for more rationale. (Beman Dawes) 

 //  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)

 //  16 Jul 99  Second beta

 //   6 Jul 99  Initial boost version

 #ifndef BOOST_TIMER_HPP

 #define BOOST_TIMER_HPP

 #include <boost/config.hpp>

 #include <ctime>

 #include <boost/limits.hpp>

 # ifdef BOOST_NO_STDC_NAMESPACE

     namespace std { using ::clock_t; using ::clock; }

 # endif

 namespace boost {

 //  timer  -------------------------------------------------------------------//

 //  A timer object measures elapsed time.

 //  It is recommended that implementations measure wall clock rather than CPU

 //  time since the intended use is performance measurement on systems where

 //  total elapsed time is more important than just process or CPU time.

 //  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours

 //  due to implementation limitations.  The accuracy of timings depends on the

 //  accuracy of timing information provided by the underlying platform, and

 //  this varies a great deal from platform to platform.

 class timer

 {

  public:

          timer() { _start_time = std::clock(); } // postcondition: elapsed()==0

 //         timer( const timer& src );      // post: elapsed()==src.elapsed()

 //        ~timer(){}

 //  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()

   void   restart() { _start_time = std::clock(); } // post: elapsed()==0

   double elapsed() const                  // return elapsed time in seconds

     { return  double(std::clock() - _start_time) / CLK_TCK; }

   double elapsed_max() const   // return estimated maximum value for elapsed()

   // Portability warning: elapsed_max() may return too high a value on systems

   // where std::clock_t overflows or resets at surprising values.

   {

     return (double((std::numeric_limits<std::clock_t>::max)())

        - double(_start_time)) / double(CLK_TCK); 

   }

   double elapsed_min() const            // return minimum value for elapsed()

    { return double(1)/double(CLK_TCK); }

  private:

   std::clock_t _start_time;

 }; // timer

 } // namespace boost

 #endif  // BOOST_TIMER_HPP