Unit.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "Dimension.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;
 
 
 
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 K;         
};
 
 
 
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
 
    class UnitRep;                                                      
    using UnitRepHandle = std::shared_ptr<UnitRep>;                     
    using UnitRepPair = std::pair<UnitRepHandle, int>;                  
    using SubUnitList = std::vector<UnitRepPair>;                       
 
    using UnitRepHandleConst = std::shared_ptr<const UnitRep>;          
    using UnitRepPairConst = std::pair<UnitRepHandleConst, int>;        
    using SubUnitListConst = std::vector<UnitRepPairConst>;             
 
    class UnitRep{
    public:
        UnitRep(StringView name, double scale, Dimension dimension, const SubUnitListConst& subunits)
            : name_{std::string(name)}
            , scale_{scale}
            , dimension_{dimension}
            , subUnits_{subunits}
        {}
        std::string          name_;          
        double               scale_{1.0};    
        Dimension            dimension_;     
        SubUnitListConst     subUnits_;      
    };
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("%", 0.01, EDimension::eUnit);
    }
 
 
    static Unit Second()
    {
        return Unit("s", 1.0, EDimension::eTime);
    }
    static Unit Minute()
    {
        return Unit("min", 60.0, EDimension::eTime);
    }
    static Unit Hour()
    {
        return Unit("h", 3600.0, EDimension::eTime);
    }
    static Unit Day()
    {
        return Unit("day", 86400.0, EDimension::eTime);
    }
    static Unit MilliSecond()
    {
        return Unit("ms", 0.001, EDimension::eTime);
    }
 
 
 
    static Unit Meter()
    {
        return Unit("m", 1.0, EDimension::eLength);
    }
    static Unit Kilometer()
    {
        return Unit("km", 1000.0, EDimension::eLength);
    }
    static Unit Centimeter()
    {
        return Unit("cm", 0.01, EDimension::eLength);
    }
    static Unit Decimeter()
    {
        return Unit("dm", 0.1, EDimension::eLength);
    }
 
    static Unit Millimeter()
    {
        return Unit("mm", 0.001, EDimension::eLength);
    }
 
    
    static Unit Inch()
    {
        return Unit("in", 0.0254, EDimension::eLength);
    }
 
    static Unit Foot()
    {
        return Unit("ft", 0.3048, EDimension::eLength);
    }
 
    static Unit Yard()
    {
        return Unit("yd", 0.9144, EDimension::eLength);
    }
 
    static Unit Mile()
    {
        return Unit("mi", 1609.344, EDimension::eLength);
    }
 
    static Unit Kilogram()
    {
        return Unit("kg", 1.0, EDimension::eMass);
    }
    static Unit Gram()
    {
        return Unit("g", 0.001, EDimension::eMass);
    }
 
    static Unit Milligram()
    {
        return Unit("mg", 0.000001, EDimension::eMass);
    }
 
    static Unit Pound()
    {
        return Unit("lb", 0.45359237, 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 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", 0.001, EDimension::eVolume);
    }
 
    static Unit Pascal()
    {
        return Unit("Pa", 1.0, EDimension::ePressure);
    }
 
public:
    Unit(): Unit{Unit::None()}{}
 
    AST_UTIL_API
    Unit(StringView name);
 
    Unit(StringView name, double scale, Dimension dimension)
        : rep_{std::make_shared<UnitRep>(name, scale, dimension, SubUnitListConst{})} 
    {}
 
protected:
    Unit(double scale, Dimension dimension, const SubUnitListConst& subunits)
        : rep_{std::make_shared<UnitRep>("", scale, dimension, (subunits))} 
    {}
 
    Unit(UnitRepHandle rep) : rep_(rep) {}
 
public:
    double fromSI(double value) const { return value / getScale(); }
 
    double toSI(double value) const { return value * getScale(); }
 
    double convertTo(double value, const Unit& unit) const { return value * (this->getScale() / unit.getScale()); }
 
    double convertFrom(double value, const Unit& unit) const { return value * (unit.getScale() / this->getScale()); }
    
    double getScale() const { return rep_->scale_; }
 
    Dimension dimension() const { return rep_->dimension_; }
 
    const std::string& name() const { return rep_->name_; }
 
    bool isValid() const { return rep_->scale_ != 0.0; }
 
public: // operators
 
    Unit clone() const { return Unit(std::make_shared<UnitRep>(*rep_)); }
 
    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 scale(StringView newname, double factor) const
    {
        return Unit(newname, factor * rep_->scale_, rep_->dimension_);
    }
 
    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_->scale_ == other.rep_->scale_ && rep_->dimension_ == other.rep_->dimension_;    
    }
 
    bool operator!=(const Unit& other) const
    {
        return !(*this == other);
    }
 
    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