Algorithms Books

This Is By Far, The Best C++ Book Ever Written! You Will Never Again Need To Buy Any Other Books On C++!!! I've Had This Book For Almost 8 Years And It Is A God Send!!! From Beginners To Experts, This Is The Ultimate Guide To C++!!!!!!!!!!!!!!!

Currently I am on chapter 9.

To be honest, this is my own first datastructure c++ book; I have read many books regarding the introduction of data structures....and they had failed to teach me.
I found this book really easy to read and understand, the important thing to remember before reading any c++ data structure book is to be able to convert the pseudocode and algorithm to c++ syntax.

The author has made life easier by writing the algorithms for you....and rest we do the job. + the usage of STL libraries...to good to use them when ur doing tedious and manipulating code i.e stack, queue, vectors, list, string..etc..

I also liked the fact he has given a section in templates, which is very important nowadays...most of the programs are templated and we should kn ow how to make them.

Every book has problems: so far I have found that his code lacks the declaration of some libraries, while he is using them in the code. Fix: just figure out what library is missing and tadaaaa ur code compiles.

Have fun reading.

I bought this book as additional reference for my Data Structures course.

Pros:

The book covers MANY topics.
Basic data structures such as stacks, queues, lists and trees (avl, binary, nary) are well developed.
ADTs have nice explanations that give a basic insight on designing and implementing them.
Great as an introduction to Data Structures with some depth.

Cons:

Very few code. Most examples don't include any code, which is a crucial part in understanding concepts at times.
Graphs seem to be unimportant to Nyhoff, since his coverage of the subject is scarce (or none?).
The complexities chapter and ADT analysis seemed too shallow. The examples are extremely simple and complexity analysis for recursive or more complex algorithms is not good.

Bottom line: as the title implies, an excellent book for introducing data structures. Lots of subjects are covered. If you need something more advanced, buy something else. Drozdek's Data Structures and Algorithms in C++ is worth checking out.

I am teaching the second programming / first data structure course in the department of electrical and computer engineering.

This book is very good for students who already know how to program in C or C++. My students learn C part of C++ in the first programming course. This book covers object oriented programming part of C++. Then it follows into data structures. It starts with its own definitions of stack and queue and then migrates to the standard template library (STL). Everything is kept on the undergraduate student level. All other STL books I know assume that you are already an expert in programming or at lest for students after two programming courses, and are too difficult for average non-CS students.

My only complain is that pointers are introduced very late in the text. Some students complain that there is not enough examples, while others complain that the book is overexplanatory. My solution to the first problem is providing a set of complete compilable examples on the course Web site. I refer the latter group of students to the programming encyclopedia books for more details.

Ordinarily I would rate this text as four star only. Since it is the only introductory text that both introduces OOP and covers STL, it gets five stars from me.

I am an independent software engineer; I got this book to help me in my development of software it is the best book I have on this subject. If I have a problem, this book gives me the information I need to solve the problem. Granted this is not a book for the person who wants Her/His hand held and this book does not spoon-feed you like the HOW TO books but that person who truly wants to learn and is willing to put in a little effort to learn, not much but a little C++ An Introduction To Data Structures is the book for you.

If you really want to learn Data Structures and how to correctly use them grab this book and you will learn more then you thought you would.

Bomber

Pevzner has written a very useful book on bioinformatics algorithms, and one that seems reasonably up to date. The table of contents follows a classic plan: restriction maps, assembly and sequencing, 2- and N- way string comparisons, and analysis of rearrangements. There's a good but brief section on mass spec analysis - unfortunately, that chapter is called "Proteomics" even though the term covers a lot more than MS. Other sections skim the surface of hidden Markov models and Gibbs sampling for finding patterns ("motifs") in DNA.

A few chapters have unusual strengths. The "Conway Equation" gives more insight in analysis of motif significance than other introductory books do. The section in sequence comparison pays a lot more attention to BLAST-like algorithms than other books do, also - modern material you'd normally see only in the journals. Also, the section on rearrangements gives some ideas about using rearrangement data for phylogenetic analysis. That really gives the material meaning. Rearrangements aren't just string operations, they're features of evolution, and they can be compared to each other. No matter what the discussion, Pevzner keeps maintains a readable and enjoyably informal tone.

The book does have some weaknesses, though. It's a bit advanced for an undergrad intro, but bottoms out before the Baum-Welch algorithm, for example. Discussion of microarrays for sequencing seems dated. Pevnzer describes their use in sequencing, a rarity now, but skips their use in functional gneomics, where they are used most often. Illustration style is erratic and many diagrams are oddly stretched (3.5, 5.7, 8.3, and others, some much worse). Formal analysis of the algorithms is weak, but Pevzner somewhat makes up for that with better statistical analysis than many authors give. Also, even though the book was reprinted in 2001, it still estimates 100K genes in the human genome.

This is a good second book, maybe the one to read after Pevzner's newer "Introduction". It covers most of the basics and gives fairly usable pseudocode. Most of all, it always keeps the biology in mind. That, by itself, makes this book stand out.

//wiredweird

Dr. Pevzner writes with a very lucid and conversational style about very complex and seemingly inscrutable topics. As a biologist who works primarily with computational tools in the field of genomics, this resource has helped to provide me with more than a rudimentary understanding of the algorithms and logic lurking in the methods of sequence analysis. Explaining dynamic programming to a biologist with rudimentary programming skills is a daunting task. However, his description of sequence alignment algorithms (including dynamic programming) in chapter 6 is quite readable and the information is very accessible. I highly recommend this book if you want a comprehensive understanding of the computational biologists toolkit.

While this is certainly the do-loop of computational biology the reader would question the assertion that this book provides a common link (no pun) between the biologists need for computational expertise and the programmer's need for biological insight. In either case a solid basis in Discrete Mathematics goes along way here (usually a required course for computer science majors). This reader thinks a similar required course in genetics should be made for engineers to reduce their reductionistic tendencies. However the distinction between these lines grows narrower with each new computer chip. None the less the book is well written, and easy to read (as Discrete Math stuff goes). This book is not for beginners in either Combinatorics or genetics and the last part of the book poses many current questions that as the author says, "are just currently being answered". This book already assumes you know about such things as NIH, PDB, Chime, Isis, NCIB, docking, etc. For those less adapt at programming (myself) the following alternatives are fun, useful and to the point. Both trees and networks can be easily set up in MathCad using their built in resource center add-ins for Combinatorics and Set Theory. They also provide a Traveling Salesman routine in Numerical Recipes that can be applied directly to the problems in Pevzner's book. (Although remembering that most optimization algorithms provide only the most probable 100 out of 2 million it is still fun!). Most of the mappings and node process familiar to Discrete Math can be solved using Mathcad and some sort of adjacency matrix combination. (Including the four-color mapping problem). This provides the basis for most nodal mappings. For the more daring the adjacency matrices can be run through Matlab's GUI's decompositions and analyzed using their optimization toolbox. Currently I'm investigating the Hidden Markovian chains using the Frame advance feature of Mathcad applied to 2D cspline- intercept graphing and updating by frame iteration. This book is for the serious student or solid course material in a related field, and while probably not rated in top ten novels of 2000 certainly rates five mouse clicks from this reader.

An excellent book for studying computational molecular biology from an algorithmic perspective. (But if you never took mathematics seriously, you are forewarned.)

As others have noted, the premise that this book is for beginners from either the computational or the biological field is flawed...unless one's definition of beginner is a lot more advanced than mine.

For example even chapter one throws out terms like "recombination" and electrophoresis. without enough explanation for the biology newbie, IMO. Heck, for someone truly new to biology, a bit of time explaining what a chromosome is is probably time well spent.

And for the person coming from a pure biology background, some of the mathematics will definitely be a problem unless they have a decent understanding of combinatorics and discrete mathematics. And that "computational biology without formulas" blurb on the back cover should be read as "not as many formulas as I could have included if I really wanted", rather than "no formulas at all". There are equations galore in this book, rest assured of that.

That said, if a person *does* have the necessary background to make the material accessbile, then the book is definitely worth the purchase. The book's failure is in defining its target audience, not in the material presented.

This is a great and comprehensive book on graph theory. The book can also serve as a reference. It is well-written, clear and precise. Almost everything that a student or practitioner need to know about graphs is likely to be found here. However the book is best appreciated by someone who has studied some graph theory. A beginner would benefit more by looking at more elementary books such as Graphs and Applications by Wilson.

Reads like a dictionary, each page is nothing more than bullet points that alternate between definitions and corollaries. Proofs are typically very short: explained and illustrated in no more than a quarter of a page. More appropriate as a reference manual than a textbook for a class.

This is a superb book for an introduction to graph theory. It is not just a pile of theorems as other books you'll find in this field. It presents insight and intuition first, and then it gives the necessary formal treatment. The topics covered are perfect, in the right order. Extremelly recommended for anyone eagerly wanting a first contact with this exciting field, as well as for any graph theory instructor looking for the right book to follow in class.

This book was used for my undergraduate course in introductory graph theory, which was split between math and computer science students. I found that this book left to be desired. The definitions are imprecise and often inconsistent with those that are standard, and much of the notation used is not standard. I would not recommend this book as a reference or for advanced students.

Regardless of whether you just want to implement a couple of graph algorithms or get into the guts of graph theoretic proofs, this book should come in as a great resource.

In over 500 pages, this book covers a lot of ground beyond the basics, such as topology of graphs, graph operations and mappings, voltage graphs, and surface imbeddings. Definitions are very clear, propositions and proofs are stated very clearly, and there are shrink-wrapped algorithms if you just want to apply them.

Requiring no previous knowledge of abstract algebra or graph theory, this is a great resource to have in your bookshelf.

The book is a little dry at times. Also, I didn't get a very clear idea of how to select kernel functions, which seems pretty important.

The book is just great. The appendix on algorithms could have more explanations. Also the application section is a short. It would have been more usuful to take one of these applicaitons and describe it in details. But all in all, the book is excellent.

This book introduces the concepts of kernel-based methods and focuses specifically on Support Vector Machines (SVM). It is hard to read and a good background in mathematic is clearly needed. The book has a strong emphasis on SVM starting from the very first line of text. Concepts are well explained, although equations are not clear. The notation doesn't facilitate the reading at all. The book covers linear as well as kernel learning. The kernel trick is well described. It is easy to understand ideas behind SVM while reading the corresponding chapter. Finally a small chapter on SVM applications is proposed. Unfortunately, it only contains typical SVM applications (i.e. standard problems).

I think this book is good if you:

* Have a strong mathematical background
* Work in the specific domain of SVM (or kernel-based methods in general)
* Want to write a research paper about SVM and need the correct notations

However, this book is NOT intended for people who:

* Don't like to read theorems, corollaries and remarks
* Are not interested in reading hundreds of proofs

This is my personal opinion as a computer scientist: this book is definitely written for mathematicians.

I just happened to read the reviews on the book on Support vector machines by Nello Cristianini and John Shawe-Taylor. Could not resist adding my own comments about the book. Excellent book. I plan to use the book for the course on "Fundamentals of computer aided engineering" that I teach at the Swiss Federal Institute of Technology, Lausanne (EPFL).

Oh Puhleeeezzzzz... How is your vector math??? Remember your linear algebra well? Do you have a background in SVM's? Intuitively able to suck out of thin air the meaning of the Gamma co-efficient as applied to svm's?? You've read all the background papers and remember your formal logic???? No?? too bad..your out of luck..

This book is more aptly titled an Introduction to the Formalisms of SVM's. If your a software engineer trying to implement one of these, forget it.. Be nice if they put that quadratic algorthim psuedocode into something more readable than greek symbology..

If you are trying to build one of these engines, then this book is of absolutely no help, unless you have a background in machine learning and have read all the papers on SVM's. If you can decompose the math into code in your head, then you might find it entertaining... What I don't get is how all the rest of these reviewers can give such "glowing praise" for this book and have it be so completely worthless as an introduction... makes me think some of these are shills..

Bottom line is, if your trying to code a svm, this book will not help. If your trying to understand how to implement a svm, this book will not help. If you are trying to understand how an svm works, this book will not help. If you want to know the mathematical basis for SVM's and like that presentation.. this is the book for you..

A mathematician at heart in the world of software engineering, this is one of those few books that I take out from time to time and leave beside my bed. With it's wide scope it is sometimes terse and needs careful reading. Yet the world of randomized algorithms comes through with strength on a good formal basis. It is an entertaining and yet highly educational book.

This book is a jewel. It demonstrates how clever and beautifully simple probabilistic ideas can lead to the design of very efficient algorithms. I like its very verbal intuitive style,
with proof strategies being always transparently explained.
For computer scientists, this is *the* reference work in randomized algorithms, by now a major paradigm of algorithms design. For classical probabilists, this
could serve as an eye-opener on unsuspected applications of their field to important areas of computer science.

Algorithms are my specialty, and I'm really interest in everything that is connected with them. This is one of the few books from the field of algorithms that I was a problem to read. I found this book hard to read because of several reasons.

Firstly, i have a problem with the composition of material from the book. The material is in the many places presented in the unnatural way. Book is method oriented, so often same problem is treated in several places in the book. On the other hand the book is not fully method oriented, so there are chapters of the book that don't present any method of building randomized algorithms. There are several chapters that are organized around some concept from the probability theory. I don't see the reason for these two orientation to be mixed.

Often I have a feeling that authors are not particulary interested in randomized algorithms, and that thet their main interest is to show probability methods in the theory of algorithms. So, there are, for example, chapters in the book named "Moments and Deviations" and "Tail Inequalities". I don't want to say that these concepts are not important for the randomized algorithm complexity claculations, but I think that such chapters belongs to book on probability theory, not randomized algorithms book. On the other side, therms of Monte Carlo and Las Vegas algorithms get together one section in the chapter in which they are described. It is true that in these chapters contain randomized algorithms as examples of usage of mathematical concepts, but the question is: should this book present general mathematical concepts, or randomized algorithms.

The second big drawback is lack of precise mathematical notion in many places in the book. For example, in the chapter on game theory the reader get impression that the whole game theory are game trees. Yet, authors fail to define what game tree is. The definition they give is more lausy desciption than definition. They don't say which kind of tree is game tree. Is it binary? Of course it is not, but authors in this section work only with binary trees. Further, in the text authors said that this tree is uniform. I have to admit that I never heard about uniform trees. The problem is that all definitions in the book is given in this way, by the paragraph of the text, which describe the term, not define it. In fact, the only concepts that are properly defined are ones form the probability theory. None of the concepts from the algorithms theory or data structures theory is not defined as it should be.

The third great problem with the book is that these concepts are never ilustrated with the concrete example. There is a section about the game trees, for example, but there is no single game tree for some game generated in this section. This is not a single case. All examples in the book are about mathmatical, or nore precisely probability theory concepts, and all of them looks like they are taken from the workbook on probability theory, and doesn't have any connection with algorithms.

Another problem is that all chapters are not builded in the same manner. There are chapters (unfortenately very little of them) that have theoretical overview of the method they deal with, but in the other chapters there are no proper theoretical description of the method of the matter.

To resume, this book shows the lack of concept and system in the writting, as well as the interest of authors more in mathmatics than in algorithm field.

My opinion is that there are much better books on the randomized algorithms tnan this one.

Overall, the authors explain core concepts, the examples and the possible applications well. However, the readibility of their proof is far from that of the above three. Honestly some proofs should be re-written completely.

For example, in page 116, they try to use the induction method to prove Lova(')sz Local Lemma. After reading that page many times, I still didn't understand the structure of their proof.

I was TA for under-grad level algorithm course, got A+ in advanced Calculus II and A in intro. to PDE (both in under-grad level), really knew something about induction method and a little bit about algorithm. I am not smart, but far from stupid.

In the end, I google the internet and found a 3-page proof for the same thing. That's easy to catch in few minutes, and then, I understand the 1-page proof in the book. Is it ironic?

The book has an exoustive amount of algorithms. Not everything is proved. Sometimes the proof contains to few steps to be understood. There are many algorithms explained well. After reading this book it is easy to create your own randomized algorithms.

Great book on Datastructures. Much verbose than the other books. But the java example in this book are horrible, particularly the variables used. Just letters are used as variables, instead of appropriate names, making it very hard to follow the example.

So overall, I would suggest buying Adam Drozdek's algorithm book.

This series is a treasure to keep. The book is filled with great diagrams and very easy to understand language.

These text(s) do for the software engineer what Cormen's book does for the scientist. To be knowledgable with algorithms will greatly seperate you from a novice.

Very good examples and using Java is very smart because most OO programmers can easily understand the language (C# is practically identical).

For those who struggle with the Cormen book, (Like I did) it would do you well to get this book. You will refer to it time and time again in your career as a software developer while the Cormen book collects dust on the shelf.

First is Knuth, second is Corman that brings the art of algorithms closer to earth. Then is Sedgewick. This book provides very good balance between theory and practice and lets the practitioners know that programming is a bit more than just writing "if" and "for" and that the art of algorithms is not only art but also science. This book evolved from early editions (Algorithms in C, 1990) and keeps the standard. These two volumes is the must for every serious programmer.

Cons: Java code is a bit "C-ish" and makes it clear that it is easy to write C program in Java. In addition, section Geometric Algorithms from 1990 edition and other material following this section is missing in newer editions. Maybe this material will be included in Volume 3, that as rumor says, is in preparation.

This book is a total mess, I don't know if it's the author or the publisher but is written in a style that got me really frustrated.

The author has the bad habit of start explaining a thing a little bit (not enough to fully understand it) then say something like "we will cover this topic in depth in chapter 7", and you are in chapter 2. This sort of jump back and forth is completely frustrating, the book doesn't seem to have any kind of flow. The same technique is used inside a chapter too, you start reading about something then the author start diverging in the middle of the topic to come back after few pages.

The code samples are a total mess, it's just really bad. I mean common, read any introductory book in software development and you get warned in the first chapter not to name your variables i,j,v i1...just give them a meaningful name.
Every time I read sample code in this book I had to spent at least 20 minutes deciphering what the variables are suppose to be, why the author define variables that are not used at all or they don't have any kind of effect on the end result (yes, I did found a whole bunch of these). If you don't know Java or don't care to follow any of Java standards fine, write C code or something, at least I will be prepared to read obfuscated code.

I give this book 2 stars, it has after all a lot of information in it, even if it is scattered all over the place

This book was pleasantly surprising: I had expected to see code presented with minimal motivation or discussion of the underlying ideas -- something of a "Computational Geometry for Dummies" sort of book. That's not the case at all. This is a bona fide textbook on the subject, suitable for an undergraduate course.
It covers all of the the "classical" topics: convex hulls, line segment intersection, polygon triangulation, Voronoi diagrams, motion planning.

The mode of presentation -- supporting a discussion of the theories with implementable code -- is actually a bit refreshing. For comparison: Other books, when discussing the line segment intersection problem (ie: Given a set of line segments, find all of their intersection points) simply assume that computing the intersection of a pair of segments can be done in constant time. This is not an especially difficult problem, but the discussion seems more complete with a brief description of how this might be done. The same can be said about other primitive tests and operations in other algorithms.

Overall, this book can stand alone as an excellent introduction to computational geometry, but a serious student in the subject will want more: perhaps Preparata and Shamos or de Berg et. al.

Anyone who is involved in areas such as computer graphics, computational radiology, robot vision, or visualization software should have a copy of this book. The author has done a fine job of introducing the most important algorithms in computational geometry, choosing the C language for their implementation. The choice of C might be somewhat dated now, since C++ is now beginning to dominate computational geometry, but readers who are actually programming these algorithms using C++ can easily extend the ones in the book to C++. Not all of the algorithms in the book are implemented into C, unfortunately, but the clarity of presentation is done well enough to make this implementation a fairly straightforward task. My interest in the book came from a need to design and implement algorithms for polyhedra in VRML and toric varieties in algebraic geometry. This book, along with others, was a great help in that regard. The running time of these algorithms was not really an issue with me, so the detail the author spends on discussing the complexity of the algorithms was not a concern. Readers who need to pay attention to running-time issues will appreciate his discussion of them for the algorithms that are presented.

The ability to visualize objects in an abstract subject like algebraic geometry boils down to, in the case of toric varieties, to a consideration of how to manipulate polytopes geometrically. A major portion of the book, if not all of it, is devoted to the computational geometry of polyhedra. Because it is an introductory book, some more advanced topics, such as Bayesian methods to find similarities between polyhedra, and neural network approaches to classifying polyhedral objects are not treated. Readers who need to do such things will be well-prepared for them after a study of this book. In addition, there are good exercises assigned at the end of each chapter, so the book could be used in the classroom. Some readers will however choose to use it as a reference source, and it would be a good one, for the author gives references to topics that he only touched upon in the book.

Some particular areas that were treated especially well were: 1. The discussion on data structures for surfaces of polyhedra. Although not very general, since he choose to deal with only triangulated polytopes, readers who need to be more general will have a good start in this discussion. 2. The discussion on volume overflow and how to deal with it using robust computation. 3. The discussion, albeit short, of the randomized incremental algorithm. 4. The treatment on the minimum spanning tree and Kruskal's algorithm. Communication network performance optimization is now a major application of this algorithm and others in graph theory, including the author's later discussion of Dijkstra's algorithm.

This book provides a reasonable introduction to the field of computational geometry, although the notation is sometimes sloppy and the author frequently makes inconsistent assumptions about the reader. For example, on the first page he refers to a circle as a "one-dimensonial set of points," which although valid from a toplogical perspective is a little confusing in an introductory text. As another example, the first exercise refers to "every point in dP," presumably meaning just the corner points (otherwise the problem would be unsolvable). The book also sets up a lot of irrelevant mathematical definitions that generally obfuscate the presentation rather than clarifying it. Although not prohibitive for the ambitious reader, these needless hindrances are at best a little annoying.

Secondly, I must criticize the text's scope, in light of the important role computational geometry has played in modern computer graphics. There is no discussion of clipping, culling, occlusion (e.g. BSP, octree, OBB), or even non-polygon primitives -- important topics arguably more useful to the target audience than e.g. convex hulls (to which over 1/4 of the book's pages are devoted).

Regardless, this book (combined with a professor and a course) probably would serve quite well as an undergraduate text. Readers interested in a cookbook of applied graphics algorithms, however, should look elsewhere.

If you are perhaps a graphics or robotics programmer, then you will often have need for computing various geometric forms. And the intersections of these forms. Rather than derive algorithms from scratch, you might want to first look here. O'Rourke has collated several useful sets of methods. Germane to two and three dimenions.

Convex hulls are important enough that he devotes 2 chapters to these. While the somewhat related idea of Voronoi diagrams gets its own chapter.

The C code is a nice bonus to some readers. Though if you are experienced enough in another language, you should be able to readily code an algorithm in the book from scratch.

i think that these website is very.it has everything that i need. all of my books are from amazan.

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.

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.

I am using this textbook in a Computer Animation course I am taking. During the course of most of the assignments, I found myself asking "is equation X correct?" It turned out that I was making a subtle mistake, but having to wonder about whether or not there is a mistake in the book is the problem. For example, if the book had made some attempt to explain the equation or where it came from, I might have asked, "What did I do wrong, because it's obvious the equation is correct."

This book isn't all bad, though. It does contain lots of useful information. It is perhaps a decent reference book, but I didn't find it very useful for learning the concepts.

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.

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.

I received the book with the book cover upside down and reversed with respect to the book.

Professor's Nancy Lynch's "Distributed Algorithms" is a definite reference for theoretical treatments of many hard problems in distributed computing. It is a textbook, but written in such a clear style that makes it almost a pleasure read. Rarely have I seen something like that! The book has a right proportion of theoretical proofs, practical applications, philosophical appreciation of the problems, research questions, examples and study points.

"Distributed Algorithms" has 3 main parts - synchronous, asynchronous and partially synchronous network algorisms. Each part describes consensus resolution, mutual exclusion, resource allocation, leader election, termination detection and failure detection as main problems in distributed computing theory. Lynch has done a masterful job of leading us from simple to complex, from theoretically solvable to practically intractable problems.

For a practitioner of computer science, who is not necessarily involved in fundamental research, this book gives a clear appreciation of problems of 2PC, resource management, failure profiles in faulty and noisy networks, optimization and fault management in distributed networks. All those things are foundations of databases, network computing and enterprise scalability. It also helped me greatly in estimating the best and worst case boundaries in certain practical distributed system optimization problems.

This book is in the same class as "Discrete mathematics" by Knuth and others. Important topic, extensive coverage, good English, zero vendor's propaganda. Super. An unexpected gift from up above (after struggling with reams of MS's (dis) information .) I am working on something distributed and ran into this book accidentally, while browsing in a bookstore--I'm glad I did. Btw, it's a few bucks cheaper in B&N store (here goes my review .)

At MIT, I took the course 6.852 Distributed Algorithms under Professor Nancy Lynch. It was an excellence course. This books is based on her lecture notes. Before this book, there is really no book that covers these material in rigorious and consistent matter. One usually have to read the actual published academic papers. Because different author may use different notations or models, sometimes it is hard to see the whole picture. This book shows exactly that. The algorithms are presented in a consistent notation, and the models and the assumptions all the explicit, clear and consistent. However, Professor Lynch's lecture style can get really dry and boring, sometimes I can't help felling asleep because the class was so early in the morning. For that, I decided to give it only 4 stars.

Together with Mrs. Lynch's other book "Atomic Transactions", this book has been my "Bible" for years already. And now that I am starting my own company in software development, I think about making this book obligatory reading for my first new employee. Not only because of the nature of its contents, but also because of the way these are presented, and the thought-work behind it. Ideas like the provability of algorithms, seeing the user as an automaton and showing that Lamport time >>really>> works, are rare to be found together in the same textbook. This book puts research back where it belongs: before practice, not over it. Mrs. Lynch has done a great job. It is upon this work of hers, together with "Atomic Transactions", that the IOA specification language is based, created in the LCS of MIT. IOA is now in near-operational working order, and puts into application almost all of the thoughts expressed in this book.

A must-read for any software engineer who takes him-/herself seriously.

I work in a field where memory management is absolutely critical and was greatly looking forward to this book greatly. However it turned out to be a massive disappointment. The title is memory management, algorithms and implementations. However, the algorithms don't even really start until the last third of the book, and when they do, they are overly simple, and barely touch on the theory or critical characteristics behind the algorithms. This book is filled with useless tangents, some of the most random of which involving microkernal versus monolithic kernal, scanning of faces at the Super Bowl, and instructions for setting the 80x line of chips from real to protected mode! This book presents no practically useful algorithms, as all of the handling of cases such as growing the memory block are left as 'excercises for the reader' as are performance improvments even though final performance is essential in order to be able to properly compare and contrast the algorithms.

In closing, skip this book and pick up either 'Operating System Concepts 6th ed' or 'Operating Systems: Design and Implemenation 2nd ed' which actually have meaningful insight into practical approaches for memory management and concerns.

As a public servant involved in technical copyright work, I normally don't stray too far from my area of specialy. However, a friend of mine recommended this book and I picked it up at a local bookstore.

This book does a nice job of looking at the countless little details that come into play when dealing with a computer's memory. What was once very easy for hackers to fiddle with in 1981 is now a nasty ordeal. Fortunately you'll have this book to guide you.

Nice explanation of the A20 address gate.

One thing I didn't expect was a look behind all the marketing hype behind Moore's Law. The last chapter is somewhat ominous, and it makes you wonder if the author has been to John Young's web site. TIA is closer than you think...

This book, is one of the few computer books I have read from cover to cover - code listings are easy to scan/skip, and the book itself is not huge (however the cost seems fairly high for the size).

This book is clearly written, and well researched. It is not for beginners.

This book spends time on the hardware aspects of Memory management based on the Intel 386 and above architecture. Real Mode versus protected mode and how the processor design allows for memory protection in protected mode.

This is then followed by a survey of Operating Systems, from DOS to Linux to Windows - which is moving from the simple to the complex - and how the OS provides Memory Management services.

Then the development of computer languages, and how they allow for memory management starting with COBOL and moving on to Object oriented C++ and Java Virtual Machines.

Finally the last part of the book has a lot of code listings with very simplistic memory management and moving into slightly more complex algorithms for memory management for programs. The focus is on introducing multiple approaches and how to measure the real performance of each - some parts of this part of the book seemed like they were repeating the same text in making comments about the code.

Overall, I liked the book. I read the Pentium Protected Mode architecture book last year, and it prepared me for this book.
I have not done much assembly level x86 programming, but enough to understand what was being shown in the early examples.

The book has a very good bibilography of sources for each chapter - six long chapters. I felt, while looking at these bibilographies, that the time spent in going through all of the items in the bibliography was part of the reason that this books price was set so high. The references here are thorough and identify some turning points in computer sciences to me.

The structure of the book is the layers by which memory managment is accomplshed - the memory management code is more of an intro. I felt that the book might be targeting Computer Science courses as its real market - the books structure lays down a good foundation for further exploration.

The deeper development of Memory Management algorithms is where I too found the book lacking, and the title a bit deceiving - a complaint from another that I would agree with. This is the reason for not giving 5 stars. It would have taken a lot more time to develop the code and write explanations for more complex approaches and the author states this repeatedly in this algorithm section of the book.

I am inspired from this book to learn more about x86 assembly language, and to study the actual code of the Linux Kernel.
If that sounds of interest to you too, then you should buy this book.

This is probably the only book I have ever bought that actually gave a discussion on protected mode that I could follow. He does keep the discussion basic (flat model, no paging), but it got me over the hurdle.

I also liked his high-level memory managers. They were to the point and easy to understand. No fancy syntax, no cryptic pointer swizzling,... just straightforward code. What Blunden provides is a solid foundation that has a low learning threshold.

Finally, Blunden speaks to the reader in a casual manner, as if you were sipping high-octane coffee somewhere on El Camino BigNum.

While a lot of books on computer memory end up abstracting their discussion somehow, Blunden's book lies at the opposite end of the spectrum. All aspects of computer memory are examined (hardware level, OS level, application level) and in each instance concrete, non-trivial, examples are presented. Nothing, and I mean nothing, is left to the imagination. This book is nothing short of an exhaustive look at memory management. Engineers interested in this traditionally neglected topic should buy this book!

Having read other reviews, I will agree that the material in the last chapter is just a little prophetic.