Object-Oriented Implementation of Numerical Methods: An Introduction with Java & Smalltalk (The Morgan Kaufmann Series in Software Engineering and Programming) [Hardcover]

Didier H. Besset (Author)

Book Description

ISBN-10: 1558606793 | ISBN-13: 978-1558606791 | Publication Date: November 8, 2000 | Edition: First Edition

Numerical methods naturally lend themselves to an object-oriented approach. Mathematics builds high- level ideas on top of previously described, simpler ones. Once a property is demonstrated for a given concept, it can be applied to any new concept sharing the same premise as the original one, similar to the ideas of reuse and inheritance in object-oriented (OO) methodology.

Few books on numerical methods teach developers much about designing and building good code. Good computing routines are problem-specific. Insight and understanding are what is needed, rather than just recipes and black box routines. Developers need the ability to construct new programs for different applications.

Object-Oriented Implementation of Numerical Methods reveals a complete OO design methodology in a clear and systematic way. Each method is presented in a consistent format, beginning with a short explanation and following with a description of the general OO architecture for the algorithm. Next, the code implementations are discussed and presented along with real-world examples that the author, an experienced software engineer, has used in a variety of commercial applications.

On the enclosed CD-ROM, you'll find files containing tested source code implementations of all the algorithms discussed in the book in both Java and Smalltalk. This includes repository files for VisualAge for Java and VisualAge for Smalltalk under ENVY.

* Reveals the design methodology behind the code, including design patterns where appropriate, rather than just presenting canned solutions.
* Implements all methods side by side in both Java and Smalltalk. This contrast can significantly enhance your understanding of the nature of OO programming languages.
* Provides a step-by-step pathway to new object-oriented techniques for programmers familiar with using procedural languages such as C or Fortran for numerical methods.
* Includes a chapter on data mining, a key application of numerical methods.

Editorial Reviews

Amazon.com Review

Didier Besset's Object-Oriented Implementation of Numerical Methods offers a wide-ranging set of objects for common numerical algorithms. Written for the math-literate Java and Smalltalk programmer, this volume demonstrates that both languages can be used to tackle common numerical calculations with ease.

This title bridges the gap between pure algorithms and object design. By tackling issues like class design, interfaces, and overcoming floating-point rounding errors in both Java and Smalltalk, the code can be used as-is or as a model for your own custom numerical classes.

The range of recipes, or sample numerical classes, all coded in both OOPLs, is rich. For anyone who's taken a few undergraduate math courses (like calculus, linear algebra, or statistics), plenty of the material will be familiar. After presenting some basic algorithm and mathematical principles, the book shows you the code that gets the job done (first in Smalltalk and then in Java). There's no room for demo code that shows how to use all this. The emphasis is on a good cross-section of common numerical calculations. The tour begins with calculus and moves through linear algebra, with plenty of material on matrices. Later sections on statistics cover familiar terms and calculations such as linear regression and calculations useful for establishing correlations between one or more independent variables. Sections on data mining examine the mathematical rules for finding patterns in large amounts of data. (There's also a nifty set of classes for implementing genetic algorithms.) Throughout, you get advice on choosing the right algorithm for the job. (There are class diagrams that map out how this class library is organized.)

Of course, it will help to know some of the underlying math to get the most out of this intelligent and wide-ranging book, but the writing is remarkably clear and the source code is a model of intelligibility, so even readers who are averse to equations will find Object-Oriented Implementation of Numerical Methods readable. In general, any competent Java or Smalltalk programmer will be able to tap into solid mathematical code by reading it, without having to reinvent the proverbial wheel. --Richard Dragan

Topics covered:

• Introduction to numerical methods and objects in Java and Smalltalk
• Numerical precision and rounding errors
• Comparing floating-point numbers
• Functions in Smalltalk and Java
• Evaluating polynomials
• The error, gamma, and beta functions
• Interpolation algorithms (Lagrange, Newton, Neville, Burlirsch-Stoer, and cubic spline interpolations)
• Choosing the right interpolation method
• Iterative algorithms
• Finding the zeroes of functions (the bisection method, Newton's method, roots of polynomials)
• Integration of functions (trapeze integration method and Simpson and Romberg integration algorithms)
• Open integrals
• Choosing the right integration method
• Infinite series
• Continued fractions
• Incomplete gamma and beta functions
• Algorithms for linear algebra
• Vectors and matrices
• Linear equations (backward substitution, Gaussian elimination, LUP decomposition)
• Matrix determinants and inversion
• Eigenvalues and eigenvectors of nonsymmetrical and symmetrical matrices
• Statistical moments
• Histograms
• Probability distributions (normal, gamma, and experimental distributions)
• The F-test
• The t-test
• The chi-squared test
• Least-fit square algorithms
• Optimization algorithms
• Extended Newton algorithms
• Hill-climbing algorithms
• Powell's algorithm
• Simplex algorithm
• The genetic algorithm
• Data mining
• Covariance
• Multidimensional probability distribution
• The Mahalanobis Distance
• Cluster analysis and variance

Review

"There are few books that show how to build programs of any kind. One common theme is compiler building, and there are shelves full of them. There are few others. It's an area, or a void, that needs filling. this book does a great job of showing how to build numerical analysis programs."
—David N. Smith, IBM T J Watson Research Center

See all Editorial Reviews

Product Details

• Hardcover: 766 pages
• Publisher: Morgan Kaufmann; First Edition edition (November 8, 2000)
• Language: English
• ISBN-10: 1558606793
• ISBN-13: 978-1558606791
• Product Dimensions: 9.3 x 7.6 x 1.6 inches
• Shipping Weight: 3.4 pounds
• Average Customer Review: 4.3 out of 5 stars  See all reviews (6 customer reviews)
• Amazon Best Sellers Rank: #1,686,319 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

9 of 10 people found the following review helpful:

5.0 out of 5 stars Excellent book, January 9, 2001

By 

Dr. Ivan Tomek (Nova Scotia, Canada) - See all my reviews

This review is from: Object-Oriented Implementation of Numerical Methods: An Introduction with Java & Smalltalk (The Morgan Kaufmann Series in Software Engineering and Programming) (Hardcover)

The author is clearly very familiar with the theory and practice of numerical computations in OO languages. For me, the main contributions of the book are an expert formulation of some of the basic numerical techniques and concepts in OO terms (a subject rarely approached in the numerous existing books on OO technology), and examples that can be followed to implement other NM techniques and concepts.

The inclusion of very readable Smalltalk and Java source code is very useful.

For use in a course, I would like to see the material complemented by exercises.

9 of 11 people found the following review helpful:

5.0 out of 5 stars Oh man, is this book neat!, December 7, 2000

By 

Lynn B. Hales (Salt Lake City, Utah USA) - See all my reviews
(REAL NAME)   

Amazon Verified Purchase

This review is from: Object-Oriented Implementation of Numerical Methods: An Introduction with Java & Smalltalk (The Morgan Kaufmann Series in Software Engineering and Programming) (Hardcover)

Dr. Besset has written an uncommonly great book where he has given us important tools while teaching object-oriented analysis and design. Having both Smalltalk and Java code included is a gift. As a smalltalker, I greatly appreciate the inclusion of the Smalltalk code. The book is well organized, very readable and provides the basis for individuals to extend the classes provides as well as build applications with the included code. The code also provides solid examples of object-oriented programming style that will aid the newer programmers in developing effective use of both Java and Smalltalk.

10 of 13 people found the following review helpful:

1.0 out of 5 stars Disappointing Introduction to the Implementation of Numerical Methods, August 31, 2005

By 

Leandro Caniglia (Argentina) - See all my reviews
(REAL NAME)   

This review is from: Object-Oriented Implementation of Numerical Methods: An Introduction with Java & Smalltalk (The Morgan Kaufmann Series in Software Engineering and Programming) (Hardcover)

As a mathematically oriented programmer I found no interesting ideas in this book. The content and treatment of the material is a bit too simplistic and, when viewed as an introduction, it looks unattractive.

Also, as a Smalltalk programmer, I was disappointed with the way algorithms are implemented. The author makes no attempt to take advantage of the wonderful expressiveness of the Smalltalk language. Classes and methods have been given awkward names; the source code is not elegant; basic objects such as matrices and polynomials are insufficiently modeled and treated as mere data structures; algorithms are not viewed as objects but as conventional procedures. Because of the flatness of the approach the resulting programming style is ugly when compared to Smalltalk standards. The eloquence and richness of pure object orientation is not achieved or suggested. SUnit tests, which would have fitted perfectly in all chapters, have been ignored everywhere.