Customer Reviews

C++ and Object-Oriented Numeric Computing for Scientists and Engineers

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

 

 

As promised in the preface, the book consists of three parts. The first introduces the basics of C++ that are comparable to other programming languages, the second part introduces the features that make C++ special (like classes, inheritance, etc.), and the third part contains a substantial application of the concepts introduced before. The distinguishing feature of this book from other C++ books is that it is written for mathematicians, scientists, and engineers interested in computation. That means that attention is paid from the beginning to important issues like representation of double variables and computational performance of C++ compared to other languages, and, particularly in the third part, the very substantive example of iterative methods for matrices in a variety of storage formats is shown. All this does not mean that one has to have background in numerical methods, as the examples themselves are elementary; the book is still first and foremost a book about C++. For students new to programming in a source code language, the first four chapters should give enough advice to get started. But on the other hand, one does not have to start reading at the beginning, I found, if one is already familiar with the basics of Part 1! Programmers experienced in C may want to start right in Part 2, as I have done. That is an important feature of a text that claims to be a reference text as well as an introduction. The snippets of code are very well-presented and have clearly been carefully chosen and debugged, while some passages of the text could have been written more smoothly. In summary, this is the best introduction to C++ for individuals interested in computations, that I am aware of.

This is probably the best C++ book on the market for scientists and engineers. Yang's book rivals, yet complements Barton & Nackmann: whereas B&N provide a good overview of "big picture" design issues (but provide few example problems), Yang provides many useful examples of problems relevant to scientists (natural sciences, not computer science!) and engineers (not computer engineers!), such as linear algebra, polynomial interpolation, numerical integration, and finite differences. The usefulness of Yang's contribution is not so much in providing the numerical methods (which can be found in standard texts), but in providing examples of designs of class hierarchies and object-oriented strategies for solving numerical problems. Yang also provides an excellent discussion of performance issues, and demonstrates a number of strategies (using function objects and/or templates) for making C++ code as efficient as C or Fortran.

The book is concise, yet complete in its coverage of C++, compliant with ISO/ANSI, and includes the latest features such as templates, namespaces, and the STL. I cannot comment on how well the book works as a first book in C++, but it does start at the "beginning", and the author is using it as a textbook in an undergarduate level C++ course. The writing style is clear, making it easy to follow even complex concepts. My only complaint is that the book is biased towards mathematical methods. I would have liked to see examples of object-oriented methods for simulation of physical "objects" and phenomena; similarly, the omission of a discussion of how to best represent "global" physical constants (global variables vs encapsulation in namespaces or classes, etc) was surprising. Bottom line: if you are a scientist or engineer interested in using C++ and OOP in your work, Yang's book is the only book other than Barton & Nackmann worth buying. I hope Yang goes on to write "Numerical Recipes in C++"!

This is a very well-written book on C++. It has less than 500 pages, but contains almost everything a C++ programmer needs to know. It provides a comprephensive coverage, concrete examples, and code snippets -- from C++ basics to its standard libraries, and to many advanced techniques such as deferred evaluation for operator overloading, expression templates, template metaprograms, and replacing certain virtual functions by static polymorphism (for efficiency reasons ). I have not seen these techiques in other C++ books I have read, including the most authoritative ones, where operator overloading and templates are used in straightforward ways. The author even gives a very good explanation on pointers, which I found very usefull in my signal and image processing project, where two and three dimensional arrays have to be dynamically allocated (using double and triple pointers). I strongly recommend this book to any C++ programmer who want intellectual stimulation and a deeper understanding of advanced C++ techniques.

If you are already a c++ expert and only looking for knowledge about numeric computing, this book is not for you because 80% of the book is about c++ rather than numeric computing. However, if you want to learn c++, you picked an excellent one for that matter. The author did a very good job to introduce c++ step by step. Every example is precise and right to the point. There is no garbage but full of useful information. That's why although the book is not big, the contents of the book covers almost all the important c++ features.
While I still believe c++ Primer and The c++ Programming Language are the best c++ book for reference, I would rate this one as the best c++ introduction book.

I used to write C and Fortran code for a living, using (although not necessarily as an expert) numerical methods to solve real-world problems. Like many, I have tried to catch up to C++ and OOPS to see what the fuss is about; like many "practical" people, I've been discouraged by the overhead burden of complexity that C++ introduces relative to C and procedural approaches. I am now using this book to teach myself the basics of C++, and can vouch that it helps the non-specialist who wants to learn a bit about both C++ and numerical methods.

I agree with the reviewers that this book will teach you a lot more about C++ than about numeric computing (although the non-specialist like me will learn something there too.) This book has, to my mind, a number of virtues:

1) It helps a scientist/engineer understand WHY ON EARTH s/he would want to pay the price of additional complexity over C or Fortran for scientific/numeric applications. It does this through showing how such standard applied math tools as vectors, matrices, complex numbers etc can be more cleanly handled in C++, and showcases a number of the language's other key features (e.g. templates).

2) The problems are great...If you don't work the problems, I don't think you can learn much, but I have found nearly every problem instructive... even those that seem "plug and chug". Downloading the code from the website minimizes the tedium.

3) It is reasonably clear, (although could be better.)

4) By the end, you will have some code you can probably use as a base for your own developments...

I have tried to learn C++ from other books, many of which are clearer and more accessible, but this is the only one that has helped me understand why, as an engineer, I should think about working in C++ rather than C.

I agree that the book does not necessarily represent a fully "object oriented approach" to software design, but I'm not quite sure what that means anyway. If you are serious about C++, this will certainly not be the last book you read, but it will help you get up and running to the point where you WANT to know and do more, and you'll have fun writing code that works in the process.

The book is a concise texbook for engineers and it is very good! The organization of the book is good and the language and examples used in the book are terse and easy to understand. It also contains some useful mathematical and numerical applications. However, you may need some other classic C++ novice textbook (like Problem solving with C++, the object of programming by Walter Savitch)in order to get a good understanding in C++.

The book does not contain all the details as in other C++ books for CS major and also doesn't have as much engineering applications as in Rojiani book ("programming in C with numerial methods for engineers"). The book is trying to offer you the minimum but adequate knowledge in C++ so that you can start programming as fast as possible. The format(printing style) of the book could be better to make it more readable however it is better than Deitel's book (C++, how to program).

In general, the book is an excellent book for engineers and novice programmers in engineering major.

As a C++ programmer, familiar to both numeric programming and RAD programming, I must say that this book is the best choice for anyone searching for a clear introduction to C++, OOP focused on numeric programming. Many books lack of numeric examples or OOP concepts, while Yang's book manage to balance them with uncommon sucess. A great book!

The book is an excellent book for one wanting to learn C++ from a numerical computing point of view. Certainly it has to be complemented with a pure C++ reference (Lippman or Stoustrup), yet one of the frustrations of a numerical analyst who wants to use C++ is the lack of significant numerical examples in a pure C++ reference book and the little concern about numerical efficiency. This book fills (partially) the gap.

I must say that there are too few books on C++ and numerical computing, it is a pity.

This book intends to be an easy, concise, but rather complete introduction to the ISO/ANSI C++ language, with applications to object oriented numeric computation for students and professionals in science and engineering. It introduces concepts, techniques, and standard libraries of C++ in a manner that is easy to understand using examples such as vectors, matrices, complex numbers, and integrals, which are familiar and useful to a typical student or professonal in science and engineering.

Besides introducing basic and advanced features of C++, the book contains an introduction and C++ programs for many numeric methods such as polynomial interpolation, numerical integration, direct and iterative algorithms for solving systems of linear equations in real and complex domains, methods for solving nonlinear equations, ordinary and partial differential equations with real and complex coefficients. These methods are fundamental in scientific and engineering computing.

This book gives numerous examples and techniques on how to reduce (C and Fortran style) run-time overhead and improve program efficiency and elegancy. Such techniques include function objects, deferred evaluation for operator overloading, expression templates, template metaprograms, and replacing certain virtual functions by templates. It also introduces tools on how to manage source files, create libraries, and debug and profile programs.

The book can be used as a textbook for students in science and engineering and a reference book for experienced scientific C++ programmers.


--------------------------------------------------------------------------------

C++, What a Programming Language Should Be!

C++'s object oriented and general programming features enable the programmer to write few codes and support an evolving process of code development. For example, One version of C++ program of preconditioned conjugate gradient and GMRES methods can be used for full (storing every entry of a matrix), banded (zero entries outside of a band along the main diagonal are not stored to save memory), and sparse (only non-zero entries of a matrix are stroed to save memory) matrices, and for real and complex single, double, long double precisions. It would require 18 versions in Fortran 77 or Fortan 90. Six versions of C code may do it, but will be much less efficient. If one later decides to add a symmetric (only store lower triangular part of a matrix to save memory) matrix storage format, then 6 more versions of Fortan code (for real, complex, and single, double, long double precisions) need be added. The same C++ program for conjugat gradient and GMRES methods still can handle this situation without any change. C++ code of preconditioned conjugat gradient and GMRES methods are given in Chapter 11 (last chapter) of the book, which work for full, banded, sparse, and other matrices in real and complex domains.

C++ has features (compound assignment operators, templates, function objects, high performance computing library such as valarray) that can be faster than Fortran 77 and C. For example, passing a pointer to a function as an argument to another function can be avoided in many C++ programs by using templates, which can improve the speed of execution by a factor of 2 on many compilers and machines. Running time comparisons with C and Fortran style function passing are done in various places of the book.

C++ provides standard libraries on data structures such as vector, set, list, map, stack, queue, valarray, and on algorithms such as sort() and find(). They come with any standard C++ compiler and can be much more efficient, convenient, and portable than codes written a typical or expert programmer. For example, using these libraries, it is much easier to write finite element programs on unstructured grids and grid generation programs in C++ than in Fortran and C. A disussion of these standard libraries and algorithms are given in various chapters of the book.

C++ programs resemble numerical algorithms more than in Fortran or C. For exmaple, we can write v = v1 + v2 for vector addition and v1 = m*v2 for (sparse, banded, or full) matrix-vector multiplication. The C++ code for the conjugate gradient method (for solving linear systems of algebraic equations) looks very much like the algorithm, which enhances readibility and maintainability. Besides, such operator overloading from built-in types to user-defined types can be done without sacrifice of run-time speed (see Chapter 6 of the book).

The author states in his preface: "This book is intended to be an easy, concise, but rather complete introduction to the ISO/ANSI C++ programming language...". In this respect the book succeeds admirably. This text is excellent as an introductory book on C++ and numeric computing and can be utilized effectively as a course textbook or for self study. Well written, concise, well paced and very clear 5 out of 5 stars.