bounds.hh

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/>.
 */


#ifndef BOUNDS_HH
#define BOUNDS_HH

/**
 * @file
 * Interface and implementation of class bounds.
 */

/**
 * A bounds object represents a pair of integer %bounds.
 * Each bound can have three types, as specified by the enum
 * bounds::bound_type.
 */
class bounds {
public:

  /**
   * Both %bounds have one of these types.
   */
  enum bound_type {

    /**
     * The bound is a real %constraint to be enforced.
     * This is a real bound that must be encoded in the output.
     */
    strict,

    /**
     * A hint for where working with unbounded values is difficult.
     * The bound given here will always be implied by a set of strict
     * %bounds. However as some output formats or solution finding
     * programs may benefit from additional %bounds being specified,
     * whenever some loose bound is known, it should be stated as a
     * hint.
     */
    hint,

    /**
     * There is no bound at this side, only infinity.
     * The value of the bound is irrelevant in this case.
     */
    infinite,
  };

  /**
   * The value of the lower bound, unless the lower bound is of type
   * infinite. 
   */
  int lower_value;

  /**
   * The value of the upper bound, unless the upper bound is of type
   * infinite.
   */
  int upper_value;

  /** The type of the lower bound. */
  bound_type lower_type;

  /** The type of the upper bound. */
  bound_type upper_type;

  /**
   * Initialize bounds to infinity in both directions.
   */
  bounds() : lower_value(std::numeric_limits<int>::min()),
             upper_value(std::numeric_limits<int>::max()),
             lower_type(infinite), upper_type(infinite) { }

  /**
   * Initialize bounds to a strict equality.
   * @param value the value that will become lower and upper bound.
   */
  bounds(int value) : lower_value(value), upper_value(value),
                      lower_type(strict), upper_type(strict) { }

  /**
   * Initialize bounds to a strict range.
   * @param lower the value of the lower bound.
   * @param upper the value of the upper bound.
   */
  bounds(int lower, int upper) : lower_value(lower), upper_value(upper),
                                 lower_type(strict), upper_type(strict) { }

  /**
   * Initialize bounds to given range and types.
   * @param lower the value of the lower bound.
   * @param lt the type of the lower bound.
   * @param upper the value of the upper bound.
   * @param ut the type of the upper bound.
   */
  bounds(int lower, bound_type lt, int upper, bound_type ut)
    : lower_value(lower), upper_value(upper),
      lower_type(lt), upper_type(ut) { }

  /**
   * Return lower bound.
   * @param want_limit whether a limit should be returned if it is
   *                   only a hint.
   * @param inf the value to be used for infinity.
   * @return the stored lower bound or the passed inf value.
   */
  int lower(bool want_limit, int inf) {
    if (lower_type == strict || (lower_type == hint && want_limit))
      return lower_value;
    else
      return inf;
  }

  /**
   * Return upper bound.
   * @param want_limit whether a limit should be returned if it is
   *                   only a hint.
   * @param inf the value to be used for infinity.
   * @return the stored lower bound or the passed inf value.
   */
  int upper(bool want_limit, int inf) {
    if (upper_type == strict || (upper_type == hint && want_limit))
      return upper_value;
    else
      return inf;
  }
  
  /**
   * Return lower bound as double.
   * @param want_limit whether a limit should be returned if it is
   *                   only a hint.
   * @param inf the value to be used for infinity.
   * @return the stored lower bound or the passed inf value.
   */
  double lower(bool want_limit = false,
               double inf = -std::numeric_limits<double>::infinity()) {
    if (lower_type == strict || (lower_type == hint && want_limit))
      return lower_value;
    else
      return inf;
  }

  /**
   * Return upper bound as double.
   * @param want_limit whether a limit should be returned if it is
   *                   only a hint.
   * @param inf the value to be used for infinity.
   * @return the stored lower bound or the passed inf value.
   */
  double upper(bool want_limit = false,
               double inf = std::numeric_limits<double>::infinity()) {
    if (upper_type == strict || (upper_type == hint && want_limit))
      return upper_value;
    else
      return inf;
  }

  /**
   * Set to strict equality.
   * The lower and upper bound will be set to the specified value.
   * @param value the value that will be the new lower and upper
   *              bound.
   * @return a reference to the left hand side of the assignment.
   */
  bounds& operator=(int value) {
    lower_value = upper_value = value;
    lower_type = upper_type = strict;
    return *this;
  }

};

#endif // ifndef BOUNDS_HH

---