APRONXX 0.9.15
/home/mine/apron/apronxx/apxx_lincons1_inline.hh
Go to the documentation of this file.
1/* -*- C++ -*-
2 * apxx_lincons1_inline.hh
3 *
4 * APRON Library / C++ inline functions
5 *
6 * DO NOT INCLUDE THIS FILE DIRECTLY
7 *
8 * Copyright (C) Antoine Mine' 2007
9 *
10 */
11/* This file is part of the APRON Library, released under LGPL license
12 with an exception allowing the redistribution of statically linked
13 executables.
14
15 Please read the COPYING file packaged in the distribution.
16*/
17
18
19/* ================================= */
20/* lincons1 */
21/* ================================= */
22
23
24/* constructors */
25/* ============ */
26
27inline lincons1::lincons1(ap_lincons1_t p) : l(p)
28{}
29
30inline lincons1::lincons1(const environment& e, const lincons0& x)
31{
32 l = ap_lincons1_of_lincons0(const_cast<ap_environment_t*>(e.get_ap_environment_t()),
33 ap_lincons0_copy(const_cast<ap_lincons0_t*>(x.get_ap_lincons0_t())));
34}
35
36inline lincons1::lincons1(const environment& e, ap_constyp_t constyp)
37{
38 ap_linexpr1_t llin =
39 ap_linexpr1_make(const_cast<ap_environment_t*>(e.get_ap_environment_t()), AP_LINEXPR_SPARSE, 0);
40 l = ap_lincons1_make(constyp, &llin, NULL);
41}
42
43inline lincons1::lincons1(ap_constyp_t constyp, const linexpr1& lin)
44{
45 ap_linexpr1_t llin = ap_linexpr1_copy(const_cast<ap_linexpr1_t*>(lin.get_ap_linexpr1_t()));
46 l = ap_lincons1_make(constyp, &llin, NULL);
47}
48
49inline lincons1::lincons1(ap_constyp_t constyp, const linexpr1& lin, const scalar& modulo)
50{
51 ap_linexpr1_t llin = ap_linexpr1_copy(const_cast<ap_linexpr1_t*>(lin.get_ap_linexpr1_t()));
52 ap_scalar_t* mmodulo = ap_scalar_alloc_set(const_cast<ap_scalar_t*>(modulo.get_ap_scalar_t()));
53 l = ap_lincons1_make(constyp, &llin, mmodulo);
54}
55
56inline lincons1::lincons1(const environment& e, unsat x)
57{
58 l = ap_lincons1_make_unsat(const_cast<ap_environment_t*>(e.get_ap_environment_t()));
59}
60
61inline lincons1::lincons1(const lincons1& x)
62{
63 l = ap_lincons1_copy(const_cast<ap_lincons1_t*>(&x.l));
64}
65
66inline lincons1::lincons1(const lincons1& x, const environment& e)
67{
68 if (!x.has_linexpr())
69 throw std::invalid_argument("apron::lincons1::lincons1(const lincons1&, const environment&) empty expression");
70 bool r =
71 ap_lincons1_extend_environment(&l,
72 const_cast<ap_lincons1_t*>(&x.l),
73 const_cast<ap_environment_t*>(e.get_ap_environment_t()));
74 if (r) throw std::invalid_argument("apron::lincons1::lincons1(const lincons1&, const environment&) not a super-environment");
75}
76
77
78/* destructor */
79/* ========== */
80
81inline lincons1::~lincons1()
82{
83 ap_lincons1_clear(&l);
84}
85
86
87/* assignment */
88/* ========== */
89
90inline lincons1& lincons1::operator= (const lincons1& x)
91{
92 ap_lincons1_t ll = ap_lincons1_copy(const_cast<ap_lincons1_t*>(&x.l));
93 ap_lincons1_clear(&l);
94 l = ll;
95 return *this;
96}
97
98inline lincons1& lincons1::operator= (unsat x)
99{
100 ap_lincons1_t ll = ap_lincons1_make_unsat(ap_lincons1_envref(&l));
101 ap_lincons1_clear(&l);
102 l = ll;
103 return *this;
104}
105
106inline void lincons1::set_modulo(const scalar& c)
107{
108 get_lincons0().set_modulo(c);
109}
110
111inline void lincons1::set_linexpr(const linexpr1& c)
112{
113 get_lincons0().set_linexpr(c.get_linexpr0());
114}
115
116
117/* dimension operations */
118/* ==================== */
119
120inline void lincons1::extend_environment(const environment& e)
121{
122 if (!has_linexpr())
123 throw std::invalid_argument("apron::lincons1::extend_environment(const environment&) empty expression");
124 bool r =
125 ap_lincons1_extend_environment_with(&l,
126 const_cast<ap_environment_t*>(e.get_ap_environment_t()));
127 if (r) throw std::invalid_argument("apron::lincons1::extend_environment(const environment&) not a super-environment");
128
129}
130
131
132/* access */
133/* ====== */
134
135inline environment lincons1::get_environment() const
136{
137 return (ap_environment_copy(ap_lincons1_envref(const_cast<ap_lincons1_t*>(&l))));
138}
139
140inline const lincons0& lincons1::get_lincons0() const
141{
142 return reinterpret_cast<lincons0&>(*ap_lincons1_lincons0ref(const_cast<ap_lincons1_t*>(&l)));
143}
144
145inline lincons0& lincons1::get_lincons0()
146{
147 return reinterpret_cast<lincons0&>(*ap_lincons1_lincons0ref(&l));
148}
149
150inline size_t lincons1::size() const
151{
152 return get_lincons0().size();
153}
154
155inline ap_constyp_t& lincons1::get_constyp()
156{
157 return get_lincons0().get_constyp();
158}
159
160inline const ap_constyp_t& lincons1::get_constyp() const
161{
162 return get_lincons0().get_constyp();
163}
164
165inline bool lincons1::has_modulo() const
166{
167 return get_lincons0().has_modulo();
168}
169
170inline bool lincons1::has_linexpr() const
171{
172 return get_lincons0().has_linexpr();
173}
174
175inline scalar& lincons1::get_modulo()
176{
177 if (!has_modulo())
178 throw std::invalid_argument("apron::lincons1::get_modulo() empty scalar");
179 return get_lincons0().get_modulo();
180}
181
182inline const scalar& lincons1::get_modulo() const
183{
184 if (!has_modulo())
185 throw std::invalid_argument("apron::lincons1::get_modulo() empty scalar");
186 return get_lincons0().get_modulo();
187}
188
189inline linexpr1 lincons1::get_linexpr() const
190{
191 if (!has_linexpr())
192 throw std::invalid_argument("apron::lincons1::get_linexpr() empty expression");
193 linexpr0 ll = get_lincons0().get_linexpr();
194 return linexpr1(get_environment(),ll);
195}
196
197inline coeff& lincons1::get_cst()
198{
199 if (!has_linexpr())
200 throw std::invalid_argument("apron::lincons1::get_cst() empty expression");
201 return reinterpret_cast<coeff&>(*ap_lincons1_cstref(&l));
202}
203
204inline const coeff& lincons1::get_cst() const
205{
206 if (!has_linexpr())
207 throw std::invalid_argument("apron::lincons1::get_cst() empty expression");
208 return reinterpret_cast<coeff&>(*ap_lincons1_cstref(const_cast<ap_lincons1_t*>(&l)));
209}
210
211inline coeff& lincons1::operator[](const var& var)
212{
213 if (!has_linexpr())
214 throw std::invalid_argument("apron::lincons1::operator[](const var&) empty expression");
215 ap_coeff_t* x = ap_lincons1_coeffref(&l,
216 const_cast<ap_var_t>(var.get_ap_var_t()));
217 if (!x)
218 throw std::invalid_argument("apron::lincons1::operator[](const var&) variable not in environment");
219 return reinterpret_cast<coeff&>(*x);
220}
221
222inline const coeff& lincons1::operator[](const var& var) const
223{
224 if (!has_linexpr())
225 throw std::invalid_argument("apron::lincons1::operator[](const var&) empty expression");
226 ap_coeff_t* x = ap_lincons1_coeffref(const_cast<ap_lincons1_t*>(&l),
227 const_cast<ap_var_t>(var.get_ap_var_t()));
228 if (!x)
229 throw std::invalid_argument("apron::lincons1::operator[](const var&) variable not in environment");
230 return reinterpret_cast<coeff&>(*x);
231}
232
233
234/* print */
235/* ===== */
236
237inline std::ostream& operator<< (std::ostream& os, const lincons1& s)
238{
239 os << s.get_linexpr();
240 switch (s.get_constyp()) {
241 case AP_CONS_EQ: return os << " = 0";
242 case AP_CONS_SUPEQ: return os << " >= 0";
243 case AP_CONS_SUP: return os << " > 0";
244 case AP_CONS_EQMOD: return os << " = 0 mod " << s.get_modulo();
245 case AP_CONS_DISEQ: return os << " != 0";
246 default: throw std::invalid_argument("apron::operator<<(ostream&, const lincons1&) invalid constraint type");
247 }
248}
249
250inline void lincons1::print(FILE* stream) const
251{
252 ap_lincons1_fprint(stream, const_cast<ap_lincons1_t*>(&l));
253}
254
255
256/* tests */
257/* ===== */
258
259inline bool lincons1::is_unsat() const
260{
261 return ap_lincons1_is_unsat(const_cast<ap_lincons1_t*>(&l));
262}
263
264inline bool lincons1::is_linear() const
265{
266 return get_lincons0().is_linear();
267}
268
269inline bool lincons1::is_quasilinear() const
270{
271 return get_lincons0().is_quasilinear();
272}
273
274
275/* C-level compatibility */
276/* ===================== */
277
278inline const ap_lincons1_t* lincons1::get_ap_lincons1_t() const
279{
280 return &l;
281}
282
283inline ap_lincons1_t* lincons1::get_ap_lincons1_t()
284{
285 return &l;
286}
287
288
289
290
291/* ================================= */
292/* lincons1_array */
293/* ================================= */
294
295
296
297/* constructors */
298/* ============ */
299
300inline lincons1_array::lincons1_array(ap_lincons1_array_t& a) : a(a)
301{}
302
303inline lincons1_array::lincons1_array(const environment& e, const lincons0_array& x)
304{
305 size_t sz = x.size();
306 a = ap_lincons1_array_make(const_cast<ap_environment_t*>(e.get_ap_environment_t()), sz);
307 for (size_t i=0; i<sz; i++)
308 a.lincons0_array.p[i] = ap_lincons0_copy(&x.a.p[i]);
309}
310
311inline lincons1_array::lincons1_array(const environment& e, size_t size)
312{
313 a = ap_lincons1_array_make(const_cast<ap_environment_t*>(e.get_ap_environment_t()), size);
314}
315
316inline lincons1_array::lincons1_array(const lincons1_array& x)
317{
318 size_t sz = x.size();
319 a = ap_lincons1_array_make(x.get_environment().get_ap_environment_t(), sz);
320 for (size_t i=0; i<sz; i++)
321 a.lincons0_array.p[i] = ap_lincons0_copy(&x.a.lincons0_array.p[i]);
322}
323
324inline lincons1_array::lincons1_array(const lincons1_array& x, const environment& e)
325{
326 bool r =
327 ap_lincons1_array_extend_environment(&a,
328 const_cast<ap_lincons1_array_t*>(&x.a),
329 const_cast<ap_environment_t*>(e.get_ap_environment_t()));
330 if (r) throw std::invalid_argument("apron::lincons1_array::lincons1_array(const lincons1_array, const environment&) not a super-environment");
331}
332
333inline lincons1_array::lincons1_array(size_t sz, const lincons1 x[])
334{
335 if (sz<1) throw std::invalid_argument("apron::lincons1_array::lincons1_array(size_t, const lincons1) null size");
336 a = ap_lincons1_array_make(x[0].get_environment().get_ap_environment_t(), sz);
337 for (size_t i=0; i<sz; i++)
338 a.lincons0_array.p[i] = ap_lincons0_copy(const_cast<ap_lincons0_t*>
339 (x[i].get_lincons0().get_ap_lincons0_t()));
340}
341
342inline lincons1_array::lincons1_array(const std::vector<lincons1>& x)
343{
344 size_t sz = x.size();
345 if (sz<1) throw std::invalid_argument("apron::lincons1_array::lincons1_array(const vector<lincons1>&) null size");
346 a = ap_lincons1_array_make(x[0].get_environment().get_ap_environment_t(), sz);
347 for (size_t i=0; i<sz; i++)
348 a.lincons0_array.p[i] = ap_lincons0_copy(const_cast<ap_lincons0_t*>
349 (x[i].get_lincons0().get_ap_lincons0_t()));
350}
351
352
353/* destructor */
354/* ========== */
355
356inline lincons1_array::~lincons1_array()
357{
358 ap_lincons1_array_clear(&a);
359}
360
361
362/* assignment */
363/* ========== */
364
365inline lincons1_array& lincons1_array::operator= (const lincons1_array& x)
366{
367 if (this!=&x) {
368 size_t sz = x.size();
369 ap_lincons1_array_clear(&a);
370 a = ap_lincons1_array_make(x.get_environment().get_ap_environment_t(), sz);
371 for (size_t i=0; i<sz; i++)
372 a.lincons0_array.p[i] = ap_lincons0_copy(&x.a.lincons0_array.p[i]);
373 }
374 return *this;
375}
376
377inline lincons1_array& lincons1_array::operator= (const lincons1 x[])
378{
379 size_t sz = size();
380 for (size_t i=0; i<sz; i++) {
381 ap_lincons0_clear(&a.lincons0_array.p[i]);
382 a.lincons0_array.p[i] = ap_lincons0_copy(const_cast<ap_lincons0_t*>
383 (x[i].get_lincons0().get_ap_lincons0_t()));
384 }
385 return *this;
386}
387
388inline lincons1_array& lincons1_array::operator= (const std::vector<lincons1>& x)
389{
390 size_t size = x.size();
391 if (size<1) {
392 ap_lincons1_array_t aa = ap_lincons1_array_make(a.env,0);
393 ap_lincons1_array_clear(&a);
394 a = aa;
395 return *this;
396 }
397 ap_lincons1_array_clear(&a);
398 a = ap_lincons1_array_make(x[0].get_environment().get_ap_environment_t(), size);
399 for (size_t i=0; i<size; i++)
400 a.lincons0_array.p[i] = ap_lincons0_copy(const_cast<ap_lincons0_t*>
401 (x[i].get_lincons0().get_ap_lincons0_t()));
402 return *this;
403}
404
405
406/* dimension operations */
407/* ==================== */
408
409inline void lincons1_array::resize(size_t size)
410{
411 ap_lincons0_array_resize(&a.lincons0_array, size);
412}
413
414inline void lincons1_array::extend_environment(const environment& e)
415{
416 bool r =
417 ap_lincons1_array_extend_environment_with(&a,
418 const_cast<ap_environment_t*>(e.get_ap_environment_t()));
419 if (r) throw std::invalid_argument("apron::lincons1_array::extend_environment(const environment&) not a super-environment");
420}
421
422
423/* access */
424/* ====== */
425
426inline size_t lincons1_array::size() const
427{
428 return ap_lincons1_array_size(const_cast<ap_lincons1_array_t*>(&a));
429}
430
431inline environment lincons1_array::get_environment() const
432{
433 return (ap_environment_copy(ap_lincons1_array_envref(const_cast<ap_lincons1_array_t*>(&a))));
434}
435
436inline const lincons0_array& lincons1_array::get_lincons0_array() const
437{
438 return reinterpret_cast<lincons0_array&>(const_cast<ap_lincons0_array_t&>(a.lincons0_array));
439}
440
441inline lincons0_array& lincons1_array::get_lincons0_array()
442{
443 return reinterpret_cast<lincons0_array&>(a.lincons0_array);
444}
445
446inline lincons1 lincons1_array::get(size_t i) const
447{
448 if (i>=size()) throw std::out_of_range("apron::lincons1_array::get(size_t)");
449 ap_lincons1_t c = ap_lincons1_array_get(const_cast<ap_lincons1_array_t*>(&a),i);
450 return lincons1(ap_lincons1_copy(&c));
451}
452
453inline void lincons1_array::set(size_t i, const lincons1& x)
454{
455 if (i>=size()) throw std::out_of_range("apron::lincons1_array::set(size_t, const lincons1&)");
456 ap_lincons0_clear(&a.lincons0_array.p[i]);
457 a.lincons0_array.p[i] = ap_lincons0_copy(const_cast<ap_lincons0_t*>
458 (x.get_lincons0().get_ap_lincons0_t()));
459}
460
461
462/* conversion */
463/* ========== */
464
465inline lincons1_array::operator std::vector<lincons1>() const
466{
467 size_t sz = size();
468 lincons1 dummy(get_environment(),unsat());
469 std::vector<lincons1> v(sz,dummy);
470 for (size_t i=0;i<sz;i++) {
471 ap_lincons1_t c = ap_lincons1_array_get(const_cast<ap_lincons1_array_t*>(&a),i);
472 v[i] = ap_lincons1_copy(&c);
473 }
474 return v;
475}
476
477
478/* print */
479/* ===== */
480
481inline std::ostream& operator<< (std::ostream& os, const lincons1_array& s)
482{
483 size_t sz = s.size();
484 os << "{ ";
485 for (size_t i=0;i<sz;i++)
486 os << s.get(i) << "; ";
487 return os << "}";
488}
489
490inline void lincons1_array:: print(FILE* stream) const
491{
492 ap_lincons1_array_fprint(stream, const_cast<ap_lincons1_array_t*>(&a));
493}
494
495
496/* C-level compatibility */
497/* ===================== */
498
499inline const ap_lincons1_array_t* lincons1_array::get_ap_lincons1_array_t() const
500{
501 return &a;
502}
503
504inline ap_lincons1_array_t* lincons1_array::get_ap_lincons1_array_t()
505{
506 return &a;
507}
508
std::ostream & operator<<(std::ostream &os, const lincons1 &s)
Definition apxx_lincons1_inline.hh:237