Compiling Recurrences over Dense and Sparse Arrays

The paper describes graph algorithms performance when using different types of data structures. To achieve that, we developed a multi-level graph processing system, which allows to create graph applications independently of any implementation details such as graph data structure or underlying computational architecture. We measure the performance of breadth-first search, max flow and random graph building algorithms when using compressed sparse row and adjacency matrix data structures. Experiments reveal different graph processing rates for different data structures, which indicates the need of using specific data structures for specific algorithms to achieve highest performance.

Efficient indexing for semantic search

In this paper we investigate the problem of building a static data structure that represents a string s using space close to its compressed size, and allows fast access to individual characters of s. This type of data structures was investigated by the recent paper of Bille et al. [3]. Let n be the size of a context-free grammar that derives a unique string s of length L. (Note that L might be exponential in n.) Bille et al. showed a data structure that uses space O(n) and allows to query for the i-th character of s using running time O(logL). Their data structure works on a word RAM with a word size of logL bits.

In classification studies in which pattern-recognition methods are used to distinguish active compounds from inactive ones, a type of data structure which we call "asymmetric" can be observed. This type of data structure can be quite common and its occurrence can have a profound effect on the classification analysis outcome. The origin of asymmetric data structure and a strategy or obtaining meaningful classification results when it is observed are discussed and illustrated with an example of active and inactive antimalarial quinones.

The concept of ‘modes of appearances’ has an odd status in colour science. As a purely descriptive concept, which has emerged from attempts to classify well-established phenomenological observations of different ‘types’ of colour appearance, it is itself in need of an explanation in terms of some abstract principles of the internal coding of colour. Still, colour science has, by and large, downplayed the theoretical importance of corresponding observations by considering them as extraneous to colour proper and ascribing them to the effects of ‘viewing conditions’ or ‘context’: Different ‘modes of appearance’ are thus not regarded as different types of colours but simply as modifications of the same colour — namely the colour directly tied to the receptor excitations elicited by the local incoming light stimulus (as produced by the ‘aperture mode’) and transformed and modified in subsequent stages of processing. Such an approach rests on the assumption that ‘colour’ constitutes a homogeneous and unitary domain with respect to the ‘data format’ or set of representational primitives in which ‘colour’ figures, and that, furthermore, issues of processing can be investigated independently of the structure of representational primitives. However, this assumption, apart from being ill-motivated from a functionalist point of view, conflicts with well-established core observations: These range from ‘modes of appearances’, and phenomena, where two different colour appearances can be simultaneously present at the same ‘location’ as distinctive aspects of the percept (such that changes in one of these aspects cannot be compensated by changes with respect to the other), problems encountered with asymmetric colour matches, to appearances of ‘material colours’ (which colour science has notorious difficulty to deal with in a theoretically satisfactory way). In contrast to this assumption, various lines of converging experimental evidence suggest that the internal processing of colour is based on (at least) two different types of data structures or representational primitives, which give rise to two proprietary types of colour codes, pertaining coarsely to the ‘colour of an object’ and the ‘colour of the ambient illumination’, respectively. Accordingly, the different ‘modes of appearance’ mirror internal colour processes of an essentially different nature (including mechanisms for dealing with vagueness, ambiguity, and continuous transitions in relevant input characteristics), and, in line with various types of observations and experimental findings, indicate that ‘colour’ exhibits different coding properties with respect to different types of representational primitives. In particular, experimental evidence suggests that the ‘colour’ parameters of the representational primitives involved are, in characteristic ways, intrinsically interwoven with other parameters of these primitives, such as ‘texture’, ‘depth’, ‘motion’ etc. Because of this, it is highly unlikely that an assignment of values to the respective ‘colour’ parameters can be made on the basis of relations on or transformations of retinal colour codes alone (as computational schemes solely based on colour codes presume). After a brief discussion of the above-mentioned issues, I will report experimental results on the segregation of the retinal colour code into a dual colour code and on colour-related input properties (e.g. scene statistics) that modulate such a segregation.

The data structures that are written in a typical data structures course cannot or would not be used in common applications in industry for two reasons. First, they do not work according to their specifications if they are used in a multi-threaded environment. If two threads are deleting adjacent elements of a linked list at the same time, for example, then one of the deletes may not have any effect. Second, they do not fire change events and thus frustrate common design practices of connecting software components. As a result, it is more difficult for the application programmer to separate the data, the structures, the logic, the user interface, and the application code from each other. Here we discuss some issues involved in including these two topics, threads and components, in a course on data structures. Students who learn these techniques will have less to learn when they begin to use and write data structures in industry.

This paper shows how to compile sparse array programming languages. A sparse array programming language is an array programming language that supports element-wise application, reduction, and broadcasting of arbitrary functions over dense and sparse arrays with any fill value. Such a language has great expressive power and can express sparse and dense linear and tensor algebra, functions over images, exclusion and inclusion filters, and even graph algorithms. Our compiler strategy generalizes prior work in the literature on sparse tensor algebra compilation to support any function applied to sparse arrays, instead of only addition and multiplication. To achieve this, we generalize the notion of sparse iteration spaces beyond intersections and unions. These iteration spaces are automatically derived by considering how algebraic properties annotated onto functions interact with the fill values of the arrays. We then show how to compile these iteration spaces to efficient code. When compared with two widely-used Python sparse array packages, our evaluation shows that we generate built-in sparse array library features with a performance of 1.4× to 53.7× when measured against PyData/Sparse for user-defined functions and between 0.98× and 5.53× when measured against SciPy/Sparse for sparse array slicing. Our technique outperforms PyData/Sparse by 6.58× to 70.3×, and (where applicable) performs between 0.96× and 28.9× that of a dense NumPy implementation, on end-to-end sparse array applications. We also implement graph linear algebra kernels in our system with a performance of between 0.56× and 3.50× compared to that of the hand-optimized SuiteSparse:GraphBLAS library.

Experiences with sparse matrix solvers in parallel ODE software

Computationally testable models in linguistics focus on declaring data structures and providing exemplar derivations. This paper outlines a comprehensive model of speech production which goes beyond derivations to show how actual instances of utterances can be formally characterised. Utterances contain a wealth of detail beyond the underlying utterance plan: some of this is a function of the mechanism itself (e.g. coarticulation) and some is the result of carefully supervised control. We develop the notion of managed or supervised speech production to enable the inclusion of EXPRESSIVE content in speech. Building on earlier work the Cognitive Phonetics Agent bridges the gap between the physical and cognitive processes in phonetics by controlling the way phonologically determined utterance plans are phonetically rendered in detail. The model is illustrated using different types of data structure which occur in speech, concentrating in particular on an XML characterisation of appropriate structures. We trace a simple utterance through from its phonological plan to a detailed intrinsic allophonic representation to show how stages in the model work.

Electromagnetic transient type (EMT-type) programs solve nodal analysis (NA) or modified-augmented-nodal-analysis (MANA) formulation based power system network equations (PSNE). The PSNE coefficient matrix can be either constant or time-varying depending on the utilized synchronous machine (SM) model. Therefore, a computational efficiency comparison for the SM models requires accounting for the refactorization scheme and the utilized sparse matrix solver (SMS). In addition, MANA formulation does not require or force admittance model usage and enables flexibility while representing the SMs in PSNE. This paper compares computational performances of various SM models for a practical case and accounts for the refactorization scheme, the utilized SMS and the SM representation in MANA formulation.

General software for preconditioning the iterative solution of linear systems is greatly lagging behind the literature. This is partly because specific problems and specific matrix and preconditioner data structures in order to be solved efficiently, i.e., multiple implementations of a preconditioner with specialized data structures are required. This article presents a framework to support preconditioning with various, possibly user-defined, data structures for matrices that are partitioned into blocks. The main idea is to define data structures for the blocks, and an upper layer of software which uses these blocks transparently of their data structure. This transparency can be accomplished by using an object-oriented language. Thus, various preconditioners, such as block relaxations and block-incomplete factorizations, only need to be defined once and will work with any block type. In addition, it is possible to transparently interchange various approximate or exact techniques for inverting pivot blocks, or solving systems whose coefficient matrices are diagonal blocks. This leads to a rich variety of preconditioners that can be selected. Operations with the blocks are performed with optimized libraries or fundamental data types. Comparisons with an optimized Fortran 77 code on both workstations and Cray supercomputers show that this framework can approach the efficiency of Fortran 77, as long as suitable block sized and block types are chosen.

This book discusses the development and implementation of data structures and algorithms using C#. The data structures we use in this book are found in the .NET Framework class library System.Collections. In this chapter, we develop the concept of a collection by first discussing the implementation of our own Collection class (using the array as the basis of our implementation) and then by covering the Collection classes in the .NET Framework. An important addition to C# 2.0 is generics. Generics allow the C# programmer to write one version of a function, either independently or within a class, without having to overload the function many times to allow for different data types. C# 2.0 provides a special library, System.Collections.Generic, that implements generics for several of the System.Collections data structures. This chapter will introduce the reader to generic programming. Finally, this chapter introduces a custom-built class, the Timing class, which we will use in several chapters to measure the performance of a data structure and/or algorithm. This class will take the place of Big O analysis, not because Big O analysis isn't important, but because this book takes a more practical approach to the study of data structures and algorithms. COLLECTIONS DEFINED A collection is a structured data type that stores data and provides operations for adding data to the collection, removing data from the collection, updating data in the collection, as well as operations for setting and returning the values of different attributes of the collection.

A direct parallel sparse matrix solver

The aim of this paper is to report on a recently developed fully coupled and fully implicit solver for turbulent combustion. All the equationsare written in terms of primitive variables (pressure, velocity, temperature, turbulent parameters and species mass fractions) and solved in a fully coupled manner. The coupled system of equations is solved using an unstructured collocated Finite Volume (FV) approach using a fully implicit temporal discretization. An all speed version of AUSM approach is used along with a time derivative preconditioning. The developed fully coupled solver can be applied to a wide range of flow speeds from incompressible limit to hyper-sonic regimes. For solving the resulting system of equations, a sparse ILU preconditioned, sparse GMRES solver is used. This sparse matrix solver is very effective and only linearly increases the computational cost with increasing number of solution cells and number of solution variables.Turbulence reaction coupling is basically obtained using Eddy Dissipation Model (EDM) approach.

The sparse matrix solver has become the bottleneck in a Simulation Program with Integrated Circuit Emphasis circuit simulator. It is difficult to parallelize the sparse matrix solver because of the high data dependence during the numerical LU factorization. In this brief, a parallel LU factorization algorithm is developed on shared-memory computers with multicore central processing units, based on KLU algorithms. An Elimination Scheduler (EScheduler) is proposed to represent the data dependence during the LU factorization. Based on the EScheduler, the parallel tasks are scheduled in two modes to achieve a high level of concurrence, i.e., cluster mode and pipeline mode . The experimental results on 26 circuit matrices reveal that the developed algorithm can achieve speedup of 1.18-4.55t (on geometric average), as compared with KLU, with 1-8 threads. The result analysis indicates that for different data dependence, different parallel strategies should be dynamically selected to obtain optimal performance.