The Experts below are selected from a list of 132 Experts worldwide ranked by ideXlab platform
Stanislav źivný - One of the best experts on this subject based on the ideXlab platform.
-
Variable elimination in binary csp via forbidden patterns
International Joint Conference on Artificial Intelligence, 2013Co-Authors: David Cohen, Martin C. Cooper, Guillaume Escamocher, Stanislav źivnýAbstract:A Variable elimination rule allows the polynomial-time identification of certain Variables whose elimination does not affect the satisfiability of an Instance. Variable elimination in the constraint satisfaction problem (CSP) can be used in preprocessing or during search to reduce search space size. We show that there are essentially just four Variable elimination rules defined by forbidding generic sub-Instances, known as irreducible patterns, in arc-consistent CSP Instances. One of these rules is the Broken Triangle Property, whereas the other three are novel.
-
IJCAI - Variable elimination in binary CSP via forbidden patterns
2013Co-Authors: David Cohen, Martin C. Cooper, Guillaume Escamocher, Stanislav źivnýAbstract:A Variable elimination rule allows the polynomial-time identification of certain Variables whose elimination does not affect the satisfiability of an Instance. Variable elimination in the constraint satisfaction problem (CSP) can be used in preprocessing or during search to reduce search space size. We show that there are essentially just four Variable elimination rules defined by forbidding generic sub-Instances, known as irreducible patterns, in arc-consistent CSP Instances. One of these rules is the Broken Triangle Property, whereas the other three are novel.
Valery Trifonov - One of the best experts on this subject based on the ideXlab platform.
-
representing java classes in a typed intermediate language
International Conference on Functional Programming, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus (Fo) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard Fo with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on Fo makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
-
ICFP - Representing Java classes in a typed intermediate language
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming - ICFP '99, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus (Fo) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard Fo with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on Fo makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
-
Representing Java classes in a typed intermediate language
ACM SIGPLAN Notices, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus ( F ω ) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard F ω with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on F ω makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
David Cohen - One of the best experts on this subject based on the ideXlab platform.
-
Variable elimination in binary csp via forbidden patterns
International Joint Conference on Artificial Intelligence, 2013Co-Authors: David Cohen, Martin C. Cooper, Guillaume Escamocher, Stanislav źivnýAbstract:A Variable elimination rule allows the polynomial-time identification of certain Variables whose elimination does not affect the satisfiability of an Instance. Variable elimination in the constraint satisfaction problem (CSP) can be used in preprocessing or during search to reduce search space size. We show that there are essentially just four Variable elimination rules defined by forbidding generic sub-Instances, known as irreducible patterns, in arc-consistent CSP Instances. One of these rules is the Broken Triangle Property, whereas the other three are novel.
-
IJCAI - Variable elimination in binary CSP via forbidden patterns
2013Co-Authors: David Cohen, Martin C. Cooper, Guillaume Escamocher, Stanislav źivnýAbstract:A Variable elimination rule allows the polynomial-time identification of certain Variables whose elimination does not affect the satisfiability of an Instance. Variable elimination in the constraint satisfaction problem (CSP) can be used in preprocessing or during search to reduce search space size. We show that there are essentially just four Variable elimination rules defined by forbidding generic sub-Instances, known as irreducible patterns, in arc-consistent CSP Instances. One of these rules is the Broken Triangle Property, whereas the other three are novel.
Christopher League - One of the best experts on this subject based on the ideXlab platform.
-
representing java classes in a typed intermediate language
International Conference on Functional Programming, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus (Fo) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard Fo with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on Fo makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
-
ICFP - Representing Java classes in a typed intermediate language
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming - ICFP '99, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus (Fo) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard Fo with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on Fo makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
-
Representing Java classes in a typed intermediate language
ACM SIGPLAN Notices, 1999Co-Authors: Christopher League, Zhong Shao, Valery TrifonovAbstract:We propose a conservative extension of the polymorphic lambda calculus ( F ω ) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard F ω with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on F ω makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private Instance Variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private Instance Variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and Instance Variable access and allows many standard optimizations to be performed on the object-oriented code.
Letha H Etzkorn - One of the best experts on this subject based on the ideXlab platform.
-
towards a measure of object oriented runtime cohesion based on number of Instance Variable accesses
ACM Southeast Regional Conference, 2011Co-Authors: Ruchira Mathur, Kevin J Keen, Letha H EtzkornAbstract:In this paper we present a new object-oriented cohesion metric at the runtime boundary, based on number of runtime Variable accesses. Only a small amount of previous work so far has been done with runtime boundary metrics [1, 2, 3, 4, 6]. This area has considerable potential: it promises more accurate quality measurements that have been available before, since quality is measured on the actual running code. We first propose the metric, then we compute the metric on an open source software package and validate it by comparing it to static cohesion metrics and expert cohesion data. Our results indicate that the metric does measure cohesion, and thus is worthy of future studies to determine its full utility.
-
ACM Southeast Regional Conference - Towards a measure of object oriented runtime cohesion based on number of Instance Variable accesses
Proceedings of the 49th Annual Southeast Regional Conference on - ACM-SE '11, 2011Co-Authors: Ruchira Mathur, Kevin J Keen, Letha H EtzkornAbstract:In this paper we present a new object-oriented cohesion metric at the runtime boundary, based on number of runtime Variable accesses. Only a small amount of previous work so far has been done with runtime boundary metrics [1, 2, 3, 4, 6]. This area has considerable potential: it promises more accurate quality measurements that have been available before, since quality is measured on the actual running code. We first propose the metric, then we compute the metric on an open source software package and validate it by comparing it to static cohesion metrics and expert cohesion data. Our results indicate that the metric does measure cohesion, and thus is worthy of future studies to determine its full utility.