finite_domain.hpp

#ifndef INFRARED_FINITEDOMAIN_HPP
#define INFRARED_FINITEDOMAIN_HPP
 
/*
 * InfraRed ---  A generic engine for Boltzmann sampling over constraint networks
 * (C) Sebastian Will, 2018
 *
 * This file is part of the InfraRed source code.
 *
 * InfraRed provides a generic framework for tree decomposition-based
 * Boltzmann sampling over constraint networks
 */
 
namespace ired {
 
    class FiniteDomain {
        public:
            explicit
            FiniteDomain(int domsize = 0)
                : lb_(0),
                  ub_(domsize-1) {
            }
 
            explicit
            FiniteDomain(std::pair<int,int> bounds)
                : lb_(bounds.first),
                  ub_(bounds.second) {
            }
 
            FiniteDomain(int lb, int ub)
                : lb_(lb),
                  ub_(ub) {
            }
 
            bool
            empty() const {
                return ub_ < lb_;
            }
 
            int
            size() const {
                if(empty())
                    return 0;
 
                return ub_ - lb_ + 1;
            }
 
            int
            lb() const {
                return lb_;
            }
 
            int
            ub() const {
                return ub_;
            }
 
            void
            inc(int & v) const {
                assert( (lb_-1) <= v && v <= ub_ );
                v++;
            }
 
            int
            undet() const {
                return lb() - 1;
            }
 
            bool
            in(int v) const {
                return lb_ <= v && v <= ub_;
            }
 
        private:
             int lb_; 
             int ub_; 
    };
 
    using FiniteDomainVector = std::vector<FiniteDomain>;
 
}
#endif