CHR++: An efficient CHR system in C++ with don’t know non-determinism
This article introduces CHR++, an implementation of CHR (Constraint Handling Rules) in C++. CHR++ has been designed to be efficient, user-friendly, and to make it easier to model problems of NP (Non-deterministic Polynomial time) complexity class thanks to the support of don’t know non-determinism....
Uloženo v:
| Vydáno v: | Expert systems with applications Ročník 238; s. 121810 |
|---|---|
| Hlavní autor: | |
| Médium: | Journal Article |
| Jazyk: | angličtina |
| Vydáno: |
Elsevier Ltd
15.03.2024
Elsevier |
| Témata: | |
| ISSN: | 0957-4174, 1873-6793 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
| Abstract | This article introduces CHR++, an implementation of CHR (Constraint Handling Rules) in C++. CHR++ has been designed to be efficient, user-friendly, and to make it easier to model problems of NP (Non-deterministic Polynomial time) complexity class thanks to the support of don’t know non-determinism. CHR++ conforms to the refined semantics of CHR and provides a high-level syntax similar to the historical CHR implementations in Prolog. It is a powerful system that incorporates many of the high-level optimisations known to date. Like implementations made on top of Prolog, it handles don’t know non-determinism through support for the CHR extension. CHR++ is the first non-Prolog CHR system that natively supports don’t know non-determinism. It makes it easier to model constrained decision or optimisation problems and shows a significant gain in efficiency compared with CHR Prolog systems. It equals or exceeds the fastest CHR systems in Java and C, but is able to tackle a whole class of problems unattainable by those systems.
•CHR++ is a powerful implementation of CHR on top of the C++ language.•CHR++ allows to model and solve decision and optimisation problems.•CHR is a CHR extension which adds the don’t know non-determinism, to gives the ability to backtrack on past states.•The mutable variables provided with CHR++ allow the manipulation of logical variables with a value that can change over time.•CHR++ describes CHR logic rules in a format similar to formal semantics. |
|---|---|
| AbstractList | This article introduces CHR++, an implementation of CHR (Constraint Handling Rules) in C++. CHR++ has been designed to be efficient, user-friendly, and to make it easier to model problems of NP (Non-deterministic Polynomial time) complexity class thanks to the support of don’t know non-determinism. CHR++ conforms to the refined semantics of CHR and provides a high-level syntax similar to the historical CHR implementations in Prolog. It is a powerful system that incorporates many of the high-level optimisations known to date. Like implementations made on top of Prolog, it handles don’t know non-determinism through support for the CHR extension. CHR++ is the first non-Prolog CHR system that natively supports don’t know non-determinism. It makes it easier to model constrained decision or optimisation problems and shows a significant gain in efficiency compared with CHR Prolog systems. It equals or exceeds the fastest CHR systems in Java and C, but is able to tackle a whole class of problems unattainable by those systems. This article introduces CHR++, an implementation of CHR (Constraint Handling Rules) in C++. CHR++ has been designed to be efficient, user-friendly, and to make it easier to model problems of NP (Non-deterministic Polynomial time) complexity class thanks to the support of don’t know non-determinism. CHR++ conforms to the refined semantics of CHR and provides a high-level syntax similar to the historical CHR implementations in Prolog. It is a powerful system that incorporates many of the high-level optimisations known to date. Like implementations made on top of Prolog, it handles don’t know non-determinism through support for the CHR extension. CHR++ is the first non-Prolog CHR system that natively supports don’t know non-determinism. It makes it easier to model constrained decision or optimisation problems and shows a significant gain in efficiency compared with CHR Prolog systems. It equals or exceeds the fastest CHR systems in Java and C, but is able to tackle a whole class of problems unattainable by those systems. •CHR++ is a powerful implementation of CHR on top of the C++ language.•CHR++ allows to model and solve decision and optimisation problems.•CHR is a CHR extension which adds the don’t know non-determinism, to gives the ability to backtrack on past states.•The mutable variables provided with CHR++ allow the manipulation of logical variables with a value that can change over time.•CHR++ describes CHR logic rules in a format similar to formal semantics. |
| ArticleNumber | 121810 |
| Author | Barichard, Vincent |
| Author_xml | – sequence: 1 givenname: Vincent orcidid: 0000-0002-9306-2897 surname: Barichard fullname: Barichard, Vincent email: vincent.barichard@univ-angers.fr organization: Univ Angers, LERIA, SFR MATHSTIC, 2 Bd Lavoisier, Angers, F-49000, France |
| BackLink | https://univ-angers.hal.science/hal-04232684$$DView record in HAL |
| BookMark | eNp9kM1KAzEURoNUsK2-gKtspcyYv5lMxE0ZtBUKgug6pJOEpnYyMgkt3fkavp5P4gyjGxddXfj4zr2XMwEj33gDwDVGKUY4v92mJhxUShChKSa4wOgMjHHBaZJzQUdgjETGE4Y5uwCTELYIYY4QH4NFuXyZze7g3ENjrauc8RF2GQzHEE0NnYflbAYPLm6gbvz351eE7745wO6BRJto2tp5F-pLcG7VLpir3zkFb48Pr-UyWT0vnsr5KqkIEzExWS4EzRHVhSKMM1XYnBNVCcap4CxnONM60-vMisIabgtLNOaKmooJTu2aTsHNsHejdvKjdbVqj7JRTi7nK9lniBFK8oLtcdcthm7VNiG0xsrKRRVd42Or3E5iJHt5cit7ebKXJwd5HUr-oX-3TkL3A2Q6AXtnWhl6n5XRrjVVlLpxp_Af5CiIVQ |
| CitedBy_id | crossref_primary_10_1145_3728640 |
| Cites_doi | 10.1016/S1571-0661(04)80344-X 10.1016/S0743-1066(98)10005-5 10.1145/41625.41635 10.1007/BFb0055987 10.1017/S0269888900005798 10.1016/0743-1066(94)90033-7 10.1145/2422085.2422086 10.1007/978-3-540-27775-0_9 10.1080/088395100117043 |
| ContentType | Journal Article |
| Copyright | 2023 Elsevier Ltd Distributed under a Creative Commons Attribution 4.0 International License |
| Copyright_xml | – notice: 2023 Elsevier Ltd – notice: Distributed under a Creative Commons Attribution 4.0 International License |
| DBID | AAYXX CITATION 1XC |
| DOI | 10.1016/j.eswa.2023.121810 |
| DatabaseName | CrossRef Hyper Article en Ligne (HAL) |
| DatabaseTitle | CrossRef |
| DatabaseTitleList | |
| DeliveryMethod | fulltext_linktorsrc |
| Discipline | Computer Science |
| EISSN | 1873-6793 |
| ExternalDocumentID | oai:HAL:hal-04232684v1 10_1016_j_eswa_2023_121810 S0957417423023126 |
| GroupedDBID | --K --M .DC .~1 0R~ 13V 1B1 1RT 1~. 1~5 4.4 457 4G. 5GY 5VS 7-5 71M 8P~ 9JN 9JO AAAKF AABNK AACTN AAEDT AAEDW AAIAV AAIKJ AAKOC AALRI AAOAW AAQFI AARIN AAXUO AAYFN ABBOA ABFNM ABMAC ABMVD ABUCO ABYKQ ACDAQ ACGFS ACHRH ACNTT ACRLP ACZNC ADBBV ADEZE ADTZH AEBSH AECPX AEKER AENEX AFKWA AFTJW AGHFR AGJBL AGUBO AGUMN AGYEJ AHHHB AHJVU AHZHX AIALX AIEXJ AIKHN AITUG AJOXV ALEQD ALMA_UNASSIGNED_HOLDINGS AMFUW AMRAJ AOUOD APLSM AXJTR BJAXD BKOJK BLXMC BNSAS CS3 DU5 EBS EFJIC EFLBG EO8 EO9 EP2 EP3 F5P FDB FIRID FNPLU FYGXN G-Q GBLVA GBOLZ HAMUX IHE J1W JJJVA KOM LG9 LY1 LY7 M41 MO0 N9A O-L O9- OAUVE OZT P-8 P-9 P2P PC. PQQKQ Q38 ROL RPZ SDF SDG SDP SDS SES SEW SPC SPCBC SSB SSD SSL SST SSV SSZ T5K TN5 ~G- 29G 9DU AAAKG AAQXK AATTM AAXKI AAYWO AAYXX ABJNI ABKBG ABUFD ABWVN ABXDB ACLOT ACNNM ACRPL ACVFH ADCNI ADJOM ADMUD ADNMO AEIPS AEUPX AFJKZ AFPUW AGQPQ AIGII AIIUN AKBMS AKRWK AKYEP ANKPU APXCP ASPBG AVWKF AZFZN CITATION EFKBS EJD FEDTE FGOYB G-2 HLZ HVGLF HZ~ R2- SBC SET WUQ XPP ZMT ~HD 1XC |
| ID | FETCH-LOGICAL-c249t-e56993603d8a2474a8f672ac94739746415dd5db5f98fe7f8f2d17a3ec4973fb3 |
| ISSN | 0957-4174 |
| IngestDate | Tue Oct 14 20:45:27 EDT 2025 Sat Nov 29 07:07:06 EST 2025 Tue Nov 18 21:34:47 EST 2025 Fri Feb 23 02:34:37 EST 2024 |
| IsPeerReviewed | true |
| IsScholarly | true |
| Keywords | Constraint handling rules Constraint handling rules with disjunction Constraint processing C++ Constraint logic programming systems Domain specific languages |
| Language | English |
| License | Distributed under a Creative Commons Attribution 4.0 International License: http://creativecommons.org/licenses/by/4.0 |
| LinkModel | OpenURL |
| MergedId | FETCHMERGED-LOGICAL-c249t-e56993603d8a2474a8f672ac94739746415dd5db5f98fe7f8f2d17a3ec4973fb3 |
| ORCID | 0000-0002-9306-2897 |
| ParticipantIDs | hal_primary_oai_HAL_hal_04232684v1 crossref_citationtrail_10_1016_j_eswa_2023_121810 crossref_primary_10_1016_j_eswa_2023_121810 elsevier_sciencedirect_doi_10_1016_j_eswa_2023_121810 |
| PublicationCentury | 2000 |
| PublicationDate | 2024-03-15 |
| PublicationDateYYYYMMDD | 2024-03-15 |
| PublicationDate_xml | – month: 03 year: 2024 text: 2024-03-15 day: 15 |
| PublicationDecade | 2020 |
| PublicationTitle | Expert systems with applications |
| PublicationYear | 2024 |
| Publisher | Elsevier Ltd Elsevier |
| Publisher_xml | – name: Elsevier Ltd – name: Elsevier |
| References | Frühwirth, Herold, Küchenhoff, Provost, Lim, Monfroy, Wallace (b14) 1993 Wolf (b35) 2001 Abdennadher, Krämer, Saft, Schmauss (b1) 2002; 64 (pp. 111–119). Jaffar, Maher (b20) 1994; 19/20 Duck, Stuckey, de la Banda, Holzbaur (b8) 2004 Nogatz (b23) 2022 Nogatz, Frühwirth, Seipel (b24) 2018 Stéphan (b30) 2021 Frühwirth (b9) 1992 (b15) 2011 Wuille, P., Schrijvers, T., & Demoen, B. (2007). CCHR: the fastest CHR implementation, in C. In Ivanović, D. (2013). Implementing Constraint Handling Rules as a Domain-Specific Language Embedded in Java. In (pp. 3–17). Number CW 421 in Dept. Computer Science, Technical Report. Van Hentenryck (b31) 1991; 6 (pp. 120–136). Abdennadher, S., & Schütz, H. (1998). CHR: A Flexible Query Language. In Betz, Frühwirth (b6) 2013; 14 (pp. 1–14). Barichard (b3) 2022 Barichard, Behuet, Genest, Legeay, Lesaint (b4) 2022 Weert, Schrijvers, Demoen (b32) 2005 Frühwirth (b12) 2009 Weert, Sneyers, Demoen (b33) 2008 Barichard, Stéphan (b5) 2019 Jaffar, J., & Lassez, J.-L. (1987). Constraint Logic Programming. In Holzbaur, de la Banda, Stuckey, Duck (b17) 2004; 5 Schrijvers, T., & Warren, D. (2004). Constraint Handling Rules and Tabled Execution. In (pp. 123–137). Nogatz (b22) 2017 Frühwirth, Abdennadher (b13) 2003 . Leuven (b21) 2013 Stephan, I. (1994). An SLOU Prolog Interpreter. In Schrijvers, T., & Demoen, B. (2004). The K. U. Leuven CHR system: Implementation and application. In Weert, Wuille, Schrijvers, Demoen (b34) 2008; vol. 5388 Frühwirth (b10) 1994 Christian, Frühwirth (b7) 2000; 14 Frühwirth (b11) 1998; 37 Holzbaur (b16) 1992 Sneyers, J., Schrijvers, T., & Demoen, B. (2005). The computational power and complexity of Constraint Handling Rules. In T. Schrijvers, & T. Frühwirth (Eds.) Schrijvers (b25) 2005 Van Hentenryck (10.1016/j.eswa.2023.121810_b31) 1991; 6 Nogatz (10.1016/j.eswa.2023.121810_b24) 2018 Jaffar (10.1016/j.eswa.2023.121810_b20) 1994; 19/20 Nogatz (10.1016/j.eswa.2023.121810_b23) 2022 10.1016/j.eswa.2023.121810_b26 10.1016/j.eswa.2023.121810_b27 10.1016/j.eswa.2023.121810_b28 10.1016/j.eswa.2023.121810_b29 Stéphan (10.1016/j.eswa.2023.121810_b30) 2021 Weert (10.1016/j.eswa.2023.121810_b34) 2008; vol. 5388 Frühwirth (10.1016/j.eswa.2023.121810_b13) 2003 Weert (10.1016/j.eswa.2023.121810_b33) 2008 Frühwirth (10.1016/j.eswa.2023.121810_b11) 1998; 37 Weert (10.1016/j.eswa.2023.121810_b32) 2005 Barichard (10.1016/j.eswa.2023.121810_b4) 2022 Frühwirth (10.1016/j.eswa.2023.121810_b10) 1994 (10.1016/j.eswa.2023.121810_b15) 2011 10.1016/j.eswa.2023.121810_b2 Wolf (10.1016/j.eswa.2023.121810_b35) 2001 Christian (10.1016/j.eswa.2023.121810_b7) 2000; 14 Holzbaur (10.1016/j.eswa.2023.121810_b17) 2004; 5 10.1016/j.eswa.2023.121810_b36 10.1016/j.eswa.2023.121810_b18 10.1016/j.eswa.2023.121810_b19 Barichard (10.1016/j.eswa.2023.121810_b5) 2019 Frühwirth (10.1016/j.eswa.2023.121810_b12) 2009 Frühwirth (10.1016/j.eswa.2023.121810_b9) 1992 Schrijvers (10.1016/j.eswa.2023.121810_b25) 2005 Duck (10.1016/j.eswa.2023.121810_b8) 2004 Barichard (10.1016/j.eswa.2023.121810_b3) 2022 Holzbaur (10.1016/j.eswa.2023.121810_b16) 1992 Frühwirth (10.1016/j.eswa.2023.121810_b14) 1993 Leuven (10.1016/j.eswa.2023.121810_b21) 2013 Abdennadher (10.1016/j.eswa.2023.121810_b1) 2002; 64 Nogatz (10.1016/j.eswa.2023.121810_b22) 2017 Betz (10.1016/j.eswa.2023.121810_b6) 2013; 14 |
| References_xml | – year: 2022 ident: b23 article-title: Chr.js source code – reference: Ivanović, D. (2013). Implementing Constraint Handling Rules as a Domain-Specific Language Embedded in Java. In – volume: vol. 5388 start-page: 161 year: 2008 end-page: 212 ident: b34 article-title: CHR for imperative host languages publication-title: Lecture notes in computer science (including subseries lecture notes in artificial intelligence and lecture notes in bioinformatics) – volume: 14 year: 2013 ident: b6 article-title: Linear-logic based analysis of constraint handling rules with disjunction publication-title: ACM Transactions on Computational Logic – start-page: 260 year: 1992 end-page: 268 ident: b16 article-title: Metastructures vs. attributed variables in the context of extensible unification publication-title: Programming language implementation and logic programming – start-page: 210 year: 2019 end-page: 223 ident: b5 article-title: Quantified constraint handling rules publication-title: ICLP 2019, Vol. 306 – start-page: 59 year: 2008 end-page: 73 ident: b33 article-title: Aggregates for CHR through program transformation publication-title: Logic-based program synthesis and transformation – start-page: 3 year: 1993 end-page: 35 ident: b14 article-title: Constraint logic programming – An informal introduction publication-title: Logic programming in Action – volume: 5 year: 2004 ident: b17 article-title: Optimizing compilation of constraint handling rules in HAL publication-title: Theory and Practice of Logic Programming – reference: Jaffar, J., & Lassez, J.-L. (1987). Constraint Logic Programming. In – year: 2013 ident: b21 article-title: An overview of CHR implementations – year: 1992 ident: b9 article-title: Constraint handling Rules – reference: Schrijvers, T., & Warren, D. (2004). Constraint Handling Rules and Tabled Execution. In – volume: 6 start-page: 151 year: 1991 end-page: 194 ident: b31 article-title: Constraint logic programming publication-title: Knowledge Engineering Review – year: 2022 ident: b3 article-title: CHR++ website – start-page: 90 year: 2004 end-page: 104 ident: b8 article-title: The refined operational semantics of constraint handling rules publication-title: Logic programming – reference: (pp. 120–136). – start-page: 256 year: 2001 end-page: 270 ident: b35 article-title: Adaptive constraint handling with CHR in java publication-title: Proceedings of 7th international conference on principles and practice of constraint programming – volume: 64 start-page: 1 year: 2002 end-page: 17 ident: b1 article-title: JACK: A java constraint kit publication-title: Electronic Notes in Theoretical Computer Science – reference: Sneyers, J., Schrijvers, T., & Demoen, B. (2005). The computational power and complexity of Constraint Handling Rules. In T. Schrijvers, & T. Frühwirth (Eds.), – year: 2022 ident: b4 article-title: A constraint language for university timetabling problems publication-title: 13th international conference on the practice and theory of automated – start-page: 131 year: 2018 end-page: 146 ident: b24 article-title: Chr.js: A CHR implementation in JavaScript publication-title: Rules and reasoning – year: 2011 ident: b15 article-title: Constraint handling rules: Compilation, execution, and analysis – start-page: 881 year: 2021 end-page: 888 ident: b30 article-title: First-order ASP programs as CHR programs publication-title: Proceedings of the 36th annual ACM symposium on applied computing – reference: (pp. 3–17). Number CW 421 in Dept. Computer Science, Technical Report. – volume: 14 start-page: 369 year: 2000 end-page: 388 ident: b7 article-title: A prolog constraint handling rules compiler and runtime system publication-title: Applied Artificial Intelligence – reference: (pp. 111–119). – volume: 37 start-page: 95 year: 1998 end-page: 138 ident: b11 article-title: Theory and practice of constraint handling rules publication-title: Journal of Logic Programming – reference: . – reference: Stephan, I. (1994). An SLOU Prolog Interpreter. In – start-page: 90 year: 1994 end-page: 107 ident: b10 article-title: Constraint handling rules publication-title: Constraint programming: Basics and trends – reference: Wuille, P., Schrijvers, T., & Demoen, B. (2007). CCHR: the fastest CHR implementation, in C. In – year: 2009 ident: b12 article-title: Constraint handling rules – year: 2017 ident: b22 article-title: Chr.js playground – reference: (pp. 1–14). – reference: Schrijvers, T., & Demoen, B. (2004). The K. U. Leuven CHR system: Implementation and application. In – year: 2003 ident: b13 article-title: Essentials of constraint programming – start-page: 47 year: 2005 end-page: 62 ident: b32 article-title: K.u.leuven JCHR: a user-friendly, flexible and efficient CHR system for java publication-title: Proceedings of the 2nd workshop on constraint handling rules – year: 2005 ident: b25 article-title: Analyses, optimizations and extensions of constraint handling rules – reference: (pp. 123–137). – reference: Abdennadher, S., & Schütz, H. (1998). CHR: A Flexible Query Language. In – volume: 19/20 start-page: 503 year: 1994 end-page: 581 ident: b20 article-title: Constraint logic programming: A survey publication-title: Journal of Logic Programming – volume: 64 start-page: 1 year: 2002 ident: 10.1016/j.eswa.2023.121810_b1 article-title: JACK: A java constraint kit publication-title: Electronic Notes in Theoretical Computer Science doi: 10.1016/S1571-0661(04)80344-X – volume: 37 start-page: 95 issue: 1-3 year: 1998 ident: 10.1016/j.eswa.2023.121810_b11 article-title: Theory and practice of constraint handling rules publication-title: Journal of Logic Programming doi: 10.1016/S0743-1066(98)10005-5 – volume: vol. 5388 start-page: 161 year: 2008 ident: 10.1016/j.eswa.2023.121810_b34 article-title: CHR for imperative host languages – year: 2022 ident: 10.1016/j.eswa.2023.121810_b4 article-title: A constraint language for university timetabling problems – year: 2017 ident: 10.1016/j.eswa.2023.121810_b22 – ident: 10.1016/j.eswa.2023.121810_b26 – ident: 10.1016/j.eswa.2023.121810_b19 doi: 10.1145/41625.41635 – ident: 10.1016/j.eswa.2023.121810_b28 – start-page: 59 year: 2008 ident: 10.1016/j.eswa.2023.121810_b33 article-title: Aggregates for CHR through program transformation – ident: 10.1016/j.eswa.2023.121810_b2 doi: 10.1007/BFb0055987 – volume: 6 start-page: 151 issue: 3 year: 1991 ident: 10.1016/j.eswa.2023.121810_b31 article-title: Constraint logic programming publication-title: Knowledge Engineering Review doi: 10.1017/S0269888900005798 – year: 2009 ident: 10.1016/j.eswa.2023.121810_b12 – volume: 19/20 start-page: 503 year: 1994 ident: 10.1016/j.eswa.2023.121810_b20 article-title: Constraint logic programming: A survey publication-title: Journal of Logic Programming doi: 10.1016/0743-1066(94)90033-7 – year: 2005 ident: 10.1016/j.eswa.2023.121810_b25 – ident: 10.1016/j.eswa.2023.121810_b36 – year: 2003 ident: 10.1016/j.eswa.2023.121810_b13 – start-page: 256 year: 2001 ident: 10.1016/j.eswa.2023.121810_b35 article-title: Adaptive constraint handling with CHR in java – start-page: 210 year: 2019 ident: 10.1016/j.eswa.2023.121810_b5 article-title: Quantified constraint handling rules – year: 2013 ident: 10.1016/j.eswa.2023.121810_b21 – year: 1992 ident: 10.1016/j.eswa.2023.121810_b9 – start-page: 881 year: 2021 ident: 10.1016/j.eswa.2023.121810_b30 article-title: First-order ASP programs as CHR programs – year: 2022 ident: 10.1016/j.eswa.2023.121810_b23 – volume: 14 issue: 1 year: 2013 ident: 10.1016/j.eswa.2023.121810_b6 article-title: Linear-logic based analysis of constraint handling rules with disjunction publication-title: ACM Transactions on Computational Logic doi: 10.1145/2422085.2422086 – start-page: 260 year: 1992 ident: 10.1016/j.eswa.2023.121810_b16 article-title: Metastructures vs. attributed variables in the context of extensible unification – ident: 10.1016/j.eswa.2023.121810_b29 – start-page: 90 year: 1994 ident: 10.1016/j.eswa.2023.121810_b10 article-title: Constraint handling rules – start-page: 47 year: 2005 ident: 10.1016/j.eswa.2023.121810_b32 article-title: K.u.leuven JCHR: a user-friendly, flexible and efficient CHR system for java – start-page: 131 year: 2018 ident: 10.1016/j.eswa.2023.121810_b24 article-title: Chr.js: A CHR implementation in JavaScript – ident: 10.1016/j.eswa.2023.121810_b18 – year: 2022 ident: 10.1016/j.eswa.2023.121810_b3 – year: 2011 ident: 10.1016/j.eswa.2023.121810_b15 – ident: 10.1016/j.eswa.2023.121810_b27 doi: 10.1007/978-3-540-27775-0_9 – start-page: 3 year: 1993 ident: 10.1016/j.eswa.2023.121810_b14 article-title: Constraint logic programming – An informal introduction – volume: 14 start-page: 369 issue: 4 year: 2000 ident: 10.1016/j.eswa.2023.121810_b7 article-title: A prolog constraint handling rules compiler and runtime system publication-title: Applied Artificial Intelligence doi: 10.1080/088395100117043 – start-page: 90 year: 2004 ident: 10.1016/j.eswa.2023.121810_b8 article-title: The refined operational semantics of constraint handling rules – volume: 5 year: 2004 ident: 10.1016/j.eswa.2023.121810_b17 article-title: Optimizing compilation of constraint handling rules in HAL publication-title: Theory and Practice of Logic Programming |
| SSID | ssj0017007 |
| Score | 2.4671845 |
| Snippet | This article introduces CHR++, an implementation of CHR (Constraint Handling Rules) in C++. CHR++ has been designed to be efficient, user-friendly, and to make... |
| SourceID | hal crossref elsevier |
| SourceType | Open Access Repository Enrichment Source Index Database Publisher |
| StartPage | 121810 |
| SubjectTerms | C++ Computer Science Constraint handling rules Constraint handling rules with disjunction Constraint logic programming systems Constraint processing Domain specific languages |
| Title | CHR++: An efficient CHR system in C++ with don’t know non-determinism |
| URI | https://dx.doi.org/10.1016/j.eswa.2023.121810 https://univ-angers.hal.science/hal-04232684 |
| Volume | 238 |
| hasFullText | 1 |
| inHoldings | 1 |
| isFullTextHit | |
| isPrint | |
| journalDatabaseRights | – providerCode: PRVESC databaseName: Elsevier SD Freedom Collection Journals 2021 customDbUrl: eissn: 1873-6793 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0017007 issn: 0957-4174 databaseCode: AIEXJ dateStart: 19950101 isFulltext: true titleUrlDefault: https://www.sciencedirect.com providerName: Elsevier |
| link | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwtV1Lb9QwELZoy4ELb0R5yUJwilwljuMHt2VVWBCqECrS3qLED7ErFKrdUHrkb_D3-CWMYzsLK1rRA9IqWjnOxMrnTMbjb2YQelaUjeSlc4Rzqwgz1pC2MYJQo1pXGZjWXA_FJsTRkZzP1ftY5m49lBMQXSfPztTJf4Ua2gBsHzp7CbhHodAA_wF0OALscPwn4KezD8_pS_8LPj87JInwW_5wJmZuHmL9Qq_gifUlPSLtQfXZECDXfemIiWSZlGdwORL37KqPslJ83G874Rv36CqEdQ1s2kWnE8smuhko8zyrEGg5-gsFYUUoqZNUJw2ZWaLyK7y5kP9VLwcXwfLArr_5ZE-0PNh0_jMJ9tbHaaQMJjbasvYyai-jDjJ20B4VlQKVtjd5czh_O24iiTxEy6eRx5ipQO_bHsl5dsnOp-RhHyyO45voelwq4EmA-Ba6Yrvb6EYqw4GjVr6DXntcsxd40uERawxtOOCDFx2eZhn2KGHA-ef3Hz32COMthO-ij68Oj6czEutjEA2L5p7YioN1yfPSyIYywRrpuKCNVkyAlck42GbGVKatnJLOCicdNYVoSquZEqVry3toF-5k7yMsG5fzFiyavLSMtUJqWmiw3dq8rQQs0fdRkZ5OrWPyeF_D5HN9Pi77KBuvOQmpUy7sXaWHXkfjLxh1NcyhC697CgiNN_DZ0meTd7Vv85Qvn8zotHhwqaE8RNc2b8AjtNuvvtrH6Ko-7Rfr1ZM4y34Bv3p_wQ |
| linkProvider | Elsevier |
| openUrl | ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rft.genre=article&rft.atitle=CHR%2B%2B%3A+An+efficient+CHR+system+in+C%2B%2B+with+don%E2%80%99t+know+non-determinism&rft.jtitle=Expert+systems+with+applications&rft.au=Barichard%2C+Vincent&rft.date=2024-03-15&rft.issn=0957-4174&rft.volume=238&rft.spage=121810&rft_id=info:doi/10.1016%2Fj.eswa.2023.121810&rft.externalDBID=n%2Fa&rft.externalDocID=10_1016_j_eswa_2023_121810 |
| thumbnail_l | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=0957-4174&client=summon |
| thumbnail_m | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=0957-4174&client=summon |
| thumbnail_s | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=0957-4174&client=summon |