Customer Reviews

Java Number Cruncher: The Java Programmer's Guide to Numerical Computing

5 star:		(8)
4 star:		(2)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

As the author says, last time I looked Java still had the +, -, /, * and % mathematical operators.. though most programmers end up forgetting it lost as they are in the boring, vulgar and repetitive coding of boiler-plate "enterprise" (read "sell sell sell") applications. This book does a very good job of introducing a Java programmer to one of the most fun and interesting powers that Java can offer ... that is playing with numbers and exploring the world of mathematics. Forget (at least for a little while) Servlets, JSP, EJB, and database massaging... and give a look to how you can use your JDK to study functions, solve differential equations, integrals, system of equations, discover prime numbers and admire the beauty of fractals. The treatment of the various subjects is done is sufficient detail to be clear and sound, but without burderdening the reader
with detail and depth best left for more specialized and hard-core texts that the curious reader can explore after this one. Refreshing.

This is not a text book on numerical algorithm: very light mathematics and there lacks something I expected, say, spline, high order differential equations and so on. However I don't complain at all, the reading is very enjoyable. Essential concepts and methods well explained. For those who are not good at math or don't intend to become a mathematician but have to get work done, will find this book a great resource. There is also some fun stuff for you to play with numbers: caculating the Pi, drawing a Mandelbrot and so on. You can find some interactive applets on the authors homepage.

The code written for numerical computing in this book is very beautiful, in an OOP manner, design pattern applied and detailed documented. It never brings you hard time to figure out the parameters and indexes. Reading the code you can understand the algorithm more thoroughly. I found the idea behind the organisation of the code is brilliant. Also a good book to learn good programming.

What's interesting, the author declares there's some intended errors in this book, he wants to see if readers pay any attention. Okay, I haven't read every page of this book and am curious to see what I would find out.

What's awkward, the package offered on his site never got accessed by my Java SDK 1.4.1. I had to pick out the source files and make new packages. The innen structure of this nc.jar appears a bit weird to me. Hope this is not an "intended error".

Anyways, thanks to Mr.Mak for this excellent book.

-Ellen

Most people don't think of Java as being the language for exploring mathematics and numbers, but this book could go a long ways toward convincing you otherwise.

Actually, I'm not a student of serious mathematics, and things like solving differential equations and linear equations are not in my list of fun things. I'll trust others to verify that these topics are covered correctly in the book.

But many of the other topics covered, such as floating point numbers, integers, interpolation and approximation, need to be understood by every Java programmer, even in business applications.

I was very impressed with the clarity and simplicity of these presentations. Mr. Mack has an excellent writing style, and real examples, which made even complex topics understandable. I wish he was around when I was in college, trying to learn some of these things.

If you are simply trying to understand how Java works with numbers of all types (like I was), you will find the book very helpful and worthwhile. In the process, I found out a lot of fun things about numerical computing that I never knew. I also came away convinced that Java can do numbers with good performance and good precision.

If you're looking for a reference on "how to" calculate prime numbers, random numbers, pi, or fractals, this book is also for you, with its many pre-coded solutions. But it doesn't read like a 'reference book', due to the "fun with numbers" style.

I liked it.

This book is an introduction to numerical computing that is both comprehensive and fun. It is not a textbook on numerical methods or numerical analysis, although it shows many key numerical algorithms all coded up in Java. The book examines these algorithms enough that you get a feel for how they work and why they're useful, without formally proving why they work. There are also demonstrations of many of the algorithms with interactive graphical programs. Overall I enjoyed this book a great deal. It is not a beginner's book on Java - you should be a pretty good Java programmer already. Also, you should be at least somewhat mathematically mature for the material past part one. That is, you should have had some Calculus and some Linear Algebra prior to reading the last 3 of the 4 parts of this book. I further describe this book in the context of its table of contents.

Part 1: WHY GOOD COMPUTATIONS GO BAD - Simply copying formulas out of a math or statistics textbook to plug into a program will almost certainly lead to wrong results. The first part of this book covers the pitfalls of basic numerical computation.

Chapter 1 discusses floating-point numbers in general and how they're different from the real numbers of mathematics. Not understanding these differences, such as the occurrence of roundoff errors, and not obeying some basic laws of algebra can lead to computations that go bad.

Chapter 2 looks at the seemingly benign integer types. They don't behave entirely as the whole numbers of mathematics do. Arithmetic operations such as addition, subtraction, and multiplication take place not on a number line, but on a clock face.

Chapter 3 examines how Java implements its floating-point types. The chapter examines the IEEE 754 floating-point standard and shows how well Java meets its provisions.

Part 2: ITERATIVE COMPUTATIONS - Computers are certainly good at looping, and many computations are iterative. But loops are where errors can build up and overwhelm the chance for any meaningful results.

Chapter 4 shows that even seemingly innocuous operations, such as summing a list of numbers, can cause trouble. Examples show how running floating-point sums can gradually lose precision and offer some ways to prevent this from happening.

Chapter 5 is about finding the roots of an algebraic equation, which is another way of saying, "Solve for x." It introduces several iterative algorithms that converge upon solutions: bisection, regula falsi, improved regula falsi, secant, Newton's, and fixed-point. This chapter also discusses how to decide which algorithm is appropriate.

Chapter 6 poses the question, Given a set of points in a plane, can you construct a smooth curve that passes through all the points, or how about a straight line that passes the closest to all the points? This chapter presents algorithms for polynomial interpolation and linear regression.

Chapter 7 tackles some integration problems from freshman calculus, but it solves them numerically. It introduces two basic algorithms, the trapezoidal algorithm and Simpson's algorithm.

Chapter 8 is about solving differential equations numerically. It covers several popular algorithms, Euler's, predictor-corrector, and Runge-Kutta.

Part 3: A MATRIX PACKAGE - This part of the book incrementally develops a practical matrix package. You can then import the classes of this package into any Java application that uses matrices.

Chapter 9 develops the matrix class for the basic operations of addition, subtraction, and multiplication. It also covers subclasses for vectors and square matrices. The chapter's interactive demo uses graphic transformation matrices to animate a three-dimensional wire-frame cube.

Chapter 10 first reviews the manual procedure you learned in high school to solve systems of linear equations. It then introduces LU decomposition to solve linear systems using matrices. An interactive demo creates polynomial regression functions of any order from 1 through 9, which requires solving a system of "normal" equations.

Chapter 11 uses LU decomposition to compute the inverse of a matrix efficiently and reliably. A demo program tests how well you can invert the dreaded Hilbert matrices, which are notoriously difficult to invert accurately. The chapter also computes determinants and condition numbers of matrices, and it compares different algorithms for solving linear systems.

Part 4: THE JOYS OF COMPUTATION - The final part of this book covers its lighter side of numerical computation.

Chapter 12 covers Java's BigNumber and BigDecimal classes, which support "arbitrary precision" arithmetic--subject to memory constraints, you can have numbers with as many digits as you like. This chapter explores how these classes can be useful. You compute a large prime number with more than 3,000 digits, and you write functions that can compute values such as the square root of two and e^x to an arbitrary number of digits of precision.

Mathematicians over the centuries have created formulas for computing the value of pi. Enigmatic Indian mathematician Ramanujan devised several very ingenious ones in the early 20th century. An iterative algorithm supposedly can compute more than 2 billion decimal digits of pi. Chapter 13 uses the big number functions from Chapter 12 to test some of these formulas and algorithms.

Chapter 14 is about random number generation. A well-known algorithm generates uniformly distributed random values. It examine algorithms that generate random normally distributed and exponentially distributed random values. The chapter concludes with a Monte Carlo algorithm that uses random numbers to compute the value of pi.

Mathematicians have mulled over prime numbers since nearly prehistoric times. Chapter 15 explores primality testing and investigates formulas that generate prime numbers, and it looks for patterns in the distribution of prime numbers.

Chapter 16 introduces fractals, which are beautiful and intricate shapes that are recursively defined. There are various algorithms for generating different types of fractals, such as Julia sets and the Mandelbrot set. In fact, Newton's algorithm for finding roots, when applied to the complex plane, can generate a fractal.

I have got hold of this book just recently. This is an excellent book on numerical computing using Java that covers many important aspects in numerical computing. I have been writing numerical methods in Java back in graduate school as well as in my professional career for mission critical programs. I must say this book has addressed many issues that must be taken into account such as machine epsilon, choices of numerical methods for different problems, limitations and precautions in using different data types, etc in Java in which if taken for granted, would produce disastrous results.

Ronald Mak has taken the trouble to explain IEEE floating point standards in a fun and easy-to-understand manner.

Another thing about this book that is worthy of a mention is its great OO programming styles. Codes are also well commented and reader friendly. Overall, it is a great source to learn not just on how to program numerical methods in Java but how to write good OO programs.

The only two bad things I could say about this book is that I should have gotten of this book much earlier and if only Amazon allows a Six Stars rating.

At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.

This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.

The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.

The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.

Numerical computing in JAVA is an often-overlooked topic. So when this book came out, I couldn't wait to find out what it offers.

The first part of the book covers the pitfalls of doing numerical computing in JAVA. Do you know how many numeric data types JAVA have and what are the differences among them? Do you know which JAVA type, float or double, is more precise and which one should be used in your computation? Do you know what is a roundoff error and what operations could lead to such an error? Do you know how JAVA handles integer overflow, whether an overflow exception will be thrown? If there is a "No" to the above questions, you will benefit from reading the first part. The book starts to talk about computational algorithms in second part. The algorithms are between high school and college level. Although I didn't learn mathematics in English and haven't touched it for many years, I was able to understand most of them without much difficulty. The author does a great job in explaining mathematical theories in a clear and non-theoretical way. The graphical illustration helped me a lot at the same time. I also liked the style that all the source codes are presented in the book. Without having to sit in front of a computer, I can relax in a sofa, browse the codes, learn the implementations and highlight whatever inspired me. I had some trouble following part III, matrix, but still got excited when finding that 3-D animation could be done by matrix operations. The funs come back in the last part. The BigDecimal and BigInteger classes get introduced there and I was impressed by the extensive functionality JAVA delivers.

All in all, this book lives up to its title. Without the requirements of a strong methematical background, you'll find this book very informative and educational and essentially broaden your JAVA and programming skills. I realize more and more applications start to use JAVA for numerical programming, especially in the academic society where the web and rich GUI features of JAVA can bring better learning experience to students. One of my personal interests is to see some comparisons between JAVA and other languages in the aspects of numerical computing.

Numerical computing in JAVA is an often-overlooked topic. So when this book came out, I couldn't wait to find out what it offers.

The first part of the book covers the pitfalls of doing numerical computing in JAVA. Do you know how many numeric data types JAVA have and what are the differences among them? Do you know which JAVA type, float or double, is more precise and which one should be used in your computation? Do you know what is a roundoff error and what operations could lead to such an error? Do you know how JAVA handles integer overflow, whether an overflow exception will be thrown? If there is a "No" to the above questions, you will benefit from reading the first part. The book starts to talk about computational algorithms in second part. The algorithms are between high school and college level. Although I didn't learn mathematics in English and haven't touched it for many years, I was able to understand most of them without much difficulty. The author does a great job in explaining mathematical theories in a clear and non-theoretical way. The graphical illustration helped me a lot at the same time. I also liked the style that all the source codes are presented in the book. Without having to sit in front of a computer, I can relax in a sofa, browse the codes, learn the implementations and highlight whatever inspired me. I had some trouble following part III, matrix, but still got excited when finding that 3-D animation could be done by matrix operations. The funs come back in the last part. The BigDecimal and BigInteger classes get introduced there and I was impressed by the extensive functionality JAVA delivers.

All in all, this book lives up to its title. Without the requirements of a strong methematical background, you'll find this book very informative and educational and essentially broaden your JAVA and programming skills. I realize more and more applications start to use JAVA for numerical programming, especially in the academic society where the web and rich GUI features of JAVA can bring better learning experience to students. One of my personal interests is to see some comparisons between JAVA and other languages in the aspects of numerical computing.

I spoke with the author when this book was in the
early concept stages. He saw a need for a book that
would explain how computers actually perform the
calculations for common numerical operations, and
how those operations could go completely awry unless
the underlying implementations are understood.

In reading the book, it's clear that the author's
motivation goes well beyond that simple explanation.
Simply put, he clearly loves this stuff! With an
easy-to-read style, he manages to share his excitement,
and reveal some tricks and surprises along the way.

The interactive, animated examples (which are also
available on the author's website) help readers to
visualize the various algorithms.

I believe that this book is very worthwhile for
anyone who does more than simple arithmetic in Java.
But more than that, it's just plain fun.

The book doesn't teach you Java. It is assumed that you already know Java.
doesn't cover all of Numerical calculus and not all of mathematical proofs but great if you are looking study practical programming with Java.

I recommend this book only if you know Java and have basic numerical knowledge.