Customer Reviews

NUMERICAL RECIPES IN C The Art of Scientific Computing

5 star:		(19)
4 star:		(11)
3 star:		(4)
2 star:		(2)
1 star:		(3)

 

 

I give the book 4 stars to maintain the current level. I own a Fortran copy of NR, but like the other authors, I like NR for the explanations of algorithms, but not for the code.

There is a VERY good alternative to Numerical Recipes in C, namely GNU Scientific Library. You can find the source code and manual from:

http://sources.redhat.com/gsl/

or

http://www.gnu.org/software/gsl

As typical GNU software, GSL is licensed under GNU General Public License, so it is ABSOLUTELY free ! You can download it, modify it, linked it with your own code, without feeling guilty of copyright violation (Not in the case of NR, NR comes with a copyright license to prohibit modification and linking).

GSL is written in C from scratch by its author. The design is modern, much better than NR in C, and also allowed linking with C++ or modern scripting language like Python. Some of the leading authors have background in theoretical physics and astrophysics, just like NR authors.

Check it out. You lose nothing to check GSL first, you may ended up saving some $$$.

I first bought the FORTRAN version of this text in 1994 while doing scientific programming for graduate school work. I've been able to do a lot of basic research quickly with NR codes, and I still occasionally use NR's routines. The authors have certainly done a good job assimilating a lot of material in the NR series. Since other reviewers have done well to highlight the importance and utility of this landmark series, there is no need to repeat those sentiments here. I also agree with earlier reviewers applauding this title more as a survey or reference work and less as a library of source code. However, to this title's detriment, the authors actually consider the NR series to be a proprietary library of source code more valuable than the explanatory text surrounding it (one can in fact download the text on-line from the publisher though it's hardly worth the hassle). This perception is ironic since the authors confess that "the lineage of many programs in common circulation is often unclear," and many details of presentation, ideas, and algorithms are clearly "borrowed" from other excellent (some now out-of-print) numerical methods books or journals.

Unfortunately, much of the source code in the 1993 C edition appears FORTRANish and is not very efficient as far as the C language goes (one would hope that improvements are coming in the new C edition, ISBN 0521574382). However, even the original FORTRAN NR routines occasionally adopted bizarre and/or obviously inefficient programming structures - over time I decided that this was probably done to make these algorithms appear as so not to obviously plagerize other published material.

Many programmers try to get around this by reworking the NR codes. Apparently the authors consider modification of their sometimes inefficient code "derivative works" (even bug fixes) which cannot be legally redistributed or even used on more than one machine at a time without purchasing a new license or book. As a student, NR's legal disclaimers regarding derivative works never bothered me and I was willing to overlook the sometimes unpolished source code insofar as it functioned properly. But as a professional, I now find the lack of fair-use provisions on uncompiled, derivative source way too restrictive to rely on them in good conscience. I have since expanded my numerical methods library to other references supporting true public-domain codes. With an expanded basis of comparison, I regret to say that I am becoming less and less impressed with NR's implementations and explanations. I am finding some of NR's algorithms to be inefficient or unnecessarily approximate, and - on rare occasion - buggy. There have been quite a few bugs uncovered over the years, although the NR web site has done a good job of keeping track of them.

In closing, this book is excellent for students wanting a good reference for quick and dirty types of analyses or scientific computing. Professional programmers, scientists, engineers, specialists or analysts performing research would be well advised to reference this title, but ultimately they will likely need to rely other resources if they require efficient and/or unrestricted (public-domain) source codes for their work.

This is an excellent text, filled with code segments, a few equations, and lots of glorious plain english *words* in which the authors share their practical experience on how to go about getting useful work done. If you've ever wanted to really understand numerical methods, or just want to make an intelligent choice between alternative approaches to a problem, this book is a gold mine.

The code itself, however, is a bit quaint. It does compile, and mostly work, but it's not the sort of thing you'd want to gamble a medical instrument or space flight on. (The code has the look and feel of 30 year old fortran which was rudely translated to C by some hapless grad student.)

Take the time to understand the routines that really matter for your application and reimplement them, with better error checking and/or optimizations to suit your needs. (Very likely the first thing you'll do is a global search to replace the string "float" with "double". That alone will bring the code out of the 70's and up to somehwere in the middle 80's)

Numerical Recipes is the perfect book for a programmer who took the required math classes and has since forgotten much of the material. Here you will encounter brief, theoretical discussions about how to solve common numerical problems, followed by implementations in C, and finished off with a few suggestions for further reading.

I've actually found the explanations about how to solve problems more useful than the code they provide. Their C coding style seems to harken back to FORTRAN days. I've also translated from C to MatLab and IDL in some instances (on one occasion, translating the MatLab routine back to C a few years later!)

Elsewhere on the net, mathematical critiques can be found. If you're trying to solve a critical problem, hunt these down. It bothered me to find vectors referenced from 1 to n as opposed to 0 to n-1, the way I'm used to seeing them in C code.

But, for practical use, this book is difficult to beat. It makes, at the very least, a great starting point, especially for those of us who last took a math class 18 years ago and find the details foggy. Kind of like The Joy of Cooking. A good, basic reference to keep around, but not the final word on gourmet programming.

I had to endure reading this book for 2 long semesters, and I've come to know some parts of it pretty well. I'll try to be short and say that the book is an excellent reference for the practicioner (and for the poor student:) - however, the ill-placed "jokes" have terribly annoyed me and my fellow class mates. Entire pagagraphs in almost every section dedicated to some second-tier humor were not so helpful in solving numerical problems.

The license for the code is just bad and I found it rather pointless, given the cost of the book (for me it's expensive; and I know it's downloadable). The authors should maybe reconsider this at a later stage...

PS: The GNU Scientific Library implements most, if not all, of the NR routines. It might be worth checking out, since it's also in plain C.

This is a very useful book for scientists and engineers, it collects codes for many most-often-encountered numerical problems, and the discussion is lucid, frank and helpful. However, the author adopted a very bad policy: they do not permit users to distribute their code. So suppose you write an application program which uses lots of integrations, linear algebra and differential equation routines, you would naturally like to use the numerical recipe routines for these basic tasks, but if you want to make your code freely available to others, you find you can't, because the numerical recipes routines are copyrighted and the authors forbid you to distribute even part of them with your code(except for a few public domain routines). They suggest you use the Netlib code which is freely available, however, since there is no systematic documentation, it is more difficult to use the netlib code. In any case, what is the point of having this book and its code if you have to use netlib code? this is really a trouble for the readers and users of this book. On the other hand, the authors provided their book online free of charge, but this is of little use--most readers would buy the book anyway, and prefer to have the code free.

There is no question that the book is a valuable resource. It draws on classic references such as Bevington's 'Data Reduction and Error Analysis...' or other good books such as Acton's 'Numerical Methods that Work.' Very nice when you need a quick understanding on how to approach/attack a problem.

I find myself disappointed with the software on the disk you purchase separately. What I was expecting/hoping was ASCII files with the source code so that I wouldn't have to type it in myself from the book; however, it is in Windows DLL format. This is not very useful if you'd like to use the code on different platforms. One puzzling thing is that the Windows disk is about $35, while they offer an on-line download Unix version for $50 ($150 for the multi-user license). I don't understand why there would be differences between the two unless the NR software is not ANSI-C compliant. If this is the case, then I'd consider the software useless.

Recommendation: Buy the book as a reference. Use different software.

Contrary to another review, the source code in ASCII text is available on the CD-ROM, but one needs a Windows platform to unpack it.

I was able to compile the small set of software I tried in MS VC++ 6.0. Its arrays are 1-based, and it uses mostly floats instead of doubles. I saw no comments in the code; I got the impression that helps to sell the book. The code also makes heavy use of preprocessor macros.

Those who want better code should refer to the Guide to Available Mathematical Software (GAMS) at http://gams.nist.gov/ GAMS-referenced software might be higher quality code, but this Numerical Recipes book is very valuable in understanding the algorithms, especially if you do not spend a large part of your professional life engrossed in their details.

This book is much more understandable than the other texts on Numerical Algorithms I have read; it frequently is even enjoyable-- a rarity in such texts.

I have owned several editions of this book since the late 1980s, first in Fortran, then in C. What makes it so valuable is that each algorithm is explained first, then implemented. A C++ man myself, I don't use the clunky C code in the text, but it is useful to see debugged code when you are doing something complicated, even when you are only translating it to another language.

The encyclopedic scope of the book is also welcome. I am always stumbling into an area of numerical analysis that is new to me, trying to get something to work. Time and again I have turned to this book to give me a basic education in some topic (say, optimization of functions) as well as actual code that I can work from. I know of no other source for this kind of information.

The text is well written, in a lively style. I recommend it most highly.

What I didn't like: the license for the source code is very
restrictive. Some things might have been implemented otherwise
(better?, oh well). Arrays use a 1-offset instead of 0 offset
as is the convention in C.

What I did like: the exposition and organization. It may not
provide the best solutions, but the ones provided are good enough
and readable.