FM / units

/usr/include/boost/units

Name	Size	Mode	Actions
base_units/	-	0755	rm
detail/	-	0755	rm
physical_dimensions/	-	0755	rm
systems/	-	0755	rm
absolute.hpp	5540	0644	edit dl rm
base_dimension.hpp	3692	0644	edit dl rm
base_unit.hpp	4132	0644	edit dl rm
cmath.hpp	20592	0644	edit dl rm
config.hpp	2829	0644	edit dl rm
conversion.hpp	9518	0644	edit dl rm
derived_dimension.hpp	6465	0644	edit dl rm
dim.hpp	4745	0644	edit dl rm
dimension.hpp	4403	0644	edit dl rm
dimensionless_quantity.hpp	995	0644	edit dl rm
dimensionless_type.hpp	1315	0644	edit dl rm
dimensionless_unit.hpp	957	0644	edit dl rm
get_dimension.hpp	1221	0644	edit dl rm
get_system.hpp	1165	0644	edit dl rm
heterogeneous_system.hpp	12258	0644	edit dl rm
homogeneous_system.hpp	2399	0644	edit dl rm
io.hpp	32470	0644	edit dl rm
is_dim.hpp	885	0644	edit dl rm
is_dimensionless.hpp	1107	0644	edit dl rm
is_dimensionless_quantity.hpp	936	0644	edit dl rm
is_dimensionless_unit.hpp	905	0644	edit dl rm
is_dimension_list.hpp	1057	0644	edit dl rm
is_quantity.hpp	916	0644	edit dl rm
is_quantity_of_dimension.hpp	1115	0644	edit dl rm
is_quantity_of_system.hpp	1097	0644	edit dl rm
is_unit.hpp	879	0644	edit dl rm
is_unit_of_dimension.hpp	1138	0644	edit dl rm
is_unit_of_system.hpp	1127	0644	edit dl rm
lambda.hpp	26841	0644	edit dl rm
limits.hpp	4345	0644	edit dl rm
make_scaled_unit.hpp	1817	0644	edit dl rm
make_system.hpp	4914	0644	edit dl rm
operators.hpp	6287	0644	edit dl rm
physical_dimensions.hpp	4532	0644	edit dl rm
pow.hpp	3033	0644	edit dl rm
quantity.hpp	41860	0644	edit dl rm
reduce_unit.hpp	868	0644	edit dl rm
scale.hpp	5062	0644	edit dl rm
scaled_base_unit.hpp	3643	0644	edit dl rm
static_constant.hpp	2425	0644	edit dl rm
static_rational.hpp	10435	0644	edit dl rm
unit.hpp	13449	0644	edit dl rm
units_fwd.hpp	2191	0644	edit dl rm

Edit: /usr/include/boost/units/unit.hpp (13449B)

#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;
        
        BOOST_CONSTEXPR unit() { }
        BOOST_CONSTEXPR unit(const this_type&) { }
        //~unit() { }  
       
        BOOST_CXX14_CONSTEXPR 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 BOOST_CONSTEXPR 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 BOOST_CONSTEXPR type value(const unit<Dim,System>&)  
    { 
        return type();
    }
};

/// unit runtime unary plus
template<class Dim,class System>
BOOST_CONSTEXPR
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>
BOOST_CONSTEXPR
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>
BOOST_CONSTEXPR
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>
BOOST_CONSTEXPR
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>
BOOST_CONSTEXPR
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>
BOOST_CONSTEXPR
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
BOOST_CONSTEXPR
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
BOOST_CONSTEXPR
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

// 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 #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace units { /// class representing a model-dependent unit with no associated value /// (e.g. meters, Kelvin, feet, etc...) template class unit { public: typedef unit unit_type; typedef unit this_type; typedef Dim dimension_type; typedef System system_type; BOOST_CONSTEXPR unit() { } BOOST_CONSTEXPR unit(const this_type&) { } //~unit() { } BOOST_CXX14_CONSTEXPR 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)); BOOST_MPL_ASSERT((is_dimension_list)); } #else private: BOOST_MPL_ASSERT((detail::check_system)); BOOST_MPL_ASSERT((is_dimension_list)); #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 struct reduce_unit > { typedef unit< Dim, typename detail::make_heterogeneous_system< Dim, System >::type > type; }; /// INTERNAL ONLY template struct is_implicitly_convertible : boost::is_same::type, typename reduce_unit::type> { }; /// unit unary plus typeof helper /// INTERNAL ONLY template struct unary_plus_typeof_helper< unit > { typedef unit type; }; /// unit unary minus typeof helper /// INTERNAL ONLY template struct unary_minus_typeof_helper< unit > { typedef unit type; }; /// unit add typeof helper /// INTERNAL ONLY template struct add_typeof_helper< unit,unit > { typedef unit type; }; /// unit subtract typeof helper /// INTERNAL ONLY template struct subtract_typeof_helper< unit,unit > { typedef unit type; }; /// unit multiply typeof helper for two identical homogeneous systems /// INTERNAL ONLY template struct multiply_typeof_helper< unit >, unit > > { typedef unit::type,homogeneous_system > type; }; /// unit multiply typeof helper for two different homogeneous systems /// INTERNAL ONLY template struct multiply_typeof_helper< unit >, unit > > { typedef unit< typename mpl::times::type, typename detail::multiply_systems< typename detail::make_heterogeneous_system::type, typename detail::make_heterogeneous_system::type >::type > type; }; /// unit multiply typeof helper for a heterogeneous and a homogeneous system /// INTERNAL ONLY template struct multiply_typeof_helper< unit >, unit > > { typedef unit< typename mpl::times::type, typename detail::multiply_systems< heterogeneous_system, typename detail::make_heterogeneous_system::type >::type > type; }; /// unit multiply typeof helper for a homogeneous and a heterogeneous system /// INTERNAL ONLY template struct multiply_typeof_helper< unit >, unit > > { typedef unit< typename mpl::times::type, typename detail::multiply_systems< typename detail::make_heterogeneous_system::type, heterogeneous_system >::type > type; }; /// unit multiply typeof helper for two heterogeneous systems /// INTERNAL ONLY template struct multiply_typeof_helper< unit >, unit > > { typedef unit< typename mpl::times::type, typename detail::multiply_systems< heterogeneous_system, heterogeneous_system >::type > type; }; /// unit divide typeof helper for two identical homogeneous systems /// INTERNAL ONLY template struct divide_typeof_helper< unit >, unit > > { typedef unit::type,homogeneous_system > type; }; /// unit divide typeof helper for two different homogeneous systems /// INTERNAL ONLY template struct divide_typeof_helper< unit >, unit > > { typedef unit< typename mpl::divides::type, typename detail::divide_systems< typename detail::make_heterogeneous_system::type, typename detail::make_heterogeneous_system::type >::type > type; }; /// unit divide typeof helper for a heterogeneous and a homogeneous system /// INTERNAL ONLY template struct divide_typeof_helper< unit >, unit > > { typedef unit< typename mpl::divides::type, typename detail::divide_systems< heterogeneous_system, typename detail::make_heterogeneous_system::type >::type > type; }; /// unit divide typeof helper for a homogeneous and a heterogeneous system /// INTERNAL ONLY template struct divide_typeof_helper< unit >, unit > > { typedef unit< typename mpl::divides::type, typename detail::divide_systems< typename detail::make_heterogeneous_system::type, heterogeneous_system >::type > type; }; /// unit divide typeof helper for two heterogeneous systems /// INTERNAL ONLY template struct divide_typeof_helper< unit >, unit > > { typedef unit< typename mpl::divides::type, typename detail::divide_systems< heterogeneous_system, heterogeneous_system >::type > type; }; /// raise unit to a @c static_rational power template struct power_typeof_helper,static_rational > { typedef unit >::type,typename static_power >::type> type; static BOOST_CONSTEXPR type value(const unit&) { return type(); } }; /// take the @c static_rational root of a unit template struct root_typeof_helper,static_rational > { typedef unit >::type,typename static_root >::type> type; static BOOST_CONSTEXPR type value(const unit&) { return type(); } }; /// unit runtime unary plus template BOOST_CONSTEXPR typename unary_plus_typeof_helper< unit >::type operator+(const unit&) { typedef typename unary_plus_typeof_helper< unit >::type type; return type(); } /// unit runtime unary minus template BOOST_CONSTEXPR typename unary_minus_typeof_helper< unit >::type operator-(const unit&) { typedef typename unary_minus_typeof_helper< unit >::type type; return type(); } /// runtime add two units template BOOST_CONSTEXPR typename add_typeof_helper< unit, unit >::type operator+(const unit&,const unit&) { BOOST_STATIC_ASSERT((boost::is_same::value == true)); typedef System1 system_type; typedef typename add_typeof_helper< unit, unit >::type type; return type(); } /// runtime subtract two units template BOOST_CONSTEXPR typename subtract_typeof_helper< unit, unit >::type operator-(const unit&,const unit&) { BOOST_STATIC_ASSERT((boost::is_same::value == true)); typedef System1 system_type; typedef typename subtract_typeof_helper< unit, unit >::type type; return type(); } /// runtime multiply two units template BOOST_CONSTEXPR typename multiply_typeof_helper< unit, unit >::type operator*(const unit&,const unit&) { typedef typename multiply_typeof_helper< unit, unit >::type type; return type(); } /// runtime divide two units template BOOST_CONSTEXPR typename divide_typeof_helper< unit, unit >::type operator/(const unit&,const unit&) { typedef typename divide_typeof_helper< unit, unit >::type type; return type(); } /// unit runtime @c operator== template inline BOOST_CONSTEXPR bool operator==(const unit&,const unit&) { return boost::is_same >::type, typename reduce_unit >::type>::value; } /// unit runtime @c operator!= template inline BOOST_CONSTEXPR bool operator!=(const unit&,const unit&) { return !boost::is_same >::type, typename reduce_unit >::type>::value; } } // namespace units } // namespace boost #endif // BOOST_UNITS_UNIT_HPP