variable.hpp

Go to the documentation of this file.

/*
 * GHOST (General meta-Heuristic Optimization Solving Tool) is a C++ framework
 * designed to help developers to model and implement optimization problem
 * solving. It contains a meta-heuristic solver aiming to solve any kind of
 * combinatorial and optimization real-time problems represented by a CSP/COP/EF-CSP/EF-COP. 
 *
 * First developed to solve game-related optimization problems, GHOST can be used for
 * any kind of applications where solving combinatorial and optimization problems. In
 * particular, it had been designed to be able to solve not-too-complex problem instances
 * within some milliseconds, making it very suitable for highly reactive or embedded systems.
 * Please visit https://github.com/richoux/GHOST for further information.
 *
 * Copyright (C) 2014-2025 Florian Richoux
 *
 * This file is part of GHOST.
 * GHOST 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 3 of the License, or
 * (at your option) any later version.
 
 * GHOST 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 GHOST. If not, see http://www.gnu.org/licenses/.
 */
 
 
#pragma once
 
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
 
#include "thirdparty/randutils.hpp"
 
namespace ghost
{
    class Variable final
    {
        friend class SearchUnit;
        friend class ModelBuilder;
 
        std::vector<int> _domain; // The domain, i.e., the vector of values the variable can take.
        int _id; // Unique ID integer
        std::string _name;  // String to give a name to the variable, helpful to debug/trace.
 
        int _current_value; // Current value assigned to the variable.
        int _min_value; // minimal value in the domain
        int _max_value; // maximal value in the domain
 
        struct valueException : std::exception
        {
            int value;
            int min;
            int max;
            valueException( int value, int min, int max ) : value( value ), min( min ), max( max ) {}
            std::string message = "Wrong value " + std::to_string( value ) + " passed to Variable::set_value. The given value does not belong to the domain and/or is not be between "
                + std::to_string( min ) + " (included) and "
                + std::to_string( max ) + " (included).\n";
            const char* what() const noexcept { return message.c_str(); }
        };
 
        // Assign to the variable a random values from its domain.
        inline void pick_random_value( randutils::mt19937_rng& rng ) {  _current_value = rng.pick( _domain ); }
 
    public:
        Variable() = default;
 
        Variable( const std::vector<int>& domain,
                  int   index = 0,
                  const std::string& name = std::string() );
 
        Variable( int starting_value,
                  std::size_t size,
                  int   index = 0,
                  const std::string& name = std::string() );
 
        Variable( const std::vector<int>& domain,
                  const std::string& name );
 
        Variable( int starting_value,
                  std::size_t size,
                  const std::string& name );
 
        inline std::vector<int> get_full_domain() const { return _domain; }
 
        std::vector<int> get_partial_domain( int range ) const;
 
        inline int get_value() const { return _current_value; }
 
        inline void set_value( int value )
        {
            if( std::find( _domain.cbegin(), _domain.cend(), value ) == _domain.cend() )
                throw valueException( value, get_domain_min_value(), get_domain_max_value() );
 
            _current_value = value;
        }
 
        inline std::size_t get_domain_size() const { return _domain.size(); }
 
        inline int get_domain_min_value() const { return _min_value; }
 
        inline int get_domain_max_value() const { return _max_value; }
 
        inline std::string get_name() const { return _name; }
 
        inline int get_id() const { return _id; }
 
        friend std::ostream& operator<<( std::ostream& os, const Variable& v )
        {
            std::string domain = "";
            for( auto value : v.get_full_domain() )
                domain += std::to_string( value ) + std::string( ", " );
 
            return os
                << "Variable name: " << v._name
                << "\nId: " <<  v._id
                << "\nValue: " <<  v._current_value
                << "\nDomain: " << domain
                << "\n--------";
        }
    };
}