Algorithms Books

This book was delivered to me before time and also paid a decent price for it.

The book is really perfect and is exactly I hoped.
However, the main and only bad critic I want to highlight is the shipping.
The package was very light and the book cover arrived damaged: the corner were maltreated.
No really, only a box including 2 plastic bubbles is not serious and totally insufficient to correctly protect such kind of nice books.

An excellent book. The only comment that I have that has not been covered is that you should know c++ templates to use this book... theres a problem with that, most if not all template books require you to know STL. You will have to read both in conjunction if you do not all ready know templates.
Once you get past that little pit fall though, this book is invaluable to any c++ programmer.

This is far and away one of the best written programming and reference books I have purchased in 20+ yrs of programming.

It gives a perspective on state-of-the-art C++ style, language constructs, and technique that only a choice few people in the industry can offer. The book has all of the meticulous attention to detail and design formalities that one could expect of the finest academic.

Bravo, Mr. Josuttis, and THANK YOU!

Tutorial? Hardly. Reference? I can find better, more complete, and more accessible reference material in 10 seconds with google. Whenever I open this book to find information about some aspect of the STL, I end up googling for the same information a few minutes later.

The examples are near useless. They are all minimal examples of basic functionality and offer no help in using the library for real-life tasks. They do show you which header files to include, which is a plus.

Hash maps are completely left out of the book. While not officially part of the stl, they are still a significant part of it, and one that requires more explaining than the rest.

I am to understand the +5 reviews were because there are no better books on this subject, similarily my +2 review is because there are not enough negative reviews of this book.

Wow. Bucknall has raised the bar on advanced Delphi books. This books coverage of Algorithms and Data Structures is suburb. This book should be required reading for all Delphi developers. No one can call themselves an expert level Delphi developer with out understanding the concepts taught in this book. Bucknall's knowledge of Algorithms and related concepts places him in a category with Knuth & Sedgewick.

This is a book that I've been waiting for for a long time (according to the acknowledgements, Julian has worked on it from April 1999 until February 2001, probably even longer). But it has been worth it, because it's an excellent book about algorithms and data structures implemented in Delphi (and Kylix) - usually version independent.

The book consists of 12 chapters. But even before the first chapter Julian takes on the question of "why a book on Delphi algorithms?" in the introduction. He explains that a number of Computer Science algorithms books are hardly practical, and the practical books are mainly for C, C++, or Java. This is a book about algorithms and data structures using Delphi (for Windows, but also Kylix for Linux), with a lot of focus on practical and useful techniques that make sense.

A great plus is that the code in the book works for every version of Delphi and Kylix (and probably also in C++Builder), and I'm fairly confident it will remain working in the next version(s) of Delphi and Kylix to come. A bonus point is the syntax high-lighting in the source code listings. A small effort for the author/publisher, but a great help for the reader who sees the source code for the first time.

This wonderful book is now again available for purchase from lulu dot com. The known errors have been fixed and its got a new smarter look and feel.

I still think of myself as being a beginning programmer, although that's not totally true, having messed around for about ten years with CAD macro's and dbase add-ons and turned them into full-blown applications that finally became fairly complex. However, I never had a decent IT training beyond some basics in Fortran and Algol, and know next to nothing about OOP.

I first thought Bucknall's book would not be for me, as I was afraid of landing into high level topics and getting lost in jargon.

On the contrary, I hardly can stop reading the book, which finally provides a very practical approach to Delphi/Kylix programming, giving light to many abstract topics you will not find in most books : the trade-off between speed and memory efficiency, how data structures and the mix you make of them in your application affect your program's speed and reliability, easy steps that make debugging and testing more efficient,...

Once you've got the hang of using the VCL within Delphi and know how to place controls on a form, you can immensely benefit from this book, that can be used as a reference into many algorithms and their Delphi implementation, or can be read chapter by chapter as an introduction to analyse the merits of several ways to sort/search/hash or use various data structures to solve a problem you face as a programmer.

Julian Bucknall's text is very understandable, even to non english native speakers, stays close to the topic while providing you with a wide scope of insights into related subjects. He's also keen on giving you all the tips he can coming from his personal practice as a programmer that make you understand why some theoretical topics matter to your program's quality. It's nearly like having him looking over your shoulder and helping you making the best choices. The book provides you with a real simple alternative to searching the web multiple times or trying to translate C coded algorithms into a Delphi equivalent, hence it will be a time saver to many Delphi user's, even a casual one like me.

This book is a must have, as a complement to a good Delphi / Pascal reference.

This book it's of essential importance for all mid-level delphi programmers. If you like to know the low-level working of common data structures of the IT software engineering (or if you like to build one), then buy hands down this book: it's the best around. Moreover the ezdsl (the author free library) is the fastest implementation that i have seen. Personally i look that ezdsl/delphi is faster than the STL equivalent under c++.

I have a virtual calculator called the DIY Calculator that accompanies my own book "How Computers Do Math" The Definitive Guide to How Computers Do Math : Featuring the Virtual DIY Calculator.

I recently added a "Conundrums, Puzzles, and Posers" section to the "Programs and Subroutines" page on my DIY Calculator website ([...]) and I've started to build a collection of simple puzzles for people to play with.

One of the first problems I posed was to count the number of ones in the 8-bit accumulator and to present the result as a binary value. I thought I had discovered the best-possible solution, until someone pointed me in the direction of the "Hacker's Delight". (In this context, "Hacker" refers to a hero who is manipulating code; not a nefarious rapscallion who breaks into other people's computer systems.)

I immediately ordered a copy from Amazon, and took delivery just yesterday as I pen these words. This book is fantastic - I kid you not - on the first page of Chapter 2, for example, I discovered at least five or six capriciously clever tricks that blew my solutions out of the water!

I highly recommend this book.

My first introduction to binary operators wizardry was in a 1st year, 1st semester course in Digital Systems at the Technion, IIT. I thought it was fun. While I was trying to write a computer program to compute Karnaugh Maps for me, I run into performance problems, and then some binary hackery helped me get back on the horse.

Since then, whenever I come across some binary trick I write it down with a few examples of usage and sometimes with some reasoning why it works.

Then came "Hacker's Delight" and I felt compelled to buy it.

I wasn't disappointed at all! Not only it contained all of the tricks that I have collected, but also it contains a lot more in depth examples of how these tricks can come in handy when trying to squeeze performance from an implementation or save a few more bytes and bits.

The book also gave me a fresh perspective on the implementation of some well known algorithms with the twist of binary arithmetic. This was very enlightening.

I read the "BASICS" chapter (chapter 2) with a single breath of air, and just couldn't leave it down. Not only it was nice to have all these tricks summarized in one book, but also I liked some of the reasoning and the "so-called" proofs.

Remaining chapters were, as I mentioned before, a fresh look for me on known algorithms. This fresh look was through the glasses of binary arithmetic.

I'd recommend this book to anyone who feels comfortable with binary arithmetic and/or computer organization -- even just for the fun of it!

I'd recommend the book to developers who don't necessarily have a sympathy to this topic, but would like a Copy&Paste solution to some problems they have to tackle.

I really enjoyed reading this book, and I will probably reference it from time to time.

This book is an absolute essential to the right reader. That right reader is either a low-level coder, a high-level logic designer, or someone who builds tools and libraries for same. In other words, not a lot of people. This is hacking at its bit-level finest, though. If you're among those few, or think you might be, or want a good laugh at the people who are, dig in.

It's good for things like counting the number of 1 bits in a word-length integer (hint: if you count the bits, you're doing it the hard way). It's good for things like fast division by an integer constant, or mod to a constant integer modulus (hint: if you perform division by dividing, you're barking up the wrong tree). If you can look into a 32x32 bit multiplication and see a convolution going on, you're way ahead of the game. The only tricks I know that didn't appear here are A) for purposes that almost no one has or B) for machines that almost no one has.

Warren presents the coolest collection of slimy coding tricks ever collected, with full attention to the number of machine cycles and the compiler-writer's unique needs. I've seen a lot, and this is by far the biggest and coolest collection around. I have two complaints, though, a small one and a really big one. The small one is that the author didn't score a direct bullseye on my somewhat offbeat needs. Well, he never tried to - that's just me griping that he didn't write a different book. The big complaint is that pages, lots of them, just fluttered out of this pricey book and onto the floor. GRRR. This takes nothing away from the content of the book, until some critical page flutters off never to be seen again. Still, if you can keep a rubber band around it, this will be one of the deepest mines of coolness in your uber-geek library.

//wiredweird

The term "hacker" in this book means someone who enjoys making computers do interesting tricks regardless of whether it turns out to be useful, not someone who is intent on circumventing computer security. Plus, how relevant would those kind of tips be coming from a book that was written in 2002? Don't let the author's definition of a hacker fool you, though - the tricks in this book are very useful.

This book is a collection of small programming tricks on various subjects. The presentation is very informal, and the methods use very basic computer math. You should know your binary number system backwards and forwards before you start this book. Either C or assembly language is used to demonstrate the hacks in code form. When assembly language is used, it is that of a fictitious machine that is representative of RISC computers. That is because the tricks are meant to be platform independent.

After disposing of basic arithmetic operations early in the book, the author turns his attention to more complex math problems such as calculating square roots. His discussion of the subject is both complex and simple. First, he explains Newton's method of computing square roots through a page full of equations that require some effort to follow. Then he gives an implementation that requires fewer than twenty lines of C code. This is followed by another method that is longer and more cryptic but executes faster, by using a binary search algorithm. Whether you are interested in the equations or merely need the C code to do your job, these solutions are efficient and elegant.

Other topics addressed include Gray codes, the Hilbert curve, and prime numbers. Gray codes are a method of arranging the integers from 1 to N in a list so that each number can be visited exactly once by flipping only one bit at a time. The Hilbert curve is a similar idea expressed geometrically: a single continuous curve which, given a space divided into a grid of squares, touches every square exactly once and does not cross itself. In each case, both the mathematical discussion and the code to solve the problem are provided.

The chapter on prime numbers is the most challenging mathematically but also one of the most interesting. It starts with a concise overview of various mathematicians' efforts to devise ways of finding prime numbers. The author is one of those people who periodically become fascinated by some problem and devote themselves to learning more about it and searching for a solution. The chapter ends not with the usual code sample, but instead with an invitation to continue the search for interesting solutions to the problem.

Clearly, the author views this book not as a finished collection, but rather as a snapshot of work in progress. After decades of interest-driven research, the author has amassed a collection of studies big enough to fill a book, and it is fortunate for the rest of us that he has written one.

They don't make them like this anymore. Amid the "Learning XXX in 21 days" and various other computer book for which depth is almost non existent (and are read like eating peanuts), this is a refreshing book that talks about solutions to sometimes common (IMHO) coding problems.
If you enjoy programming gems, or remember that beyond your C code there is a machine that executes your program, this is the book for you. For example, think how would you count the 1 bits in a 32 bit integer - the book has an elegant solution in log(n). Aside from this, the book has about 50 or so problems, with their solutions (and proof).
Bottom line: fine book, worthy to be near my Knoth, R&K and Stroustrup books.

Kishor's book is one of the few highly readable books on queueing
and stochastic processes. The abundant examples and discussions
of reliability also aid in understanding the material.
I would recommend this book to undergraduates and beginning
graduate students.

Second edition of "Probability and Statistics with Reliability, Queuing and Computer Science Applications" by Kishor S. Trivedi is a highly recommendable book. The concepts provided for probability theory and stochastic processes are excellent for students of communication, networking and computer science. It provides a good understanding of stochastic processes and Markov chains which are very relevant for students and teachers especially working in the speech processing area. I found the book and its contents very relevant and the examples provided could be very well related to networking and computer science, a unique aspect of this book. The students grasped the concepts well and found the problems very challenging and helpful in building up their concepts and knowledge. I had previously taught a number of other books and introduced this book last year at my University, I feel very satisfied and content with the decision of choosing this book for my students. All eleven chapters are equipped with excellent examples, problems and exercises broadening the reader's mind. The first 5 chapters constitute the probability theory while the rest of the chapters emphasize on stochastic processes very relevant to students of advanced networking and speech processing. Other books on probability and statistics usually lack an important aspect specially when used for computer science and telecommunication students. The examples and exercises not only make students learn and understand and probability and statistics concepts but also create its relevance to their very fields, therefore the book is an extremely precious gift from Prof. Trivedi specially for the students of computer science and telecommunication. An inexpensive Asian edition (paperback), a solution manual and powerpoint slides of each chapter are now available.

Prof. Trivedi has done a tremendous job in introducing topics of advanced research not found before; the students gained knowledge about the modern research environment and felt confident too. This book is not only recommended for beginners but also for professionals and engineers.

This book from Prof. K. Trivedi is another great guide for the novice student and the expert researcher for modeling tools and techniques. It builds upon neatly explained concepts of probability, queuing and stochastic processes to provide a variety of examples of applications. It is definitely a book that one has to keep at hand, as it contains recipes for a huge number of performance and dependability evaluation needs. Besides the rich content, the structure and the presentation are great: a bit of theory and soon one example from practical life, the reader never gets lost but he is rather brought step by step to a comprehensive understanding of the topics.

The "Probability and Statistics with Reliability, Queuing and Computer Science Applications - 2nd edition " by Kishor S. Trivedi is a valuable reference for students and professionals. Didactically organized the eleven chapters presents the core concepts of probability theory and stochastic processes in an accessible easy-to-understand approach. The rich set of examples and exercises, based on numerous computer science and engineering real world applications, allow the readers to build their knowledge gradually.
I would like to highlight the system reliability fundamentals covered and articulate with the remains topics.

A very useful book. A good choice for somebody who is just starting to get a feel of the subject, or someone who is looking to build a strong foundation in the area. The best feature of this book is its lucid language. There are many books in the market, which cover a lot of material but, for the average reader, are very difficult to understand. The example-based approach coupled with a comprehensive material coverage are additional selling points. I would highly recommend this book

I have to say that this is a true classic. It gives a very nice treatment of what is NP-completeness in a fashion that really defends the topic well. It gives nice illustrations to show different situations and how to deal with it. But after the first couple of chapters it does get a little out there with the proofs it does. It is still approachable, but it assumes that the reader is already familiar with the basics of combinatorial complexity, especially in reductions. I would only recommend this book to readers who has gone through such books as Introduction to Algorithms by Cormen et al. or Combinatorial Complexity by Papadimitriou and Steiglitz. Those two books are more for beginners and this book should be one to help anyone interested in NP-complete problems to get more practice and depth understanding. Overall a great book for anyone interested in the topic. The grand challenge is to reduce everything to at least something within the 150 problems listed on your own.

The book is excellent in explaining NP-completeness problem. Take it as a reference if you would like to do research in this field.

This is a rare example of a textbook where the authors actually go to the trouble of considering the fact that the intended reader is a non-expert. Published in 1979 and still the best.

The book arrived in time, in good condition, and adequate packing.

This is among the most eloquently written books that I have ever read in my life. Highly recommended.

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.

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.

If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.

No, there isn't any real source code here. That should not be a problem - this book aims above the cut&paste programmer. The book in meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.

String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other non-deterministic optimizations, and probability-based techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.

By the way, don't let the biological orientation put you off. DNA analysis is just one place where string-matching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.

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.

If you like definition-theorem-proof-example and exercise books, Gusfield's book is the definitive text for string algorithms. The algorithms are abstracted from their biological applications, and the book would make sense without reading a single page of the biological motivations. Gusfield aims his book at readers who are fluent in basic algorithms and data structures (at the level of Cormen, Leisersohn and Rivest's excellent text). The exercises are wonderfully illustrative, being neither trivial nor impossible.

All of the major exact string algorithms are covered, including Knuth-Morris-Pratt, Boyer-Moore, Aho-Corasick and the focus of the book, suffix trees for the much harder probem of finding all repeated substrings of a given string in linear time. In addition to exact string matching, there are extensive discussions of inexact matching. Even the discussions of widely known topics like dynamic programming for edit distance are insightful; for instance, we find how to easily cut space requirements from quadratic to linear. There is also a short chapter on semi-numerical matching methods, which are also of use in information retrieval applications. Inexact matching is extended to the threshold all-against-all problem, which finds all substrings of a string that match up to a given edit distance threshold. The theoretical development concludes with the much more difficult problem of aligning multiple sequences with ultrametric trees, with applications to phylogenetic alignment for evolutionary trees (an approach that has also been applied to the evolution of natural languages).

Note that there is no discussion of statistical string matching. For that, Durbin, Eddy, Krogh and Mitchison's "Biological Sequence Analysis: Probabilistic Models of Proteins and Nucleic Acides" is a good choice, or for those more interested in language than biology, Manning and Schuetze's "Statistical Natural Language Processing". There is also no information on more structured string matching models such as context-free grammars, as are commonly used to analyze RNA folding or natural language syntax. Luckily, Durbin et al. and Manning and Schuetze also provide excellent coverage of these higher-order models in their books.

This book is not about efficient implementation. If you need to build these algorithms, you'll also need to know how to write efficient code and tune it for your needs. This is an algorithms book, pure and simple.

As a computer scientist, I found the discussions of computational biology to be more enlightening than in other textbooks on similar topics such as Durbin et al., because Gusfield does not assume the reader has any background in cellular biology. Instead, he provides his own clear and gentle introductions illustrated with algorithms, applications, open problems and extensive references. Like most Cambridge University Press books, this one is beautifully typeset and edited.

Beautifully written book covering almost all area of spoken language processing. However, despite of relative ease of reading, it is necessary to warn the beginning reader, that in some sections the deep enough acquaintance to their theme is veiled. It, for example, concerns questions of definition and application of delta function concept in chapter 5 (Digital Signal Processing).

What a wonderful book. Whether you are a computer scientist or mathematician with limited exposure to the discipline of speech processing, or alternatively you are a dedicated expert in this field, you will find everything you are looking for in this book. For two weeks, I couldn't put this thing down. And that's an extraordinary testimony to a book that's 800+ pages of technical detail. If you want a high level understanding of how speech processing works, or if you want to dig in and build your own speech engine, everything you need is right here.

A thourough and complete review about the subject, in which many disciplines (language, computer, probability, statistics, numerical analysis) converge. As a non-practitioner I have found it an enjoyable opportunity to refresh my knowledges in the field of signal processing, and a source of many hints I have been able to develop in other branches. In spite of notations and methodologies (e.g. bayesian) a bit far from I am used to, the near one thousand pages never seemed extreme related to the meaning compressed into them, spreading from base theory to advanced applications.

This book is a comprehensive overview of most of the major topics associated with speech processing. Divided into five main sections, the book is well structured with a clear division of concerns. The title, "Spoken Language Processing", may be misleading to some as language processing topics only accounts for one section of the book.

The first two sections cover the fundamental theories that should be understood before embarking in-depth into a study of speech processing. This may seem an obvious approach but many texts do not follow this pattern making their use as reference tomes limited. Separating background theory from its use is also useful in that it allows a rigorous approach to its description. Too often texts give a hurried imprecise overview of theories used before launching into a long and complex use of the theory; losing the reader instantly in a quagmire of formulae.

The first two sections of the book deals with background material, material that the reader should at least understand the key concepts of. The first section concentrates on speech in general (including production and perception), probability and statistics, and pattern classification. These last two topics mentioned are both important parts of the book and are dealt with in their own chapters. Both are well written with the right amount of explanation and background. Much of the remainder of the book expects at least some familiarity with the material presented here. These chapters, like all chapters in the book finish with a section entitled, "Historical Perspective and Further Reading". The inclusion of recommended further reading, in addition to the vast number of references appearing in each chapter, make the book as a whole a very good starting point for any work in speech processing.

The second section concerns itself with the DSP topics which relate to speech processing. In this section the reader will find everything from FFTs to multi-rate signal processing and speech signal representations to speech coding. Again the section is well written and the reader is not forced to refer to other texts to understand what is written. If a topic is not expanded upon here then it is an indication that is not dealt further in any great depth in the remainder of the book.

The third section of the book covers speech recognition and is probably the section which will find most use with many readers. This section is very thorough in its treatment of the subject. It starts immediately with a discussion of Hidden Markov Models which is almost exclusively the method employed in the pattern matching stage of speech recognition. Any algorithms that are mentioned are also detailed which really make the book useful. In fact algorithms are presented throughout the book making it a practical reference as much as a theoretical one. This is important because there is a big jump from understanding theory to being able to implement an algorithm to exploit that theory. Other topics covered include an excellent chapter on environmental robustness with one of the best discussions of microphones I have seen. Language modelling and search algorithms are given a thorough treatment. I would like to have seen more detailed information on front-end processing and endpoint detection, as this remains a critical stage of the recognition process. Perhaps the level of detail reflects the fact that this is currently a hot research topic with potential for significant advancement.

Section four, on text-to-speech processing, is a good overview of the field and better than any book I've seen on the subject. It shows numerous block diagrams of what you need to build such a system and gives numerous algorithms in pseudocode. It also dedicates a subsection to each block of the text-to-speech system block diagram, discussing in detail what you would need to do to implement that particular block. Since much of the individual blocks have been discussed earlier in the book, it refers you back to specific earlier sections for details.

The fifth section is a short one on entire systems and shows some case studies, concentrating on what Microsoft was doing at the time this book was published, since that is where the authors' research came from. I would highly recommend that anyone anticipating getting into speech processing have a copy of this classic nearby.

This is a great book if you want to know the future of what Microsoft's top researchers like XD Huang etc are thinking and working. Dr Huang is a super star of the field and it is equally worthwhile to read his excellent book.

I've found this book quite useful. There are lots of practical tips, tricks and techniques for VB 2005. I've gleaned a multitude of ideas for use in an intermediate VB class that I teach.

'Visual Basic 2005 Cookbook: Solutions for VB 2005 Programmers' by Tim Patrick is a perfect reference and solution manual for any and all Visual Basic 2005 developers. Written in typical great O'Reilly cookbook fashion, this book is chock full of nuts with 700+ pages of goodness.

Chapter Overview

01. VB Basics
02. Development Environment
03. Application Organization
04. Forms, Controls, Other Objects
05. Strings
06. Numbers And Math
07. Dates & Times
08. Arrays & Collections
09. Graphics
10. Multimedia
11. Printing
12. Files & File Systems
13. Databases
14. Programming Techniques
15. Exceptions
16. Cryptography & Compression
17. Web Development

This is simply a fabulous book that any and all VB programmers of today need to pick up. Not only will you save time, you'll enjoy doing it while reading this wonderful guide!!

***** HIGHLY RECOMMENDED

There are various sections in this book that are pretty basic and unnecessary to even an amateur programmer but there are also lots of other sections that are just chock full of great stuff and even advanced programmers would benefit from them. It also suffers from the common tendency to say very simple things using a lot of words in order to take up a lot of space. I think I even found a tip or two which show up twice in different sections. That being said, there's still a whole lot of worthwhile material in this book.

If you're new to programming in Visual Basic .NET, but have programmed in some other langauge before, there is always this barrier that one faces when they know, to a certain degree, the task they want to accomplish, but often fall short trying to figure out the syntax or method to implement it here. That is what this book does. It's an essential cookbook, in the language of choice, that bridges that barrier.

It's also a great side-companion for beginners, mainly because the intro books do a fair job of getting people started, but they also need to figure out specific tasks or methods of doing things that tutorial books won't cover. It does not overstate the obvious, and it serves up pretty clear impressions and explanations on what it delivers.

Very helpful for a casual programmer like myself. Just remember to download the "recipies" to avoid retyping.

It's rare to find an advanced computer science textbook that's both so engaging and so informative. I've only read the first seven chapters so far, but when I sat down to write my first genetic algorithm (for real research use), the book had already prepared me well.

It's hard to imagine a better introductory textbook for this topic.

This book is a great introduction to genetic programming and should be a model for textbook authors in other fields. Knowing little about genetic programming to begin with, this book guides the reader through the various topics and problems associated with genetic programming in a very logical and understandable way. Highly recommended! I wish more technical books were like this!

I skimmed the Koza books (GP: I & II) and this one at the store. Using the layout, chapter names, and the introductory chapters as my guide, I decided to buy this book to introduce me to the current state of the art in GP. The strengths of this book are its textbook format and the informal exercises that are presented for the reader at the end of every chapter. There is also a great deal of compilation from other relevant gp works presented in a localized, intra-chapter basis. The book is thus highly digestable to a newcomer, and is a far less time-consuming way to learn about GP than through the "expert" papers on the web. Having now almost finished the book, I feel that I am ready and able to author and apply GP techniques in a wide variety of applications and languages, having spent less than 20 hours in study time. A terrific achievement by Banzhaf and company, highly recommended.

This book is good for getting a general view of genetic programming. Nevertheless, I think it neglects many details. For example, it is very hard to from the book how a simple selection strategy (tournament selection) works in practice.

I do not think this book is useful for someone intending to code a genetic programming algorithm.

We all know that kind of books where the author likes to show how much he knows making things intentionally complex....well...this is the opposite side of the spectrum.
The book is very complete and detailed yet easy to read, even after a day of work.
The first part of the book contains introductory information on background areas like probability, biology and computer science as a general discipline.
Getting into the topic, it clarifies some of the differences between evolutionary systems and genetic algorithms and shows how all this contributes to the theory of genetic programming and the evolution of computer programs.
It explains how things are done with different types of individuals (tree, linear, graph, etc) and gives valuable insight about the implementation process.
Although you may need other sources for formal treatment of some topics, this book is a very good acquisition.

I already knew image processing when I bought this book, so I am not sure how it would appear to the novice seeking a textbook on the subject of image processing and analysis, but I imagine it could be somewhat confusing. I always recommend Gonzales and Wood's "Digital Image Processing" for those seeking a clear read on image processing and analysis from the ground up. Where Seul's book comes in is with clear descriptions and working code for many basic - and some not so basic - image processing and image analysis algorithms. The book is also very good at explaining the applications of the various transforms. One of the little things that the author of this book does that authors of other books similar to it don't bother to do is to realize that when you are working in image processing you likely have an image as an input and you want an image as an output. Thus the author has built his code libraries so that they work that way. You are not left with arrays of pixels that you have to figure out how to store and manage. In the end you have a nice functional toolbox of working image processing and analysis subroutines that you can chain together and make just about any type of image transform tool you could think of. I'm mainly interested in image effects, and I know this book has been useful to me. The accompanying CD-ROM contains all of the C source code for the algorithms so that you can port them to another language or tinker with them if you so desire. Highly recommended.

The title of this book corresponds to its content, the tutorial gives an excellent overview of basic key points to those readers who are unfamiliar with the subject (as I was). The book can not be used for rigorous study of even simple things but rather kicks you with essentials that are easy to understand with high-school background. This book, written for non-specialists in "image field", gives them techniques for their practical needs and concentrates exactly on image analysis, not on image processing. If you have no time to go through more complex (and deeper) books, take this one to discover basic principles in short form with no attempt to explain the fundamentals. The authors just put you into the facts, so that is why I would characterize the "Practical Algorithms" book as being "handbook". The good point is that the areas of applicability of these facts are explained, the drawback: you have to go to other books to get more details on image processing roots, e. g., to R. Gonzalez and R. Woods' "Digital Image Processing". I bought both, and use them as good annex to each other. The "Practical Algorithms" has lack of some significant areas, like snake algorithm and image binarization (thresholding) techniques but e.g., the cellular processing is quite well highlighted.
Surprisingly, the CD that comes along with this book gave me almost 80% examples that I was able to recompile instantly, and only several examples have failed, mainly due to image file format issues. The source code is not both elegant and bugless, but it is very transparent and portable and can easily fit, e.g., a 16-bit microcontroller.
Overall, this is good book for fast start. You can get real output and pick up ideas on practical side of image analysis. Just remember, the most book examples came from the medicine world, so they are quite specific and may not be implemented directly in your particular application.

Excelente libro. hace un tiempo que he estado estudiando y desarrollando estrategias para la implementación de sistemas de vision computarizada. Este libro es de una gran claridad práctica sin abandonar la necesaria base teorica. Muy buenos ejemplo, información adicional, ejemplos y aplicaciones. Para cualquier investigador en el área debe ser considerado como un recurso indispensable. (if you want my comments in english please send me an e-mail to innovacl@vtr.net)

I found the book to be very informative and I acquired several ideas from reading it. But, I repeatedly found myself searching the book for definitions of some of the terms it uses throughout its text. Practical Algorithms for Image Analysis will introduce new terms without any hint of their meaning, assuming that the reader already knows all they need to know about the subject matter (which would negate the need to buy the book!). This book sorely needs a glossary.

The book is just great! I used the source code from the CD-ROM for various image processing projects. The algorithms are also very practical if you have to deal with images. The code is neat and ready to compile and run.

Also this book is good on the description of image process and image analysis algorithms. I read the whole book and use it as a reference during my programming. It sits in my bookshelf and I use it almost everyday.

I recommend anybody who wishes to do serious image programming to have this book. It's just great!