Units.h

Go to the documentation of this file.

#ifndef included_AMP_Units
#define included_AMP_Units
 
#include <array>
#include <math.h>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
 
namespace AMP {
 
enum class UnitPrefix : int8_t {
    quecto  = 0,
    ronto   = 1,
    yocto   = 2,
    zepto   = 3,
    atto    = 4,
    femto   = 5,
    pico    = 6,
    nano    = 7,
    micro   = 8,
    milli   = 9,
    centi   = 10,
    deci    = 11,
    none    = 12,
    deca    = 13,
    hecto   = 14,
    kilo    = 15,
    mega    = 16,
    giga    = 17,
    tera    = 18,
    peta    = 19,
    exa     = 20,
    zetta   = 21,
    yotta   = 22,
    ronna   = 23,
    quetta  = 24,
    unknown = -1
};
 
 
enum class UnitType : int8_t {
    unitless              = 0,
    time                  = 1,
    length                = 2,
    mass                  = 3,
    current               = 4,
    temperature           = 5,
    mole                  = 6,
    intensity             = 7,
    angle                 = 8,
    solidAngle            = 9,
    energy                = 10,
    power                 = 11,
    frequency             = 12,
    force                 = 13,
    pressure              = 14,
    electricCharge        = 15,
    electricalPotential   = 16,
    capacitance           = 17,
    resistance            = 18,
    electricalConductance = 19,
    magneticFlux          = 20,
    magneticFluxDensity   = 21,
    inductance            = 22,
    luminousFlux          = 23,
    illuminance           = 24,
    unknown               = -1
};
 
 
class alignas( 8 ) Units final
{
public:
    using unit_type = std::array<char, 31>;
    using SI_type   = std::array<int8_t, 9>;
 
public:
    constexpr Units() = default;
 
    constexpr Units( const char *unit );
 
    constexpr Units( const std::string_view &unit );
 
    constexpr Units( const std::string_view &unit, double value );
 
    explicit constexpr Units( const SI_type &unit, double scale = 1.0 );
 
    explicit constexpr Units( const UnitType &unit, double scale = 1.0 );
 
    constexpr UnitType getType() const noexcept;
 
    constexpr static UnitPrefix getUnitPrefix( const std::string_view &str ) noexcept;
 
    constexpr bool compatible( const Units &unit ) noexcept;
 
    constexpr double convert( const Units &unit ) const;
 
    constexpr static double convert( UnitPrefix x ) noexcept;
 
    constexpr bool operator==( const Units &rhs ) const noexcept;
 
    constexpr bool operator!=( const Units &rhs ) const noexcept { return !operator==( rhs ); }
 
    constexpr void operator*=( const Units &rhs ) noexcept;
 
    constexpr void operator*=( double x ) noexcept { d_scale *= x; }
 
    constexpr void operator/=( const Units &rhs ) noexcept;
 
    constexpr Units pow( int p ) const noexcept;
 
    constexpr bool isNull() const { return d_scale == 0; }
 
 
public:
    std::string str() const;
 
    static constexpr std::string_view getPrefixStr( UnitPrefix ) noexcept;
 
    std::string printSI() const;
 
    std::string printUnit() const;
 
    std::string printFull() const;
 
 
public:
    static inline std::vector<std::string> getAllPrefixes();
 
    static inline std::vector<std::string> getAllUnits();
 
    // Convert string to int
    static constexpr int atoi( std::string_view, bool = true );
 
    // Convert string to double
    static constexpr double strtod( std::string_view );
 
 
protected:
    unit_type d_unit = { 0 };
    SI_type d_SI     = { 0 };
    double d_scale   = { 0.0 };
 
protected:
    std::string printSIBase() const;
    static constexpr Units read( std::string_view str );
    static constexpr Units read2( std::string_view str );
    static constexpr Units readUnit( const std::string_view &str, bool throwErr = true );
    static constexpr SI_type combine( const SI_type &a, const SI_type &b );
    static constexpr SI_type getSI( UnitType );
    static constexpr std::pair<size_t, char> findToken( const std::string_view &, size_t );
    static constexpr size_t findPar( const std::string_view &, size_t );
 
protected:
    friend constexpr Units pow( Units base, int exponent );
};
 
 
inline std::ostream &operator<<( std::ostream &os, const Units &unit )
{
    os << unit.str();
    return os;
}
 
 
} // namespace AMP
 
 
#include "AMP/utils/Units.hpp"
 
 
#endif