Unit.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "Dimension.hpp"
#include "UnitRep.hpp"
#include "AstUtil/Object.hpp"
#include "AstUtil/SharedPtr.hpp"
#include "AstUtil/StringView.hpp"
#include "AstUtil/Constants.h"
#include <cmath>
#include <string>
#include <vector>
#include <memory>
 
AST_NAMESPACE_BEGIN
 
 
class Unit;     
class Quantity; 
class UnitRep;  
 
 
 
namespace units
{
    extern AST_UTIL_API Unit none;      
 
    extern AST_UTIL_API Unit mm;        
    extern AST_UTIL_API Unit cm;        
    extern AST_UTIL_API Unit dm;        
    extern AST_UTIL_API Unit m;         
    extern AST_UTIL_API Unit km;        
 
    extern AST_UTIL_API Unit in;        
    extern AST_UTIL_API Unit ft;        
    extern AST_UTIL_API Unit yd;        
    extern AST_UTIL_API Unit mi;        
 
 
 
    extern AST_UTIL_API Unit sec;       
    extern AST_UTIL_API Unit s;         
    extern AST_UTIL_API Unit ms;        
    extern AST_UTIL_API Unit minute;    
    extern AST_UTIL_API Unit hour;      
    extern AST_UTIL_API Unit h;         
    extern AST_UTIL_API Unit day;       
 
    extern AST_UTIL_API Unit kg;        
    extern AST_UTIL_API Unit g;         
    extern AST_UTIL_API Unit mg;        
    extern AST_UTIL_API Unit lb;        
 
    extern AST_UTIL_API Unit N;         
 
    extern AST_UTIL_API Unit deg;       
    extern AST_UTIL_API Unit rad;       
    extern AST_UTIL_API Unit arcsec;    
 
    extern AST_UTIL_API Unit A;         
 
    extern AST_UTIL_API Unit m2;        
 
    extern AST_UTIL_API Unit m3;        
    extern AST_UTIL_API Unit L;         
    
    extern AST_UTIL_API Unit Pa;        
 
    extern AST_UTIL_API Unit T;         
    extern AST_UTIL_API Unit nT;        
    extern AST_UTIL_API Unit Gs;        
 
    extern AST_UTIL_API Unit K;         
 
    extern AST_UTIL_API Unit degC;      
    extern AST_UTIL_API Unit degF;      
    extern AST_UTIL_API Unit degR;      
 
    extern AST_UTIL_API Unit dB;        
    extern AST_UTIL_API Unit dBm;       
    extern AST_UTIL_API Unit dBW;       
 
    extern AST_UTIL_API Unit B;         
};
 
 
 
AST_UTIL_API Unit aUnitMultiply(const Unit& unit1, const Unit& unit2);
 
AST_UTIL_API Unit aUnitMultiply(const Unit& unit1, const Unit& unit2, StringView newname);
 
AST_UTIL_API Unit aUnitDivide(const Unit& unit1, const Unit& unit2);
 
AST_UTIL_API Unit aUnitDivide(const Unit& unit1, const Unit& unit2, StringView newname);
 
AST_UTIL_API Unit aUnitPower(const Unit& unit, int exponent);
 
AST_UTIL_API Unit aUnitPower(const Unit& unit, int exponent, StringView newname);
 
AST_UTIL_API Unit aUnitInvert(const Unit& unit);
 
AST_UTIL_API Unit aUnitInvert(const Unit& unit, StringView newname);
 
AST_UTIL_API void aUnitFactorize(const Unit& unit, Unit& newUnit, double& scale);
 
AST_UTIL_API void aUnitFactorize(Unit& unit, double& scale);
 
 
 
 
class Unit
{
public:
    #ifdef AST_BUILD_LIB_UTIL
    friend Unit unit_multiply(const Unit& unit1, const Unit& unit2);
    friend Unit unit_divide(const Unit& unit1, const Unit& unit2);
    friend Unit unit_power(const Unit& unit, int exponent);
    friend void unit_setname(Unit& unit, StringView name);
    #endif
public: // 便捷工厂(只能用于创建基本单位，不建议用于直接创建复合单位，否则所创建复合单位会缺少子单位信息)
 
    AST_UTIL_API
    static Unit MakeScale(StringView name, Dimension dim, double scale);
 
    AST_UTIL_API
    static Unit MakeAffine(StringView name, Dimension dim, double scale, double offset);
 
    AST_UTIL_API
    static Unit MakeLogarithmic(StringView name, Dimension dim, double reference, double factor);
 
public:
    static Unit NaN()
    {
        return Unit("", 0.0, EDimension::eUnit);
    }
 
    static Unit None()
    {
        return Unit("", 1.0, EDimension::eUnit);
    }    
 
    static Unit One()
    {
        // return Unit(aText("×1"), 1.0, EDimension::eUnit);
        return Unit(aText("\u00D71"), 1.0, EDimension::eUnit);
    }
 
    AST_UTIL_API 
    static Unit Scale(double scale);
 
    static Unit Percent()
    {
        return Unit("%", kPercentToUnit, EDimension::eUnit);
    }
 
 
    static Unit Second()
    {
        return Unit("s", 1.0, EDimension::eTime);
    }
    static Unit Minute()
    {
        return Unit("min", kSecondsPerMinute, EDimension::eTime);
    }
    static Unit Hour()
    {
        return Unit("h", kSecondsPerHour, EDimension::eTime);
    }
    static Unit Day()
    {
        return Unit("day", kSecondsPerDay, EDimension::eTime);
    }
    static Unit MilliSecond()
    {
        return Unit("ms", kMilliSecToSec, EDimension::eTime);
    }
 
 
 
    static Unit Meter()
    {
        return Unit("m", 1.0, EDimension::eLength);
    }
    static Unit Kilometer()
    {
        return Unit("km", kKilometerToMeter, EDimension::eLength);
    }
    static Unit Centimeter()
    {
        return Unit("cm", kCentimeterToMeter, EDimension::eLength);
    }
    static Unit Decimeter()
    {
        return Unit("dm", kDecimeterToMeter, EDimension::eLength);
    }
 
    static Unit Millimeter()
    {
        return Unit("mm", kMillimeterToMeter, EDimension::eLength);
    }
 
    
    static Unit Inch()
    {
        return Unit("in", kInchToMeter, EDimension::eLength);
    }
 
    static Unit Foot()
    {
        return Unit("ft", kFootToMeter, EDimension::eLength);
    }
 
    static Unit Yard()
    {
        return Unit("yd", kYardToMeter, EDimension::eLength);
    }
 
    static Unit Mile()
    {
        return Unit("mi", kMileToMeter, EDimension::eLength);
    }
 
    static Unit Kilogram()
    {
        return Unit("kg", 1.0, EDimension::eMass);
    }
    static Unit Gram()
    {
        return Unit("g", kGramToKilogram, EDimension::eMass);
    }
 
    static Unit Milligram()
    {
        return Unit("mg", kMilligramToKilogram, EDimension::eMass);
    }
 
    static Unit Pound()
    {
        return Unit("lb", kPoundToKilogram, EDimension::eMass);
    }
 
    static Unit Radian()
    {
        return Unit("rad", 1.0, EDimension::eAngle);
    }
 
    static Unit Degree()
    {
        // return Unit("°", 0.017453292519943295, EDimension::eAngle);
        return Unit(aText("\u00B0"), kDegToRad, EDimension::eAngle);
    }
 
    static Unit ArcSecond()
    {
        return Unit(aText("\u2033"), kArcSecToRad, EDimension::eAngle);
    }
 
    static Unit Newton()
    {
        return Unit("N", 1.0, EDimension::eForce);
    }
 
    static Unit Ampere()
    {
        return Unit("A", 1.0, EDimension::eCurrent);
    }
    static Unit Kelvin()
    {
        return Unit("K", 1.0, EDimension::eTemperature);
    }
 
    static Unit Celsius()
    {
        return MakeAffine(aText("°C"), EDimension::eTemperature, 1.0, kCelsiusToKelvinOffset);
    }
    static Unit Fahrenheit()
    {
        return MakeAffine(aText("°F"), EDimension::eTemperature, kFahrenheitToKelvinScale, kFahrenheitToKelvinOffset);
    }
    static Unit Rankine()
    {
        return MakeScale(aText("°R"), EDimension::eTemperature, kRankineToKelvin);
    }
 
    static Unit Decibel()
    {
        return MakeLogarithmic(aText("dB"), EDimension::eUnit, 1.0, kDecibelPowerFactor);
    }
    static Unit DecibelMilliwatt()
    {
        // @todo 修复构造单位后缺少子单位信息
        // dBm 为导出量纲(功率)，MakeLogarithmic 的断言不满足，直接构造对数单位表示
        return Unit(std::make_shared<LogarithmicUnitRep>(aText("dBm"), EDimension::ePower, kMilliwattToWatt, kDecibelPowerFactor));
    }
    static Unit DecibelWatt()
    {
        // @todo 修复构造单位后缺少子单位信息
        // dBW 为导出量纲(功率)，直接构造对数单位表示
        return Unit(std::make_shared<LogarithmicUnitRep>(aText("dBW"), EDimension::ePower, 1.0, kDecibelPowerFactor));
    }
 
    static Unit Bel()
    {
        return MakeLogarithmic(aText("B"), EDimension::eUnit, 1.0, kBelFactor);
    }
 
    // static Unit Mole()
    // {
    //     return Unit("mol", 1.0, EDimension::eAmount);
    // }
 
    // 下面是组合单位
 
    static Unit CentimeterPerSecond(){
        return Centimeter() / Second();
    }
    static Unit KilometerPerHour()
    {
        return Kilometer() / Hour();
    }
    static Unit MeterPerMinute()
    {
        return Meter() / Minute();
    }
    static Unit SquareMeter()
    {
        return Meter() * Meter();
    }
    static Unit SquareKilometer()
    {
        return Kilometer() * Kilometer();
    }
    static Unit SquareFoot()
    {
        return Foot() * Foot();
    }
 
    static Unit SquareYard()
    {
        return Yard() * Yard();
    }
 
    static Unit CubicMeter()
    {
        return Meter() * Meter() * Meter();
    }
    static Unit Liter()
    {
        return Unit("L", kLiterToCubicMeter, EDimension::eVolume);
    }
 
    static Unit Pascal()
    {
        return Unit("Pa", 1.0, EDimension::ePressure);
    }
 
    static Unit Tesla()
    {
        return Unit("T", 1.0, EDimension::eMagneticFluxDensity);
    }
    static Unit NanoTesla()
    {
        return Unit("nT", kNanoteslaToTesla, EDimension::eMagneticFluxDensity);
    }
    static Unit Gauss()
    {
        return Unit("Gs", kGaussToTesla, EDimension::eMagneticFluxDensity);
    }
 
public:
    Unit(): Unit{Unit::None()}{}
 
    AST_UTIL_API
    Unit(StringView name);
 
    Unit(StringView name, double scale, Dimension dimension)
        : rep_{std::make_shared<ScaleUnitRep>(name, dimension, scale)} 
    {}
 
protected:
    Unit(double scale, Dimension dimension, const SubUnitListConst& subunits)
        : rep_{std::make_shared<ScaleUnitRep>("", dimension, (subunits), scale)} 
    {}
 
    Unit(UnitRepHandle rep) : rep_(rep) {}
 
public:
    double fromSI(double value) const { return rep_->fromSI(value); }
 
    double toSI(double value) const { return rep_->toSI(value); }
 
    double convertTo(double value, const Unit& unit) const { return unit.fromSI(toSI(value)); }
 
    double convertFrom(double value, const Unit& unit) const { return fromSI(unit.toSI(value)); }
 
    double getScale() const { return rep_->scale(); }
 
    Dimension dimension() const { return rep_->dimension_; }
 
    const std::string& name() const { return rep_->name_; }
 
    EUnitKind kind() const { return rep_->kind_; }
 
    bool isValid() const { return rep_->valid(); }
 
public: // operators
 
    Unit clone() const { return Unit(rep_->clone()); }
 
    Unit invert() const { return aUnitInvert(*this); }
 
    Unit multiply(StringView newname, const Unit& other) const
    {
        return aUnitMultiply(*this, other, newname);
    }
 
    Unit divide(StringView newname, const Unit& other) const
    {
        return aUnitDivide(*this, other, newname);
    }
 
    Unit pow(StringView newname, int exponent) const
    {
        return aUnitPower(*this, exponent, newname);
    }
 
    Unit pow(int exponent) const
    {
        return aUnitPower(*this, exponent);
    }
 
    bool operator==(const Unit& other) const
    {
        if(rep_ == other.rep_)
            return true;
        return rep_->operator==(*other.rep_);    
    }
 
    bool operator!=(const Unit& other) const
    {
        return !(*this == other);
    }
 
    // @todo 应禁止 affine（如 °C）与 logarithmic（如 dBm）单位的复合算术（乘/除/幂），这些单位不能按线性比例运算。
    Unit operator*(const Unit& other) const
    {
        return aUnitMultiply(*this, other);
    }
 
    Unit operator/(const Unit& other) const
    {
        return aUnitDivide(*this, other);
    }
    Unit& operator*=(const Unit& other)
    {
        *this = *this * other;
        return *this;
    }
    Unit& operator/=(const Unit& other)
    {
        *this = *this / other;
        return *this;
    }
 
 
public:
    UnitRepHandle rep_{};
};
 
 
AST_NAMESPACE_END