(3)

NAME
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),_Y>

SYNOPSIS

// In header: <boost/units/quantity.hpp>
template<typename System, typename Y>
class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> {
public:
  // types
  typedef quantity< unit< dimensionless_type, System >, Y > this_type;
  typedef Y                                                 value_type;
  typedef System                                            system_type;
  typedef dimensionless_type                                dimension_type;
  typedef unit< dimension_type, system_type >               unit_type;
  // construct/copy/destruct
  quantity& operator=(const this_type &);
  template<typename YY>
    quantity& operator=(const quantity< unit< dimension_type, system_type >, YY > &);
  template<typename System2>
    quantity& operator=(const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System2), Y > &);
  // public member functions
   quantity();
   quantity(value_type);
   quantity(const this_type &);
  template<typename YY>
     quantity(const quantity< unit< dimension_type, system_type >, YY > &,
              unspecified = 0);
  template<typename YY>
     quantity(const quantity< unit< dimension_type, system_type >, YY > &,
              unspecified = 0);
  template<typename System2, typename Y2>
     quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > &,
              unspecified = 0, unspecified = 0, unspecified = 0);
  template<typename System2, typename Y2>
     quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > &,
              unspecified = 0, unspecified = 0, unspecified = 0);
  template<typename System2, typename Y2>
     quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > &,
              unspecified = 0);
  operator value_type() const;
  const value_type & value() const;
  this_type & operator+=(const this_type &);
  this_type & operator-=(const this_type &);
  this_type & operator*=(const value_type &);
  this_type & operator/=(const value_type &);
  // public static functions
  static this_type from_value(const value_type &);
};

DESCRIPTION

Specialization for dimensionless quantities. Implicit conversions between unit systems are allowed because all dimensionless quantities are equivalent. Implicit construction and assignment from and conversion to value_type is also allowed.

  quantity public construct/copy/destruct

    1.

    quantity& operator=(const this_type & source);

    2.

    template<typename YY>
      quantity& operator=(const quantity< unit< dimension_type, system_type >, YY > & source);
    implicit assignment between value types is allowed if allowed for value types themselves .RE

        3.

        template<typename System2>
          quantity& operator=(const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System2), Y > & source);
        implicit assignment between different unit systems is allowed .RE

  quantity public member functions

    1.

     quantity();

    2.

     quantity(value_type val);
    construction from raw value_type is allowed .RE

        3.

         quantity(const this_type & source);

        4.

        template<typename YY>
           quantity(const quantity< unit< dimension_type, system_type >, YY > & source,
                    unspecified = 0);
        implicit conversion between value types is allowed if allowed for value types themselves .RE

            5.

            template<typename YY>
               quantity(const quantity< unit< dimension_type, system_type >, YY > & source,
                        unspecified = 0);
            implicit conversion between value types is not allowed if not allowed for value types themselves .RE

                6.

                template<typename System2, typename Y2>
                   quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > & source,
                            unspecified = 0, unspecified = 0, unspecified = 0);
                implicit conversion between different unit systems is allowed .RE

                    7.

                    template<typename System2, typename Y2>
                       quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > & source,
                                unspecified = 0, unspecified = 0, unspecified = 0);
                    implicit conversion between different unit systems is allowed .RE

                        8.

                        template<typename System2, typename Y2>
                           quantity(const quantity< unit< dimensionless_type, System2 >, Y2 > & source,
                                    unspecified = 0);

                        conversion between different unit systems is explicit when the units are not equivalent.

                        9.

                        operator value_type() const;
                        implicit conversion to value_type is allowed .RE

                            10.

                            const value_type & value() const;

                            constant accessor to value can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type

                            11.

                            this_type & operator+=(const this_type & source);
                            can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

                                12.

                                this_type & operator-=(const this_type & source);
                                can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

                                    13.

                                    this_type & operator*=(const value_type & val);
                                    can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

                                        14.

                                        this_type & operator/=(const value_type & val);

  quantity public static functions

    1.

    static this_type from_value(const value_type & val);
    Construct quantity directly from value_type. .RE