Etude de la compilation des langages logiques de programmation par contraintes sur les domaines finis: le système clp(FD)

This work focuses on the compilation of languages ​​constraint logic programming over finite domains (DF) . Rather than taking the usual approach considering the solver as a black box we chose the glass box approach proposed by P. Van Hentenryck. In this approach, the solver handles a single primitive constraint . All complex constraints ( equations, symbolic constraints ... ) are translated into calls to primitive constraints . The solver is simple and homogeneous. In addition , the user can define his own constraints in terms of this primitive. This primitive allows us to define an abstract machine for compiling FD constraints. In addition, managing a single primitive allows us to define global optimizations that benefit to all high-level constraints. All these ideas are detailed and lead to the definition of the clp(FD) language. The performance of clp(FD) shows that this approach is very effective in all cases better than solvers based on a black-box approach . We also study the ability of clp (FD) to solve Boolean constraints because they are a special case of FD. Again clp (FD) compares very well to specialized solvers. Finally, we are interested in the detection of constraint satisfaction to allow the user to specify data-driven calculations (rather than instructions). This work leads quite naturally to the implementation of concurrent languages ​​.Ce travail porte sur la compilation des langages de programmation logique par contraintes sur les domaines finis (DF). Plutôt que d'adopter l'approche usuelle considérant le résolveur comme une boîte noire nous avons choisi l'approche boîte de verre de P. Van Hentenryck. Dans celle-ci, le résolveur gère une seule contrainte primitive. Toutes les contraintes complexes (équations, contraintes symboliques...) sont traduites en des appels de contraintes primitives. Le résolveur est ainsi simple et homogène. De plus, l'utilisateur peut définir ses propres contraintes en termes de cette primitive. Cette primitive nous permet de définir une machine abstraite pour la compilation des contraintes DF. En outre, le traitement d'une seule primitive permet de définir des optimisations globales dont bénéficient toutes les contraintes de haut niveau. Toutes ces idées sont détaillées et aboutissent à la définition du langage clp (FD). L'étude des performances de clp (FD) montre que cette approche est très efficace, meilleure en tous cas que les résolveurs boîtes noires. Nous étudions également les aptitudes de clp (FD) à résoudre des contraintes booléennes car elles sont un cas particulier des DF. Là encore clp (FD) se compare très bien avec des résolveurs spécialisés. Nous nous intéressons enfin à la détection de la satisfaction des contraintes pour permettre à l'utilisateur de spécifier des calculs dirigés par les données (plutôt que par les instructions). Ce travail débouche donc tout naturellement sur l'implantation des langages concurrents