TnbFraction.h

[詳解]

#pragma once
#include "TnbComparable.h"
 
 
 
namespace TNB
{
 
 
 
template<typename TYP = int>
class CFractionT : public IComparableT<CFractionT<TYP> >
{
public:
 
    CFractionT(TYP num, TYP den) : m_numerator(num), m_denominator(den)
    {
    }
 
    void Set(TYP num, TYP den)
    {
        m_numerator = num;
        m_denominator = den;
    }
 
    CFractionT& operator=(const CFractionT& other)
    {
        m_numerator = other.m_numerator;
        m_denominator = other.m_denominator;
        return *this;
    }
 
    virtual INT_PTR Compare(const CFractionT& t) const
    {
        TYP t1 = m_numerator * t.m_denominator;
        TYP t2 = t.m_numerator * m_denominator;
        if ( t1 == t2 )
        {
            return 0;
        }
        return (t1 > t2) ? 1 : -1;
    }
 
    CFractionT& operator+=(const CFractionT& other)
    {
        if ( m_denominator == other.m_denominator )
        {
            m_numerator += other.m_numerator;
        }
        else
        {
            m_denominator *= other.m_denominator;
            m_numerator *= other.m_denominator;
            m_numerator += other.m_numerator * other.m_denominator;
        }
        return LeastCommonDivisor();
    }
 
    CFractionT& operator-=(const CFractionT& other)
    {
        if ( m_denominator == other.m_denominator )
        {
            m_numerator -= other.m_numerator;
        }
        else
        {
            m_denominator *= other.m_denominator;
            m_numerator *= other.m_denominator;
            m_numerator -= other.m_numerator * other.m_denominator;
        }
        return LeastCommonDivisor();
    }
 
    CFractionT& operator*=(const CFractionT& other)
    {
        m_numerator *= other.m_numerator;
        m_denominator *= other.m_denominator;
        return LeastCommonDivisor();
    }
 
    CFractionT& operator*=(TYP val)
    {
        m_numerator *= val;
        return LeastCommonDivisor();
    }
 
    CFractionT& operator/=(const CFractionT& other)
    {
        m_numerator *= other.m_denominator;
        m_denominator *= other.m_numerator;
        return LeastCommonDivisor();
    }
 
    CFractionT& operator/=(TYP val)
    {
        m_denominator *= val;
        return LeastCommonDivisor();
    }
 
    CFractionT& operator-(void)
    {
        m_numerator = -m_numerator;
        return *this;
    }
 
    CFractionT operator+(const CFractionT& other) const
    {
        CFractionT r = *this;
        return (r += other);
    }
 
    CFractionT operator-(const CFractionT& other) const
    {
        CFractionT r = *this;
        return (r -= other);
    }
 
    CFractionT operator*(const CFractionT& other) const
    {
        CFractionT r = *this;
        return (r *= other);
    }
 
    CFractionT operator*(TYP val) const
    {
        CFractionT r = *this;
        return (r *= val);
    }
 
    CFractionT operator/(const CFractionT& other) const
    {
        CFractionT r = *this;
        return (r /= other);
    }
 
    CFractionT operator/(TYP val) const
    {
        CFractionT r = *this;
        return (r /= val);
    }
 
    TYP GetNumerator(void) const
    {
        return m_numerator;
    }
 
    TYP GetDenominator(void) const
    {
        return m_denominator;
    }
 
    double Get(void) const
    {
        double r = m_numerator;
        return r / m_denominator;
    }
 
    CFractionT& LeastCommonDivisor(void)
    {
        TYP r = ms_gcd(m_numerator, m_denominator); //分子と分母の最小公倍数
        if ( r == 0 )
        {
            ; // 何もしない
        }
        else
        {
            m_numerator /= r;
            m_denominator /= r;
        }
        return *this;
    }
 
private:
 
    static TYP ms_gcd(TYP m, TYP n)
    {
        if ( 0 == m || 0 == n )
        {
            return 0; // 引数に０がある場合は０を返す
        }
        if ( m < n )
        {
            Swap(m, n);
        }
        // ユークリッドの方法
        while ( m != n )
        {
            (m > n) ? (m -= n) : (n -= m);
        }
        return m;
    }
 
    static TYP ms_lcm(TYP m, TYP n)
    {
        if ( 0 == m || 0 == n )
        {
            return 0; // 引数に０がある場合は０を返す
        }
        if ( m < n )
        {
            Swap(m, n);
        }
        return ((m / ms_gcd(m, n)) * n); // lcm = m * n / gcd(m,n)
    }
 
    TYP m_numerator;    
    TYP m_denominator;  
    friend class CFractionTest;
};
 
 
 
typedef CFractionT<int> CFraction;
 
 
 
}; // TNB