mp units

mp-units - The Quantities and Units Library para C ++

A biblioteca MP-Units pode ser o assunto da padronização ISO para C ++ 29. Mais sobre isso pode ser encontrado nas seguintes propostas ISO C ++:

• P1935: uma abordagem C ++ para unidades físicas,
• P2980: Uma motivação, escopo e planejamento para uma biblioteca de quantidades e unidades,
• P3045: Biblioteca de quantidades e unidades.

Estamos procurando ativamente as partes interessadas em julgar em campo a biblioteca.

Introdução ao vídeo

Uma breve introdução às interfaces da biblioteca e a lógica para mudanças na versão 2.0 das unidades MP foram fornecidas em detalhes por Mateusz Pusz no "The Power of C ++ Modelos com unidades de MP: lições aprendidas e um novo design da biblioteca" no C ++ na conferência Sea 2023.

Documentação

Uma extensa documentação do projeto pode ser encontrada nas páginas do MP-Units Github. Inclui instruções de instalação e um guia detalhado do usuário.

Termos e definições

Este projeto usa o vocabulário oficial da Metrologia definido pela ISO e BIPM. Familiarize-se com esses termos para entender melhor a documentação e melhorar a comunicação e as discussões relacionadas ao domínio. Você pode encontrar definições essenciais relacionadas ao projeto no capítulo "Glossário" da nossa documentação. Ainda mais termos são fornecidos no vocabulário oficial da ISO e BIPM.

Tl; dr

mp-units é uma biblioteca C ++ moderna ativada por tempo de compilação que fornece análise dimensional do tempo de compilação e manipulação de unidade/quantidade.

Aqui está um pequeno exemplo de operações possíveis:

# 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);

Experimente no Compiler Explorer.

Esta biblioteca usa fortemente os recursos C ++ 20 (conceitos, classes como NTTPs, ...). Graças a eles, o usuário recebe interfaces poderosos, mas ainda fáceis de usar, e todas as conversões de unidades e análises dimensionais podem ser realizadas sem sacrificar o desempenho ou a precisão do tempo de execução. Consulte o exemplo abaixo para obter uma rápida prévia dos recursos básicos da biblioteca:

# 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
}

Experimente no Compiler Explorer.