Dimension.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <string>
#include <array>
 
AST_NAMESPACE_BEGIN
 
typedef uint32_t dimension_t;
enum class EDimension: dimension_t;
constexpr size_t sizeof_dimension = sizeof(EDimension);
constexpr size_t bits_of_dimension = sizeof_dimension * 8;
 
 
#define _AST_DIM_EXP_OPBIN(value1, value2, op) \
    (unsigned(( dim_get_exponent(value1, 0) op dim_get_exponent(value2, 0)) & 0xF) << 0) | \
    (unsigned(( dim_get_exponent(value1, 1) op dim_get_exponent(value2, 1)) & 0xF) << 4) | \
    (unsigned(( dim_get_exponent(value1, 2) op dim_get_exponent(value2, 2)) & 0xF) << 8) | \
    (unsigned(( dim_get_exponent(value1, 3) op dim_get_exponent(value2, 3)) & 0xF) << 12) | \
    (unsigned(( dim_get_exponent(value1, 4) op dim_get_exponent(value2, 4)) & 0xF) << 16) | \
    (unsigned(( dim_get_exponent(value1, 5) op dim_get_exponent(value2, 5)) & 0xF) << 20) | \
    (unsigned(( dim_get_exponent(value1, 6) op dim_get_exponent(value2, 6)) & 0xF) << 24) | \
    (unsigned(( dim_get_exponent(value1, 7) op dim_get_exponent(value2, 7)) & 0xF) << 28)
 
 
#define _AST_DIM_EXP_TIMES(value, times)\
    (unsigned(( dim_get_exponent(value, 0) * times) & 0xF) << 0) | \
    (unsigned(( dim_get_exponent(value, 1) * times) & 0xF) << 4) | \
    (unsigned(( dim_get_exponent(value, 2) * times) & 0xF) << 8) | \
    (unsigned(( dim_get_exponent(value, 3) * times) & 0xF) << 12) | \
    (unsigned(( dim_get_exponent(value, 4) * times) & 0xF) << 16) | \
    (unsigned(( dim_get_exponent(value, 5) * times) & 0xF) << 20) | \
    (unsigned(( dim_get_exponent(value, 6) * times) & 0xF) << 24) | \
    (unsigned(( dim_get_exponent(value, 7) * times) & 0xF) << 28)
 
 
#ifdef A_CXX14
#   define _AST_DIM_USE_CXX14
#endif
 
template<typename T>
constexpr int dim_get_exponent(T dimension, int idx) noexcept
{
    static_assert(sizeof(T) == sizeof(EDimension), "size not correct");
    return (int((unsigned)dimension << (bits_of_dimension - 4 - idx * 4)) >> (bits_of_dimension - 4));  // 先逻辑左移，再算数右移
}
 
template<typename T>
A_CONSTEXPR_CXX14 inline EDimension dim_set_exponent(T dimension, int idx, int exponent) noexcept
{
    static_assert(sizeof(T) == sizeof(EDimension), "size not correct");
    // @todo 检查指数范围（4位有符号数范围：-8到7）
    // if (exponent < -8 || exponent > 7) {
    //     //throw std::out_of_range("Exponent must be between -8 and 7");
    // }
    dimension_t value = (dimension_t) dimension;
    int shift = static_cast<int>(idx) * 4;
    int mask = 0xF << shift;
    dimension_t newValue = value & ~mask; // 清除原值
    // 将指数转换为4位有符号表示
    int expBits = exponent & 0xF;
    newValue |= (expBits << shift); // 设置新值
 
    return (EDimension)newValue;
}
 
 
template<typename T>
constexpr int dim_get_sum_abs_exponent(T dimension) noexcept
{
#if defined(_AST_DIM_USE_CXX14)
    int sum = 0;
    for (int i = 0; i < 8; ++i) {
        sum += std::abs(dim_get_exponent(dimension, i));
    }
    return sum;
#else
    return std::abs(dim_get_exponent(dimension, 0)) + 
           std::abs(dim_get_exponent(dimension, 1)) + 
           std::abs(dim_get_exponent(dimension, 2)) + 
           std::abs(dim_get_exponent(dimension, 3)) +
           std::abs(dim_get_exponent(dimension, 4)) + 
           std::abs(dim_get_exponent(dimension, 5)) + 
           std::abs(dim_get_exponent(dimension, 6)) + 
           std::abs(dim_get_exponent(dimension, 7));
#endif
}
 
template<typename T>
constexpr dimension_t dim_product(T dim1, T dim2) noexcept
{
    #if defined(_AST_DIM_USE_CXX14)
    static_assert(sizeof(T) == sizeof(EDimension), "size not correct");
    const size_t size = sizeof(T) * 8;
    dimension_t result = 0;
    dimension_t value1 = (dimension_t)dim1;
    dimension_t value2 = (dimension_t)dim2;
 
    // 对每个量纲分别处理
    for (int i = 0; i < 8; ++i) {
        int shift = i * 4;
        // 提取两个操作数的指数
        int exp1 = (int((unsigned)value1 << (size - 4 - shift)) >> (size - 4)); // 先逻辑左移，再算数右移
        int exp2 = (int((unsigned)value2 << (size - 4 - shift)) >> (size - 4)); // 先逻辑左移，再算数右移
 
        // 指数相加
        int sum = exp1 + exp2;
 
        // @todo 检查是否溢出（4位有符号数范围：-8到7）
        // if (sum < -8 || sum > 7) {
        //     //throw std::overflow_error("Exponent overflow in multiplication");
        // }
 
        // 转换回4位表示
        int sumBits = sum & 0xF;
        result |= (sumBits << shift);
    }
 
    return result;
    #else
    return _AST_DIM_EXP_OPBIN(dim1, dim2, +);
    #endif
}
 
// 量纲除法
template<typename T>
constexpr dimension_t dim_divide(T dim1, T dim2) noexcept
{
    #if defined(_AST_DIM_USE_CXX14)
    static_assert(sizeof(T) == sizeof(EDimension), "size not correct");
    const size_t size = sizeof(T) * 8;
    dimension_t result = 0;
    dimension_t value1 = (dimension_t)dim1;
    dimension_t value2 = (dimension_t)dim2;
 
 
    // 对每个量纲分别处理
    for (int i = 0; i < 8; ++i) {
        int shift = i * 4;
        // 提取两个操作数的指数
        int exp1 = (int((unsigned)value1 << (size - 4 - shift)) >> (size - 4)); // 先逻辑左移，再算数右移
        int exp2 = (int((unsigned)value2 << (size - 4 - shift)) >> (size - 4)); // 先逻辑左移，再算数右移
 
        // 指数相减
        int diff = exp1 - exp2;
 
        // @todo 检查是否溢出
        // if (diff < -8 || diff > 7) {
        //     // throw std::overflow_error("Exponent overflow in division");
        // }
 
        // 转换回4位表示
        int diffBits = diff & 0xF;
        result |= (diffBits << shift);
    }
 
    return result;
    #else
    return _AST_DIM_EXP_OPBIN(dim1, dim2, -);
    #endif
}
 
template<typename T>
constexpr dimension_t dim_pow(T dimension, int n) noexcept
{
    #if defined(_AST_DIM_USE_CXX14)
    static_assert(sizeof(T) == sizeof(EDimension), "size not correct");
    const size_t size = sizeof(T) * 8;
    dimension_t result = 0;
    dimension_t value = (dimension_t)dimension;
 
    for (int i = 0; i < 8; ++i) {
        int shift = i * 4;
        int exp = (int((unsigned)value << (size - 4 - shift)) >> (size - 4)); // 先逻辑左移，再算数右移
 
        int newExp = exp * n;
 
        // @todo 检查是否溢出
        // if (newExp < -8 || newExp > 7) {
        //     throw std::overflow_error("Exponent overflow in power operation");
        // }
 
        int newExpBits = newExp & 0xF;
        result |= (newExpBits << shift);
    }
 
    return result;
    #else
    return _AST_DIM_EXP_TIMES(dimension, n);
    #endif
}
 
 
template<typename T>
constexpr dimension_t dim_invert(T dimension) noexcept
{
    return dim_pow(dimension, -1);
}
 
constexpr EDimension operator *(EDimension dim1, EDimension dim2) noexcept
{
    return (EDimension)dim_product(dim1, dim2);
}
 
constexpr EDimension operator/(EDimension dim1, EDimension dim2) noexcept
{
    return (EDimension)dim_divide(dim1, dim2);
}
 
namespace internal
{
constexpr EDimension pow(EDimension dimension, int n) noexcept
{
    return (EDimension)dim_pow(dimension, n);
}
};
 
// @brief 量纲索引枚举类
enum
{
    kIdxMass,           
    kIdxLength,         
    kIdxAngle,          
    kIdxTime,           
    kIdxTemperature,    
    kIdxCurrent,        
    kIdxDateTime,       
    // kIdxAmount,      ///< 物质的量: 这个基本量纲在动力学中基本用不到，故不启用
    kIdxLuminous,       
};
 
namespace dimensions
{
    constexpr dimension_t kUnit               = 0;
 
    // 基本量纲 7个
    constexpr dimension_t kLength             = 1 << kIdxLength * 4;                
    constexpr dimension_t kMass               = 1 << kIdxMass * 4;                
    constexpr dimension_t kTime               = 1 << kIdxTime * 4;                  
    constexpr dimension_t kCurrent            = 1 << kIdxCurrent * 4;               
    constexpr dimension_t kTemperature        = 1 << kIdxTemperature * 4;           
    constexpr dimension_t kDateTime           = 1 << kIdxDateTime * 4;              
    //constexpr dimension_t kAmount           = 1 << kIdxAmount * 4;   
    constexpr dimension_t kLuminous           = 1 << kIdxLuminous * 4;              
    // 辅助量纲 
    constexpr dimension_t kAngle              = 1 << kIdxAngle * 4;                 
 
    // 导出量纲（由基本量纲组合而成） 
    constexpr dimension_t kAngVel             = dim_divide(kAngle, kTime);         
    constexpr dimension_t kAngularVelocity    = kAngVel;                           
 
    // 导出量纲（由基本量纲组合而成） 
    constexpr dimension_t kArea               = dim_product(kLength, kLength);      
    constexpr dimension_t kVolume             = dim_product(kArea, kLength);      
    constexpr dimension_t kSpeed              = dim_divide(kLength, kTime);        
    constexpr dimension_t kAcceleration       = dim_divide(kSpeed, kTime);         
    constexpr dimension_t kForce              = dim_product(kMass, kAcceleration); 
    constexpr dimension_t kPressure           = dim_divide(kForce, kArea);  
    constexpr dimension_t kEnergy             = dim_product(kForce, kLength);       
    constexpr dimension_t kPower              = dim_divide(kEnergy, kTime);       
    constexpr dimension_t kFrequency          = dim_divide(kUnit, kTime);
    constexpr dimension_t kDensity            = dim_divide(kMass, kVolume);
};
 
typedef enum class EDimension : dimension_t
{
    eUnit               = dimensions::kUnit,                 
 
    // 基本量纲 7个
    eLength             = dimensions::kLength,               
    eMass               = dimensions::kMass,                 
    eTime               = dimensions::kTime,                 
    eCurrent            = dimensions::kCurrent,              
    eTemperature        = dimensions::kTemperature,          
    eDateTime           = dimensions::kDateTime,             
    //eAmount             = dimensions::kAmount,             ///< 物质量N    (相应的基本单位: mol)
    eLuminous           = dimensions::kLuminous,             
    // 辅助量纲 
    eAngle              = dimensions::kAngle,                
 
    //  
    eAngVel             = dimensions::kAngVel,               
    eAngularVelocity    = dimensions::kAngularVelocity,      
 
    // 导出量纲（由基本量纲组合而成） 
    eArea               = dimensions::kArea,                 
    eVolume             = dimensions::kVolume,               
    eSpeed              = dimensions::kSpeed,                
    eAcceleration       = dimensions::kAcceleration,         
    eForce              = dimensions::kForce,                
    ePressure           = dimensions::kPressure,             
    eEnergy             = dimensions::kEnergy,               
    ePower              = dimensions::kPower,                
    eFrequency          = dimensions::kFrequency,            
    eDensity            = dimensions::kDensity,              
 
} AEDimension;
 
 
 
AST_UTIL_API std::string aDimName(EDimension dimension);
 
AST_UTIL_API std::string aDimSymbol(EDimension dimension);
 
A_CONSTEXPR_CXX14 inline bool aDimIsBase(EDimension dimension) noexcept
{
    return dim_get_sum_abs_exponent(dimension) == 1;
}
 
A_CONSTEXPR_CXX14 inline  bool aDimIsDerived(EDimension dimension) noexcept
{
    return dim_get_sum_abs_exponent(dimension) > 1;
}
 
A_CONSTEXPR_CXX14 inline bool aDimIsUnit(EDimension dimension) noexcept
{
    return dimension == EDimension::eUnit;
}
 
 
 
class Dimension
{
public:
    constexpr Dimension() noexcept: dimension_(EDimension::eUnit) {}
 
    constexpr Dimension(EDimension dimension) noexcept: dimension_(dimension) {}
    
    static constexpr Dimension Unit() { return Dimension(EDimension::eUnit); }
    static constexpr Dimension Length() { return Dimension(EDimension::eLength); }
    static constexpr Dimension Mass() { return Dimension(EDimension::eMass); }
    static constexpr Dimension Time() { return Dimension(EDimension::eTime); }
    static constexpr Dimension Current() { return Dimension(EDimension::eCurrent); }
    static constexpr Dimension Temperature() { return Dimension(EDimension::eTemperature); }
    static constexpr Dimension DateTime() { return Dimension(EDimension::eDateTime); }
 
    // static constexpr Dimension Amount() { return Dimension(EDimension::eAmount); }
    
    static constexpr Dimension Luminous() { return Dimension(EDimension::eLuminous); }
    static constexpr Dimension Angle() { return Dimension(EDimension::eAngle); }
    static constexpr Dimension AngVel() noexcept{ return Dimension(EDimension::eAngVel); }
    static constexpr Dimension AngularVelocity() noexcept{ return Dimension(EDimension::eAngularVelocity); }
    static constexpr Dimension Area() noexcept{ return Dimension(EDimension::eArea); }
    static constexpr Dimension Volume() noexcept{ return Dimension(EDimension::eVolume); }
    static constexpr Dimension Speed() noexcept{ return Dimension(EDimension::eSpeed); }
    static constexpr Dimension Acceleration() noexcept{ return Dimension(EDimension::eAcceleration); }
    static constexpr Dimension Pressure() noexcept{ return Dimension(EDimension::ePressure); }
    static constexpr Dimension Energy() noexcept{ return Dimension(EDimension::eEnergy); }
    static constexpr Dimension Power() noexcept{ return Dimension(EDimension::ePower); }
    static constexpr Dimension Frequency() noexcept { return Dimension(EDimension::eFrequency); }
    static constexpr Dimension Force() noexcept{ return Dimension(EDimension::eForce); }
    static constexpr Dimension Density() noexcept{ return Dimension(EDimension::eDensity); }
public:
    std::string name() const { return aDimName(value()); }
    std::string symbol() const { return aDimSymbol(value()); }
    A_CONSTEXPR_CXX14 bool isBase() const noexcept { return aDimIsBase(value()); }
    A_CONSTEXPR_CXX14 bool isDerived() const noexcept { return aDimIsDerived(value()); }
    A_CONSTEXPR_CXX14 bool isUnit() const noexcept { return aDimIsUnit(value()); }
public:
    A_CONSTEXPR_CXX14 Dimension pow(int n) const noexcept
    {
        return EDimension(dim_pow(value(), n));
    }
    A_CONSTEXPR_CXX14 Dimension invert() const noexcept
    {
        return EDimension(dim_invert(value()));
    }
    A_CONSTEXPR_CXX14 Dimension operator*(Dimension other) const noexcept
    {
        return value() * other.value();
    }
    A_CONSTEXPR_CXX14 Dimension& operator*=(Dimension other) noexcept
    {
        this->dimension_ = value() * other.value();
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension operator/(Dimension other) const noexcept
    {
        return value() / other.value();
    }
    A_CONSTEXPR_CXX14 Dimension& operator/=(Dimension other) noexcept
    {
        this->dimension_ = value() / other.value();
        return *this;
    }
    A_CONSTEXPR_CXX14 bool operator==(Dimension other) const noexcept
    {
        return value() == other.value();
    }
    A_CONSTEXPR_CXX14 bool operator!=(Dimension other) const noexcept
    {
        return value() != other.value();
    }
    A_CONSTEXPR_CXX14 bool operator==(EDimension other) const noexcept
    {
        return value() == other;
    }
    A_CONSTEXPR_CXX14 bool operator!=(EDimension other) const noexcept
    {
        return value() != other;
    }
public:
    A_CONSTEXPR_CXX14 operator EDimension() const noexcept { return dimension_; }
    A_CONSTEXPR_CXX14 EDimension value() const noexcept { return dimension_; }
    A_CONSTEXPR_CXX14 int getMass() const noexcept { return dim_get_exponent(dimension_, kIdxMass); }
    A_CONSTEXPR_CXX14 int getLength() const noexcept { return dim_get_exponent(dimension_, kIdxLength);}
    A_CONSTEXPR_CXX14 int getTime() const noexcept { return dim_get_exponent(dimension_, kIdxTime);}
    A_CONSTEXPR_CXX14 int getCurrent() const noexcept { return  dim_get_exponent(dimension_, kIdxCurrent);}
    A_CONSTEXPR_CXX14 int getAngle() const noexcept { return  dim_get_exponent(dimension_, kIdxAngle);}
    A_CONSTEXPR_CXX14 int getTemperature() const noexcept { return  dim_get_exponent(dimension_, kIdxTemperature);}
    
    A_CONSTEXPR_CXX14 int getDateTime() const noexcept { return  dim_get_exponent(dimension_, kIdxDateTime);}
 
    // A_CONSTEXPR_CXX14 int getAmount() const noexcept { return  dim_get_exponent(dimension_, kIdxAmount);}
    
    A_CONSTEXPR_CXX14 int getLuminous() const noexcept { return  dim_get_exponent(dimension_, kIdxLuminous);}
 
    A_CONSTEXPR_CXX14 Dimension& setMass(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxMass, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setLength(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxLength, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setTime(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxTime, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setCurrent(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxCurrent, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setAngle(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxAngle, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setTemperature(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxTemperature, n);
        return *this;
    }
    A_CONSTEXPR_CXX14 Dimension& setDateTime(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxDateTime, n);
        return *this;
    }
    
    // A_CONSTEXPR_CXX14 Dimension& setAmount(int n) noexcept
    // {
    //     dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxAmount, n);
    //     return *this;
    // }
 
    A_CONSTEXPR_CXX14 Dimension& setLuminous(int n) noexcept
    {
        dimension_ = (EDimension)dim_set_exponent(dimension_, kIdxLuminous, n);
        return *this;
    }
public:
    AST_UTIL_API
    void decompose(std::array<std::pair<Dimension, int>, 8>& basicDimensions) const;
protected:
    EDimension dimension_;
};
 
namespace internal{
    A_CONSTEXPR_CXX14 inline Dimension pow(Dimension dim, int n)
    {
        return (EDimension)dim_pow(dim.value(), n);
    }
}
 
AST_NAMESPACE_END