Algorithms Books

I checked this out from the library and was glad that I didn't buy it without reading it. It has very few equations and algorithms, and is more of a general overview or listing of computations done in GIS. Those hoping for a cookbook for geometric and analytic geography operations would best turn to Keith Clark's Analytic and Computer Cartograhy or a even good survey handbook for a better overview of the most important algorithms and formulas.

Yes, there are algorithms here, but they are not only a mishmash, but not very important ones

After reading this book, there are some parts missing here. I just described as follows.

For video scaling part, the polyphase filter design give more details on FIR filter design for fractional ratio. However, other methods like spline interpolation or nearest neighboring pixel method is not described here. The nonlinear scaling method gives more or less hints to design them which are all based on the high order polynomials and related to warping theory.

For digial video warping, it is better to refer to Dr. George Wolberg's book "Digital Image Warping" as keystone correction implementation

This book gives some information regarding gardient
calculations on edge detection which are based on frame level of video sequence. The de-interlacing parts did not give more industry designs on motion adaptive algorithms which use multiple fields data for motion detection/motion history and motion compensation based methods.

The diagonal direction based deinterlacing is not described here such as simple ELA algorithm.

The polyphase filter based deinterlacer will not work on fast motion video sequences when intra-field interpolation should be used. For slow motion of video, it might be ok to use vertical temporal filtering or even the previous field pixel for almost static image to create good result as intra field interpolation.

Readers who want to learn motion compensation based deitnerlacing should refer to Dr. Erwin Bellers's book "De-interlacing" for more advanced algorithms such as majority selection on 3D recursive search block matcher.

The 3:2 reverse pulldown for film material part only describes
pixel differences method. Block based variance or deviation methods are not mentioned here.

Examples are cluttered, confusing, and book is not very organized. Book could use more simple examples similar to homework problems. More in-depth explanation of ideas.

Lack of simplified examples makes the book hard to read and apply the tools to business questions. Requires a lot of effort to translate the contents for applying to real-world problems.

In some ways, this book offers the most thorough introduction to reconfigurable computing (RC) that I've seen. It starts with the platforms themselves, from Estrin's work around 1960 up to this year's Virtex 5 family of FPGAs. That discussion includes mainstream technologies, as well as recent explorations into coarse-grained and other architectures and a few of the commercially failed ideas that have arisen over time.

The next two chapters address basic issues in logic synthesis, at the gate level and datapath level. No one intro can cover the entire literature of the field, but this goes into mathematically proven depth in a few important algorithms. Two more chapters (5 and 7) address re-use the computing fabric over time, first as a formal exercise combining geometric constraints with temporal dependencies and then as a pragmatic exercise in terms of current chips and tools. Despite the amount of research attention that partial reconfiguration has gotten, tools are still crude and researchy. Instead of a commercial tool flow, expect to find a series of isolated puddles. Two more chapters (6 and 8) address system-on-chip issues. Finally, chapter 9 devotes about 30 pages to RC applications - or does it?

Really, it just names the applications and mentions a bit of why reconfigurability suits them. It doesn't go into much depth about the computations themselves. Even then, the discussion has more multiprocessor-on-chip flavor than any real sense of what makes FPGA-based RC truly different from von Neumann. I don't think the term "systolic array" appears anywhere.

I suppose it depends on what you want. Tool-builders will find a solid intro that works forward from a cold start. They'll see familiar compilation technologies applied in distinctive ways, with plenty of references for anyone in need of details. They'll see many of the unique problems in swapping parts of the computation on and off a working chip. RC practitioners take synthesis for granted though - synthesis algorithms hold only incidental interest. Partial reconfiguration, as the author emphasizes it, works only on one or two of the most recent chip famiies from Xilinx, and not at all on the Altera chips that are becoming more common in the RC arena. Applications focus on the embedded - media, signal processing, and the like - with scant mention of performance computing, my central interest. Although wide-ranging and well-researched, I have trouble imagining the RC practitioner who will take this book to the lab bench.

-- wiredweird

This book was very attractive to me by its title, so I bought it with a non-low price. However, the contents are neither rich and entensive nor systematic, and the robot systems are not novel at all. So after read it, I found nothing, but waiste of my time, energy and money. The book does really not match its title and price.

I wish that I could give this book a higher rating than I have, for the subject matter is one that I find of enormous intrinsic interest. Moreover, Dr. Chaitin is one of the most important contributors to this field of the last 30+ years.

My reasons for being disappointed in this book may well be the reasons others enthusiastically endorse it. Dr. Chaitin himself, in his preface, places this volume as the one thing he would most wish to save were a disaster to wipe out the rest of his oeuvre.

The sub-title of the book is "A Course on Information Theory and the Limits of Formal Reasoning." This sub-heading I find to be quite misleading. The book is not a "course" on any thing -- rather, it is a collection of a very small number of informal papers that Dr. Chaitin has given in recent years, and a very large number of pages devoted to LISP programs that can be used to demonstrate aspects of his extensions to the results of Turing and Goedel. The collection of articles seem largely redundant to me; any one of the articles by itself would be sufficient to summarize the rest of the book's contents. As for the programming, that should either have been provided in the form of a CD-ROM (as only someone of a genuinely "special" nature would actually sit down and manually type in all those instructions) or a functioning URL (such URL's as do appear in the book do not seem to be working as of this writing, Mar. 2007).

I was hoping to get something more comprehenive, and that could function as a stand-alone text. This book seems to be neither. The technical details are all to be found elsewhere, and the functional aspects that might translate into an actual course of study are simply not to be found at all. Dr. Chaitin notes that the original technical work of his, published in the 60's, had a formal error that has since been corrected. Quite frankly, I would rather have that work plus a footnote regarding the later developments, than this volume which (sadly) I find of no real help. (I have since ordered and received a used, 1987 imprint of his "Algorithmic Information Theory" as printed by Cambridge.)

Alternatively, and perhaps more importantly, I would very much liked to have seen this "course" developed as a *COURSE*, rather than as three more or less popular, and largely independent, lectures. These lectures seem, at best, only to minimally build upon one another. A more integrated and coherent work that developed its subject in a step-wise manner, rather than repeating itself with only slightly different glosses, is something that I would have liked much more.

My background in logic and computer science, while not trivial, remains that of a studious and committed autodidact. It is possible that someone with less of a background in topics of formal reasoning than myself would find this book of enormous value. For me, however, it lacked both the technical details to make it a worthy struggle, and the pedagogical depth to make it of significant value.

I am not a proffessional JAVA programmer, so keep that in mind when using this review. I find the information hard to read in this book. As a student in the second semester of JAVA, I still need to see good examples of implementation, and this book seems to lack that. There are also mistakes in many places, especially in examples, so it makes it that much harder to learn from this book, and the way the author shows examples of code is hard to follow. I have other books that teach JAVA and find any of them easier to understand and much more useful than this book. I would say that if the intent is to learn the theory of Data Abstraction and Structures, this could be a good book if you can find it easy to read. If you want a reference book, this is the last thing you want to get.

Somehow, this book came across as too narrow and too broad, both at the same time.

Too narrow, in that each chapter was a very detailed study of a specific implementation or idea. The first few chapters, for example, presented particular extensions to the Haskell programming langauge, intended to support parallel programming. Lord knows that parallel systems need all the help they can get. If hard-core functional programming is the answer, though, I'm not sure I heard the question. Functional programmers have been beating their drum for at least 30 years, and still have little effect on the main parade of software development.

What they call "skeletons" seem to be fairly ordinary constructs for parallelism, including co-begin and pipelining. I have trouble getting excited about seeing them presented in obscure notation. I would also have hoped to see more demanding kinds of applications. Ray-tracing was a common one, but ray-tracing is "embarassingly parallel." It's almost hard not to get a parallel speedup approaching 1:1 with the number of processors.

The remainder of the book operates at a very different level. Instead of specific syntax in a specific language, it presents a number of design patterns at a very high conceptual level. Instead of particular implementations on specific processors, it discusses techniques that can be applied across loosely-coupled, web-based ensembles. The design pattern discussion was adequate, but seemed an odd mate for the low-level detail of the book's first section.

Even though I work every day with highly parallel computation, I just didn't come away with much I could use. I found this book frankly disappointing.