 Shopping Bag ( 0 items )

All (9) from $28.15

New (5) from $46.93

Used (4) from $28.15
More About This Textbook
Overview
Product Details
Related Subjects
Meet the Author
RONALD MAK is a senior scientist at the Research Institute for Advanced Computer Science, located at the NASA Ames Research Center in California. He is currently designing Javabased enterprise software for the next Mars rover mission. He has degrees in the mathematical sciences and in computer science from Stanford University. His two previous books were on compiler writing.
Read an Excerpt
Preface
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 floatingpoint 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 standalone 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 standalone 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, commercialquality 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 email at ron@aproposlogic.com or write to me at
Apropos Logic P.O. Box 20884
San Jose, CA 95160
Table of Contents
Preface.
How to Download the Source Code.
I. WHY GOOD COMPUTATIONS GO BAD.
1. FloatingPoint Numbers Are Not Real!
Roundoff Errors. Error Explosion. Real Numbers versus FloatingPoint 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'sComplement. Whole Numbers versus Integer Numbers. Wrapper Classes. Integer Division and Remainder. Integer Exponentiation.
3. The FloatingPoint Standard.
The FloatingPoint Formats. Denormalized Numbers. Decomposing FloatingPoint Numbers. The FloatingPoint Operations. 60, 6', and NaN. No Exceptions! Another Look at Roundoff Errors. Strict or Nonstrict FloatingPoint Arithmetic. The Machine Epsilon e. Error Analysis.
II. ITERATIVE COMPUTATIONS.
4. Summing Lists of Numbers.
A Summing Mysterythe 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. FixedPoint Iteration. Double Trouble with Multiple Roots. Comparing the RootFinder Algorithms.
6. Interpolation and Approximation.
The Power Form versus the Newton Form. Polynomial Interpolation Functions. Divided Differences. Constructing the Interpolation Function. LeastSquares 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 PredictorCorrector Algorithm. The FourthOrder RungeKutta 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 3D 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 MillerRabin Test. A Combined Primality Tester. Generating Prime Numbers. Prime Number Patterns.
16. Fractals.
FixedPoint 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.
Preface
Preface
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 floatingpoint 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 standalone 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 standalone 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, commercialquality 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 email at
ron@aproposlogic.com
or write to me atApropos Logic
P.O. Box 20884
San Jose, CA 95160