cel_rational.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_rational_h_
#define _cel_rational_h_

#include "cel_types.h"
#include "cel_endian.h"
#include "cel_exception.h"
#include "cel_datatraits.h"
#include "cel_iostream.h"

namespace Celartem
{

    template<typename Int> struct Rational
    {
        Int num;

        Int den;

        Rational() : num(0), den(1) {}

        Rational(const Int& n) : num(n), den(1) {}

        Rational(const Int& n, const Int& d) : num(n), den(d) {normalize();}

        Rational(const Rational& r) : num(r.num), den(r.den) {}

        inline Rational& operator=(const Rational& r)
        {
            num = r.num;
            den = r.den;
            return *this;
        }

        inline Rational& operator=(const Int& n)
        {
            num = n;
            den = 1;
            return *this;
        }

        inline void assign(const Int& n, const Int& d)
        {
            num = n;
            den = d;
            normalize();
        }

        void normalize()
        {
            if(den == zero())
                celThrow(errInvalidState); // ???

            if(num == zero())
            {
                den = 1;
                return;
            }

            Int g = gcd(num, den);
            if(den < zero())
                g = zero() - g;

            num /= g;
            den /= g;
        }

        inline Rational& operator+=(const Rational& r)
        {
            Int g = gcd(den, r.den);
            den /= g;
            num = num * (r.den / g) + r.num * den;
            g = gcd(num, g);
            num /= g;
            den *= r.den / g;
            return *this;
        }

        inline Rational& operator-=(const Rational& r)
        {
            Int g = gcd(den, r.den);
            den /= g;
            num = num * (r.den / g) - r.num * den;
            g = gcd(num, g);
            num /= g;
            den *= r.den / g;
            return *this;
        }

        inline Rational& operator*=(const Rational& r)
        {
            Int gcd1 = gcd(num, r.den);
            Int gcd2 = gcd(r.num, den);
            num = (num / gcd1) * (r.num / gcd2);
            den = (den / gcd2) * (r.den / gcd1);
            return *this;
        }

        inline Rational& operator/=(const Rational& r)
        {
            if(num == zero())
                return *this;

            if(r.den == zero())
                celThrow(errDivByZero);

            Int gcd1 = gcd(num, r.num);
            Int gcd2 = gcd(r.den, den);
            num = (num / gcd1) * (r.den / gcd2);
            den = (den / gcd2) * (r.num / gcd1);
            return *this;
        }

        inline const Rational& operator++()
        {
            num += den;
            return *this;
        }

        inline const Rational& operator--()
        {
            num -= den;
            return *this;
        }

        Rational operator+(const Rational<Int>& r) const
        {
            Rational temp = *this;
            temp += r;
            return temp;
        }

        Rational operator-(const Rational<Int>& r) const
        {
            Rational temp = *this;
            temp -= r;
            return temp;
        }

        Rational operator*(const Rational<Int>& r) const
        {
            Rational temp = *this;
            temp *= r;
            return temp;
        }

        Rational operator/(const Rational<Int>& r) const
        {
            Rational temp = *this;
            temp /= r;
            return temp;
        }

#if 0

        Rational operator+() const
        {
            return *this;
        }

        Rational operator-() const
        {
            return Rational(-r.num, r.den);
        }
#endif

        bool operator<(const Rational& r) const
        {
            if(num < zero() && r.num >= zero())
                return true;
            if(num >= zero() && r.num <= zero())
                return false;

            Int gcd1 = gcd(num, r.num);
            Int gcd2 = gcd(r.den, den);
            return
                (num / gcd1) * (r.den / gcd2)
                < (den / gcd2) * (r.num / gcd1);
        }

        inline bool operator<=(const Rational& r) const
        {
            return (*this == r) || (*this < r);
        }

        inline bool operator==(const Rational& r) const
        {
            return (num == r.num && den == r.den);
        }

        inline bool operator!=(const Rational& r) const
        {
            return (num != r.num || den != r.den);
        }

        inline bool operator>(const Rational& r) const
        {
            return !(*this <= r);
        }

        inline bool operator>=(const Rational& r) const
        {
            return !(*this < r);
        }

        Rational reciprocal() const
        {
            return Rational(den, num);
        }

        void serialize(
            Stream *inStream, size_t inLevel, Endian inEndian) const
        {
            write<Int>(inStream, num, inEndian);
            write<Int>(inStream, den, inEndian);
        }

        void deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            num = read<Int>(inStream, inEndian);
            den = read<Int>(inStream, inEndian);
        }

    private:
        static inline const Int& zero()
        {
            static Int _zero(0);
            return _zero;
        }

        static Int gcd(Int n, Int m)
        {
            if(n < zero()) n = zero() - n;
            if(m < zero()) m = zero() - m;

            for(;;)
            {
                if(m == zero())
                    return n;
                n %= m;
                if(n == zero())
                    return m;
                m %= n;
            }
        }

        static Int lcm(Int n, Int m)
        {
            if(n == zero() || n == zero())
                return zero();
            n /= gcd(n, m);
            n *= m;
            if(n < zero())
                return -n;
            return n;
        }
    };

    template<typename Int> struct DataTraits< Rational<Int> >
    {
        static const CopyPolicy
            copyPolicy = byMemcpy; 
        static const StoragePolicy
            storagePolicy = byClassMethods; 
    };

    typedef Rational<uint32_t> TIFF_RATIONAL;

    typedef Rational<int32_t> TIFF_SRATIONAL;

    template<> TIFF_RATIONAL swap<TIFF_RATIONAL>(const TIFF_RATIONAL& num);
    template<> TIFF_SRATIONAL swap<TIFF_SRATIONAL>(const TIFF_SRATIONAL& num);
}

#endif // _cel_rational_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.