LrsWrapper.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Pierre-Henri WUILLEMIN and Christophe GONZALES  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef __LRSWrapper_WRAPPER__H__
#define __LRSWrapper_WRAPPER__H__

#include <agrum/agrum.h>
#include <agrum/core/math/math.h>


#ifdef HAVE_UNISTD_H
#  include <unistd.h>
#else
#  include <agrum/core/mvsc/unistd.h>
#endif

#include <chrono>
#include <cstdio>
#include <fcntl.h>
#include <fstream>
#include <unordered_set>
#include <vector>

#include <agrum/core/math/rational.h>

// we force MP (not long or GMP)
#undef LONG
#undef LRSLONG
#undef GMP
#define MP
// lrs stuff
extern "C" {
#include <agrum/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 {
      private:
      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 __coutOff() const;

      void __coutOn() const;



      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/LrsWrapper_tpl.h>

#endif