opbgen.cc

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of mqn2mps.
 *
 *  mqn2mps 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.
 *
 *  mqn2mps 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, see <http://www.gnu.org/licenses/>.
 */


#include <cassert>
#include <vector>
#include <iostream>
#include <fstream>
#include <limits>

#include "driver.hh"
#include "bounds.hh"
#include "mipgen.hh"
#include "opbgen.hh"

/**
 * @file
 * Implementation of class opbgen
 */

/**
 * Constructor.
 *
 * This constructor simply passes its parameter through to the base
 * class.
 *
 * @param d the driver, used to access configuration settings and
 *          input data.
 */
opbgen::opbgen(const driver& d) : mipgen(d) {
}

/**
 * Write OPBDP instance to output stream.
 *
 * This is the only interesting method in this whole class.
 *
 * @param out the stream to which output will be written.
 */
void opbgen::write(std::ostream& out) {
  size_t rows = row_names.size(), cols = col_names.size();
  int bits;
  for (bits = 1; drv.max_order >= (1 << bits); ++bits) ;
  out << "min:";
  for (size_t col = modcount; col < cols; ++col) {
    for (int bit = bits - 1; bit >= 0; --bit) {
      out << " " << std::showpos << (1 << bit) << std::noshowpos
          << "*" << col_names[col] << "_" << bit;
    }
  }
  out << ";" << std::endl;
  for (size_t row = 0; row < rows; ++row) {
    int mod = 0, modcol = -1;
    for (size_t col = 0; col < modcount; ++col) {
      if (matrix[row][col]) {
        assert(mod == 0);
        modcol = col;
        mod = matrix[row][col];
      }
    }
    if (mod) {
      for (size_t col = modcount; col < cols; ++col) {
        matrix[row][col] = realmod(matrix[row][col], mod);
      }
      if (row_bounds[row].lower_type != bounds::infinite)
        row_bounds[row].lower_value = 
          realmod(row_bounds[row].lower_value, mod) + drv.max_order * mod;
      if (row_bounds[row].upper_type != bounds::infinite)
        row_bounds[row].upper_value = 
          realmod(row_bounds[row].upper_value, mod) + drv.max_order * mod;
    }
    for (int side = 0; side < 2; ++side) {
      out << row_names[row] << ":";
      for (size_t col = 0; col < cols; ++col) {
        int c1 = matrix[row][col];
        // if (!c1) continue;
        for (int bit = (col == 0 && drv.gamma_constraint) ? 0 : bits - 1;
             bit >= 0; --bit) {
          int c2 = c1 << bit;
          if (mod && col >= modcount) c2 %= mod;
          if (!c2) continue;
          out << " " << std::showpos << c2 << std::noshowpos
              << "*" << col_names[col] << "_" << bit;
        }
      }
      if (row_bounds[row].lower_value == row_bounds[row].upper_value) {
        out << " = " << row_bounds[row].lower_value << ";" << std::endl;
        break;
      }
      if (side == 0)
        out << " >= " << row_bounds[row].lower_value << ";" << std::endl;
      else
        out << " <= " << row_bounds[row].upper_value << ";" << std::endl;
    }
  }
}

---