mp units

mp-units - La bibliothèque des quantités et des unités pour C ++

La bibliothèque MP-Units pourrait faire l'objet d'une normalisation ISO pour C ++ 29. Plus de choses à ce sujet peuvent être trouvées dans les propositions ISO C ++ suivantes:

• P1935: une approche C ++ des unités physiques,
• P2980: une motivation, une portée et un plan pour une bibliothèque de quantités et d'unités,
• P3045: Bibliothèque de quantités et unités.

Nous recherchons activement des parties intéressées par la bibliothèque à l'essai sur le terrain.

Introduction vidéo

Une brève introduction aux interfaces de la bibliothèque et la justification des modifications de la version 2.0 des unités MP ont été fournies en détail par Mateusz Pusz dans le "Power of C ++ Modèles avec MP-Units: leçons apprises et une nouvelle conception de la bibliothèque" lors de la conférence C ++ On Sea 2023.

Documentation

Une documentation approfondie du projet peut être trouvée sur les pages GitHub MP-Units. Il comprend des instructions d'installation et un guide détaillé de l'utilisateur.

Termes et définitions

Ce projet utilise le vocabulaire officiel de métrologie définie par l'ISO et le BIPM. Veuillez vous familiariser avec ces termes pour mieux comprendre la documentation et améliorer la communication et les discussions liées au domaine. Vous pouvez trouver des définitions essentielles liées au projet dans le chapitre "Glossaire" de notre documentation. Encore plus de termes sont fournis dans le vocabulaire officiel de l'ISO et du BIPM.

Tl; dr

mp-units est une bibliothèque C ++ moderne activée en temps compilé qui fournit une analyse dimensionnelle de compilation et une manipulation unitaire / quantité.

Voici un petit exemple d'opérations possibles:

# include < mp-units/systems/si.h >

using namespace mp_units ;
using namespace mp_units ::si::unit_symbols ;

// simple numeric operations
static_assert ( 10 * km / 2 == 5 * km);

// conversions to common units
static_assert ( 1 * h == 3600 * s);
static_assert ( 1 * km + 1 * m == 1001 * m);

// derived quantities
static_assert ( 1 * km / ( 1 * s) == 1000 * m / s);
static_assert ( 2 * km / h * ( 2 * h) == 4 * km);
static_assert ( 2 * km / ( 2 * km / h) == 1 * h);

static_assert ( 2 * m * ( 3 * m) == 6 * m2);

static_assert ( 10 * km / ( 5 * km) == 2 * one);

static_assert ( 1000 / ( 1 * s) == 1 * kHz);

Essayez-le sur l'explorateur du compilateur.

Cette bibliothèque utilise fortement les fonctionnalités C ++ 20 (concepts, classes comme NTTP, ...). Grâce à eux, l'utilisateur obtient des interfaces puissantes mais toujours faciles à utiliser et toutes les conversions d'unités et l'analyse dimensionnelle peuvent être effectuées sans sacrifier les performances ou la précision de l'exécution. Veuillez consulter l'exemple ci-dessous pour un aperçu rapide des fonctionnalités de la bibliothèque de base:

# include < mp-units/format.h >
# include < mp-units/ostream.h >
# include < mp-units/systems/international.h >
# include < mp-units/systems/isq.h >
# include < mp-units/systems/si.h >
# include < format >
# include < iomanip >
# include < iostream >
# include < print >

using namespace mp_units ;

constexpr QuantityOf<isq::speed> auto avg_speed (QuantityOf<isq::length> auto d,
                                                QuantityOf<isq::time> auto t)
{
  return d / t;
}

int main ()
{
  using namespace mp_units ::si::unit_symbols ;
  using namespace mp_units ::international::unit_symbols ;

  constexpr quantity v1 = 110 * km / h;
  constexpr quantity v2 = 70 * mph;
  constexpr quantity v3 = avg_speed ( 220 . * isq::distance[km], 2 * h);
  constexpr quantity v4 = avg_speed ( isq::distance ( 140 . * mi), 2 * h);
  constexpr quantity v5 = v3. in (m / s);
  constexpr quantity v6 = value_cast<m / s>(v4);
  constexpr quantity v7 = value_cast< int >(v6);

  std::cout << v1 << ' n ' ;                                        // 110 km/h
  std::cout << std::setw ( 10 ) << std::setfill ( ' * ' ) << v2 << ' n ' ;  // ***70 mi/h
  std::cout << std::format ( " {:*^10} n " , v3);                      // *110 km/h*
  std::println ( " {:%N in %U of %D} " , v4);                          // 70 in mi/h of LT⁻¹
  std::println ( " {::N[.2f]} " , v5);                                 // 30.56 m/s
  std::println ( " {::N[.2f]U[dn]} " , v6);                            // 31.29 m⋅s⁻¹
  std::println ( " {:%N} " , v7);                                      // 31
}

Essayez-le sur l'explorateur du compilateur.