aGrUM 3.1.1
a C++ library for (probabilistic) graphical models
errors.cpp
Go to the documentation of this file.
1/****************************************************************************
2 * This file is part of the aGrUM/pyAgrum library. *
3 * *
4 * Copyright (c) 2005-2026 by *
5 * - Pierre-Henri WUILLEMIN(_at_LIP6) *
6 * - Christophe GONZALES(_at_AMU) *
7 * *
8 * The aGrUM/pyAgrum library is free software; you can redistribute it *
9 * and/or modify it under the terms of either : *
10 * *
11 * - the GNU Lesser General Public License as published by *
12 * the Free Software Foundation, either version 3 of the License, *
13 * or (at your option) any later version, *
14 * - the MIT license (MIT), *
15 * - or both in dual license, as here. *
16 * *
17 * (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html) *
18 * *
19 * This aGrUM/pyAgrum library is distributed in the hope that it will be *
20 * useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
21 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
22 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE *
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, *
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR *
26 * OTHER DEALINGS IN THE SOFTWARE. *
27 * *
28 * See LICENCES for more details. *
29 * *
30 * SPDX-FileCopyrightText: Copyright 2005-2026 *
31 * - Pierre-Henri WUILLEMIN(_at_LIP6) *
32 * - Christophe GONZALES(_at_AMU) *
33 * SPDX-License-Identifier: LGPL-3.0-or-later OR MIT *
34 * *
35 * Contact : info_at_agrum_dot_org *
36 * homepage : http://agrum.gitlab.io *
37 * gitlab : https://gitlab.com/agrumery/agrum *
38 * *
39 ****************************************************************************/
40
41
49
50#include <agrum/PRM/o3prm/errors.h>
51
52#ifndef DOXYGEN_SHOULD_SKIP_THIS
53
54namespace gum {
55 namespace prm {
56 namespace o3prm {
57
58 void O3PRM_TYPE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
59 auto pos = val.position();
60 errors.addError(std::format("Error : Unknown type {}", val.label()),
61 pos.file(),
62 pos.line(),
63 pos.column());
64 }
65
66 void O3PRM_TYPE_AMBIGUOUS(const O3Label& val,
67 const std::vector< std::string >& matches,
68 ErrorsContainer& errors) {
69 const auto& pos = val.position();
70 std::string matchList;
71 for (std::size_t i = 0; i < matches.size() - 1; ++i) {
72 matchList += matches[i] + ", ";
73 }
74 matchList += matches.back();
75 errors.addError(
76 std::format("Error : Ambiguous name {}, found more than one elligible types: {}",
77 val.label(),
78 matchList),
79 pos.file(),
80 pos.line(),
81 pos.column());
82 }
83
84 void O3PRM_TYPE_RESERVED(const O3Label& val, ErrorsContainer& errors) {
85 const auto& pos = val.position();
86 errors.addError(std::format("Error : Type name {} is reserved", val.label()),
87 pos.file(),
88 pos.line(),
89 pos.column());
90 }
91
92 void O3PRM_TYPE_DUPPLICATE(const O3Label& val, ErrorsContainer& errors) {
93 const auto& pos = val.position();
94 errors.addError(std::format("Error : Type {} exists already", val.label()),
95 pos.file(),
96 pos.line(),
97 pos.column());
98 }
99
100 void O3PRM_TYPE_CYCLIC_INHERITANCE(const O3Label& sub_type,
101 const O3Label& super_type,
102 ErrorsContainer& errors) {
103 const auto& pos = sub_type.position();
104 errors.addError(std::format("Error : Cyclic inheritance between type {} and type {}",
105 sub_type.label(),
106 super_type.label()),
107 pos.file(),
108 pos.line(),
109 pos.column());
110 }
111
112 void
113 O3PRM_TYPE_UNKNOWN_LABEL(const O3Label& type, const O3Label& l, ErrorsContainer& errors) {
114 const auto& pos = l.position();
115 errors.addError(std::format("Error : Unknown label {} in {}", l.label(), type.label()),
116 pos.file(),
117 pos.line(),
118 pos.column());
119 }
120
121 void O3PRM_TYPE_INVALID_RANGE(const O3IntType& val, ErrorsContainer& errors) {
122 const auto& pos = val.position();
123 errors.addError(
124 std::format("Error : Invalid range {} -> {}", val.start().value(), val.end().value()),
125 pos.file(),
126 pos.line(),
127 pos.column());
128 }
129
130 void O3PRM_TYPE_INVALID_RANGE(const O3RealType& val, ErrorsContainer& errors) {
131 const auto& pos = val.position();
132 errors.addError(std::format("Error : Found {} values in range expected at least 3",
133 val.values().size()),
134 pos.file(),
135 pos.line(),
136 pos.column());
137 }
138
139 void O3PRM_CLASS_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
140 const auto& pos = val.position();
141 const auto msg = std::format("Error : Unknown class {}", val.label());
142 errors.addError(msg, pos.file(), pos.line(), pos.column());
143 GUM_ERROR(FatalError, msg)
144 }
145
146 void O3PRM_CLASS_AMBIGUOUS(const O3Label& val,
147 const std::vector< std::string >& matches,
148 ErrorsContainer& errors) {
149 const auto& pos = val.position();
150 std::string matchList;
151 for (std::size_t i = 0; i < matches.size() - 1; ++i) {
152 matchList += matches[i] + ", ";
153 }
154 matchList += matches.back();
155 errors.addError(std::format("Error : Name {} is ambiguous: {}", val.label(), matchList),
156 pos.file(),
157 pos.line(),
158 pos.column());
159 }
160
161 void O3PRM_CLASS_DUPLICATE(const O3Label& val, ErrorsContainer& errors) {
162 // Raised if duplicate type names
163 const auto& pos = val.position();
164 errors.addError(std::format("Error : Class name {} exists already", val.label()),
165 pos.file(),
166 pos.line(),
167 pos.column());
168 }
169
170 void O3PRM_CLASS_CYLIC_INHERITANCE(const O3Label& sub,
171 const O3Label& super,
172 ErrorsContainer& errors) {
173 // Cyclic inheritance
174 const auto& pos = sub.position();
175 errors.addError(std::format("Error : Cyclic inheritance between class {} and class {}",
176 sub.label(),
177 super.label()),
178 pos.file(),
179 pos.line(),
180 pos.column());
181 }
182
183 void O3PRM_CLASS_ATTR_IMPLEMENTATION(const O3Label& c,
184 const O3Label& i,
185 const O3Label& attr,
186 ErrorsContainer& errors) {
187 const auto& pos = attr.position();
188 errors.addError(std::format("Error : Class {} attribute {} does not respect interface {}",
189 c.label(),
190 attr.label(),
191 i.label()),
192 pos.file(),
193 pos.line(),
194 pos.column());
195 }
196
197 void O3PRM_CLASS_AGG_IMPLEMENTATION(const O3Label& c,
198 const O3Label& i,
199 const O3Label& attr,
200 ErrorsContainer& errors) {
201 const auto& pos = attr.position();
202 errors.addError(std::format("Error : Class {} aggregate {} does not respect interface {}",
203 c.label(),
204 attr.label(),
205 i.label()),
206 pos.file(),
207 pos.line(),
208 pos.column());
209 }
210
211 void O3PRM_CLASS_REF_IMPLEMENTATION(const O3Label& c,
212 const O3Label& i,
213 const O3Label& ref,
214 ErrorsContainer& errors) {
215 const auto& pos = ref.position();
216 errors.addError(std::format("Error : Class {} reference {} does not respect interface {}",
217 c.label(),
218 ref.label(),
219 i.label()),
220 pos.file(),
221 pos.line(),
222 pos.column());
223 }
224
225 void O3PRM_CLASS_MISSING_ATTRIBUTES(const O3Label& c,
226 const O3Label& i,
227 ErrorsContainer& errors) {
228 const auto& pos = c.position();
229 errors.addError(
230 std::format("Error : Class {} does not implement all of interface {} attributes",
231 c.label(),
232 i.label()),
233 pos.file(),
234 pos.line(),
235 pos.column());
236 }
237
238 void O3PRM_CLASS_DUPLICATE_REFERENCE(const O3Label& ref, ErrorsContainer& errors) {
239 const auto& pos = ref.position();
240 errors.addError(std::format("Error : Reference Slot name {} exists already", ref.label()),
241 pos.file(),
242 pos.line(),
243 pos.column());
244 }
245
246 void O3PRM_CLASS_SELF_REFERENCE(const O3Label& c,
247 const O3Label& ref,
248 ErrorsContainer& errors) {
249 const auto& pos = ref.position();
250 errors.addError(std::format("Error : Class {} cannot reference itself", c.label()),
251 pos.file(),
252 pos.line(),
253 pos.column());
254 }
255
256 void O3PRM_CLASS_ILLEGAL_SUB_REFERENCE(const O3Label& c,
257 const O3Label& sub,
258 ErrorsContainer& errors) {
259 const auto& pos = sub.position();
260 errors.addError(
261 std::format("Error : Class {} cannot reference subclass {}", c.label(), sub.label()),
262 pos.file(),
263 pos.line(),
264 pos.column());
265 }
266
267 void O3PRM_CLASS_PARENT_NOT_FOUND(const O3Label& parent, ErrorsContainer& errors) {
268 const auto& pos = parent.position();
269 errors.addError(std::format("Error : Parent {} not found", parent.label()),
270 pos.file(),
271 pos.line(),
272 pos.column());
273 }
274
275 void O3PRM_CLASS_ILLEGAL_PARENT(const O3Label& parent, ErrorsContainer& errors) {
276 const auto& pos = parent.position();
277 errors.addError(std::format("Error : Illegal parent {}", parent.label()),
278 pos.file(),
279 pos.line(),
280 pos.column());
281 }
282
283 void O3PRM_CLASS_LINK_NOT_FOUND(const O3Label& chain,
284 std::string_view s,
285 ErrorsContainer& errors) {
286 const auto& pos = chain.position();
287 errors.addError(std::format("Error : Link {} in chain {} not found", s, chain.label()),
288 pos.file(),
289 pos.line(),
290 pos.column());
291 }
292
293 void O3PRM_CLASS_ILLEGAL_CPT_SIZE(std::string_view c,
294 const O3Label& attr,
295 Size found,
296 Size expected,
297 ErrorsContainer& errors) {
298 const auto& pos = attr.position();
299 errors.addError(
300 std::format("Error : Illegal CPT size, expected {} found {} for attribute {}.{}",
301 expected,
302 found,
303 c,
304 attr.label()),
305 pos.file(),
306 pos.line(),
307 pos.column());
308 }
309
310 void O3PRM_CLASS_ILLEGAL_CPT_VALUE(std::string_view c,
311 const O3Label& attr,
312 const O3Formula& f,
313 ErrorsContainer& errors) {
314 const auto& pos = f.position();
315 auto msg = std::format("Error : Illegal CPT value \"{}\" in attribute {}.{}",
316 f.formula().formula(),
317 c,
318 attr.label());
319 try {
320 auto result = f.formula().result();
321 msg += std::format(", formula resolve to {}", result);
322 } catch (...) {
323 msg += std::format(", could not resolve the following formula: \"{}\"",
324 f.formula().formula());
325 }
326 errors.addError(msg, pos.file(), pos.line(), pos.column());
327 }
328
329 void O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1(std::string_view c,
330 const O3Label& attr,
331 float f,
332 ErrorsContainer& errors) {
333 const auto& pos = attr.position();
334 errors.addError(std::format("Error : PRMAttribute {}.{} CPT does not sum to 1, found {}",
335 c,
336 attr.label(),
337 f),
338 pos.file(),
339 pos.line(),
340 pos.column());
341 }
342
343 void O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1_WARNING(std::string_view c,
344 const O3Label& attr,
345 float f,
346 ErrorsContainer& errors) {
347 const auto& pos = attr.position();
348 errors.addWarning(
349 std::format("Warning : PRMAttribute {}.{} CPT does not sum to 1, found {}",
350 c,
351 attr.label(),
352 f),
353 pos.file(),
354 pos.line(),
355 pos.column());
356 }
357
358 void O3PRM_CLASS_ILLEGAL_RULE_SIZE(const O3RuleCPT::O3Rule& rule,
359 size_t found,
360 size_t expected,
361 ErrorsContainer& errors) {
362 const auto& pos = rule.first.front().position();
363 errors.addError(std::format("Error : Expected {} value(s), found {}", expected, found),
364 pos.file(),
365 pos.line(),
366 pos.column());
367 }
368
369 void O3PRM_CLASS_ILLEGAL_RULE_LABEL(const O3RuleCPT::O3Rule& rule,
370 const O3Label& label,
371 const O3Label& parent,
372 ErrorsContainer& errors) {
373 const auto& pos = label.position();
374 errors.addError(
375 std::format("Error : Label {} is not part of {} domain", label.label(), parent.label()),
376 pos.file(),
377 pos.line(),
378 pos.column());
379 }
380
381 void O3PRM_CLASS_WRONG_PARENT(const O3Label& prnt, ErrorsContainer& errors) {
382 const auto& pos = prnt.position();
383 errors.addError(std::format("Error : Illegal parent {}", prnt.label()),
384 pos.file(),
385 pos.line(),
386 pos.column());
387 }
388
389 void O3PRM_CLASS_WRONG_PARENT_TYPE(const O3Label& prnt,
390 std::string_view expected,
391 std::string_view found,
392 ErrorsContainer& errors) {
393 const auto& pos = prnt.position();
394 errors.addError(std::format("Error : Expected type {} for parent {}, found {}",
395 expected,
396 prnt.label(),
397 found),
398 pos.file(),
399 pos.line(),
400 pos.column());
401 }
402
403 void O3PRM_CLASS_ILLEGAL_OVERLOAD(const O3Label& elt,
404 const O3Label& c,
405 ErrorsContainer& errors) {
406 const auto& pos = elt.position();
407 errors.addError(std::format("Error : Illegal overload of element {} from class {}",
408 elt.label(),
409 c.label()),
410 pos.file(),
411 pos.line(),
412 pos.column());
413 }
414
415 void O3PRM_CLASS_AGG_PARAMETERS(const O3Label& agg,
416 Size expected,
417 Size found,
418 ErrorsContainer& errors) {
419 const auto& pos = agg.position();
420 errors.addError(std::format("Error : Expected {} parameters , found {}", expected, found),
421 pos.file(),
422 pos.line(),
423 pos.column());
424 }
425
426 void O3PRM_CLASS_AGG_PARAMETER_NOT_FOUND(const O3Label& agg,
427 const O3Label& param,
428 ErrorsContainer& errors) {
429 const auto& pos = param.position();
430 errors.addError(
431 std::format("Error : Parameter {} in aggregate {} does not match any expected values",
432 param.label(),
433 agg.label()),
434 pos.file(),
435 pos.line(),
436 pos.column());
437 }
438
439 void O3PRM_INTERFACE_ILLEGAL_ARRAY(const O3Label& val, ErrorsContainer& errors) {
440 const auto& pos = val.position();
441 errors.addError(std::format("Error : PRMAttribute {} can not be an array", val.label()),
442 pos.file(),
443 pos.line(),
444 pos.column());
445 }
446
447 void O3PRM_INTERFACE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
448 const auto& pos = val.position();
449 errors.addError(std::format("Error : Interface {} not found", val.label()),
450 pos.file(),
451 pos.line(),
452 pos.column());
453 }
454
455 void O3PRM_INTERFACE_AMBIGUOUS(const O3Label& val,
456 const std::vector< std::string >& matches,
457 ErrorsContainer& errors) {
458 const auto& pos = val.position();
459 std::string matchList;
460 for (std::size_t i = 0; i < matches.size() - 1; ++i) {
461 matchList += matches[i] + ", ";
462 }
463 matchList += matches.back();
464 errors.addError(std::format("Error : Name {} is ambiguous: {}", val.label(), matchList),
465 pos.file(),
466 pos.line(),
467 pos.column());
468 }
469
470 void O3PRM_INTERFACE_DUPLICATE(const O3Label& val, ErrorsContainer& errors) {
471 const auto& pos = val.position();
472 errors.addError(std::format("Error : Interface name {} exists already", val.label()),
473 pos.file(),
474 pos.line(),
475 pos.column());
476 }
477
478 void O3PRM_INTERFACE_DUPLICATE_ELEMENT(const O3InterfaceElement& elt,
479 ErrorsContainer& errors) {
480 const auto& pos = elt.type().position();
481 errors.addError(std::format("Error : Element {} already exists", elt.name().label()),
482 pos.file(),
483 pos.line(),
484 pos.column());
485 }
486
487 void O3PRM_INTERFACE_CYCLIC_INHERITANCE(const O3Label& sub,
488 const O3Label& super,
489 ErrorsContainer& errors) {
490 const auto& pos = super.position();
491 errors.addError(
492 std::format("Error : Cyclic inheritance between interface {} and interface {}",
493 sub.label(),
494 super.label()),
495 pos.file(),
496 pos.line(),
497 pos.column());
498 }
499
500 void O3PRM_INTERFACE_SELF_REFERENCE(const O3Interface& i,
501 const O3InterfaceElement& r,
502 ErrorsContainer& errors) {
503 const auto& pos = r.type().position();
504 errors.addError(
505 std::format("Error : Interface {} cannot reference itself", i.name().label()),
506 pos.file(),
507 pos.line(),
508 pos.column());
509 }
510
511 void O3PRM_INTERFACE_ILLEGAL_SUB_REFERENCE(const O3Interface& i,
512 const O3InterfaceElement& ref,
513 ErrorsContainer& errors) {
514 const auto& pos = ref.type().position();
515 errors.addError(std::format("Error : Interface {} cannot reference subinterface {}",
516 i.name().label(),
517 ref.type().label()),
518 pos.file(),
519 pos.line(),
520 pos.column());
521 }
522
523 void O3PRM_INTERFACE_ILLEGAL_OVERLOAD(const O3InterfaceElement& elt,
524 ErrorsContainer& errors) {
525 const auto& pos = elt.type().position();
526 errors.addError(std::format("Error : Illegal overload of element {}", elt.name().label()),
527 pos.file(),
528 pos.line(),
529 pos.column());
530 }
531
532 void O3PRM_REFERENCE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
533 const auto& pos = val.position();
534 errors.addError(std::format("Error : Reference Slot type {} not found", val.label()),
535 pos.file(),
536 pos.line(),
537 pos.column());
538 }
539
540 void O3PRM_REFERENCE_AMBIGUOUS(const O3Label& val,
541 const std::vector< std::string >& matches,
542 ErrorsContainer& errors) {
543 const auto& pos = val.position();
544 std::string matchList;
545 for (std::size_t i = 0; i < matches.size() - 1; ++i) {
546 matchList += matches[i] + ", ";
547 }
548 matchList += matches.back();
549 errors.addError(std::format("Error : Name {} is ambiguous: {}", val.label(), matchList),
550 pos.file(),
551 pos.line(),
552 pos.column());
553 }
554
555 void O3PRM_SYSTEM_INSTANTIATION_FAILED(const O3System& sys, ErrorsContainer& errors) {
556 const auto& pos = sys.name().position();
557 errors.addError(
558 std::format("Error : Could not instantiate the system, some reference slots must be "
559 "unassigned"),
560 pos.file(),
561 pos.line(),
562 pos.column());
563 }
564
565 void O3PRM_SYSTEM_NOT_A_CLASS(const O3Instance& i, ErrorsContainer& errors) {
566 const auto& pos = i.type().position();
567 errors.addError(std::format("Error : {} is not a class", i.type().label()),
568 pos.file(),
569 pos.line(),
570 pos.column());
571 }
572
573 void O3PRM_SYSTEM_DUPLICATE_INSTANCE(const O3Instance& i, ErrorsContainer& errors) {
574 const auto& pos = i.type().position();
575 errors.addError(std::format("Error : Instance {} already exists", i.name().label()),
576 pos.file(),
577 pos.line(),
578 pos.column());
579 }
580
581 void O3PRM_SYSTEM_NOT_A_PARAMETER(const O3InstanceParameter& param, ErrorsContainer& errors) {
582 const auto& pos = param.name().position();
583 errors.addError(std::format("Instance error : {} is not a parameter", param.name().label()),
584 pos.file(),
585 pos.line(),
586 pos.column());
587 }
588
589 void O3PRM_SYSTEM_PARAMETER_NOT_FOUND(const O3InstanceParameter& param,
590 ErrorsContainer& errors) {
591 const auto& pos = param.name().position();
592 errors.addError(std::format("Error : Parameter {} not found", param.name().label()),
593 pos.file(),
594 pos.line(),
595 pos.column());
596 }
597
598 void O3PRM_SYSTEM_PARAMETER_NOT_INT(const O3InstanceParameter& param,
599 ErrorsContainer& errors) {
600 const auto& pos = param.value().position();
601 errors.addError(std::format("Error : Parameter {} is an integer", param.name().label()),
602 pos.file(),
603 pos.line(),
604 pos.column());
605 }
606
607 void O3PRM_SYSTEM_PARAMETER_NOT_FLOAT(const O3InstanceParameter& param,
608 ErrorsContainer& errors) {
609 const auto& pos = param.value().position();
610 errors.addError(std::format("Error : Parameter {} is a float", param.name().label()),
611 pos.file(),
612 pos.line(),
613 pos.column());
614 }
615
616 void O3PRM_SYSTEM_INVALID_LEFT_VALUE(const O3Label& val, ErrorsContainer& errors) {
617 const auto& pos = val.position();
618 errors.addError(std::format("Error : Invalid left expression {}", val.label()),
619 pos.file(),
620 pos.line(),
621 pos.column());
622 }
623
624 void O3PRM_SYSTEM_INSTANCE_NOT_FOUND(const O3Label& i, ErrorsContainer& errors) {
625 const auto& pos = i.position();
626 errors.addError(std::format("Error : Instance {} not found", i.label()),
627 pos.file(),
628 pos.line(),
629 pos.column());
630 }
631
632 void O3PRM_SYSTEM_REFERENCE_NOT_FOUND(const O3Label& ref,
633 std::string_view type,
634 ErrorsContainer& errors) {
635 const auto& pos = ref.position();
636 errors.addError(
637 std::format("Error : Reference {} not found in class {}", ref.label(), type),
638 pos.file(),
639 pos.line(),
640 pos.column());
641 }
642
643 void O3PRM_SYSTEM_NOT_AN_ARRAY(const O3Label& val, ErrorsContainer& errors) {
644 const auto& pos = val.position();
645 errors.addError(std::format("Error : {} is not an array", val.label()),
646 pos.file(),
647 pos.line(),
648 pos.column());
649 }
650
651 void O3PRM_DEPRECATED_TYPE_WARNING(const O3Label& val, ErrorsContainer& errors) {
652 const auto& pos = val.position();
653 errors.addWarning(
654 std::format("Warning : {} is declared using a deprecated syntax.", val.label()),
655 pos.file(),
656 pos.line(),
657 pos.column());
658 }
659
660
661 } // namespace o3prm
662 } // namespace prm
663} // namespace gum
664
665#endif // DOXYGEN_SHOULD_SKIP_THIS
gum::prm::o3prm::O3Formula
The O3Formula is part of the AST of the O3PRM language.
Definition O3prm.h:107
gum::prm::o3prm::O3InstanceParameter
The O3InstanceParameter is part of the AST of the O3PRM language.
Definition O3prm.h:781
gum::prm::o3prm::O3Instance
The O3Instance is part of the AST of the O3PRM language.
Definition O3prm.h:813
gum::prm::o3prm::O3IntType
The O3IntType is part of the AST of the O3PRM language.
Definition O3prm.h:268
gum::prm::o3prm::O3InterfaceElement
The O3InterfaceElement is part of the AST of the O3PRM language.
Definition O3prm.h:344
gum::prm::o3prm::O3Interface
The O3Interface is part of the AST of the O3PRM language.
Definition O3prm.h:377
gum::prm::o3prm::O3Label
The O3Label is part of the AST of the O3PRM language.
Definition O3prm.h:194
gum::prm::o3prm::O3RealType
The O3RealType is part of the AST of the O3PRM language.
Definition O3prm.h:308
gum::prm::o3prm::O3RuleCPT::O3Rule
std::pair< O3LabelList, O3FormulaList > O3Rule
Definition O3prm.h:565
gum::prm::o3prm::O3System
The O3System is part of the AST of the O3PRM language.
Definition O3prm.h:851
errors.h
Functions for error messages.
GUM_ERROR
#define GUM_ERROR(type, msg)
Definition exceptions.h:76
gum::Size
std::size_t Size
In aGrUM, hashed values are unsigned long int.
Definition types.h:74
gum::prm
namespace for all probabilistic relational models entities
Definition agrum.h:68
gum
gum is the global namespace for all aGrUM entities
Definition agrum.h:46
aGrUM 3.1.1

© PHW&CG&others - 2022
DoXyGeN 1.16.1