Abstract. In this note the main features and newer developments of the C++ class library for extended scientific computing C-XSC 2.0 will be discussed. The original version of the C-XSC library is about ten years old. But in the last decade the underlying programming language C++ has been developed significantly. Since November 1998 the C++ standard is available and more and more compilers support (most of) the features of this standard. The new version C-XSC 2.0 conforms to this standard. Application programs written for older C-XSC versions have to be modified to run with C-XSC 2.0. Several examples will help the user to see which changes have to be done. Note, that all sample codes given in [6] have to be modified to work properly with C-XSC 2.0. All sample codes listed in this note will be made available on the web page

Trie is a popular data structure in frequent itemset mining (FIM) algorithms. It is memory-efficient, and allows fast construction and information retrieval. Many trie-related techniques can be applied in FIM algorithms to improve efficiency. In this paper we propose new techniques for fast management, but more importantly we scrutinize the well-known ones especially those which can be employed in APRIORI. The theoretical claims are supported by results of a comprehensive set of experiments, based on hundreds of tests that were performed on numerous databases, with different support thresholds. We offer some surprising conclusions, which at some point contradict published claims. 1.

This pattern faces the problem of improving the performances of design patterns when they are involved in intensive algorithms. Generic programming is a paradigm in which most classes and procedures are parameterized, thus leading to the construction of general and efficient software components. We demonstrate that some design patterns from Gamma et al. can be translated into this paradigm while handling operation polymorphism by parametric polymorphism. We thus preserve their modularity and reusability properties but we avoid the performance penalty due to their dynamic behavior, which is a critical issue in numerical computing.

Linear probing is one of the most popular implementations of dynamic hash tables storing all keys in a single array. When we get a key, we first hash it to a location. Next we probe consecutive locations until the key or an empty location is found. At STOC’07, Pagh et al. presented data sets where the standard implementation of 2-universal hashing leads to an expected number of Ω(log n) probes. They also showed that with 5-universal hashing, the expected number of probes is constant. Unfortunately, we do not have 5-universal hashing for, say, variable length strings. When we want to do such complex hashing from a complex domain, the generic standard solution is that we first do collision free hashing (w.h.p.) into a simpler intermediate domain, and second do the complicated hash function on this intermediate domain. Our contribution is that for an expected constant number of linear probes, it is suffices that each key has O(1) expected collisions with the first hash function, as long as the second hash function is 5-universal. This means that the intermediate domain can be n times smaller, and such a smaller intermediate domain typically means that the overall hash function can be made simpler and at least twice as fast. The same doubling of hashing speed for O(1) expected probes follows for most domains bigger than 32-bit integers, e.g., 64-bit integers and fixed length strings. In addition, we study how the overhead from linear probing diminishes as the array gets larger, and what happens if strings are stored directly as intervals of the array. These cases were not considered by Pagh et al. 1

Families of independent classes, where each class represents a separate, orthogonal concern are highly attractive for implementing collaboration-based design. However, required subtype relationship between such families cannot be expressed in many programming languages.

The concepts of the basic entities, i.e., objects, object classes, object types, etc., in the type hierarchy of object-oriented languages are revisited. The notion of object reuse is defined and elaborated. We show that while object classes are useful in object description and creation, the class-is-type principle which is used in many object-oriented languages is inadequate for object reuse. We also show that parameterized types and generic functions are better served by using kind-bounded qualification than universal qualification and other mechanisms. Keywords: Object reuse, software integration, objects, classes, types, kinds, class-is-type principle, parameterized types, generic functions, kind-bounded polymorphism 1

Computation with large-scale heterogeneous data typically requires universal traversal to search forall occurrences of a substructure that matches a possibly complex search pattern, whose context may be different in different places within the data. Both aspects cause difficulty for existing general-purpose programming languages, because these languages are designed for homogeneous data and have problems typing the different substructures in heterogeneous data, and the complex patterns to match with the substructures. Programmers either have to hard-code the structures and search patterns, preventing programs from being reusable and scalable, or have to use low-level untyped programming or programming with special-purpose query languages, opening the door to type mismatches that cause a high risk of program correctness and security problems. This thesis invents the concept of pattern structures, and proposes a general solution to the above problems -- a programming technique using pattern structures. In this solution, well-typed pattern structures are defined to represent complex search patterns, and pattern searching over heterogeneous data is programmed with pattern parameters, in a statically-typed language that supports first-class typing of structures and patterns. The resulting programs are statically-typed, highly reusable for different data structures and different patterns, and highly scalable in terms of the complexity of data structures and patterns. Adding new kinds of patterns for an application no longer requires changing the language in use or creating new ones, but is only a programming task. The thesis demonstrates the application of this approach to, and its advantages in, two important examples of computation with heterogeneous data, i.e., XML data processing and Java bytecode analysis.

This thesis describes the Omnibus language and its supporting framework of tools. Omnibus is an object-oriented language which is superficially similar to the Java programming language but uses value semantics for objects and incorporates a behavioural interface specification language. Specifications are defined in terms of a subset of the query functions of the classes for which a frame-condition logic is provided. The language is well suited to the specification of modelling types and can also be used to write implementations. An overview of the language is presented and then specific aspects such as subtleties in the frame-condition logic, the implementation of value semantics and the role of equality are discussed. The challenges of reference semantics are also discussed. The Omnibus language is supported by an integrated verification tool which provides support for three assertion-based verification approaches: run-time assertion checking, extended static checking and full formal verification. The different approaches provide different balances between rigour and ease of use. The Omnibus tool allows these approaches to be used together in different parts of the same project. Guidelines are presented in order to help users avoid conflicts when using the approaches together. The use of the integrated verification approach to meet two key requirements of safe software

Today’s programming languages, in particular aspect-oriented languages such as AspectJ [9], have received aconsiderable degree of complexity, making it both hard to learn their “vocabulary ” (i. e., simply know all concepts and constructs offered by the language) and to “fluently speak ” them (i. e., successfully apply these concepts and constructs in daily programming). In contrast, traditional procedural

The widespread use of Web technologies and, in particular, the ever growing number of applications adopting XML [XML00] as the standard language for the encoding of any piece of structured information, naturally calls for efficient implementations of DOM, the standard interface to access the internal structure of documents.