Writing Scientific Software: A Guide to Good Style

by Suely Oliveira , David E. Stewart

• ISBN13: 9780521675956
• ISBN10: 0521675952
• Edition: 1st
• Format: Paperback
• Copyright: 2006-09-18
• Publisher: Cambridge University Press

Summary

The core of scientific computing is designing, writing, testing, debugging and modifying numerical software for application to a vast range of areas: from graphics, meteorology and chemistry to engineering, biology and finance. Scientists, engineers and computer scientists need to write good code, for speed, clarity, flexibility and ease of re-use. Oliveira and Stewart's style guide for numerical software points out good practices to follow, and pitfalls to avoid. By following their advice, readers will learn how to write efficient software, and how to test it for bugs, accuracy, and performance. Techniques are explained with a variety of programming languages, and illustrated with two extensive design examples, one in Fortran 90 and one in C++: other examples in C, C++, Fortran 90 and Java are scattered throughout the book. This manual of scientific computing style will be an essential addition to the bookshelf and lab of everyone who writes numerical software.

Table of Contents

Preface	ix
Part I Numerical Software	1	(42)
1 Why numerical software?	3	(5)
1.1 Efficient kernels	4	(1)
1.2 Rapid change	5	(1)
1.3 Large-scale problems	6	(2)
2 Scientific computation and numerical analysis	8	(22)
2.1 The trouble with real numbers	8	(10)
2.2 Fixed-point arithmetic	18	(1)
2.3 Algorithm stability vs. problem stability	19	(4)
2.4 Numerical accuracy and reliability	23	(7)
3 Priorities	30	(6)
3.1 Correctness	30	(2)
3.2 Numerical stability	32	(1)
3.3 Accurate discretization	32	(1)
3.4 Flexibility	33	(2)
3.5 Efficiency: time and memory	35	(1)
4 Famous disasters	36	(3)
4.1 Patriot missiles	36	(1)
4.2 Ariane 5	37	(1)
4.3 Sleipner A oil rig collapse	38	(1)
5 Exercises	39	(4)
Part II Developing Software	43	(104)
6 Basics of computer organization	45	(12)
6.1 Under the hood: what a CPU does	45	(2)
6.2 Calling routines: stacks and registers	47	(4)
6.3 Allocating variables	51	(2)
6.4 Compilers, linkers, and loaders	53	(4)
7 Software design	57	(33)
7.1 Software engineering	57	(1)
7.2 Software life-cycle	57	(2)
7.3 Programming in the large	59	(2)
7.4 Programming in the small	61	(6)
7.5 Programming in the middle	67	(3)
7.6 Interface design	70	(5)
7.7 Top-down and bottom-up development	75	(2)
7.8 Don't hard-wire it unnecessarily!	77	(1)
7.9 Comments	78	(2)
7.10 Documentation	80	(2)
7.11 Cross-language development	82	(5)
7.12 Modularity and all that	87	(3)
8 Data structures	90	(28)
8.1 Package your data!	90	(1)
8.2 Avoid global variables!	91	(1)
8.3 Multidimensional arrays	92	(4)
8.4 Functional representation vs. data structures	96	(1)
8.5 Functions and the "environment problem"	97	(9)
8.6 Some comments on object-oriented scientific software	106	(12)
9 Design for testing and debugging	118	(25)
9.1 Incremental testing	118	(2)
9.2 Localizing bugs	120	(1)
9.3 The mighty "print" statement	120	(2)
9.4 Get the computer to help	122	(7)
9.5 Using debuggers	129	(1)
9.6 Debugging functional representation:'	130	(2)
9.7 Error and exception handling	132	(3)
9.8 Compare and contrast	135	(1)
9.9 Tracking bugs	136	(1)
9.10 Stress testing and performance testing	137	(4)
9.11 Random test data	141	(2)
10 Exercises	143	(4)
Part III Efficiency in Time, Efficiency in Memory	147	(70)
11 Be algorithm aware	149	(7)
11.1 Numerical algorithms	149	(2)
11.2 Discrete algorithms	151	(2)
11.3 Numerical algorithm design techniques	153	(3)
12 Computer architecture and efficiency	156	(31)
12.1 Caches and memory hierarchies	156	(2)
12.2 A tour of the Pentium 4TM architecture	158	(6)
12.3 Virtual memory and paging	164	(1)
12.4 Thrashing	164	(1)
12.5 Designing for memory hierarchies	165	(3)
12.6 Dynamic data structures and memory hierarchies	168	(1)
12.7 Pipelining and loop unrolling	168	(2)
12.8 Basic Linear Algebra Software (BLAS)	170	(8)
12.9 LAPACK	178	(6)
12.10 Cache-oblivious algorithms and data structures	184	(1)
12.11 Indexing vs. pointers for dynamic data structures	185	(2)
13 Global vs. local optimization	187	(8)
13.1 Picking algorithms vs. keyhole optimization	187	(1)
13.2 What optimizing compilers do	188	(3)
13.3 Helping the compiler along	191	(1)
13.4 Practicalities and asymptotic complexity	192	(3)
14 Grabbing memory when you need it	195	(13)
14.1 Dynamic memory allocation	195	(2)
14.2 Giving it back	197	(1)
14.3 Garbage collection	198	(1)
14.4 Life with garbage collection	199	(3)
14.5 Conservative garbage collection	202	(1)
14.6 Doing it yourself	203	(2)
14.7 Memory tips	205	(3)
15 Memory bugs and leaks	208	(9)
15.1 Beware: unallocated memory!	208	(1)
15.2 Beware: overwriting memory!	208	(2)
15.3 Beware: dangling pointers!	210	(4)
15.4 Beware: memory leaks!	214	(1)
15.5 Debugging tools	215	(2)
Part IV Tools	217	(20)
16 Sources of scientific software	219	(4)
16.1 Netlib	220	(1)
16.2 BLAS	220	(1)
16.3 LAPACK	221	(1)
16.4 GAMS	221	(1)
16.5 Other sources	221	(2)
17 Unix tools	223	(14)
17.1 Automated builds: make	223	(3)
17.2 Revision control: RCS, CVS, Subversion and Bitkeeper	226	(2)
17.3 Profiling: prof and gprof	228	(2)
17.4 Text manipulation: grep, sed, awk, etc.	230	(2)
17.5 Other tools	232	(1)
17.6 What about Microsoft Windows?	233	(4)
Part V Design Examples	237	(50)
18 Cubic spline function library	239	(23)
18.1 Creation and destruction	242	(2)
18.2 Output	244	(1)
18.3 Evaluation	244	(3)
18.4 Spline construction	247	(10)
18.5 Periodic splines	257	(3)
18.6 Performance testing	260	(2)
19 Multigrid algorithms	262	(25)
19.1 Discretizing partial differential equations	262	(2)
19.2 Outline of multigrid methods	264	(1)
19.3 Implementation of framework	265	(7)
19.4 Common choices for the framework	272	(1)
19.5 A first test	273	(3)
19.6 The operator interface and its uses	276	(3)
19.7 Dealing with sparse matrices	279	(3)
19.8 A second test	282	(5)
Appendix A Review of vectors and matrices	287	(5)
A.1 Identities and inverses	288	(1)
A.2 Norms and errors	289	(2)
A.3 Errors in solving linear systems	291	(1)
Appendix B Trademarks	292	(1)
References	293	(6)
Index	299