rational.hpp

Go to the documentation of this file.

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpniio is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpniio.  If not, see <http://www.gnu.org/licenses/>.
// ===========================================================================
//
// Created on: Jun 17, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
//
#pragma once

#include <iostream>
#include <pni/core/types.hpp>

namespace pni{
namespace io{
namespace tiff{


    template<typename T> class rational
    {
        protected:
            T _numerator;    
            T _denominator;  
        public:
            //=================constructors and destructor=================
            rational();
            rational(const rational &o);
            explicit rational(const T &,const T&);
            ~rational(){}

            //====================conversion operator=======================
            template<typename U> operator U()
            {
                return (U)((U)(_numerator))/((U)(_denominator));
            }

            //================assignment operator===========================
            virtual rational<T> &operator=(const rational<T> &r);

            void numerator(const T &v) { _numerator = v; }
            T numerator() const { return _numerator; } 

            void denominator(T &v) { _denominator = v; }
            T denominator() const { return _denominator; }

    };

    //=============implementation of template methods======================
    //implementation of the default constructor
    template<typename T> rational<T>::rational():
        _numerator(0),
        _denominator(0)
    { }

    //------------------------------------------------------------------------
    //implementation of the copy constructor
    template<typename T> rational<T>::rational(const rational<T> &r):
        _numerator(r._numerator),
        _denominator(r._denominator)
    { }

    //------------------------------------------------------------------------
    //implementation of the standard constructor
    template<typename T> rational<T>::rational(const T &n,const T &d):
        _numerator(n),
        _denominator(d)
    { }

    //------------------------------------------------------------------------
    //implementation of the copy assignment operator
    template<typename T> 
        rational<T> &rational<T>::operator=(const rational<T> &r)
    {
        if(this != &r){
            _numerator = r._numerator;
            _denominator = r._denominator;
        }
        return *this;
    }
    
    //------------------------------------------------------------------------
    //implementation of the output operator
    template<typename T> 
        std::ostream &operator<<(std::ostream &o,const rational<T> &r)
    {
        o<<r.numerator()<<"/"<<r.denominator();
        return o;
    }


    //some default types 
    typedef rational<pni::core::uint32> uirational;
    typedef rational<pni::core::int32> irational;

//end namespaces
}
}
}