ceph/src/boost/libs/units/test/test_dimensionless_quantity.cpp

   1 // Boost.Units - A C++ library for zero-overhead dimensional analysis and
   2 // unit/quantity manipulation and conversion
   3 //
   4 // Copyright (C) 2003-2008 Matthias Christian Schabel
   5 // Copyright (C) 2008 Steven Watanabe
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 /**
  12 \file
  13
  14 \brief test_dimensionless_quantity.cpp
  15
  16 \details
  17 Test unit class.
  18
  19 Output:
  20 @verbatim
  21 @endverbatim
  22 **/
  23
  24 #include "test_header.hpp"
  25
  26 #include <boost/units/pow.hpp>
  27
  28 namespace bu = boost::units;
  29
  30 static const double E_ = 2.718281828459045235360287471352662497757;
  31
  32 int test_main(int,char *[])
  33 {
  34     // default constructor
  35     const bu::quantity<bu::dimensionless>           E1;
  36     BOOST_CHECK(E1.value() == double());
  37
  38     // value_type constructor
  39     const bu::quantity<bu::dimensionless>           E2(E_);
  40     BOOST_CHECK(E2.value() == E_);
  41
  42     // copy constructor
  43     const bu::quantity<bu::dimensionless>           E3(E2);
  44     BOOST_CHECK(E3.value() == E_);
  45
  46     // operator=
  47     const bu::quantity<bu::dimensionless>           E4 = E2;
  48     BOOST_CHECK(E4.value() == E_);
  49
  50     // implicit copy constructor value_type conversion
  51     const bu::quantity<bu::dimensionless,float>     E5(E2);
  52     BOOST_UNITS_CHECK_CLOSE(E5.value(), float(E_));
  53
  54     const bu::quantity<bu::dimensionless,long>      E6(E2);
  55     BOOST_CHECK(E6.value() == long(E_));
  56
  57     // implicit operator= value_type conversion
  58     // narrowing conversion disallowed
  59 //    const bu::quantity<bu::dimensionless,float>     E7 = E2;
  60 //    BOOST_UNITS_CHECK_CLOSE(E7.value(),float(E_));
  61
  62     // narrowing conversion disallowed
  63 //    const bu::quantity<bu::dimensionless,long>      E8 = E2;
  64 //    BOOST_CHECK(E8.value() == long(E_));
  65
  66     // const construction
  67     bu::quantity<bu::dimensionless>                 E9(E2);
  68     BOOST_CHECK(E9.value() == E_);
  69
  70 //    // value assignment
  71 //    E9.value() = 1.5*bu::dimensionless();
  72 //    BOOST_CHECK(E9.value() == 1.5);
  73 //
  74 //    // value assignment with implicit conversion
  75 //    E9.value() = 1.5;
  76 //    BOOST_CHECK(E9.value() == 1.5);
  77 //
  78 //    // value assignment with implicit value_type conversion
  79 //    E9.value() = 2*bu::dimensionless();
  80 //    BOOST_CHECK(E9.value() == double(2));
  81 //
  82 //    // value assignment with implicit value_type conversion
  83 //    E9.value() = 2;
  84 //    BOOST_CHECK(E9.value() == double(2));
  85
  86     // operator+=(this_type)
  87     E9 = 2.0;
  88     E9 += E9;
  89     BOOST_CHECK(E9.value() == 4.0);
  90
  91     // operator-=(this_type)
  92     E9 = 2.0;
  93     E9 -= E9;
  94     BOOST_CHECK(E9.value() == 0.0);
  95
  96     // operator*=(value_type)
  97     E9 = 2.0;
  98     E9 *= 2.0;
  99     BOOST_CHECK(E9.value() == 4.0);
 100
 101     // operator/=(value_type)
 102     E9 = 2.0;
 103     E9 /= 2.0;
 104     BOOST_CHECK(E9.value() == 1.0);
 105
 106     // static construct quantity from value_type
 107     const bu::quantity<bu::dimensionless>           E(bu::quantity<bu::dimensionless>::from_value(2.5));
 108     BOOST_CHECK(E.value() == 2.5);
 109
 110     // implicit conversion to value_type
 111     const double    V1(E9);
 112     BOOST_CHECK(V1 == E9.value());
 113
 114     const double    V2 = E9;
 115     BOOST_CHECK(V2 == E9.value());
 116
 117     // unit * scalar
 118     BOOST_CHECK(bu::dimensionless()*2.0 == bu::quantity<bu::dimensionless>::from_value(2.0));
 119
 120     // unit / scalar
 121     BOOST_CHECK(bu::dimensionless()/2.0 == bu::quantity<bu::dimensionless>::from_value(0.5));
 122
 123     // scalar * unit
 124     BOOST_CHECK(2.0*bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0));
 125
 126     // scalar / unit
 127     BOOST_CHECK(2.0/bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0));
 128
 129     //  quantity * scalar
 130     BOOST_CHECK(E*2.0 == bu::quantity<bu::dimensionless>::from_value(5.0));
 131
 132     //  quantity / scalar
 133     BOOST_CHECK(E/2.0 == bu::quantity<bu::dimensionless>::from_value(1.25));
 134
 135     // scalar * quantity
 136     BOOST_CHECK(2.0*E == bu::quantity<bu::dimensionless>::from_value(5.0));
 137
 138     // scalar / quantity
 139     BOOST_CHECK(2.0/E == bu::quantity<bu::dimensionless>::from_value(0.8));
 140
 141     const bu::quantity<bu::dimensionless>       D1(1.0),
 142                                                 D2(2.0);
 143
 144     // unit * quantity
 145     BOOST_CHECK(bu::dimensionless()*D1 == D1);
 146
 147     // unit / quantity
 148     BOOST_CHECK(bu::dimensionless()/D1 == D1);
 149
 150     // quantity * unit
 151     BOOST_CHECK(D1*bu::dimensionless() == D1);
 152
 153     // quantity / unit
 154     BOOST_CHECK(D1*bu::dimensionless() == D1);
 155
 156     // +quantity
 157     BOOST_CHECK(+D1 == 1.0*bu::dimensionless());
 158
 159     // -quantity
 160     BOOST_CHECK(-D1 == -1.0*bu::dimensionless());
 161
 162     // quantity + quantity
 163     BOOST_CHECK(D2+D1 == 3.0*bu::dimensionless());
 164
 165     // quantity - quantity
 166     BOOST_CHECK(D2-D1 == 1.0*bu::dimensionless());
 167
 168     // quantity * quantity
 169     BOOST_CHECK(D1*D2 == 2.0*bu::dimensionless());
 170
 171     // quantity / quantity
 172     BOOST_CHECK(D2/D1 == 2.0*bu::dimensionless());
 173
 174     // integer power of quantity
 175     BOOST_CHECK(2.0*bu::pow<2>(D2) == 2.0*std::pow(2.0,2.0)*bu::dimensionless());
 176
 177     // rational power of quantity
 178     BOOST_CHECK((2.0*bu::pow< bu::static_rational<2,3> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless()));
 179
 180     // integer root of quantity
 181     BOOST_CHECK(2.0*bu::root<2>(D2) == 2.0*std::pow(2.0,1.0/2.0)*bu::dimensionless());
 182
 183     // rational root of quantity
 184     BOOST_CHECK((2.0*bu::root< bu::static_rational<3,2> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless()));
 185
 186     const bu::quantity<bu::dimensionless>   A1(0.0),
 187                                             A2(0.0),
 188                                             A3(1.0),
 189                                             A4(-1.0);
 190
 191     // operator==
 192     BOOST_CHECK((A1 == A2) == true);
 193     BOOST_CHECK((A1 == A3) == false);
 194
 195     // operator!=
 196     BOOST_CHECK((A1 != A2) == false);
 197     BOOST_CHECK((A1 != A3) == true);
 198
 199     // operator<
 200     BOOST_CHECK((A1 < A2) == false);
 201     BOOST_CHECK((A1 < A3) == true);
 202
 203     // operator<=
 204     BOOST_CHECK((A1 <= A2) == true);
 205     BOOST_CHECK((A1 <= A3) == true);
 206
 207     // operator>
 208     BOOST_CHECK((A1 > A2) == false);
 209     BOOST_CHECK((A1 > A4) == true);
 210
 211     // operator>=
 212     BOOST_CHECK((A1 >= A2) == true);
 213     BOOST_CHECK((A1 >= A4) == true);
 214
 215     return 0;
 216 }