Algorithms Books

I am a graduate student doing thesis related to Neural Networks. I never took any class about Neural Networks before. After reading the chapter "Artificial Neural Networks", I found out that it is very readable for students who are new to Neural Networks. It shows clearly how to calculate/adjust weights with many examples, without overwhelming you with too much Math. I highly recommend this book if you are new to Neural Networks subject.

The subtitle advertises "concepts, models, methods, and algorithms". Concepts and models, yes; methods, a few; algorithms, nearly none that you could actually code.

This book's strength is its breadth. It offers brief tastes of many topics. It discusses early data preparation, including reduction of dimension and handling of outliers and missing values. It emphasizes that different kinds of questions must be addressed in different ways. The rest of the book then covers decision rules of different sorts, clustering, neural networks, genetic algorithms, fuzzy logic, and data visualization. Each chapter includes references and comments on what to expect from each reference - a nice touch. The end of the book names a wide variety of web sites, products, and companies dedicated to data mining.

The big problem, however, is that the book is shallow. With a few exceptions, it just names techniques instead of giving descriptions that a programmer can use. For example, the discussion of missing data barely mentions the idea that imputed (made-up) values must be tailored to the specific analysis technique, so as to minimize their effect on results. There are exceptions, of course. Neural nets get a relatively detailed treatment. The author gives illustrative examples of genetic algorithms, but those were thin and tangential to data mining. The section on data visualization could have been much more lively. There is a huge body of visual technique, some bordering on artistry, that can present high-dimensional data to the human pattern-detection faculty, and samples are readily available. This book's examples were small and drab, though. Also, it completely ignored the research in auditory and tactile data representation, and omitted discussion of graphic design principles required for effective presentation.

What really bothered me were examples of sheer carelessness. A number of figures, including 4.8 and 9.9, contain errors severe enough to interfere with the point being made. Important relationships are simply illegible. Books like this aren't cheap - I would have hoped that the author would show a little more respect for the people paying the money.

This book may have value as a survey resource, but isn't for the reader who wants to implement the algorithms. Its bibliography is informative, but not a major asset. Indices of current products and web sites nearly guarantee early obsolescence. Look this over thoroughly before you commit your time and money to it.

This book can be used as an introduction to pattern recognition or machine learning rather than into data mining. Data mining does appear here and there, but mostly it is the classical pattern recognition and machine learning material (data reduction, clustering, neural networks) with very few illustrations from data mining. An introduction into genetic algorithms and fuzzy sets is also in the book, just in case, I suppose. If you'd like more specific data mining knowledge, look elsewhere.

Once you get past the typos, the content is excellent. Comming from a C/C++ background I found the information needed to easily transition into the world of Ada.

I don't know what the other reviewer here was thinking, but this book, though a few syntactical flaws in it, is an excellent book, written just like how lecture would be given. Algorithms, packaging, and all concepts are all explained thoroughly. Good Job!

This is one of the worst software development books I have ever read. Both grammatical and syntactical programming mistakes are present frequently throughout the text. Do not get this book!

It says it's a hardcover but I got a softcover -- a really flimsy softcover. It looks like something someone made in their basement with a photocopier. I am sure the technical merits of this text stand on their own, but the quality of this reproduction are not worth the price. I have contacted amazon and asked them to correct the product page (if necessary) -- certainly I'd be cautious about ordering this product.

After finishing this course for our 2nd semester in CS, covering data structures, I was taken back by how much this book has in it. I totally did not expect to see so much inside a book this small when I first glanced at it the day I received it.

Their concept of Lists are phenomenal and this topic is only expanded on greatly as the chapters go on. Their technique of reusing old code while keeping implementation independence and only slightly changing it for future implementations is the backbone of the book.

Programs developed range from complex, rational and polynomial code, graphical display list, graphical region filling, standard and complex parenthesis checker using stacks, infix to postix algorithm, operating system simluator, applying header nodes, circular list concepts developing a Lisp subset interpreter, line editor, expression evaluator, trees of all sorts and their counterpart graphs and their applications to a four-in-a-row game, Dijkstra's algorithm, and from sets to sorting, and many many more, there's even more they suggest for you to write in their exercises.

Do not buy this book unless you're serious about taking on it's seriously 'advanced' approach, or unless it's required by your course. It assumes a level of maturity as the book goes on by leaving out components to their programs for your interpretation and development on your own. Exercises are just that, exercises - there are no answers given. You are to interpret what they have and run with it.

I also minus a point due to K&R C. It was the only nuisance in the book. Otherwise, enjoyable read and the learning process from this book has been a worthwhile experience.

This was the book that made things click for me. It has a nice introduction to pointers and memory management using malloc(), then goes on to show how to implement stacks, queues, singly-linked lists, doubly-linked lists, circular lists, trees, and graphs. The example applications include a tiny line-oriented text editor (like UNIX's ed or DOS's edlin) and a lisp interpreter.

The only downside to the book is that it uses old K&R C, so the syntax for function declarations is not compatible with strict ANSI C compilers.

One would have thought from the title of the book that it would contain "... Parallel Genetic Algorithms", however it does not. The book covers statistical analyses of algorithms. The reader is meant to find other references that contain algorithms. It is expensive for such a small book. The author talks 'around' the algorithms, without going into the necessary details to write your own parallel genetic algorithms. There are many plots of evolution, so the author must of had access to the algorithms. This book could have been so much more valuable if it contained the algorithms, rather than just talk about them.

I think the previous reviewer got it wrong: It is very clear from the editorial introduction and from the table of contents that this book is about the ANALYSIS of parallel genetic algorithms, not about their implementation. The problem here is that implementing these algorithms is relatively easy, but configuring them is very complicated because there are many parameters. The work of Cantu-Paz---excellently summarized in this little book---is the best analysis available for the different types of parallel genetic algorithms.

I recommend this book wholeheartedly.

Genetic algorithms are easy to parallelize, but they are difficult to control. In a very concise manner, this book presents some theoretical results derived by the author that show how to make parallel genetic algoritms work for many problems and different architectures.

The book has a lot of new theory that is easy to follow and gives recommendations to make parallel genetic algorithms work well in many circumstances. Although the theory makes many simplyfying assumptions, the examples in the book demonstrate that the models are very accurate and the recommendations made in the book seem very reasonable.

This book is one of the best I have seen that completely covers clustering, and so many important applications of it to a wide variety of fields. The book is authored by some of the best researchers in the fields of fuzzy systems, pattern recognition and computational intelligence, so the text is complete, concise, and heavily informative.

Fuzzy Image processing in MTV'

This is the first comprehensive review of clustering algorithms with enough detail to implement and apply them that I have found. It is readable for an upper level undergrad, and is a superb reference on the mixing of fuzzy methods, clustering, and visual pattern recognition. The notation and pseudocode are very clear, and the authors tell you the practicalities of the advantages and problems with the various methods. I have written code for artificial intelligence, clustering, image processing and fuzzy. This puts it all together and would have saved me months. Bezdek is a guru on this stuff and has an incredibly clear view of his subjects.

Personally, I am satisfied with what I bought. I wrote an uninspired fast fourier transform from its mathematical formula and it took 30 seconds to execute. I knew I could do better. After buying the book I learn to play close attention to the bit reversal on the twiddles (trig functions). I also learned how to do the split-radix. I also learned that each calculation yields two terms. Also, I gained emough of a sense of how the fft works that I was able to successfully create threads and try parallel processing. All totalled, I reduced the run time from 30 seconds to 1 second.

The book was not as well written as I would have liked. The formula for the split-radix was screwed up. Using the form of the formula and the suggestion of what it represented I was able to derive the formula. It would have been nice if they had written out each term of each iteration for a 64-term fft. That is what I did to see with my own eyes what was happening. The text is too abstract.

All-in-all it was worth the $100.

While I'm positive that this book will serve engineers well, I cannot recommend it to practitioners of pure mathematics, videlicit those who are not comfortable with the bloodied abortion that is mathematics to the engineer. It blows my mind that we ever got a man on the moon! A good example can be found in the first line of page 7. omega^l=omega^(l+(2*n+1)). Keep in mind that n is an element of the set of positive integers, their claim not mine. Now, if you solve for n you'll find that this equation can only be satisfied for n=-1/2, clearly not an element of Z+! (Perhaps rational numbers are included in the set of "integers for engineers.") And yet they seem to indicate that it holds for all n in the aforementioned set! I pray that I've missed something and that someone will embarrass me by pointing out my mistake because as irate as I am right now, blood will likely shoot out of my nose in the next 5 minutes and they'll find me dead in my office at day's end.

If you need this book, you already know it. You barely remember what the Fourier transform does, let alone how it works, and you need to implement it from scratch. This book is for you.

Most programmers never need to use Fourier transforms. Most of the ones who do will get by quite nicely on black boxes from Mathematica, Matlab, or Numerical Recipes. Data goes in, answers come out, and "a miracle occurs" somewhere in between. There are those times, however, when you can't use the canned routines. You just have to write your own.

This book isn't for the faint-hearted, but really does give everything a non-specialist needs for creating a competent implementation. There's no cut&paste code here, but this is for people with unique needs. It presents a number of basic variations, with clear illustrations and pseudocode. It even discusses 2D transforms, but most of that discussion centers on how to transpose the 2D matrix between 1D transforms.

The discussion of parallel implementation was the only section I found weak. It's aimed at standard sorts of multiprocessors, with specific kinds of connection networks between processors. First, those networks are rare in commercial multiprocessors or are so deeply embedded that the topology is not accessible to the application writer. Second, those networks and architectures miss a lot of important computing environments completely - including the ones important to me.

I don't wish it on anyone, but it might happen - you might have to implement a FFT for yourself. If it does happen, this book may be your most effective tool. It will probably take the non-specialist (like me) time to get past some of the notation, but the answers here are worth the effort.

//wiredweird

This book has three subject matters which all run in parallel, informing and commenting on each other.

These subjects are: * the relationship between biological entities and computer objects * the future of the internet * OOPs programming in Director

The book is very clearly and cleverly written. The Lingo scripting, for example, is discussed in the main text in terms of its underlying principles, and the actual scripts are shown in illustrations, reproducing Director's script window. This means that the underlying arguments can be read without interruption, and by readers who have no Lingo experience.

Indeed many of the arguments in the book are addressed to a much wider audience than Director users and Lingo programmers. Peter Small suggests through a series of analogies and practical examples that there may be less difference between human and artificial intelligence than is normally thought - if we concentrate on the effects of intelligence rather than getting caught up in arguments as to what intelligence is and where it comes from.

He uses a wide range of examples, introducing the idea of Hilbert Space as his final conceptual flourish. Against the odds he even manages to explain this abstruse mathematical concept clearly and simply, and then demonstrate convincingly how it can be a useful tool for thinking about the future development of multimedia.

Peter's concern with multimedia lies in the development of 'intelligent' multimedia entities that he refers to as avatars - entities which can grow and change, accessing information on local hard disks, on CD-Roms and on the world wide web. The primary difference between these and traditional bots is that they are designed to operate from a client oriented perspective, rather than the more usual server side emphasis. They are designed to grow organically, to exceed the original intentions of the original programmers. They are designed to be diverse and different, and to use that as a strength.

In many ways Peter is proposing a complete inversion of the way we currently see the Internet. It is usually seen as a new broadcasting medium - I have a website and you can tune into it. Peter suggests that this is a very limited and limiting way to see what is essentially a huge repository of information, all able to be communicated in any way we can imagine. He suggests that the idea of the standard, generalised browser is an idea whose time has more or less gone. Instead he proposes specialised avatar systems who can respond to their users needs and desires and extend themselves across the web to bring back information in useful and structured forms.

One of his demonstrations concerns the construction of a café which can be used to bring like-minded people together, while another concerns avatar web-bots which can be sent off in search of like-minded people to bring to the café. Both of these are described in terms of the fundamental principles, their likely effects - and the Lingo necessary to construct them.

For readers with no Lingo experience Peter provides convincing arguments with just enough technical detail to demonstrate that what he is talking about is not science fiction but can be done today with standard software.

For readers who do have Lingo experience, there is plenty to chew on in the accompanying illustrations of scripts. Here Peter provides the details of how various avatar systems can be built and extended. In addition to the café and web-bots, these include a chemist who is able to work out the correct set of ingredients from sixty million possible combinations in less than 38 steps, taking a second or less in total. Peter uses this as the basis for discussing genetic algorithms, which can be used to model complex thought processes, and which can learn from their experiences, becoming more intelligent the longer they are allowed to 'live'.

Most interestingly of all, though, Peter intends to work out the implications of what he is suggesting in practice on the web. The book is therefore a starting point for an experiment which will be carried out by Peter and anyone who wishes to join him.

The book is, in effect, an invitation to participate in a uniquely exciting experiment - and there aren't many books you can say that about.

Some people may be put off by the author's referrences to magic and sorcery in his titles. In my opinion, Peter Small has something important to say to those of us interested in knowledge management and Web marketing. An avatar is an animated character on a computer screen and may represent a real person in a virtual world. In my opinion, the importance of avatars is not so much in the programming behind them (as impressive as that may be) but in the human willingness to attribute emotion and intelligence to avatars. An avatar that can access a variety of forms of multimedia, can learn from a variety of sources, and can visually represent emotion is of great potential consequence. Peter Small is a visionary and makes some pretty "radical" statements in his books. This is about the juncture of artificial intelligence, object-oriented programming, and animated interface design. That is potentially a very rich juncture. I wish there was a virtual community of people interested in the practical applications of Mr. Small's ideas.

Although the too-cool title made me suspicious, I got this book because I read an excellent review of it (on this page). I was hoping to read a forward-looking thesis on multimedia avatars, but got instead a book which should have been called "Having Fun with Director." It's not about programming, artificial life or avatars. If you have never heard of genetic algorithms or object-oriented programming and think the internet is an incredible source of useful information, then perhaps this book is worth a quick read. Otherwise skip it.

I ordered this from the publisher and it literally fell apart as I started reading it. I'm going to have to 3-hole punch it and find a thick binder for the over 500 pages! I thought it might be the publisher (Sitepoint), but I just read that a Peachpit book (the new Scott Kelby book) is having the same problems. I wonder if they use the same binder? I can't actually review the book, as it's unreadable in the present condition. I have read other Sitepoint books though, and find them quite good, particularly the Yank book. This is the first one to fall apart.

While I wouldn't read this book cover-to-cover, it makes a very handy and current reference title for any intermediate PHP programmer.

100 Solutions, neatly divided into 13 chapters, make it very quick to find what I was looking for. The downloadable code from the publishers website also helped a great deal and saved me some time.

I found the security checklist at the back of the book particularly useful and helped me pinpoint and solve some potential vulnerbilities. Chapter 13 on best practices was also a clear standout in my mind, as it covers PHP coding best practices and helped me improve how I work.

I really wasn't sure what to expect with the book, my shelves are already packed with a stack of good PHP books that I've read through once, got a few good gems of info from, put on the shelf, and never touch again.

It was the title that got me first interested in this book, sort of like the greatest hits of PHP which, in theory, is a book that I expected to get a little more use from.

I'm happy to say that this book delivered on it's promise and them some.

The difference between this book and say some of the other more tutorial style PHP books I own is that it doesn't follow the one size fits all approach. It actually explains solutions to problems that your able to adapt you your own world. I downloaded the code from the books website which made my life even easier.

It's organized into stack of little mini tutorials covering most of the challenges you'll face if you're programming with PHP. I didn't read this from cover-to-cover but more jumped straight to some of the specific sections that I was keen to learn about. The layout and design of this book enables you to jump around from section to section easily.

I'm now finding myself going back to this book time and time again as new problems crop up, just today I had to solve a caching issue and violia a nice little example of exactly what I needed was there in chapter 11. It saved me a stack of time so I thought I'd use it to write this review.

It's also worth noting that chapter 1 contains a nicely written introduction to object-oriented PHP and is worth a read if your just starting with PHP and everyone should read chapter 13. Even though I've been programming in PHP for a while now this chapter opened my eyes to why I experience some of the frustrations I do... I'd probably be happy with paying the cover price just for that chapter alone.

It's my first sitepoint book and I've got to say I'm extremely happy. They seem to do things a little different than you're old schoolers and I've got to say the approach is refreshing. I'd have no problem with recommending this to PHP developers at any level.

If you don't already know the C programming language, this is probably a pretty good book on C++ programming basics. It goes into control structures, arrays, strings, pointers, recursion, and abstract data types, among other topics. It even has a good introductory chapter on the basics of computing that even includes information on the binary and hex number systems. In that sense, it is good enough to stand alone as a pretty good textbook. However, there is one major component missing from this outline that is essential for anyone who claims to know C++ in any meaningful way, that being any mention of object-oriented programming constructs as expressed in the C++ language. If you don't know object orientation as it is expressed in C++, then you are just a C programmer programming with C++ notation. Thus, this outline is not wrong, it is just woefully incomplete. I still give it three stars because for the right audience it is a good beginner's text at a very cheap price. For those who are interested in learning object orientation as it is expressed in the C++ language, I instead recommend "Schaum's Outline of Programming with C++". In that book there is less of an emphasis on algorithms and computing and more of an emphasis on teaching the complete language with all of its components.

This is the C++ guide in the famous Schaum's outlines series. It teaches you the foundation's of C++ fairly well, as usual with a great load of examples and code snippets. We are used to this by Schaum.

What I am missing is in-depth information. How do I use make to compile bigger programs? How do I use the STL? How do I use glib?

This book will scratch the surface, and will probably be an ok guide for a novice. But if you want to take a step further after the first weeks of learning C++, you will have to look elsewhere.

I am a 12 year old male who just happens to be interested in learning C/C++. Someone showed this book to me and highly recommended it. I have found that the text is simple to understand even to a novice starting for the first time, and that it is completely stuffed with useful examples. I am going to buy this book -- you just wait!

I bought this book to gain a practical understanding of Fourier Transforms and how to implement them with real data. I already had a conceptual understanding of FTs but not a practical one to where I could use them. This book bridged that gap for me and it seems as though that was among the author's intentions were when he wrote it. I would recommend this book and its companion to anyone in the same position.

I needed to learn some basics about the DFT and FFT. "Understanding the FFT" seemed to be loaded with computer programs. I found very little to help me learn the concepts. "Who Is Fourier? A Mathematical Adventure" by the Transnational College of Lex and "Introduction to Fourier Analysis" by Norman Morrison where the books that helped me the most.

This book contains all the necessary info to obtain a working knowledge of DFT and FFT. It contains many GWBASIC example programs so the reader can get a good grasp of what the algorithms are supposed to do. "C" progammers would have no difficulty rewitting these algorithms in "C".
Notes:
(1) most GWBASIC programs run without modification under QBASIC.
(2) the ones that don't run under QBASIC contain graphics statements and are easily fixed using QBASIC help.
(3) if you hate to enter source code, the software is available on diskette from the publisher for a small fee ...(includes GWBASIC and QBASIC examples)
(4) I've discovered "BASIC programmer" web sites where both GWBASIC and QBASIC are available for free download.