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