length.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_UNITS_LENGTH_HPP
#define MTCORE_UNITS_LENGTH_HPP
 
#include "mtcore/units/base.hpp"
 
#include <concepts>
#include <string_view>
 
namespace mtcore::units {
  namespace length {
    // SI Units
    constexpr auto attometre  = Units<Unit<dimensions::LENGTH, std::atto>>{};
    constexpr auto attometer  = attometre;
    constexpr auto femtometre = Units<Unit<dimensions::LENGTH, std::femto>>{};
    constexpr auto femtometer = femtometre;
    constexpr auto picometre  = Units<Unit<dimensions::LENGTH, std::pico>>{};
    constexpr auto picometer  = picometre;
    constexpr auto nanometre  = Units<Unit<dimensions::LENGTH, std::nano>>{};
    constexpr auto nanometer  = nanometre;
    constexpr auto micrometre = Units<Unit<dimensions::LENGTH, std::micro>>{};
    constexpr auto micrometer = micrometre;
    constexpr auto millimetre = Units<Unit<dimensions::LENGTH, std::milli>>{};
    constexpr auto millimeter = millimetre;
    constexpr auto centimetre = Units<Unit<dimensions::LENGTH, std::centi>>{};
    constexpr auto centimeter = centimetre;
    constexpr auto decimetre  = Units<Unit<dimensions::LENGTH, std::deci>>{};
    constexpr auto decimeter  = decimetre;
    constexpr auto metre      = Units<Unit<dimensions::LENGTH>>{};
    constexpr auto meter      = metre;
    constexpr auto decametre  = Units<Unit<dimensions::LENGTH, std::deca>>{};
    constexpr auto decameter  = decametre;
    constexpr auto hectometre = Units<Unit<dimensions::LENGTH, std::hecto>>{};
    constexpr auto hectometer = hectometre;
    constexpr auto kilometre  = Units<Unit<dimensions::LENGTH, std::kilo>>{};
    constexpr auto kilometer  = kilometre;
    constexpr auto megametre  = Units<Unit<dimensions::LENGTH, std::mega>>{};
    constexpr auto megameter  = megametre;
    constexpr auto gigametre  = Units<Unit<dimensions::LENGTH, std::giga>>{};
    constexpr auto gigameter  = gigametre;
    constexpr auto terametre  = Units<Unit<dimensions::LENGTH, std::tera>>{};
    constexpr auto terameter  = terametre;
    constexpr auto petametre  = Units<Unit<dimensions::LENGTH, std::peta>>{};
    constexpr auto petameter  = petametre;
    constexpr auto exametre   = Units<Unit<dimensions::LENGTH, std::exa>>{};
    constexpr auto exameter   = exametre;
 
    constexpr auto twip       = Units<Unit<dimensions::LENGTH, std::ratio<127, 7200000>>>{};
    constexpr auto thou       = Units<Unit<dimensions::LENGTH, std::ratio<254, 10000000>>>{};
    constexpr auto barleycorn = Units<Unit<dimensions::LENGTH, std::ratio<127, 15000>>>{};
    constexpr auto inch       = Units<Unit<dimensions::LENGTH, std::ratio<381, 15000>>>{};
    constexpr auto hand       = Units<Unit<dimensions::LENGTH, std::ratio<127, 1250>>>{};
    constexpr auto foot       = Units<Unit<dimensions::LENGTH, std::ratio<381, 1250>>>{};
    constexpr auto yard       = Units<Unit<dimensions::LENGTH, std::ratio<1143, 1250>>>{};
    constexpr auto chain      = Units<Unit<dimensions::LENGTH, std::ratio<12573, 625>>>{};
    constexpr auto furlong    = Units<Unit<dimensions::LENGTH, std::ratio<25146, 125>>>{};
    constexpr auto mile       = Units<Unit<dimensions::LENGTH, std::ratio<201168, 125>>>{};
    constexpr auto league     = Units<Unit<dimensions::LENGTH, std::ratio<603504, 125>>>{};
 
    static_assert(3 * mile == 1 * league);
    static_assert(8 * furlong == 1 * mile);
    static_assert(10 * chain == 1 * furlong);
    static_assert(22 * yard == 1 * chain);
    static_assert(3 * foot == 1 * yard);
    static_assert(12 * inch == 1 * foot);
    static_assert(3 * barleycorn == 1 * inch);
    static_assert((333.333333 * thou).to(barleycorn).val >= 0.99999 &&
                  (333.333333 * thou).to(barleycorn).val <= 1.000001);
    static_assert((1.44 * twip).to(thou).val >= 0.99999 && (1.44 * twip).to(thou).val <= 1.0001);
 
    static_assert((25.4 * millimeter).to(inch).val >= 0.99999 && (25.4 * millimeter).to(inch).val <= 1.000001);
 
    // Maritime Units
    constexpr auto fathom        = Units<Unit<dimensions::LENGTH, std::ratio<463, 250>>>{};
    constexpr auto cable         = Units<Unit<dimensions::LENGTH, std::ratio<926, 5>>>{};
    constexpr auto nautical_mile = Units<Unit<dimensions::LENGTH, std::ratio<1852>>>{};
 
    static_assert((1. * fathom).to(meter).val == 1.852);
    static_assert(1. * fathom == 1.852 * meter);
    static_assert(100 * fathom == 1 * cable);
    static_assert(10 * cable == 1 * nautical_mile);
 
    // Gunter's survey units
    constexpr auto link = Units<Unit<dimensions::LENGTH, std::ratio<12573, 62500>>>{};
    constexpr auto rod  = Units<Unit<dimensions::LENGTH, std::ratio<12573, 2500>>>{};
 
    static_assert(7.92 * inch == 1. * link);
    static_assert(25 * link == 1 * rod);
  }  // namespace length
 
  namespace impl {
    static_assert(AllLeftInRight<decltype(length::meter), decltype(length::meter)>::value);
    static_assert(Convert<decltype(length::meter), decltype(length::centimeter)>::convert<false>(1) == 100);
    static_assert(Convert<decltype(length::meter), decltype(length::decimeter)>::convert<false>(1) == 10);
 
    static_assert(std::same_as<ConvertMorePrecise<std::remove_cv_t<decltype(length::meter)>,
                                                  std::remove_cv_t<decltype(length::decimeter)>>::T,
                               std::remove_cv_t<decltype(length::decimeter)>>);
 
    static_assert(std::same_as<ConvertMorePrecise<std::remove_cv_t<decltype(length::decimeter)>,
                                                  std::remove_cv_t<decltype(length::meter)>>::T,
                               std::remove_cv_t<decltype(length::decimeter)>>);
  }  // namespace impl
 
  MTCORE_DEF_UNIT_NAME_SI(length, metre, meter, m)
  MTCORE_DEF_UNIT_NAME_DIFF_US(length, attometre, attometer, am);
  MTCORE_DEF_UNIT_NAME_DIFF_US(length, exametre, exameter, Em);
 
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(length, twip);
  MTCORE_DEF_UNIT_NAME(length, thou, th);
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(length, barleycorn);
  MTCORE_DEF_UNIT_NAME_SYM(length, inch, in, "″");
  MTCORE_DEF_UNIT_NAME(length, hand, hh);
  MTCORE_DEF_UNIT_NAME_SYM(length, foot, in, "′");
  MTCORE_DEF_UNIT_NAME(length, yard, yd);
  MTCORE_DEF_UNIT_NAME(length, chain, ch);
  MTCORE_DEF_UNIT_NAME(length, furlong, fur);
  MTCORE_DEF_UNIT_NAME(length, mile, mi);
  MTCORE_DEF_UNIT_NAME(length, league, lea);
 
  MTCORE_DEF_UNIT_NAME(length, fathom, ftm);
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(length, cable);
  MTCORE_DEF_UNIT_NAME(length, nautical_mile, "nmi");
 
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(length, link);
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(length, rod);
 
  namespace area {
    constexpr auto perch       = length::rod * length::rod;
    constexpr auto rood        = length::furlong * length::rod;
    constexpr auto acre        = length::furlong * length::chain;
    constexpr auto square_mile = length::mile * length::mile;
 
    static_assert(1. * perch == 272.25 * length::foot * length::foot);
    static_assert(1. * rood == 40. * perch);
    static_assert(1. * acre == 4. * rood);
    static_assert(1. * square_mile == 640. * acre);
  }  // namespace area
 
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(area, perch);
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(area, rood);
  MTCORE_DEF_UNIT_NAME_NO_ABBREV(area, acre);
  MTCORE_DEF_UNIT_NAME(area, square_mile, sq mi);
 
  namespace volume {
    // SI volumes
    constexpr auto litre      = length::decimetre * length::decimetre * length::decimetre;
    constexpr auto liter      = litre;
    constexpr auto microlitre = length::millimetre * length::millimetre * length::millimetre;
    constexpr auto millilitre = length::centimetre * length::centimetre * length::centimetre;
    constexpr auto milliliter = millilitre;
    constexpr auto microliter = microlitre;
    constexpr auto centilitre = length::decimeter * length::centimeter * length::centimeter;
    constexpr auto centiliter = centilitre;
    constexpr auto decilitre  = length::decimeter * length::decimeter * length::centimeter;
    constexpr auto deciliter  = decilitre;
    constexpr auto nanolitre  = length::meter * length::micrometre * length::micrometre;
    constexpr auto nanoliter  = nanolitre;
    constexpr auto picolitre  = length::millimetre * length::micrometre * length::micrometre;
    constexpr auto picoliter  = picolitre;
    constexpr auto femtolitre = length::micrometre * length::micrometre * length::micrometre;
    constexpr auto femtoliter = femtolitre;
 
    constexpr auto decalitre  = length::metre * length::decimetre * length::decimetre;
    constexpr auto decaliter  = decalitre;
    constexpr auto hectolitre = length::metre * length::metre * length::decimetre;
    constexpr auto hectoliter = hectolitre;
 
    constexpr auto kilolitre = length::meter * length::meter * length::meter;
    constexpr auto kiloliter = kilolitre;
 
    constexpr auto megalitre = length::decametre * length::decametre * length::decametre;
    constexpr auto megaliter = megalitre;
 
    constexpr auto gigalitre = length::hectometre * length::hectometre * length::hectometre;
    constexpr auto gigaliter = gigalitre;
 
    constexpr auto teralitre = length::kilometre * length::kilometre * length::kilometre;
    constexpr auto teraliter = teralitre;
 
    constexpr auto petalitre = length::megameter * length::kilometre * length::kilometre;
    constexpr auto petaliter = petalitre;
 
    static_assert(10 * decilitre == 1 * liter);
    static_assert(100 * centilitre == 1 * liter);
    static_assert(1000 * millilitre == 1 * liter);
    static_assert(1e6 * microlitre == 1 * liter);
    static_assert(1e9 * nanolitre == 1 * liter);
    static_assert(1e12 * picoliter == 1. * liter);
    static_assert(1e15 * femtoliter == 1. * liter);
    static_assert(1e-1 * decalitre == 1. * liter);
    static_assert(1e-2 * hectoliter == 1. * liter);
    static_assert(1e-3 * kiloliter == 1. * liter);
    static_assert(1e-6 * megaliter == 1. * liter);
    static_assert(1e-9 * gigaliter == 1. * liter);
    static_assert(1e-12 * teraliter == 1. * liter);
    static_assert(1e-15 * petaliter == 1. * liter);
 
    // US Customary cubics
    constexpr auto cubic_inch = length::inch * length::inch * length::inch;
    constexpr auto cubic_foot = length::foot * length::foot * length::foot;
    constexpr auto cubic_yard = length::yard * length::yard * length::yard;
    constexpr auto acre_foot =
      Units<Unit<dimensions::LENGTH, std::ratio<1659636, 125>>>{} * length::foot * length::foot;
 
    static_assert(1. * cubic_inch >= 16.387064 * millilitre - 0.00001 * millilitre);
    static_assert(1. * cubic_inch <= 16.387064 * millilitre + 0.00001 * millilitre);
 
    static_assert(1. * cubic_foot >= 28.316846592 * liter - 0.00001 * liter);
    static_assert(1. * cubic_foot <= 28.316846592 * liter + 0.00001 * liter);
 
    static_assert(1. * cubic_yard >= 764.554857984 * liter - 0.00001 * liter);
    static_assert(1. * cubic_yard <= 764.554857984 * liter + 0.00001 * liter);
 
    static_assert(1. * acre_foot >= 43560 * cubic_foot - 0.00001 * cubic_foot);
    static_assert(1. * acre_foot <= 43560 * cubic_foot + 0.00001 * cubic_foot);
 
    // US Fluid volume
    namespace fluid {
      constexpr auto us_gal   = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                      Unit<dimensions::LENGTH, std::ratio<43209091, 11414634250>>>{};
      constexpr auto us_pot   = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                      Unit<dimensions::LENGTH, std::ratio<43209091, 22829268500>>>{};
      constexpr auto us_quart = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                      Unit<dimensions::LENGTH, std::ratio<43209091, 45658537000>>>{};
      constexpr auto us_pint  = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                      Unit<dimensions::LENGTH, std::ratio<43209091, 91317074000>>>{};
      constexpr auto us_cup   = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                      Unit<dimensions::LENGTH, std::ratio<43209091, 182634148000>>>{};
 
      constexpr auto us_fluid_ounce = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<43209091, 1461073184000>>>{};
      constexpr auto us_gill        = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<43209091, 365268296000>>>{};
      constexpr auto us_jig         = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<129627273, 2922146368000>>>{};
      constexpr auto us_tablespoon  = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<43209091, 2922146368000>>>{};
      constexpr auto us_teaspoon    = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<43209091, 8766439104000>>>{};
      constexpr auto us_barrel      = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<2722172733, 22829268500>>>{};
      constexpr auto us_oil_barrel  = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<907390911, 5707317125>>>{};
      constexpr auto us_hogshead    = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                            Unit<dimensions::LENGTH, std::ratio<2722172733, 11414634250>>>{};
 
      static_assert(1. * us_gal >= 3.785411784 * liter - 0.0000001 * liter);
      static_assert(1. * us_gal <= 3.785411784 * liter + 0.0000001 * liter);
      static_assert(1. * us_gal <= 231. * cubic_inch + 0.0000001 * cubic_inch);
      static_assert(2. * us_pot == 1. * us_gal);
      static_assert(4. * us_quart == 1. * us_gal);
      static_assert(8. * us_pint == 1. * us_gal);
      static_assert(16. * us_cup == 1. * us_gal);
      static_assert(2. * us_gill >= 1. * us_cup - 0.000001 * us_cup);
      static_assert(2. * us_gill <= 1. * us_cup + 0.000001 * us_cup);
      static_assert(8. * us_fluid_ounce == 1.0 * us_cup);
      static_assert(4. * us_fluid_ounce == 1.0 * us_gill);
      static_assert(1.5 * us_fluid_ounce == 1.0 * us_jig);
      static_assert(2. * us_tablespoon == 1.0 * us_fluid_ounce);
      static_assert((3. * us_teaspoon).to(us_tablespoon).val == 1.0);
      static_assert(3. * us_teaspoon == 1. * us_tablespoon);
      static_assert(1. * us_barrel >= 31.5 * us_gal - 0.00001 * us_gal);
      static_assert(1. * us_barrel <= 31.5 * us_gal + 0.00001 * us_gal);
      static_assert(1. * us_oil_barrel >= 42 * us_gal - 0.00001 * us_gal);
      static_assert(1. * us_oil_barrel <= 42 * us_gal + 0.00001 * us_gal);
      static_assert(1. * us_hogshead >= 63 * us_gal - 0.00001 * us_gal);
      static_assert(1. * us_hogshead <= 63 * us_gal + 0.00001 * us_gal);
    }  // namespace fluid
 
    // US dry volume
    namespace dry {
      constexpr auto us_gal    = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<220244188543, 50000000000000>>>{};
      constexpr auto us_quart  = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<220244188543, 200000000000000>>>{};
      constexpr auto us_pint   = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<220244188543, 400000000000000>>>{};
      constexpr auto us_peck   = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<220244188543, 25000000000000>>>{};
      constexpr auto us_bushel = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<220244188543, 6250000000000>>>{};
      constexpr auto us_barrel = Units<Unit<dimensions::LENGTH>, Unit<dimensions::LENGTH>,
                                       Unit<dimensions::LENGTH, std::ratio<4625127959403, 40000000000000>>>{};
 
      static_assert(1. * us_gal == 4.40488377086 * liter);
      static_assert(4. * us_quart == 1. * us_gal);
      static_assert(2. * us_pint == 1. * us_quart);
      static_assert(1. * us_peck == 2. * us_gal);
      static_assert(1. * us_bushel == 4. * us_peck);
      static_assert(1. * us_barrel >= 26.25 * us_gal - 0.00001 * us_gal);
      static_assert(1. * us_barrel <= 26.25 * us_gal + 0.00001 * us_gal);
    }  // namespace dry
  }  // namespace volume
 
  MTCORE_DEF_UNIT_NAME_SI(volume, litre, liter, L);
 
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_gal, "US gallon", "gallon", "US gal", "US gal", "gal", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_pot, "US pot", "pot", "US pot", "US pot", "pot", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_quart, "US quart", "quart", "US qt", "US qt", "qt", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_pint, "US pint", "pint", "US pt", "US pt", "pt", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_cup, "US cup", "cup", "US c", "US c", "c", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_gill, "US gill", "gill", "US gi", "US gi", "gi", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_jig, "US jig", "jig", "US jig", "US jig", "jig", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_fluid_ounce, "US fluid ounce", "fluid ounce", "US fl oz", "US fl oz",
                            "fl oz", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_tablespoon, "US tablespoon", "tablespoon", "US tbsp", "US tbsp", "tbsp",
                            "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_teaspoon, "US teaspoon", "teaspoon", "US tsp", "US tsp", "tsp", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_barrel, "US barrel (liquid)", "barrel (liquid)", "US bbl", "US bbl",
                            "bbl", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_oil_barrel, "US oil barrel", "oil barrel", "US bbl", "US bbl", "bbl", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, fluid::us_hogshead, "US hogshead", "hogshead", "US hogshead", "US hogshead",
                            "hogshead", "");
 
  MTCORE_DEF_UNIT_NAME_STRS(volume, cubic_inch, "cubic inch", "cubic inch", "cu in", "cu in", "cu in", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, cubic_foot, "cubic foot", "cubic foot", "cu ft", "cu ft", "cu ft", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, cubic_yard, "cubic yard", "cubic yard", "cu yd", "cu yd", "cu yd", "");
  MTCORE_DEF_UNIT_NAME_STRS(volume, acre_foot, "acre-foot", "acre-foot", "acre-ft", "acre-ft", "acre-ft", "");
 
  static_assert(UnitName<std::remove_const_t<decltype(length::meter)>>::name == "metre");
  static_assert(UnitName<std::remove_const_t<decltype(length::decimeter)>>::name == "decimetre");
  static_assert(UnitName<std::remove_const_t<decltype(area::acre)>>::name == "acre");
  static_assert(UnitName<std::remove_const_t<decltype(volume::litre)>>::name == "litre");
  static_assert(UnitName<std::remove_const_t<decltype(volume::decilitre)>>::name == "decilitre");
  static_assert(UnitName<std::remove_const_t<decltype(volume::decilitre)>>::name == "decilitre");
 
  static_assert(std::same_as<std::remove_cvref_t<decltype(length::meter * length::meter)>, Units<Unit<0>, Unit<0>>>);
  static_assert(impl::GetUnit<0, std::remove_cvref_t<decltype(length::meter * length::meter)>>::exponent == 2);
  static_assert(
    std::same_as<std::remove_cvref_t<decltype(1 * length::meter * length::meter)::UnitsType>, Units<Unit<0>, Unit<0>>>);
  static_assert(impl::GetUnit<0, decltype(1 * length::meter * length::meter)::UnitsType>::exponent == 2);
  static_assert(impl::GetUnit<0, decltype(length::meter * length::meter)>::exponent == 2);
  static_assert(impl::GetUnit<0, decltype(1.5 * length::decimeter * length::decimeter)::UnitsType>::exponent == 2);
  static_assert(1.5 * length::decimeter * length::decimeter == 1.5 * length::decimeter * length::decimeter);
  static_assert((1.5 * length::decimeter * length::decimeter).val == 1.5);
  static_assert((1.5 * length::centimeter * length::decimeter).val == 1.5);
  static_assert((1.5 * length::decimeter * length::centimeter).to(length::centimeter * length::centimeter).val == 15);
  static_assert((1.5 * length::decimeter * length::decimeter + 1.5 * length::decimeter * length::decimeter).val == 3.);
  static_assert((1 * length::meter) + (2 * length::meter) == (3 * length::meter));
  static_assert((1. * length::meter) + (2. * length::meter) == (3. * length::meter));
  static_assert((1 / length::meter) + (2 / length::meter) == (3 / length::meter));
  static_assert((1. / length::meter) + (2. / length::meter) == (3. / length::meter));
  static_assert((1 / length::meter) * length::meter == 1);
  static_assert(((1 * length::meter) + (10 * length::decimeter)).val == 20);
  static_assert((1 * length::meter) + (10 * length::decimeter) == 20 * length::decimeter);
  static_assert((1 * length::meter) + (10 * length::decimeter) == 2 * length::meter);
  static_assert((1. * length::meter) + (15. * length::decimeter) == 2.5 * length::meter);
  static_assert(((1. * length::meter) + (15. * length::decimeter)).convert<decltype(length::meter)>() ==
                2.5 * length::meter);
  static_assert(((1. * length::meter) + (15. * length::decimeter)).to(length::meter) == 2.5 * length::meter);
  static_assert((1. * length::meter * length::meter) + (1.5 * length::meter * length::meter) ==
                2.5 * length::meter * length::meter);
  static_assert(((1. * length::meter * length::meter) + (1.5 * length::decimeter * length::decimeter)).val == 1.015);
  static_assert(((1. * length::meter * length::meter) + (1.5 * length::decimeter * length::decimeter)) ==
                1.015 * length::meter * length::meter);
  static_assert(((1. * length::meter * length::meter) + (1.5 * length::centimeter * length::decimeter)).val == 1.0015);
  static_assert(((1. * length::meter * length::meter) + (1.5 * length::centimeter * length::decimeter)) ==
                1.0015 * length::meter * length::meter);
}  // namespace mtcore::units
 
#endif  // MTCORE_UNITS_LENGTH_HPP