infty_int.hh

#ifndef LOCARNA_INFTY_INT_HH
#define LOCARNA_INFTY_INT_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <algorithm>
#include <iosfwd>
#include <assert.h>

namespace LocARNA {

    class FiniteInt;
    class InftyInt;
    
    class TaintedInftyInt {
    public:
        typedef long int base_type;

    protected:
        base_type val; 
        
        static const base_type min_finity;

        static const base_type max_finity;
        
        static const base_type min_normal_neg_infty;
        
        static const base_type max_normal_pos_infty;
    public:
        
        TaintedInftyInt(): val(0) {
        }

        explicit
        TaintedInftyInt(const base_type &x)
            : val(x) {
        }
        
        static
        base_type
        min_finite() {
            return min_finity;
        }

        static
        base_type
        max_finite() {
            return max_finity;
        }
        
        bool
        is_neg_infty() const {
            return val < min_finity;
        }

        bool
        is_pos_infty() const {
            return val > max_finity;
        }

        bool
        is_finite() const {
            return min_finity <= val &&  val <= max_finity;
        }
        
        bool 
        is_normal() const {
            return min_normal_neg_infty <= val &&  val <= max_normal_pos_infty;
        }
        
        base_type 
        finite_value() const {
            assert(is_finite());
            return val;
        }

        TaintedInftyInt &
        operator =(const FiniteInt &x);

        friend
        bool
        operator ==(const TaintedInftyInt &x, const TaintedInftyInt &y);
        
        friend
        TaintedInftyInt
        operator +(const TaintedInftyInt &x, const FiniteInt &y);
        
        friend
        TaintedInftyInt
        operator -(const TaintedInftyInt &x, const FiniteInt &y);

        friend
        TaintedInftyInt
        operator +(const InftyInt &x, const InftyInt &y);
        
        friend 
        TaintedInftyInt
        operator -(const InftyInt &x, const InftyInt &y);
        
        friend
        TaintedInftyInt
        min(const TaintedInftyInt &x, const TaintedInftyInt &y);

        friend
        TaintedInftyInt
        max(const TaintedInftyInt &x, const TaintedInftyInt &y);

        friend
        bool
        operator > (const TaintedInftyInt &x, const TaintedInftyInt &y);

        friend
        bool
        operator < (const TaintedInftyInt &x, const TaintedInftyInt &y);

        friend
        bool
        operator >= (const TaintedInftyInt &x, const TaintedInftyInt &y);

        friend
        bool
        operator <= (const TaintedInftyInt &x, const TaintedInftyInt &y);


        friend class InftyInt;

        friend
        std::ostream &
        operator <<(std::ostream &out, const TaintedInftyInt &x);

    };
    
    class InftyInt : public TaintedInftyInt {
        
    public:
        
        static const InftyInt neg_infty;
        static const InftyInt pos_infty;
        
    private:
        void normalize() {
            //std::cout << "NORMALIZE" <<std::endl;
            if (is_neg_infty()) {
                val = neg_infty.val;
            } else if (is_pos_infty()) {
                val = pos_infty.val;
            }
        }
    public:
        
        InftyInt(): TaintedInftyInt() {
        }

        explicit
        InftyInt(const base_type &x):TaintedInftyInt(x) {
            assert(is_normal());
        }
        
        explicit
        InftyInt(const FiniteInt &x);
        
        InftyInt(const TaintedInftyInt &x) :TaintedInftyInt(x) {
            normalize();
        }

        InftyInt &
        operator =(TaintedInftyInt &x) {
            val = x.val;
            normalize();
            return *this;
        }

        InftyInt &
        operator +=(const FiniteInt &x);

        InftyInt &
        operator -=(const FiniteInt &x);


        friend
        InftyInt
        operator +(const InftyInt &x, const FiniteInt &y);
        
        friend
        InftyInt
        operator -(const InftyInt &x, const FiniteInt &y);
        
    };
    
    class FiniteInt : public InftyInt {
    public:

        FiniteInt(): InftyInt() {
        }
        
        FiniteInt(base_type x): InftyInt(x) {
            assert(is_finite());
        }
        
        const base_type &
        finite_value() const {
            return val;
        }
        
        friend
        FiniteInt
        operator +(const FiniteInt &x, const FiniteInt &y);

        friend
        FiniteInt
        operator -(const FiniteInt &x, const FiniteInt &y);
        
    };
    
    inline
    TaintedInftyInt
    operator +(const TaintedInftyInt &x, const FiniteInt &y) {
        TaintedInftyInt res(x);
        res.val+=y.val;
        return res;
    }
    
    inline
    TaintedInftyInt
    operator -(const TaintedInftyInt &x, const FiniteInt &y) {
        TaintedInftyInt res(x);
        res.val-=y.val;
        return res;
    }
    
    inline
    TaintedInftyInt
    operator +(const InftyInt &x, const InftyInt &y) {
        TaintedInftyInt res(x);
        res.val+=y.val;
        return res;    
    }
    
    inline
    TaintedInftyInt
    operator -(const InftyInt &x, const InftyInt &y) {
        TaintedInftyInt res(x);
        res.val-=y.val;
        return res;
    }


    inline
    InftyInt &
    InftyInt::operator +=(const FiniteInt &x) {
        val += x.val;
        return *this;
    }
    
    inline
    InftyInt &
    InftyInt::operator -=(const FiniteInt &x) {
        val -= x.val;
        return *this;
    }
    
    
    inline
    InftyInt
    operator +(const InftyInt &x, const FiniteInt &y) {
        InftyInt res(x);
        res.val+=y.val;
        return res;    
    }
    
    inline
    InftyInt
    operator -(const InftyInt &x, const FiniteInt &y) {
        InftyInt res(x);
        res.val-=y.val;
        return res;
    }

    inline
    FiniteInt
    operator +(const FiniteInt &x, const FiniteInt &y) {
        FiniteInt res(x);
        res.val+=y.val;
        return res;
    }

    inline
    FiniteInt
    operator -(const FiniteInt &x, const FiniteInt &y) {
        FiniteInt res(x);
        res.val-=y.val;
        return res;
    }

    inline
    bool
    operator ==(const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return x.val==y.val;
    }

    inline
    TaintedInftyInt &
    TaintedInftyInt::operator =(const FiniteInt &x) {
        val=x.val;
        return *this;
    }

    inline
    TaintedInftyInt
    min(const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return TaintedInftyInt(std::min(x.val,y.val));
    }
    
    inline
    TaintedInftyInt
    max(const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return TaintedInftyInt(std::max(x.val,y.val));
    }

    inline
    InftyInt::InftyInt(const FiniteInt &x): TaintedInftyInt(x) {
    }
    
    inline
    bool
    operator > (const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return x.val > y.val;
    }

    inline
    bool
    operator < (const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return x.val < y.val;
    }

    inline
    bool
    operator >= (const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return x.val >= y.val;
    }

    inline
    bool
    operator <= (const TaintedInftyInt &x, const TaintedInftyInt &y) {
        return x.val <= y.val;
    }




} // end namespace LocARNA


#endif