1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
// test_duration.cpp ----------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was extracted by Vicente J. Botet Escriba from Beman Dawes time2_demo.cpp which
was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.9 Time utilities [time] of the C++ committee's working paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
#include <boost/assert.hpp>
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#include <iostream>
template <class Rep, class Period>
void inspect_duration(boost::chrono::duration<Rep, Period> d, const std::string& name)
{
typedef boost::chrono::duration<Rep, Period> Duration;
std::cout << "********* " << name << " *********\n";
std::cout << "The period of " << name << " is " << (double)Period::num/Period::den << " seconds.\n";
std::cout << "The frequency of " << name << " is " << (double)Period::den/Period::num << " Hz.\n";
std::cout << "The representation is ";
if (boost::is_floating_point<Rep>::value)
{
std::cout << "floating point\n";
std::cout << "The precision is the most significant ";
std::cout << std::numeric_limits<Rep>::digits10 << " decimal digits.\n";
}
else if (boost::is_integral<Rep>::value)
{
std::cout << "integral\n";
d = Duration(Rep(1));
boost::chrono::duration<double> dsec = d;
std::cout << "The precision is " << dsec.count() << " seconds.\n";
}
else
{
std::cout << "a class type\n";
d = Duration(Rep(1));
boost::chrono::duration<double> dsec = d;
std::cout << "The precision is " << dsec.count() << " seconds.\n";
}
d = Duration((std::numeric_limits<Rep>::max)());
using namespace boost::chrono;
typedef duration<double, boost::ratio_multiply<boost::ratio<24*3652425,10000>, hours::period>::type> Years;
Years years = d;
std::cout << "The range is +/- " << years.count() << " years.\n";
std::cout << "sizeof(" << name << ") = " << sizeof(d) << '\n';
}
void inspect_all()
{
using namespace boost::chrono;
std::cout.precision(6);
inspect_duration(nanoseconds(), "nanoseconds");
inspect_duration(microseconds(), "microseconds");
inspect_duration(milliseconds(), "milliseconds");
inspect_duration(seconds(), "seconds");
inspect_duration(minutes(), "minutes");
inspect_duration(hours(), "hours");
inspect_duration(duration<double>(), "duration<double>");
}
using namespace boost::chrono;
void test_duration_division()
{
typedef boost::common_type<boost::chrono::hours::rep, boost::chrono::minutes::rep>::type h_min_rep;
h_min_rep r3 = hours(3) / minutes(5);
std::cout << r3 << '\n';
std::cout << hours(3) / minutes(5) << '\n';
std::cout << hours(3) / milliseconds(5) << '\n';
std::cout << milliseconds(5) / hours(3) << '\n';
std::cout << hours(1) / milliseconds(1) << '\n';
}
void test_duration_multiply()
{
hours h15= 5 * hours(3);
(void)h15;
hours h6= hours(3) *2;
(void)h6;
}
void f(duration<double> d, double res) // accept floating point seconds
{
// d.count() == 3.e-6 when passed microseconds(3)
BOOST_ASSERT(d.count()==res);
}
void g(nanoseconds d, boost::intmax_t res)
{
// d.count() == 3000 when passed microseconds(3)
std::cout << d.count() << " " <<res << std::endl;
BOOST_ASSERT(d.count()==res);
}
template <class Rep, class Period>
void tmpl(duration<Rep, Period> d, boost::intmax_t res)
{
// convert d to nanoseconds, rounding up if it is not an exact conversion
nanoseconds ns = duration_cast<nanoseconds>(d);
if (ns < d)
++ns;
// ns.count() == 333333334 when passed 1/3 of a floating point second
BOOST_ASSERT(ns.count()==res);
}
template <class Period>
void tmpl2(duration<long long, Period> d, boost::intmax_t res)
{
// convert d to nanoseconds, rounding up if it is not an exact conversion
nanoseconds ns = duration_cast<nanoseconds>(d);
if (ns < d)
++ns;
// ns.count() == 333333334 when passed 333333333333 picoseconds
BOOST_ASSERT(ns.count()==res);
}
int main()
{
minutes m1(3); // m1 stores 3
minutes m2(2); // m2 stores 2
minutes m3 = m1 + m2; // m3 stores 5
BOOST_ASSERT(m3.count()==5);
microseconds us1(3); // us1 stores 3
microseconds us2(2); // us2 stores 2
microseconds us3 = us1 + us2; // us3 stores 5
BOOST_ASSERT(us3.count()==5);
microseconds us4 = m3 + us3; // us4 stores 300000005
BOOST_ASSERT(us4.count()==300000005);
microseconds us5 = m3; // us4 stores 300000000
BOOST_ASSERT(us5.count()==300000000);
//minutes m4 = m3 + us3; // won't compile
minutes m4 = duration_cast<minutes>(m3 + us3); // m4.count() == 5
BOOST_ASSERT(m4.count()==5);
typedef duration<double, boost::ratio<60> > dminutes;
dminutes dm4 = m3 + us3; // dm4.count() == 5.000000083333333
BOOST_ASSERT(dm4.count()==5.000000083333333);
f(microseconds(3), 0.000003);
g(microseconds(3), 3000);
duration<double> s(1./3); // 1/3 of a second
g(duration_cast<nanoseconds>(s), 333333333); // round towards zero in conversion to nanoseconds
//f(s); // does not compile
tmpl(duration<double>(1./3), 333333334);
tmpl2(duration<long long, boost::pico>(333333333333LL), 333333334); // About 1/3 of a second worth of picoseconds
//f(3,3); // Will not compile, 3 is not implicitly convertible to any `duration`
//g(3,3); // Will not compile, 3 is not implicitly convertible to any `duration`
//tmpl(3,3); // Will not compile, 3 is not implicitly convertible to any `duration`
//tmpl2(3,3); // Will not compile, 3 is not implicitly convertible to any `duration`
{
double r = double(milliseconds(3) / milliseconds(3));
std::cout << r << '\n';
duration<double, boost::milli> d = milliseconds(3) * 2.5;
duration<double, boost::milli> d2 = 2.5 * milliseconds(3) ;
(void)d2;
duration<double, boost::milli> d3 = milliseconds(3) / 2.5;
(void)d3;
duration<double, boost::milli> d4 = milliseconds(3) + milliseconds(5) ;
(void)d4;
inspect_duration(milliseconds(3) * 2.5, "milliseconds(3) * 2.5");
std::cout << d.count() << '\n';
// milliseconds ms(3.5); // doesn't compile
std::cout << "milliseconds ms(3.5) doesn't compile\n";
}
test_duration_division();
test_duration_multiply();
return 0;
}
|
