src/LocARNA/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