TnbValueUnit.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbRealNumber.h"
#include "TnbException.h"
 
 
 
//TNB Library
namespace TNB   
{
 
 
 
#define _PAI 3.14159265358979323846264338327950288 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
#if defined(_UNICODE) && ! defined(_TnbUnit_SpecialChar_DISABLE)
    #define _S2     L"\x00B2"
    #define _M3     L"\x33A5"
    #define _S3     L"\x00B3"
    #define _LITRE  L"\x2113"
    #define _DL     L"\x3397"
#else
    #define _S2     _T("^2")
    #define _M3     _T("m^3")
    #define _S3     _T("^3")
    #define _LITRE  _T("l")
    #define _DL     _T("dl")
#endif
#endif //_TnbDOXYGEN
 
 
 
class CAbstractUnit
{
public:
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    enum {
        RASING = 1,             
        EXCODE = _BIT(29),      
        PFCODE = _BIT(30),      
        TNBLIB_VALUEUNIT = -1   
    };
    #endif
};
 
 
 
struct TUnitParam
{
    LPCTSTR lpszMarkString;     
    LPCTSTR lpszJapanString;    
    double  doCoefficient;      
    double  doRevise;           
};
 
 
 
class CPfUnit
{
public:
    enum EPfUnitCode
    {
        DEF = _BIT(30),     
        YOTTA,              
        ZETTA,              
        EXA,                
        PETA,               
        TERA,               
        GIGA,               
        MEGA,               
        KILO,               
        DECI,               
        CENTI,              
        MILLI,              
        MICRO,              
        NANO,               
        PICO,               
        FEMTO,              
        ATTO,               
        ZEPTO,              
        YOCTO,              
        //
        YOBI,               
        ZEBI,               
        EXBI,               
        PEBI,               
        TEBI,               
        GIBI,               
        MEBI,               
        KIBI,               
 
        KIRO = KILO,                
    };
 
    static const TUnitParam* GetPfParam(EPfUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T(""),         _T(""),             1.0         },  // -
            {   _T("Y"),        _T("ヨタ"),           1.0E-24     },  // yotta
            {   _T("Z"),        _T("ゼタ"),           1.0E-21     },  // zetta
            {   _T("E"),        _T("エクサ"),      1.0E-18     },  // exa
            {   _T("P"),        _T("ぺタ"),           1.0E-15     },  // peta
            {   _T("T"),        _T("テラ"),           1.0E-12     },  // tera
            {   _T("G"),        _T("ギガ"),           1.0E-9      },  // giga
            {   _T("M"),        _T("メガ"),           1.0E-6      },  // mega
            {   _T("k"),        _T("キロ"),           1.0E-3      },  // kilo
            {   _T("d"),        _T("デシ"),           1.0E+1      },  // deci
            {   _T("c"),        _T("センチ"),      1.0E+2      },  // centi
            {   _T("m"),        _T("ミリ"),           1.0E+3      },  // milli
            {   _T("μ"),        _T("マイクロ"),     1.0E+6      },  // micro
            {   _T("n"),        _T("ナノ"),           1.0E+9      },  // nano
            {   _T("p"),        _T("ピコ"),           1.0E+12     },  // pico
            {   _T("f"),        _T("フェムト"),     1.0E+15     },  // femto
            {   _T("a"),        _T("アト"),           1.0E+18     },  // atto
            {   _T("z"),        _T("ゼプト"),      1.0E+21     },  // zepto
            {   _T("y"),        _T("ヨクト"),      1.0E+24     },  // yocto
            //
            {   _T("Yi"),       _T("ヨビ"),           1.0 / 1208925819614629174706176.0   },
            {   _T("Zi"),       _T("ゼビ"),           1.0 / 1180591620717411303424.0 },
            {   _T("Ei"),       _T("エクスビ"),     1.0 / (1ui64 << 60) } ,
            {   _T("Pi"),       _T("ペビ"),           1.0 / (1ui64 << 50) },
            {   _T("Ti"),       _T("テビ"),           1.0 / (1ui64 << 40) },
            {   _T("Gi"),       _T("ギビ"),           1.0 / (1ui64 << 30) },
            {   _T("Mi"),       _T("メビ"),           1.0 / (1ui64 << 20) },
            {   _T("Ki"),       _T("キビ"),           1.0 / (1ui64 << 10) },
        };
        int i = code - DEF;     
        if ( i >= 0 && i < countof(A) )
        {
            return &A[i];
        }
        throw CNoSuchTypeException();
    }
};
 
 
 
template<typename U>
class CValueUnitT : public U, public CPfUnit
{
public:
 
    class CCode
    {
        int     m_code;     
    public:
        typedef typename U::EUnitCode EUnitCode;    
        CCode(void) : m_code(0) {}
        CCode(EUnitCode code) : m_code(code) {}
        CCode(EPfUnitCode code) : m_code(code) {}
        operator EUnitCode(void) const { return EUnitCode(HasPfCode() ? 0 : m_code); }
        operator EPfUnitCode(void) const { return EPfUnitCode(HasPfCode() ? m_code : 0); }
        bool operator==(const CCode& c) const { return m_code == c.m_code; }
        bool operator!=(const CCode& c) const { return m_code != c.m_code; }
        bool HasPfCode(void) const { return (m_code & PFCODE) != 0; }
        int ToInt(void) const { return m_code; };
        void SetInt(int i) { m_code = i; }
    };
 
private:
 
    CRealNumber         m_value;    
    CCode               m_code;     
    
    void m_Test(const CAbstractUnit* u){}
    void m_Test(LPCVOID u){ ASSERT(false); }
 
    double m_GetRevise(const CCode& c) const
    {
        const TUnitParam* P = c.HasPfCode() ? GetPfParam(c) : U::GetParam(c);
        return P->doRevise;
    }
 
    double m_GetCoefficient(const CCode& c) const
    {
        double r;
        if ( c.HasPfCode() )
        {
            double a = GetPfParam(c)->doCoefficient;
            r = 1;
            loop ( i, U::RASING )
            {
                r *= a;
            }
        }
        else
        {
            r = U::GetParam(c)->doCoefficient;
        }
        return r;
    }
 
public:
 
    CValueUnitT(void) : m_value(), m_code()
    {
        DEBUG_ONLY(m_Test(this));
    }
 
    explicit CValueUnitT(const CRealNumber& v) : m_value(v), m_code()
    {
        DEBUG_ONLY(m_Test(this));
    }
 
    CValueUnitT(const CRealNumber& v, CCode code) : m_value(v), m_code(code)
    {
        DEBUG_ONLY(m_Test(this));
    }
 
    void Set(const CRealNumber& v)
    {
        m_value = v;
    }
 
    void Set(const CRealNumber& v, CCode code)
    {
        m_value = v;
        m_code  = code;
    }
 
    CStr ToString(LPCTSTR lpszFormat = NULL) const
    {
        return m_value.ToString(lpszFormat) + GetUnitMarkString(m_code);
    }
 
    CStr ToString(CCode code, LPCTSTR lpszFormat = NULL) const
    {
        CValueUnitT r = *this;
        r.ToUnit(code);
        return r.ToString(lpszFormat);
    }
 
    CCode GetUnitCode(void) const
    {
        return m_code;
    }
 
    CStr GetUnitMarkString(void) const
    {
        return GetUnitMarkString(m_code);
    }
 
    CStr GetUnitJapanString(void) const
    {
        return GetUnitJapanString(m_code);
    }
 
    CValueUnitT& ToUnit(CCode code)
    {
        if ( m_code != code )
        {
            m_value -= m_GetRevise(m_code);
            m_value *= m_GetCoefficient(code) / m_GetCoefficient(m_code);
            m_value += m_GetRevise(code);
            m_code = code;
        }
        return *this;
    }
 
    CRealNumber GetValue(void) const
    {
        return m_value;
    }
 
    operator CRealNumber(void) const
    {
        return m_value;
    }
 
    CRealNumber GetValue(CCode code) const
    {
        CValueUnitT r = *this;
        r.ToUnit(code);
        return r.GetValue();
    }
 
    CValueUnitT& operator+=(const CValueUnitT& u)
    {
        m_value += u.GetValue(m_code);
        return *this;
    }
 
    CValueUnitT operator+(const CValueUnitT& u) const
    {
        CValueUnitT r = *this;
        return r += u;
    }
 
    CValueUnitT& operator+=(const CRealNumber& v)
    {
        m_value += v;
        return *this;
    }
 
    CValueUnitT operator+(const CRealNumber& v) const
    {
        CValueUnitT r = *this;
        return r += v;
    }
 
    friend CValueUnitT operator+(const CRealNumber& v, const CValueUnitT& u)
    {
        return u + v;
    }
 
    CValueUnitT& operator-=(const CValueUnitT& u)
    {
        m_value -= u.GetValue(m_code);
        return *this;
    }
 
    CValueUnitT operator-(const CValueUnitT& u) const
    {
        CValueUnitT r = *this;
        return r -= u;
    }
 
    CValueUnitT& operator-=(const CRealNumber& v)
    {
        m_value -= v;
        return *this;
    }
 
    CValueUnitT operator-(const CRealNumber& v) const
    {
        CValueUnitT r = *this;
        return r -= v;
    }
 
    friend CValueUnitT operator-(const CRealNumber& v, const CValueUnitT& u)
    {
        CValueUnitT r = u;
        u.m_value = v - u.m_value;
        return *this;
    }
 
    CValueUnitT& operator*=(const CRealNumber& v)
    {
        m_value *= v;
        return *this;
    }
 
    CValueUnitT operator*(const CRealNumber& v) const
    {
        CValueUnitT r = *this;
        return r *= v;
    }
 
    friend CValueUnitT operator*(const CRealNumber& v, const CValueUnitT& u)
    {
        return u * v;
    }
 
    CRealNumber operator/(const CValueUnitT& u) const
    {
        return m_value / u.GetValue(m_code);
    }
 
    CValueUnitT& operator/=(const CRealNumber& v)
    {
        m_value /= v;
        return *this;
    }
 
    CValueUnitT operator/(const CRealNumber& v) const
    {
        CValueUnitT r = *this;
        return r /= v;
    }
 
    bool operator==(const CValueUnitT& t) const { return m_value == t.GetValue(m_code); }
    
    bool operator!=(const CValueUnitT& t) const { return m_value != t.GetValue(m_code); }
    
    bool operator<(const CValueUnitT& t) const { return m_value < t.GetValue(m_code); }
    
    bool operator<=(const CValueUnitT& t) const {return m_value <= t.GetValue(m_code); }
    
    bool operator>(const CValueUnitT& t) const { return m_value > t.GetValue(m_code); }
    
    bool operator>=(const CValueUnitT& t) const { return m_value >= t.GetValue(m_code); }
 
 
    //----------------
 
 
    static CStr GetUnitKindString(void)
    {
        return U::GetKindString();
    }
 
    static DWORD GetUnitKindCode(void)
    {
        return U::KINDCODE;
    }
 
    static CStr GetUnitMarkString(CCode code)
    {
        CStr s;
        if ( code.HasPfCode() )
        {
            s = GetPfParam(code)->lpszMarkString;
            s += U::GetParam(U::EUnitCode(0))->lpszMarkString;
        }
        else
        {
            s = U::GetParam(code)->lpszMarkString;
        }
        return s;
    }
 
    static CStr GetUnitJapanString(CCode code) 
    {
        CStr s;
        if ( code.HasPfCode() )
        {
            s = GetPfParam(code)->lpszJapanString;
            s += U::GetParam(U::EUnitCode(0))->lpszJapanString;
        }
        else
        {
            s = U::GetParam(code)->lpszJapanString;
        }
        return s;
    }
};
 
 
 
//--------------------------------
 
 
 
template<typename T>
inline CStr ToStringWithJapanUnit(const T& t, LPCTSTR lpszFormat = NULL)
{
    return t.GetValue().ToString(lpszFormat) + t.GetUnitJapanString();
}
 
 
 
template<typename T>
inline CStr ToStringWithUnitMark(const T& t, LPCTSTR lpszFormat = NULL)
{
    return t.GetValue().ToString(lpszFormat) + t.GetUnitMarkString();
}
 
 
 
template<typename T>
inline CStr GetUnitKindString(const T& t)
{
    return T::GetKindString();
}
 
template<typename T>
inline DWORD GetUnitKindCode(const T& t)
{
    return T::KINDCODE;
}
 
 
 
//--------------------------------
 
 
 
class CUnitDistance : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("距離"); }
 
    enum { KINDCODE = 'Di' };
 
    enum EUnitCode
    {
        M,          
        INCH,       
        FEET,       
        YARD,       
        MILE,       
        KAIRI,      
        SHAKU,      
        KEN,        
        CHOU,       
        SATO,       
        ANG,        
        AU,         
        LY,         
        PC,         
 
        MM      = CPfUnit::MILLI,   
        CM      = CPfUnit::CENTI,   
        KM      = CPfUnit::KIRO,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                 係数
            {   _T("m"),        _T("メートル"),         1.0         },  // m
            {   _T("in"),       _T("インチ"),          39.37       },  // inch
            {   _T("ft"),       _T("フィート"),         3.28084     },  // feet
            {   _T("yd"),       _T("ヤード"),          1.09361     },  // yard
            {   _T("mile"),     _T("マイル"),          0.000621    },  // mile
            {   _T("n.m."),     _T("海里"),               0.000539    },  // kairi
            {   _T("尺"),        _T("尺"),                3.3         },  // 尺
            {   _T("間"),        _T("間"),                3.3 / 6.0   },  // 間
            {   _T("町"),        _T("町"),                3.3 / 360.0 },  // 町
            {   _T("里"),        _T("里"),                3.3 / 12960.0}, // 里
            {   _T("Å"),        _T("オングストローム"), 1.0E+10     },  // オングストローム
            {   _T("AU"),       _T("天文単位"),         6.68459E-12 },  // 天文単位
            {   _T("ly"),       _T("光年"),               1.05700E-16 },  // 光年
            {   _T("pc"),       _T("パーセク"),         3.24078E-17 },  // パーセク
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitDistance> CValueDistance;
 
inline CValueDistance CalcSlantingDistance(const CValueDistance& x, const CValueDistance& y)
{
    const CValueDistance::CCode& code = x.GetUnitCode();
    const CRealNumber& xx = x.GetValue();
    const CRealNumber& yy = y.GetValue(code);
    CRealNumber r = sqrt(xx * xx + yy * yy);
    return CValueDistance(r, code);
}
 
inline CValueDistance CalcCircleDistance(const CValueDistance& r)
{
    return r * 2 * _PAI;
}
 
inline CValueDistance CalcEllipseDistance(const CValueDistance& x, const CValueDistance& y)
{
    const CValueDistance::CCode& code = x.GetUnitCode();
    const CRealNumber& xx = x.GetValue();
    const CRealNumber& yy = y.GetValue(code);
    CRealNumber r = _PAI * sqrt((xx * xx + yy * yy) * 2);
    return CValueDistance(r, code);
}
 
inline CValueDistance CalcEllipseDistance_t2(const CValueDistance& x, const CValueDistance& y)
{
    const CValueDistance::CCode& code = x.GetUnitCode();
    CRealNumber A = x.GetValue();
    CRealNumber B = y.GetValue(code);
    if ( A < B )
    {
        Swap(A, B);
    }
    CRealNumber r = _PAI * sqrt((A * A + B * B) * 2 - (A - B) * (A - B) / 2.2);
    return CValueDistance(r, code);
}
 
inline CValueDistance CalcEllipseDistance_t3(const CValueDistance& x, const CValueDistance& y)
{
    const CValueDistance::CCode& code = x.GetUnitCode();
    CRealNumber A = x.GetValue();
    CRealNumber B = y.GetValue(code);
    if ( A < B )
    {
        Swap(A, B);
    }
    if ( B == 0.0 )
    {
        return CValueDistance(A * 4.0, code);
    }
    CRealNumber a = 1 - (B * B) / (A * A);
    CRealNumber r = 2 * A * _PAI * (1 - a / 4 - (a * a) * 3 / 64 - (a * a * a) * 5 / 256);  
    return CValueDistance(r, code);
}
 
 
 
class CUnitArea : public CAbstractUnit
{
public:
    enum { RASING = 2 };
 
    static LPCTSTR GetKindString(void) { return _T("面積"); }
 
    enum { KINDCODE = 'Ar' };
 
    enum EUnitCode
    {
        M2,     
        A,      
        HA,     
        INCH2,  
        YARD2,  
        ACRE,   
 
        MM2     = CPfUnit::MILLI,   
        CM2     = CPfUnit::CENTI,   
        KM2     = CPfUnit::KIRO,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                     係数
            {   _T("㎡"),        _T("平方メートル"),           1.0             },  // m2
            {   _T("a"),        _T("アール"),              0.01            },  // a
            {   _T("ha"),       _T("ヘクトアール"),           0.0001          },  // ha
            {   _T("in") _S2,   _T("平方インチ"),            1550.0          },  // inch2
            {   _T("yd") _S2,   _T("平方ヤード"),            1.19599         },  // yard2
            {   _T("acre"),     _T("エーカー"),             0.000247        },  // acre
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitArea> CValueArea;
 
inline CValueArea operator*(const CValueDistance& d1, const CValueDistance& d2)
{
    return CValueArea(d1.GetValue(d1.M) * d2.GetValue(d2.M), CValueArea::M2);
}
 
inline CValueDistance operator/(const CValueArea& a, const CValueDistance& d)
{
    return CValueDistance(a.GetValue(a.M2) / d.GetValue(d.M), CValueDistance::M);
}
 
inline CValueDistance sqrt(const CValueArea& a)
{
    CRealNumber r = sqrt(a.GetValue(a.M2));
    return CValueDistance(r, CValueDistance::M);
}
    
inline CValueArea CalcTriangleArea(const CValueDistance& x, const CValueDistance& y)
{
    return x * y / 2.0;
}
 
inline CValueArea CalcCircleArea(const CValueDistance& r)
{
    return r * r * _PAI;
}
 
inline CValueArea CalcEllipseArea(const CValueDistance& x, const CValueDistance& y)
{
    return x * y * _PAI;
}
 
 
 
class CUnitCubic : public CAbstractUnit
{
public:
    enum { RASING = 3 };
 
    static LPCTSTR GetKindString(void) { return _T("体積"); }
 
    enum { KINDCODE = 'Cu' };
 
    enum EUnitCode
    {
        M3,     
        INCH3,  
        YARD3,  
        BBL,    
        LITRE,  
        DL,     
        CC,     
 
        MM3     = CPfUnit::MILLI,   
        CM3     = CPfUnit::CENTI,   
        KM3     = CPfUnit::KIRO,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                     係数
            {   _M3,            _T("立方メートル"),           1.0                     },  // m3
            {   _T("in") _S3,   _T("立方インチ"),            61023.6                 },  // inch3
            {   _T("yd") _S3,   _T("立方ヤード"),            1.30795                 },  // yard3
            {   _T("bbl"),      _T("バレル"),              6.28982                 },  // bbl
            {   _LITRE,         _T("リットル"),             1000.0                  },  // litre
            {   _DL,            _T("デシリットル"),           10000.0                 },  // dl
            {   _T("cc"),       _T("cc"),                   1000000.0               },  // cc
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitCubic> CValueCubic;
 
inline CValueCubic operator*(const CValueArea& a, const CValueDistance& d)
{
    return CValueCubic(a.GetValue(a.M2) * d.GetValue(d.M), CValueCubic::M3);
}
 
inline CValueCubic operator*(const CValueDistance& d, const CValueArea& a)
{
    return a * d;
}
 
 
 
class CUnitWeight : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("重量"); }
 
    enum { KINDCODE = 'We' };
 
    enum EUnitCode
    {
        G,              
        T,              
        OZ,             
        LB,             
        CT,             
        KAN,            
        MONME,          
 
        MG      = CPfUnit::MILLI,   
        KG      = CPfUnit::KIRO,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                 係数
            {   _T("g"),        _T("グラム"),          1.0                 },  // g
            {   _T("t"),        _T("トン"),               0.000001            },  // t
            {   _T("oz"),       _T("オンス"),          35.274 * 0.001      },  // oz
            {   _T("lb"),       _T("ポンド"),          2.20462291 * 0.001  },  // lb
            {   _T("ct"),       _T("カラット"),         1.0 / 0.2           },  // ct
            {   _T("貫"),        _T("貫"),                0.001 / 3.750       },  // kan
            {   _T("mon"),      _T("匁"),                1.0 / 3.750         },  //monme
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitWeight> CValueWeight;
 
 
 
class CUnitTemperature : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("温度"); }
 
    enum { KINDCODE = 'Te' };
 
    enum EUnitCode
    {
        C,              
        F,              
        K,              
 
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語         係数      補正値
            {   _T("℃"),        _T("摂氏"),       1.0,        0       },  // C
            {   _T("゜F"),       _T("華氏"),       9.0 / 5.0,  32,     },  // F
            {   _T("K"),        _T("ケルビン"), 1.0,        273.15  },  // K
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitTemperature> CValueTemperature;
 
 
 
class CUnitTime : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("時間"); }
 
    enum { KINDCODE = 'Ti' };
 
    enum EUnitCode
    {
        SEC,                
        MIN,                
        HOUR,               
        DAY,                
        WEEK,               
 
        MSEC        = CPfUnit::MILLI,   
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語         係数
            {   _T("s"),        _T("秒"),        1.0                     },  // sec
            {   _T("m"),        _T("分"),        1.0 / 60.0              },  // min
            {   _T("h"),        _T("時"),        1.0 / 3600              },  // hour
            {   _T("day"),      _T("日"),        1.0 / (3600 * 24)       },  // day
            {   _T("week"),     _T("週"),        1.0 / (3600 * 24 * 7)   },  // week
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitTime> CValueTime;
 
class CUnitTime2 : public CAbstractUnit
{
public:
    enum { RASING = 2 };
 
    static LPCTSTR GetKindString(void) { return _T("時間^2"); }
 
    enum { KINDCODE = 'Tt' };
 
    enum EUnitCode
    {
        SEC2,               
        MIN2,               
        HOUR2,              
        DAY2,               
        WEEK2,              
 
        MSEC2   = CPfUnit::MILLI,   
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語         係数
            {   _T("s^2"),      _T("秒^2"),      1.0                             },  // sec
            {   _T("m^2"),      _T("分^2"),      (1.0 / 60.0) * (1.0 / 60.0)     },  // min
            {   _T("h^2"),      _T("時^2"),      (1.0 / 3600) * (1.0 / 3600)     },  // hour
            {   _T("day^2"),    _T("日^2"),      (1.0 / (3600 * 24)) * (1.0 / (3600 * 24))}, // day
            {   _T("week^2"),   _T("週^2"),      (1.0 / (3600 * 24 * 7)) * (1.0 / (3600 * 24 * 7))}, // week
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitTime2> CValueTime2;
 
inline CValueTime2 operator*(const CValueTime& t1, const CValueTime& t2)
{
    return CValueTime2(t1.GetValue(t1.SEC) * t2.GetValue(t2.SEC), CValueTime2::SEC2);
}
 
inline CValueTime operator/(const CValueTime2& t2, const CValueTime& t)
{
    return CValueTime(t2.GetValue(t2.SEC2) / t.GetValue(t.SEC), CValueTime::SEC);
}
 
inline CValueTime sqrt(const CValueTime2& t2)
{
    CRealNumber r = sqrt(t2.GetValue(t2.SEC2));
    return CValueTime(r, CValueTime::SEC);
}
 
 
 
class CUnitFrequency : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("周波数"); }
 
    enum { KINDCODE = 'Fr' };
 
    enum EUnitCode
    {
        HZ,             
 
        KHZ     = CPfUnit::KIRO,    
        MHZ     = CPfUnit::MEGA,    
        GHZ     = CPfUnit::GIGA,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T("Hz"),       _T("ヘルツ"),      1.0         },  // Hz
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitFrequency> CValueFrequency;
 
inline CRealNumber operator*(const CValueFrequency& f, const CValueTime& t)
{
    return f.GetValue(f.HZ) * t.GetValue(t.SEC);
}
 
inline CRealNumber operator*(const CValueTime& t, const CValueFrequency& f)
{
    return f * t;
}
 
inline CValueTime operator/(const CRealNumber& v, const CValueFrequency& f)
{
    return CValueTime(v / f.GetValue(f.HZ), CValueTime::SEC);
}
 
inline CValueFrequency operator/(const CRealNumber& v, const CValueTime& t)
{
    return CValueFrequency(v / t.GetValue(t.SEC), CValueFrequency::HZ);
}
 
 
 
class CUnitDegree : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("角度"); }
 
    enum { KINDCODE = 'De' };
 
    enum EUnitCode
    {
        DEG,                
        DEGS,               
        RAD,                
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語         係数
            {   _T("°"),        _T("度"),        1.0         },  // DEG
            {   _T("\""),       _T("秒"),        60.0 * 60.0 },  // DEG(秒)
            {   _T(""),         _T(""),         _PAI / 180.0},  // RAD
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitDegree> CValueDegree;
 
inline CRealNumber sin(const CValueDegree& d) { return sin(d.GetValue(d.RAD)); }
 
inline CRealNumber sinh(const CValueDegree& d) { return sinh(d.GetValue(d.RAD)); }
 
inline CRealNumber cos(const CValueDegree& d) { return cos(d.GetValue(d.RAD)); }
 
inline CRealNumber cosh(const CValueDegree& d) { return cosh(d.GetValue(d.RAD)); }
 
inline CRealNumber tan(const CValueDegree& d) { return tan(d.GetValue(d.RAD)); }
 
inline CRealNumber tanh(const CValueDegree& d) { return tanh(d.GetValue(d.RAD)); }
 
inline CValueDegree MakeDegree(int dd, int mm = 0, double ss = 0.0)
{
    if ( ss < 0.0 )
    {
        ss = -ss;
    }
    double r = abs(dd) * 60 * 60 + abs(mm * 60) + ss;
    if ( dd < 0 )
    {
        r = -r;
    }
    return CValueDegree(r, CValueDegree::DEGS);
}
 
inline CValueDegree MakeDegree(BYTE dd, BYTE mm, double ss)
{
    double r = dd * 60 * 60 + mm * 60 + ss;
    return CValueDegree(r, CValueDegree::DEGS);
}
 
inline CValueDistance CalcRightTriangleHeight(const CValueDistance& di, const CValueDegree& de)
{
    CValueDistance::CCode c = di.GetUnitCode();
    return CValueDistance(di.GetValue(c) * tan(de), c);
}
 
inline CValueDegree CalcDegreeAverage(size_t size, const CValueDegree* pDegs)
{
    CRealNumber x = 0;
    CRealNumber y = 0;
    loop ( i, size )
    {
        x += sin(pDegs[i]);
        y += cos(pDegs[i]);
    }
    CValueDegree d;
    d.Set(atan2(x, y), CValueDegree::RAD);
    return d;
}
 
inline CValueDegree CalcDegreeAverage(const CValueDegree& d1, const CValueDegree& d2, double r1 = 1.0, double r2 = 1.0)
{
    CValueDegree::CCode c = d1.GetUnitCode();
    CRealNumber x = sin(d1) * r1 + sin(d2) * r2;
    CRealNumber y = cos(d1) * r1 + cos(d2) * r2;
    CValueDegree d;
    d.Set(atan2(x, y), CValueDegree::RAD);
    d.ToUnit(c);
    return d;
}
 
inline CValueDegree CalcDegreeDifference(const CValueDegree& d1, const CValueDegree& d2)
{
    CRealNumber v1 = d1.GetValue(CValueDegree::DEG);
    CRealNumber v2 = d2.GetValue(CValueDegree::DEG);
    CValueDegree d;
    v1 = fmod(v1 + 360.0 * 1000.0, 360.0);
    v2 = fmod(v2 + 360.0 * 1000.0, 360.0);
    v1 = fabs(v1 - v2);
    if ( v1 > 180.0 )
    {
        v1 = 360.0 - v1;
    }
    d.Set(v1, CValueDegree::DEG);
    return d;
}
 
 
 
class CUnitPressure : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("圧力"); }
 
    enum { KINDCODE = 'Pr' };
 
    enum EUnitCode
    {
        MMHG,       
        TORR,       
        INHG,       
        PA,         
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                     係数
            {   _T("mmHg"),     _T("水銀柱ミリメートル"),    1.0         },  // mmHg
            {   _T("Torr"),     _T("トル"),                   1.0         },  // Torr
            {   _T("inHg"),     _T("水銀柱インチ"),           3.937E-02   },  // inHg
            {   _T("Pa"),       _T("パスカル"),             133.3224    },  // パスカル
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitPressure> CValuePressure;
 
 
 
class CUnitRatio : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("割合"); }
 
    enum { KINDCODE = 'Re' };
 
    enum EUnitCode
    {
        PERCENT,                
        WARI,                   
        DEC,                    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T("%"),        _T("パーセント"),    1.0         },  // °
            {   _T("割"),        _T("割"),            0.1         },  // °
            {   _T(""),         _T(""),             0.01        },  // °
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitRatio> CValueRatio;
 
 
 
class CUnitAmpere : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("電流"); }
 
    enum { KINDCODE = 'A' };
 
    enum EUnitCode
    {
        A,              
        BI,             
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T("A"),        _T("アンペア"),     1.0         },  // A
            {   _T("Bi"),       _T("ビオ"),           0.1         },  // Bi
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitAmpere> CValueAmpere;
 
 
 
class CUnitVolt : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("電圧"); }
 
    enum { KINDCODE = 'V' };
 
    enum EUnitCode
    {
        V,              
 
        MV      = CPfUnit::MILLI,   
        KV      = CPfUnit::KIRO,    
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T("V"),        _T("ボルト"),      1.0         },  // V
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitVolt> CValueVolt;
 
 
 
class CUnitDummy : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T(""); }
 
    enum { KINDCODE = ' ' * 0x100 };
 
    enum EUnitCode
    {
        NON,                
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語             係数
            {   _T(""),         _T(""),             1.0         },
        };
        if ( code >= 0 && code < countof(A) )
        {
            return &A[code];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueUnitT<CUnitDummy> CValueNonUnit;
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
    #undef _S2      
    #undef _M3      
    #undef _S3      
    #undef _LITRE   
    #undef _DL      
#endif
 
 
 
}; // TNB