Abhiram G. Ranade

Review: A variation on SVD based image compression

We present a variation to the well studied SVD based image compression technique. Our variation can be viewed as a preprocessing step in which the input image is permuted as per a fixed, data independent permutation, after which it is fed to the standard SVD algorithm. Likewise, our decompression algorithm can be viewed as the standard SVD algorithm followed by a postprocessing step which applies the inverse permutation. On experimenting with standard images we show that our method performs substantially better than the standard method. Typically, for any given compression quality, our method needs about 30% fewer singular values and vectors to be retained. We also present a bit allocation scheme and show that our method also performs better than the more familiar discrete cosine transform (DCT). We show that the original SVD algorithm as well as our variation, can be viewed as instances of the Karhunen-Loeve transform (KLT). In fact, we observe that there is a whole family of variations possible by choosing different parameter values while applying the KLT. We present heuristic arguments to show that our variation is likely to yield the best compression of all these. We also present experimental evidence, which appears to justify our analysis.

Register Efficient Mergesorting

We present a register efficient implementation of Mergesort which we call FAME (Finite Automaton MErgesort). FAME is a m-way Mergesort. The m streams are merged by organizing comparison tournaments among the elements at the heads of the streams. The winners of the tournament form the output stream. Many ideas are used to increase efficiency. First, the heads of the streams are maintained in the register file. Second, the tournaments are evaluated incrementally, i.e. after one winner is output the next tournament uses the results of the comparisons performed in the preceding tournaments and thus minimizes work. Third, to minimize register movement, the state of the tournament is encoded as a finite automaton. We experimented with 8-way and 4-way FAME on an Ultrasparc and a DEC Alpha and found that these algorithms were better than cache-cognizant Quicksort algorithms on the same machines.

Scheduling light-trails on WDM rings

We consider the problem of scheduling communication on optical WDM (wavelength division multiplexing) networks using the light-trails technology. We seek to design scheduling algorithms such that the given transmission requests can be scheduled using a minimum number of wavelengths (optical channels). We provide algorithms and close lower bounds for two versions of the problem on an n processor linear array/ring network. In the stationary version, the pattern of transmissions (given) is assumed to not change over time. For this, a simple lower bound is c, the congestion or the maximum total traffic required to pass through any link. We give an algorithm that schedules the transmissions using O(c+logn) wavelengths. We also show a pattern for which @W(c+logn/loglogn) wavelengths are needed. In the on-line version, the transmissions arrive and depart dynamically, and must be scheduled without upsetting the previously scheduled transmissions. For this case we give an on-line algorithm which has competitive ratio @Q(logn). We show that this is optimal in the sense that every on-line algorithm must have competitive ratio @W(logn). We also give an algorithm that appears to do well in simulations (for the classes of traffic we consider), but which has competitive ratio between @W(log^2n/loglogn) and O(log^2n). We present detailed simulations of both our algorithms.

Precedence constrained scheduling in (2-73p+1)·optimal

We present a polynomial time approximation algorithm for unit time precedence constrained scheduling. Our algorithm guarantees schedules which are at most (2-73p+1) factor as long as the optimal, where p>3 is the number of processors. This improves upon a long standing bound of (2-2p) due to Coffman and Graham.

An improved maximum likelihood formulation for accurate genome assembly

We present improvements to the recently proposed maximum likelihood method for genome assembly. We formulate the problem as one of direct convex optimization, and achieve the following improvements: Our method does not require identical read lengths and can deal with reads of varying lengths. We eliminate the requirement to a priori know a stringent estimate of the length of the genome or the need to use further expectation minimization to predict the most likely length. Instead, we explicitly incorporate the uncertainty in the length estimate by a range parameter without affecting the convexity required for the optimization. Results indicate that our method can generate accurate estimates of repeat counts and produces fewer and much longer contigs. These results mark a further advancement of maximum likelihood genome assembly and the potential of this approach in building future genome assemblers.

A simple optimal list ranking algorithm

We consider the problem of ranking an N element list on a P processor EREW PRAM. Recent work on this problem has shown the importance of grain size. While several optimal O(N/P+log P) time list ranking algorithms are known, Reid-Miller and Blelloch (1994) recently showed that these do not lead to good implementations in practice, because of the fine-grained nature of these algorithms. In Reid-Miller and Blellochs experiments the best performance was obtained by an O(N/P+log/sup 2/ P) time coarse grained randomized algorithm devised by them. We build upon their idea and present a coarse-grained randomized algorithm that runs in time O(N/P+log P), and is thus also optimal. Our algorithm simplifies some of the ideas from [6, 7]-these simplifications might be of interest to implementers.

Exact train pathing

Suppose we are given a schedule of train movements over a rail network into which a new train is to be included. The origin and the destination are specified for the new train; it is required that a schedule (including the path) be determined for it so as to minimize the time taken without affecting the schedules for the old trains. In the standard formulations of this single train pathing problem, the time taken by the train to traverse any block (track segment guarded by a signal) in the network is deemed to be a fixed number, independent of how the train arrived onto that block. In other words, the standard formulations of train pathing do not accurately model the acceleration/deceleration restrictions on trains.In this paper we give an algorithm to solve the single train pathing problem, while taking into account the maximum allowed acceleration and deceleration as well as explicitly modeling signals. For trains having ‘large’ maximum acceleration and deceleration, our algorithm runs in polynomial time. On the other hand, if the train to be pathed is capable of only very small acceleration so that it must take a long time to reach full speed, our algorithm takes exponential time. However, we prove that the pathing problem is NP-complete for small acceleration values, thus justifying the time required by our algorithm.Our algorithm can be used as a subroutine in a heuristic for multiple train pathing. If all trains have large (but possibly different) accelerations this algorithm will run in polynomial time.

Branch-and-Bound Global-Search Algorithm for Aircraft Ground Movement Optimization

Optimal aircraft ground scheduling is a well-known nondeterministic polynomial-time-hard problem; hence, many heuristics are used to generate schedules within realistic runtimes. These heuristics are designed to run fast, but they often do not promise any guarantee about the solution quality. Inspired by two existing algorithms for scheduling of railway operations, this paper introduces a branch-and-bound-based aircraft routing and scheduling approach with guaranteed global optimality as a real-time decision support tool for air traffic controllers. The performance of the algorithm is benchmarked against two previous approaches: a combinatorial approach using mixed-integer linear programming, and a heuristic approach based on bacterial foraging. The configuration agnostic design of the algorithm makes it suitable for applications: even to unconventional airport layouts. The globally optimal nature of the current solution exhibits a distinct improvement over the respective solutions while maintaining minim...

Introductory Programming: Let Us Cut through the Clutter!

Introductory programming courses often leave students unimpressed. We feel this is because teaching approaches (a) overemphasize the syntactic aspects of the programming language being taught instead of using programming to do interesting things, (b) do not respect the computational maturity/intellectual leanings of the students, and (c) are simply not fun enough. We have developed an approach which we believe addresses these issues in the context of teaching introductory programming to college students majoring in science and engineering. We use the C++ programming language augmented with a graphics library and some linguistic devices we have developed. We believe that our approach enables interesting material to be handled from day one and generally garners more student interest.

Scheduling loosely connected task graphs

We present a polynomial time algorithm for precedence-constrained scheduling problems in which the task graph can be partitioned into large disjoint parts by removing edges with high float, where the float of an edge is defined as the difference between the length of the longest path in the graph and the length of the longest path containing the edge. Our algorithm guarantees schedules within a factor 1.875 of the optimal independent of the number of processors. The best-known factor for this problem and in general is 2-2/p, where p is the number of processors, due to Coffman-Graham. Our algorithm is unusual and considerably different from that of Coffman-Graham and other algorithms in the literature.