generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-01-07 09:48:04 +01:00
Code Issues Projects Releases Wiki Activity
c8a96c9247
poco/Util/include/Poco/Util/Units.h
Roger Meier b0581433a7 LICENSE: add info about SPDX-License-Identifier usage and use it 
fix: remove executable flag and change back to 100644 (was 100755)

Signed-off-by: Roger Meier <r.meier@siemens.com>
2014-05-14 08:38:09 +02:00

1301 lines
32 KiB
C++
Raw Blame History

//
// Units.h
//
// $Id: //poco/1.4/Util/include/Poco/Util/Units.h#1 $
//
// Library: Util
// Package: Units
// Module: Units
//
// Definitions for the C++ Units library.
//
// Copyright (c) 2007-2010, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
// Adapted for POCO from the following source:
//
// C++ Units by Calum Grant
//
// Written by Calum Grant
// Copyright (C) Calum Grant 2007
//
// Home page: http://calumgrant.net/units
// File location: http://calumgrant.net/units/units.hpp
// Manual: http://calumgrant.net/units/units.html
//
// Copying permitted under the terms of the Boost software license.
//
#ifndef Util_Units_INCLUDED
#define Util_Units_INCLUDED
#include "Poco/Util/Util.h"
#include <cmath>
namespace Poco {
namespace Util {
namespace Units {
namespace Internal
{
template <typename T1, typename T2> struct Convert;
struct None;
template <int Num, int Den, int Div=Num/Den, int Mod=Num%Den>
struct FixedPower;
}
template <typename Unit1, typename Unit2>
struct Compose;
/// Construct a unit equivalent to Unit1*Unit2
template <typename U, int Num, int Den = 1>
struct Scale;
/// Constructs a unit equivalent to U*Num/Den
template <typename U, int Num, int Den = 1>
struct Translate;
/// Constructs a Unit equivalent to U+Num/Den
template <typename U, int Num, int Den = 1>
struct Power;
/// Constructs a Unit equivalent to U^(Num/Den)
typedef Power<Internal::None, 0> Unit;
/// A unit which is effectively no units at all.
template <typename V, typename U>
class Value
/// A Value with a unit.
/// - V is the type you are storing
/// - U is the unit of the Value
///
/// This class is usually not used directly;
/// client code should use the typedef'd
/// instantiations defined in the Values and
/// Constants namespace.
///
/// Example:
///
/// using namespace Poco::Util::Units::Values;
///
/// std::cout << "One mile is " << km(mile(1)) << std::endl;
/// // Output: One mile is 1.60934 km
///
/// std::cout << "Flow rate is " << m3(mile(1)*inch(80)*foot(9))/s(minute(5));
/// // Output: Flow rate is 29.9026 (m)^3.(s)^-1
///
/// hours h;
/// h = cm(3); // Compile-time error: incompatible units
/// h = 4; // Compile-time error: 4 of what?
/// h = days(4); // Ok: h is 96 hours
{
public:
typedef V ValueType;
typedef U Unit;
Value(): _rep()
{
}
explicit Value(const ValueType& v): _rep(v)
{
}
template <typename OV, typename OU>
Value(const Value<OV, OU>& v):
_rep(Internal::Convert<OU, U>::fn(v.get()))
{
}
const ValueType& get() const
{
return _rep;
}
template <typename OV, typename OU>
Value& operator = (const Value<OV, OU>& other)
{
_rep = Value(other).get();
return *this;
}
template <typename OV, typename OU>
Value operator + (const Value<OV, OU>& other) const
{
return Value(get() + Value(other).get());
}
template <typename OV, typename OU>
Value& operator += (const Value<OV, OU>& other)
{
_rep += Value(other).get();
return *this;
}
template <typename OV, typename OU>
Value& operator -= (const Value<OV, OU>& other)
{
_rep -= Value(other).get();
return *this;
}
template <typename OV, typename OU>
Value operator - (const Value<OV, OU>& other) const
{
return Value(get() - Value(other).get());
}
Value operator - () const
{
return Value(-get());
}
template <typename OV, typename OU>
Value<V, Compose<U, OU> >
operator * (const Value<OV, OU>& other) const
{
return Value<V, Compose<U, OU> >(get() * other.get());
}
Value operator * (const ValueType& v) const
{
return Value(get() * v);
}
Value& operator *= (const ValueType& v)
{
_rep *= v;
return *this;
}
template <typename OV, typename OU>
Value<V, Compose<U, Power<OU, -1> > > operator / (const Value<OV, OU>& other) const
{
return Value<V, Compose<U, Power<OU, -1> > >(get() / other.get());
}
Value operator / (const ValueType& v) const
{
return Value(get() / v);
}
Value& operator /= (const ValueType& v)
{
_rep /= v;
return *this;
}
template <typename OV, typename OU>
bool operator == (const Value<OV, OU>& other) const
{
return get() == Value(other).get();
}
template <typename OV, typename OU>
bool operator != (const Value<OV, OU>& other) const
{
return get() != Value(other).get();
}
template <typename OV, typename OU>
bool operator < (const Value<OV, OU>& other) const
{
return get() < Value(other).get();
}
template <typename OV, typename OU>
bool operator <= (const Value<OV, OU>& other) const
{
return get() <= Value(other).get();
}
template <typename OV, typename OU>
bool operator > (const Value<OV, OU>& other) const
{
return get() > Value(other).get();
}
template <typename OV, typename OU>
bool operator >= (const Value<OV, OU>& other) const
{
return get() >= Value(other).get();
}
Value& operator ++ ()
{
++_rep;
return *this;
}
Value operator ++ (int)
{
Value v = *this;
++_rep;
return v;
}
Value& operator -- ()
{
--_rep;
return *this;
}
Value operator -- (int)
{
Value v = *this;
--_rep;
return v;
}
private:
ValueType _rep;
};
template <typename V, typename U>
Value<V, Power<U, -1> > operator / (const V& a, const Value<V, U>& b)
{
return Value<V, Power<U, -1> >(a / b.get());
}
template <typename V, typename U>
Value<V, U > operator * (const V& a, const Value<V, U>& b)
{
return Value<V, U>(a * b.get());
}
template <typename V, typename U>
Value<V, Power<U, 1, 2> > sqrt(const Value<V, U>& a)
{
return Value<V, Power<U, 1, 2> >(std::sqrt(a.get()));
}
template <typename V, typename U>
Value<V, Power<U, 2, 1> > square(const Value<V, U>& a)
{
return Value<V, Power<U, 2, 1> >(std::pow(a.get(), 2));
}
template <typename V, typename U>
Value<V, Power<U, 3, 1> > cube(const Value<V, U>& a)
{
return Value<V, Power<U, 3, 1> >(std::pow(a.get(), 3));
}
template <int Num, int Den, typename V, typename U>
Value<V, Power<U, Num, Den> > raise(const Value<V, U>& a)
{
return Value<V, Power<U, Num, Den> >(Internal::FixedPower<Num, Den>::Power(a.get()));
}
namespace Internal
{
template <typename T1, typename T2>
struct Convertible;
template <typename U>
struct ScalingFactor;
template <typename T1, typename T2>
struct Convert3
/// Converts T1 to T2.
/// Stage 3 - performed after Stage 1 and Stage 2.
/// The reason we perform Convert in stages is so that the compiler
/// can resolve templates in the order we want it to.
{
template <typename V>
static V fn(const V& v)
/// The default implementation assumes that the two quantities are in compatible
/// Units up to some scaling factor. Find the scaling factor and apply it.
{
return v * ScalingFactor<T2>::template fn<V>() / ScalingFactor<T1>::template fn<V>();
}
};
template <typename T1, typename T2>
struct Convert2
/// Converts T1 to T2.
/// Template matches the first argument (T1),
/// this is the fall-through to Convert3.
{
template <typename V>
static V fn(const V& v)
{
return Convert3<T1,T2>::fn(v);
}
};
template <typename T1, typename T2>
struct Convert
/// Converts T1 to T2.
/// If you really want to implement your own conversion routine,
/// specialize this template.
/// The default implementation falls through to Convert2.
{
/// If this fails, then T1 is not Convertible to T2:
poco_static_assert ((Convertible<T1,T2>::Value));
template <typename V>
static V fn(const V& v)
{
return Convert2<T1,T2>::fn(v);
}
};
template <typename T>
struct Convert<T, T>
// Trivial conversion to the same type.
{
template <typename U>
static const U& fn(const U& u) { return u; }
};
template <typename T>
struct Convert3<T, T>
// Convert to same type.
{
template <typename U>
static const U& fn(const U& u) { return u; }
};
template <typename T, typename U, int Num, int Den>
struct Convert2<Scale<T, Num, Den>, U>
// Convert from a scaled Unit.
{
template <typename V>
static V fn(const V& v)
{
return Convert<T, U>::fn((v * Den)/Num);
}
};
template <typename T, typename U, int Num, int Den>
struct Convert3<T, Scale<U, Num, Den> >
// Convert to a scaled Unit.
{
template <typename V>
static V fn(const V& v)
{
return (Convert<T, U>::fn(v) * Num)/ Den;
}
};
template <typename T, typename U, int Num, int Den>
struct Convert2<Translate<T, Num, Den>, U>
// Convert from a translated Unit.
{
template <typename V>
static V fn(const V& v)
{
return Convert<T, U>::fn(v - static_cast<V>(Num) / static_cast<V>(Den));
}
};
template <typename T, typename U, int Num, int Den>
struct Convert3<T, Translate<U, Num, Den> >
// Convert to a translated Unit.
{
template <typename V>
static V fn(const V& v)
{
return Convert<T, U>::fn(v) + static_cast<V>(Num) / static_cast<V>(Den);
}
};
template <typename Term, typename List>
struct CountTerms
/// Count the power to which Unit Term is raised in the Unit List.
/// Returns a rational num/den of the power of term Term in List.
/// The default assumes that Term is not found (num/den=0).
{
static const int num = 0;
static const int den = 1;
};
template <typename Term>
struct CountTerms<Term, Term>
{
static const int num = 1;
static const int den = 1;
};
template <typename Term, typename U, int N, int D>
struct CountTerms<Term, Scale<U, N, D> >
// CountTerms ignores scaling factors - that is taken care of by ScalingFactor.
{
typedef CountTerms<Term, U> result;
static const int num = result::num;
static const int den = result::den;
};
template <typename Term, typename U, int N, int D>
struct CountTerms<Term, Translate<U, N, D> >
// CountTerms ignores translation.
{
typedef CountTerms<Term, U> result;
static const int num = result::num;
static const int den = result::den;
};
template <typename Term, typename T1, typename T2>
struct CountTerms<Term, Compose<T1,T2> >
// Addition of fractions.
{
typedef CountTerms<Term, T1> result1;
typedef CountTerms<Term, T2> result2;
static const int num = result1::num * result2::den + result1::den * result2::num;
static const int den = result1::den * result2::den;
};
template <typename Term, typename U, int N, int D>
struct CountTerms<Term, Power<U, N, D> >
// Multiplication of fractions.
{
typedef CountTerms<Term, U> result;
static const int num = N * result::num;
static const int den = D * result::den;
};
template <typename Term, typename T1, typename T2>
struct CheckTermsEqual
/// Counts the power of the Unit Term in Units T1 and T2.
/// Reports if they are equal, using equality of fractions.
/// Does a depth-first search of the Unit "Term",
/// or counts the terms in the default case.
{
typedef CountTerms<Term, T1> count1;
typedef CountTerms<Term, T2> count2;
static const bool Value =
count1::num * count2::den ==
count1::den * count2::num;
};
template <typename U, int N, int D, typename T1, typename T2>
struct CheckTermsEqual<Power<U, N, D>, T1, T2 >
{
static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
};
template <typename U, int N, int D, typename T1, typename T2>
struct CheckTermsEqual<Scale<U, N, D>, T1, T2 >
{
static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
};
template <typename U, int N, int D, typename T1, typename T2>
struct CheckTermsEqual<Translate<U, N, D>, T1, T2 >
{
static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
};
template <typename T1, typename T2, typename T3, typename T4>
struct CheckTermsEqual<Compose<T1,T2>,T3,T4>
{
static const bool Value =
CheckTermsEqual<T1, T3, T4>::Value &&
CheckTermsEqual<T2, T3, T4>::Value;
};
template <typename T1, typename T2>
struct Convertible
/// Determines whether two types are Convertible.
/// Counts the powers in the LHS and RHS and ensures they are equal.
{
static const bool Value =
CheckTermsEqual<T1,T1,T2>::Value &&
CheckTermsEqual<T2,T1,T2>::Value;
};
template <int Num, int Den, int Div, int Mod>
struct FixedPower
/// A functor that raises a Value to the power Num/Den.
/// The template is specialised for efficiency
/// so that we don't always have to call the std::power function.
{
template <typename T> static T Power(const T& t)
{
return std::pow(t, static_cast<T>(Num)/static_cast<T>(Den));
}
};
template <int N, int D>
struct FixedPower<N, D, 1, 0>
{
template <typename T> static const T& Power(const T& t)
{
return t;
}
};
template <int N, int D>
struct FixedPower<N, D, 2, 0>
{
template <typename T> static T Power(const T& t)
{
return t*t;
}
};
template <int N, int D>
struct FixedPower<N, D, 3, 0>
{
template <typename T> static T Power(const T& t)
{
return t*t*t;
}
};
template <int N, int D>
struct FixedPower<N, D, 4, 0>
{
template <typename T> static const T& Power(const T& t)
{
T u = t*t;
return u*u;
}
};
template <int N, int D>
struct FixedPower<N, D, -1, 0>
{
template <typename T> static T Power(const T& t)
{
return 1/t;
}
};
template <int N, int D>
struct FixedPower<N, D, -2, 0>
{
template <typename T> static T Power(const T& t)
{
return 1/(t*t);
}
};
template <int N, int D>
struct FixedPower<N, D, 0, 0>
{
template <typename T> static T Power(const T& t)
{
return 1;
}
};
template <typename U>
struct ScalingFactor
/// Determine the scaling factor of a Unit in relation to its "base" Units.
/// Default is that U is a primitive Unit and is not scaled.
{
template <typename T>
static T fn() { return 1; }
};
template <typename U1, typename U2>
struct ScalingFactor< Compose<U1, U2> >
{
template <typename T>
static T fn()
{
return
ScalingFactor<U1>::template fn<T>() *
ScalingFactor<U2>::template fn<T>();
}
};
template <typename U, int N, int D>
struct ScalingFactor< Scale<U, N, D> >
{
template <typename T>
static T fn()
{
return
ScalingFactor<U>::template fn<T>() *
static_cast<T>(N) / static_cast<T>(D);
}
};
template <typename U, int N, int D>
struct ScalingFactor< Power<U, N, D> >
{
template <typename T>
static T fn()
{
return FixedPower<N, D>::Power(ScalingFactor<U>::template fn<T>());
}
};
template <typename U, int N, int D>
struct ScalingFactor< Translate<U, N, D> >
{
template <typename T>
static T fn()
{
return ScalingFactor<U>::template fn<T>();
}
};
} // namespace Internal
///
/// Display
///
#define UNIT_DISPLAY_NAME(Unit, string) \
template <> \
struct OutputUnit<Unit> \
{ \
template <typename Stream> \
static void fn(Stream& os) \
{ \
os << string; \
} \
}
namespace Internal
{
template <typename U>
struct OutputUnit2
/// The default Unit formatting mechanism.
{
template <typename Stream>
static void fn(Stream &os)
{
os << "Units";
}
};
}
template <typename U>
struct OutputUnit
/// Functor to write Unit text to stream.
{
template <typename Stream>
static void fn(Stream &os)
{
Internal::OutputUnit2<U>::fn(os);
}
};
UNIT_DISPLAY_NAME(Unit, "1");
namespace Internal
{
template <typename U1, typename U2>
struct OutputUnit2< Compose<U1,U2> >
{
template <typename Stream>
static void fn(Stream &os)
{
OutputUnit<U1>::fn(os);
os << '.';
OutputUnit<U2>::fn(os);
}
};
template <typename U, int Num, int Den>
struct OutputUnit2< Power<U, Num, Den > >
{
template <typename Stream>
static void fn(Stream &os)
{
if(Num!=Den) os << '(';
OutputUnit<U>::fn(os);
if(Num!=Den)
{
os << ')';
os << '^' << Num;
if(Num%Den)
{
os << '/' << Den;
}
}
}
};
template <typename U, int Num, int Den>
struct OutputUnit2< Translate<U, Num, Den > >
{
template <typename Stream>
static void fn(Stream &os)
{
os << '(';
OutputUnit<U>::fn(os);
os << '+' << Num;
if(Den!=1) os << '/' << Den;
os << ')';
}
};
template <typename U, int Num, int Den>
struct OutputUnit2< Scale<U, Num, Den > >
{
template <typename Stream>
static void fn(Stream &os)
{
os << Den;
if(Num != 1)
os << '/' << Num;
os << '.';
OutputUnit<U>::fn(os);
}
};
} // namespace Internal
template <typename Str, typename V, typename U>
Str& operator << (Str& os, const Value<V, U>& value)
{
os << value.get() << ' ';
OutputUnit<U>::fn(os);
return os;
}
///
/// Additional Units
///
namespace Units
{
typedef Poco::Util::Units::Unit Unit;
// SI base Units:
struct m; /// meter
struct kg; /// kilogram
struct s; /// second
struct K; /// Kelvin
struct A; /// Ampere
struct mol; /// mole
struct cd; /// candela
}
UNIT_DISPLAY_NAME(Units::m, "m");
UNIT_DISPLAY_NAME(Units::kg, "kg");
UNIT_DISPLAY_NAME(Units::s, "s");
UNIT_DISPLAY_NAME(Units::K, "K");
UNIT_DISPLAY_NAME(Units::A, "A");
UNIT_DISPLAY_NAME(Units::mol, "mol");
UNIT_DISPLAY_NAME(Units::cd, "cd");
namespace Units
{
// SI derived Units:
typedef Compose<m, Power<m, -1> > rad;
typedef Compose<Power<m, 2>, Power<m, -2> > sr;
typedef Power<s, -1> Hz;
typedef Compose<m, Compose<kg, Power<s, -2> > > N;
typedef Compose<N, Power<m, -2> > Pa;
typedef Compose<N, m> J;
typedef Compose<J, Power<s, -1> > W;
typedef Compose<s, A> C;
typedef Compose<W, Power<A, -1> > V;
typedef Compose<C, Power<V, -1> > F;
typedef Compose<V, Power<A, -1> > Ohm;
typedef Compose<A, Power<V, -1> > S;
typedef Compose<V, s> Wb;
typedef Compose<Wb, Power<m, -2> > T;
typedef Compose<Wb, Power<A, -1> > H;
typedef cd lm;
typedef Compose<lm, Power<m, -2> > lx;
typedef Power<s, -1> Bq;
typedef Compose<J, Power<kg, -1> > Gy;
typedef Gy Sv;
typedef Compose<Power<s, -1>,mol> kat;
}
UNIT_DISPLAY_NAME(Units::rad, "rad");
UNIT_DISPLAY_NAME(Units::sr, "sr");
// UNIT_DISPLAY_NAME(Units::Hz, "Hz"); // Too problematic
UNIT_DISPLAY_NAME(Units::N, "N");
UNIT_DISPLAY_NAME(Units::Pa, "Pa");
UNIT_DISPLAY_NAME(Units::J, "J");
UNIT_DISPLAY_NAME(Units::W, "W");
UNIT_DISPLAY_NAME(Units::C, "C");
UNIT_DISPLAY_NAME(Units::V, "V");
UNIT_DISPLAY_NAME(Units::F, "F");
UNIT_DISPLAY_NAME(Units::Ohm, "Ohm");
UNIT_DISPLAY_NAME(Units::S, "S");
UNIT_DISPLAY_NAME(Units::Wb, "Wb");
UNIT_DISPLAY_NAME(Units::T, "T");
UNIT_DISPLAY_NAME(Units::H, "H");
UNIT_DISPLAY_NAME(Units::lx, "lx");
UNIT_DISPLAY_NAME(Units::Gy, "Gy");
UNIT_DISPLAY_NAME(Units::kat, "kat");
namespace Units
{
// SI prefixes:
template <typename U> struct deca { typedef Scale<U, 1, 10> type; };
template <typename U> struct hecto { typedef Scale<U, 1, 100> type; };
template <typename U> struct kilo { typedef Scale<U, 1, 1000> type; };
template <typename U> struct mega { typedef Scale<typename kilo<U>::type, 1, 1000> type; };
template <typename U> struct giga { typedef Scale<typename mega<U>::type, 1, 1000> type; };
template <typename U> struct tera { typedef Scale<typename giga<U>::type, 1, 1000> type; };
template <typename U> struct peta { typedef Scale<typename tera<U>::type, 1, 1000> type; };
template <typename U> struct exa { typedef Scale<typename peta<U>::type, 1, 1000> type; };
template <typename U> struct zetta { typedef Scale<typename exa<U>::type, 1, 1000> type; };
template <typename U> struct yotta { typedef Scale<typename zetta<U>::type, 1, 1000> type; };
template <typename U> struct deci { typedef Scale<U, 10> type; };
template <typename U> struct centi { typedef Scale<U, 100> type; };
template <typename U> struct milli { typedef Scale<U, 1000> type; };
template <typename U> struct micro { typedef Scale<typename milli<U>::type, 1000> type; };
template <typename U> struct nano { typedef Scale<typename micro<U>::type, 1000> type; };
template <typename U> struct pico { typedef Scale<typename nano<U>::type, 1000> type; };
template <typename U> struct femto { typedef Scale<typename pico<U>::type, 1000> type; };
template <typename U> struct atto { typedef Scale<typename femto<U>::type, 1000> type; };
template <typename U> struct zepto { typedef Scale<typename atto<U>::type, 1000> type; };
template <typename U> struct yocto { typedef Scale<typename zepto<U>::type, 1000> type; };
// Some prefixed SI Units:
typedef centi<m>::type cm;
typedef milli<m>::type mm;
typedef kilo<m>::type km;
typedef milli<kg>::type g;
typedef milli<g>::type mg;
typedef milli<s>::type ms;
class Prefix
/// Parent class for unit prefixes.
/// Use classes inheriting from this class to scale
/// the values.
{
public:
template <typename T>
Prefix(const T& val, double multiplier = 1, const std::string& prefix = ""):
_pHolder(new Holder<T>(val)),
_multiplier(multiplier),
_prefix(prefix)
{
}
double value() const
{
return _pHolder->get() * _multiplier;
}
void addPrefix(std::ostream& os) const
{
os << _prefix;
}
void addUnit(std::ostream& os) const
{
_pHolder->appendUnit(os);
}
private:
Prefix();
class Placeholder
{
public:
virtual ~Placeholder() { }
virtual double get() const = 0;
virtual void appendUnit(std::ostream& os) const = 0;
};
template <typename U>
struct Holder : public Placeholder
{
typedef Value<typename U::ValueType, typename U::Unit> ValueType;
Holder (const U& val): _val(ValueType(val))
{
}
double get() const
{
return _val.get();
}
void appendUnit(std::ostream& os) const
{
OutputUnit<typename U::Unit>::fn(os);
}
ValueType _val;
};
Placeholder* _pHolder;
double _multiplier;
std::string _prefix;
};
}
template <typename Str>
Str& streamOp (Str& os, const Units::Prefix& val)
{
os << val.value() << ' ';
val.addPrefix(os);
val.addUnit(os);
return os;
}
template <typename Str>
Str& operator << (Str& os, const Units::Prefix& val)
/// Streaming operator for prefixed values.
{
return streamOp(os, val);
}
UNIT_DISPLAY_NAME(Units::cm, "cm");
UNIT_DISPLAY_NAME(Units::mm, "mm");
UNIT_DISPLAY_NAME(Units::km, "km");
UNIT_DISPLAY_NAME(Units::g, "g");
UNIT_DISPLAY_NAME(Units::mg, "mg");
UNIT_DISPLAY_NAME(Units::ms, "ms");
namespace Units
{
// Non-SI mass
typedef Scale<kg, 22046223, 10000000> lb;
typedef Scale<lb, 16> oz;
typedef Scale<kg, 1, 1000> tonne;
// Non-SI temperature
typedef Translate<K, -27315, 100> Celsius;
typedef Translate<Scale<Celsius, 9, 5>, 32> Fahrenheit;
// Non-SI time
typedef Scale<s, 1, 60> minute;
typedef Scale<minute, 1, 60> hour;
typedef Scale<hour, 1, 24> day;
typedef Scale<day, 1, 7> week;
struct month; // No fixed ratio with week
typedef Scale<month, 1, 12> year;
typedef Scale<year, 1, 100> century;
typedef Scale<year, 1, 1000> millennium;
// Non-SI length
typedef Scale<cm, 100, 254> inch;
typedef Scale<inch, 1, 12> foot;
typedef Scale<inch, 1, 36> yard;
typedef Scale<yard, 1, 1760> mile;
typedef Scale<m, 1, 1852> nautical_mile;
// Non-SI area
typedef Power<m, 2> m2;
typedef Power<mm, 2> mm2;
typedef Scale<m2, 1, 10000> hectare;
typedef Scale<m2, 1, 100> are;
typedef Power<inch, 2> inch2;
typedef Scale<hectare, 24710538, 10000000> acre;
// Non-SI volume
typedef Power<cm, 3> cm3;
typedef cm3 ml;
typedef Scale<ml, 1, 1000> liter;
typedef Scale<liter, 10> dl;
typedef Scale<liter, 100> cl;
typedef Power<m, 3> m3;
// Non-SI velocity
typedef Compose<mile, Power<hour, -1> > mph;
typedef Compose<km, Power<hour, -1> > kph;
typedef Compose<m, Power<s, -1> > meters_per_second;
typedef Compose<nautical_mile, Power<hour, -1> > knot;
typedef Scale<meters_per_second, 100, 34029> mach;
// Angles
typedef Scale<rad, 180000000, 3141593> degree;
typedef Scale<rad, 200000000, 3141593> grad;
typedef Scale< degree, 60 > degree_minute;
typedef Scale< degree_minute, 60 > degree_second;
// Pressure
typedef Scale<Pa, 1, 1000> kPa;
typedef Scale<kPa, 1450377, 10000000> psi;
typedef Scale<kPa, 10> millibar;
// Other
typedef Scale<Hz, 60> rpm;
typedef Scale<Unit, 100> percent;
typedef Scale<Unit, 1, 12> dozen;
typedef Scale<Unit, 1, 13> bakers_dozen;
}
UNIT_DISPLAY_NAME(Units::lb, "lb");
UNIT_DISPLAY_NAME(Units::oz, "oz");
UNIT_DISPLAY_NAME(Units::tonne, "tonnes");
UNIT_DISPLAY_NAME(Units::Celsius, "'C");
UNIT_DISPLAY_NAME(Units::Fahrenheit, "'F");
UNIT_DISPLAY_NAME(Units::minute, "minutes");
UNIT_DISPLAY_NAME(Units::hour, "hours");
UNIT_DISPLAY_NAME(Units::day, "days");
UNIT_DISPLAY_NAME(Units::week, "weeks");
UNIT_DISPLAY_NAME(Units::month, "months");
UNIT_DISPLAY_NAME(Units::year, "years");
UNIT_DISPLAY_NAME(Units::century, "centuries");
UNIT_DISPLAY_NAME(Units::millennium, "millennia");
UNIT_DISPLAY_NAME(Units::inch, "inches");
UNIT_DISPLAY_NAME(Units::foot, "foot");
UNIT_DISPLAY_NAME(Units::yard, "yards");
UNIT_DISPLAY_NAME(Units::mile, "miles");
UNIT_DISPLAY_NAME(Units::nautical_mile, "nautical miles");
UNIT_DISPLAY_NAME(Units::hectare, "ha");
UNIT_DISPLAY_NAME(Units::are, "are");
UNIT_DISPLAY_NAME(Units::acre, "acres");
UNIT_DISPLAY_NAME(Units::ml, "ml");
UNIT_DISPLAY_NAME(Units::liter, "l");
UNIT_DISPLAY_NAME(Units::dl, "dl");
UNIT_DISPLAY_NAME(Units::cl, "cl");
UNIT_DISPLAY_NAME(Units::mph, "mph");
UNIT_DISPLAY_NAME(Units::kph, "km/h");
UNIT_DISPLAY_NAME(Units::knot, "knots");
UNIT_DISPLAY_NAME(Units::mach, "mach");
UNIT_DISPLAY_NAME(Units::degree, "deg");
UNIT_DISPLAY_NAME(Units::grad, "grad");
UNIT_DISPLAY_NAME(Units::degree_minute, "'");
UNIT_DISPLAY_NAME(Units::degree_second, "\"");
UNIT_DISPLAY_NAME(Units::kPa, "kPa");
UNIT_DISPLAY_NAME(Units::psi, "PSI");
UNIT_DISPLAY_NAME(Units::millibar, "millibars");
UNIT_DISPLAY_NAME(Units::percent, "%");
UNIT_DISPLAY_NAME(Units::rpm, "rpm");
UNIT_DISPLAY_NAME(Units::dozen, "dozen");
UNIT_DISPLAY_NAME(Units::bakers_dozen, "bakers dozen");
namespace Values
{
typedef Value<double, Units::Unit> Unit;
// SI Units
typedef Value<double, Units::m> m;
typedef Value<double, Units::kg> kg;
typedef Value<double, Units::s> s;
typedef Value<double, Units::K> K;
typedef Value<double, Units::A> A;
typedef Value<double, Units::mol> mol;
typedef Value<double, Units::cd> cd;
// SI derived
typedef Value<double, Units::rad> rad;
typedef Value<double, Units::sr> sr;
typedef Value<double, Units::Hz> Hz;
typedef Value<double, Units::N> N;
typedef Value<double, Units::Pa> Pa;
typedef Value<double, Units::J> J;
typedef Value<double, Units::W> W;
typedef Value<double, Units::C> C;
typedef Value<double, Units::V> V;
typedef Value<double, Units::F> F;
typedef Value<double, Units::Ohm> Ohm;
typedef Value<double, Units::S> S;
typedef Value<double, Units::Wb> Wb;
typedef Value<double, Units::T> T;
typedef Value<double, Units::H> H;
typedef Value<double, Units::lm> lm;
typedef Value<double, Units::lx> lx;
typedef Value<double, Units::Bq> Bq;
typedef Value<double, Units::Gy> Gy;
typedef Value<double, Units::Sv> Sv;
typedef Value<double, Units::kat> kat;
// Prefixed Units
typedef Value<double, Units::cm> cm;
typedef Value<double, Units::mm> mm;
typedef Value<double, Units::km> km;
typedef Value<double, Units::g> g;
typedef Value<double, Units::mg> mg;
typedef Value<double, Units::ms> ms;
// Non-SI
typedef Value<double, Units::lb> lb;
typedef Value<double, Units::oz> oz;
typedef Value<double, Units::tonne> tonne;
typedef Value<double, Units::Celsius> Celsius;
typedef Value<double, Units::Fahrenheit> Fahrenheit;
typedef Value<double, Units::minute> minute;
typedef Value<double, Units::hour> hour;
typedef Value<double, Units::day> day;
typedef Value<double, Units::week> week;
typedef Value<double, Units::month> month;
typedef Value<double, Units::year> year;
typedef Value<double, Units::century> century;
typedef Value<double, Units::millennium> millennium;
typedef Value<double, Units::inch> inch;
typedef Value<double, Units::foot> foot;
typedef Value<double, Units::yard> yard;
typedef Value<double, Units::mile> mile;
typedef Value<double, Units::nautical_mile> nautical_mile;
typedef Value<double, Units::m2> m2;
typedef Value<double, Units::mm2> mm2;
typedef Value<double, Units::hectare> hectare;
typedef Value<double, Units::are> are;
typedef Value<double, Units::inch2> inch2;
typedef Value<double, Units::acre> acre;
typedef Value<double, Units::cm3> cm3;
typedef Value<double, Units::ml> ml;
typedef Value<double, Units::cl> cl;
typedef Value<double, Units::liter> liter;
typedef Value<double, Units::dl> dl;
typedef Value<double, Units::m3> m3;
typedef Value<double, Units::mph> mph;
typedef Value<double, Units::kph> kph;
typedef Value<double, Units::meters_per_second> meters_per_second;
typedef Value<double, Units::knot> knot;
typedef Value<double, Units::mach> mach;
typedef Value<double, Units::degree> degree;
typedef Value<double, Units::grad> grad;
typedef Value<double, Units::degree_minute> degree_minute;
typedef Value<double, Units::degree_second> degree_second;
typedef Value<double, Units::kPa> kPa;
typedef Value<double, Units::psi> psi;
typedef Value<double, Units::millibar> millibar;
typedef Value<double, Units::percent> percent;
typedef Value<double, Units::rpm> rpm;
typedef Value<double, Units::dozen> dozen;
typedef Value<double, Units::bakers_dozen> bakers_dozen;
#define DEFINE_PREFIX_CLASS(name, scale, prefix) \
struct name: public Units::Prefix \
{ \
template <typename T> \
name(const T& val): Prefix(val, scale, prefix) \
{ \
} \
}; \
template <typename Str> \
Str& operator << (Str& os, const name& val) \
{ \
return streamOp<Str>(os, val); \
}
DEFINE_PREFIX_CLASS (deca, .1, "da")
DEFINE_PREFIX_CLASS (hecto, .01, "h")
DEFINE_PREFIX_CLASS (kilo, .001, "k")
DEFINE_PREFIX_CLASS (mega, 1e-6, "M")
DEFINE_PREFIX_CLASS (giga, 1e-9, "G")
DEFINE_PREFIX_CLASS (tera, 1e-12, "T")
DEFINE_PREFIX_CLASS (peta, 1e-15, "P")
DEFINE_PREFIX_CLASS (exa, 1e-18, "E")
DEFINE_PREFIX_CLASS (zetta, 1e-21, "Z")
DEFINE_PREFIX_CLASS (yotta, 1e-24, "Y")
DEFINE_PREFIX_CLASS (deci, 10, "d")
DEFINE_PREFIX_CLASS (centi, 100, "c")
DEFINE_PREFIX_CLASS (milli, 1000, "m")
DEFINE_PREFIX_CLASS (micro, 1e6, "u")
DEFINE_PREFIX_CLASS (nano, 1e9, "n")
DEFINE_PREFIX_CLASS (pico, 1e12, "p")
DEFINE_PREFIX_CLASS (femto, 1e15, "f")
DEFINE_PREFIX_CLASS (atto, 1e18, "a")
DEFINE_PREFIX_CLASS (zepto, 1e21, "z")
DEFINE_PREFIX_CLASS (yocto, 1e24, "y")
}
namespace Constants
{
// Physical constants:
const Value<double, Compose<Units::J, Power<Units::K, -1> > > k (1.3806504e-23);
const Value<double, Units::kg> mu (1.660538782e-27);
const Value<double, Power<Units::mol, -1> > NA (6.02214179e23);
const Value<double, Units::s> G0 (7.7480917004e-5);
const Value<double, Compose<Units::F, Power<Units::m, -1> > > e0 (8.854187817e-12);
const Value<double, Units::kg> me (9.10938215e-31);
const Value<double, Units::J> eV (1.602176487e-19);
const Value<double, Units::C> e (1.602176487e-19);
const Value<double, Units::F> F (96485.3399);
const Value<double, Units::Unit> alpha (7.2973525376e-3);
const Value<double, Units::Unit> inv_alpha (137.035999679);
const Value<double, Compose<Units::N, Power<Units::A, -2> > > u0 (12.566370614);
const Value<double, Units::Wb> phi0 (2.067833667e-15); // ??
const Value<double, Compose<Units::J, Compose<Power<Units::mol, -1>, Power<Units::kg, -1> > > > R (8.314472);
const Value<double, Compose< Power<Units::m, 3>, Compose<Power<Units::kg, -1>, Power<Units::s, -2> > > > G (6.67428e-11);
const Value<double, Compose< Units::J, Units::s > > h (6.62606896e-34);
const Value<double, Compose< Units::J, Units::s > > h_bar (1.054571628e-34);
const Value<double, Units::kg> mp (1.672621637e-27);
const Value<double, Unit> mpme (1836.15267247);
const Value<double, Power<Units::m, -1> > Rinf (10973731.568527);
const Value<double, Compose<Units::m, Power<Units::s, -1> > > c (299792458);
const Value<double, Compose<Units::W, Compose< Power<Units::m, -1>, Power<Units::K, -4> > > > rho (5.6704e-8);
// Other constants:
const Value<double, Units::rad> pi (3.141592653589793);
const Value<double, Units::m> lightyear (9.4605284e15);
const Value<double, Units::km> AU(149597871);
const Value<double, Compose<Units::m, Power<Units::s, -2> > > g (9.80665);
}
//
// Trigonometry
//
template <typename V, typename U>
V sin(const Value<V, U>& angle)
{
return std::sin(Value<V, Units::rad>(angle).get());
}
template <typename V, typename U>
V cos(const Value<V, U>& angle)
{
return std::cos(Value<V, Units::rad>(angle).get());
}
template <typename V, typename U>
V tan(const Value<V, U>& angle)
{
return std::tan(Value<V, Units::rad>(angle).get());
}
} } } // namespace Poco::Util::Units
#endif // Util_Units_INCLUDED
Reference in New Issue View Git Blame Copy Permalink