Algorithms Books

If you are interested in this topic, you should read this book. Disclaimer: I am new to the topic but appreciate when it is done well and need to understand how to implement it for my job. I was blown away by both the conceptual coverage and the implementation details. This book will allow you to cover the concepts on a first pass then come back and actually build the approaches you are most interested in. Even if you ultimately use a vendor product for recommendation, you will understand the algorithms being used and their proper application and where they are deficient.

Programming Collective Intelligence is a book about applying data mining techniques to analyse collections of data. There is submerged information in Ebay prices, in Facebook profile networks, in collections of movie reviews, in news sites, in the stockmarket; this book by Toby Segaran shows ways to extract, visualise, understand, and predict that information.

Each chapter explains and explores a different data mining algorithm, and builds up a working example in Python, while presenting different methods and parameters of the implementation. I hadn't really worked with Python before, but found the code easy to follow, and picked up some interesting Python idioms that I haven't seen in other languages before. Chapters end with a set of exercises to follow that build your understanding.

As you follow the examples you build up a reasonably generic code base that allows you to swap in and out different implementations, and reuse previous code to add to new applications.

The examples use live examples from the web: sites like Ebay, Facebook, and Yahoo Finance, and this makes the book more interesting and the results more visceral than some other books on the subject which use more contrived or obscure examples. Even though there is a strong web (or web 2.0) focus on the examples, the methods and the understanding is useful for a whole range of applications.

Some of the topics covered:

* Bayesian classifiers to detect spam, or to file news articles into site sections
* Hierarchical and k-means clustering to discover groups of similar items in massive sets
* Euclidiean distance, Pearson Correlation Coefficient, Tanimoto Coefficient: ways to measure the distance (or difference) between items
* Neural networks to predict user behaviour and improve search result ordering
* Optimisation methods like hill climbing, simulated annealing, and genetic algorithms
* Non-negative matrix factorization
* Support vector machines and kernel methods to go where linear regression can't

I found it exciting to read -- it's one of those books that give you a whole bunch of new ideas for things to build as you read it. The presentation is very good: no background is assumed, and it doesn't talk down to those more experienced.

Recommended.

I have just about finished reading this book, and I'm really enjoying it. It's loaded with great information and examples. I like how the author gives the reader tips on when certain techniques are better than others. The python examples are clear and easy to read. I'd love to see more books follow this one's style and structure.

most people have shared their thoughts on the good of this book. I like to point out some of the bad as I read through:

- first, too many typos - both the author and oreilly should do a better job on proof read the materials. the typos are so much that it can easily wreck otherwise good materials.

- second, arcane solution and coding style. Many first step to the solution of machine learning is to represent the problem at hand well. The author's brain apparently wired different from mine so the opinion is personal. For example: chapter 5 on "optimization for preference", he chose to represent a solution as vector form like [0,0,0,0,0,0,0,0,0,0], there is no way I can relate this solution to the real meaning (you want to allocate 10 students into 5 rooms each with two slots) - if there is an easy explanation, the book didn't say so.

thus the 3 star. I believe a second edition is warranted and should be much better.
just my 2c.

Once I got past the initial shock of finding several glaring grammar and spelling errors in the introduction, I have been pleased with this purchase ever since.

The author gives a good overview the many different approaches to machine language (with great examples in Python). However, it's just that - an overview. While the explanations are very clear and the concepts are presented in a very accessible manner, I found myself having to look elsewhere for more detail on the various algorithms. Yes, with the level of understanding presented in this book you should be able to create functional code for your particular data set. However, I felt that to really get the best results from the algorithms I needed to study them a bit further in order to best apply them to my data.

As a recent CS graduate, I would certainly recommend this book to anyone looking for a basic understanding of machine learning and data mining techniques.

This book presents an excellent introduction to Data Structures using Java.The workshop applets are really helpful to get quick understanding.

If you r looking for a book that concentrates on Data structures in JAVA, then this book is definately for you. It does not bore you with the AWT libararies and all that, it lets u jump into the nitty gritty of data structures programming in Java. I don't think it even touched on the AWT libraries once in this book. Which is good for me since my school sylabus doesn't touch on that at all either. It especially touched on the topic of linked lists very well, explaining the concept in the most simplest way possible. And for alot of us, we usually hit the brick wall when we reach tht topic on linked list. So yeah, if u really want to buy a good book for DS on Java, this book is for u!

This book is outstanding. I am very familiar with data structures and I am fluent in several computer languages, but not Java. I was looking for a book that would let me quickly implement the data structures I needed in Java. This book is perfect for that. LaFore is an excellent writer. The examples are short and focussed on particular data structures. The code is very easy to read, modify, and combine. And, unlike many other books, LaFore's code is debugged and works right out of the book. I purchased several books on data structures in Java, and this is the one I use. My recommendation: buy it.

When I started studying data structures, I was quite taken aback by the descriptions given in my college textbook. The examples were convoluted and shied from giving the reader an understanding of the basic concepts. Rather, it chose to focus purely on algorithmic analysis. That approach required too many mathematical proofs and other complex notation. Fortunately for me, this gem by Lafore came to the rescue.

Lafore's illustration of data structures is concise and easy to follow. In each section the data structure is discussed in general and then further dissected into easily understandable subsections. An added benefit is that each chapter has Java code that illustrates the main functions of each data structure discussed. The code is included on a CD that also contains interactive Java Applets. I found that the applets really helped illustrate how some of the more complex structures work.

There is no code in the chapter on Red-Black trees or in the chapter on 2-3-4 Trees and external storage. This is okay however, since presentation of the code might have consumed too much space and have been difficult to follow (Fortunately, There are insightful applets for these topics). My only regret is that the book doesn't give as much in-depth information on certain functions of B-trees and B+ Trees as it does on the other topics. More than less likely this is a little (too?) picky on my part.

Overall a great book to get if you are interested in learning essential Data Structures.

Is there a perfect book out there on data structures using Java? No, but this book by Lafore is the best among the lot especially for students (like me) trying to learn the stuff. This book is the exact opposite of the widely used book by Tamassia&Goodrich (T&G) - that is, Lafore covers data structures in a non-mathematical, non-technical way without using formal proofs and abstract mathematical definitions. This makes it very readable and understandable especially when compared to T&G. It covers all the major topics you're likely to see in your data structures course: arrays, stacks, linked lists, queues, sorting algorithms, trees, heaps and hash tables. The last chapter - When to Use What - is excellent. Distills the whole topic into just a few pages.

Complaints: This book gives very short shrift to big O notation IMO. And Lafore really takes the easy way out with heaps - he uses an array (Ugh!). Come on, Lafore, you should have used a tree for this ! He doesn't cover AVL trees at all so you'll have to look elsewhere for that. Also, ... the source code isn't 'generic' enough - he implements many data structures to hold a specific type instead of allowing them to hold generic Objects. There are no end of chapter exercises so I don't know if it could be used as a regular class text. The applets on the disc are instructive, though.

If you could combine the topic coverage of T&G (along with just a bit of their formalism) and Lafore's readablity you'd have the perfect teaching book on data structures using Java.

I had the pleasure of taking the course "Concrete Mathematics" with Ron Graham as an undergrad engineering student at Princeton University in the late 1980s, and in retrospect it was quite possibly the highlight of my academic career. Likewise, this text has a cherished spot in my bookcase even to this day. The material is challenging, sometimes downright frustrating, but good stuff nonetheless... and as others have noted, very useful! The skills gained are specifically tailored for application in fields such as computer science, really a number of disciplines; and complement what one learns in the more "standard" math courses. How many academic texts have become must-haves even beyond your college years? For me, only this one. I'd give it fifteen stars if I could.

This book's title can be misleading. I would say it is more of an advanced textbook on the mathematics that is a foundation for computer science than a foundational book on the mathematics of computer science. I think this misreading of the title and thus the book's content is what is behind much of the heartache that readers have when trying to tackle it. This book expands on the "Mathematical Preliminaries" portion of "The Art of Computer Programming" series of books by Knuth, and thus this book has a style much like that series of books. The book is complete and clear, but it is also densely packed with lots of theory and proofs and will require much effort and time to understand well. It is really not meant to be an applied mathematics textbook at all. I show the table of contents next. Note that there are exercises at the conclusion of each chapter with solutions in the back of the book. However, most of the exercises are not so simple that you can just glimpse at the solution and figure out how to get from A to B. I recommend it if you have the time. It can really bring out thoughts and the beauty of mathematics that you may not have considered before.

1. Recurrent Problems.
The Tower of Hanoi.
Lines in the Plane.
The Josephus Problem.
Exercises.

2. Sums.
Notation.
Sums and Recurrences.
Manipulation of Sums.
Multiple Sums.
General Methods.
Finite and Infinite Calculus.
Infinite Sums.
Exercises.

3. Integer Functions.
Floors and Ceilings.
Floor/Ceiling Applications.
Floor/Ceiling Recurrences.
'mod': The Binary Operation.
Floor/Ceiling Sums.
Exercises.

4. Number Theory.
Divisibility.
Factorial Factors.
Relative Primality.
'mod': The Congruence Relation.
Independent Residues.
Additional Applications.
Phi and Mu.
Exercises.

5. Binomial Coefficients.
Basic Identities.
Basic Practice.
Tricks of the Trade.
Generating Functions.
Hypergeometric Functions.
Hypergeometric Transformations.
Partial Hypergeometric Sums.
Mechanical Summation.
Exercises.

6. Special Numbers.
Stirling Numbers.
Eulerian Numbers.
Harmonic Numbers.
Harmonic Summation.
Bernoulli Numbers.
Fibonacci Numbers.
Continuants.
Exercises.

7. Generating Functions.
Domino Theory and Change.
Basic Maneuvers.
Solving Recurrences.
Special Generating Functions.
Convolutions.
Exponential Generating Functions.
Dirichlet Generating Functions.
Exercises.

8. Discrete Probability.
Definitions.
Mean and Variance.
Probability Generating Functions.
Flipping Coins.
Hashing.
Exercises.

9. Asymptotics.
A Hierarchy.
O Notation.
O Manipulation.
Two Asymptotic Tricks.
Euler's Summation Formula.
Final Summations.
Exercises.

A. Answers to Exercises.
B. Bibliography.

This is one of those math books where the authors enjoy making inexplicable leaps between equations that really don't follow in a smooth logical fashion one from another. They are terrible at explaining things. They like to boast that they are from Stanford, (subtext: implied: if you are not from Stanford you probably wouldn't understand it anyway, you poor pitiful low-income commoner). I absolutely hate the tone of this book. And the side comments in the margins are inane, weak and mostly irritating. I threw it aside in disgust and went back to Warren Weaver.

This book is great. It is the funnest math book I have worked with, and I appreciate the intensity of the mathematics -- something that is falling out of the norm in computer science. The book is also a great source of fantastic combinatorics.

I have the First Edition and came here to look into the Second Edition. There are several negative reviews and basically those folks have fundamental misunderstandings. So I'll add my review.

First, what kind of book is it? It is not an introductory-level math book with lots and lots of repetition. It is a book on hard math, done in a concise manner by brilliant teachers who assume students are very comfortable with calculus, probability, etc. You really cannot afford to skip around and dabble as if this were an introductory algebra course or something. (I'm not being elitist. I did not attend Stanford and don't consider myself a math genius and am not making this a "we versus the unwashed masses" issue, as I have really struggled with the material myself.)

Second, what is the book about? Several reviewers have theories on where the "Concrete" part of the title comes from, but the bottom line is that it's a book on the discrete math that you need to know for theoretical computer science. (For example, discrete calculus versus the continuous calculus we all learned in school.) Any Analysis of Algorithms course, for example, will confront you with recurrence equations and lots of discrete math.

Third, how is the book organized? At first, it appears rather disjoint. The authors have a sort of, "Hey, look at that flower," and "hey, look under this rock" kind of approach as you walk down a path but the path itself isn't really spelled out. None-the-less, the book does build step-by-step from examples of recurrence equations (Towers of Hanooi, Josephus) in Chapter 1, to Generating Functions in Chapter 7.

Perhaps they could have made the path more explicit, but I can't see how they'd organize it much differently. They could throw entire chapters into Appendices, but things build on each other in such a way that you'd simply have to skip around from the main chapters to the Appendix anyhow.

Fourth, what other books cover this material? I'm not well-qualified to talk about the entire universe of books, but I must say that the three Analysis of Algorithm books I have for my current class definitely give only the very basics of this material and really only present two possibilities: 1) fiddle around with the equation, possibly using a graphic representation, until you see a pattern and make a guess, then prove it by induction, or 2) if your algorithm is one specific class, plug some numbers into this 3-part formula and if one of the parts applies an answer will pop out for you. Concrete Math is gives you many powerful tools to solve such problems.

Fifth, what is the flavor of the book? The authors have an informal writing style -- outside of the very formal math and proofs -- and the book has marginal notes that were contributed by the "beta-tester students" as the book was being written.

Some reviewers have criticized the marginal notes, and I simply have to shake my head and be glad I don't have to work alongside them. Yes, many of the notes are puns or other humor, but those are a nice break from the heavy math. And many of the notes provide great hints and perspectives from students who are also learning the material. I wish all technical books had such notes, but only a Knuth could get a publisher to go to the trouble.

So that's my review. An excellent book that's very intense and covers a hard, very technical topic. It's like learning math from algebra to differential equations all over again in a different language, and perhaps the negative reviewers simply never understood this. If you're not a programmer who needs to rigorously analyze algorithms, skip the book unless you simply want to learn for the joy of learning.

If this book doesn't get you excited about programming, I don't know what will. Bentley writes about programming problems that are as glamorous as hollywood. The collective wisdom of the Bell labs super-stars shines through in this timeless classic.

This book is really addressed towards absolute beginner programmers. Maybe if you've only taken an introductory course or two at college, or just have the syntax of one language under your belt and want a broader perspective this book will be useful.

If you have any experience, the examples are all very mundane. (E.g. "this is what a minheap is"). If you have just finished reading a "Learn [Language] in 24 hours!" type book, I guess this wouldn't be a bad follow up. Otherwise, steer clear.

great book. guaranteed to transform you into a better and more professional software engineer

Read this book, the sooner the better! This IS the Computer Science as it's supposed to be in the same row with Knuth and Sedgewick.

Derived from a popular series of columns from the ACM flagship magazine (Communications of the ACM), this book takes you as near as possible to a professional programmer's way of thinking.

Each chapter walks through the internal process a programmer follows to solve particular problems (and teaches newcomers how some techniques should be used in practice).

If you read only one book on computer programming apart from your language handbook (something I would never recommend), this should be the one.

PS: Plauger's "Programming on Purpose: Essays on Software Design" would probably be my second choice.

This book is splitted in two parts.
The first part mostly contains general advices about algorithms, performances, and such.
The second part is more like a huge catalogue of "classical" problems and algorithms related to those, with advices about how to work them. It does not contain algorithms or pseudo-code (or very little), but is more about how to address the problem (and also contains pointers to an implementation).

For those computer science students and programmers who are put off by the style of "Introduction to Algorithms" by Cormen et al., this book is a good alternative. Rather than just being a catalog of algorithms with code and little explanation, this book covers a much needed middle ground and contains a good deal about the analysis and design of algorithms in general along with discussions of common algorithms themselves in an accessible style. In fact, the author makes a point of mentioning in his preface that you will not find a single theorem in this book, and that the purpose of his book is to get working programmers up to speed quickly on both the generalities and specifics of algorithm design.
The first part of the book is on techniques, and covers the basics of modeling algorithms along with "Big Oh" notation, data structures and sorting, dynamic programming, graph algorithms, combinational search, and the concept of intractibility. What makes this section of the book particularly interesting are the author's "war stories" that talk about real world applications of the ideas discussed in each chapter.
Part two of the book, "Resources", is an extensive catalog of algorithmic problems organized by type. For each problem mentioned, the book includes a problem description and discussion, possible implementations, and other algorithmic problems that are related to this one. In the implementation section for each algorithm, the author demonstrates the kinds of questions that the reader should ask when designing his or her own implementation. The C, C++, Fortran, and Pascal code for all algorithm implementations mentioned is on the accompanying CD rather than in the book itself, which helps make the book more compact.
This book is a very good introduction to the methods of algorithm analysis and design, and an encyclopedic reference on many different types of algorithms. Highly recommended.

There are many reasons I like this book more than other Algorithms books I own (e.g. Sedgewick). One is that Skiena's book comes with an HTML version, so it's easy to keep it with you at all times (e.g. on your laptop, at work, and at home). Another is the "war stories". I found that I wanted to read the war stories first, rather than the technical content. Another is that the book points you at existing implementations, which really is what you'll eventually need to look at if you're going to use or write any code.

Overall, I found that when confronted to real world problems, the "Algorithm Design Manual" was a better resource than other Algorithm books. This is why I'm recommending it to software engineers out there. It seems to be written for people working with algorithms to solve problems, rather than as a support for an academic course.

On the negative side: I find the resource catalog to be exhaustive but somewhat shallow. As I'm getting older and slower, some things are not as obvious as they used to be. For example, I was quite unable to derive how to use Voronoi diagrams to perform nearest neighbour search, although it is supposed to be "a simple matter".

I found this book extremely practical, especially for professionals that don't have everyday the occasion to be confronted with real algorithmic problems (I assume that most of the industry-related software programmers / designers / analysts are in this category), thus beeing in need to have a reference at hand "just in case" :-).

Together with "Programming challenges" also from Skiena & co. constitutes a powerful known algorithms references, and supplied with some natural problem-solving talent, could be a succesfull preparation for something like ACM contests or topcoders.com

Nice to have this book handy if you need to design efficient algorithms for your programs. This is more of a reference than to teach you what algorithms are out there, so you better know them before using this book. That said, this book is quite unique since it differs from a typical algorithm book on the market. Skiena has done a great job in presenting the material. I find this book really handy, definately recommanded.

This book is splitted in two parts.
The first part mostly contains general advices about algorithms, performances, and such.
The second part is more like a huge catalogue of "classical" problems and algorithms related to those, with advices about how to work them. It does not contain algorithms or pseudo-code (or very little), but is more about how to address the problem (and also contains pointers to an implementation).

For those computer science students and programmers who are put off by the style of "Introduction to Algorithms" by Cormen et al., this book is a good alternative. Rather than just being a catalog of algorithms with code and little explanation, this book covers a much needed middle ground and contains a good deal about the analysis and design of algorithms in general along with discussions of common algorithms themselves in an accessible style. In fact, the author makes a point of mentioning in his preface that you will not find a single theorem in this book, and that the purpose of his book is to get working programmers up to speed quickly on both the generalities and specifics of algorithm design.
The first part of the book is on techniques, and covers the basics of modeling algorithms along with "Big Oh" notation, data structures and sorting, dynamic programming, graph algorithms, combinational search, and the concept of intractibility. What makes this section of the book particularly interesting are the author's "war stories" that talk about real world applications of the ideas discussed in each chapter.
Part two of the book, "Resources", is an extensive catalog of algorithmic problems organized by type. For each problem mentioned, the book includes a problem description and discussion, possible implementations, and other algorithmic problems that are related to this one. In the implementation section for each algorithm, the author demonstrates the kinds of questions that the reader should ask when designing his or her own implementation. The C, C++, Fortran, and Pascal code for all algorithm implementations mentioned is on the accompanying CD rather than in the book itself, which helps make the book more compact.
This book is a very good introduction to the methods of algorithm analysis and design, and an encyclopedic reference on many different types of algorithms. Highly recommended.

There are many reasons I like this book more than other Algorithms books I own (e.g. Sedgewick). One is that Skiena's book comes with an HTML version, so it's easy to keep it with you at all times (e.g. on your laptop, at work, and at home). Another is the "war stories". I found that I wanted to read the war stories first, rather than the technical content. Another is that the book points you at existing implementations, which really is what you'll eventually need to look at if you're going to use or write any code.

Overall, I found that when confronted to real world problems, the "Algorithm Design Manual" was a better resource than other Algorithm books. This is why I'm recommending it to software engineers out there. It seems to be written for people working with algorithms to solve problems, rather than as a support for an academic course.

On the negative side: I find the resource catalog to be exhaustive but somewhat shallow. As I'm getting older and slower, some things are not as obvious as they used to be. For example, I was quite unable to derive how to use Voronoi diagrams to perform nearest neighbour search, although it is supposed to be "a simple matter".

I found this book extremely practical, especially for professionals that don't have everyday the occasion to be confronted with real algorithmic problems (I assume that most of the industry-related software programmers / designers / analysts are in this category), thus beeing in need to have a reference at hand "just in case" :-).

Together with "Programming challenges" also from Skiena & co. constitutes a powerful known algorithms references, and supplied with some natural problem-solving talent, could be a succesfull preparation for something like ACM contests or topcoders.com

Nice to have this book handy if you need to design efficient algorithms for your programs. This is more of a reference than to teach you what algorithms are out there, so you better know them before using this book. That said, this book is quite unique since it differs from a typical algorithm book on the market. Skiena has done a great job in presenting the material. I find this book really handy, definately recommanded.

I found the book very interesting to read as a textbook becasue it draws many examples from everyday applications. The style of writing is good and it covers broadly all areas of IT security. For those requiring more detailed discussions in specific areas of security, this may not be sufficient.

The title is maybe misleading. It is not really a guide that will show you a procedure step by step 'how to do' to build secure systems as most engineering books do. It is rather a survey of the different security protocols used in various fields. Of course, you can learn from the success and errors described in the book and use this knowledge for developing a new system but you will have to connect the dots yourself.

The book is very dense in information and at first, its format was making it tedious for me to read. It did take around 3 chapters before I get accustomed to the format. Once, this aspect was out of the way, this book became amazingly interesting. It describes systems used in banking, by diplomats, military, for nuclear weapons, police, set-up box TV decoders smart cards and anti tampering devices in general, spies, biometric authentication, etc.. and focus on the security protocols used by these systems and then highlights the weaknesses of the systems and how people have figured out how to workaround these protocols.

The best quality of the book is that it will help you to better understand the mindset of a secure system designer and a system hacker.

Nutshell review - You should read this book if you have anything to do with information security. Chapters are topic specific and can be easily used as a reference. Well written, easy to follow, great book.

The book is interesting but it's starting to show signs of it's age. I think the last revision of it was 2001, so the examples are good, yet aged. It would be great if they updated it. Still a useful and good book though.

This is certainly a good book for getting introduced to most high-level architectural concepts related to Network security, cryptography, mandatory/multi-level access control etc. From a application development perspective, this book falls short on how to build architecure, design and implement them into your business applications which ultimately meets the end-user. The author justifies the high-level concepts well enough from a generalist perspective, but the industry-standards from OASIS leans towards standards-based application security protocols..which pushes a developer/architect like me to take those suggestions first and how to apply them in real world. The book also does'nt address on how-to build security for emerging application architectures based on Service-oriented architecture (SOA), Identity Management, Net-centric Federated applications. As a developer/architect using Java or Microsoft .NET or open-source based distributed applications, I need guidance on how to implement the recommended concepts (in the book) for example using biometrics or smartcards for building multi-factor access control at my application-level...unfortunately I don't find any answers for real-world implementation.

This is a very large book covering many areas of digital signal processing. I bought a used copy of the third edition to replace an earlier one. Unfortunately, many of the errors - conceptual, not typographical - have remained. For example, the authors state in Sec. 8.3 that the frequency response of an elliptic (Cauer) filter is a rational function of a Jacobian elliptic function of frequency. An electrical engineer would know that a transfer function of a network of discrete components is a rational function of frequency, whereas the Jacobian elliptic is a transcendental function. The typographical error in the name of the mathematician Schur has finally been corrected attesting to the fact that neither author ever read the original paper. The presentation is extremely detailed in trivialities, with as many pictures, including a derivation of the sum of a geometric series as an exercise, a subject usually taught in high school. Finally, as another example, the solution's manual gives the wrong answer for Problem 2.9(a) stating, in effect, that a periodic function possesses a limit as its argument tends to infinity, showing complete ignorance of the notion of limit by the authors. Books such as this have little educational value, confusing the student with tons of irrelevant information, non-standard nomenclature - the Cauchy Residue Theorem in Sec. 3.1.2 is renamed to Cauchy Integral Theorem - and wrong answers. This book, if properly corrected, would be very useful.

It's very very useful book for system identification specially newstarted, because of the fact that system identification is heavily related DFT, FFT, Spectral Analysis, Wiener-Khinchine relations and so on. Congratulations !!!

This book is a great theoretical introduction to DSP. Although its size looks intimidating and there is a lot of math, this book is very good for a beginner because firstly, the size of the book is due to numerous examples as well as clear and detailed explanations for most of the concepts and secondly, it is possible to skip over much of the math if you are so inclined and take away the gist of the section. This is the case in some of the more advanced topics covered which may be suitable for a second reading.

Some of the things I liked in this book are:
- The organization of the material and lucidity of the writing and explanation
- Consistency of notation
- The concepts of frequency in continuous and discrete time signals in Chapter 1
- The long introduction to discrete time systems and the concepts of linear time invariance in Chapter 2
- The explanation of Fourier series and Fourier transforms of continuous time and discrete time signals (periodic and non periodic) in Chapter 4 is the best part of this book
- Frequency domain characteristics of LTI systems in Chapter 4
- The way the DFT was introduced and its relationship with the DTFT in Chapter 5
- Sampling and reconstruction of signals in Chapter 9

Some of the things I did not like in this book are:
- The way the sampling theorem was derived in Chapter 4. In DSP you can derive the same thing in many ways but in many cases one method is more intuitive and simpler than the rest. There is an easier way to derive the sampling theorem
- There are mistakes in some equations. Not a major issue though
- There is no MATLAB or computer exercises or examples anywhere. This is a pity because you can learn so much and get a lot of insights with a few hours of DSP with MATLAB. Also there are some things like filter design which are done only on a computer
- I did not like the treatment of Multirate DSP in Chapter 10
- There is no treatment of 2D processing anywhere

On the whole this is a great theoretical introduction to DSP with a few minor drawbacks. I would still recommend this book over the ones by Oppenheim and Mitra for a beginner. But I would wait for the fourth edition that comes out in Feb. 2006 before buying any DSP book.

This book was required for a graduate-level DSP course, but I found it quite insufficient for study without a VERY good set of classroom notes. There are mistakes in various equations throughout the text, little to no examples, and I have yet to find a solutions manual.

The one nice thing I can say about the text is that it is thorough in its coverage. The book covers almost every topic I can think of for both undergraduate and graduate-level courses. My course has supplemented the text with "Discrete-Time Signal Processing" by Oppenheim and Schafer as well as "Adaptive Filter Theory" by Haykin. I found Oppenheim's text to be better for the examples -- even buying the Shaum's Outline for DSP can suffice. Haykin's text is for our coverage of adaptive filter theory.

If you're looking for a good undergraduate text try B.P. Lathi's book "Signal Processing and Linear Systems" -- it's much better and has been used at my University for a number of years now to teach our two undergraduate-level DSP courses.

I am a graduate student at USC and this book I actually used in lieu of the assigned book Digital Signal Processing (by Mitra). I referred to this book mainly because the assigned book hardly had any intuitive explanations and was quite convoluted. Proakis did a much better job in terms of the relationships between the various Fourier Transforms without comprising mathematical rigor. I also have Lyons Understanding Digital Signal Processing which is great for people new to DSP but I felt it lacked some depth in certain areas and did not have sample problems. Overall Proakis does a solid job with this book. I'd recommend it after knowing the material in Lyon's book.

I liked this book.
it presented many ideas and a right pragmatic approach to test a trading system.
I found tough the statistics part, but it's not an author's fault: it's statistics.
in the final part I found many repetition (many pages might be saved just writing: " hey, for this system we apply the same said at pag. xyz..").

Only two things remained a mistery to me (but I'm not much intellingent..): why didn't the author make any test for longer horizons? in the end, the strategies never approached a longer term trading strategy: usually the trades last few days.
maybe it's not worth? the author doesn't tell us

ah, and it's not an encyclopedia: why did he choose this name?
this is the second mistery...

Wow! For the research oriented person, this book is great! Not
only does it go over large variety of different approaches
to the commodities market, but the authors let you know the
pitfalls and traps to various methods of evaluating the markets.
The book is written in a concise manner that allows quick naviagation
and further study of any desired topics. The authors have
documented their sources well and really covered a lot of ground!
A *must* read for traders! *AND* I was interested in
the companion CD, called the number listed on the web site
and got to speak with one of the authors! He was very helpful
and answered all my questions right away! You can't beat
that for service with a book!

This is a good book. Everyone who is thinking about trading and/or is trading already should get a copy of the book. There isn't any "holy grail" strategy in this book, by the way. Rather, this book is about teaching how all these different indicators have performed under strict test conditions and unveils some of the mysteries about different strategies that people have talked about over the years. IMO, the author's work can be the basis of a great system. The first step has already been taken by the author, and you just have to elaborate it to add your flair and style. Happy trading!

This is by far the most complete and advanced work I've read on the subject. However, read Robert Pardo's "Design, Testing, and Optimization of Trading Systems" first if you are new to backtesting.

The Encyclopedia of Trading Strategies is well written and is a good book if you are looking for something very technical and mechanical. I was disappointed with the book. I thought it would offer chart set ups or set ups per technical indicators. Instead, it offered codes, etc for setting up mechanical systems.

This book puts most of my college textbooks to shame. Not that they were bad, but really this is a step above. Sedgewick is a master at distilling difficult concepts into just a few lines of code, and then talking the reader through all of the implications of any design decision. For a professional who needs to reacquaint himself with the basic principles of algorithms, and needs some simple code to get started on coding a solution, this cannot be beat. While I am not in school anymore, I feel this can also be a great supplemental text for any serious Computer Science university student, although it's possible that the focus on C++ implementations may not be ideal for curricula where Java is the mainstay.

One of the factors that I did not see mentioned in other reviews is that Sedgewick's visual representations of the algorithms are phenomenal. In older algorithms textbooks, these have always been represented by small diagrams--if any--that show what happens when an algorithm is used to attack a small problem (say, a linked list with 10 nodes). This text shows a visual representation of those small cases, but then goes the extra mile to show visual representations of the same algorithm when scaled to a variety of massive inputs. These representations are a great tool for comparing the scalability of various algorithmic approaches against one another.

I purchased this book to refresh my memory on data structures with templates. It is well written in most spots and provides excellent examples. I would recommend this book to any intermediate c++ programmer who wishes to learn/relearn advanced data structures such as Linked Lists,Hash,QuickSort,etc....

This book is full of great information on C++ algorithms. There are many excellent examples, and the author presents the gammit as far as topics. They really open up your mind to possibilities. The reading at times is rough going, though (very dry). Sample code or examples to download may be found at the publisher's website instead of the one printed in the book.

If you're looking for an exhaustive, upto-date reference/textbook for
fundamental, searching and sorting algorithms, then this is one of
the very best available.

Sedgewick has split his popular book into two volumes, with Graph
algorithms being hifted to the second volume. Moreover, many advanced
topics like computational geometry, fft, number theoretic algorithms
etc, which were introduced in the previous edition, seem to be missing
now - so the breadth of coverage seems to have reduced, which is a pity.

However, the depth has increased instead - i doubt that even Knuth
covers more sorting algorithms ! In particular, there are several
recent algorithms and data structures which are treated in greater
detail here than by Knuth. Of course, Knuth analyses all the
algorithms he presents in rigorous and exhaustive detail, which
this book doesn't.

Moreover, the book has many new algorithms and presents the state of the
art in sorting and searching algorithms, giving it a distinct advantage
over the older books.

Sedgewick makes it very clear in the preface that the emphasis is on
the practical importance of the algorithms, so esoteric algorithms which
are important 'only in theory' may find no mention. Also the emphasis is
more on the design of algorithms than on their analysis.

The number of (exercise!!) problems has multiplied manifold in this edition
to become more than most competing textbooks. Problems are graded by
difficulty level to help you choose the ones relevant to your needs.

The exposition is clear and authoritative - Prof. Sedgewick is a leading
authority in the field of algorithms and a student of Donald Knuth.
He has a gift for making difficult concepts seem simple, and the great
illustrations in the book go a long way in explaining the behaviour of
the algorithms.

For the practising professional, this is an ideal reference, since it'll
help you select the best algorithm for your task without bogging you
down with heavy mathematics.

The reasearcher, on the other hand, may benefit by gaining unique insights
from a master of the area, while using other books for the detailed
analysis of algorithms, including prehaps Sedgewick's own book on the
analysis of algorithms(with Flajolet).

A caveat - the code may not be 'ready to run'. It's better not to rely
on this book to provide you with usable code - if that is what you want,
perhaps the books by Drozdek/Weiss/Heileman/Rowe might be better choices.

If you want C code rather than C++, then the C version of this book is
a good choice, since the code provided is of 'K & R' class and therefore
a delight to read.

Of course, if you're looking for a language independent coverage,
then 'Introduction to algorithms' by Cormen,Leiserson and Rivest is
possibly the best book which combines rigor with comprehensive coverage
of the most important algorithms. Look out for the newly released
second edition.

And if you want a more rigorous and equally exhaustive coverage of
sorting and searching, go for Knuth vol.3 - still the authoritative
reference, though it may require more hard work on the reader's part.

Otherwise, invest in this and you won't be disappointed.

When you are ready to take the bold step into algorithms, this book is a great second step. I say second step because I think it helps if you read "teach yourself algorithms in 21 days" before this book.

This book deals with a good number of algorithms and does not shy away from reasonable analysis. The book helped a lot when I was having problems with putting a good harsh function together.

The chapter on recursion is also very good too.

In order to write decent code you have to know about this difficult/painful subject and this book takes some of that pain away.