1. mzR
  2. src
  3. boost
  4. timer.hpp
Browse code

Updating pwiz to 3_0_21263

Steffen Neumann authored on 23/09/2021 12:34:25
Showing 1 changed files
src/boost/timer.hpp
History View file @ 72fef926d8
1 1 
new file mode 100755
... ... 
@@ -0,0 +1,75 @@
1 
+//  boost timer.hpp header file  ---------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
+//  Software License, Version 1.0. (See accompanying file
5 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
+
7 
+//  See http://www.boost.org/libs/timer for documentation.
8 
+
9 
+//  Revision History
10 
+//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
+//  12 Jan 01  Change to inline implementation to allow use without library
12 
+//             builds. See docs for more rationale. (Beman Dawes)
13 
+//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
+//  16 Jul 99  Second beta
15 
+//   6 Jul 99  Initial boost version
16 
+
17 
+#ifndef BOOST_TIMER_HPP
18 
+#define BOOST_TIMER_HPP
19 
+
20 
+#include <boost/config/header_deprecated.hpp>
21 
+BOOST_HEADER_DEPRECATED( "the facilities in <boost/timer/timer.hpp>" )
22 
+
23 
+#include <boost/config.hpp>
24 
+#include <ctime>
25 
+#include <boost/limits.hpp>
26 
+
27 
+# ifdef BOOST_NO_STDC_NAMESPACE
28 
+    namespace std { using ::clock_t; using ::clock; }
29 
+# endif
30 
+
31 
+
32 
+namespace boost {
33 
+
34 
+//  timer  -------------------------------------------------------------------//
35 
+
36 
+//  A timer object measures elapsed time.
37 
+
38 
+//  It is recommended that implementations measure wall clock rather than CPU
39 
+//  time since the intended use is performance measurement on systems where
40 
+//  total elapsed time is more important than just process or CPU time.
41 
+
42 
+//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
43 
+//  due to implementation limitations.  The accuracy of timings depends on the
44 
+//  accuracy of timing information provided by the underlying platform, and
45 
+//  this varies a great deal from platform to platform.
46 
+
47 
+class timer
48 
+{
49 
+ public:
50 
+         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
51 
+//         timer( const timer& src );      // post: elapsed()==src.elapsed()
52 
+//        ~timer(){}
53 
+//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
54 
+  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
55 
+  double elapsed() const                  // return elapsed time in seconds
56 
+    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
57 
+
58 
+  double elapsed_max() const   // return estimated maximum value for elapsed()
59 
+  // Portability warning: elapsed_max() may return too high a value on systems
60 
+  // where std::clock_t overflows or resets at surprising values.
61 
+  {
62 
+    return (double((std::numeric_limits<std::clock_t>::max)())
63 
+       - double(_start_time)) / double(CLOCKS_PER_SEC);
64 
+  }
65 
+
66 
+  double elapsed_min() const            // return minimum value for elapsed()
67 
+   { return double(1)/double(CLOCKS_PER_SEC); }
68 
+
69 
+ private:
70 
+  std::clock_t _start_time;
71 
+}; // timer
72 
+
73 
+} // namespace boost
74 
+
75 
+#endif  // BOOST_TIMER_HPP
Browse code

drop old boost

From: Steffen Neumann <sneumann@ipb-halle.de>

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@125184 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 15/12/2016 10:41:45
Showing 1 changed files
src/boost/timer.hpp
History View file @ f28e8d3dd6
1 1 
deleted file mode 100644
... ... 
@@ -1,72 +0,0 @@
1 
-//  boost timer.hpp header file  ---------------------------------------------//
2 
-
3 
-//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
-//  Software License, Version 1.0. (See accompanying file
5 
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
-
7 
-//  See http://www.boost.org/libs/timer for documentation.
8 
-
9 
-//  Revision History
10 
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
-//  12 Jan 01  Change to inline implementation to allow use without library
12 
-//             builds. See docs for more rationale. (Beman Dawes)
13 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
-//  16 Jul 99  Second beta
15 
-//   6 Jul 99  Initial boost version
16 
-
17 
-#ifndef BOOST_TIMER_HPP
18 
-#define BOOST_TIMER_HPP
19 
-
20 
-#include <boost/config.hpp>
21 
-#include <ctime>
22 
-#include <boost/limits.hpp>
23 
-
24 
-# ifdef BOOST_NO_STDC_NAMESPACE
25 
-    namespace std { using ::clock_t; using ::clock; }
26 
-# endif
27 
-
28 
-
29 
-namespace boost {
30 
-
31 
-//  timer  -------------------------------------------------------------------//
32 
-
33 
-//  A timer object measures elapsed time.
34 
-
35 
-//  It is recommended that implementations measure wall clock rather than CPU
36 
-//  time since the intended use is performance measurement on systems where
37 
-//  total elapsed time is more important than just process or CPU time.
38 
-
39 
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
-//  due to implementation limitations.  The accuracy of timings depends on the
41 
-//  accuracy of timing information provided by the underlying platform, and
42 
-//  this varies a great deal from platform to platform.
43 
-
44 
-class timer
45 
-{
46 
- public:
47 
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
-//        ~timer(){}
50 
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
-  double elapsed() const                  // return elapsed time in seconds
53 
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
-
55 
-  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
-  // Portability warning: elapsed_max() may return too high a value on systems
57 
-  // where std::clock_t overflows or resets at surprising values.
58 
-  {
59 
-    return (double((std::numeric_limits<std::clock_t>::max)())
60 
-       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
-  }
62 
-
63 
-  double elapsed_min() const            // return minimum value for elapsed()
64 
-   { return double(1)/double(CLOCKS_PER_SEC); }
65 
-
66 
- private:
67 
-  std::clock_t _start_time;
68 
-}; // timer
69 
-
70 
-} // namespace boost
71 
-
72 
-#endif  // BOOST_TIMER_HPP
Browse code

checkout latest pwiz, ammend Makevars

From: Laurent <lg390@cam.ac.uk>

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@125180 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 15/12/2016 10:21:41
Showing 1 changed files
src/boost/timer.hpp
History View file @ 94d4ecf589
... ... 
@@ -1,72 +1,72 @@
1 
-//  boost timer.hpp header file  ---------------------------------------------//
2 
-
3 
-//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
-//  Software License, Version 1.0. (See accompanying file
5 
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
-
7 
-//  See http://www.boost.org/libs/timer for documentation.
8 
-
9 
-//  Revision History
10 
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
-//  12 Jan 01  Change to inline implementation to allow use without library
12 
-//             builds. See docs for more rationale. (Beman Dawes)
13 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
-//  16 Jul 99  Second beta
15 
-//   6 Jul 99  Initial boost version
16 
-
17 
-#ifndef BOOST_TIMER_HPP
18 
-#define BOOST_TIMER_HPP
19 
-
20 
-#include <boost/config.hpp>
21 
-#include <ctime>
22 
-#include <boost/limits.hpp>
23 
-
24 
-# ifdef BOOST_NO_STDC_NAMESPACE
25 
-    namespace std { using ::clock_t; using ::clock; }
26 
-# endif
27 
-
28 
-
29 
-namespace boost {
30 
-
31 
-//  timer  -------------------------------------------------------------------//
32 
-
33 
-//  A timer object measures elapsed time.
34 
-
35 
-//  It is recommended that implementations measure wall clock rather than CPU
36 
-//  time since the intended use is performance measurement on systems where
37 
-//  total elapsed time is more important than just process or CPU time.
38 
-
39 
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
-//  due to implementation limitations.  The accuracy of timings depends on the
41 
-//  accuracy of timing information provided by the underlying platform, and
42 
-//  this varies a great deal from platform to platform.
43 
-
44 
-class timer
45 
-{
46 
- public:
47 
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
-//        ~timer(){}
50 
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
-  double elapsed() const                  // return elapsed time in seconds
53 
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
-
55 
-  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
-  // Portability warning: elapsed_max() may return too high a value on systems
57 
-  // where std::clock_t overflows or resets at surprising values.
58 
-  {
59 
-    return (double((std::numeric_limits<std::clock_t>::max)())
60 
-       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
-  }
62 
-
63 
-  double elapsed_min() const            // return minimum value for elapsed()
64 
-   { return double(1)/double(CLOCKS_PER_SEC); }
65 
-
66 
- private:
67 
-  std::clock_t _start_time;
68 
-}; // timer
69 
-
70 
-} // namespace boost
71 
-
72 
-#endif  // BOOST_TIMER_HPP
1 
+//  boost timer.hpp header file  ---------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
+//  Software License, Version 1.0. (See accompanying file
5 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
+
7 
+//  See http://www.boost.org/libs/timer for documentation.
8 
+
9 
+//  Revision History
10 
+//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
+//  12 Jan 01  Change to inline implementation to allow use without library
12 
+//             builds. See docs for more rationale. (Beman Dawes)
13 
+//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
+//  16 Jul 99  Second beta
15 
+//   6 Jul 99  Initial boost version
16 
+
17 
+#ifndef BOOST_TIMER_HPP
18 
+#define BOOST_TIMER_HPP
19 
+
20 
+#include <boost/config.hpp>
21 
+#include <ctime>
22 
+#include <boost/limits.hpp>
23 
+
24 
+# ifdef BOOST_NO_STDC_NAMESPACE
25 
+    namespace std { using ::clock_t; using ::clock; }
26 
+# endif
27 
+
28 
+
29 
+namespace boost {
30 
+
31 
+//  timer  -------------------------------------------------------------------//
32 
+
33 
+//  A timer object measures elapsed time.
34 
+
35 
+//  It is recommended that implementations measure wall clock rather than CPU
36 
+//  time since the intended use is performance measurement on systems where
37 
+//  total elapsed time is more important than just process or CPU time.
38 
+
39 
+//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
+//  due to implementation limitations.  The accuracy of timings depends on the
41 
+//  accuracy of timing information provided by the underlying platform, and
42 
+//  this varies a great deal from platform to platform.
43 
+
44 
+class timer
45 
+{
46 
+ public:
47 
+         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
+//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
+//        ~timer(){}
50 
+//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
+  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
+  double elapsed() const                  // return elapsed time in seconds
53 
+    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
+
55 
+  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
+  // Portability warning: elapsed_max() may return too high a value on systems
57 
+  // where std::clock_t overflows or resets at surprising values.
58 
+  {
59 
+    return (double((std::numeric_limits<std::clock_t>::max)())
60 
+       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
+  }
62 
+
63 
+  double elapsed_min() const            // return minimum value for elapsed()
64 
+   { return double(1)/double(CLOCKS_PER_SEC); }
65 
+
66 
+ private:
67 
+  std::clock_t _start_time;
68 
+}; // timer
69 
+
70 
+} // namespace boost
71 
+
72 
+#endif  // BOOST_TIMER_HPP
Browse code

Commit made by the Bioconductor Git-SVN bridge.

Commit id: 0b3d4d9bb71e3ca5891b777610fc8dec103a6d61

Bumped version after KK's updates


Commit id: 9e04409b64757a177893d56c0300904f31945cb1

modified: src/pwiz/data/common/BinaryIndexStream.cpp modified: src/win/i386/libpwiz.a modified: src/win/x64/libpwiz.a


Commit id: f16b04258dc20bf3315beac99708e11728cfc12b

update precompiled lib for windows


Commit id: 5d56197f1148378d92e89b2d0a167e18c4b7ab2e

Bump version, tame .Rbuildignore


Commit id: 432da5bd294c9b87f7761e15bc814c3785c21abf

Merge remote-tracking branch 'origin/boost_159'


Commit id: 92be978bf72d90c2222a19ddf365f6d1acc9f20d

upadte Makevars


Commit id: ae75037a780cead56c4d20bedf822c94fb413677

upgrade to boost 1.5.9



git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@110126 bc3139a8-67e5-0310-9ffc-ced21a209358

s.neumann authored on 01/11/2015 22:33:47
Showing 1 changed files
src/boost/timer.hpp
History View file @ ea16439957
... ... 
@@ -1,72 +1,72 @@
1 
-//  boost timer.hpp header file  ---------------------------------------------//
2 
-
3 
-//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
-//  Software License, Version 1.0. (See accompanying file
5 
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
-
7 
-//  See http://www.boost.org/libs/timer for documentation.
8 
-
9 
-//  Revision History
10 
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
-//  12 Jan 01  Change to inline implementation to allow use without library
12 
-//             builds. See docs for more rationale. (Beman Dawes)
13 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
-//  16 Jul 99  Second beta
15 
-//   6 Jul 99  Initial boost version
16 
-
17 
-#ifndef BOOST_TIMER_HPP
18 
-#define BOOST_TIMER_HPP
19 
-
20 
-#include <boost/config.hpp>
21 
-#include <ctime>
22 
-#include <boost/limits.hpp>
23 
-
24 
-# ifdef BOOST_NO_STDC_NAMESPACE
25 
-    namespace std { using ::clock_t; using ::clock; }
26 
-# endif
27 
-
28 
-
29 
-namespace boost {
30 
-
31 
-//  timer  -------------------------------------------------------------------//
32 
-
33 
-//  A timer object measures elapsed time.
34 
-
35 
-//  It is recommended that implementations measure wall clock rather than CPU
36 
-//  time since the intended use is performance measurement on systems where
37 
-//  total elapsed time is more important than just process or CPU time.
38 
-
39 
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
-//  due to implementation limitations.  The accuracy of timings depends on the
41 
-//  accuracy of timing information provided by the underlying platform, and
42 
-//  this varies a great deal from platform to platform.
43 
-
44 
-class timer
45 
-{
46 
- public:
47 
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
-//        ~timer(){}
50 
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
-  double elapsed() const                  // return elapsed time in seconds
53 
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
-
55 
-  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
-  // Portability warning: elapsed_max() may return too high a value on systems
57 
-  // where std::clock_t overflows or resets at surprising values.
58 
-  {
59 
-    return (double((std::numeric_limits<std::clock_t>::max)())
60 
-       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
-  }
62 
-
63 
-  double elapsed_min() const            // return minimum value for elapsed()
64 
-   { return double(1)/double(CLOCKS_PER_SEC); }
65 
-
66 
- private:
67 
-  std::clock_t _start_time;
68 
-}; // timer
69 
-
70 
-} // namespace boost
71 
-
72 
-#endif  // BOOST_TIMER_HPP
1 
+//  boost timer.hpp header file  ---------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
+//  Software License, Version 1.0. (See accompanying file
5 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
+
7 
+//  See http://www.boost.org/libs/timer for documentation.
8 
+
9 
+//  Revision History
10 
+//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
+//  12 Jan 01  Change to inline implementation to allow use without library
12 
+//             builds. See docs for more rationale. (Beman Dawes)
13 
+//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
+//  16 Jul 99  Second beta
15 
+//   6 Jul 99  Initial boost version
16 
+
17 
+#ifndef BOOST_TIMER_HPP
18 
+#define BOOST_TIMER_HPP
19 
+
20 
+#include <boost/config.hpp>
21 
+#include <ctime>
22 
+#include <boost/limits.hpp>
23 
+
24 
+# ifdef BOOST_NO_STDC_NAMESPACE
25 
+    namespace std { using ::clock_t; using ::clock; }
26 
+# endif
27 
+
28 
+
29 
+namespace boost {
30 
+
31 
+//  timer  -------------------------------------------------------------------//
32 
+
33 
+//  A timer object measures elapsed time.
34 
+
35 
+//  It is recommended that implementations measure wall clock rather than CPU
36 
+//  time since the intended use is performance measurement on systems where
37 
+//  total elapsed time is more important than just process or CPU time.
38 
+
39 
+//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
+//  due to implementation limitations.  The accuracy of timings depends on the
41 
+//  accuracy of timing information provided by the underlying platform, and
42 
+//  this varies a great deal from platform to platform.
43 
+
44 
+class timer
45 
+{
46 
+ public:
47 
+         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
+//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
+//        ~timer(){}
50 
+//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
+  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
+  double elapsed() const                  // return elapsed time in seconds
53 
+    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
+
55 
+  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
+  // Portability warning: elapsed_max() may return too high a value on systems
57 
+  // where std::clock_t overflows or resets at surprising values.
58 
+  {
59 
+    return (double((std::numeric_limits<std::clock_t>::max)())
60 
+       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
+  }
62 
+
63 
+  double elapsed_min() const            // return minimum value for elapsed()
64 
+   { return double(1)/double(CLOCKS_PER_SEC); }
65 
+
66 
+ private:
67 
+  std::clock_t _start_time;
68 
+}; // timer
69 
+
70 
+} // namespace boost
71 
+
72 
+#endif  // BOOST_TIMER_HPP
Browse code

Added the mzR package to the repository.

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@57456 bc3139a8-67e5-0310-9ffc-ced21a209358

c.wong authored on 15/08/2011 19:53:29
Showing 1 changed files
src/boost/timer.hpp
History View file @ bcff5d52a8
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,72 @@
1 
+//  boost timer.hpp header file  ---------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
4 
+//  Software License, Version 1.0. (See accompanying file
5 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
+
7 
+//  See http://www.boost.org/libs/timer for documentation.
8 
+
9 
+//  Revision History
10 
+//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
11 
+//  12 Jan 01  Change to inline implementation to allow use without library
12 
+//             builds. See docs for more rationale. (Beman Dawes)
13 
+//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
14 
+//  16 Jul 99  Second beta
15 
+//   6 Jul 99  Initial boost version
16 
+
17 
+#ifndef BOOST_TIMER_HPP
18 
+#define BOOST_TIMER_HPP
19 
+
20 
+#include <boost/config.hpp>
21 
+#include <ctime>
22 
+#include <boost/limits.hpp>
23 
+
24 
+# ifdef BOOST_NO_STDC_NAMESPACE
25 
+    namespace std { using ::clock_t; using ::clock; }
26 
+# endif
27 
+
28 
+
29 
+namespace boost {
30 
+
31 
+//  timer  -------------------------------------------------------------------//
32 
+
33 
+//  A timer object measures elapsed time.
34 
+
35 
+//  It is recommended that implementations measure wall clock rather than CPU
36 
+//  time since the intended use is performance measurement on systems where
37 
+//  total elapsed time is more important than just process or CPU time.
38 
+
39 
+//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
40 
+//  due to implementation limitations.  The accuracy of timings depends on the
41 
+//  accuracy of timing information provided by the underlying platform, and
42 
+//  this varies a great deal from platform to platform.
43 
+
44 
+class timer
45 
+{
46 
+ public:
47 
+         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
48 
+//         timer( const timer& src );      // post: elapsed()==src.elapsed()
49 
+//        ~timer(){}
50 
+//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
51 
+  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
52 
+  double elapsed() const                  // return elapsed time in seconds
53 
+    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
54 
+
55 
+  double elapsed_max() const   // return estimated maximum value for elapsed()
56 
+  // Portability warning: elapsed_max() may return too high a value on systems
57 
+  // where std::clock_t overflows or resets at surprising values.
58 
+  {
59 
+    return (double((std::numeric_limits<std::clock_t>::max)())
60 
+       - double(_start_time)) / double(CLOCKS_PER_SEC);
61 
+  }
62 
+
63 
+  double elapsed_min() const            // return minimum value for elapsed()
64 
+   { return double(1)/double(CLOCKS_PER_SEC); }
65 
+
66 
+ private:
67 
+  std::clock_t _start_time;
68 
+}; // timer
69 
+
70 
+} // namespace boost
71 
+
72 
+#endif  // BOOST_TIMER_HPP