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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
/* NNC_Polyhedron class declaration.
Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
Copyright (C) 2010-2011 BUGSENG srl (http://bugseng.com)
This file is part of the Parma Polyhedra Library (PPL).
The PPL 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.
The PPL 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, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
For the most up-to-date information see the Parma Polyhedra Library
site: http://www.cs.unipr.it/ppl/ . */
#ifndef PPL_NNC_Polyhedron_defs_hh
#define PPL_NNC_Polyhedron_defs_hh 1
#include "C_Polyhedron.types.hh"
#include "NNC_Polyhedron.types.hh"
#include "Polyhedron.defs.hh"
#include "Grid.types.hh"
//! A not necessarily closed convex polyhedron.
/*! \ingroup PPL_CXX_interface
An object of the class NNC_Polyhedron represents a
<EM>not necessarily closed</EM> (NNC) convex polyhedron
in the vector space \f$\Rset^n\f$.
\note
Since NNC polyhedra are a generalization of closed polyhedra,
any object of the class C_Polyhedron can be (explicitly) converted
into an object of the class NNC_Polyhedron.
The reason for defining two different classes is that objects of
the class C_Polyhedron are characterized by a more efficient
implementation, requiring less time and memory resources.
*/
class Parma_Polyhedra_Library::NNC_Polyhedron : public Polyhedron {
public:
//! Builds either the universe or the empty NNC polyhedron.
/*!
\param num_dimensions
The number of dimensions of the vector space enclosing the NNC polyhedron;
\param kind
Specifies whether a universe or an empty NNC polyhedron should be built.
\exception std::length_error
Thrown if \p num_dimensions exceeds the maximum allowed space dimension.
Both parameters are optional:
by default, a 0-dimension space universe NNC polyhedron is built.
*/
explicit NNC_Polyhedron(dimension_type num_dimensions = 0,
Degenerate_Element kind = UNIVERSE);
//! Builds an NNC polyhedron from a system of constraints.
/*!
The polyhedron inherits the space dimension of the constraint system.
\param cs
The system of constraints defining the polyhedron.
*/
explicit NNC_Polyhedron(const Constraint_System& cs);
//! Builds an NNC polyhedron recycling a system of constraints.
/*!
The polyhedron inherits the space dimension of the constraint system.
\param cs
The system of constraints defining the polyhedron. It is not
declared <CODE>const</CODE> because its data-structures may be
recycled to build the polyhedron.
\param dummy
A dummy tag to syntactically differentiate this one
from the other constructors.
*/
NNC_Polyhedron(Constraint_System& cs, Recycle_Input dummy);
//! Builds an NNC polyhedron from a system of generators.
/*!
The polyhedron inherits the space dimension of the generator system.
\param gs
The system of generators defining the polyhedron.
\exception std::invalid_argument
Thrown if the system of generators is not empty but has no points.
*/
explicit NNC_Polyhedron(const Generator_System& gs);
//! Builds an NNC polyhedron recycling a system of generators.
/*!
The polyhedron inherits the space dimension of the generator system.
\param gs
The system of generators defining the polyhedron. It is not
declared <CODE>const</CODE> because its data-structures may be
recycled to build the polyhedron.
\param dummy
A dummy tag to syntactically differentiate this one
from the other constructors.
\exception std::invalid_argument
Thrown if the system of generators is not empty but has no points.
*/
NNC_Polyhedron(Generator_System& gs, Recycle_Input dummy);
//! Builds an NNC polyhedron from a system of congruences.
/*!
The polyhedron inherits the space dimension of the congruence system.
\param cgs
The system of congruences defining the polyhedron. It is not
declared <CODE>const</CODE> because its data-structures may be
recycled to build the polyhedron.
*/
explicit NNC_Polyhedron(const Congruence_System& cgs);
//! Builds an NNC polyhedron recycling a system of congruences.
/*!
The polyhedron inherits the space dimension of the congruence
system.
\param cgs
The system of congruences defining the polyhedron. It is not
declared <CODE>const</CODE> because its data-structures may be
recycled to build the polyhedron.
\param dummy
A dummy tag to syntactically differentiate this one
from the other constructors.
*/
NNC_Polyhedron(Congruence_System& cgs, Recycle_Input dummy);
//! Builds an NNC polyhedron from the C polyhedron \p y.
/*!
\param y
The C polyhedron to be used;
\param complexity
This argument is ignored.
*/
explicit NNC_Polyhedron(const C_Polyhedron& y,
Complexity_Class complexity = ANY_COMPLEXITY);
//! Builds an NNC polyhedron out of a box.
/*!
The polyhedron inherits the space dimension of the box
and is the most precise that includes the box.
\param box
The box representing the polyhedron to be built;
\param complexity
This argument is ignored as the algorithm used has
polynomial complexity.
\exception std::length_error
Thrown if the space dimension of \p box exceeds the maximum allowed
space dimension.
*/
template <typename Interval>
explicit NNC_Polyhedron(const Box<Interval>& box,
Complexity_Class complexity = ANY_COMPLEXITY);
//! Builds an NNC polyhedron out of a grid.
/*!
The polyhedron inherits the space dimension of the grid
and is the most precise that includes the grid.
\param grid
The grid used to build the polyhedron.
\param complexity
This argument is ignored as the algorithm used has
polynomial complexity.
*/
explicit NNC_Polyhedron(const Grid& grid,
Complexity_Class complexity = ANY_COMPLEXITY);
//! Builds a NNC polyhedron out of a BD shape.
/*!
The polyhedron inherits the space dimension of the BD shape
and is the most precise that includes the BD shape.
\param bd
The BD shape used to build the polyhedron.
\param complexity
This argument is ignored as the algorithm used has
polynomial complexity.
*/
template <typename U>
explicit NNC_Polyhedron(const BD_Shape<U>& bd,
Complexity_Class complexity = ANY_COMPLEXITY);
//! Builds a NNC polyhedron out of an octagonal shape.
/*!
The polyhedron inherits the space dimension of the octagonal shape
and is the most precise that includes the octagonal shape.
\param os
The octagonal shape used to build the polyhedron.
\param complexity
This argument is ignored as the algorithm used has
polynomial complexity.
*/
template <typename U>
explicit NNC_Polyhedron(const Octagonal_Shape<U>& os,
Complexity_Class complexity = ANY_COMPLEXITY);
//! Ordinary copy constructor.
NNC_Polyhedron(const NNC_Polyhedron& y,
Complexity_Class complexity = ANY_COMPLEXITY);
/*! \brief
The assignment operator.
(\p *this and \p y can be dimension-incompatible.)
*/
NNC_Polyhedron& operator=(const NNC_Polyhedron& y);
//! Assigns to \p *this the C polyhedron \p y.
NNC_Polyhedron& operator=(const C_Polyhedron& y);
//! Destructor.
~NNC_Polyhedron();
/*! \brief
If the poly-hull of \p *this and \p y is exact it is assigned
to \p *this and <CODE>true</CODE> is returned,
otherwise <CODE>false</CODE> is returned.
\exception std::invalid_argument
Thrown if \p *this and \p y are dimension-incompatible.
*/
bool poly_hull_assign_if_exact(const NNC_Polyhedron& y);
//! Same as poly_hull_assign_if_exact(y).
bool upper_bound_assign_if_exact(const NNC_Polyhedron& y);
};
#include "NNC_Polyhedron.inlines.hh"
#endif // !defined(PPL_NNC_Polyhedron_defs_hh)
|
