Settings.cc

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of bande.
 *
 *  bande 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.
 *
 *  bande 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/>.
 */


/**
 * @file
 * Implementation of class bande::Settings.
 */

#include "bande.hh"

namespace bande {

  /**
   * Constructor.
   */
  Settings::Settings()
    : inFile(0)
    , outFile(0)
  {
  }

  /**
   * Destructor.
   */
  Settings::~Settings() {
  }

  /**
   * @var Settings::opts
   * List of command line options.
   * This list should be kept in sync with the usage() description.
   */
  const struct option Settings::opts[] = {
    {"help", no_argument, NULL, 'h'},
    {"output", required_argument, NULL, 'o'},
    {"debug", optional_argument, NULL, 'D'},
    { 0, 0, 0, 0 }
  };

  /**
   * Prints usage description and exits.
   *
   * This information can be displayed by passing the command line
   * argument @c --help.
   *
   * @param prog the name with which the program was executed,
   *             @c argv[0].
   * @param out the stream to which usage information is printed.
   * @param ret the return code with which the program terminates.
   */
  void Settings::usage(char* prog, std::ostream& out, int ret) {
    out << "Usage:   " << prog << " [OPTIONS] FILE\n"
        << "Options: \n"
        << " -h --help         Display this help\n"
        << " -o --output=STR   Write solutions to this file\n"
        << " -D --debug[=INT]  Set debug message mask\n"
      ;
    exit(ret);
  }

  /**
   * Global debug bit mask.
   * The value of this bit mask can be specified on the command line.
   * At the moment only the least significant bit, 1, has any
   * meaning. It enables tracing of the branching algorithm in
   * BranchControl::branch().
   */
  unsigned Settings::debug = 0;

  /**
   * Parse command line arguments.
   * @param argc the number of command line arguments.
   * @param argv an array of command line arguments.
   */
  void Settings::args(int argc, char** argv) {
    int opt;
    while ((opt = getopt_long(argc, argv, "ho:D::", opts, NULL)) != -1) {
      switch (opt) {

      case 'h':
        usage(argv[0], std::cout, EXIT_SUCCESS);

      case 'o':
        outFile = optarg;
        break;

      case 'D':
#ifdef NDEBUG
        std::cerr << "Debug code has been disabled." << std::endl;
#else
        if (optarg) debug = atoi(optarg);
        else debug = (unsigned)-1;
#endif
        break;

      default:
        usage(argv[0], std::cerr, EXIT_FAILURE);

      }
    }
    switch (argc - optind) {
    case 1:
      inFile = argv[optind];
      break;
    case 0:
      inFile = "/dev/stdin";
      break;
    default:
      std::cerr << "Invalid number of arguments" << std::endl;
      usage(argv[0], std::cerr, EXIT_FAILURE);
    }
  }

  /**
   * Execute appropriate operations according to command line.
   *
   * Once all settings are in place, This method is called in order to
   * run the requested command. Currently that means reading the
   * requested input file and enumerating all solutions for it.
   *
   * @bug There is no check whether the problem instance is
   * bounded. The branching process assumes that each LP instance is
   * either infeasible or allows for an optimal solution. Enumeration
   * on an unbounded instance doesn't make too much sense. To be
   * generally applicable there should be one check to ensure that the
   * problem is bounded.
   */
  void Settings::run() {
    CoinSeedRandom(42); // produce deterministic reproducible results
    std::cerr << std::setprecision(std::numeric_limits<double>::digits10+2);
    Solutions sols;
    if (outFile) sols.writeToFile(outFile);
    BranchControl bc(sols);
    bc.getIP().readMps(inFile);
    bc.getIP().randomizeObjective();
    bc.run(); // Everything is ready, lets go hunt some solutions.
  }

}

---