idCondSet.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2025 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2025                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/
 

#ifndef GUM_LEARNING_ID_SET_H
#define GUM_LEARNING_ID_SET_H
 
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
#include <agrum/agrum.h>
 
#include <agrum/base/core/sequence.h>
#include <agrum/base/graphs/graphElements.h>
 
#include <type_traits>
 
namespace gum {
 
  namespace learning {
 
 
    class IdCondSet;

    class IdCondSetIterator {
      public:
      using iterator_category = std::forward_iterator_tag;
      using value_type        = NodeId;
      using reference         = NodeId&;
      using const_reference   = const NodeId&;
      using pointer           = NodeId*;
      using const_pointer     = const NodeId*;
      using difference_type   = std::ptrdiff_t;
 
 
      // ##########################################################################
      // ##########################################################################


      IdCondSetIterator();


      IdCondSetIterator(const IdCondSet& idset);

      IdCondSetIterator(const IdCondSetIterator& from);

      IdCondSetIterator(IdCondSetIterator&& from);

      virtual ~IdCondSetIterator();

 
 
      // ##########################################################################
      // ##########################################################################

      IdCondSetIterator& operator=(const IdCondSetIterator& from);

      IdCondSetIterator& operator=(IdCondSetIterator&& from);

      NodeId operator*() const;

      bool operator!=(const IdCondSetIterator& from) const;

      bool operator==(const IdCondSetIterator& from) const;

      IdCondSetIterator& operator++();

      IdCondSetIterator& operator+=(const std::size_t i);

      IdCondSetIterator operator+(const std::size_t i);

 
 
      // ##########################################################################
      // ##########################################################################

      std::size_t pos() const;

 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
      private:
      const Sequence< NodeId >* _seq_{nullptr};

      std::size_t _index_{std::size_t(0)};
 

      void _gotoEnd_();
 
      friend class IdCondSet;
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };

    class IdCondSet {
      public:
      using iterator            = IdCondSetIterator;
      using const_iterator      = IdCondSetIterator;
      using iterator_safe       = IdCondSetIterator;
      using const_iterator_safe = IdCondSetIterator;
 
      // ##########################################################################
      // ##########################################################################

      IdCondSet();


      IdCondSet(const std::vector< NodeId >& ids, const bool rhs_ids, const bool ordered_ids);


      IdCondSet(NodeId                       var1,
                const std::vector< NodeId >& rhs_ids,
                const bool                   ordered_rhs_ids = false);


      IdCondSet(NodeId                       var1,
                NodeId                       var2,
                const std::vector< NodeId >& rhs_ids,
                const bool                   ordered_lhs_vars,
                const bool                   ordered_rhs_ids = false);


      IdCondSet(NodeId                       var1,
                NodeId                       var2,
                NodeId                       var3,
                const std::vector< NodeId >& rhs_ids,
                const bool                   ordered_lhs_vars,
                const bool                   ordered_rhs_ids = false);

      IdCondSet(const IdCondSet& from);

      IdCondSet(IdCondSet&& from);

      virtual IdCondSet* clone() const;

      virtual ~IdCondSet();

 
 
      // ##########################################################################
      // ##########################################################################

      IdCondSet& operator=(const IdCondSet& from);

      IdCondSet& operator=(IdCondSet&& from);

      NodeId operator[](const std::size_t index) const;

      bool operator==(const IdCondSet& from) const;

      bool operator!=(const IdCondSet& from) const;

 
 
      // ##########################################################################
      // ##########################################################################

      iterator_safe beginSafe() const;

      const iterator_safe& endSafe() const;

      iterator begin() const;

      const iterator& end() const;

 
 
      // ##########################################################################
      // ##########################################################################

      const Sequence< NodeId >& ids() const;

      IdCondSet conditionalIdCondSet() const;

      std::size_t nbLHSIds() const;

      std::size_t nbRHSIds() const;

      bool contains(const IdCondSet& set) const;

      void clear();

      std::size_t size() const;


      std::size_t pos(const NodeId id) const;

      bool exists(const NodeId id) const;


      void erase(const NodeId id);

      bool hasConditioningSet() const;

      bool empty() const;

      std::string toString() const;

      std::pair< NodeSet, NodeSet > toNodeSets() const;

 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
      private:
      Sequence< NodeId > _ids_;

      std::size_t _nb_lhs_ids_{std::size_t(0)};

      IdCondSetIterator _end_safe_;
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };

    std::ostream& operator<<(std::ostream& stream, const IdCondSet& idset);
 
  } /* namespace learning */

  template <>
  class HashFunc< learning::IdCondSet >: public HashFuncBase< learning::IdCondSet > {
    public:
    static Size castToSize(const learning::IdCondSet& key);

    Size operator()(const learning::IdCondSet& key) const final;
  };
 
 
} /* namespace gum */
 
// include the inlined functions if necessary
#ifndef GUM_NO_INLINE
#  include <agrum/base/stattests/idCondSet_inl.h>
#endif /* GUM_NO_INLINE */
 
#endif /* GUM_LEARNING_ID_SET_H */