LpDataBase.h

Go to the documentation of this file.

#ifndef LPPARSER_DATABASE_H
#define LPPARSER_DATABASE_H

#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cassert>
#include <limits>
#include <limbo/math/Math.h>

namespace LpParser {

using std::cout;
using std::endl;
using std::cerr;
using std::string; 
using std::vector;
using std::pair;
using std::make_pair;
using std::ostringstream;
typedef int int32_t;
typedef unsigned int uint32_t;
typedef long int64_t;

typedef std::vector<int64_t> IntegerArray; 
typedef std::vector<std::string> StringArray; 

#if 0
class IntegerArray : public vector<int64_t>
{
    public: 
        typedef vector<int64_t> base_type;
        using base_type::size_type;
        using base_type::value_type;
        using base_type::allocator_type;

        IntegerArray(const allocator_type& alloc = allocator_type())
            : base_type(alloc) {}
        IntegerArray(size_type n, const value_type& val, const allocator_type& alloc = allocator_type())
            : base_type(n, val, alloc) {}
};

class StringArray : public vector<string>
{
    public: 
        typedef vector<string> base_type;
        using base_type::size_type;
        using base_type::value_type;
        using base_type::allocator_type;

        StringArray(const allocator_type& alloc = allocator_type())
            : base_type(alloc) {}
        StringArray(size_type n, const value_type& val, const allocator_type& alloc = allocator_type())
            : base_type(n, val, alloc) {}
};
#endif

struct Term 
{
    double coef; 
    string var; 

    Term(double c, string const& v) : coef(c), var(v) {}
};

typedef std::vector<Term> TermArray; 

// temporary data structures to hold parsed data 

// forward declaration
class LpDataBase
{
    public:
        virtual void add_variable(string const& vname, 
                double l = limbo::lowest<double>(), 
                double r = std::numeric_limits<double>::max()) = 0;
        virtual void add_constraint(string const& cname, TermArray const& terms, char compare, double constant) = 0; 
        virtual void add_objective(bool minimize, TermArray const& terms) = 0;
        virtual void set_integer(string const& vname, bool binary) = 0; 
};

} // namespace DefParser

#endif