w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2024-11-09 02:26:06 -05:00
Code Issues Packages Projects Releases Wiki Activity
4ebe6417a5
WSJT-X/boost/units/unit.hpp
Bill Somerville 4ebe6417a5 Squashed 'boost/' content from commit b4feb19f2 
git-subtree-dir: boost
git-subtree-split: b4feb19f287ee92d87a9624b5d36b7cf46aeadeb
2018-06-09 21:48:32 +01:00

441 lines
13 KiB
C++
Raw Blame History

// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_UNITS_UNIT_HPP
#define BOOST_UNITS_UNIT_HPP
#include <boost/static_assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/units/config.hpp>
#include <boost/units/dimension.hpp>
#include <boost/units/operators.hpp>
#include <boost/units/units_fwd.hpp>
#include <boost/units/homogeneous_system.hpp>
#include <boost/units/heterogeneous_system.hpp>
#include <boost/units/is_dimension_list.hpp>
#include <boost/units/reduce_unit.hpp>
#include <boost/units/static_rational.hpp>
namespace boost {
namespace units {
/// class representing a model-dependent unit with no associated value
/// (e.g. meters, Kelvin, feet, etc...)
template<class Dim,class System, class Enable>
class unit
{
public:
typedef unit<Dim, System> unit_type;
typedef unit<Dim,System> this_type;
typedef Dim dimension_type;
typedef System system_type;
unit() { }
unit(const this_type&) { }
//~unit() { }
this_type& operator=(const this_type&) { return *this; }
// sun will ignore errors resulting from templates
// instantiated in the return type of a function.
// Make sure that we get an error anyway by putting.
// the check in the destructor.
#ifdef __SUNPRO_CC
~unit() {
BOOST_MPL_ASSERT((detail::check_system<System, Dim>));
BOOST_MPL_ASSERT((is_dimension_list<Dim>));
}
#else
private:
BOOST_MPL_ASSERT((detail::check_system<System, Dim>));
BOOST_MPL_ASSERT((is_dimension_list<Dim>));
#endif
};
}
}
#if BOOST_UNITS_HAS_BOOST_TYPEOF
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::unit, 2)
#endif
namespace boost {
namespace units {
/// Returns a unique type for every unit.
template<class Dim, class System>
struct reduce_unit<unit<Dim, System> >
{
typedef unit<
Dim,
typename detail::make_heterogeneous_system<
Dim,
System
>::type
> type;
};
/// INTERNAL ONLY
template<class S1,class S2>
struct is_implicitly_convertible :
boost::is_same<typename reduce_unit<S1>::type, typename reduce_unit<S2>::type>
{ };
/// unit unary plus typeof helper
/// INTERNAL ONLY
template<class Dim,class System>
struct unary_plus_typeof_helper< unit<Dim,System> >
{
typedef unit<Dim,System> type;
};
/// unit unary minus typeof helper
/// INTERNAL ONLY
template<class Dim,class System>
struct unary_minus_typeof_helper< unit<Dim,System> >
{
typedef unit<Dim,System> type;
};
/// unit add typeof helper
/// INTERNAL ONLY
template<class Dim,
class System>
struct add_typeof_helper< unit<Dim,System>,unit<Dim,System> >
{
typedef unit<Dim,System> type;
};
/// unit subtract typeof helper
/// INTERNAL ONLY
template<class Dim,
class System>
struct subtract_typeof_helper< unit<Dim,System>,unit<Dim,System> >
{
typedef unit<Dim,System> type;
};
/// unit multiply typeof helper for two identical homogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System>
struct multiply_typeof_helper< unit<Dim1,homogeneous_system<System> >,
unit<Dim2,homogeneous_system<System> > >
{
typedef unit<typename mpl::times<Dim1,Dim2>::type,homogeneous_system<System> > type;
};
/// unit multiply typeof helper for two different homogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct multiply_typeof_helper< unit<Dim1,homogeneous_system<System1> >,
unit<Dim2,homogeneous_system<System2> > >
{
typedef unit<
typename mpl::times<Dim1,Dim2>::type,
typename detail::multiply_systems<
typename detail::make_heterogeneous_system<Dim1, System1>::type,
typename detail::make_heterogeneous_system<Dim2, System2>::type
>::type
> type;
};
/// unit multiply typeof helper for a heterogeneous and a homogeneous system
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct multiply_typeof_helper< unit<Dim1,heterogeneous_system<System1> >,
unit<Dim2,homogeneous_system<System2> > >
{
typedef unit<
typename mpl::times<Dim1,Dim2>::type,
typename detail::multiply_systems<
heterogeneous_system<System1>,
typename detail::make_heterogeneous_system<Dim2, System2>::type
>::type
> type;
};
/// unit multiply typeof helper for a homogeneous and a heterogeneous system
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct multiply_typeof_helper< unit<Dim1,homogeneous_system<System1> >,
unit<Dim2,heterogeneous_system<System2> > >
{
typedef unit<
typename mpl::times<Dim1,Dim2>::type,
typename detail::multiply_systems<
typename detail::make_heterogeneous_system<Dim1, System1>::type,
heterogeneous_system<System2>
>::type
> type;
};
/// unit multiply typeof helper for two heterogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct multiply_typeof_helper< unit<Dim1,heterogeneous_system<System1> >,
unit<Dim2,heterogeneous_system<System2> > >
{
typedef unit<
typename mpl::times<Dim1,Dim2>::type,
typename detail::multiply_systems<
heterogeneous_system<System1>,
heterogeneous_system<System2>
>::type
> type;
};
/// unit divide typeof helper for two identical homogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System>
struct divide_typeof_helper< unit<Dim1,homogeneous_system<System> >,
unit<Dim2,homogeneous_system<System> > >
{
typedef unit<typename mpl::divides<Dim1,Dim2>::type,homogeneous_system<System> > type;
};
/// unit divide typeof helper for two different homogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct divide_typeof_helper< unit<Dim1,homogeneous_system<System1> >,
unit<Dim2,homogeneous_system<System2> > >
{
typedef unit<
typename mpl::divides<Dim1,Dim2>::type,
typename detail::divide_systems<
typename detail::make_heterogeneous_system<Dim1, System1>::type,
typename detail::make_heterogeneous_system<Dim2, System2>::type
>::type
> type;
};
/// unit divide typeof helper for a heterogeneous and a homogeneous system
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct divide_typeof_helper< unit<Dim1,heterogeneous_system<System1> >,
unit<Dim2,homogeneous_system<System2> > >
{
typedef unit<
typename mpl::divides<Dim1,Dim2>::type,
typename detail::divide_systems<
heterogeneous_system<System1>,
typename detail::make_heterogeneous_system<Dim2, System2>::type
>::type
> type;
};
/// unit divide typeof helper for a homogeneous and a heterogeneous system
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct divide_typeof_helper< unit<Dim1,homogeneous_system<System1> >,
unit<Dim2,heterogeneous_system<System2> > >
{
typedef unit<
typename mpl::divides<Dim1,Dim2>::type,
typename detail::divide_systems<
typename detail::make_heterogeneous_system<Dim1, System1>::type,
heterogeneous_system<System2>
>::type
> type;
};
/// unit divide typeof helper for two heterogeneous systems
/// INTERNAL ONLY
template<class Dim1,
class Dim2,
class System1,
class System2>
struct divide_typeof_helper< unit<Dim1,heterogeneous_system<System1> >,
unit<Dim2,heterogeneous_system<System2> > >
{
typedef unit<
typename mpl::divides<Dim1,Dim2>::type,
typename detail::divide_systems<
heterogeneous_system<System1>,
heterogeneous_system<System2>
>::type
> type;
};
/// raise unit to a @c static_rational power
template<class Dim,class System,long N,long D>
struct power_typeof_helper<unit<Dim,System>,static_rational<N,D> >
{
typedef unit<typename static_power<Dim,static_rational<N,D> >::type,typename static_power<System, static_rational<N,D> >::type> type;
static type value(const unit<Dim,System>&)
{
return type();
}
};
/// take the @c static_rational root of a unit
template<class Dim,class System,long N,long D>
struct root_typeof_helper<unit<Dim,System>,static_rational<N,D> >
{
typedef unit<typename static_root<Dim,static_rational<N,D> >::type,typename static_root<System, static_rational<N,D> >::type> type;
static type value(const unit<Dim,System>&)
{
return type();
}
};
/// unit runtime unary plus
template<class Dim,class System>
typename unary_plus_typeof_helper< unit<Dim,System> >::type
operator+(const unit<Dim,System>&)
{
typedef typename unary_plus_typeof_helper< unit<Dim,System> >::type type;
return type();
}
/// unit runtime unary minus
template<class Dim,class System>
typename unary_minus_typeof_helper< unit<Dim,System> >::type
operator-(const unit<Dim,System>&)
{
typedef typename unary_minus_typeof_helper< unit<Dim,System> >::type type;
return type();
}
/// runtime add two units
template<class Dim1,
class Dim2,
class System1,
class System2>
typename add_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator+(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
BOOST_STATIC_ASSERT((boost::is_same<System1,System2>::value == true));
typedef System1 system_type;
typedef typename add_typeof_helper< unit<Dim1,system_type>,
unit<Dim2,system_type> >::type type;
return type();
}
/// runtime subtract two units
template<class Dim1,
class Dim2,
class System1,
class System2>
typename subtract_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator-(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
BOOST_STATIC_ASSERT((boost::is_same<System1,System2>::value == true));
typedef System1 system_type;
typedef typename subtract_typeof_helper< unit<Dim1,system_type>,
unit<Dim2,system_type> >::type type;
return type();
}
/// runtime multiply two units
template<class Dim1,
class Dim2,
class System1,
class System2>
typename multiply_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator*(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
typedef typename multiply_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type type;
return type();
}
/// runtime divide two units
template<class Dim1,
class Dim2,
class System1,
class System2>
typename divide_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator/(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
typedef typename divide_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type type;
return type();
}
/// unit runtime @c operator==
template<class Dim1,
class Dim2,
class System1,
class System2>
inline
bool
operator==(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
return boost::is_same<typename reduce_unit<unit<Dim1,System1> >::type, typename reduce_unit<unit<Dim2,System2> >::type>::value;
}
/// unit runtime @c operator!=
template<class Dim1,
class Dim2,
class System1,
class System2>
inline
bool
operator!=(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
return !boost::is_same<typename reduce_unit<unit<Dim1,System1> >::type, typename reduce_unit<unit<Dim2,System2> >::type>::value;
}
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_UNIT_HPP
Reference in New Issue View Git Blame Copy Permalink