Register your product to gain access to bonus material or receive a coupon.
Understand "computer math" and get the numbers you expect, reliably.
In Java Number Cruncher, author Ronald Mak explains how to spot-and how to avoid-the subtle programming miscues that can cause vexing calculation errors in your applications. An authority on mapping pure math to computer math, he explains how to use the often-overlooked computational features of Java, and does so in a clear, non-theoretical style.
Without getting lost in mathematical detail, you'll learn practical numerical algorithms for safely summing numbers, finding roots of equations, interpolation and approximation, numerical integration, solving differential equations, matrix operations, and solving sets of simultaneous equations. You'll also enjoy intriguing topics such as searching for patterns in prime numbers, generating random numbers, computing thousands of digits of pi, and creating intricately beautiful fractal images.
Java Number Cruncher includes:
This book is useful to all Java programmers, especially for those who want to learn about numerical computation, and for developers of scientific, financial, and data analysis applications.
The source code from this book can be found on the author's web site: http://www.apropos-logic.com/nc/.
Preface.
How to Download the Source Code.
I. WHY GOOD COMPUTATIONS GO BAD.
1. Floating-Point Numbers Are Not Real!Roundoff Errors. Error Explosion. Real Numbers versus Floating-Point Numbers. Precision and Accuracy. Disobeying the Laws of Algebra. And What about Those Integers?
2. How Wholesome Are the Integers?The Integer Types and Operations. Signed Magnitude versus Two's-Complement. Whole Numbers versus Integer Numbers. Wrapper Classes. Integer Division and Remainder. Integer Exponentiation.
3. The Floating-Point Standard.The Floating-Point Formats. Denormalized Numbers. Decomposing Floating-Point Numbers. The Floating-Point Operations. 60, 6`, and NaN. No Exceptions! Another Look at Roundoff Errors. Strict or Nonstrict Floating-Point Arithmetic. The Machine Epsilon e. Error Analysis.
II. ITERATIVE COMPUTATIONS.
4. Summing Lists of Numbers.A Summing Mystery-the Magnitude Problem. The Kahan Summation Algorithm. Summing Numbers in a Random Order. Summing Addends with Different Signs. Insightful Computing. Summation Summary.
5. Finding Roots.Analytical versus Computer Solutions. The Functions. The Bisection Algorithm. The Regula Falsi Algorithm. The Improved Regula Falsi Algorithm. The Secant Algorithm. Newton's Algorithm. Fixed-Point Iteration. Double Trouble with Multiple Roots. Comparing the Root-Finder Algorithms.
6. Interpolation and Approximation.The Power Form versus the Newton Form. Polynomial Interpolation Functions. Divided Differences. Constructing the Interpolation Function. Least-Squares Linear Regression. Constructing the Regression Line.
7. Numerical Integration.Back to Basics. The Trapezoidal Algorithm. Simpson's Algorithm.
8. Solving Differential Equations Numerically.Back to Basics. A Differential Equation Class. Euler's Algorithm. A Predictor-Corrector Algorithm. The Fourth-Order Runge-Kutta Algorithm.
III. A MATRIX PACKAGE.
9. Basic Matrix Operations.Matrix. Square Matrix. Identity Matrix. Row Vector. Column Vector. Graphic Transformation Matrices. A Tumbling Cube in 3-D Space.
10. Solving Systems of Linear Equations.The Gaussian Elimination Algorithm. Problems with Gaussian Elimination. Partial Pivoting. Scaling. LU Decomposition. Iterative Improvement. A Class for Solving Systems of Linear Equations. A Program to Test LU Decomposition. Polynomial Regression.
11. Matrix Inversion, Determinants, and Condition Numbers.The Determinant. The Inverse. The Norm and the Condition Number. The Invertible Matrix Class. Hilbert Matrices. Comparing Solution Algorithms.
IV. THE JOYS OF COMPUTATION.
12. Big Numbers.Big Integers. A Very Large Prime Number. Big Integers and Cryptography. Big Decimal Numbers. Big Decimal Functions.
13. Computing p.Estimates of p and Ramanujan's Formulas. Arctangent Formulas That Generate p. Generating Billions of Digits.
14. Generating Random Numbers.Pseudorandom Numbers. Uniformly Distributed Random Numbers. Normally Distributed Random Numbers. Exponentially Distributed Random Numbers. Monte Carlo, Buffon's Needle, and p.
15. Prime Numbers.The Sieve of Eratosthenes and Factoring. Congruences and Modulo Arithmetic. The Lucas Test. The Miller-Rabin Test. A Combined Primality Tester. Generating Prime Numbers. Prime Number Patterns.
16. Fractals.Fixed-Point Iteration and Orbits. Bifurcation and the Real Function f(x) 5 x2 1 c. Julia Sets and the Complex Function f(z) 5 z2 1 c. Newton's Algorithm in the Complex Plane. The Mandelbrot Set.
Index.The last time I looked, the Java programming language still had 1, 2, *, /, and % operators to do operations with numbers. It may be hard to believe today, but programming is not only about Web pages, graphics, enterprise software, database systems, and computer games.
I wrote this book to remind today's programmers, especially Java programmers, that computers really are quite good at numerical computing, affectionately known as "number crunching." In fact, some numerical computing underlies most programs—for example, not too many graphics applications or interactive computer games would get very far without crunching at least a few numbers. Of course, scientific, mathematical, statistical, and financial programs rely heavily on numerical computing.
So it behooves the typical Java programmer, besides knowing the standard API alphabet soup—JFC, RMI, JSP, EJB, JDBC, and so on—to know something about how to do good numerical computing. You'll never know when a roundoff error will bite you, or why that "correct" formula you copied right out of your favorite physics textbook into your program somehow computes the wrong answer.
Another reason I wrote this book is that I'm fascinated by the dichotomies of pure mathematics and computer science. On one hand, you have mathematics, a rigorous, abstract world where it is possible to prove, absolutely, that a computation is correct. On the other hand, you have computers, where computations are, well, they're fast. And yet, mathematicians and computer scientists can work together to devise some very clever ways to enable computers to do mathematics and, in the great majority of cases, to compute the right answer.
This book is an introduction to numerical computing. It is not a textbook on numerical methods or numerical analysis, although it certainly shows how to program many key numerical algorithms in Java. We'll examine these algorithms, enough to get a feel for how they work and why they're useful, without formally proving why they work. Because Java is ideal for doing so, we'll also demonstrate many of the algorithms with interactive, graphical programs. After seeing how we can dodge some of the pitfalls of floating-point and integer computations, we'll explore programs that solve equations for x, do interpolation and integration, solve differential equations and systems of linear equations, and more.
Numerical computing is not all work, either. This book also contains several chapters on lighter (but not necessarily less useful) topics, including computing thousands of digits of π, using different ways to generate random numbers, looking for patterns in the prime numbers, and creating the intricately beautiful fractal images.
I tried hard to keep the math in this book at the freshman calculus level or below—knowledge of high school algebra should be enough for most of it.
All the interactive programs in this book can run either as applets or as stand-alone programs. My friends and I have tested them with the Netscape 4.7 browser running on Windows, Linux, and Solaris, with Microsoft Internet Explorer 6.0 running on the PC, and Microsoft Internet Explorer 5.1 running on the Macintosh. I've tested the stand-alone programs on my Windows 98 PC with JDK 1.2, 1.3, and 1.4. Of course, there's no guarantee they'll all work perfectly for you, but the source code for all the programs, along with instructions on how to compile and run them, are available for downloading.
I wrote all the programs strictly as illustrative examples for this book. You're free to use the source code anyway you like, but bear in mind that this is not fully tested, commercial-quality code. Neither Prentice Hall nor I can be responsible for anything bad that may happen if you use these programs.
Although creating this book was primarily a solitary activity, I must acknowledge the help I got from several longtime good friends. Steve Drach, Bob Nicholson, and Owen Densmore tried out my demo applets to let me know whether they were any good and whether they ran properly in different browsers on various machine platforms (PCs, Macintoshes, and Sun workstations). Steve and I had a couple days of fun seeing how fast I could get my p programs to run.
I give extra special thanks to my technical reviewer, Wes Mitchell, another longtime friend who is currently an enterprise architect extraordinaire and formerly a mathematics and computer science professor. Wes made many suggestions for improving the text and caught some really embarrassing misstatements. (Any remaining errors are intentional—I want to see if you're paying attention.)
My agent from Waterside Productions, Danielle Jatlow, and my editor at Prentice Hall, Paul Petralia, got this project underway and kept it going.
I had a lot of fun writing this book and its programs, and I hope that comes through in the text. If you're inspired to learn more about any of the topics, then I will be very happy. You can send me e-mail at ron@apropos-logic.com
or write to me at
Apropos Logic
P.O. Box 20884
San Jose, CA 95160