units.hpp

Go to the documentation of this file.

/// @file       vnix/units.hpp
///
/// @brief      Definition of various units in namespaces
///             vnix::units::flt,
///             vnix::units::dbl, and
///             vnix::units::ldbl.
///
/// @copyright  2019 Thomas E. Vaughan; all rights reserved.
/// @license    BSD three-clause; see LICENSE.

// This file was machine-generated from 'units.hpp.erb'.

#ifndef VNIX_UNITS_HPP
#define VNIX_UNITS_HPP

#include <vnix/units/dimval.hpp>

namespace vnix {
namespace units {


constexpr dim      length_dim(1,0,0,0,0); ///< Exponents for      length.
constexpr dim        mass_dim(0,1,0,0,0); ///< Exponents for        mass.
constexpr dim        time_dim(0,0,1,0,0); ///< Exponents for        time.
constexpr dim      charge_dim(0,0,0,1,0); ///< Exponents for      charge.
constexpr dim temperature_dim(0,0,0,0,1); ///< Exponents for temperature.


/// Template structs that user would use only to extend the library.  Each
/// template struct defined in impl is called by a vnix::units function whose
/// name is the same as the struct.
namespace impl {

/// Template used to construct a number of meters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct meters : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1;

  /// Initialize from number of meters.
  constexpr meters(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf*v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const meters<T>::sf;

/// Template-variable for symbol for meters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr meters<T> m(T(1));

/// Template used to construct a number of centimeters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct centimeters : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.01;

  /// Initialize from number of centimeters.
  constexpr centimeters(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const centimeters<T>::sf;

/// Template-variable for symbol for centimeters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr centimeters<T> cm(T(1));

/// Template used to construct a number of millimeters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct millimeters : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of millimeters.
  constexpr millimeters(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const millimeters<T>::sf;

/// Template-variable for symbol for millimeters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr millimeters<T> mm(T(1));

/// Template used to construct a number of micrometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct micrometers : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of micrometers.
  constexpr micrometers(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const micrometers<T>::sf;

/// Template-variable for symbol for micrometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr micrometers<T> mum(T(1));

/// Template used to construct a number of nanometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct nanometers : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-09;

  /// Initialize from number of nanometers.
  constexpr nanometers(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const nanometers<T>::sf;

/// Template-variable for symbol for nanometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr nanometers<T> nm(T(1));

/// Template used to construct a number of picometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct picometers : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-12;

  /// Initialize from number of picometers.
  constexpr picometers(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const picometers<T>::sf;

/// Template-variable for symbol for picometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr picometers<T> pm(T(1));

/// Template used to construct a number of femtometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct femtometers : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-15;

  /// Initialize from number of femtometers.
  constexpr femtometers(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const femtometers<T>::sf;

/// Template-variable for symbol for femtometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr femtometers<T> fm(T(1));

/// Template used to construct a number of kilometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilometers : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilometers.
  constexpr kilometers(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const kilometers<T>::sf;

/// Template-variable for symbol for kilometers.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilometers<T> km(T(1));

/// Template used to construct a number of megameters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct megameters : public basic_statdim<length_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000.0;

  /// Initialize from number of megameters.
  constexpr megameters(T v) :
    basic_statdim<length_dim.encode(), T>(
      sf * meters<T>::sf * v,
      length_dim)
  {}
};

template <typename T>
constexpr long double const megameters<T>::sf;

/// Template-variable for symbol for megameters.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr megameters<T> Mm(T(1));

/// Template used to construct a number of grams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct grams : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1;

  /// Initialize from number of grams.
  constexpr grams(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf*v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const grams<T>::sf;

/// Template-variable for symbol for grams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr grams<T> g(T(1));

/// Template used to construct a number of milligrams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct milligrams : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of milligrams.
  constexpr milligrams(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const milligrams<T>::sf;

/// Template-variable for symbol for milligrams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr milligrams<T> mg(T(1));

/// Template used to construct a number of micrograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct micrograms : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of micrograms.
  constexpr micrograms(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const micrograms<T>::sf;

/// Template-variable for symbol for micrograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr micrograms<T> mug(T(1));

/// Template used to construct a number of nanograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct nanograms : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-09;

  /// Initialize from number of nanograms.
  constexpr nanograms(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const nanograms<T>::sf;

/// Template-variable for symbol for nanograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr nanograms<T> ng(T(1));

/// Template used to construct a number of picograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct picograms : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-12;

  /// Initialize from number of picograms.
  constexpr picograms(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const picograms<T>::sf;

/// Template-variable for symbol for picograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr picograms<T> pg(T(1));

/// Template used to construct a number of kilograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilograms : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilograms.
  constexpr kilograms(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const kilograms<T>::sf;

/// Template-variable for symbol for kilograms.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilograms<T> kg(T(1));

/// Template used to construct a number of megagrams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct megagrams : public basic_statdim<mass_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000.0;

  /// Initialize from number of megagrams.
  constexpr megagrams(T v) :
    basic_statdim<mass_dim.encode(), T>(
      sf * grams<T>::sf * v,
      mass_dim)
  {}
};

template <typename T>
constexpr long double const megagrams<T>::sf;

/// Template-variable for symbol for megagrams.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr megagrams<T> Mg(T(1));

/// Template used to construct a number of seconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct seconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1;

  /// Initialize from number of seconds.
  constexpr seconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf*v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const seconds<T>::sf;

/// Template-variable for symbol for seconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr seconds<T> s(T(1));

/// Template used to construct a number of milliseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct milliseconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of milliseconds.
  constexpr milliseconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf * seconds<T>::sf * v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const milliseconds<T>::sf;

/// Template-variable for symbol for milliseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr milliseconds<T> ms(T(1));

/// Template used to construct a number of microseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microseconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microseconds.
  constexpr microseconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf * seconds<T>::sf * v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const microseconds<T>::sf;

/// Template-variable for symbol for microseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microseconds<T> mus(T(1));

/// Template used to construct a number of nanoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct nanoseconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-09;

  /// Initialize from number of nanoseconds.
  constexpr nanoseconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf * seconds<T>::sf * v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const nanoseconds<T>::sf;

/// Template-variable for symbol for nanoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr nanoseconds<T> ns(T(1));

/// Template used to construct a number of picoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct picoseconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-12;

  /// Initialize from number of picoseconds.
  constexpr picoseconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf * seconds<T>::sf * v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const picoseconds<T>::sf;

/// Template-variable for symbol for picoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr picoseconds<T> ps(T(1));

/// Template used to construct a number of femtoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct femtoseconds : public basic_statdim<time_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-15;

  /// Initialize from number of femtoseconds.
  constexpr femtoseconds(T v) :
    basic_statdim<time_dim.encode(), T>(
      sf * seconds<T>::sf * v,
      time_dim)
  {}
};

template <typename T>
constexpr long double const femtoseconds<T>::sf;

/// Template-variable for symbol for femtoseconds.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr femtoseconds<T> fs(T(1));

/// Template used to construct a number of coulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct coulombs : public basic_statdim<charge_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1;

  /// Initialize from number of coulombs.
  constexpr coulombs(T v) :
    basic_statdim<charge_dim.encode(), T>(
      sf*v,
      charge_dim)
  {}
};

template <typename T>
constexpr long double const coulombs<T>::sf;

/// Template-variable for symbol for coulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr coulombs<T> C(T(1));

/// Template used to construct a number of millicoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct millicoulombs : public basic_statdim<charge_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of millicoulombs.
  constexpr millicoulombs(T v) :
    basic_statdim<charge_dim.encode(), T>(
      sf * coulombs<T>::sf * v,
      charge_dim)
  {}
};

template <typename T>
constexpr long double const millicoulombs<T>::sf;

/// Template-variable for symbol for millicoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr millicoulombs<T> mC(T(1));

/// Template used to construct a number of microcoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microcoulombs : public basic_statdim<charge_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microcoulombs.
  constexpr microcoulombs(T v) :
    basic_statdim<charge_dim.encode(), T>(
      sf * coulombs<T>::sf * v,
      charge_dim)
  {}
};

template <typename T>
constexpr long double const microcoulombs<T>::sf;

/// Template-variable for symbol for microcoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microcoulombs<T> muC(T(1));

/// Template used to construct a number of nanocoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct nanocoulombs : public basic_statdim<charge_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-09;

  /// Initialize from number of nanocoulombs.
  constexpr nanocoulombs(T v) :
    basic_statdim<charge_dim.encode(), T>(
      sf * coulombs<T>::sf * v,
      charge_dim)
  {}
};

template <typename T>
constexpr long double const nanocoulombs<T>::sf;

/// Template-variable for symbol for nanocoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr nanocoulombs<T> nC(T(1));

/// Template used to construct a number of picocoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct picocoulombs : public basic_statdim<charge_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-12;

  /// Initialize from number of picocoulombs.
  constexpr picocoulombs(T v) :
    basic_statdim<charge_dim.encode(), T>(
      sf * coulombs<T>::sf * v,
      charge_dim)
  {}
};

template <typename T>
constexpr long double const picocoulombs<T>::sf;

/// Template-variable for symbol for picocoulombs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr picocoulombs<T> pC(T(1));

/// Template used to construct a number of kelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kelvins : public basic_statdim<temperature_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1;

  /// Initialize from number of kelvins.
  constexpr kelvins(T v) :
    basic_statdim<temperature_dim.encode(), T>(
      sf*v,
      temperature_dim)
  {}
};

template <typename T>
constexpr long double const kelvins<T>::sf;

/// Template-variable for symbol for kelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kelvins<T> K(T(1));

/// Template used to construct a number of millikelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct millikelvins : public basic_statdim<temperature_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of millikelvins.
  constexpr millikelvins(T v) :
    basic_statdim<temperature_dim.encode(), T>(
      sf * kelvins<T>::sf * v,
      temperature_dim)
  {}
};

template <typename T>
constexpr long double const millikelvins<T>::sf;

/// Template-variable for symbol for millikelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr millikelvins<T> mK(T(1));

/// Template used to construct a number of microkelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microkelvins : public basic_statdim<temperature_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microkelvins.
  constexpr microkelvins(T v) :
    basic_statdim<temperature_dim.encode(), T>(
      sf * kelvins<T>::sf * v,
      temperature_dim)
  {}
};

template <typename T>
constexpr long double const microkelvins<T>::sf;

/// Template-variable for symbol for microkelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microkelvins<T> muK(T(1));

/// Template used to construct a number of nanokelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct nanokelvins : public basic_statdim<temperature_dim.encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-09;

  /// Initialize from number of nanokelvins.
  constexpr nanokelvins(T v) :
    basic_statdim<temperature_dim.encode(), T>(
      sf * kelvins<T>::sf * v,
      temperature_dim)
  {}
};

template <typename T>
constexpr long double const nanokelvins<T>::sf;

/// Template-variable for symbol for nanokelvins.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr nanokelvins<T> nK(T(1));

/// Template used to construct a number of feet.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct feet : public basic_statdim<(m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.3048*m<long double>.sf;

  /// Initialize from number of feet.
  constexpr feet(T v) :
    basic_statdim<(m<float>.d()).encode(), T>(
      sf*v,
      m<float>.d())
  {}
};

template <typename T>
constexpr long double const feet<T>::sf;

/// Template-variable for symbol for feet.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr feet<T> ft(T(1));

/// Template used to construct a number of kilofeet.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilofeet : public basic_statdim<(m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilofeet.
  constexpr kilofeet(T v) :
    basic_statdim<(m<float>.d()).encode(), T>(
      sf * feet<T>::sf * v,
      m<float>.d())
  {}
};

template <typename T>
constexpr long double const kilofeet<T>::sf;

/// Template-variable for symbol for kilofeet.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilofeet<T> kft(T(1));

/// Template used to construct a number of inches.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct inches : public basic_statdim<(ft<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = ft<long double>.sf/12;

  /// Initialize from number of inches.
  constexpr inches(T v) :
    basic_statdim<(ft<float>.d()).encode(), T>(
      sf*v,
      ft<float>.d())
  {}
};

template <typename T>
constexpr long double const inches<T>::sf;

/// Template-variable for symbol for inches.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr inches<T> in(T(1));

/// Template used to construct a number of yards.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct yards : public basic_statdim<(ft<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 3*ft<long double>.sf;

  /// Initialize from number of yards.
  constexpr yards(T v) :
    basic_statdim<(ft<float>.d()).encode(), T>(
      sf*v,
      ft<float>.d())
  {}
};

template <typename T>
constexpr long double const yards<T>::sf;

/// Template-variable for symbol for yards.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr yards<T> yd(T(1));

/// Template used to construct a number of miles.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct miles : public basic_statdim<(ft<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 5280*ft<long double>.sf;

  /// Initialize from number of miles.
  constexpr miles(T v) :
    basic_statdim<(ft<float>.d()).encode(), T>(
      sf*v,
      ft<float>.d())
  {}
};

template <typename T>
constexpr long double const miles<T>::sf;

/// Template-variable for symbol for miles.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr miles<T> mi(T(1));

/// Template used to construct a number of newtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct newtons : public basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = kg<long double>.sf*m<long double>.sf/s<long double>.sf/s<long double>.sf;

  /// Initialize from number of newtons.
  constexpr newtons(T v) :
    basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf*v,
      kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const newtons<T>::sf;

/// Template-variable for symbol for newtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr newtons<T> N(T(1));

/// Template used to construct a number of millinewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct millinewtons : public basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of millinewtons.
  constexpr millinewtons(T v) :
    basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf * newtons<T>::sf * v,
      kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const millinewtons<T>::sf;

/// Template-variable for symbol for millinewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr millinewtons<T> mN(T(1));

/// Template used to construct a number of micronewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct micronewtons : public basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of micronewtons.
  constexpr micronewtons(T v) :
    basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf * newtons<T>::sf * v,
      kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const micronewtons<T>::sf;

/// Template-variable for symbol for micronewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr micronewtons<T> muN(T(1));

/// Template used to construct a number of kilonewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilonewtons : public basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilonewtons.
  constexpr kilonewtons(T v) :
    basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf * newtons<T>::sf * v,
      kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const kilonewtons<T>::sf;

/// Template-variable for symbol for kilonewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilonewtons<T> kN(T(1));

/// Template used to construct a number of meganewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct meganewtons : public basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000.0;

  /// Initialize from number of meganewtons.
  constexpr meganewtons(T v) :
    basic_statdim<(kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf * newtons<T>::sf * v,
      kg<float>.d()+m<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const meganewtons<T>::sf;

/// Template-variable for symbol for meganewtons.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr meganewtons<T> MN(T(1));

/// Template used to construct a number of dynes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct dynes : public basic_statdim<(g<float>.d()+cm<float>.d()-s<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = g<long double>.sf*cm<long double>.sf/s<long double>.sf/s<long double>.sf;

  /// Initialize from number of dynes.
  constexpr dynes(T v) :
    basic_statdim<(g<float>.d()+cm<float>.d()-s<float>.d()-s<float>.d()).encode(), T>(
      sf*v,
      g<float>.d()+cm<float>.d()-s<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const dynes<T>::sf;

/// Template-variable for symbol for dynes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr dynes<T> dyn(T(1));

/// Template used to construct a number of joules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct joules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = N<long double>.sf*m<long double>.sf;

  /// Initialize from number of joules.
  constexpr joules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf*v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const joules<T>::sf;

/// Template-variable for symbol for joules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr joules<T> J(T(1));

/// Template used to construct a number of millijoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct millijoules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of millijoules.
  constexpr millijoules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf * joules<T>::sf * v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const millijoules<T>::sf;

/// Template-variable for symbol for millijoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr millijoules<T> mJ(T(1));

/// Template used to construct a number of microjoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microjoules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microjoules.
  constexpr microjoules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf * joules<T>::sf * v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const microjoules<T>::sf;

/// Template-variable for symbol for microjoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microjoules<T> muJ(T(1));

/// Template used to construct a number of kilojoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilojoules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilojoules.
  constexpr kilojoules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf * joules<T>::sf * v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const kilojoules<T>::sf;

/// Template-variable for symbol for kilojoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilojoules<T> kJ(T(1));

/// Template used to construct a number of megajoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct megajoules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000.0;

  /// Initialize from number of megajoules.
  constexpr megajoules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf * joules<T>::sf * v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const megajoules<T>::sf;

/// Template-variable for symbol for megajoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr megajoules<T> MJ(T(1));

/// Template used to construct a number of gigajoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct gigajoules : public basic_statdim<(N<float>.d()+m<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000000.0;

  /// Initialize from number of gigajoules.
  constexpr gigajoules(T v) :
    basic_statdim<(N<float>.d()+m<float>.d()).encode(), T>(
      sf * joules<T>::sf * v,
      N<float>.d()+m<float>.d())
  {}
};

template <typename T>
constexpr long double const gigajoules<T>::sf;

/// Template-variable for symbol for gigajoules.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr gigajoules<T> GJ(T(1));

/// Template used to construct a number of ergs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct ergs : public basic_statdim<(dyn<float>.d()+cm<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = dyn<long double>.sf*cm<long double>.sf;

  /// Initialize from number of ergs.
  constexpr ergs(T v) :
    basic_statdim<(dyn<float>.d()+cm<float>.d()).encode(), T>(
      sf*v,
      dyn<float>.d()+cm<float>.d())
  {}
};

template <typename T>
constexpr long double const ergs<T>::sf;

/// Template-variable for symbol for ergs.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr ergs<T> erg(T(1));

/// Template used to construct a number of watts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct watts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = J<long double>.sf/s<long double>.sf;

  /// Initialize from number of watts.
  constexpr watts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf*v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const watts<T>::sf;

/// Template-variable for symbol for watts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr watts<T> W(T(1));

/// Template used to construct a number of milliwatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct milliwatts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of milliwatts.
  constexpr milliwatts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf * watts<T>::sf * v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const milliwatts<T>::sf;

/// Template-variable for symbol for milliwatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr milliwatts<T> mW(T(1));

/// Template used to construct a number of microwatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microwatts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microwatts.
  constexpr microwatts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf * watts<T>::sf * v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const microwatts<T>::sf;

/// Template-variable for symbol for microwatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microwatts<T> muW(T(1));

/// Template used to construct a number of kilowatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct kilowatts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000.0;

  /// Initialize from number of kilowatts.
  constexpr kilowatts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf * watts<T>::sf * v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const kilowatts<T>::sf;

/// Template-variable for symbol for kilowatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr kilowatts<T> kW(T(1));

/// Template used to construct a number of megawatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct megawatts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000.0;

  /// Initialize from number of megawatts.
  constexpr megawatts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf * watts<T>::sf * v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const megawatts<T>::sf;

/// Template-variable for symbol for megawatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr megawatts<T> MW(T(1));

/// Template used to construct a number of gigawatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct gigawatts : public basic_statdim<(J<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1000000000.0;

  /// Initialize from number of gigawatts.
  constexpr gigawatts(T v) :
    basic_statdim<(J<float>.d()-s<float>.d()).encode(), T>(
      sf * watts<T>::sf * v,
      J<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const gigawatts<T>::sf;

/// Template-variable for symbol for gigawatts.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr gigawatts<T> GW(T(1));

/// Template used to construct a number of amperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct amperes : public basic_statdim<(C<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = C<long double>.sf/s<long double>.sf;

  /// Initialize from number of amperes.
  constexpr amperes(T v) :
    basic_statdim<(C<float>.d()-s<float>.d()).encode(), T>(
      sf*v,
      C<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const amperes<T>::sf;

/// Template-variable for symbol for amperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr amperes<T> A(T(1));

/// Template used to construct a number of milliamperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct milliamperes : public basic_statdim<(C<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 0.001;

  /// Initialize from number of milliamperes.
  constexpr milliamperes(T v) :
    basic_statdim<(C<float>.d()-s<float>.d()).encode(), T>(
      sf * amperes<T>::sf * v,
      C<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const milliamperes<T>::sf;

/// Template-variable for symbol for milliamperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr milliamperes<T> mA(T(1));

/// Template used to construct a number of microamperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T>
struct microamperes : public basic_statdim<(C<float>.d()-s<float>.d()).encode(), T> {
  /// Scale factor.
  constexpr static long double const sf = 1.0e-06;

  /// Initialize from number of microamperes.
  constexpr microamperes(T v) :
    basic_statdim<(C<float>.d()-s<float>.d()).encode(), T>(
      sf * amperes<T>::sf * v,
      C<float>.d()-s<float>.d())
  {}
};

template <typename T>
constexpr long double const microamperes<T>::sf;

/// Template-variable for symbol for microamperes.
/// @tparam T  Numeric type (float, double, etc.).
template <typename T> constexpr microamperes<T> muA(T(1));

} // namespace impl


/// Produce dimensioned quantity from number of meters.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of meters
template <typename T>
constexpr auto meters(T v) { return impl::meters<T>(v); }

/// Produce dimensioned quantity from number of centimeters.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of centimeters
template <typename T>
constexpr auto centimeters(T v) { return impl::centimeters<T>(v); };

/// Produce dimensioned quantity from number of millimeters.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of millimeters
template <typename T>
constexpr auto millimeters(T v) { return impl::millimeters<T>(v); };

/// Produce dimensioned quantity from number of micrometers.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of micrometers
template <typename T>
constexpr auto micrometers(T v) { return impl::micrometers<T>(v); };

/// Produce dimensioned quantity from number of nanometers.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of nanometers
template <typename T>
constexpr auto nanometers(T v) { return impl::nanometers<T>(v); };

/// Produce dimensioned quantity from number of picometers.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of picometers
template <typename T>
constexpr auto picometers(T v) { return impl::picometers<T>(v); };

/// Produce dimensioned quantity from number of femtometers.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of femtometers
template <typename T>
constexpr auto femtometers(T v) { return impl::femtometers<T>(v); };

/// Produce dimensioned quantity from number of kilometers.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilometers
template <typename T>
constexpr auto kilometers(T v) { return impl::kilometers<T>(v); };

/// Produce dimensioned quantity from number of megameters.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of megameters
template <typename T>
constexpr auto megameters(T v) { return impl::megameters<T>(v); };

/// Produce dimensioned quantity from number of grams.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of grams
template <typename T>
constexpr auto grams(T v) { return impl::grams<T>(v); }

/// Produce dimensioned quantity from number of milligrams.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of milligrams
template <typename T>
constexpr auto milligrams(T v) { return impl::milligrams<T>(v); };

/// Produce dimensioned quantity from number of micrograms.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of micrograms
template <typename T>
constexpr auto micrograms(T v) { return impl::micrograms<T>(v); };

/// Produce dimensioned quantity from number of nanograms.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of nanograms
template <typename T>
constexpr auto nanograms(T v) { return impl::nanograms<T>(v); };

/// Produce dimensioned quantity from number of picograms.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of picograms
template <typename T>
constexpr auto picograms(T v) { return impl::picograms<T>(v); };

/// Produce dimensioned quantity from number of kilograms.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilograms
template <typename T>
constexpr auto kilograms(T v) { return impl::kilograms<T>(v); };

/// Produce dimensioned quantity from number of megagrams.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of megagrams
template <typename T>
constexpr auto megagrams(T v) { return impl::megagrams<T>(v); };

/// Produce dimensioned quantity from number of seconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of seconds
template <typename T>
constexpr auto seconds(T v) { return impl::seconds<T>(v); }

/// Produce dimensioned quantity from number of milliseconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of milliseconds
template <typename T>
constexpr auto milliseconds(T v) { return impl::milliseconds<T>(v); };

/// Produce dimensioned quantity from number of microseconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microseconds
template <typename T>
constexpr auto microseconds(T v) { return impl::microseconds<T>(v); };

/// Produce dimensioned quantity from number of nanoseconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of nanoseconds
template <typename T>
constexpr auto nanoseconds(T v) { return impl::nanoseconds<T>(v); };

/// Produce dimensioned quantity from number of picoseconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of picoseconds
template <typename T>
constexpr auto picoseconds(T v) { return impl::picoseconds<T>(v); };

/// Produce dimensioned quantity from number of femtoseconds.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of femtoseconds
template <typename T>
constexpr auto femtoseconds(T v) { return impl::femtoseconds<T>(v); };

/// Produce dimensioned quantity from number of coulombs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of coulombs
template <typename T>
constexpr auto coulombs(T v) { return impl::coulombs<T>(v); }

/// Produce dimensioned quantity from number of millicoulombs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of millicoulombs
template <typename T>
constexpr auto millicoulombs(T v) { return impl::millicoulombs<T>(v); };

/// Produce dimensioned quantity from number of microcoulombs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microcoulombs
template <typename T>
constexpr auto microcoulombs(T v) { return impl::microcoulombs<T>(v); };

/// Produce dimensioned quantity from number of nanocoulombs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of nanocoulombs
template <typename T>
constexpr auto nanocoulombs(T v) { return impl::nanocoulombs<T>(v); };

/// Produce dimensioned quantity from number of picocoulombs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of picocoulombs
template <typename T>
constexpr auto picocoulombs(T v) { return impl::picocoulombs<T>(v); };

/// Produce dimensioned quantity from number of kelvins.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kelvins
template <typename T>
constexpr auto kelvins(T v) { return impl::kelvins<T>(v); }

/// Produce dimensioned quantity from number of millikelvins.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of millikelvins
template <typename T>
constexpr auto millikelvins(T v) { return impl::millikelvins<T>(v); };

/// Produce dimensioned quantity from number of microkelvins.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microkelvins
template <typename T>
constexpr auto microkelvins(T v) { return impl::microkelvins<T>(v); };

/// Produce dimensioned quantity from number of nanokelvins.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of nanokelvins
template <typename T>
constexpr auto nanokelvins(T v) { return impl::nanokelvins<T>(v); };

/// Produce dimensioned quantity from number of feet.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of feet.
template <typename T>
constexpr auto feet(T v) { return impl::feet<T>(v); }

/// Produce dimensioned quantity from number of kilofeet.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilofeet.
template <typename T>
constexpr auto kilofeet(T v) { return impl::kilofeet<T>(v); }

/// Produce dimensioned quantity from number of inches.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of inches.
template <typename T>
constexpr auto inches(T v) { return impl::inches<T>(v); }

/// Produce dimensioned quantity from number of yards.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of yards.
template <typename T>
constexpr auto yards(T v) { return impl::yards<T>(v); }

/// Produce dimensioned quantity from number of miles.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of miles.
template <typename T>
constexpr auto miles(T v) { return impl::miles<T>(v); }

/// Produce dimensioned quantity from number of newtons.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of newtons.
template <typename T>
constexpr auto newtons(T v) { return impl::newtons<T>(v); }

/// Produce dimensioned quantity from number of millinewtons.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of millinewtons.
template <typename T>
constexpr auto millinewtons(T v) { return impl::millinewtons<T>(v); }

/// Produce dimensioned quantity from number of micronewtons.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of micronewtons.
template <typename T>
constexpr auto micronewtons(T v) { return impl::micronewtons<T>(v); }

/// Produce dimensioned quantity from number of kilonewtons.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilonewtons.
template <typename T>
constexpr auto kilonewtons(T v) { return impl::kilonewtons<T>(v); }

/// Produce dimensioned quantity from number of meganewtons.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of meganewtons.
template <typename T>
constexpr auto meganewtons(T v) { return impl::meganewtons<T>(v); }

/// Produce dimensioned quantity from number of dynes.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of dynes.
template <typename T>
constexpr auto dynes(T v) { return impl::dynes<T>(v); }

/// Produce dimensioned quantity from number of joules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of joules.
template <typename T>
constexpr auto joules(T v) { return impl::joules<T>(v); }

/// Produce dimensioned quantity from number of millijoules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of millijoules.
template <typename T>
constexpr auto millijoules(T v) { return impl::millijoules<T>(v); }

/// Produce dimensioned quantity from number of microjoules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microjoules.
template <typename T>
constexpr auto microjoules(T v) { return impl::microjoules<T>(v); }

/// Produce dimensioned quantity from number of kilojoules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilojoules.
template <typename T>
constexpr auto kilojoules(T v) { return impl::kilojoules<T>(v); }

/// Produce dimensioned quantity from number of megajoules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of megajoules.
template <typename T>
constexpr auto megajoules(T v) { return impl::megajoules<T>(v); }

/// Produce dimensioned quantity from number of gigajoules.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of gigajoules.
template <typename T>
constexpr auto gigajoules(T v) { return impl::gigajoules<T>(v); }

/// Produce dimensioned quantity from number of ergs.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of ergs.
template <typename T>
constexpr auto ergs(T v) { return impl::ergs<T>(v); }

/// Produce dimensioned quantity from number of watts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of watts.
template <typename T>
constexpr auto watts(T v) { return impl::watts<T>(v); }

/// Produce dimensioned quantity from number of milliwatts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of milliwatts.
template <typename T>
constexpr auto milliwatts(T v) { return impl::milliwatts<T>(v); }

/// Produce dimensioned quantity from number of microwatts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microwatts.
template <typename T>
constexpr auto microwatts(T v) { return impl::microwatts<T>(v); }

/// Produce dimensioned quantity from number of kilowatts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of kilowatts.
template <typename T>
constexpr auto kilowatts(T v) { return impl::kilowatts<T>(v); }

/// Produce dimensioned quantity from number of megawatts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of megawatts.
template <typename T>
constexpr auto megawatts(T v) { return impl::megawatts<T>(v); }

/// Produce dimensioned quantity from number of gigawatts.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of gigawatts.
template <typename T>
constexpr auto gigawatts(T v) { return impl::gigawatts<T>(v); }

/// Produce dimensioned quantity from number of amperes.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of amperes.
template <typename T>
constexpr auto amperes(T v) { return impl::amperes<T>(v); }

/// Produce dimensioned quantity from number of milliamperes.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of milliamperes.
template <typename T>
constexpr auto milliamperes(T v) { return impl::milliamperes<T>(v); }

/// Produce dimensioned quantity from number of microamperes.
/// @tparam T  Numeric type stored in dimensioned quantity.
/// @param  v  Number of microamperes.
template <typename T>
constexpr auto microamperes(T v) { return impl::microamperes<T>(v); }


/// Single-precision dimensions and units.
namespace flt {

/// Type of dimensioned value whose dimension is not known at compile-time.
using dyndim = basic_dyndim<float>;

/// Interpret a number, suffixed with '_m',
/// as a (literal) number of meters.
constexpr auto operator"" _m(long double v) {
  return meters(float(v));
}

/// Constant-expression symbol for m.
constexpr auto m = impl::m<float>;

/// Type for variable of dimension length.
using length = basic_statdim<length_dim.encode(), float>;

/// Interpret a number, suffixed with '_cm',
/// as a (literal) number of centimeters.
constexpr auto operator"" _cm(long double v) {
  return centimeters(float(v));
}

/// Constant-expression symbol for cm.
constexpr auto cm = impl::cm<float>;

/// Interpret a number, suffixed with '_mm',
/// as a (literal) number of millimeters.
constexpr auto operator"" _mm(long double v) {
  return millimeters(float(v));
}

/// Constant-expression symbol for mm.
constexpr auto mm = impl::mm<float>;

/// Interpret a number, suffixed with '_mum',
/// as a (literal) number of micrometers.
constexpr auto operator"" _mum(long double v) {
  return micrometers(float(v));
}

/// Constant-expression symbol for mum.
constexpr auto mum = impl::mum<float>;

/// Interpret a number, suffixed with '_nm',
/// as a (literal) number of nanometers.
constexpr auto operator"" _nm(long double v) {
  return nanometers(float(v));
}

/// Constant-expression symbol for nm.
constexpr auto nm = impl::nm<float>;

/// Interpret a number, suffixed with '_pm',
/// as a (literal) number of picometers.
constexpr auto operator"" _pm(long double v) {
  return picometers(float(v));
}

/// Constant-expression symbol for pm.
constexpr auto pm = impl::pm<float>;

/// Interpret a number, suffixed with '_fm',
/// as a (literal) number of femtometers.
constexpr auto operator"" _fm(long double v) {
  return femtometers(float(v));
}

/// Constant-expression symbol for fm.
constexpr auto fm = impl::fm<float>;

/// Interpret a number, suffixed with '_km',
/// as a (literal) number of kilometers.
constexpr auto operator"" _km(long double v) {
  return kilometers(float(v));
}

/// Constant-expression symbol for km.
constexpr auto km = impl::km<float>;

/// Interpret a number, suffixed with '_Mm',
/// as a (literal) number of megameters.
constexpr auto operator"" _Mm(long double v) {
  return megameters(float(v));
}

/// Constant-expression symbol for Mm.
constexpr auto Mm = impl::Mm<float>;

/// Interpret a number, suffixed with '_g',
/// as a (literal) number of grams.
constexpr auto operator"" _g(long double v) {
  return grams(float(v));
}

/// Constant-expression symbol for g.
constexpr auto g = impl::g<float>;

/// Type for variable of dimension mass.
using mass = basic_statdim<mass_dim.encode(), float>;

/// Interpret a number, suffixed with '_mg',
/// as a (literal) number of milligrams.
constexpr auto operator"" _mg(long double v) {
  return milligrams(float(v));
}

/// Constant-expression symbol for mg.
constexpr auto mg = impl::mg<float>;

/// Interpret a number, suffixed with '_mug',
/// as a (literal) number of micrograms.
constexpr auto operator"" _mug(long double v) {
  return micrograms(float(v));
}

/// Constant-expression symbol for mug.
constexpr auto mug = impl::mug<float>;

/// Interpret a number, suffixed with '_ng',
/// as a (literal) number of nanograms.
constexpr auto operator"" _ng(long double v) {
  return nanograms(float(v));
}

/// Constant-expression symbol for ng.
constexpr auto ng = impl::ng<float>;

/// Interpret a number, suffixed with '_pg',
/// as a (literal) number of picograms.
constexpr auto operator"" _pg(long double v) {
  return picograms(float(v));
}

/// Constant-expression symbol for pg.
constexpr auto pg = impl::pg<float>;

/// Interpret a number, suffixed with '_kg',
/// as a (literal) number of kilograms.
constexpr auto operator"" _kg(long double v) {
  return kilograms(float(v));
}

/// Constant-expression symbol for kg.
constexpr auto kg = impl::kg<float>;

/// Interpret a number, suffixed with '_Mg',
/// as a (literal) number of megagrams.
constexpr auto operator"" _Mg(long double v) {
  return megagrams(float(v));
}

/// Constant-expression symbol for Mg.
constexpr auto Mg = impl::Mg<float>;

/// Interpret a number, suffixed with '_s',
/// as a (literal) number of seconds.
constexpr auto operator"" _s(long double v) {
  return seconds(float(v));
}

/// Constant-expression symbol for s.
constexpr auto s = impl::s<float>;

/// Type for variable of dimension time.
using time = basic_statdim<time_dim.encode(), float>;

/// Interpret a number, suffixed with '_ms',
/// as a (literal) number of milliseconds.
constexpr auto operator"" _ms(long double v) {
  return milliseconds(float(v));
}

/// Constant-expression symbol for ms.
constexpr auto ms = impl::ms<float>;

/// Interpret a number, suffixed with '_mus',
/// as a (literal) number of microseconds.
constexpr auto operator"" _mus(long double v) {
  return microseconds(float(v));
}

/// Constant-expression symbol for mus.
constexpr auto mus = impl::mus<float>;

/// Interpret a number, suffixed with '_ns',
/// as a (literal) number of nanoseconds.
constexpr auto operator"" _ns(long double v) {
  return nanoseconds(float(v));
}

/// Constant-expression symbol for ns.
constexpr auto ns = impl::ns<float>;

/// Interpret a number, suffixed with '_ps',
/// as a (literal) number of picoseconds.
constexpr auto operator"" _ps(long double v) {
  return picoseconds(float(v));
}

/// Constant-expression symbol for ps.
constexpr auto ps = impl::ps<float>;

/// Interpret a number, suffixed with '_fs',
/// as a (literal) number of femtoseconds.
constexpr auto operator"" _fs(long double v) {
  return femtoseconds(float(v));
}

/// Constant-expression symbol for fs.
constexpr auto fs = impl::fs<float>;

/// Interpret a number, suffixed with '_C',
/// as a (literal) number of coulombs.
constexpr auto operator"" _C(long double v) {
  return coulombs(float(v));
}

/// Constant-expression symbol for C.
constexpr auto C = impl::C<float>;

/// Type for variable of dimension charge.
using charge = basic_statdim<charge_dim.encode(), float>;

/// Interpret a number, suffixed with '_mC',
/// as a (literal) number of millicoulombs.
constexpr auto operator"" _mC(long double v) {
  return millicoulombs(float(v));
}

/// Constant-expression symbol for mC.
constexpr auto mC = impl::mC<float>;

/// Interpret a number, suffixed with '_muC',
/// as a (literal) number of microcoulombs.
constexpr auto operator"" _muC(long double v) {
  return microcoulombs(float(v));
}

/// Constant-expression symbol for muC.
constexpr auto muC = impl::muC<float>;

/// Interpret a number, suffixed with '_nC',
/// as a (literal) number of nanocoulombs.
constexpr auto operator"" _nC(long double v) {
  return nanocoulombs(float(v));
}

/// Constant-expression symbol for nC.
constexpr auto nC = impl::nC<float>;

/// Interpret a number, suffixed with '_pC',
/// as a (literal) number of picocoulombs.
constexpr auto operator"" _pC(long double v) {
  return picocoulombs(float(v));
}

/// Constant-expression symbol for pC.
constexpr auto pC = impl::pC<float>;

/// Interpret a number, suffixed with '_K',
/// as a (literal) number of kelvins.
constexpr auto operator"" _K(long double v) {
  return kelvins(float(v));
}

/// Constant-expression symbol for K.
constexpr auto K = impl::K<float>;

/// Type for variable of dimension temperature.
using temperature = basic_statdim<temperature_dim.encode(), float>;

/// Interpret a number, suffixed with '_mK',
/// as a (literal) number of millikelvins.
constexpr auto operator"" _mK(long double v) {
  return millikelvins(float(v));
}

/// Constant-expression symbol for mK.
constexpr auto mK = impl::mK<float>;

/// Interpret a number, suffixed with '_muK',
/// as a (literal) number of microkelvins.
constexpr auto operator"" _muK(long double v) {
  return microkelvins(float(v));
}

/// Constant-expression symbol for muK.
constexpr auto muK = impl::muK<float>;

/// Interpret a number, suffixed with '_nK',
/// as a (literal) number of nanokelvins.
constexpr auto operator"" _nK(long double v) {
  return nanokelvins(float(v));
}

/// Constant-expression symbol for nK.
constexpr auto nK = impl::nK<float>;

/// Constant-expression symbol for ft.
constexpr auto ft = impl::ft<float>;

/// Interpret a number, suffixed with '_ft',
/// as a (literal) number of feet.
constexpr auto operator"" _ft(long double v) {
  return float(v)*ft;
}

/// Constant-expression symbol for kft.
constexpr auto kft = impl::kft<float>;

/// Interpret a number, suffixed with '_kft',
/// as a (literal) number of kilofeet.
constexpr auto operator"" _kft(long double v) {
  return float(v)*kft;
}

/// Constant-expression symbol for in.
constexpr auto in = impl::in<float>;

/// Interpret a number, suffixed with '_in',
/// as a (literal) number of inches.
constexpr auto operator"" _in(long double v) {
  return float(v)*in;
}

/// Constant-expression symbol for yd.
constexpr auto yd = impl::yd<float>;

/// Interpret a number, suffixed with '_yd',
/// as a (literal) number of yards.
constexpr auto operator"" _yd(long double v) {
  return float(v)*yd;
}

/// Constant-expression symbol for mi.
constexpr auto mi = impl::mi<float>;

/// Interpret a number, suffixed with '_mi',
/// as a (literal) number of miles.
constexpr auto operator"" _mi(long double v) {
  return float(v)*mi;
}

/// Constant-expression symbol for N.
constexpr auto N = impl::N<float>;

/// Interpret a number, suffixed with '_N',
/// as a (literal) number of newtons.
constexpr auto operator"" _N(long double v) {
  return float(v)*N;
}

/// Constant-expression symbol for mN.
constexpr auto mN = impl::mN<float>;

/// Interpret a number, suffixed with '_mN',
/// as a (literal) number of millinewtons.
constexpr auto operator"" _mN(long double v) {
  return float(v)*mN;
}

/// Constant-expression symbol for muN.
constexpr auto muN = impl::muN<float>;

/// Interpret a number, suffixed with '_muN',
/// as a (literal) number of micronewtons.
constexpr auto operator"" _muN(long double v) {
  return float(v)*muN;
}

/// Constant-expression symbol for kN.
constexpr auto kN = impl::kN<float>;

/// Interpret a number, suffixed with '_kN',
/// as a (literal) number of kilonewtons.
constexpr auto operator"" _kN(long double v) {
  return float(v)*kN;
}

/// Constant-expression symbol for MN.
constexpr auto MN = impl::MN<float>;

/// Interpret a number, suffixed with '_MN',
/// as a (literal) number of meganewtons.
constexpr auto operator"" _MN(long double v) {
  return float(v)*MN;
}

/// Constant-expression symbol for dyn.
constexpr auto dyn = impl::dyn<float>;

/// Interpret a number, suffixed with '_dyn',
/// as a (literal) number of dynes.
constexpr auto operator"" _dyn(long double v) {
  return float(v)*dyn;
}

/// Constant-expression symbol for J.
constexpr auto J = impl::J<float>;

/// Interpret a number, suffixed with '_J',
/// as a (literal) number of joules.
constexpr auto operator"" _J(long double v) {
  return float(v)*J;
}

/// Constant-expression symbol for mJ.
constexpr auto mJ = impl::mJ<float>;

/// Interpret a number, suffixed with '_mJ',
/// as a (literal) number of millijoules.
constexpr auto operator"" _mJ(long double v) {
  return float(v)*mJ;
}

/// Constant-expression symbol for muJ.
constexpr auto muJ = impl::muJ<float>;

/// Interpret a number, suffixed with '_muJ',
/// as a (literal) number of microjoules.
constexpr auto operator"" _muJ(long double v) {
  return float(v)*muJ;
}

/// Constant-expression symbol for kJ.
constexpr auto kJ = impl::kJ<float>;

/// Interpret a number, suffixed with '_kJ',
/// as a (literal) number of kilojoules.
constexpr auto operator"" _kJ(long double v) {
  return float(v)*kJ;
}

/// Constant-expression symbol for MJ.
constexpr auto MJ = impl::MJ<float>;

/// Interpret a number, suffixed with '_MJ',
/// as a (literal) number of megajoules.
constexpr auto operator"" _MJ(long double v) {
  return float(v)*MJ;
}

/// Constant-expression symbol for GJ.
constexpr auto GJ = impl::GJ<float>;

/// Interpret a number, suffixed with '_GJ',
/// as a (literal) number of gigajoules.
constexpr auto operator"" _GJ(long double v) {
  return float(v)*GJ;
}

/// Constant-expression symbol for erg.
constexpr auto erg = impl::erg<float>;

/// Interpret a number, suffixed with '_erg',
/// as a (literal) number of ergs.
constexpr auto operator"" _erg(long double v) {
  return float(v)*erg;
}

/// Constant-expression symbol for W.
constexpr auto W = impl::W<float>;

/// Interpret a number, suffixed with '_W',
/// as a (literal) number of watts.
constexpr auto operator"" _W(long double v) {
  return float(v)*W;
}

/// Constant-expression symbol for mW.
constexpr auto mW = impl::mW<float>;

/// Interpret a number, suffixed with '_mW',
/// as a (literal) number of milliwatts.
constexpr auto operator"" _mW(long double v) {
  return float(v)*mW;
}

/// Constant-expression symbol for muW.
constexpr auto muW = impl::muW<float>;

/// Interpret a number, suffixed with '_muW',
/// as a (literal) number of microwatts.
constexpr auto operator"" _muW(long double v) {
  return float(v)*muW;
}

/// Constant-expression symbol for kW.
constexpr auto kW = impl::kW<float>;

/// Interpret a number, suffixed with '_kW',
/// as a (literal) number of kilowatts.
constexpr auto operator"" _kW(long double v) {
  return float(v)*kW;
}

/// Constant-expression symbol for MW.
constexpr auto MW = impl::MW<float>;

/// Interpret a number, suffixed with '_MW',
/// as a (literal) number of megawatts.
constexpr auto operator"" _MW(long double v) {
  return float(v)*MW;
}

/// Constant-expression symbol for GW.
constexpr auto GW = impl::GW<float>;

/// Interpret a number, suffixed with '_GW',
/// as a (literal) number of gigawatts.
constexpr auto operator"" _GW(long double v) {
  return float(v)*GW;
}

/// Constant-expression symbol for A.
constexpr auto A = impl::A<float>;

/// Interpret a number, suffixed with '_A',
/// as a (literal) number of amperes.
constexpr auto operator"" _A(long double v) {
  return float(v)*A;
}

/// Constant-expression symbol for mA.
constexpr auto mA = impl::mA<float>;

/// Interpret a number, suffixed with '_mA',
/// as a (literal) number of milliamperes.
constexpr auto operator"" _mA(long double v) {
  return float(v)*mA;
}

/// Constant-expression symbol for muA.
constexpr auto muA = impl::muA<float>;

/// Interpret a number, suffixed with '_muA',
/// as a (literal) number of microamperes.
constexpr auto operator"" _muA(long double v) {
  return float(v)*muA;
}

using speed        = decltype(m/s);
using acceleration = decltype(m/s/s);
using momentum     = decltype(g*m/s);
using force        = decltype(N/1);
using current      = decltype(C/s);
using energy       = decltype(J/1);
using power        = decltype(W/1);
using area         = decltype(m*m);
using volume       = decltype(m*m*m);
using pressure     = decltype(N/m/m);

} // namespace flt


/// Double-precision dimensions and units.
namespace dbl {

/// Type of dimensioned value whose dimension is not known at compile-time.
using dyndim = basic_dyndim<double>;

/// Interpret a number, suffixed with '_m',
/// as a (literal) number of meters.
constexpr auto operator"" _m(long double v) {
  return meters(double(v));
}

/// Constant-expression symbol for m.
constexpr auto m = impl::m<double>;

/// Type for variable of dimension length.
using length = basic_statdim<length_dim.encode(), double>;

/// Interpret a number, suffixed with '_cm',
/// as a (literal) number of centimeters.
constexpr auto operator"" _cm(long double v) {
  return centimeters(double(v));
}

/// Constant-expression symbol for cm.
constexpr auto cm = impl::cm<double>;

/// Interpret a number, suffixed with '_mm',
/// as a (literal) number of millimeters.
constexpr auto operator"" _mm(long double v) {
  return millimeters(double(v));
}

/// Constant-expression symbol for mm.
constexpr auto mm = impl::mm<double>;

/// Interpret a number, suffixed with '_mum',
/// as a (literal) number of micrometers.
constexpr auto operator"" _mum(long double v) {
  return micrometers(double(v));
}

/// Constant-expression symbol for mum.
constexpr auto mum = impl::mum<double>;

/// Interpret a number, suffixed with '_nm',
/// as a (literal) number of nanometers.
constexpr auto operator"" _nm(long double v) {
  return nanometers(double(v));
}

/// Constant-expression symbol for nm.
constexpr auto nm = impl::nm<double>;

/// Interpret a number, suffixed with '_pm',
/// as a (literal) number of picometers.
constexpr auto operator"" _pm(long double v) {
  return picometers(double(v));
}

/// Constant-expression symbol for pm.
constexpr auto pm = impl::pm<double>;

/// Interpret a number, suffixed with '_fm',
/// as a (literal) number of femtometers.
constexpr auto operator"" _fm(long double v) {
  return femtometers(double(v));
}

/// Constant-expression symbol for fm.
constexpr auto fm = impl::fm<double>;

/// Interpret a number, suffixed with '_km',
/// as a (literal) number of kilometers.
constexpr auto operator"" _km(long double v) {
  return kilometers(double(v));
}

/// Constant-expression symbol for km.
constexpr auto km = impl::km<double>;

/// Interpret a number, suffixed with '_Mm',
/// as a (literal) number of megameters.
constexpr auto operator"" _Mm(long double v) {
  return megameters(double(v));
}

/// Constant-expression symbol for Mm.
constexpr auto Mm = impl::Mm<double>;

/// Interpret a number, suffixed with '_g',
/// as a (literal) number of grams.
constexpr auto operator"" _g(long double v) {
  return grams(double(v));
}

/// Constant-expression symbol for g.
constexpr auto g = impl::g<double>;

/// Type for variable of dimension mass.
using mass = basic_statdim<mass_dim.encode(), double>;

/// Interpret a number, suffixed with '_mg',
/// as a (literal) number of milligrams.
constexpr auto operator"" _mg(long double v) {
  return milligrams(double(v));
}

/// Constant-expression symbol for mg.
constexpr auto mg = impl::mg<double>;

/// Interpret a number, suffixed with '_mug',
/// as a (literal) number of micrograms.
constexpr auto operator"" _mug(long double v) {
  return micrograms(double(v));
}

/// Constant-expression symbol for mug.
constexpr auto mug = impl::mug<double>;

/// Interpret a number, suffixed with '_ng',
/// as a (literal) number of nanograms.
constexpr auto operator"" _ng(long double v) {
  return nanograms(double(v));
}

/// Constant-expression symbol for ng.
constexpr auto ng = impl::ng<double>;

/// Interpret a number, suffixed with '_pg',
/// as a (literal) number of picograms.
constexpr auto operator"" _pg(long double v) {
  return picograms(double(v));
}

/// Constant-expression symbol for pg.
constexpr auto pg = impl::pg<double>;

/// Interpret a number, suffixed with '_kg',
/// as a (literal) number of kilograms.
constexpr auto operator"" _kg(long double v) {
  return kilograms(double(v));
}

/// Constant-expression symbol for kg.
constexpr auto kg = impl::kg<double>;

/// Interpret a number, suffixed with '_Mg',
/// as a (literal) number of megagrams.
constexpr auto operator"" _Mg(long double v) {
  return megagrams(double(v));
}

/// Constant-expression symbol for Mg.
constexpr auto Mg = impl::Mg<double>;

/// Interpret a number, suffixed with '_s',
/// as a (literal) number of seconds.
constexpr auto operator"" _s(long double v) {
  return seconds(double(v));
}

/// Constant-expression symbol for s.
constexpr auto s = impl::s<double>;

/// Type for variable of dimension time.
using time = basic_statdim<time_dim.encode(), double>;

/// Interpret a number, suffixed with '_ms',
/// as a (literal) number of milliseconds.
constexpr auto operator"" _ms(long double v) {
  return milliseconds(double(v));
}

/// Constant-expression symbol for ms.
constexpr auto ms = impl::ms<double>;

/// Interpret a number, suffixed with '_mus',
/// as a (literal) number of microseconds.
constexpr auto operator"" _mus(long double v) {
  return microseconds(double(v));
}

/// Constant-expression symbol for mus.
constexpr auto mus = impl::mus<double>;

/// Interpret a number, suffixed with '_ns',
/// as a (literal) number of nanoseconds.
constexpr auto operator"" _ns(long double v) {
  return nanoseconds(double(v));
}

/// Constant-expression symbol for ns.
constexpr auto ns = impl::ns<double>;

/// Interpret a number, suffixed with '_ps',
/// as a (literal) number of picoseconds.
constexpr auto operator"" _ps(long double v) {
  return picoseconds(double(v));
}

/// Constant-expression symbol for ps.
constexpr auto ps = impl::ps<double>;

/// Interpret a number, suffixed with '_fs',
/// as a (literal) number of femtoseconds.
constexpr auto operator"" _fs(long double v) {
  return femtoseconds(double(v));
}

/// Constant-expression symbol for fs.
constexpr auto fs = impl::fs<double>;

/// Interpret a number, suffixed with '_C',
/// as a (literal) number of coulombs.
constexpr auto operator"" _C(long double v) {
  return coulombs(double(v));
}

/// Constant-expression symbol for C.
constexpr auto C = impl::C<double>;

/// Type for variable of dimension charge.
using charge = basic_statdim<charge_dim.encode(), double>;

/// Interpret a number, suffixed with '_mC',
/// as a (literal) number of millicoulombs.
constexpr auto operator"" _mC(long double v) {
  return millicoulombs(double(v));
}

/// Constant-expression symbol for mC.
constexpr auto mC = impl::mC<double>;

/// Interpret a number, suffixed with '_muC',
/// as a (literal) number of microcoulombs.
constexpr auto operator"" _muC(long double v) {
  return microcoulombs(double(v));
}

/// Constant-expression symbol for muC.
constexpr auto muC = impl::muC<double>;

/// Interpret a number, suffixed with '_nC',
/// as a (literal) number of nanocoulombs.
constexpr auto operator"" _nC(long double v) {
  return nanocoulombs(double(v));
}

/// Constant-expression symbol for nC.
constexpr auto nC = impl::nC<double>;

/// Interpret a number, suffixed with '_pC',
/// as a (literal) number of picocoulombs.
constexpr auto operator"" _pC(long double v) {
  return picocoulombs(double(v));
}

/// Constant-expression symbol for pC.
constexpr auto pC = impl::pC<double>;

/// Interpret a number, suffixed with '_K',
/// as a (literal) number of kelvins.
constexpr auto operator"" _K(long double v) {
  return kelvins(double(v));
}

/// Constant-expression symbol for K.
constexpr auto K = impl::K<double>;

/// Type for variable of dimension temperature.
using temperature = basic_statdim<temperature_dim.encode(), double>;

/// Interpret a number, suffixed with '_mK',
/// as a (literal) number of millikelvins.
constexpr auto operator"" _mK(long double v) {
  return millikelvins(double(v));
}

/// Constant-expression symbol for mK.
constexpr auto mK = impl::mK<double>;

/// Interpret a number, suffixed with '_muK',
/// as a (literal) number of microkelvins.
constexpr auto operator"" _muK(long double v) {
  return microkelvins(double(v));
}

/// Constant-expression symbol for muK.
constexpr auto muK = impl::muK<double>;

/// Interpret a number, suffixed with '_nK',
/// as a (literal) number of nanokelvins.
constexpr auto operator"" _nK(long double v) {
  return nanokelvins(double(v));
}

/// Constant-expression symbol for nK.
constexpr auto nK = impl::nK<double>;

/// Constant-expression symbol for ft.
constexpr auto ft = impl::ft<double>;

/// Interpret a number, suffixed with '_ft',
/// as a (literal) number of feet.
constexpr auto operator"" _ft(long double v) {
  return double(v)*ft;
}

/// Constant-expression symbol for kft.
constexpr auto kft = impl::kft<double>;

/// Interpret a number, suffixed with '_kft',
/// as a (literal) number of kilofeet.
constexpr auto operator"" _kft(long double v) {
  return double(v)*kft;
}

/// Constant-expression symbol for in.
constexpr auto in = impl::in<double>;

/// Interpret a number, suffixed with '_in',
/// as a (literal) number of inches.
constexpr auto operator"" _in(long double v) {
  return double(v)*in;
}

/// Constant-expression symbol for yd.
constexpr auto yd = impl::yd<double>;

/// Interpret a number, suffixed with '_yd',
/// as a (literal) number of yards.
constexpr auto operator"" _yd(long double v) {
  return double(v)*yd;
}

/// Constant-expression symbol for mi.
constexpr auto mi = impl::mi<double>;

/// Interpret a number, suffixed with '_mi',
/// as a (literal) number of miles.
constexpr auto operator"" _mi(long double v) {
  return double(v)*mi;
}

/// Constant-expression symbol for N.
constexpr auto N = impl::N<double>;

/// Interpret a number, suffixed with '_N',
/// as a (literal) number of newtons.
constexpr auto operator"" _N(long double v) {
  return double(v)*N;
}

/// Constant-expression symbol for mN.
constexpr auto mN = impl::mN<double>;

/// Interpret a number, suffixed with '_mN',
/// as a (literal) number of millinewtons.
constexpr auto operator"" _mN(long double v) {
  return double(v)*mN;
}

/// Constant-expression symbol for muN.
constexpr auto muN = impl::muN<double>;

/// Interpret a number, suffixed with '_muN',
/// as a (literal) number of micronewtons.
constexpr auto operator"" _muN(long double v) {
  return double(v)*muN;
}

/// Constant-expression symbol for kN.
constexpr auto kN = impl::kN<double>;

/// Interpret a number, suffixed with '_kN',
/// as a (literal) number of kilonewtons.
constexpr auto operator"" _kN(long double v) {
  return double(v)*kN;
}

/// Constant-expression symbol for MN.
constexpr auto MN = impl::MN<double>;

/// Interpret a number, suffixed with '_MN',
/// as a (literal) number of meganewtons.
constexpr auto operator"" _MN(long double v) {
  return double(v)*MN;
}

/// Constant-expression symbol for dyn.
constexpr auto dyn = impl::dyn<double>;

/// Interpret a number, suffixed with '_dyn',
/// as a (literal) number of dynes.
constexpr auto operator"" _dyn(long double v) {
  return double(v)*dyn;
}

/// Constant-expression symbol for J.
constexpr auto J = impl::J<double>;

/// Interpret a number, suffixed with '_J',
/// as a (literal) number of joules.
constexpr auto operator"" _J(long double v) {
  return double(v)*J;
}

/// Constant-expression symbol for mJ.
constexpr auto mJ = impl::mJ<double>;

/// Interpret a number, suffixed with '_mJ',
/// as a (literal) number of millijoules.
constexpr auto operator"" _mJ(long double v) {
  return double(v)*mJ;
}

/// Constant-expression symbol for muJ.
constexpr auto muJ = impl::muJ<double>;

/// Interpret a number, suffixed with '_muJ',
/// as a (literal) number of microjoules.
constexpr auto operator"" _muJ(long double v) {
  return double(v)*muJ;
}

/// Constant-expression symbol for kJ.
constexpr auto kJ = impl::kJ<double>;

/// Interpret a number, suffixed with '_kJ',
/// as a (literal) number of kilojoules.
constexpr auto operator"" _kJ(long double v) {
  return double(v)*kJ;
}

/// Constant-expression symbol for MJ.
constexpr auto MJ = impl::MJ<double>;

/// Interpret a number, suffixed with '_MJ',
/// as a (literal) number of megajoules.
constexpr auto operator"" _MJ(long double v) {
  return double(v)*MJ;
}

/// Constant-expression symbol for GJ.
constexpr auto GJ = impl::GJ<double>;

/// Interpret a number, suffixed with '_GJ',
/// as a (literal) number of gigajoules.
constexpr auto operator"" _GJ(long double v) {
  return double(v)*GJ;
}

/// Constant-expression symbol for erg.
constexpr auto erg = impl::erg<double>;

/// Interpret a number, suffixed with '_erg',
/// as a (literal) number of ergs.
constexpr auto operator"" _erg(long double v) {
  return double(v)*erg;
}

/// Constant-expression symbol for W.
constexpr auto W = impl::W<double>;

/// Interpret a number, suffixed with '_W',
/// as a (literal) number of watts.
constexpr auto operator"" _W(long double v) {
  return double(v)*W;
}

/// Constant-expression symbol for mW.
constexpr auto mW = impl::mW<double>;

/// Interpret a number, suffixed with '_mW',
/// as a (literal) number of milliwatts.
constexpr auto operator"" _mW(long double v) {
  return double(v)*mW;
}

/// Constant-expression symbol for muW.
constexpr auto muW = impl::muW<double>;

/// Interpret a number, suffixed with '_muW',
/// as a (literal) number of microwatts.
constexpr auto operator"" _muW(long double v) {
  return double(v)*muW;
}

/// Constant-expression symbol for kW.
constexpr auto kW = impl::kW<double>;

/// Interpret a number, suffixed with '_kW',
/// as a (literal) number of kilowatts.
constexpr auto operator"" _kW(long double v) {
  return double(v)*kW;
}

/// Constant-expression symbol for MW.
constexpr auto MW = impl::MW<double>;

/// Interpret a number, suffixed with '_MW',
/// as a (literal) number of megawatts.
constexpr auto operator"" _MW(long double v) {
  return double(v)*MW;
}

/// Constant-expression symbol for GW.
constexpr auto GW = impl::GW<double>;

/// Interpret a number, suffixed with '_GW',
/// as a (literal) number of gigawatts.
constexpr auto operator"" _GW(long double v) {
  return double(v)*GW;
}

/// Constant-expression symbol for A.
constexpr auto A = impl::A<double>;

/// Interpret a number, suffixed with '_A',
/// as a (literal) number of amperes.
constexpr auto operator"" _A(long double v) {
  return double(v)*A;
}

/// Constant-expression symbol for mA.
constexpr auto mA = impl::mA<double>;

/// Interpret a number, suffixed with '_mA',
/// as a (literal) number of milliamperes.
constexpr auto operator"" _mA(long double v) {
  return double(v)*mA;
}

/// Constant-expression symbol for muA.
constexpr auto muA = impl::muA<double>;

/// Interpret a number, suffixed with '_muA',
/// as a (literal) number of microamperes.
constexpr auto operator"" _muA(long double v) {
  return double(v)*muA;
}

using speed        = decltype(m/s);
using acceleration = decltype(m/s/s);
using momentum     = decltype(g*m/s);
using force        = decltype(N/1);
using current      = decltype(C/s);
using energy       = decltype(J/1);
using power        = decltype(W/1);
using area         = decltype(m*m);
using volume       = decltype(m*m*m);
using pressure     = decltype(N/m/m);

} // namespace dbl


/// Extended-precision dimensions and units.
namespace ldbl {

/// Type of dimensioned value whose dimension is not known at compile-time.
using dyndim = basic_dyndim<long double>;

/// Interpret a number, suffixed with '_m',
/// as a (literal) number of meters.
constexpr auto operator"" _m(long double v) {
  return meters(v);
}

/// Constant-expression symbol for m.
constexpr auto m = impl::m<long double>;

/// Type for variable of dimension length.
using length = basic_statdim<length_dim.encode(), long double>;

/// Interpret a number, suffixed with '_cm',
/// as a (literal) number of centimeters.
constexpr auto operator"" _cm(long double v) {
  return centimeters(v);
}

/// Constant-expression symbol for cm.
constexpr auto cm = impl::cm<long double>;

/// Interpret a number, suffixed with '_mm',
/// as a (literal) number of millimeters.
constexpr auto operator"" _mm(long double v) {
  return millimeters(v);
}

/// Constant-expression symbol for mm.
constexpr auto mm = impl::mm<long double>;

/// Interpret a number, suffixed with '_mum',
/// as a (literal) number of micrometers.
constexpr auto operator"" _mum(long double v) {
  return micrometers(v);
}

/// Constant-expression symbol for mum.
constexpr auto mum = impl::mum<long double>;

/// Interpret a number, suffixed with '_nm',
/// as a (literal) number of nanometers.
constexpr auto operator"" _nm(long double v) {
  return nanometers(v);
}

/// Constant-expression symbol for nm.
constexpr auto nm = impl::nm<long double>;

/// Interpret a number, suffixed with '_pm',
/// as a (literal) number of picometers.
constexpr auto operator"" _pm(long double v) {
  return picometers(v);
}

/// Constant-expression symbol for pm.
constexpr auto pm = impl::pm<long double>;

/// Interpret a number, suffixed with '_fm',
/// as a (literal) number of femtometers.
constexpr auto operator"" _fm(long double v) {
  return femtometers(v);
}

/// Constant-expression symbol for fm.
constexpr auto fm = impl::fm<long double>;

/// Interpret a number, suffixed with '_km',
/// as a (literal) number of kilometers.
constexpr auto operator"" _km(long double v) {
  return kilometers(v);
}

/// Constant-expression symbol for km.
constexpr auto km = impl::km<long double>;

/// Interpret a number, suffixed with '_Mm',
/// as a (literal) number of megameters.
constexpr auto operator"" _Mm(long double v) {
  return megameters(v);
}

/// Constant-expression symbol for Mm.
constexpr auto Mm = impl::Mm<long double>;

/// Interpret a number, suffixed with '_g',
/// as a (literal) number of grams.
constexpr auto operator"" _g(long double v) {
  return grams(v);
}

/// Constant-expression symbol for g.
constexpr auto g = impl::g<long double>;

/// Type for variable of dimension mass.
using mass = basic_statdim<mass_dim.encode(), long double>;

/// Interpret a number, suffixed with '_mg',
/// as a (literal) number of milligrams.
constexpr auto operator"" _mg(long double v) {
  return milligrams(v);
}

/// Constant-expression symbol for mg.
constexpr auto mg = impl::mg<long double>;

/// Interpret a number, suffixed with '_mug',
/// as a (literal) number of micrograms.
constexpr auto operator"" _mug(long double v) {
  return micrograms(v);
}

/// Constant-expression symbol for mug.
constexpr auto mug = impl::mug<long double>;

/// Interpret a number, suffixed with '_ng',
/// as a (literal) number of nanograms.
constexpr auto operator"" _ng(long double v) {
  return nanograms(v);
}

/// Constant-expression symbol for ng.
constexpr auto ng = impl::ng<long double>;

/// Interpret a number, suffixed with '_pg',
/// as a (literal) number of picograms.
constexpr auto operator"" _pg(long double v) {
  return picograms(v);
}

/// Constant-expression symbol for pg.
constexpr auto pg = impl::pg<long double>;

/// Interpret a number, suffixed with '_kg',
/// as a (literal) number of kilograms.
constexpr auto operator"" _kg(long double v) {
  return kilograms(v);
}

/// Constant-expression symbol for kg.
constexpr auto kg = impl::kg<long double>;

/// Interpret a number, suffixed with '_Mg',
/// as a (literal) number of megagrams.
constexpr auto operator"" _Mg(long double v) {
  return megagrams(v);
}

/// Constant-expression symbol for Mg.
constexpr auto Mg = impl::Mg<long double>;

/// Interpret a number, suffixed with '_s',
/// as a (literal) number of seconds.
constexpr auto operator"" _s(long double v) {
  return seconds(v);
}

/// Constant-expression symbol for s.
constexpr auto s = impl::s<long double>;

/// Type for variable of dimension time.
using time = basic_statdim<time_dim.encode(), long double>;

/// Interpret a number, suffixed with '_ms',
/// as a (literal) number of milliseconds.
constexpr auto operator"" _ms(long double v) {
  return milliseconds(v);
}

/// Constant-expression symbol for ms.
constexpr auto ms = impl::ms<long double>;

/// Interpret a number, suffixed with '_mus',
/// as a (literal) number of microseconds.
constexpr auto operator"" _mus(long double v) {
  return microseconds(v);
}

/// Constant-expression symbol for mus.
constexpr auto mus = impl::mus<long double>;

/// Interpret a number, suffixed with '_ns',
/// as a (literal) number of nanoseconds.
constexpr auto operator"" _ns(long double v) {
  return nanoseconds(v);
}

/// Constant-expression symbol for ns.
constexpr auto ns = impl::ns<long double>;

/// Interpret a number, suffixed with '_ps',
/// as a (literal) number of picoseconds.
constexpr auto operator"" _ps(long double v) {
  return picoseconds(v);
}

/// Constant-expression symbol for ps.
constexpr auto ps = impl::ps<long double>;

/// Interpret a number, suffixed with '_fs',
/// as a (literal) number of femtoseconds.
constexpr auto operator"" _fs(long double v) {
  return femtoseconds(v);
}

/// Constant-expression symbol for fs.
constexpr auto fs = impl::fs<long double>;

/// Interpret a number, suffixed with '_C',
/// as a (literal) number of coulombs.
constexpr auto operator"" _C(long double v) {
  return coulombs(v);
}

/// Constant-expression symbol for C.
constexpr auto C = impl::C<long double>;

/// Type for variable of dimension charge.
using charge = basic_statdim<charge_dim.encode(), long double>;

/// Interpret a number, suffixed with '_mC',
/// as a (literal) number of millicoulombs.
constexpr auto operator"" _mC(long double v) {
  return millicoulombs(v);
}

/// Constant-expression symbol for mC.
constexpr auto mC = impl::mC<long double>;

/// Interpret a number, suffixed with '_muC',
/// as a (literal) number of microcoulombs.
constexpr auto operator"" _muC(long double v) {
  return microcoulombs(v);
}

/// Constant-expression symbol for muC.
constexpr auto muC = impl::muC<long double>;

/// Interpret a number, suffixed with '_nC',
/// as a (literal) number of nanocoulombs.
constexpr auto operator"" _nC(long double v) {
  return nanocoulombs(v);
}

/// Constant-expression symbol for nC.
constexpr auto nC = impl::nC<long double>;

/// Interpret a number, suffixed with '_pC',
/// as a (literal) number of picocoulombs.
constexpr auto operator"" _pC(long double v) {
  return picocoulombs(v);
}

/// Constant-expression symbol for pC.
constexpr auto pC = impl::pC<long double>;

/// Interpret a number, suffixed with '_K',
/// as a (literal) number of kelvins.
constexpr auto operator"" _K(long double v) {
  return kelvins(v);
}

/// Constant-expression symbol for K.
constexpr auto K = impl::K<long double>;

/// Type for variable of dimension temperature.
using temperature = basic_statdim<temperature_dim.encode(), long double>;

/// Interpret a number, suffixed with '_mK',
/// as a (literal) number of millikelvins.
constexpr auto operator"" _mK(long double v) {
  return millikelvins(v);
}

/// Constant-expression symbol for mK.
constexpr auto mK = impl::mK<long double>;

/// Interpret a number, suffixed with '_muK',
/// as a (literal) number of microkelvins.
constexpr auto operator"" _muK(long double v) {
  return microkelvins(v);
}

/// Constant-expression symbol for muK.
constexpr auto muK = impl::muK<long double>;

/// Interpret a number, suffixed with '_nK',
/// as a (literal) number of nanokelvins.
constexpr auto operator"" _nK(long double v) {
  return nanokelvins(v);
}

/// Constant-expression symbol for nK.
constexpr auto nK = impl::nK<long double>;

/// Constant-expression symbol for ft.
constexpr auto ft = impl::ft<long double>;

/// Interpret a number, suffixed with '_ft',
/// as a (literal) number of feet.
constexpr auto operator"" _ft(long double v) {
  return v*ft;
}

/// Constant-expression symbol for kft.
constexpr auto kft = impl::kft<long double>;

/// Interpret a number, suffixed with '_kft',
/// as a (literal) number of kilofeet.
constexpr auto operator"" _kft(long double v) {
  return v*kft;
}

/// Constant-expression symbol for in.
constexpr auto in = impl::in<long double>;

/// Interpret a number, suffixed with '_in',
/// as a (literal) number of inches.
constexpr auto operator"" _in(long double v) {
  return v*in;
}

/// Constant-expression symbol for yd.
constexpr auto yd = impl::yd<long double>;

/// Interpret a number, suffixed with '_yd',
/// as a (literal) number of yards.
constexpr auto operator"" _yd(long double v) {
  return v*yd;
}

/// Constant-expression symbol for mi.
constexpr auto mi = impl::mi<long double>;

/// Interpret a number, suffixed with '_mi',
/// as a (literal) number of miles.
constexpr auto operator"" _mi(long double v) {
  return v*mi;
}

/// Constant-expression symbol for N.
constexpr auto N = impl::N<long double>;

/// Interpret a number, suffixed with '_N',
/// as a (literal) number of newtons.
constexpr auto operator"" _N(long double v) {
  return v*N;
}

/// Constant-expression symbol for mN.
constexpr auto mN = impl::mN<long double>;

/// Interpret a number, suffixed with '_mN',
/// as a (literal) number of millinewtons.
constexpr auto operator"" _mN(long double v) {
  return v*mN;
}

/// Constant-expression symbol for muN.
constexpr auto muN = impl::muN<long double>;

/// Interpret a number, suffixed with '_muN',
/// as a (literal) number of micronewtons.
constexpr auto operator"" _muN(long double v) {
  return v*muN;
}

/// Constant-expression symbol for kN.
constexpr auto kN = impl::kN<long double>;

/// Interpret a number, suffixed with '_kN',
/// as a (literal) number of kilonewtons.
constexpr auto operator"" _kN(long double v) {
  return v*kN;
}

/// Constant-expression symbol for MN.
constexpr auto MN = impl::MN<long double>;

/// Interpret a number, suffixed with '_MN',
/// as a (literal) number of meganewtons.
constexpr auto operator"" _MN(long double v) {
  return v*MN;
}

/// Constant-expression symbol for dyn.
constexpr auto dyn = impl::dyn<long double>;

/// Interpret a number, suffixed with '_dyn',
/// as a (literal) number of dynes.
constexpr auto operator"" _dyn(long double v) {
  return v*dyn;
}

/// Constant-expression symbol for J.
constexpr auto J = impl::J<long double>;

/// Interpret a number, suffixed with '_J',
/// as a (literal) number of joules.
constexpr auto operator"" _J(long double v) {
  return v*J;
}

/// Constant-expression symbol for mJ.
constexpr auto mJ = impl::mJ<long double>;

/// Interpret a number, suffixed with '_mJ',
/// as a (literal) number of millijoules.
constexpr auto operator"" _mJ(long double v) {
  return v*mJ;
}

/// Constant-expression symbol for muJ.
constexpr auto muJ = impl::muJ<long double>;

/// Interpret a number, suffixed with '_muJ',
/// as a (literal) number of microjoules.
constexpr auto operator"" _muJ(long double v) {
  return v*muJ;
}

/// Constant-expression symbol for kJ.
constexpr auto kJ = impl::kJ<long double>;

/// Interpret a number, suffixed with '_kJ',
/// as a (literal) number of kilojoules.
constexpr auto operator"" _kJ(long double v) {
  return v*kJ;
}

/// Constant-expression symbol for MJ.
constexpr auto MJ = impl::MJ<long double>;

/// Interpret a number, suffixed with '_MJ',
/// as a (literal) number of megajoules.
constexpr auto operator"" _MJ(long double v) {
  return v*MJ;
}

/// Constant-expression symbol for GJ.
constexpr auto GJ = impl::GJ<long double>;

/// Interpret a number, suffixed with '_GJ',
/// as a (literal) number of gigajoules.
constexpr auto operator"" _GJ(long double v) {
  return v*GJ;
}

/// Constant-expression symbol for erg.
constexpr auto erg = impl::erg<long double>;

/// Interpret a number, suffixed with '_erg',
/// as a (literal) number of ergs.
constexpr auto operator"" _erg(long double v) {
  return v*erg;
}

/// Constant-expression symbol for W.
constexpr auto W = impl::W<long double>;

/// Interpret a number, suffixed with '_W',
/// as a (literal) number of watts.
constexpr auto operator"" _W(long double v) {
  return v*W;
}

/// Constant-expression symbol for mW.
constexpr auto mW = impl::mW<long double>;

/// Interpret a number, suffixed with '_mW',
/// as a (literal) number of milliwatts.
constexpr auto operator"" _mW(long double v) {
  return v*mW;
}

/// Constant-expression symbol for muW.
constexpr auto muW = impl::muW<long double>;

/// Interpret a number, suffixed with '_muW',
/// as a (literal) number of microwatts.
constexpr auto operator"" _muW(long double v) {
  return v*muW;
}

/// Constant-expression symbol for kW.
constexpr auto kW = impl::kW<long double>;

/// Interpret a number, suffixed with '_kW',
/// as a (literal) number of kilowatts.
constexpr auto operator"" _kW(long double v) {
  return v*kW;
}

/// Constant-expression symbol for MW.
constexpr auto MW = impl::MW<long double>;

/// Interpret a number, suffixed with '_MW',
/// as a (literal) number of megawatts.
constexpr auto operator"" _MW(long double v) {
  return v*MW;
}

/// Constant-expression symbol for GW.
constexpr auto GW = impl::GW<long double>;

/// Interpret a number, suffixed with '_GW',
/// as a (literal) number of gigawatts.
constexpr auto operator"" _GW(long double v) {
  return v*GW;
}

/// Constant-expression symbol for A.
constexpr auto A = impl::A<long double>;

/// Interpret a number, suffixed with '_A',
/// as a (literal) number of amperes.
constexpr auto operator"" _A(long double v) {
  return v*A;
}

/// Constant-expression symbol for mA.
constexpr auto mA = impl::mA<long double>;

/// Interpret a number, suffixed with '_mA',
/// as a (literal) number of milliamperes.
constexpr auto operator"" _mA(long double v) {
  return v*mA;
}

/// Constant-expression symbol for muA.
constexpr auto muA = impl::muA<long double>;

/// Interpret a number, suffixed with '_muA',
/// as a (literal) number of microamperes.
constexpr auto operator"" _muA(long double v) {
  return v*muA;
}

using speed        = decltype(m/s);
using acceleration = decltype(m/s/s);
using momentum     = decltype(g*m/s);
using force        = decltype(N/1);
using current      = decltype(C/s);
using energy       = decltype(J/1);
using power        = decltype(W/1);
using area         = decltype(m*m);
using volume       = decltype(m*m*m);
using pressure     = decltype(N/m/m);

} // namespace ldbl


} // namespace units
} // namespace vnix

#endif // ndef VNIX_UNITS_HPP