Tzu-Yi Chen

Balancing sparse matrices for computing eigenvalues

Abstract Applying a permuted diagonal similarity transform DPAP T D −1 to a matrix A before calculating its eigenvalues can improve the speed and accuracy with which the eigenvalues are computed. This is often called balancing . This paper describes several balancing algorithms for sparse matrices and compares them against each other and the traditional dense algorithm. We first discuss our sparse implementation of the dense algorithm; our code is faster than the dense algorithm when the density of the matrix is no more than approximately .5, and is much faster for large, sparse matrices. We next describe a set of randomized balancing algorithms for matrices that are not given explicitly, i.e. given a vector x , we can compute only Ax and perhaps A T x . We motivate these Krylov-based algorithms using Perron–Frobenius theory. Results are given comparing the Krylov-based algorithms to each other and to the sparse and dense direct balancing algorithms, looking at norm reduction, running times, and the accuracy of eigenvalues computed after a matrix is balanced. We conclude that sparse balancing algorithms are efficient preconditioners for eigensolvers.

DARPA's HPCS Program- History, Models, Tools, Languages

Abstract The historical context with regard to the origin of the DARPA High Productivity Computing Systems (HPCS) program is important for understanding why federal government agencies launched this new, long-term high-performance computing program and renewed their commitment to leadership computing in support of national security, large science and space requirements at the start of the 21st century. In this chapter, we provide an overview of the context for this work as well as various procedures being undertaken for evaluating the effectiveness of this activity including such topics as modelling the proposed performance of the new machines, evaluating the proposed architectures, understanding the languages used to program these machines as well as understanding programmer productivity issues in order to better prepare for the introduction of these machines in the 2011–2015 timeframe.

Neural Networks for Predicting the Behavior of Preconditioned Iterative Solvers

We evaluate the effectiveness of neural networks as a tool for predicting whether a particular combination of preconditioner and iterative method will correctly solve a given sparse linear system Ax= b. We consider several scenarios corresponding to different assumptions about the relationship between the systems used to train the neural network and those for which the neural network is expected to predict behavior. Greater similarity between those two sets leads to better accuracy, but even when the two sets are very different prediction accuracy can be improved by using additional computation.

Commonsense computing (episode 5): algorithm efficiency and balloon testing

This paper investigates what students understand about algorithm efficiency before receiving any formal instruction on the topic. We gave students a challenging search problem and two solutions, then asked them to identify the more efficient solution and to justify their choice. Many students did not use the standard worst-case analysis of algorithms; rather they chose other metrics, including average-case, better for more cases, better in all cases, one algorithm being more correct, and better for real-world scenarios. Students were much more likely to choose the correct algorithm when they were asked to trace the algorithms on specific examples; this was true even if they traced the algorithms incorrectly.

On Using Reinforcement Learning to Solve Sparse Linear Systems

This paper describes how reinforcement learning can be used to select from a wide variety of preconditioned solvers for sparse linear systems. This approach provides a simple way to consider complex metrics of goodness, and makes it easy to evaluate a wide range of preconditioned solvers. A basic implementation recommends solvers that, when they converge, generally do so with no more than a 17% overhead in time over the best solver possible within the test framework. Potential refinements of, and extensions to, the system are discussed.

Commonsense understanding of concurrency: computing students and concert tickets

Innate understanding of concurrency helps beginners solve CS problems with multiple processes executing at the same time.

The (relative) importance of software design criteria

We study how the relative values placed on a variety of software design criteria differs between beginning students, advanced students, and educators. We also consider how these values change depending on the specific design situation. Statistical analysis of data collectedfrom over 300 subjects reveals relatively small differences between the two student populations and significant differences between educators and students. In addition to often valuing different criteria, educators also value criteria more consistently across the design situations.

What do beginning students know, and what can they do?

We are studying what students know about computer science-related topics before they take formal coursework at the university level. Preliminary results suggest that entering students have a fairly sophisticated understanding of algorithms. We are exploring other central computing topics for similar shared commonsense understanding.

User interface evaluation by novices

This study examines the extent to which novice computing students with minimal computer science coursework and no training in user interface (UI) evaluation consider UI concepts such as usability, user experience, and the context in which software will be used when evaluating an interface. In analyzing the responses of 149 novice computer science students who were asked to evaluate two interfaces for converting temperatures between Fahrenheit and Celsius, we observed that students generally considered usability and user experience factors, but were less likely to consider context. For educators, this exact task could be given to a class in order to initiate discussion of user-centered design; the study also provides a framework for structuring the discussion. More generally, the results of this study provide insight into some opportunities and challenges in teaching good interface design and evaluation skills.

ILUTP_Mem: A Space-Efficient Incomplete LU Preconditioner

When direct methods for solving large, sparse, nonsymmetric systems of linear equations use too much computer memory, users often turn to preconditioned iterative methods. It can be critical in solving such systems to choose a preconditioner which both uses a limited amount of memory, and helps the subsequently applied iterative solver converge more rapidly. This paper describes ILUTP_Mem, an incomplete LU preconditioner that computes an incomplete LU factorization that effectively uses an amount of space specified by the user. The ILUTP_Mem preconditioner is evaluated on a set of matrices from real applications.