/usr/include/coin/MP_boolean.hpp is in coinor-libflopc++-dev 1.0.6-3.1+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 | // ******************** FlopCpp **********************************************
// File: MP_boolean.hpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
// ****************************************************************************
#ifndef _MP_boolean_hpp_
#define _MP_boolean_hpp_
#include <vector>
using std::vector;
#include "MP_index.hpp"
namespace flopc {
class SUBSETREF;
/// @ingroup INTERNAL_USE
class Boolean_base {
friend class Handle<Boolean_base*>;
friend class MP_boolean;
public:
virtual bool evaluate() const = 0;
protected:
Boolean_base() : count(0) {}
virtual ~Boolean_base() {}
int count;
};
/** @brief Reference counted class for all "boolean" types of data.
@ingroup PublicInterface
This contains counters to ConstantBase pointers.
These pointers may be of any of the Boolean_base * type.
This can be a constant valued boolean as well.
@TODO explain SUBSETREF
*/
class MP_boolean : public Handle<Boolean_base*> {
public:
MP_boolean() : Handle<Boolean_base*>(0) {}
MP_boolean(bool b);
MP_boolean(const Constant& c);
MP_boolean(SUBSETREF& c);
MP_boolean(Boolean_base* r) : Handle<Boolean_base*>(r) {}
};
////////// Operators creating MP_boolean expressions /////////////////////
/** @brief For computing the logical negation of a boolean
@ingroup PublicInterface
This is used in the normal formation of an expression.
@param b boolean
@returns A boolean which evaluates to the negation of the input expression.
@todo true? haven't used it.
*/
MP_boolean operator!(const MP_boolean& b);
/** @brief For computing the logical AND of two booleans
@ingroup PublicInterface
This is used in the normal formation of an expression.
@param e1 first boolean
@param e2 second boolean
@returns A boolean which evaluates to true of both booleans are true.
@todo true? haven't used it.
*/
MP_boolean operator&&(const MP_boolean& e1, const MP_boolean& e2);
/** @brief For computing the logical OR of two booleans
@ingroup PublicInterface
This is used in the normal formation of an expression.
@param e1 first boolean
@param e2 second boolean
@returns A boolean which evaluates to true if either booleans are true.
@todo true? haven't used it.
*/
MP_boolean operator||(const MP_boolean& e1, const MP_boolean& e2);
// /** @brief boolean which returns true if all in domain evaluate to true.
// @ingroup PublicInterface
// This is used in the normal formation of an expression.
// @param d MP_domain to evaluate with
// @param b boolean expression to evaluate.
// @returns A boolean which evaluates to true all domain evaluations of the boolean
// evaluate to true.
// */
// MP_boolean alltrue(const MP_domain& d, const MP_boolean& b);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
The brief code below is a bit contrived, but the right hand side
illustrate the utility of combining an index expression.
<code>
MP_index i;
<br>MP_index j;
<br>MP_boolean &b = (i+5)<=(j);
</code>
*/
MP_boolean operator<=(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator<=(const Constant& e1, const Constant& e2);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression involving an MP_index
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
*/
MP_boolean operator<(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator<(const Constant& e1, const Constant& e2);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression involving an MP_index
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
*/
MP_boolean operator>=(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator>=(const Constant& e1, const Constant& e2);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression involving an MP_index
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
*/
MP_boolean operator>(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator>(const Constant& e1, const Constant& e2);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression involving an MP_index
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
*/
MP_boolean operator==(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator==(const Constant& e1, const Constant& e2);
/** @brief constructs a boolean evaluator using operator overloading
@ingroup PublicInterface
This is used in the normal formation of an expression.
This is useful when combining index expressions.
@param e1 is an index expression involving an MP_index
@param e2 second index expression
@li used in forming sets of tuples of index values, or subsets.
@todo improve this a bit?
*/
MP_boolean operator!=(const MP_index_exp& e1, const MP_index_exp& e2);
/** @brief constructs a boolean evaluator by comparing two constants.
@ingroup PublicInterface
This is used in the normal formation of an expression.
This utility of this is when comparing constants
@param e1 first constant expression
@param e2 second constant expression
*/
MP_boolean operator!=(const Constant& e1, const Constant& e2);
} // End of namespace flopc
#endif
|