Algorithms Books

Yukawa is hired by Ichiro Ono of Ono Robotics to be the head curator of a new museum he is building to honor the 365 Views of Mt. Fuji painted by the artist Takenoko. The problem is that Ichiro only owns one third of the paintings; the others are divided equally between his brother Gun, who runs a gay nightclub, and sister Akiko, who operated a ryokan (similar to a motel) which has been in the family for generations. They haven't spoken in nearly 20 years so the task is placed upon Yukawa to gather all the paintings together.

As Yukawa begins his task of cataloguing the views and trying to convince the others to loan them to the musuem, he tries to make an intimate connectionwith both the methodical Kumi (Ichiro's daughter) and the overprotected Haruna (Akiko's daughter). Then, mysterious packages containing some of the views begin to arrive at his dorm room, his office, his car, and Yukawa is unwittingly drawn into the bizarre and secretive world of the Ono family.

This is an intersting novel with a very good story. The author Todd Shimoda has added a unique twist by inserting more stories which run concurrently with the main plotline into the margins of each page, to give character depth as well as background into the artist Takenoko. While each of the characters is well-drawn and interesting, I felt that much of the extra info given was unnecessary and sometimes distracting. The story itself is intriguing enough to keep you reading.

A very strong book bringing us on a fast tour of modern life, 365 views draws us into the lives of many different characters, yet manages to strongly characterize each person. Each character develops and suprises. The story is intriguing, and the style also interesting. Reminiscent of Haruki Murakami.

Keizo Yukawa, an museum curator in Japan, embarks on an intense and excruciating test when he accepts the job of head curator at a new private museum dedicated to the enigmatic artist Takenoko. As Yukawa's story unfolds, Takenoko's parallels it in the margins of this imaginative and thought-provoking work. One by one, Yukawa meets the family of Ichiro Ono, the museum owner. Each one introduces a tiny piece of the puzzle that is the Ono family history and draws Yukawa deeper into the part he has to play in the mystery.

Illustrations by L.J.C. Shimoda add an authenticity and depth to this well-researched and beautifully written book. If you're interested in Japanese culture, the question of aesthetics, or just looking for a book that diverges in a lively way from the norm, pick up this book.

Most writers have enough trouble managing one viewpoint throughout a novel. Meet Todd Shimoda, the brilliant author who uses three intertwined narratives to tell the story of 365 Views Of Mount Fuji.

This is a story of the conflict between tradition and desire, expectations and personal freedom. Keizo Yukawa thinks he knows what he wants, but a move to a new job in a strange new environment will make him question his goals.

The story of Yukawa is the main thread of narrative. Sidebars provide insight into the strange characters that he encounters. Beautiful, traditional illustrations in the margin are a flickering glimpse of the past and the present.

Blending the ancient world with the growing techno-society produces a mesmerizing tour through the mind of modern Japan.

This book is one surprise after the other. First, the main text is a fast paced, mystery/suspense novel that would stand well on its own. However, in the margins are small sub-stories that can be read on their own but really are pertinent to the unfolding novel. In addition, every page has beautiful pen and ink drawings that are related to that particular part of the story. These drawings are a curious mixture of classical japanese art icons and ultra-modern social commentary. It is amazing how well these three elements blend to exponentially enhance the book's message. Although I was initally put off by the daunting task of assimilating all the information on each page, it was surprisingly easy and enjoyable to read. It's a book you want to read again immediatly after finishing it and one you want to set on your coffee table so you can thumb through the artwork. 5 stars.

The C++ implementations in the book are simple but very effective and well-organized.

Hi! I want to see how are you look like ? So, please show m

I've been hunting around for a while now for a book which teaches data structures using C++ as the implementation language. I think I've finaly found it in this book. All other books I've looked at have just been poor rewrites of previous C algorithm books.

The material is clearly explained most of the time, always with an example to show the algorithm at work. The book focuses on algorithms and data structures that you might actually use one day, unlike some other books which have all these wierd and wonderful algorithms but which you will probably never need to use.

This is the book to have when you start forgeting all that data structure stuff you did in college and you need a review.

The best thing about this book is that it's only ~350 pages so it wont take you years to get through.

I've been researching on C++ algorithms to handle large integers for a Visual C++ Calculator I'm currently writing. This book provided me not only with a full and clear explanation of the methodology involved, but also with a complete listing of the class required to handle these operations. Among other techniques, it also showed me clear guidelines to convert recursive algorithms into non-recursive procedures, which I have found very useful for the work I'm doing. This book will indeed be one of my main sources of information in this area. The source code described in the book is also well supported at the Web site which address is provided in the book.

I used this book for my Data Structures course and found it very difficult to decifer. The text is hard to understand and if you haven't had much practice in figuring out C++ code, you definitely will have difficulty with Leendert's examples. However, with a little effort and a lot of work (as well as some help by someone more experienced) the code is deciferable. In fact, if you can figure out these examples, you're well on your way to becoming an expert C++ programmer.

I'd recommend this book for the advanced programmer or the programmer that has a great deal of drive and assistance. All in all, definitely worth taking a close look at.

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++!!!!!!!!!!!!!!!

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.

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 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.

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

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 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.

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.

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.