chrono/example/test_duration.cpp

//  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;
}