Quantity.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/Unit.hpp"
#include <string>       
#include <limits>       // for std::numeric_limits
 
AST_NAMESPACE_BEGIN
 
class Quantity;
 
AST_UTIL_API Quantity aQuantityAdd(const Quantity& q1, const Quantity& q2);
 
AST_UTIL_API Quantity aQuantitySub(const Quantity& q1, const Quantity& q2);
 
 
AST_UTIL_API Quantity aQuantityMul(const Quantity& q1, const Quantity& q2);
 
 
AST_UTIL_API Quantity aQuantityMul(const Quantity& q, const Unit& unit);
 
 
AST_UTIL_API Quantity aQuantityDiv(const Quantity& q1, const Quantity& q2);
 
 
AST_UTIL_API Quantity aQuantityDiv(const Quantity& q, const Unit& unit);
 
 
AST_UTIL_API void aQuantityReduce(Quantity& q);
 
 
AST_UTIL_API std::string aQuantityToString(const Quantity& q);
 
A_ALWAYS_INLINE std::string aFormatQuantity(const Quantity& q)
{
    return aQuantityToString(q);
}
 
AST_UTIL_API Quantity operator*(double value, const Unit& unit);
 
 
 
class Quantity
{
public:
    static Quantity NaN()
    {
        // 无效数量值使用NaN表示
        return Quantity(std::numeric_limits<double>::quiet_NaN(), Unit::NaN());
    }
 
    static Quantity Zero()
    {
        return Scalar(0.0);
    }
 
    static Quantity One()
    {
        return Scalar(1.0);
    }
 
    static Quantity Scalar(double value)
    {
        return Quantity(value, Unit::None());
    }
 
public:
    Quantity()
        : magnitude_(0.0), unit_{}
    {}
    Quantity(double magnitude, const Unit& unit)
        : magnitude_(magnitude), unit_(unit)
    {}
    explicit Quantity(double magnitude)
        : magnitude_(magnitude), unit_(Unit::None())
    {}
public:
    double magnitude() const { return magnitude_; }
    
    double& magnitude() { return magnitude_; }
 
    double getMagnitude() const { return magnitude_; }
 
    void setMagnitude(double value) { magnitude_ = value; }
 
    const Unit& unit() const { return unit_; }
 
    Unit& unit() { return unit_; }
 
    const Unit& getUnit() const { return unit_; }
 
    void setUnit(const Unit& unit) { unit_ = unit; }
 
    void changeUnit(const Unit& unit);
 
    EDimension dimension() const { return unit_.dimension(); }
 
    double getValueSI() const { return unit_.toSI(magnitude_); }
 
    void setValueSI(double value) { magnitude_ = unit_.fromSI(value); }
 
    double getValueInUnit(const Unit& unit) const { return unit_.convertTo(magnitude_, unit); }
 
    void setValueInUnit(double value, const Unit& unit) { magnitude_ = unit_.convertFrom(value, unit); }
 
    void setValueUnit(double value, const Unit& unit) { magnitude_ = value; unit_ = unit; }
 
    bool isValid() const { return unit_.isValid(); }
 
    bool operator ==(const Quantity& q) const{
        return this->dimension() == q.dimension() && this->getValueSI() == q.getValueSI();
    }
    bool operator !=(const Quantity& q) const{return !(*this == q);}
    
    bool operator == (double value) const{
        return this->dimension() == EDimension::eUnit && this->getValueSI() == value;
    }
 
    bool operator != (double value) const{
        return !(*this == value);
    }
 
    Quantity invert() const { return Quantity(1.0 / magnitude_, unit_.invert()); }
 
    Quantity operator+() const { return *this; }
    Quantity operator-() const { return Quantity(-magnitude_, unit_); }
 
    Quantity operator*(double scale) const { return Quantity(magnitude_ * scale, unit_); }
    Quantity operator/(double scale) const { return Quantity(magnitude_ / scale, unit_); }
    Quantity& operator*=(double scale) { magnitude_ *= scale; return *this; }
    Quantity& operator/=(double scale) { magnitude_ /= scale; return *this; }
    Quantity operator*(const Unit& unit) const { return aQuantityMul(*this, unit); }
    Quantity operator/(const Unit& unit) const { return aQuantityDiv(*this, unit); }
    Quantity& operator*=(const Unit& unit) { *this = aQuantityMul(*this, unit); return *this; }
    Quantity& operator/=(const Unit& unit) { *this = aQuantityDiv(*this, unit); return *this; }
 
 
    Quantity operator+(const Quantity& q) const { return aQuantityAdd(*this, q); }
    Quantity operator-(const Quantity& q) const { return aQuantitySub(*this, q); }
    Quantity operator*(const Quantity& q) const { return aQuantityMul(*this, q); }
    Quantity operator/(const Quantity& q) const { return aQuantityDiv(*this, q); }
    Quantity& operator+=(const Quantity& q) { *this = aQuantityAdd(*this, q); return *this; }
    Quantity& operator-=(const Quantity& q) { *this = aQuantitySub(*this, q); return *this; }
    Quantity& operator*=(const Quantity& q) { *this = aQuantityMul(*this, q); return *this; }
    Quantity& operator/=(const Quantity& q) { *this = aQuantityDiv(*this, q); return *this; }
    std::string toString() const{return aQuantityToString(*this);}
private:
    double magnitude_;
    Unit unit_;
};
 
inline void Quantity::changeUnit(const Unit &unit)
{
    magnitude_ = unit_.convertTo(magnitude_, unit);
    unit_ = unit;
}
 
inline Quantity operator*(double value, const Quantity& q)
{
    return q * value;
}
 
inline Quantity operator/(double value, const Quantity& q)
{
    return value * q.invert();
}
 
AST_NAMESPACE_END