Customer Reviews (9)

Very effective introduction to algorithms
The book used in my graduate Intro to Algorithms course, and I think the follow-on. While I am obviously not as well read in this subject as many of the other reviewers, I can say "it worked", and indeed worked well. A course that has a weak text or teacher will not inspire... A-H-O/DACA and Prof. Carlson made the material exciting, even to an "architecture guy". My interests in grad school in the early 80's revolved around tessellation automata (aka systolic arrays and other highly regular compute structures) and big steaming fast computer structures. A-H-O provided me with the best understanding of the kinds of problems faced by the computers which interested me the most, and the kinds of tools needed to understand computational impact and algorithmic structuring of solutions to them. I sincerely with I hadn't lost my copy with the hundreds of annotations in the margins.

still the classic
One of the classics -- a readable and practical textbook with dozens of problems and projects. Great as a reference to basic data structures and algorithms, too!

Not optional
When I was in grad school starting a course in the Analysis of Algorithms, our professor told us there were only two reasonable choices of text for the course.We could use Knuth TAOCP or AHU.Since we were all students, probably starving, we would use AHU.

The very classic
Excluding Knuth's opera (another dimension), this (AHU) is about the other and only renowned classic algorithms book, deseverdly I'd say, together with Cormen-Leiserson-Rivest's (CLR) "Introduction to Algorithms". With the difference that the first and only edition of AHU has been written 16 years before the first (of the two) editions of CLR.

The two books are quite different in the language and formalism used: more formal and mathematical inclined AHU with respect to CLR. I'd say, the very classic style of his authors who have made history in the CS literature with their books (particularly 2 on algorithms and data structures, 2 on Computer Theory, 2 on Compilers, 1 on CS foundations): as these books have been used in most universities around the world for decades, they've proved to be real milestones in the education of thousands of students.

The books differ also in scope, since AHU is certainly not an encyclopedic collection as CLR does, with his roughly 500 pages against 1000. In spite of this, I'd point out the following: my textbook on Algorithms was CLR, but when we got to Complexity Classes (P-NP and theory behind) we "had" to switch to AHU for the simple reason that CLR did not almost mention at all Turing Machines nor Space Complexity, without which is certainly possible to learn e.g. about NP-TIME completeness, but without which, such a path would equally certainly miss some foundamental topics of Complexity Theory.

All in all, then, imo the book truly deserves 5 stars (and perhaps it would deserve a second, updated, edition too ... possibly, imho, through a bit less revolutionary revision job than they did with "Introduction to Automata Theory, Language and Computation").

As a final note, those looking for a more applicative and self-reference than an educational introductory text, could have a look at the two-volumes opera by the former Knuth's pupil, Robert Sedgewick (possibly the more consolidated C or C++ versions).

An excellent presentation of essential concepts
The book elaborates thoroughly on the basics every programmer should be familiar with. If you are into software development, and have found some unfamiliar concepts in the book description - that's a sure sign that you need this book on your desk. ... Read more

Product Description
Picking up where their classic Fundamentals of Computer Algorithms left off, the acclaimed Horowitz/Sahni team offers this new title, available in both Pseudocode and C++ versions. This well-researched text takes a solid, theoretical approach to the subject and lays a basis for more in-depth study while providing opportunities for hands-on learning. Computer Science Press Pseudocode Version ... Read more

Customer Reviews (12)

Good for some purposes
There are essentially three reasons one might want a book on algorithms: (a) to learn how to design algorithms; (b) to learn how to analyze algorithms; and (c) as a reference for algorithms that are already known.This is a decent book for the first purpose, and a poor choice for the remaining two.Organizationally, it is structured around general techniques for algorithm design, which means that techniques of analysis and algorithms for solving specific problems are scattered widely and difficult to find or link together into a logical sequence.

I also find myself sympathetic with other reviewers who complain about the difficulty in understanding the book.The problem is not that the information is difficult, but that the authors often do not approach it seriously.It's easy to tell that they are interested in the general techniques, and that they considered it a chore to explain the mathematics behind analysis.As a result, the mathematical side of the book is not particularly inspired.

That said, though, this is the ONLY book I'm aware of that teaches with this particular organization.If your goal is to create new algorithms for solving problems (particularly combinatorial problems), then this is probably worth a read even if you have to refer elsewhere to fill in some details.

No online corrections/list of errors?
One of the first examples in the book, priming you to analyze the time complexity of random algorithms, goes on to conclude that the probability of rolling 2 6-sided dice whose faces add to ten is 9/36, or 1/4.

Of course, that doesn't make sense and all the examples are bad at explaining how they come to conclusions.Since I can't find any online corrections of errors in the book, I'm already lost, not knowing if I just don't understand or if they just got it wrong.

It would also have been nice if they put in the fairly standard "solutions to every other problem" in the back of the book, or at least offered (at an extra cost, of course) a solution guide.

useless book
i dont understand why authors like horowitz and rajasekharan,write books which they can only read themselves that too under extreme trauma.

i know it may sound harsh, but all the students i have interacted absolutely hate this book,with good reasons too.

too obcure langauge,little explanation of algorithm.

if u read this book u will develop a hatred for algorithms.which is not good at all.

Avery good book!
I dont know why this books has such negative reviews. Its one of the only algo books that covers so many topics in detail.
In most Indian universities, "Introduction To algorithms" By Comer(MIT press) is the standard book for undergrad and Knuths book is used for Grad. But the Comer book is too theoretical. It does not tell you how to think. The Horowitz/Sahni book gives you an idea of how to think intuitively. To see what I mean, read "Greedy algorithms" chapter from both the books and you will start loving Horowitz/Sahni book. My advice is that first understand the concepts from Horowitz/Sahni - it will also cover most maths. Then read Comer. And dont skip the problems
in Comer.

A unique textbook
The most interesting fact about this book is that, as far as I know, it is the only one to provide general guidelines and explicit strategies for algorithm design. It covers most of the known techniques for exhaustive and heuristic traversals of decision trees and should provide an invaluable background to all those that have to solve new problems. More than an introduction to algorithms, it develops a true methodology. ... Read more

Product Description
Algorithms for Computer Algebra is the firstcomprehensive textbook to be published on the topic of computationalsymbolic mathematics. The book first develops the foundationalmaterial from modern algebra that is required for subsequent topics.It then presents a thorough development of modern computationalalgorithms for such problems as multivariate polynomial arithmetic andgreatest common divisor calculations, factorization of multivariatepolynomials, symbolic solution of linear and polynomial systems ofequations, and analytic integration of elementary functions. Numerousexamples are integrated into the text as an aid to understanding themathematical development. The algorithms developed for each topic arepresented in a Pascal-like computer language. An extensive set ofexercises is presented at the end of each chapter.
Algorithms for Computer Algebra is suitable for use as atextbook for a course on algebraic algorithms at the third-year,fourth-year, or graduate level. Although the mathematical developmentuses concepts from modern algebra, the book is self-contained in thesense that a one-term undergraduate course introducing students torings and fields is the only prerequisite assumed. The book alsoserves well as a supplementary textbook for a traditional modernalgebra course, by presenting concrete applications to motivate theunderstanding of the theory of rings and fields.
... Read more

Customer Reviews (2)

an excellent treatment
We used this book in an advanced undergraduate/early graduate class in computer algebra.The book provides a concise and rigorous, but very readable introduction to computational algebra theory, with algorithms written in pseudo code.

Assuming proficiency in programming, as further pre-requisite I would suggest an undergraduate course in abstract algebra (or equivalent mathematical maturity) for maximum benefit.

An excellent collection of algorithms, proofs, and advanced introductory material, written in a (comparatively) breezy style.

Clear and understandable, but some bugs
I found this book very useful as a reference while writing a smallcomputer algebra system.It's a definate must-have for all the hordes ofpeople out there who are rewriting subsets of Maple, Mathematica, etc.Theexplanation of the theory is relatively clear and helpful so that anot-so-theory-inclined person (such as myself) can understand the material. The cost of such clarity is a loss of some conciseness so someone wholives and breathes abstract algebra may desire a more esoteric book (likeWinkler's). The biggest flaw of the book are the poorly debuggedalgorithms.Almost every algorithm presented in the book has some sort ofminor flaw with serious reprecussions on correctness.This results in muchfrustration if you're actually trying to implement the algorithms. ... Read more

Product Description
Drawing upon combined decades of teaching experience, Professors Sara Baase and Allen Van Gelder have extensively revised this best seller on algorithm design and analysis to make it the most current and accessible book available.This edition features an increased emphasis on algorithm design techniques such as divide-and-conquer and greedy algorithms, along with the addition of new topics and exercises.It continues the tradition of solid mathematical analysis and clear writing style that made it so popular in previous editions. ... Read more

Customer Reviews (20)

Like "Where's Waldo" but with variables.
This book contains some good information, but it's written in a pretty annoying fashion. As other people have noted, you'll constantly need to flip back (or forward) pages or whole sections just to figure out where a particular variable or function was defined. It makes the book confusing and time consuming to follow. I'd stick with Cormen's book.

Terrible book
This book was required by my professor because he wrote it (Allen Van Gelder) and I must say it has been one of the worst academic experiences I have ever had. He seems to have some specific way to teach each concept, which takes away from the books ability to explain the fundamentals. In some cases, he talks about a certain type of tree without ever giving an example of that kind of tree. In other cases, he will talk about an algorithm only in terms of "changes" you would make to another algorithm, so that you never get to see the pseudocode for the algorithm you are trying to understand. The pictures are nice, but they would be so much more effective if everything was just explained clearly to go along with them.

Do not buy this unless you need it for a course
This book is not very clear, skips steps, and in general wanders around. This is one of the worst computer science books I have read. Unfortunately I had to buy it for a class; so unless you find yourself in a similar position, don't buy this book.

Readable algorithms book with lots of good information
I don't quite understand all of these negative reviews.This is a solid text for algorithmic analysis that for the most part is at just the right level for most students -- neither too theoretical nor too superficial for the important topics.The graph algorithms material is a nice improvement over the earlier edition.I've used this book as an instructor many times and most serious students have found it to be an effective complement to the material presented in class.

Terrible, don't buy unless required
I had to buy this because my instructor wrote this book and homework assignments were from the book.

The whole book is designed very poorly and I remember having to flip back and forth just to read it straight forward.Let me clarify.As an example, I would be reading a paragraph that refers to page C, so I would go to page C and that page C refers to page A, etc.It was just painful to try to understand what this.

Today (after 5 years later), I use this book as an example of how not to write a book. ... Read more

Product Description

Humans perceive the three-dimensional structure of the world with apparent ease. However, despite all of the recent advances in computer vision research, the dream of having a computer interpret an image at the same level as a two-year old remains elusive. Why is computer vision such a challenging problem and what is the current state of the art?

Computer Vision: Algorithms and Applications explores the variety of techniques commonly used to analyze and interpret images. It also describes challenging real-world applications where vision is being successfully used, both for specialized applications such as medical imaging, and for fun, consumer-level tasks such as image editing and stitching, which students can apply to their own personal photos and videos.

More than just a source of “recipes,” this exceptionally authoritative and comprehensive textbook/reference also takes a scientific approach to basic vision problems, formulating physical models of the imaging process before inverting them to produce descriptions of a scene. These problems are also analyzed using statistical models and solved using rigorous engineering techniques

Topics and features: structured to support active curricula and project-oriented courses, with tips in the Introduction for using the book in a variety of customized courses; presents exercises at the end of each chapter with a heavy emphasis on testing algorithms and containing numerous suggestions for small mid-term projects; provides additional material and more detailed mathematical topics in the Appendices, which cover linear algebra, numerical techniques, and Bayesian estimation theory; suggests additional reading at the end of each chapter, including the latest research in each sub-field, in addition to a full Bibliography at the end of the book; supplies supplementary course material for students at the associated website, http://szeliski.org/Book/.

Suitable for an upper-level undergraduate or graduate-level course in computer science or engineering, this textbook focuses on basic techniques that work under real-world conditions and encourages students to push their creative boundaries. Its design and exposition also make it eminently suitable as a unique reference to the fundamental techniques and current research literature in computer vision.

Product Description
Some books on algorithms are rigorous but incomplete; others cover masses of material but lack rigor. Introduction to Algorithms uniquely combines rigor and comprehensiveness. The book covers a broad range of algorithms in depth, yet makes their design and analysis accessible to all levels of readers. Each chapter is relatively self-contained and can be used as a unit of study. The algorithms are described in English and in a pseudocode designed to be readable by anyone who has done a little programming. The explanations have been kept elementary without sacrificing depth of coverage or mathematical rigor.

The first edition became a widely used text in universities worldwide as well as the standard reference for professionals. The second edition featured new chapters on the role of algorithms, probabilistic analysis and randomized algorithms, and linear programming. The third edition has been revised and updated throughout. It includes two completely new chapters, on van Emde Boas trees and multithreaded algorithms, and substantial additions to the chapter on recurrences (now called "Divide-and-Conquer"). It features improved treatment of dynamic programming and greedy algorithms and a new notion of edge-based flow in the material on flow networks. Many new exercises and problems have been added for this edition.

As of the third edition, this textbook is published exclusively by the MIT Press. ... Read more

Customer Reviews (16)

The book for a valley interview
Studying this book will help you land a job faster and for better pay. (It will improve your day to day coding, too.) Go in ready for Dijkstra's algorithm, and you are ready for any interview question.

I bought this book as per [...], and prepped as hard as I could (while holding a job) for a little over a month before a Google interview. I read it and did exercises in just about every spare moment.

They rejected me, but when my whole department got the ax soon after, that prep helped me end up with two different offers, both significantly better than the old job.

One of the most complete books in the field of algorithms
Books about algorithms can be divided into two big groups: Those that mainly explain common applied algorithms (sorting, number theory, graph problems, information retrieval, etc.) and another group that revolves around algorithm design techniques (divide and conquer, dynamic programming, greedy, etc.). One example of the latter is "Fundamentals of Algorithmics", by Brassard & Bratley. This book is more oriented towards common applied algorithms, but there are also interspersed chapters about the most common design techniques. This is important specially if you're engaged in an undergraduate course; ask your instructor first about the type of course (s)he is planning to teach.

Mathematical background

Algorithms are mathematics. While reading this book requires less mathematical knowledge and fluency than reading Knuth's "The Art of Computer Programming", you should have done a little programming before, and possibly have taken a course in elemental calculus (summations, products...) and discrete structures (sets, relations, graphs...). Don't worry if you don't remember all of this stuff, the appendices are excelent and cover this material concisely, in case you need it while reading the book.

Ease of reading

The book is designed in a way that it's easy to read from cover to cover, but you can also read only the individual chapters that interest you with no problem at all. Algorithms are described with pseudocode that is similar to modern procedural languages (Java, Pyton, C++...). They are explained both graphically and textually, in a step by step manner. This is invaluable when you are facing a rare of difficult algorithm.

Comprehensiveness

The book is more that 1000 pages long, and covers a lot of algorithms. One could say that the most important algorithms used in computing are in this book. There's also a part about basic and advanced data structures that could make a book on its own. It covers lots of material and perfectly fits with the style of the rest of the text.

Should I buy the third edition if I already have the second edition?

It's up yo you. To help you decide, the most prominent additions to the third edition are a chapter about parallel algorithms (very important for the current and future software engineers), new exercises and problems (please, try them because they will improve your thinking!), and better pseudocode.

nice book
nice quality, excellent content, it is really significant for mathematics or computer science students to have this book~

COMPLETE ALGORITHM
It is Comprehensive, Complete and Sufficient (no need of other books).

Some chapters dive into theory, but lots of content, computations.

Graph theory is included extensively.

Introduction to Algorithms, 3rd Ed. By Thomas Cormen, Charles Leierson, Ronald Rivest, Clifford Stein. (MIT Press)
Algorithms, which perform some sequence of mathematical operations, form the core of computer programming. Intended as a text for computer programming courses, especially undergraduate courses in data structures and graduate courses in algorithms, an "Introduction to Algorithms" provides a comprehensive overview, that will be appreciated technical professionals, as well.

The major topics presented are sorting, data structures, graph algorithms and a variety of selected topics. Computer programmers can draw desired algorithms directly from the text or use the clear explanations of the underlying mathematics to develop custom algorithms. The algorithms are presented in pseudocode that can be adapted to programming languages, such as C++ and Java. The focus is on design rather than implementation.

While a solid background in advanced mathematics and probability theory is needed to fully appreciate the material, non-programmers and IT professionals (such as this reviewer) will appreciate the numerous tips provided for improving the efficiency and thus reducing the cost of developing applications.

Any Computer Science student would find this text an essential resource, even if not specifically required for course work. However, the advanced mathematical principles needed to grasp the material are presented as exercises, intended to be worked through in class, so no solutions are provided, which may frustrate self-studiers and limit its utility as a reference. Although surprisingly well written, a book of this size and complexity is bound to have some errors. See [...] for the error list and supplemental information about the book (including solutions to some, but not all exercises, and an explanation of the corny professor jokes sprinkled throughout the text). ... Read more

Product Description
Driven by the demands of research and the entertainment industry, the techniques of animation are pushed to render increasingly complex objects with ever-greater life-like appearance and motion. This rapid progression of knowledge and technique impacts professional developers, as well as students. Developers must maintain their understanding of conceptual foundations, while their animation tools become ever more complex and specialized. The second edition of Rick Parent's Computer Animation is an excellent resource for the designers who must meet this challenge. The first edition established its reputation as the best technically oriented animation text. This new edition focuses on the many recent developments in animation technology, including fluid animation, human figure animation, and soft body animation. The new edition revises and expands coverage of topics such as quaternions, natural phenomenon, facial animation, and inverse kinematics. The book includes up-to-date discussions of Maya scripting and the Maya C++ API, programming on real-time 3D graphics hardware, collision detection, motion capture, and motion capture data processing.

* The leading text for animation courses that have a technical focus
* Includes companion site with contemporary animation examples drawn from research and entertainment, sample animations, and example code
* Decribes the key mathematical and algorithmic foundations of animation that provide the animator with a deep understanding and control of techniqueAmazon.com Review
What many digital animators fail to realize is that someone needs to make the software that's used to bring images to life. Without the tools, the ideas can never be materialized. In Computer Animation: Algorithms and Techniques, the concepts and formulas used behind the scenes and under the hood of contemporary animation software are clearly explained for the programmer and the technical director.

Hardbound, liberally illustrated, and with an eight-page color gallery, there are six chapters and three appendices. The book starts with an overview of animation and works through some technical background information, and then delves into interpolation and basic techniques for representing 3-D motion and space on a 2-D display. Later chapters walk through advanced algorithms (kinematics, rigid body simulation, constraints) and then a discussion of ways to represent natural phenomena. There's also a focus on modeling and animating articulated figures. It's important to note that these chapters are not about which buttons to push in a given software package, but rather about the use and explanation of formulas for representing a specific simulation.

Perhaps the best feature of the book is the information and samples available on a companion Web site. Rather than include a CD-ROM, which raises the cost of the book and whose information can grow stale, the reader can find sample animations and ready-to-use code snippets, as well as links to other relevant Web sites.

There are any number of books available on computer animation software packages, but precious few on how they do what they do. Computer Animation: Algorithms and Techniques is an invaluable resource, a textbook for anyone interested in computer animation programming or for anyone who simply wants to get under the hood of their favorite animation application. --Mike Caputo ... Read more

Customer Reviews (7)

It's alright
The section on inverse kinematics is really good, it goes over some basics pretty well. Gives a pretty good introduction to animation. Didn't read it all the way through but I was able to implement a few chapters with not too much headache.

Wonderful book
The book was absolutely excellent!I got this book as a recommended reference book for my course in digital games and animation, and was bowled over by the book. The concepts in the book are very well-defined, and it really helped me a lot in an animation I am putting together now.

Good book on the math and algorithms of computer animation
This book is not about how to accomplish animation using prepackaged software nor is it about art design for animation. Instead, it is aimed at computer science students who wish to write programs that perform animation and want to understand the algorithmic and mathematical issues behind that task.
Chapter one is a broad history of computer animation, and it would be misleading to think that this is a typical chapter in this book. Chapter 2 is a broad overview of computer graphics topics. It mentions quaternions, transformation matrices, the rendering pipeline, and I think it is meant to be a quick review more than an instructive chapter. If you are not already familiar with the material in chapter 2 this book will be over your head.
Chapters 3 through 6 are the meat of the book for those interested in computer animation algorithms. Chapter 3 presents low level details on interpolation and not only shows the math but also shows code fragments in C on how to accomplish some of the tasks mentioned. Chapter four presents more advanced algorithms such as camera control, kinematic modeling, rigid body simulation, flocking behavior, and collision detection. Again in this chapter mathematics of the algorithms is presented along side of C code to accomplish the tasks.
Chapter 5 changes topics from the discussion of object motion and the underlying physics to the topic of natural phenomena. The author does a good job of laying out clearly the basics of the mathematics behind these effects. However, he does seem to gloss over details more than he did in previous chapters. The same is true of Chapter 6 on the modeling and animation of articulated figures. The basics are all there, but there just wasn't enough detail to satisfy me.
As for the companion website, it is working at the time I am writing this review. However, the problem I have with books that have companion sites in place of an accompanying CD is that over time these websites are usually neglected and at worst, disconnected. However, an accompanying CD is always shipped with a new book.
Overall, this book is the best compromise I've found between accessible and comprehensive on this subject, and I would recommend it to anyone thinking about writing their own computer animation code.

Deft Introduction to Animation
I'll tip my hand--I'm also a student of the author.

That said, there are some objectively excellent qualities to this book.For starters, the book is undeniably thorough.It includes a brief history of the genre of computer animation (a welcome touch) and a chapter on background information usually covered in any introductory graphics course.

The math used in the book is considerable, and some students will probably find themselves overwhelmed with calculus and linear algebra.(If so, graphics may not be the field for you!)As a courtesy, Dr Parent included appendices with background mathematics and physics which will help fill in the gaps and calm some of the more distraught readers.Code is also provided inline as an assist to the student, which may clarify some of the math involved.(A trifling complaint is that the code is not object-oriented.)

Readers who do not have a math background needn't worry if they are not planning on implementing any of the algorithms described in the book.The math is provided as necessary for implementation purposes.Students who do plan on implementing the algorithms would do well to have taken a numerical methods course; some knowledge of linear algebra and calculus is necessary as well.

On the whole, this book is an excellent introduction to many animation techniques and algorithms.Many of them are complex and will require a lot of effort to understand and implement, so students should be prepared to spend a bit of time going through it.They'll be happy to find that the book is laid out well and very readable.

And references are provided at the end of every chapter--there's plenty of material for students who are looking for more detailed information about any of the topics.

Broad overview with excellent clarity and depth
This book serves as an excellent guide to the technical and aesthetic challenges within the large field of computer animation. The greatest strength is the author's ability to compress an extensive amount of information into core equations and knowledge.Each chapter imparts a mastery of basic concepts and an introduction to more advanced areas of study.Also of note are the extensive, quality references listed at the conclusion of each chapter.The author's experience in the field of computer graphics (dating back to the birth of the field in the late 1960's) shines through in the high quality and candid nature of his exposition.Although I'm a little biased because of being taught by the author, I have no hesitation in recommending this text to students and professionals who desire a broad and technical look at the field of computer animation. ... Read more

Product Description
A cookbook of the hottest new algorithms and cutting-edge techniques in image processing and computer vision

This amazing book/CD package puts the power of all the hottest new image processing techniques and algorithms in your hands. Based on J. R. Parker's exhaustive survey of Internet newsgroups worldwide, Algorithms for Image Processing and Computer Vision answers the most frequently asked questions with practical solutions.

Parker uses dozens of real-life examples taken from fields such as robotics, space exploration, forensic analysis, cartography, and medical diagnostics, to clearly describe the latest techniques for morphing, advanced edge detection, wavelets, texture classification, image restoration, symbol recognition, and genetic algorithms, to name just a few. And, best of all, he implements each method covered in C and provides all the source code on the CD.

For the first time, you're rescued from the hours of mind-numbing mathematical calculations it would ordinarily take to program these state-of-the-art image processing capabilities into software. At last, nonmathematicians get all the shortcuts they need for sophisticated image recognition and processing applications.

On the CD-ROM you'll find:
* Complete code for examples in the book
* A gallery of images illustrating the results of advanced techniques
* A free GNU compiler that lets you run source code on any platform
* A system for restoring damaged or blurred images
* A genetic algorithms package ... Read more

Customer Reviews (10)

Good book; somewhat sloppy code
Clear and simple book, goes right to the guts. One minus is sloppy code. It's written by a scientist who is not a programmer. Implementations are slow and sometimes inaccurate. For example, function nays8 counts 0's in one thinning algorithm. Function snays count 0's in another thinnnig algorithm, while nays8 now count 1's!
Most of these comes from straightforward implementation of ideas. Sure enough, exactly this makes his code a good starting point in writing more effective programs.

Good book for C++ programmers
It's a good book for people who is working in Computer Vision with C++ language. There are explanations of some algorithms and their respective implementation in C++, so it's very helpful. Furthermore, after each topic there is a bibliography list about this topic, which is better than have all bibiography in the last part of the book.
The only drawback is that the quality of the book is not good. The pages are very easy to tear.

An unusually clear book -- and great for OCR researchers.
This nifty book is unusual in several respects: it is written in an extremely clear and simple style; it presents good clear code, both in print and on the accompanying CD; and it presents a variety of different methods for achieving each given goal. For example, the book presents a half-dozen different algorithms (usually with code) for edge-detection, for thresholding, and for skeletonization. For the most part, the book does a good job of explaining the relative merits or suitabilities of the different algorithms.

It's important to say, though, that this book is not a comprehensive introduction to image processing issues and algorithms (such as Gonzales&Woods), nor is it a soup-to-nuts cookbook of code (such as Myler&Weeks' admittedly dated "Pocket Handbook"). Although the book is written in a style that students could understand, I wouldn't recommend it as a first book for novice students. It would be better suited to a non-specialist who nevertheless needs to accomplish something specific -- like thresholding or edge-detection -- in short order, and with an algorithm that's tuned to their particular application.

One last thing: this book will be VERY MUCH appreciated by anyone seeking a foundation in optical character recognition.

Outstanding source of implementations of image processing algorithms
This book is a great source of code for the implementations of common and not so common algorithms used in image processing and computer vision. It is not meant to be a textbook on either subject. For that I suggest you turn to "Digital Image Processing" by Gonzalez and Woods for the subject of image processing and to "Computer Vision" by Linda Shapiro for computer vision.
The book starts out with the treatment of a common subject - edge detection - and provides code for various edge detectors including Canny, Shen-Casten, and Marr-Hildreth.
Chapter 2 does a pretty good job of explaining digital morphology, the various operations, and their uses.
Chapter 3 has a very brief introduction to gray-level segmentation, and then jumps into more advanced topics such as the method of iterative selection, entropy, fuzzy logic methods, and the method of Chow and Kaneko, among others. Most of the methods here are somewhat mathematically involved, and the author does a pretty good job of explaining the mathematics and showing resulting images that show the strengths of each method.
Chapter 4 is about the calculation and use of texture in image processing and computer vision. Again, the mathematics here can get involved and equations and illustrations are included to help make the concepts clear. Even fractal geometry and its use in texture is very briefly mentioned.
Chapter 5 is one of my favorites, since it covers the topic of skeletonization, which is not commonly covered in most vision or image processing books. The most common method is mentioned first - that of the medial axis transform. This is followed by a discussion of iterative morphological methods and also the use of contours. Finally, the chapter is rounded out with an explanation of the Zhang-Suen/Stentiford/Holt combined method and accompanying code. This method usually produces the best combination of good visual results and computational efficiency.
In Chapter 6, on image restoration, the author moves to the frequency domain and discusses the Fourier Transform, the FFT, and their uses in image restoration. The author provides his own image restoration system, the Eagle Restoration System, complete with code.
Chapter 7, on wavelets, is a very brief and not too satisfying introduction to the topic. The author does provide some mathematics and some code for some basic transforms, but does not provide much in the way of motivation.
Chapters 8 and 9, on optical character recognition and symbol recognition respectively, are two very good chapters on this subject. It provides the simple introductory information on recognizing printed alphabetic characters. It also talks about skew detection in the case of slanted lines of text. Chapter 9 expands the concepts with a very good section on neural networks and character recognition concluding with a system that recognizes printed music.
Chapter 10, the final chapter of the book, was an OK introduction to genetic algorithms and evolutionary computing. However, like the chapter on wavelets, I found it a bit thin.
The appendix contains a listing of all of the C code included on the CD and each program's purpose. Going through the individual programs was, for me, almost as educational as reading the book, since the code is very well laid out and commented. I highly recommend this book to individuals looking for implementations and discussions of certain image processing and computer vision algorithms.

I like this book
It has source C code available, which I found is very helpful. It would be better if its code is written in C++. ... Read more

Product Description
The bible of programming theory and practice is being updated for the first time in more than 20 years. The book is concerned with information structures--the representation of information within a computer, the structural interrelations between data elements and how to work with them efficiently, and applications to simulation, numerical methods and software design.Amazon.com Review
This magnificent tour de force presents a comprehensiveoverview of a wide variety of algorithms and the analysis of them. Nowin its third edition, The Art of Computer Programming, Volume I:Fundamental Algorithms contains substantial revisions by theauthor and includes numerous new exercises.

Although this book wasconceived several decades ago, it is still a timeless classic. One ofthe book's greatest strengths is the wonderful collection of problemsthat accompany each chapter. The author has chosen problems carefullyand indexed them according to difficulty. Solving a substantial numberof these problems will help you gain a solid understanding of theissues surrounding the given topic. Furthermore, the exercises featurea variety of classic problems.

Fundamental Algorithms beginswith mathematical preliminaries. The first section offers a goodgrounding in a variety of useful mathematical tools: proof techniques,combinatorics, and elementary number theory. Knuth then details theMIX processor, a virtual machine architecture that serves as theprogramming target for subsequent discussions. This wonderful sectioncomprehensively covers the principles of simple machine architecture,beginning with a register-level discussion of the instruction set. Alater discussion of a simulator for this machine includes an excellentdescription of the principles underlying the implementation ofsubroutines and co-routines. Implementing such a simulator is anexcellent introduction to computer design.

In the second section,Knuth covers data structures--stacks, queues, lists, arrays, andtrees--and presents implementations (in MIX assembly) along withtechniques for manipulating these structures. Knuth follows many ofthe algorithms with careful time and space analysis. In the section ontree structures, the discussion includes a series of interestingproblems concerning the combinatorics of trees (counting distincttrees of a particular form, for example) and some particularlyinteresting applications. Also featured is a discussion of Huffmannencoding and, in the section on lists, an excellent introduction togarbage collection algorithms and the difficult challenges associatedwith such a task. The book closes with a discussion of dynamicallocation algorithms.

The clear writing in FundamentalAlgorithms is enhanced by Knuth's dry humor and the historicaldiscussions that accompany the technical matter. Overall, this text isone of the great classics of computer programming literature--it's notan easy book to grasp, but one that any true programmer will studywith pleasure. ... Read more

Customer Reviews (49)

Hard, but worth the effort
This is one of those books that separates the computer scientist from the 'programming for dummies' crowd.

Yes, assembly is not used much in practice, but understanding algorithms at the assembler level is absolutely necessary. The math is absolutely necessary. Computer science and programming are mathematical disciplines, this can not be overstated. Not understanding the mathematics is as bad as not understanding computation at the assembler level. It's like trying to come up with an encryption algorithm without understanding abstract algebra, it is even like coming up with a regular expression without understanding automata. Sure, you can create an encryption algorithm without the math, but it will be cracked easily, and your regex will likely be inefficient, and you won't be able to write one for anything mildly complex without understanding automata. It is the same thing with understanding algorithms and not understanding the math and what is going on under the hood. Granted, if you are a .NET of Java EE "programmer" that simply ties method calls together, you might not need this, but are you really a programmer? And when something bites you hard, will you blindly try "stuff" to fix it, or will be able to understand what went wrong and how to properly fix it?

Knuth's books give you this understanding that will lift you from API monkey status to programmer. It is timeless in the sense that the concepts in the book never change. It doesn't matter that languages change, the underlying concepts do not. They have just been abstracted to the point where people can read a dumbed down book and think they can program.

Painful
Yes, I know, we devs should all pay homage to the great Knuth.I don't dispute it.But I also don't want to read a textbook.That's what this is.And unless you're writing low level algorithm libraries, you have no business reading this book.'Cause if you can't grasp the basics already, this book will do more to scare the crap out of you than anything else.

For the hardcore only!

Algorithms, Data Structures, Computing Machine, Analysis
This is a classic book on algorithm analysis and also in programming techniques. The first one for which author create a hypothetical computing machine (he call it MIX), his own style to describe algorithms, a machine operation instruction and data representation, an assembly language (he call it MIXAL) for map algorithms and data structures into reality.

In another sense: it's a self-contained book.

Each chapter includes a historical review of concepts and methods.


Important topics
----------------
* Section 1.2. Mathematical basement for algorithm performance analysis. Includes a review of Numbers, Powers, Logarithms, binomial coefficients, and also an example of algorithm analysis using "Kirchhoff's first law" for inputs/outputs (flow to/from each step).

* Section 1.3. Description of the hypothetic computing machine (MIX): memory word, registers, comparison and overflow indicators, input/output device names, machine instruction format, machine instructions.

* Section 1.3.2. Description of the assembly language (MIXAL). Includes an interesting figure on relation between machine instruction codes and assembly language representation.

* Section 1.4.1. Introduce concepts of subroutine and co routine. Co routine is described as a team of sub-programs ideal for multi-pass algorithms (the kind used for processing a stream input).

* Section 1.4.3. Introduce in the field of interpretive routines and simulators. The author tells you how good programmers are at the same time good machine designers (as is the same today with virtual machines and little languages as Java). It includes a simulator program for the hypothetical MIX computing machine. You will learn how a state machine or sequential machine is implemented using a so called Control Routine (complement this reading with section 5.1 of "Computer Organization & Design" by Patterson and Hennessy - see my review for that book).

* Section 2.2.5. Describes the use of doubly linked list data structure by using a discrete simulation example (author use previously reviewed concepts like coroutine and control routine). You learn how the idea of coroutine is a base for discrete simulations. Also, author use what he call a "pseudo parallel procedure": a WAITLIST. This kind of procedure was used during 1960s and 1970s as a multi-task procedure.

* Section 2.3.2. Describe binary trees. The highlight of this section is a "Differentiation" algorithm. The author uses an algorithm to traverse a tree in post-order with each node representing a symbol. He then implements the algorithm using a control routine like the one implemented in Sections 1.4.5 and 2.2.5. The control routine includes a "Jump Table" for processing each node.

In resume, the book describes important topics for past and present programmers. I recommend you to read "Computer Organization & Design" by Patterson and Hennessy as an intro. Then read this one. Also you can complement this read with "Fascicle 1." by Donald E. Knuth, which describes an advanced MIX computing machine called MMIX (a 32 bit hypothetical RISC machine similar to DLX machine used on "Computer Architecture: A Quantitative Approach - 2d edition" by Patterson and Hennessy. Also, "The Art of Computer Programming, Volume 3" will very useful (Balanced Trees algorithm for example, as a "self-reshaping" structure).

Just try sorting and searching with out this book.
This book has saved my bacon several times through the decades. Once I needed to actually build a database package from scratch instead of using a commercial package.

I almost did not buy it when all I saw in it was mostly math. But I was desperate and it paid off. Turns out you could not explain it any other way. I use it primarily for balanced trees. I may try some thing more exotic later.

The set also looks impressive in the library.

Mechanical things: foundations
"The Art of Computer Programming" (TAoCP) is about machines and mechanical methods.

TAoCP is "about timeless truths" as the author writes. It's about CPU registers and memory cells. It's about counting the number of machine cycles a program will take. It's about precision. It's not about creating fancy Excel macros or adding pop-up windows to your web page.

Volume one contains two chapters. Chapter One first defines algorithms, gives basic math concepts for computer science starting with Mathematical Induction, continuing with a section on how to analyse algorithm, plus a couple of sections for people familiar with mathematical analysis (i.e. the math behind calculus). It ends with a complete description of MIX, a fictional computer, and of the machine language for programming MIX. (Note: MIX will soon be upgraded to the equally fictional MMIX). I won't repeat the author's rationale for sticking to machine language, and a fictional one at that! Suffice it to say that he has his reasons.

Chapter Two is about lists and trees, the most fundamental of data structures. Stacks, queues, and deques are lists with one or two entry and exit points. Linked lists have as many entry and exit points as there are elements, but careful! you need to worry about linking elements to one another, and ending with correct linking when adding or removing an element. And then there are trees, and the many ways to visit all nodes in a tree exactly once. Leftmost node first? Last? Middle node first?

Who should read this then? Patient people! Knuth published the first volume in 1966 and plans to finish the final edition of the fifth volume in 2015. This is not a For Dummies book, so don't expect to speed read through it. I skimmed the whole thing cover to cover, skipping the exercises and occasionally working hard at achieving perfect understanding of two or three pages (several hours!). I'm now going through it again more slowly, part by part, doing some of the problems. If I want, I can have fun with this book for the rest of my life.

Apart from that, well obviously computer science academics will enjoy TAoCP and find inspiration here for classes and tutorials. This is a monograph, so it is complete and mostly self-contained. It is also accessible to anyone willing to put in the hours to read it, and very little beyond a little programming experience is required.

Most of all, TAoCP is for people who enjoy thinking for its own sake, people who enjoy puzzling out and finding tricky solutions to what might seem like a straightforward problem. Some people enjoy tinkering with cars, others like building model ships. Like these activites, going through the exercises in TAoCP gives us what Fred Brooks calls the sheer joy of creating things.

By the way, it's worth learning MIX. I do the exercises in Perl (egad! I can only handle some of the problems...) but since the solutions are in MIX, it pays to know it well enough to read through Knuth's examples.

Vincent Poirier, Tokyo ... Read more

Product Description
Computer vision encompasses the construction of integrated vision systems and the application of vision to problems of real-world importance. The process of creating 3D models is still rather difficult, requiring mechanical measurement of the camera positions or manual alignment of partial 3D views of a scene. However using algorithms, it is possible to take a collection of stereo-pair images of a scene and then automatically produce a photo-realistic, geometrically accurate digital 3D model.

This book provides a comprehensive introduction to the methods, theories and algorithms of 3D computer vision. Almost every theoretical issue is underpinned with practical implementation or a working algorithm using pseudo-code and complete code written in C++ and MatLab®. There is the additional clarification of an accompanying website with downloadable software, case studies and exercises. Organised in three parts, Cyganek and Siebert give a brief history of vision research, and subsequently:  

• present basic low-level image processing operations for image matching, including a separate chapter on image matching algorithms;
• explain scale-space vision, as well as space reconstruction and multiview integration;
• demonstrate a variety of practical applications for 3D surface imaging and analysis;
• provide concise appendices on topics such as the basics of projective geometry and tensor calculus for image processing, distortion and noise in images plus image warping procedures.

An Introduction to 3D Computer Vision Algorithms and Techniques is a valuable reference for practitioners and programmers working in 3D computer vision, image processing and analysis as well as computer visualisation. It would also be of interest to advanced students and researchers in the fields of engineering, computer science, clinical photography, robotics, graphics and mathematics. ... Read more

Customer Reviews (2)

Quite complete and easy to understand
Although Hartley's book offers a deeper perspective on stereo 3D reconstruction, it is also aimed at an audience with a higher knowledge on this area, both mathematically and conceptually.
This book on the other hand offers a more simplistic solution but it also offers a good review on disparity and point correspondence estimation, which on Hartley's book is barely covered.
As each of theese books offfers a slightly different point of view on the matter, I suggest having both as good references on the subject.

state of the art for 2008
For professional researchers in computer vision, this book is useful as a summation of the state of the art for 2008. It is comparable to Davies' Machine Vision : Theory, Algorithms, Practicalities (Signal Processing and its Applications) from 2004.

The text starts with a general outline of the problem, giving basic ideas and deploying the maths needed in many of the algorithms. Tensor analysis is widely used and you need to be familiar with it.

As befitting the title, little space is devoted to 2D image recognition. The far more difficult problem is to identify "strong" characteristics of a desired object embedded in a 3D space. Methods like Haar transforms are invoked. But overall, the human eye, backed up by the brain's wetware, is still a more robust detector. The state of the art has further to progress. ... Read more

Product Description
In the last 40 years, machine vision has evolved into a mature field embracing a wide range of applications including surveillance, automated inspection, robot assembly, vehicle guidance, traffic monitoring and control, signature verification, biometric measurement, and analysis of remotely sensed images. While researchers and industry specialists continue to document their work in this area, it has become increasingly difficult for professionals and graduate students to understand the essential theory and practicalities well enough to design their own algorithms and systems. This book directly addresses this need.

As in earlier editions, E.R. Davies clearly and systematically presents the basic concepts of the field in highly accessible prose and images, covering essential elements of the theory while emphasizing algorithmic and practical design constraints. In this thoroughly updated edition, he divides the material into horizontal levels of a complete machine vision system. Application case studies demonstrate specific techniques and illustrate key constraints for designing real-world machine vision systems.

· Includes solid, accessible coverage of 2-D and 3-D scene analysis.
· Offers thorough treatment of the Hough Transform-a key technique for inspection and surveillance.
· Brings vital topics and techniques together in an integrated system design approach.
· Takes full account of the requirement for real-time processing in real applications. ... Read more

Customer Reviews (5)

use it to understand OpenCV
For the analyst wanting to get into image recognition, Davies offers a detailed look at the many methods used in the last 30-40 years. These include neural networks, support vector machines, and the Hough transform.

If you are tempted to use [or are using] the OpenCV code base for image research, then the book can be a vital theoretical framework. OpenCV is about the best open source image code out there on the net, but it is poorly documented. It does come with many methods for basic and vital operations like make a grayscale image from a colour image, and making a binary image from a grayscale image. But why the code does certainthings (actually many things) is rarely explained. Try using this book for understanding. Plus, the text lets you get an idea of how to modify OpenCV for your purposes.

And if you are going to use this book with OpenCV, look closely at the section on using multiple classifiers for training and then testing against unknown images. It is the basic idea for the cascading classifiers used by OpenCV.

Along these lines, one improvement for a future edition of the book could be an analysis of code packages that are currently available for image processing. Just a thought. But it would greatly help people wanting an expert assessment on the efficacies of available packages. Or, on a more basic level, it would aid simply in delineating what is out there.

Good survey of specific machine vision techniques
To begin with, the latest edition of this book was published in 2004, so all reviews dated earlier than that are referring to a previous edition. This book is a good one on issues and algorithms as they pertain to machine vision versus general computer vision. If you want a good general textbook on computer vision try "Computer Vision" by Linda Shapiro. It has all of the background material and a firm foundation in all of the topics you would expect in a course on computer vision. This book also has a section on introductory computer vision topics, I just don't think it is as clear and as comprehensive as Shapiro's book, especially for students.

However, if you want an excellent treatment of the kinds of problems specific to machine vision - the detection of lines, holes, corners, circles, elipses, and polygons, for example, along with specific algorithm details, this book is very good. It also has good sections on pattern matching, motion estimation, and 3D machine vision. I would recommend it especially for those individuals who are already familiar with the basics of computer vision and would like a book on algorithms for solving specific problems in machine vision. I notice that Amazon only shows the table of contents for the previous edition, so I show the table of contents for the new edition next:

1. Vision, The Challenge

PART 1 - LOW-LEVEL VISION
2. Images and Imaging Operations
3. Basic Image Filtering Operations
4. Thresholding Techniques
5. Edge Detection
6. Binary Shape Analysis
7. Boundary Pattern Analysis
8. Mathematical Morphology

PART 2 - INTERMEDIATE-LEVEL VISION
9. Line Detection
10. Circle Detection
11. The Hough Transform and Its Nature
12. Ellipse Detection
13. Hole Detection
14. Polygon and Corner Detection
15. Abstract Pattern Matching Techniques

PART 3 - 3D VISION AND MOTION
16. The Three-Dimensional World
17. Tackling the Perspective n-Point Problem
18. Motion
19. Invariants and their Applications
20. Egomotion and Related Tasks
21. Image Transformations and Camera Calibration

Part 4 - TOWARDS REAL-TIME PATTERN RECOGNITION SYSTEMS
22. Automated Visual Inspection
23. Inspection of Cereal Grains
24. Statistical Pattern Recognition
25. Biologically Inspired Recognition Schemes
26. Texture
27. Image Acquisition
28. Real-Time Hardware and Systems Design Considerations

PART 5 - PERSPECTIVES ON VISION
29. Machine Vision, Art or Science?

Solid Foundation to computer Vision
First of all I like this book very much. This book provides a solid and concrete foundation to computer vision from engineering point of view. The basic issues are treated very well in the conceptual and practical levels (e.g. edge detection). I came from a photogrammetry background, which means that the geometric aspects are very dominant in my thinking, and this book emphasize many geometric concepts in computer vision specially the treatment of Hough Transform as a main theme in the book. I recommend this book to the practitioners in spatial sciences (GIS, Remote sensing, Photogrammetry, etc) as well as the general community of computer vision.

Excellent resource
Covers many aspects of vision, from basic image processing through high level scene analysis.It doesn't always go down to the nitty-gritty source code level for every topic, but it does provide the direction to handle most every common machine vision problem.Of the ten or so general machine vision books on my easy-access shelf, this is the one I seem to pull down the most.

Good structured reference, very useful
A very clearly structured book which is useful as a reference. Covers a lot of subjects (filtering, detection of shapes [lines, circles, holes and more], pattern matching/recognition, motion, invariants, ...), includingthe implementation aspects (hard/software). The chapters sometimes do notgo much into deep but provide further references. Recommended book! ... Read more

Product Description

Customer Reviews (8)

One of the worst textbooks
One has to read reviews of textbooks with a great deal of skepticism.The students reviewing it are often struggling with the material and shift at least some of the blame to the textbook.Another common complaint about this specific subject is the text does not cover enough topics.To me, neither of these apply here.

The book truly is terrible in and of itself.The text does not flow, the examples are poorly written, and the whole is largely incomprehensible.This is neither a good reference nor a useful didactic text.

I recommend Algorithms [Johnsonbaugh & Schaefer; 2003] first, as it's a clear text and the pseudocode is quite readable.My second recommendation would be Introduction to Algorithms [Cormen, Leiserson, Rivest, and Stein; 2009].

I had this text in graduate school.I have not looked at it again.Nearly 10 years, and this text stands out as the worst I've ever had.

not too good,
Not the worst, but there are better algorithm books out there
ie. algorithms by dasgupti

Good idea, poor implementation
Actually, I was pretty impressed when I saw the contents of the book - it looked like it covers lots of practical programming aspects, in addition to the algorithms basics & advanced topics. But I was pretty disappointed - the book is almost unreadable and the code it pretty poor (I'm not a C++ guru myself, but it looks like the code in the book was written by the C++ amateur - I've had that 'wtf' feeling pretty often).
However, the book is not a complete disaster. It has pretty nice exercises as well as giving pretty complete list of topics that you can 'google' (or find somewhere else) then.
Fortunately, I've borrowed that book from the university library - I would never spend 71$ for that.

Obviously not for the faint of heart.
... If the primary complaint against this text is that the authors have not provided enough C++ source code examples for the types of algorithms explained, take a look at the price tag.At a list price of [price], one can logically deduce that this text is for a university audience, emphasizing the theory behind the algorithms, as well as the synthesis it takes for you to generate modified versions from the templates presented.If you are looking for a more "how to"-oriented text (you know, the kind that "spoon feeds" you) with excessive source code examples, you definitely should look for another text.Nevertheless, I consider this book to be both highly appropriate and effective for its intended audience.

Buy something else..
Don't waste your money on this text, it is rotten.I had it for a class and found this book to do very little in aiding the learning process due to its lack of any sort of coherent explaination. I ended up purchasinganother textand used it from then and until now, after college.

thisis the only textbook i have ever sold back after the semester. ... Read more

Product Description

Customer Reviews (8)

O'Reilly's Algorithms
This is another great addition to the programmer's bookshelf. I would still recommend "Introduction to Algorithms" if you want to learn algorithms, but this book could serve as a great quick reference. All examples are done in C, which is fine although I would have liked to see other languages.

This book is okay
I have read this book. It is okay book. I bought it to refresh my concept of algorithm and found this book does the job. After I finished reading, I still need to look for another book.

Quickly locate algorithms that relate to the problems that you want to solve
This is my first Safari book that has the free online edition for 45 days.

I have a pretty good collection of books on algorithms. Many O'Reilly books are among the collection. Yet I am most impressed with" Algorithms in a Nutshell "a desktop quick reference. I won't go into a lot of detail as anybody who purchases this book was already know what they're looking for. I am impressed however that for such a small book this goes into a lot of deep concepts and gives you practical solutions.

The best way to see if this book is useful compared to others is to look at sorting algorithms that you know by heart such as median sort and quick sort. If this book tells you what you already know or even does a better job of explaining what you know this is the book for you. This is definitely the book for me.

Even with these examples, that take very little adjustment to put into the real world, you may want to supplement this book with "Sorting and Searching (The Art of Computer Programming, Volume 3)" by Donald E Knuth, Richard S Varga, and Michael A Harrison.

Even if you are not a programmer this book can help you to understand what programmers and or coders are accomplishing with their programs. For people taking any math discipline school this makes a fantastic supplement to understanding math from a different angle.

Sorting and Searching (The Art of Computer Programming, Volume 3)

Delivers as advertised
The book does not aim to be an introduction to, nor the definitive encyclopedia on, the subject of algorithms.

It is intended, as advertised on the cover, as "A Desktop Quick Reference".In the Preface it states that the goal is to provide a useful tool for working programmers to find good solutions to the problems they solve.

As a self-taught programmer I am finding this book interesting to better understand the various ways that the same problem can be solved, and the pros and cons of each.While the book is mainly intended to help programmers review and select appropriate algorithms for a problem at hand, I am using it as a study guide and have enjoyed it as such thus far.While it doesn't exactly make for light reading, each algorithm is considered individually, which makes for a decent size chunk of information which can be considered independently.

Multiple languages (C, C++, Java, Ruby) are used throughout the book in demonstrating the algorithms, solutions are not provided in each language for each algorithm.However, if you are using this as a study guide, this can provide a good exercise to translate the solution into the language of your liking.

Interesting, but...
The preface states that the main purpose of this book is to provide usable implementations of some of the most useful algorithms. To illustrate the superiority of this approach as compared to similar books, the authors present the pseudo-code of the Ford-Fulkerson algorithm as given in Wikipedia and Cormen's textbook. Then they write that such listings are basically useless for a software engineer, who cannot produce working programs from them. He needs a book with real, working, verified implementations rather than pseudo-code and proofs of correctness. This is that book.

After reading this part of the preface in a local bookstore, I read the table of contents and picked at random the section on Linear Programming for a closer look at the contents. This 2-page section provides no code whatsoever. Not even pseudo-code. It uses a commercial mathematical software to solve a problem and advises the readers to do the same. Don't implement anything here because it's too complicated, just use a commercial package. I found this message a bit amusing, and somehow opposed to the stated purpose of the book.

Maybe I was unlucky, and other sections are different. You'll have to check that for yourselves. The book seems otherwise compact in its field, reasonably priced, rich in tables, examples, illustrations and other attention-grabbers. I'd say buy it, but take its promises with a grain of salt.

Incidentally, the Wikipedia article on Ford-Fulkerson provides a Python implementation in addition to the pseudo-code. It might have been added after this book was published. Nevertheless, this shows how quickly some parts of a 2008 book can become outdated. ... Read more

Product Description
This text explains the fundamental principles of algorithms available for performing arithmetic operations on digital computers. These include basic arithmetic operations like addition, subtraction, multiplication, and division in fixed-point and floating-point number systems as well as more complex operations such as square root extraction and evaluation of exponential, logarithmic, and trigonometric functions. The algorithms described are independent of the particular technology employed for their implementation.

Numerical examples illustrate the working of the algorithms presented and explain the concepts behind the algorithms without relying on gate diagrams.

This new edition includes sections on floating-point adders, floating-point exceptions, general carry-look-ahead adders, prefix adders, Ling adders, and fused multiply-add units. New algorithms and implementations have been addedto almost all chapters. ... Read more

Customer Reviews (6)

Excellent but challenging book on computer arithmetic algorithms
Although I found this book very challenging to read at times, the author gave enough examples for each algorithm to help steer me in the right direction. To succeed in reading and understanding the book's content one has to carefully work through the examples and practice with self-created ones to help get the needed insight. Many of the terse explanations and equations require careful thought and analysis from the reader. Often I found myself working out the deatails of some equation to convince myself of the author's assertion. In other words, one has to be actively engaged when working throug the book. The reward for doing seems very profound: namely one gains an understanding of how arithmetic is efficiently performed, and how transcendental functions are realized on a computer. The ability to reduce the foundations of mathematics to a Boolean structural level will no doubt find many applications that go far beyond hardware arithmetic component design. With that said, from basic addition to cosh and sinh, the author delivers as advertised. Dr. Koren has an impressive mastery of this subject.

Amazing collection of ideas but terse in explanation
On a first reading, this book looked horrible. Little explanation is given. Well, the author gives you just a clue for you to do a lot of brainstorming to understand the concepts. While this helps to put you right in the mood for the material, since most of it are highly intellectual, but I think some more explanation and insight would have helped anyway. And actually it would have helped a lot. Instead of relying on each reader's understanding, giving more clues and more explanation means more insight for the reader and more getting the big picture. The big picture here is so important since many of the concepts in this book are highly interrelated.
On a second reading, this book was a very good reference. A good collection of well made, highly intellectual algorithms.
I recommend this book for every computer arithmetic enthusiast, but I suggest it to be read sequentially, and be prepared to a lot of brain storming.

Probably one of best arithmetic books
This book is a fantastic book on digital computer arithmetic that covers the basic algorithms.It covers basic addition, subtraction, multiplication, and division in an easy-to-follow manner.A must-have for those concentrating on digital computer arithmetic.

Note:the reviewer who noted that this book doesn't cover Brent-Kung is wrong.It covers things the way it should!

It is a horrible textbook
I am a graduate student. This book is a first horrible textbook I have had. It is very difficult to grasp the basic concepts from the book. And the content jumps all over the place. The author seems to have the ability to make simple things complicated.

Brilliant book for Brilliant minds !
There are very few books in market that are as packed in content. I like the author's lucid style of emphasizing his points while still maintaining the rigor of the subject. Digital hardware engineers have used and willcontinue using this book for sound design practices and optimized designs. ... Read more

Product Description
Data structures and algorithms are presented at the college level in a highly accessible format that presents material with one-page displays in a way that will appeal to both teachers and students. The thirteen chapters cover: Models of Computation, Lists, Induction and Recursion, Trees, Algorithm Design, Hashing, Heaps, Balanced Trees, Sets Over a Small Universe, Graphs, Strings, Discrete Fourier Transform Parallel Computation. Key features:

Complicated concepts are expressed clearly in a single page with minimal notation and without the "clutter" of the syntax of a particular programming language; algorithms are presented with self-explanatory "pseudo-code."

Chapters 1-4 focus on elementary concepts, the exposition unfolding at a slower pace. Sample exercises with solutions are provided. Sections that may be skipped for an introductory course are starred. Requires only some basic mathematics background and some computer programming experience.

Chapters 5-13 progress at a faster pace. The material is suitable for undergraduates or first-year graduates who need only review Chapters 1-4.

Chapters 1-4. This book may be used for a one-semester introductory course (based on Chapters 1-4 and portions of the chapters on algorithm design, hashing, and graph algorithms) and for a one-semester advanced course that starts at Chapter 5. A yearlong course may be based on the entire book.

Sorting, often perceived as rather technical, is not treated as a separate chapter, but is used in many examples (including bubble sort, merge sort, tree sort, heap sort, quick sort, and several parallel algorithms). Also, lower bounds on sorting by comparisons are included with the presentation of heaps in the context of lower bounds for comparison-based structures.

Chapter 13 on parallel models of computation is something of a mini-book itself, and a good way to end a course. Although it is not clear what parallel architectures will prevail in the future, the idea is to further teachAlthough it is not clear what parallel architectures will prevail in the future, the idea is to further teach fundamental concepts in the design of algorithms by exploring classic models of parallel computation, including the PRAM, generic PRAM simulation, HC/CCC/Butterfly, the mesh, and parallel hardware area-time tradeoffs (with many examples). Apart from classroom use, this book serves as a good reference on the subject of data structures and algorithms. Its page-at-a-time format makes it easy to review material that the reader has studied in the past. ... Read more

Customer Reviews (1)

For Serious Developers
If you have cut your teeth on Donald Knuth's classic three volumes, "The Art of Computer Programming", and you want more detail, at a similar level of complexity, then consider Storer's book.

It delves into lists, recursion, trees, graphs, heaps and sets. Like Knuth, Storer thoughtfully supplies an extensive list of questions at the end of each chapter that will greatly deepen your appreciation of the field if you tackle them. Ok, he doesn't give answers, but think of that as greater incentive on your part to solve them. There are almost 400 questions in the book.

The teaching style is similar to Knuth, in that it has all the rigour needed by an algorithm designer like yourself, without drowning you in epsilon-delta ultra rigour like a pure maths text.

Note that the only code fragments are in pseudocode. This should not be a problem for you. I am assuming you are experienced enough that what you need is understanding of an algorithm, and that manually converting it to code is straightforward and a purely secondary issue.

The take home message is that this is excellent for anyone doing serious programming. ... Read more

Product Description
Traditionally an area of study in computer science, string algorithms have, in recent years, become an increasingly important part of biology, particularly genetics.This volume is a comprehensive look at computer algorithms for string processing. In addition to pure computer science, Gusfield adds extensive discussions on biological problems that are cast as string problems and on methods developed to solve them. This text emphasizes the fundamental ideas and techniques central to today's applications.New approaches to this complex material simplify methods that up to now have been for the specialist alone.With over 400 exercises to reinforce the material and develop additional topics, the book is suitable as a text for graduate or advanced undergraduate students in computer science, computational biology, or bio-informatics. ... Read more

Customer Reviews (13)

A very dense book
Don't get thrown off by the 'bio' in the title. I use it for computer security - signature based intrusion detection.

This is a very dense book for the serious. The author does not waste any time on trivialities. He gives a brief orientation to the notations and jumps into very intricate algorithms right from the start. You will need to draw pictures or make notes on a scratch paper as you read to follow concepts from one paragraph to the next.

This is a treatise on string algorithms.

Good Buy
The book was like new. The shipping was fast. I am very happy with this purchase!!!

phenomenal
This book is absolutely excellent.Gusfield walks the reader from simple concepts in string matching through advanced in a way that I found very easy to follow.Every bioinformatics researcher should have copy of this text.

Well Written Text Book
A well written text book with an obvious bias to biological application, but maybe most useful for its clear explanation and rigour of string algorithms.

nice intersection of computing and biology
The text sits at the intersection of computer science and computational biology. It centres around the observation made by the author and others that often in CS, one has to manipulate strings of text, which are just sequences of text. While in computational biology, a recurrent theme is how to deal with sequences of molecules. These might be in a DNA sample or in a protein.

Surprisingly, from this simple observation, Gusfield manages to gather together considerable material. Over the decades, computing has accrued many algorithms for text string processing. The book's merit is in presenting those which are also applicable in bioinfomatics. The level of treatment is sophisticated, from the computing vantage. Enough so that perhaps the typical geneticist might not be able to easily follow the narrative. But a researcher with a strong background in both fields might be able to benefit. ... Read more

Product Description
Possibly the most comprehensive overview of computer graphics as seen in the context of geometric modeling, this two volume work covers implementation and theory in a thorough and systematic fashion. Computer Graphics and Geometric Modeling: Implementation and Algorithms covers the computer graphics part of the field of geometric modeling and includes all the standard computer graphics topics. The first part deals with basic concepts and algorithms and the main steps involved in displaying photorealistic images on a computer. The second part covers curves and surfaces and a number of more advanced geometric modeling topics including intersection algorithms, distance algorithms, polygonizing curves and surfaces, trimmed surfaces, implicit curves and surfaces, offset curves and surfaces, curvature, geodesics, blending etc. The third part touches on some aspects of computational geometry and a few special topics such as interval analysis and finite element methods. The volume includes two companion programs. ... Read more

Product Description
In classic "cookbook style," this book offers guided access for researchers and practitioners to techniques for the digital manipulation and analysis of images, ranging from the simplest steps to advanced functions.Drawing on their long experience as users and developers of image analysis algorithms and software, the authors present a description and implementation of the most suitable procedures in easy-to-use form.Each self-contained section treats a single operation, describing typical situations requiring that operation and discussing the algorithm and implementation.Sections start with a "before" and "after" pictorial example and a ready-reference listing typical applications, keywords, and related procedures. This new edition has additional sections on Gabor filtering and on threshholding by connectivity, plus an expanded program listing and suggested projects for classroom use.And now the accompanying CD-ROM contains C programs not only as source code for carrying out the book's procedures but also as executables with a graphical user interface for Windows and Linux. ... Read more

Customer Reviews (14)

A must in computational digital image processing
An excellent set of recipes for both researchers and practitioners of different levels on processing of digital images, ranging from simple operations to advanced image analysis in C language. First published in 2008 and subsequently reprinted in 2009 clearly highlights the interest in this valuable textbook.
The second edition, apart from enriched material contained (e.g., Gabor filtering related with wavelets and natural images), it is accompanied by a CD-ROM, which contains C programs both as source codes and executables as well with a graphical user interface for Windows and Linux.
All in all, an excellent computing guide in image manipulation "made in Cambridge."
Radu Mutihac, Prof., University of Bucharest, Romania.

Practical Algorithms for Image Analysis
This is an update to the previous edition with a few new chapters. Good diagrams, illustrations, and bibliography. Sample code is on the CDROM, not in the text. Lots of mathematical formulae in the text. Solid text.

Excellent book

As described on the cover page, this book is cookbook style so I went through the programs on the CD before reading the chapters. I like this book for two reasons.

First, the book is easy to read. A bunch of equations may not always be helpful to understand a problem. What confuses readers most is how an implementation/program corresponds to those equation(s). This book explains the image processing techniques in a plain language and gives you an hand-on experience with those techniques.

Second, to practice image processing, clicking a button on windows or just calling a built-in function, e.g. process(image), will not be enough. When you go to the directory of programs on the CD, you may find out every details. Each program is relatively independent to each other. You will not be stuck by a function call, which you never know or find. Each program is well commented and can be easily modified and incorporated into your program.

This book is good for those who are new to image processing, because it helps you understand what image processing does. It is also good for an experience practicer, because you can find well-organized stuff to build your own applications. It is a must-have book for your shelf of image processing.

plug and play
Searching for an easy plug & play solution for simple imaging tasks?
No time for programming & debugging things yourself?
No interest in crawling through literature to figure what & how you should program "the methods that solves all your problems"?

Here's a book that deals with most of the elementary - and most used - approaches in image enhancement and analysis. The CD offers a collection of ready-to-play-with programs, both in C source as in executables.

I appreciated the book set-up: each section describes one single task, describes the problem, gives an example, discusses a solution given in literature, and presents the input / output / options for the C code.
- If you want to know more: get the recommended references.
- If you want to modify the program: why not? (well, perhaps because the code is good enough!)
- If you don't care about the scientific background and/or programming: just plug & play!

Excellent new reference for document recognition
I have found this book to be extremely useful as a reference for my class on document image analysis. The book discusses (with software which is a bonus!) a whole bunch of image processing techniques that are very useful.

Students can now find in one place- a reference for techniques such as gabor wavelet analysis, convex hulls, moments, fourier descriptors, thinning, hough transform, and chain coding. This allows me as an instructor of an advanced document recognition course to let the students self-study these image processing techniques while I can focus on the recognition topics.

The authors have done a great job of picking examples from a wide range of applications such asoutdoor scenes, fingerprints, and documents.The book is "easy to read" and requires just basics of linear algebra to follow. ... Read more

Product Description
Algorithms and Data Structures in C++ introduces modern issues in the theory of algorithms, emphasizing complexity, graphs, parallel processing, and visualization. To accomplish this, the book uses an appropriate subset of frequently utilized and representative algorithms and applications in order to demonstrate the unique and modern aspects of the C++ programming language. What makes this book so valuable is that many complete C++ programs have been compiled and executed on multiple platforms. Each program presented is a stand-alone functional program. A number of applications that exercise significant features of C++, including templates and polymorphisms, is included. The book is a perfect text for computer science and engineering students in traditional algorithms or data structures courses. It will also benefit professionals in all fields of computer science and engineering. ... Read more

Customer Reviews (2)

I can't believe it! The book got huge mistakes in first page
The formulas of (1.3), (1.4), (1.5),(1.6) are all wrong!

Can't believe it, four formulas in first page are all have errors. Maybe the author fell so sleepy when he's writing this book!

Excellent little book
This is one of the best book on own on C++.Its concise, accurate, and well thought out in its approach to describing whats needed to design efficient data structures.Also it's one of the few remaining texts (along with Carrano's DS more legthy tome) to do all this without using templates.The pointers descriptions are exceptional.

The only downside is that its rather short, especially for the steep price. ... Read more

Product Description
Image algebra is a comprehensive, unifying theory of image transformations, image analysis, and image understanding. In 1996, the bestselling first edition of the Handbook of Computer Vision Algorithms in Image Algebra introduced engineers, scientists, and students to this powerful tool, its basic concepts, and its use in the concise representation of computer vision algorithms.Updated to reflect recent developments and advances, the second edition continues to provide an outstanding introduction to image algebra. It describes more than 80 fundamental computer vision techniques and introduces the portable iaC++ library, which supports image algebra programming in the C++ language. Revisions to the first edition include a new chapter on geometric manipulation and spatial transformation, several additional algorithms, and the addition of exercises to each chapter.The authors-both instrumental in the groundbreaking development of image algebra-introduce each technique with a brief discussion of its purpose and methodology, then provide its precise mathematical formulation. In addition to furnishing the simple yet powerful utility of image algebra, the Handbook of Computer Vision Algorithms in Image Algebra supplies the core of knowledge all computer vision practitioners need. It offers a more practical, less esoteric presentation than those found in research publications that will soon earn it a prime location on your reference shelf. ... Read more