LrsWrapper.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 __LRSWrapper_WRAPPER__H__
#define __LRSWrapper_WRAPPER__H__
 
#include <chrono>
#include <cstdio>
#include <fcntl.h>
#include <fstream>
#include <vector>
 
#include <agrum/agrum.h>
 
#include <agrum/base/core/math/rational.h>
 
#include <unordered_set>
 
// we force MP (not long or GMP)
#undef LONG
#undef LRSLONG
#undef GMP
#define MP
// lrs stuff
extern "C" {
#include <agrum/base/external/lrslib/lrslib.h>
}
/* *** from lrs, we need to know BASE to read multiple precision integers *** */
#ifdef B32
/*32 bit machines */
#  define FORMAT   "%4.4lu"
#  define MAXD     2147483647L
#  define BASE     10000L
#  define BASE_DIG 4
#  define INTSIZE  8L
#  define BIT      "32bit"
#else
/* 64 bit machines */
#  define MAXD     9223372036854775807L
#  define BASE     1000000000L
#  define FORMAT   "%9.9lu"
#  define BASE_DIG 9
#  define INTSIZE  16L
#  define BIT      "64bit"
#endif
 
// 64 bits for windows (long is 32 bits)
#ifdef _MSC_VER
typedef __int64          int64_t;
typedef unsigned __int64 uint64_t;
#else
#  include <stdint.h>
#endif
 
/* ************ */
 
#define enumStringify(name) #name
 
namespace gum {
  namespace credal {

    template < typename GUM_SCALAR >
    class LRSWrapper {
      using matrix = typename std::vector< std::vector< GUM_SCALAR > >;

      matrix _input_;

      matrix _output_;

      unsigned int _card_;

      std::unordered_set< int > _insertedModals_;

      unsigned int _vertices_;

      std::vector< std::vector< GUM_SCALAR > > _insertedVertices_;

      std::vector< GUM_SCALAR > _vertex_;

      enum class _states_ : char {
        none     = char(0),
        Hup      = char(1),
        Vup      = char(2),
        H2Vready = char(3),
        V2Hready = char(4),
      };

      _states_ _state_;

      GUM_SCALAR _volume_;

      const char* _setUpStateNames_[5] = {
          enumStringify(_states_::none),
          enumStringify(_states_::nHup),
          enumStringify(_states_::nVup),
          enumStringify(_states_::nH2Vready),
          enumStringify(_states_::nV2Hready),
      };

      mutable int _oldCout_;


      lrs_dic* _dic_;

      lrs_dat* _dat_;

      lrs_mp_vector _lrsOutput_;

      lrs_mp_matrix _Lin_;


 
      bool _getVolume_;
 
      bool _hull_;
 
      bool _polytope_;



      void _freeLrs_();

      void _initLrs_();

      void _fill_() const;

      void _getLRSWrapperOutput_(lrs_mp                  Nin,
                                 lrs_mp                  Din,
                                 std::vector< int64_t >& Num,
                                 std::vector< int64_t >& Den) const;

 
      public:

      LRSWrapper();

      ~LRSWrapper();



      const matrix& getInput() const;

      const matrix& getOutput() const;

      const unsigned int& getVerticesNumber() const;

      const GUM_SCALAR& getVolume() const;



      void setUpH(const Size& card);

      void setUpV(const Size& card, const Size& vertices);

      void tearDown();

      void nextHInput();



      void fillH(const GUM_SCALAR& min, const GUM_SCALAR& max, const Size& modal);

      void fillMatrix(const std::vector< std::vector< GUM_SCALAR > >& matrix);

      void fillV(const std::vector< GUM_SCALAR >& vertex);



      void H2V();

      void V2H();

      void computeVolume();

      void elimRedundVrep();


    };
 
  }   // namespace credal
}   // namespace gum
 
#include <agrum/CN/polytope/LrsWrapper_tpl.h>
 
#endif