Press, William H. - Numerical Recipes

SAVE OFFLINE

i i

i “nr3” — 2007/5/1 — 20:53 — page ii — #2

i

This page intentionally left blank

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page i — #1

i

NUMERICAL RECIPES The Art of Scientific Computing

Third Edition

i

i

i i

i

i “nr3” — 2007/5/1 — 20:53 — page ii — #2

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page iii — #3

i

NUMERICAL RECIPES The Art of Scientific Computing

Third Edition

William H. Press Raymer Chair in Computer Sciences and Integrative Biology The University of Texas at Austin

Saul A. Teukolsky Hans A. Bethe Professor of Physics and Astrophysics Cornell University

William T. Vetterling Research Fellow and Director of Image Science ZINK Imaging, LLC

Brian P. Flannery Science, Strategy and Programs Manager Exxon Mobil Corporation

i

i

CAMBRIDGE UNIVERSITY PRESS

Cambridge, New York, Melbourne, Madrid, Cape Town, Singapore, São Paulo Cambridge University Press The Edinburgh Building, Cambridge CB2 8RU, UK Published in the United States of America by Cambridge University Press, New York www.cambridge.org Information on this title: www.cambridge.org/9780521880688 © Cambridge University Press 1988, 1992, 2002, 2007 except for 13.10, which is placed into the public domain, and except for all other computer programs and procedures, which are This publication is in copyright. Subject to statutory exception and to the provision of relevant collective licensing agreements, no reproduction of any part may take place without the written permission of Cambridge University Press. First published in print format 2007 eBook (NetLibrary) ISBN-13 978-0-511-33555-6 ISBN-10 0-511-33555-5 eBook (NetLibrary) ISBN-13 ISBN-10

hardback 978-0-521-88068-8 hardback 0-521-88068-8

Cambridge University Press has no responsibility for the persistence or accuracy of urls for external or third-party internet websites referred to in this publication, and does not guarantee that any content on such websites is, or will remain, accurate or appropriate. Without an additional license to use the contained software, this book is intended as a text and reference book, for reading and study purposes only. However, a restricted, limited free license for use of the software by the individual owner of a copy of this book who personally keyboards one or more routines into a single computer is granted under terms described on p. xix. See the section “License and Legal Information” (pp. xix–xxi) for information on obtaining more general licenses. Machine-readable media containing the software in this book, with included license for use by a single individual, are available from Cambridge University Press. The software may also be downloaded, with immediate purchase of a license also possible, from the Numerical Recipes Software Web site (http: //www.nr.com). Unlicensed transfer of Numerical Recipes programs to any other format, or to any computer except one that is specifically licensed, is strictly prohibited. Technical questions, corrections, and requests for information should be addressed to Numerical Recipes Software, P.O. Box 380243, Cambridge, MA 02238-0243 (USA), email info@nr. com, or fax 781-863-1739.

i

i “nr3” — 2007/5/1 — 20:53 — page v — #5

i

i

Contents

Preface to the Third Edition (2007)

xi

Preface to the Second Edition (1992)

xiv

Preface to the First Edition (1985)

xvii

License and Legal Information

xix

1

2

3

Preliminaries 1.0 Introduction . . . . . . . . . . . . . . . . 1.1 Error, Accuracy, and Stability . . . . . . . 1.2 C Family Syntax . . . . . . . . . . . . . . 1.3 Objects, Classes, and Inheritance . . . . . 1.4 Vector and Matrix Objects . . . . . . . . . 1.5 Some Further Conventions and Capabilities

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

1 1 8 12 17 24 30

Solution of Linear Algebraic Equations 2.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . 2.1 Gauss-Jordan Elimination . . . . . . . . . . . . . . . . 2.2 Gaussian Elimination with Backsubstitution . . . . . . 2.3 LU Decomposition and Its Applications . . . . . . . . 2.4 Tridiagonal and Band-Diagonal Systems of Equations . 2.5 Iterative Improvement of a Solution to Linear Equations 2.6 Singular Value Decomposition . . . . . . . . . . . . . . 2.7 Sparse Linear Systems . . . . . . . . . . . . . . . . . . 2.8 Vandermonde Matrices and Toeplitz Matrices . . . . . . 2.9 Cholesky Decomposition . . . . . . . . . . . . . . . . 2.10 QR Decomposition . . . . . . . . . . . . . . . . . . . 2.11 Is Matrix Inversion an N 3 Process? . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

37 37 41 46 48 56 61 65 75 93 100 102 106

Interpolation and Extrapolation 3.0 Introduction . . . . . . . . . . . . . . . . . . . . 3.1 Preliminaries: Searching an Ordered Table . . . . 3.2 Polynomial Interpolation and Extrapolation . . . . 3.3 Cubic Spline Interpolation . . . . . . . . . . . . . 3.4 Rational Function Interpolation and Extrapolation

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

110 110 114 118 120 124

. . . . .

. . . . .

. . . . .

v i

i

i

i “nr3” — 2007/5/1 — 20:53 — page vi — #6

i

vi

Contents

3.5 3.6 3.7 3.8 4

5

6

i

i

Coefficients of the Interpolating Polynomial . . . . Interpolation on a Grid in Multidimensions . . . . . Interpolation on Scattered Data in Multidimensions Laplace Interpolation . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

129 132 139 150

Integration of Functions 4.0 Introduction . . . . . . . . . . . . . . . . . . . . . 4.1 Classical Formulas for Equally Spaced Abscissas . . 4.2 Elementary Algorithms . . . . . . . . . . . . . . . 4.3 Romberg Integration . . . . . . . . . . . . . . . . . 4.4 Improper Integrals . . . . . . . . . . . . . . . . . . 4.5 Quadrature by Variable Transformation . . . . . . . 4.6 Gaussian Quadratures and Orthogonal Polynomials 4.7 Adaptive Quadrature . . . . . . . . . . . . . . . . . 4.8 Multidimensional Integrals . . . . . . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

155 155 156 162 166 167 172 179 194 196

Evaluation of Functions 5.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Polynomials and Rational Functions . . . . . . . . . . . . . . . 5.2 Evaluation of Continued Fractions . . . . . . . . . . . . . . . . 5.3 Series and Their Convergence . . . . . . . . . . . . . . . . . . 5.4 Recurrence Relations and Clenshaw’s Recurrence Formula . . . 5.5 Complex Arithmetic . . . . . . . . . . . . . . . . . . . . . . . 5.6 Quadratic and Cubic Equations . . . . . . . . . . . . . . . . . 5.7 Numerical Derivatives . . . . . . . . . . . . . . . . . . . . . . 5.8 Chebyshev Approximation . . . . . . . . . . . . . . . . . . . . 5.9 Derivatives or Integrals of a Chebyshev-Approximated Function 5.10 Polynomial Approximation from Chebyshev Coefficients . . . 5.11 Economization of Power Series . . . . . . . . . . . . . . . . . 5.12 Pad´e Approximants . . . . . . . . . . . . . . . . . . . . . . . 5.13 Rational Chebyshev Approximation . . . . . . . . . . . . . . . 5.14 Evaluation of Functions by Path Integration . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

201 201 201 206 209 219 225 227 229 233 240 241 243 245 247 251

Special Functions 6.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Gamma Function, Beta Function, Factorials, Binomial Coefficients 6.2 Incomplete Gamma Function and Error Function . . . . . . . . . . 6.3 Exponential Integrals . . . . . . . . . . . . . . . . . . . . . . . . 6.4 Incomplete Beta Function . . . . . . . . . . . . . . . . . . . . . . 6.5 Bessel Functions of Integer Order . . . . . . . . . . . . . . . . . . 6.6 Bessel Functions of Fractional Order, Airy Functions, Spherical Bessel Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7 Spherical Harmonics . . . . . . . . . . . . . . . . . . . . . . . . . 6.8 Fresnel Integrals, Cosine and Sine Integrals . . . . . . . . . . . . . 6.9 Dawson’s Integral . . . . . . . . . . . . . . . . . . . . . . . . . . 6.10 Generalized Fermi-Dirac Integrals . . . . . . . . . . . . . . . . . . 6.11 Inverse of the Function x log.x/ . . . . . . . . . . . . . . . . . . . 6.12 Elliptic Integrals and Jacobian Elliptic Functions . . . . . . . . . .

255 255 256 259 266 270 274 283 292 297 302 304 307 309

i

i

i “nr3” — 2007/5/1 — 20:53 — page vii — #7

i

i

vii

Contents

6.13 Hypergeometric Functions . . . . . . . . . . . . . . . . . . . . . . 318 6.14 Statistical Functions . . . . . . . . . . . . . . . . . . . . . . . . . 320 7

8

9

Random Numbers 7.0 Introduction . . . . . . . . . . . . . . . . . . 7.1 Uniform Deviates . . . . . . . . . . . . . . . 7.2 Completely Hashing a Large Array . . . . . . 7.3 Deviates from Other Distributions . . . . . . . 7.4 Multivariate Normal Deviates . . . . . . . . . 7.5 Linear Feedback Shift Registers . . . . . . . . 7.6 Hash Tables and Hash Memories . . . . . . . 7.7 Simple Monte Carlo Integration . . . . . . . . 7.8 Quasi- (that is, Sub-) Random Sequences . . . 7.9 Adaptive and Recursive Monte Carlo Methods

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

340 340 341 358 361 378 380 386 397 403 410

Sorting and Selection 8.0 Introduction . . . . . . . . . . . . . . 8.1 Straight Insertion and Shell’s Method . 8.2 Quicksort . . . . . . . . . . . . . . . . 8.3 Heapsort . . . . . . . . . . . . . . . . 8.4 Indexing and Ranking . . . . . . . . . 8.5 Selecting the M th Largest . . . . . . . 8.6 Determination of Equivalence Classes .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

419 419 420 423 426 428 431 439

Root Finding and Nonlinear Sets of Equations 9.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 Bracketing and Bisection . . . . . . . . . . . . . . . . . . . . . . 9.2 Secant Method, False Position Method, and Ridders’ Method . . . 9.3 Van Wijngaarden-Dekker-Brent Method . . . . . . . . . . . . . . 9.4 Newton-Raphson Method Using Derivative . . . . . . . . . . . . . 9.5 Roots of Polynomials . . . . . . . . . . . . . . . . . . . . . . . . 9.6 Newton-Raphson Method for Nonlinear Systems of Equations . . . 9.7 Globally Convergent Methods for Nonlinear Systems of Equations

442 442 445 449 454 456 463 473 477

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

10 Minimization or Maximization of Functions 10.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Initially Bracketing a Minimum . . . . . . . . . . . . . . . . . 10.2 Golden Section Search in One Dimension . . . . . . . . . . . . 10.3 Parabolic Interpolation and Brent’s Method in One Dimension . 10.4 One-Dimensional Search with First Derivatives . . . . . . . . . 10.5 Downhill Simplex Method in Multidimensions . . . . . . . . . 10.6 Line Methods in Multidimensions . . . . . . . . . . . . . . . . 10.7 Direction Set (Powell’s) Methods in Multidimensions . . . . . 10.8 Conjugate Gradient Methods in Multidimensions . . . . . . . . 10.9 Quasi-Newton or Variable Metric Methods in Multidimensions 10.10 Linear Programming: The Simplex Method . . . . . . . . . . . 10.11 Linear Programming: Interior-Point Methods . . . . . . . . . . 10.12 Simulated Annealing Methods . . . . . . . . . . . . . . . . . . 10.13 Dynamic Programming . . . . . . . . . . . . . . . . . . . . .

i

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

487 487 490 492 496 499 502 507 509 515 521 526 537 549 555

i

i

i “nr3” — 2007/5/1 — 20:53 — page viii — #8

i

viii

i

Contents

11 Eigensystems 11.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1 Jacobi Transformations of a Symmetric Matrix . . . . . . . . . . 11.2 Real Symmetric Matrices . . . . . . . . . . . . . . . . . . . . . 11.3 Reduction of a Symmetric Matrix to Tridiagonal Form: Givens and Householder Reductions . . . . . . . . . . . . . . . . . . . 11.4 Eigenvalues and Eigenvectors of a Tridiagonal Matrix . . . . . . 11.5 Hermitian Matrices . . . . . . . . . . . . . . . . . . . . . . . . 11.6 Real Nonsymmetric Matrices . . . . . . . . . . . . . . . . . . . 11.7 The QR Algorithm for Real Hessenberg Matrices . . . . . . . . 11.8 Improving Eigenvalues and/or Finding Eigenvectors by Inverse Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Fast Fourier Transform 12.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1 Fourier Transform of Discretely Sampled Data . . . . . . . . . 12.2 Fast Fourier Transform (FFT) . . . . . . . . . . . . . . . . . . 12.3 FFT of Real Functions . . . . . . . . . . . . . . . . . . . . . . 12.4 Fast Sine and Cosine Transforms . . . . . . . . . . . . . . . . 12.5 FFT in Two or More Dimensions . . . . . . . . . . . . . . . . 12.6 Fourier Transforms of Real Data in Two and Three Dimensions 12.7 External Storage or Memory-Local FFTs . . . . . . . . . . . .

. . . . .

578 583 590 590 596

. 597

. . . . . . . .

600 600 605 608 617 620 627 631 637

. . . . . . .

640 640 641 648 649 652 667 673

. . . . .

681 685 692 699 717

14 Statistical Description of Data 14.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1 Moments of a Distribution: Mean, Variance, Skewness, and So Forth 14.2 Do Two Distributions Have the Same Means or Variances? . . . . . 14.3 Are Two Distributions Different? . . . . . . . . . . . . . . . . . . 14.4 Contingency Table Analysis of Two Distributions . . . . . . . . . 14.5 Linear Correlation . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Nonparametric or Rank Correlation . . . . . . . . . . . . . . . . . 14.7 Information-Theoretic Properties of Distributions . . . . . . . . . . 14.8 Do Two-Dimensional Distributions Differ? . . . . . . . . . . . . .

720 720 721 726 730 741 745 748 754 762

. . . . . . . .

13 Fourier and Spectral Applications 13.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1 Convolution and Deconvolution Using the FFT . . . . . . . . . . 13.2 Correlation and Autocorrelation Using the FFT . . . . . . . . . . 13.3 Optimal (Wiener) Filtering with the FFT . . . . . . . . . . . . . 13.4 Power Spectrum Estimation Using the FFT . . . . . . . . . . . . 13.5 Digital Filtering in the Time Domain . . . . . . . . . . . . . . . 13.6 Linear Prediction and Linear Predictive Coding . . . . . . . . . . 13.7 Power Spectrum Estimation by the Maximum Entropy (All-Poles) Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8 Spectral Analysis of Unevenly Sampled Data . . . . . . . . . . . 13.9 Computing Fourier Integrals Using the FFT . . . . . . . . . . . . 13.10 Wavelet Transforms . . . . . . . . . . . . . . . . . . . . . . . . 13.11 Numerical Use of the Sampling Theorem . . . . . . . . . . . . .

i

563 . 563 . 570 . 576

i

i i

i “nr3” — 2007/5/1 — 20:53 — page ix — #9

i

ix

Contents

14.9 Savitzky-Golay Smoothing Filters . . . . . . . . . . . . . . . . . . 766

i

15 Modeling of Data 15.0 Introduction . . . . . . . . . . . . . . . . . . . . . 15.1 Least Squares as a Maximum Likelihood Estimator . 15.2 Fitting Data to a Straight Line . . . . . . . . . . . . 15.3 Straight-Line Data with Errors in Both Coordinates 15.4 General Linear Least Squares . . . . . . . . . . . . 15.5 Nonlinear Models . . . . . . . . . . . . . . . . . . 15.6 Confidence Limits on Estimated Model Parameters . 15.7 Robust Estimation . . . . . . . . . . . . . . . . . . 15.8 Markov Chain Monte Carlo . . . . . . . . . . . . . 15.9 Gaussian Process Regression . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

773 773 776 780 785 788 799 807 818 824 836

16 Classification and Inference 16.0 Introduction . . . . . . . . . . . . . . . . . . . . 16.1 Gaussian Mixture Models and k-Means Clustering 16.2 Viterbi Decoding . . . . . . . . . . . . . . . . . . 16.3 Markov Models and Hidden Markov Modeling . . 16.4 Hierarchical Clustering by Phylogenetic Trees . . 16.5 Support Vector Machines . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

840 840 842 850 856 868 883

17 Integration of Ordinary Differential Equations 17.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 17.1 Runge-Kutta Method . . . . . . . . . . . . . . . . . . . . 17.2 Adaptive Stepsize Control for Runge-Kutta . . . . . . . . 17.3 Richardson Extrapolation and the Bulirsch-Stoer Method 17.4 Second-Order Conservative Equations . . . . . . . . . . 17.5 Stiff Sets of Equations . . . . . . . . . . . . . . . . . . . 17.6 Multistep, Multivalue, and Predictor-Corrector Methods . 17.7 Stochastic Simulation of Chemical Reaction Networks . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

899 899 907 910 921 928 931 942 946

18 Two-Point Boundary Value Problems 18.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 18.1 The Shooting Method . . . . . . . . . . . . . . . . . . . 18.2 Shooting to a Fitting Point . . . . . . . . . . . . . . . . . 18.3 Relaxation Methods . . . . . . . . . . . . . . . . . . . . 18.4 A Worked Example: Spheroidal Harmonics . . . . . . . . 18.5 Automated Allocation of Mesh Points . . . . . . . . . . . 18.6 Handling Internal Boundary Conditions or Singular Points

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

955 955 959 962 964 971 981 983

19 Integral Equations and Inverse Theory 19.0 Introduction . . . . . . . . . . . . . . . . . . . . . . 19.1 Fredholm Equations of the Second Kind . . . . . . . 19.2 Volterra Equations . . . . . . . . . . . . . . . . . . . 19.3 Integral Equations with Singular Kernels . . . . . . . 19.4 Inverse Problems and the Use of A Priori Information 19.5 Linear Regularization Methods . . . . . . . . . . . . 19.6 Backus-Gilbert Method . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

986 986 989 992 995 1001 1006 1014

. . . . . .

. . . . . . .

. . . . . . .

i

i

i “nr3” — 2007/5/1 — 20:53 — page x — #10

i

x

i

Contents

19.7 Maximum Entropy Image Restoration . . . . . . . . . . . . . . . . 1016 20 Partial Differential Equations 20.0 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 20.1 Flux-Conservative Initial Value Problems . . . . . . . . . . 20.2 Diffusive Initial Value Problems . . . . . . . . . . . . . . . 20.3 Initial Value Problems in Multidimensions . . . . . . . . . 20.4 Fourier and Cyclic Reduction Methods for Boundary Value Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.5 Relaxation Methods for Boundary Value Problems . . . . . 20.6 Multigrid Methods for Boundary Value Problems . . . . . . 20.7 Spectral Methods . . . . . . . . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

1024 1024 1031 1043 1049

. . . .

. . . .

. . . .

. . . .

1053 1059 1066 1083

21 Computational Geometry 21.0 Introduction . . . . . . . . . . . . . . . . . . . . . 21.1 Points and Boxes . . . . . . . . . . . . . . . . . . . 21.2 KD Trees and Nearest-Neighbor Finding . . . . . . 21.3 Triangles in Two and Three Dimensions . . . . . . 21.4 Lines, Line Segments, and Polygons . . . . . . . . 21.5 Spheres and Rotations . . . . . . . . . . . . . . . . 21.6 Triangulation and Delaunay Triangulation . . . . . 21.7 Applications of Delaunay Triangulation . . . . . . . 21.8 Quadtrees and Octrees: Storing Geometrical Objects

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

1097 1097 1099 1101 1111 1117 1128 1131 1141 1149

22 Less-Numerical Algorithms 22.0 Introduction . . . . . . . . . . . . . . . . 22.1 Plotting Simple Graphs . . . . . . . . . . 22.2 Diagnosing Machine Parameters . . . . . . 22.3 Gray Codes . . . . . . . . . . . . . . . . . 22.4 Cyclic Redundancy and Other Checksums 22.5 Huffman Coding and Compression of Data 22.6 Arithmetic Coding . . . . . . . . . . . . . 22.7 Arithmetic at Arbitrary Precision . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

1160 1160 1160 1163 1166 1168 1175 1181 1185

Index

i

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

1195

i

i i

i “nr3” — 2007/5/1 — 20:53 — page xi — #11

i

Preface to the Third Edition (2007) “I was just going to say, when I was interrupted: : :” begins Oliver Wendell Holmes in the second series of his famous essays, The Autocrat of the Breakfast Table. The interruption referred to was a gap of 25 years. In our case, as the autocrats of Numerical Recipes, the gap between our second and third editions has been “only” 15 years. Scientific computing has changed enormously in that time. The first edition of Numerical Recipes was roughly coincident with the first commercial success of the personal computer. The second edition came at about the time that the Internet, as we know it today, was created. Now, as we launch the third edition, the practice of science and engineering, and thus scientific computing, has been profoundly altered by the mature Internet and Web. It is no longer difficult to find somebody’s algorithm, and usually free code, for almost any conceivable scientific application. The critical questions have instead become, “How does it work?” and “Is it any good?” Correspondingly, the second edition of Numerical Recipes has come to be valued more and more for its text explanations, concise mathematical derivations, critical judgments, and advice, and less for its code implementations per se. Recognizing the change, we have expanded and improved the text in many places in this edition and added many completely new sections. We seriously considered leaving the code out entirely, or making it available only on the Web. However, in the end, we decided that without code, it wouldn’t be Numerical Recipes. That is, without code you, the reader, could never know whether our advice was in fact honest, implementable, and practical. Many discussions of algorithms in the literature and on the Web omit crucial details that can only be uncovered by actually coding (our job) or reading compilable code (your job). Also, we needed actual code to teach and illustrate the large number of lessons about object-oriented programming that are implicit and explicit in this edition. Our wholehearted embrace of a style of object-oriented computing for scientific applications should be evident throughout this book. We say “a style,” because, contrary to the claims of various self-appointed experts, there can be no one rigid style of programming that serves all purposes, not even all scientific purposes. Our style is ecumenical. If a simple, global, C-style function will fill the need, then we use it. On the other hand, you will find us building some fairly complicated structures for something as complicated as, e.g., integrating ordinary differential equations. For more on the approach taken in this book, see 1.3 – 1.5. In bringing the text up to date, we have luckily not had to bridge a full 15-year gap. Significant modernizations were incorporated into the second edition versions in Fortran 90 (1996) and C++ (2002), in which, notably, the last vestiges of unitbased arrays were expunged in favor of C-style zero-based indexing. Only with this third edition, however, have we incorporated a substantial amount (several hundred pages!) of completely new material. Highlights include:  a new chapter on classification and inference, including such topics as Gaussian mixture models, hidden Markov modeling, hierarchical clustering (phylogenetic trees), and support vector machines  “Alas, poor Fortran 90! We knew him, Horatio: a programming language of infinite jest, of most excellent fancy: he hath borne us on his back a thousand times.”

xi i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xii — #12

i

xii

i

Preface to the Third Edition

 a new chapter on computational geometry, including topics like KD trees, quad- and octrees, Delaunay triangulation and applications, and many useful algorithms for lines, polygons, triangles, spheres, etc.  many new statistical distributions, with pdfs, cdfs, and inverse cdfs  an expanded treatment of ODEs, emphasizing recent advances, and with completely new routines  much expanded sections on uniform random deviates and on deviates from many other statistical distributions  an introduction to spectral and pseudospectral methods for PDEs  interior point methods for linear programming  more on sparse matrices  interpolation on scattered data in multidimensions  curve interpolation in multidimensions  quadrature by variable transformation and adaptive quadrature  more on Gaussian quadratures and orthogonal polynomials  more on accelerating the convergence of series  improved incomplete gamma and beta functions and new inverse functions  improved spherical harmonics and fast spherical harmonic transforms  generalized Fermi-Dirac integrals  multivariate Gaussian deviates  algorithms and implementations for hash memory functions  incremental quantile estimation  chi-square with small numbers of counts  dynamic programming  hard and soft error correction and Viterbi decoding  eigensystem routines for real, nonsymmetric matrices  multitaper methods for power spectral estimation  wavelets on the interval  information-theoretic properties of distributions  Markov chain Monte Carlo  Gaussian process regression and kriging  stochastic simulation of chemical reaction networks  code for plotting simple graphs from within programs The Numerical Recipes Web site, www.nr.com, is one of the oldest active sites on the Internet, as evidenced by its two-letter domain name. We will continue to make the Web site useful to readers of this edition. Go there to find the latest bug reports, to purchase the machine-readable source code, or to participate in our readers’ forum. With this third edition, we also plan to offer, by subscription, a completely electronic version of Numerical Recipes — accessible via the Web, downloadable, printable, and, unlike any paper version, always up to date with the latest corrections. Since the electronic version does not share the page limits of the print version, it will grow over time by the addition of completely new sections, available only electronically. This, we think, is the future of Numerical Recipes and perhaps of technical reference books generally. If it sounds interesting to you, look at http://www.nr.com/electronic. This edition also incorporates some “user-friendly” typographical and stylistic improvements: Color is used for headings and to highlight executable code. For code, a label in the margin gives the name of the source file in the machine-readable distribution. Instead of printing repetitive #include statements, we provide a con-

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page xiii — #13

Preface to the Third Edition

i

xiii

venient Web tool at http://www.nr.com/dependencies that will generate exactly the statements you need for any combination of routines. Subsections are now numbered and referred to by number. References to journal articles now include, in most cases, the article title, as an aid to easy Web searching. Many references have been updated; but we have kept references to the grand old literature of classical numerical analysis when we think that books and articles deserve to be remembered.

Acknowledgments Regrettably, over 15 years, we were not able to maintain a systematic record of the many dozens of colleagues and readers who have made important suggestions, pointed us to new material, corrected errors, and otherwise improved the Numerical Recipes enterprise. It is a tired clich´e to say that “you know who you are.” Actually, in most cases, we know who you are, and we are grateful. But a list of names would be incomplete, and therefore offensive to those whose contributions are no less important than those listed. We apologize to both groups, those we might have listed and those we might have missed. We prepared this book for publication on Windows and Linux machines, generally with Intel Pentium processors, using LaTeX in the TeTeX and MiKTeX implementations. Packages used include amsmath, amsfonts, txfonts, and graphicx, among others. Our principal development environments were Microsoft Visual Studio / Microsoft Visual C++ and GNU C++. We used the SourceJammer crossplatform source control system. Many tasks were automated with Perl scripts. We could not live without GNU Emacs. To all the developers: “You know who you are,” and we thank you. Research by the authors on computational methods was supported in part by the U.S. National Science Foundation and the U.S. Department of Energy.

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page xiv — #14

i

Preface to the Second Edition (1992) Our aim in writing the original edition of Numerical Recipes was to provide a book that combined general discussion, analytical mathematics, algorithmics, and actual working programs. The success of the first edition puts us now in a difficult, though hardly unenviable, position. We wanted, then and now, to write a book that is informal, fearlessly editorial, unesoteric, and above all useful. There is a danger that, if we are not careful, we might produce a second edition that is weighty, balanced, scholarly, and boring. It is a mixed blessing that we know more now than we did six years ago. Then, we were making educated guesses, based on existing literature and our own research, about which numerical techniques were the most important and robust. Now, we have the benefit of direct feedback from a large reader community. Letters to our alter-ego enterprise, Numerical Recipes Software, are in the thousands per year. (Please, don’t telephone us.) Our post office box has become a magnet for letters pointing out that we have omitted some particular technique, well known to be important in a particular field of science or engineering. We value such letters and digest them carefully, especially when they point us to specific references in the literature. The inevitable result of this input is that this second edition of Numerical Recipes is substantially larger than its predecessor, in fact about 50% larger in both words and number of included programs (the latter now numbering well over 300). “Don’t let the book grow in size,” is the advice that we received from several wise colleagues. We have tried to follow the intended spirit of that advice, even as we violate the letter of it. We have not lengthened, or increased in difficulty, the book’s principal discussions of mainstream topics. Many new topics are presented at this same accessible level. Some topics, both from the earlier edition and new to this one, are now set in smaller type that labels them as being “advanced.” The reader who ignores such advanced sections completely will not, we think, find any lack of continuity in the shorter volume that results. Here are some highlights of the new material in this second edition:  a new chapter on integral equations and inverse methods  a detailed treatment of multigrid methods for solving elliptic partial differential equations  routines for band-diagonal linear systems  improved routines for linear algebra on sparse matrices  Cholesky and QR decomposition  orthogonal polynomials and Gaussian quadratures for arbitrary weight functions  methods for calculating numerical derivatives  Pad´e approximants and rational Chebyshev approximation  Bessel functions, and modified Bessel functions, of fractional order and several other new special functions  improved random number routines  quasi-random sequences  routines for adaptive and recursive Monte Carlo integration in high-dimensional spaces  globally convergent methods for sets of nonlinear equations  simulated annealing minimization for continuous control spaces xiv i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xv — #15

i

Preface to the Second Edition

            

i

xv

fast Fourier transform (FFT) for real data in two and three dimensions fast Fourier transform using external storage improved fast cosine transform routines wavelet transforms Fourier integrals with upper and lower limits spectral analysis on unevenly sampled data Savitzky-Golay smoothing filters fitting straight line data with errors in both coordinates a two-dimensional Kolmogorov-Smirnoff test the statistical bootstrap method embedded Runge-Kutta-Fehlberg methods for differential equations high-order methods for stiff differential equations a new chapter on “less-numerical” algorithms, including Huffman and arithmetic coding, arbitrary precision arithmetic, and several other topics

Consult the Preface to the first edition, following, or the Contents, for a list of the more “basic” subjects treated.

Acknowledgments It is not possible for us to list by name here all the readers who have made useful suggestions; we are grateful for these. In the text, we attempt to give specific attribution for ideas that appear to be original and are not known in the literature. We apologize in advance for any omissions. Some readers and colleagues have been particularly generous in providing us with ideas, comments, suggestions, and programs for this second edition. We especially want to thank George Rybicki, Philip Pinto, Peter Lepage, Robert Lupton, Douglas Eardley, Ramesh Narayan, David Spergel, Alan Oppenheim, Sallie Baliunas, Scott Tremaine, Glennys Farrar, Steven Block, John Peacock, Thomas Loredo, Matthew Choptuik, Gregory Cook, L. Samuel Finn, P. Deuflhard, Harold Lewis, Peter Weinberger, David Syer, Richard Ferch, Steven Ebstein, Bradley Keister, and William Gould. We have been helped by Nancy Lee Snyder’s mastery of a complicated TEX manuscript. We express appreciation to our editors Lauren Cowles and Alan Harvey at Cambridge University Press, and to our production editor Russell Hahn. We remain, of course, grateful to the individuals acknowledged in the Preface to the first edition. Special acknowledgment is due to programming consultant Seth Finkelstein, who wrote, rewrote, or influenced many of the routines in this book, as well as in its Fortran-language twin and the companion Example books. Our project has benefited enormously from Seth’s talent for detecting, and following the trail of, even very slight anomalies (often compiler bugs, but occasionally our errors), and from his good programming sense. To the extent that this edition of Numerical Recipes in C has a more graceful and “C-like” programming style than its predecessor, most of the credit goes to Seth. (Of course, we accept the blame for the Fortranish lapses that still remain.) We prepared this book for publication on DEC and Sun workstations running the UNIX operating system and on a 486/33 PC compatible running MS-DOS 5.0 / Windows 3.0. We enthusiastically recommend the principal software used: GNU Emacs, TEX, Perl, Adobe Illustrator, and PostScript. Also used were a variety of C

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xvi — #16

i

xvi

i

Preface to the Second Edition

compilers — too numerous (and sometimes too buggy) for individual acknowledgment. It is a sobering fact that our standard test suite (exercising all the routines in this book) has uncovered compiler bugs in many of the compilers tried. When possible, we work with developers to see that such bugs get fixed; we encourage interested compiler developers to contact us about such arrangements. WHP and SAT acknowledge the continued support of the U.S. National Science Foundation for their research on computational methods. DARPA support is acknowledged for 13.10 on wavelets.

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page xvii — #17

i

Preface to the First Edition (1985) We call this book Numerical Recipes for several reasons. In one sense, this book is indeed a “cookbook” on numerical computation. However, there is an important distinction between a cookbook and a restaurant menu. The latter presents choices among complete dishes in each of which the individual flavors are blended and disguised. The former — and this book — reveals the individual ingredients and explains how they are prepared and combined. Another purpose of the title is to connote an eclectic mixture of presentational techniques. This book is unique, we think, in offering, for each topic considered, a certain amount of general discussion, a certain amount of analytical mathematics, a certain amount of discussion of algorithmics, and (most important) actual implementations of these ideas in the form of working computer routines. Our task has been to find the right balance among these ingredients for each topic. You will find that for some topics we have tilted quite far to the analytic side; this where we have felt there to be gaps in the “standard” mathematical training. For other topics, where the mathematical prerequisites are universally held, we have tilted toward more indepth discussion of the nature of the computational algorithms, or toward practical questions of implementation. We admit, therefore, to some unevenness in the “level” of this book. About half of it is suitable for an advanced undergraduate course on numerical computation for science or engineering majors. The other half ranges from the level of a graduate course to that of a professional reference. Most cookbooks have, after all, recipes at varying levels of complexity. An attractive feature of this approach, we think, is that the reader can use the book at increasing levels of sophistication as his/her experience grows. Even inexperienced readers should be able to use our most advanced routines as black boxes. Having done so, we hope that these readers will subsequently go back and learn what secrets are inside. If there is a single dominant theme in this book, it is that practical methods of numerical computation can be simultaneously efficient, clever, and — important — clear. The alternative viewpoint, that efficient computational methods must necessarily be so arcane and complex as to be useful only in “black box” form, we firmly reject. Our purpose in this book is thus to open up a large number of computational black boxes to your scrutiny. We want to teach you to take apart these black boxes and to put them back together again, modifying them to suit your specific needs. We assume that you are mathematically literate, i.e., that you have the normal mathematical preparation associated with an undergraduate degree in a physical science, or engineering, or economics, or a quantitative social science. We assume that you know how to program a computer. We do not assume that you have any prior formal knowledge of numerical analysis or numerical methods. The scope of Numerical Recipes is supposed to be “everything up to, but not including, partial differential equations.” We honor this in the breach: First, we do have one introductory chapter on methods for partial differential equations. Second, we obviously cannot include everything else. All the so-called “standard” topics of a numerical analysis course have been included in this book: linear equations, interpolation and extrapolation, integration, nonlinear root finding, eigensystems, and ordinary differential equations. Most of these topics have been taken beyond their xvii i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xviii — #18

i

xviii

i

Preface to the First Edition

standard treatments into some advanced material that we have felt to be particularly important or useful. Some other subjects that we cover in detail are not usually found in the standard numerical analysis texts. These include the evaluation of functions and of particular special functions of higher mathematics; random numbers and Monte Carlo methods; sorting; optimization, including multidimensional methods; Fourier transform methods, including FFT methods and other spectral methods; two chapters on the statistical description and modeling of data; and two-point boundary value problems, both shooting and relaxation methods.

Acknowledgments Many colleagues have been generous in giving us the benefit of their numerical and computational experience, in providing us with programs, in commenting on the manuscript, or with general encouragement. We particularly wish to thank George Rybicki, Douglas Eardley, Philip Marcus, Stuart Shapiro, Paul Horowitz, Bruce Musicus, Irwin Shapiro, Stephen Wolfram, Henry Abarbanel, Larry Smarr, Richard Muller, John Bahcall, and A.G.W. Cameron. We also wish to acknowledge two individuals whom we have never met: Forman Acton, whose 1970 textbook Numerical Methods That Work (New York: Harper and Row) has surely left its stylistic mark on us; and Donald Knuth, both for his series of books on The Art of Computer Programming (Reading, MA: AddisonWesley), and for TEX, the computer typesetting language that immensely aided production of this book. Research by the authors on computational methods was supported in part by the U.S. National Science Foundation.

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page xix — #19

i

License and Legal Information You must read this section if you intend to use the code in this book on a computer. You’ll need to read the following Disclaimer of Warranty, acquire a Numerical Recipes software license, and get the code onto your computer. Without the license, which can be the limited, free “immediate license” under terms described below, this book is intended as a text and reference book, for reading and study purposes only. For purposes of licensing, the electronic version of the Numerical Recipes book is equivalent to the paper version. It is not equivalent to a Numerical Recipes software license, which must still be acquired separately or as part of a combined electronic product. For information on Numerical Recipes electronic products, go to http://www.nr.com/electronic.

Disclaimer of Warranty We make no warranties, express or implied, that the programs contained in this volume are free of error, or are consistent with any particular standard of merchantability, or that they will meet your requirements for any particular application. They should not be relied on for solving a problem whose incorrect solution could result in injury to a person or loss of property. If you do use the programs in such a manner, it is at your own risk. The authors and publisher disclaim all liability for direct or consequential damages resulting from your use of the programs.

The Restricted, Limited Free License We recognize that readers may have an immediate, urgent wish to copy a small amount of code from this book for use in their own applications. If you personally keyboard no more than 10 routines from this book into your computer, then we authorize you (and only you) to use those routines (and only those routines) on that single computer. You are not authorized to transfer or distribute the routines to any other person or computer, nor to have any other person keyboard the programs into a computer on your behalf. We do not want to hear bug reports from you, because experience has shown that virtually all reported bugs in such cases are typing errors! This free license is not a GNU General Public License.

Regular Licenses When you purchase a code subscription or one-time code download from the Numerical Recipes Web site (http://www.nr.com), or when you buy physical Numerical Recipes media published by Cambridge University Press, you automatically get a Numerical Recipes Personal Single-User License. This license lets you personally use Numerical Recipes code on any one computer at a time, but not to allow anyone else access to the code. You may also, under this license, transfer precompiled, executable programs incorporating the code to other, unlicensed, users or computers, providing that (i) your application is noncommercial (i.e., does not involve the selling of your program for a fee); (ii) the programs were first developed, compiled, and successfully run by you; and (iii) our routines are bound into the programs in such a manner that they cannot be accessed as individual routines and cannot practicably be xix i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xx — #20

i

xx

i

License and Legal Information

unbound and used in other programs. That is, under this license, your program user must not be able to use our programs as part of a program library or “mix-and-match” workbench. See the Numerical Recipes Web site for further details. Businesses and organizations that purchase code subscriptions, downloads, or media, and that thus acquire one or more Numerical Recipes Personal Single-User Licenses, may permanently assign those licenses, in the number acquired, to individual employees. In most cases, however, businesses and organizations will instead want to purchase Numerical Recipes licenses “by the seat,” allowing them to be used by a pool of individuals rather than being individually permanently assigned. See http://www.nr.com/licenses for information on such licenses. Instructors at accredited educational institutions who have adopted this book for a course may purchase on behalf of their students one-semester subscriptions to both the electronic version of the Numerical Recipes book and to the Numerical Recipes code. During the subscription term, students may download, view, save, and print all of the book and code. See http://www.nr.com/licenses for further information. Other types of corporate licenses are also available. Please see the Numerical Recipes Web site.

About Copyrights on Computer Programs Like artistic or literary compositions, computer programs are protected by copyright. Generally it is an infringement for you to copy into your computer a program from a copyrighted source. (It is also not a friendly thing to do, since it deprives the program’s author of compensation for his or her creative effort.) Under copyright law, all “derivative works” (modified versions, or translations into another computer language) also come under the same copyright as the original work. Copyright does not protect ideas, but only the expression of those ideas in a particular form. In the case of a computer program, the ideas consist of the program’s methodology and algorithm, including the necessary sequence of steps adopted by the programmer. The expression of those ideas is the program source code (particularly any arbitrary or stylistic choices embodied in it), its derived object code, and any other derivative works. If you analyze the ideas contained in a program, and then express those ideas in your own completely different implementation, then that new program implementation belongs to you. That is what we have done for those programs in this book that are not entirely of our own devising. When programs in this book are said to be “based” on programs published in copyright sources, we mean that the ideas are the same. The expression of these ideas as source code is our own. We believe that no material in this book infringes on an existing copyright.

Trademarks Several registered trademarks appear within the text of this book. Words that are known to be trademarks are shown with an initial capital letter. However, the capitalization of any word is not an expression of the authors’ or publisher’s opinion as to whether or not it is subject to proprietary rights, nor is it to be regarded as affecting the validity of any trademark. Numerical Recipes, NR, and nr.com (when identifying our products) are trademarks of Numerical Recipes Software.

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page xxi — #21

i

License and Legal Information

i

xxi

Attributions The fact that ideas are legally “free as air” in no way supersedes the ethical requirement that ideas be credited to their known originators. When programs in this book are based on known sources, whether copyrighted or in the public domain, published or “handed-down,” we have attempted to give proper attribution. Unfortunately, the lineage of many programs in common circulation is often unclear. We would be grateful to readers for new or corrected information regarding attributions, which we will attempt to incorporate in subsequent printings.

Routines by Chapter and Section Previous editions included a table of all the routines in the book, along with a short description, arranged by chapter and section. This information is now available as an interactive Web page at http://www.nr.com/routines. The following illustration gives the idea.

i

i

i i

i

i “nr3” — 2007/5/1 — 20:53 — page xxii — #22

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 1 — #23

i

CHAPTER

Preliminaries

1

1.0 Introduction This book is supposed to teach you methods of numerical computing that are practical, efficient, and (insofar as possible) elegant. We presume throughout this book that you, the reader, have particular tasks that you want to get done. We view our job as educating you on how to proceed. Occasionally we may try to reroute you briefly onto a particularly beautiful side road; but by and large, we will guide you along main highways that lead to practical destinations. Throughout this book, you will find us fearlessly editorializing, telling you what you should and shouldn’t do. This prescriptive tone results from a conscious decision on our part, and we hope that you will not find it irritating. We do not claim that our advice is infallible! Rather, we are reacting against a tendency, in the textbook literature of computation, to discuss every possible method that has ever been invented, without ever offering a practical judgment on relative merit. We do, therefore, offer you our practical judgments whenever we can. As you gain experience, you will form your own opinion of how reliable our advice is. Be assured that it is not perfect! We presume that you are able to read computer programs in C++. The question, “Why C++?”, is a complicated one. For now, suffice it to say that we wanted a language with a C-like syntax in the small (because that is most universally readable by our audience), which had a rich set of facilities for object-oriented programming (because that is an emphasis of this third edition), and which was highly backwardcompatible with some old, but established and well-tested, tricks in numerical programming. That pretty much led us to C++, although Java (and the closely related C#) were close contenders. Honesty compels us to point out that in the 20-year history of Numerical Recipes, we have never been correct in our predictions about the future of programming languages for scientific programming, not once! At various times we convinced ourselves that the wave of the scientific future would be . . . Fortran . . . Pascal . . . C . . . Fortran 90 (or 95 or 2000) . . . Mathematica . . . Matlab . . . C++ or Java . . . . Indeed, several of these enjoy continuing success and have significant followings (not including Pascal!). None, however, currently command a majority, or even a large plurality, of scientific users. 1 i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 2 — #24

i

2

i

Chapter 1. Preliminaries

With this edition, we are no longer trying to predict the future of programming languages. Rather, we want a serviceable way of communicating ideas about scientific programming. We hope that these ideas transcend the language, C++, in which we are expressing them. When we include programs in the text, they look like this: calendar.h

void flmoon(const Int n, const Int nph, Int &jd, Doub &frac) { Our routines begin with an introductory comment summarizing their purpose and explaining their calling sequence. This routine calculates the phases of the moon. Given an integer n and a code nph for the phase desired (nph D 0 for new moon, 1 for first quarter, 2 for full, 3 for last quarter), the routine returns the Julian Day Number jd, and the fractional part of a day frac to be added to it, of the nth such phase since January, 1900. Greenwich Mean Time is assumed. const Doub RAD=3.141592653589793238/180.0; Int i; Doub am,as,c,t,t2,xtra; c=n+nph/4.0; This is how we comment an individual line. t=c/1236.85; t2=t*t; as=359.2242+29.105356*c; You aren’t really intended to understand am=306.0253+385.816918*c+0.010730*t2; this algorithm, but it does work! jd=2415020+28*n+7*nph; xtra=0.75933+1.53058868*c+((1.178e-4)-(1.55e-7)*t)*t2; if (nph == 0 || nph == 2) xtra += (0.1734-3.93e-4*t)*sin(RAD*as)-0.4068*sin(RAD*am); else if (nph == 1 || nph == 3) xtra += (0.1721-4.0e-4*t)*sin(RAD*as)-0.6280*sin(RAD*am); else throw("nph is unknown in flmoon"); This indicates an error condition. i=Int(xtra >= 0.0 ? floor(xtra) : ceil(xtra-1.0)); jd += i; frac=xtra-i; }

Note our convention of handling all errors and exceptional cases with a statement like throw("some error message");. Since C++ has no built-in exception class for type char*, executing this statement results in a fairly rude program abort. However we will explain in 1.5.1 how to get a more elegant result without having to modify the source code.

1.0.1 What Numerical Recipes Is Not We want to use the platform of this introductory section to emphasize what Numerical Recipes is not: 1. Numerical Recipes is not a textbook on programming, or on best programming practices, or on C++, or on software engineering. We are not opposed to good programming. We try to communicate good programming practices whenever we can — but only incidentally to our main purpose, which is to teach how practical numerical methods actually work. The unity of style and subordination of function to standardization that is necessary in a good programming (or software engineering) textbook is just not what we have in mind for this book. Each section in this book has as its focus a particular computational method. Our goal is to explain and illustrate that method as clearly as possible. No single programming style is best for all such methods, and, accordingly, our style varies from section to section. 2. Numerical Recipes is not a program library. That may surprise you if you are one of the many scientists and engineers who use our source code regularly. What

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 3 — #25

i

1.0 Introduction

i

3

makes our code not a program library is that it demands a greater intellectual commitment from the user than a program library ought to do. If you haven’t read a routine’s accompanying section and gone through the routine line by line to understand how it works, then you use it at great peril! We consider this a feature, not a bug, because our primary purpose is to teach methods, not provide packaged solutions. This book does not include formal exercises, in part because we consider each section’s code to be the exercise: If you can understand each line of the code, then you have probably mastered the section. There are some fine commercial program libraries [1,2] and integrated numerical environments [3-5] available. Comparable free resources are available, both program libraries [6,7] and integrated environments [8-10]. When you want a packaged solution, we recommend that you use one of these. Numerical Recipes is intended as a cookbook for cooks, not a restaurant menu for diners.

1.0.2 Frequently Asked Questions This section is for people who want to jump right in. 1. How do I use NR routines with my own program? The easiest way is to put a bunch of #include’s at the top of your program. Always start with nr3.h, since that defines some necessary utility classes and functions (see 1.4 for a lot more about this). For example, here’s how you compute the mean and variance of the Julian Day numbers of the first 20 full moons after January 1900. (Now there’s a useful pair of quantities!) #include "nr3.h" #include "calendar.h" #include "moment.h" Int main(void) { const Int NTOT=20; Int i,jd,nph=2; Doub frac,ave,vrnce; VecDoub data(NTOT); for (i=0;i 3) b += 1; else b -= 1;

/* questionable! */

As judged by the indentation used on successive lines, the intent of the writer of this code is the following: ‘If b is greater than 3 and a is greater than 3, then increment b. If b is not greater than 3, then decrement b.’ According to the rules, however, the actual meaning is ‘If b is greater than 3, then evaluate a. If a is greater than 3, then increment b, and if a is less than or equal to 3, decrement b.’ The point is that an else clause is associated with the most recent open if statement, no matter how you lay it out on the page. Such confusions in meaning are easily resolved by the inclusion of braces that clarify your intent and improve the program. The above fragment should be written as if (b > 3) { if (a > 3) b += 1; } else { b -= 1; }

While iteration. Alternative to the for iteration is the while structure, for example,

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 15 — #37

1.2 C Family Syntax

i

15

while (n < 1000) { n *= 2; j += 1; }

The control clause (in this case n < 1000) is evaluated before each iteration. If the clause is not true, the enclosed statements will not be executed. In particular, if this code is encountered at a time when n is greater than or equal to 1000, the statements will not even be executed once. Do-While iteration. Companion to the while iteration is a related control structure that tests its control clause at the end of each iteration: do { n *= 2; j += 1; } while (n < 1000);

In this case, the enclosed statements will be executed at least once, independent of the initial value of n. Break and Continue. You use the break statement when you have a loop that is to be repeated indefinitely until some condition tested somewhere in the middle of the loop (and possibly tested in more than one place) becomes true. At that point you wish to exit the loop and proceed with what comes after it. In C family languages the simple break statement terminates execution of the innermost for, while, do, or switch construction and proceeds to the next sequential instruction. A typical usage might be for(;;) { ... if (...) break; ... } ...

(statements before the test) (statements after the test) (next sequential instruction)

Companion to break is continue, which transfers program control to the end of the body of the smallest enclosing for, while, or do statement, but just inside that body’s terminating curly brace. In general, this results in the execution of the next loop test associated with that body.

1.2.3 How Tricky Is Too Tricky? Every programmer is occasionally tempted to write a line or two of code that is so elegantly tricky that all who read it will stand in awe of its author’s intelligence. Poetic justice is that it is usually that same programmer who gets stumped, later on, trying to understand his or her own creation. You might momentarily be proud of yourself at writing the single line k=(2-j)*(1+3*j)/2;

if you want to permute cyclically one of the values j D .0; 1; 2/ into respectively k D .1; 2; 0/. You will regret it later, however. Better, and likely also faster, is

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 16 — #38

i

16

i

Chapter 1. Preliminaries

k=j+1; if (k == 3) k=0;

On the other hand, it can also be a mistake, or at least suboptimal, to be too ploddingly literal, as in switch (j) { case 0: k=1; break; case 1: k=2; break; case 2: k=0; break; default: { cerr 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++;

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 17 — #39

i

1.3 Objects, Classes, and Inheritance

i

17

rounds a positive (or unsigned) 32-bit integer v up to the next power of 2 that is  v. When we use the bit-twiddling hacks, we’ll include an explanatory comment in the code.

1.2.4 Utility Macros or Templated Functions The file nr3.h includes, among other things, definitions for the functions MAX(a,b) MIN(a,b) SWAP(a,b) SIGN(a,b)

These are all self-explanatory, except possibly the last. SIGN(a,b) returns a value with the same magnitude as a and the same sign as b. These functions are all implemented as templated inline functions, so that they can be used for all argument types that make sense semantically. Implementation as macros is also possible. CITED REFERENCES AND FURTHER READING: Harbison, S.P., and Steele, G.L., Jr. 2002, C: A Reference Manual, 5th ed. (Englewood Cliffs, NJ: Prentice-Hall).[1] Anderson, S.E. 2006, “Bit Twiddling Hacks,” at http://graphics.stanford.edu/~seander/ bithacks.html.[2]

1.3 Objects, Classes, and Inheritance An object or class (the terms are interchangeable) is a program structure that groups together some variables, or functions, or both, in such a way that all the included variables or functions “see” each other and can interact intimately, while most of this internal structure is hidden from other program structures and units. Objects make possible object-oriented programming (OOP), which has become recognized as the almost unique successful paradigm for creating complex software. The key insight in OOP is that objects have state and behavior. The state of the object is described by the values stored in its member variables, while the possible behavior is determined by the member functions. We will use objects in other ways as well. The terminology surrounding OOP can be confusing. Objects, classes, and structures pretty much refer to the same thing. Member functions in a class are often referred to as methods belonging to that class. In C++, objects are defined with either the keyword class or the keyword struct. These differ, however, in the details of how rigorously they hide the object’s internals from public view. Specifically, struct SomeName { ...

is defined as being the same as class SomeName { public: ...

In this book we always use struct. This is not because we deprecate the use of public and private access specifiers in OOP, but only because such access control would add little to understanding the underlying numerical methods that are the focus of this book. In fact, access specifiers could impede your understanding, because

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 18 — #40

i

18

i

Chapter 1. Preliminaries

you would be constantly moving things from private to public (and back again) as you program different test cases and want to examine different internal, normally private, variables. Because our classes are declared by struct, not class, use of the word “class” is potentially confusing, and we will usually try to avoid it. So “object” means struct, which is really a class! If you are an OOP beginner, it is important to understand the distinction between defining an object and instantiating it. You define an object by writing code like this: struct Twovar { Doub a,b; Twovar(const Doub aa, const Doub bb) : a(aa), b(bb) {} Doub sum() {return a+b;} Doub diff() {return a-b;} };

This code does not create a Twovar object. It only tells the compiler how to create one when, later in your program, you tell it to do so, for example by a declaration like, Twovar mytwovar(3.,5.);

which invokes the Twovar constructor and creates an instance of (or instantiates) a Twovar. In this example, the constructor also sets the internal variables a and b to 3 and 5, respectively. You can have any number of simultaneously existing, noninteracting, instances: Twovar anothertwovar(4.,6.); Twovar athirdtwovar(7.,8.);

We have already promised you that this book is not a textbook in OOP, or the C++ language; so we will go no farther here. If you need more, good references are [1-4].

1.3.1 Simple Uses of Objects We use objects in various ways, ranging from trivial to quite complex, depending on the needs of the specific numerical method that is being discussed. As mentioned in 1.0, this lack of consistency means that Numerical Recipes is not a useful examplar of a program library (or, in an OOP context, a class library). It also means that, somewhere in this book, you can probably find an example of every possible way to think about objects in numerical computing! (We hope that you will find this a plus.) Object for Grouping Functions. Sometimes an object just collects together a group of closely related functions, not too differently from the way that you might use a namespace. For example, a simplification of Chapter 6’s object Erf looks like: struct Erf { Doub erf(Doub x); Doub erfc(Doub x); Doub inverf(Doub p); Doub inverfc(Doub p); Doub erfccheb(Doub z); };

No constructor needed.

As will be explained in 6.2, the first four methods are the ones intended to be called by the user, giving the error function, complementary error function, and the two

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 19 — #41

i

i

19

1.3 Objects, Classes, and Inheritance

corresponding inverse functions. But these methods share some code and also use common code in the last method, erfccheb, which the user will normally ignore completely. It therefore makes sense to group the whole collection as an Erf object. About the only disadvantage of this is that you must instantiate an Erf object before you can use (say) the erf function: Erf myerf; ... Doub y = myerf.erf(3.);

The name myerf is arbitrary.

Instantiating the object doesn’t actually do anything here, because Erf contains no variables (i.e., has no stored state). It just tells the compiler what local name you are going to use in referring to its member functions. (We would normally use the name erf for the instance of Erf, but we thought that erf.erf(3.) would be confusing in the above example.) Object for Standardizing an Interface. In 6.14 we’ll discuss a number of useful standard probability distributions, for example, normal, Cauchy, binomial, Poisson, etc. Each gets its own object definition, for example, struct Cauchydist { Doub mu, sig; Cauchydist(Doub mmu = 0., Doub ssig = 1.) : mu(mmu), sig(ssig) {} Doub p(Doub x); Doub cdf(Doub x); Doub invcdf(Doub p); };

where the function p returns the probability density, the function cdf returns the cumulative distribution function (cdf), and the function invcdf returns the inverse of the cdf. Because the interface is consistent across all the different probability distributions, you can change which distribution a program is using by changing a single program line, for example from Cauchydist mydist();

to Normaldist mydist();

All subsequent references to functions like mydist.p, mydist.cdf, and so on, are thus changed automatically. This is hardly OOP at all, but it can be very convenient. Object for Returning Multiple Values. It often happens that a function computes more than one useful quantity, but you don’t know which one or ones the user is actually interested in on that particular function call. A convenient use of objects is to save all the potentially useful results and then let the user grab those that are of interest. For example, a simplified version of the Fitab structure in Chapter 15, which fits a straight line y D a C bx to a set of data points xx and yy, looks like this: struct Fitab { Doub a, b; Fitab(const VecDoub &xx, const VecDoub &yy); };

Constructor.

(We’ll discuss VecDoub and related matters below, in 1.4.) The user calculates the fit by calling the constructor with the data points as arguments, Fitab myfit(xx,yy);

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 20 — #42

i

20

i

Chapter 1. Preliminaries

Then the two “answers” a and b are separately available as myfit.a and myfit.b. We will see more elaborate examples throughout the book. Objects That Save Internal State for Multiple Uses. This is classic OOP, worthy of the name. A good example is Chapter 2’s LUdcmp object, which (in abbreviated form) looks like this: struct LUdcmp { Int n; MatDoub lu; LUdcmp(const MatDoub &a); Constructor. void solve(const VecDoub &b, VecDoub &x); void inverse(MatDoub &ainv); Doub det(); };

This object is used to solve linear equations and/or invert a matrix. You use it by creating an instance with your matrix a as the argument in the constructor. The constructor then computes and stores, in the internal matrix lu, a so-called LU decomposition of your matrix (see 2.3). Normally you won’t use the matrix lu directly (though you could if you wanted to). Rather, you now have available the methods solve(), which returns a solution vector x for any right-hand side b, inverse(), which returns the inverse matrix, and det(), which returns the determinant of your matrix. You can call any or all of LUdcmp’s methods in any order; you might well want to call solve multiple times, with different right-hand sides. If you have more than one matrix in your problem, you create a separate instance of LUdcmp for each one, for example, LUdcmp alu(a), aalu(aa);

after which alu.solve() and aalu.solve() are the methods for solving linear equations for each respective matrix, a and aa; alu.det() and aalu.det() return the two determinants; and so forth. We are not finished listing ways to use objects: Several more are discussed in the next few sections.

1.3.2 Scope Rules and Object Destruction This last example, LUdcmp, raises the important issue of how to manage an object’s time and memory usage within your program. For a large matrix, the LUdcmp constructor does a lot of computation. You choose exactly where in your program you want this to occur in the obvious way, by putting the declaration LUdcmp alu(a);

in just that place. The important distinction between a non-OOP language (like C) and an OOP language (like C++) is that, in the latter, declarations are not passive instructions to the compiler, but executable statments at run-time. The LUdcmp constructor also, for a large matrix, grabs a lot of memory, to store the matrix lu. How do you take charge of this? That is, how do you communicate that it should save this state for as long as you might need it for calls to methods like alu.solve(), but not indefinitely?

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 21 — #43

1.3 Objects, Classes, and Inheritance

i

21

The answer lies in C++’s strict and predictable rules about scope. You can start a temporary scope at any point by writing an open bracket, “{”. You end that scope by a matching close bracket, “}”. You can nest scopes in the obvious way. Any objects that are declared within a scope are destroyed (and their memory resources returned) when the end of the scope is reached. An example might look like this: MatDoub a(1000,1000); VecDoub b(1000),x(1000); ... { LUdcmp alu(a); ... alu.solve(b,x); ... } ... Doub d = alu.det();

Create a big matrix, and a couple of vectors. Begin temporary scope. Create object alu. Use alu. End temporary scope. Resources in alu are freed. ERROR! alu is out of scope.

This example presumes that you have some other use for the matrix a later on. If not, then the the declaration of a should itself probably be inside the temporary scope. Be aware that all program blocks delineated by braces are scope units. This includes the main block associated with a function definition and also blocks associated with control structures. In code like this, for (;;) { ... LUdcmp alu(a); ... }

a new instance of alu is created at each iteration and then destroyed at the end of that iteration. This might sometimes be what you intend (if the matrix a changes on each iteration, for example); but you should be careful not to let it happen unintentionally.

1.3.3 Functions and Functors Many routines in this book take functions as input. For example, the quadrature (integration) routines in Chapter 4 take as input the function f .x/ to be integrated. For a simple case like f .x/ D x 2 , you code such a function simply as Doub f(const Doub x) { return x*x; }

and pass f as an argument to the routine. However, it is often useful to use a more general object to communicate the function to the routine. For example, f .x/ may depend on other variables or parameters that need to be communicated from the calling program. Or the computation of f .x/ may be associated with other subcalculations or information from other parts of the program. In non-OOP programing, this communication is usually accomplished with global variables that pass the information “over the head” of the routine that receives the function argument f. C++ provides a better and more elegant solution: function objects or functors. A functor is simply an object in which the operator () has been overloaded to play the role of returning a function value. (There is no relation between this use of the word functor and its different meaning in pure mathematics.) The case f .x/ D x 2 would now be coded as

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 22 — #44

i

22

i

Chapter 1. Preliminaries

struct Square { Doub operator()(const Doub x) { return x*x; } };

To use this with a quadrature or other routine, you declare an instance of Square Square g;

and pass g to the routine. Inside the quadrature routine, an invocation of g(x) returns the function value in the usual way. In the above example, there’s no point in using a functor instead of a plain function. But suppose you have a parameter in the problem, for example, f .x/ D cx p , where c and p are to be communicated from somewhere else in your program. You can set the parameters via a constructor: struct Contimespow { Doub c,p; Contimespow(const Doub cc, const Doub pp) : c(cc), p(pp) {} Doub operator()(const Doub x) { return c*pow(x,p); } };

In the calling program, you might declare the instance of Contimespow by Contimespow h(4.,0.5);

Communicate c and p to the functor.

and later pass h to the routine. Clearly you can make the functor much more complicated. For example, it can contain other helper functions to aid in the calculation of the function value. So should we implement all our routines to accept only functors and not functions? Luckily, we don’t have to decide. We can write the routines so they can accept either a function or a functor. A routine accepting only a function to be integrated from a to b might be declared as Doub someQuadrature(Doub func(const Doub), const Doub a, const Doub b);

To allow it to accept either functions or functors, we instead make it a templated function: template Doub someQuadrature(T &func, const Doub a, const Doub b);

Now the compiler figures out whether you are calling someQuadrature with a function or a functor and generates the appropriate code. If you call the routine in one place in your program with a function and in another with a functor, the compiler will handle that too. We will use this capability to pass functors as arguments in many different places in the book where function arguments are required. There is a tremendous gain in flexibility and ease of use. As a convention, when we write Ftor, we mean a functor like Square or Contimespow above; when we write fbare, we mean a “bare” function like f above; and when we write ftor (all in lower case), we mean an instantiation of a functor, that is, something declared like Ftor ftor(...);

Replace the dots by your parameters, if any.

Of course your names for functors and their instantiations will be different. Slightly more complicated syntax is involved in passing a function to an object

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 23 — #45

1.3 Objects, Classes, and Inheritance

i

23

that is templated to accept either a function or functor. So if the object is template struct SomeStruct { SomeStruct(T &func, ...); constructor ...

we would instantiate it with a functor like this: Ftor ftor; SomeStruct s(ftor, ...

but with a function like this: SomeStruct s(fbare, ...

In this example, fbare takes a single const Doub argument and returns a Doub. You must use the arguments and return type for your specific case, of course.

1.3.4 Inheritance Objects can be defined as deriving from other, already defined, objects. In such inheritance, the “parent” class is called a base class, while the “child” class is called a derived class. A derived class has all the methods and stored state of its base class, plus it can add any new ones. “Is-a” Relationships. The most straightforward use of inheritance is to describe so-called is-a relationships. OOP texts are full of examples where the base class is ZooAnimal and a derived class is Lion. In other words, Lion “is-a” ZooAnimal. The base class has methods common to all ZooAnimals, for example eat() and sleep(), while the derived class extends the base class with additional methods specific to Lion, for example roar() and eat_visitor(). In this book we use is-a inheritance less often than you might expect. Except in some highly stylized situations, like optimized matrix classes (“triangular matrix is-a matrix”), we find that the diversity of tasks in scientific computing does not lend itself to strict is-a hierarchies. There are exceptions, however. For example, in Chapter 7, we define an object Ran with methods for returning uniform random deviates of various types (e.g., Int or Doub). Later in the chapter, we define objects for returning other kinds of random deviates, for example normal or binomial. These are defined as derived classes of Ran, for example, struct Binomialdev : Ran {};

so that they can share the machinery already in Ran. This is a true is-a relationship, because “binomial deviate is-a random deviate.” Another example occurs in Chapter 13, where objects Daub4, Daub4i, and Daubs are all derived from the Wavelet base class. Here Wavelet is an abstract base class or ABC [1,4] that has no content of its own. Rather, it merely specifies interfaces for all the methods that any Wavelet is required to have. The relationship is nevertheless is-a: “Daub4 is-a Wavelet”. “Prerequisite” Relationships. Not for any dogmatic reason, but simply because it is convenient, we frequently use inheritance to pass on to an object a set of methods that it needs as prerequisites. This is especially true when the same set of prerequisites is used by more than one object. In this use of inheritance, the base class has no particular ZooAnimal unity; it may be a grab-bag. There is not a logical is-a relationship between the base and derived classes. An example in Chapter 10 is Bracketmethod, which is a base class for several

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 24 — #46

i

24

i

Chapter 1. Preliminaries

minimization routines, but which simply provides a common method for the initial bracketing of a minimum. In Chapter 7, the Hashtable object provides prerequisite methods to its derived classes Hash and Mhash, but one cannot say, “Mhash is-a Hashtable” in any meaningful way. An extreme example, in Chapter 6, is the base class Gauleg18, which does nothing except provide a bunch of constants for GaussLegendre integration to derived classes Beta and Gamma, both of which need them. Similarly, long lists of constants are provided to the routines StepperDopr853 and StepperRoss in Chapter 17 by base classes to avoid cluttering the coding of the algorithms. Partial Abstraction. Inheritance can be used in more complicated or situationspecific ways. For example, consider Chapter 4, where elementary quadrature rules such as Trapzd and Midpnt are used as building blocks to construct more elaborate quadrature algorithms. The key feature these simple rules share is a mechanism for adding more points to an existing approximation to an integral to get the “next” stage of refinement. This suggests deriving these objects from an abstract base clase called Quadrature, which specifies that all objects derived from it must have a next() method. This is not a complete specification of a common is-a interface; it abstracts only one feature that turns out to be useful. For example, in 4.6, the Stiel object invokes, in different situations, two different quadrature objects, Trapzd and DErule. These are not interchangeable. They have different constructor arguments and could not easily both be made ZooAnimals (as it were). Stiel of course knows about their differences. However, one of Stiel’s methods, quad(), doesn’t (and shouldn’t) know about these differences. It uses only the method next(), which exists, with different definitions, in both Trapzd and DErule. While there are several different ways to deal with situations like this, an easy one is available once Trapzd and DErule have been given a common abstract base class Quadrature that contains nothing except a virtual interface to next. In a case like this, the base class is a minor design feature as far as the implementation of Stiel is concerned, almost an afterthought, rather than being the apex of a top-down design. As long as the usage is clear, there is nothing wrong with this. Chapter 17, which discusses ordinary differential equations, has some even more complicated examples that combine inheritance and templating. We defer further discussion to there. CITED REFERENCES AND FURTHER READING: Stroustrup, B. 1997, The C++ Programming Language, 3rd ed. (Reading, MA: AddisonWesley).[1] Lippman, S.B., Lajoie, J., and Moo, B.E. 2005, C++ Primer, 4th ed. (Boston: Addison-Wesley).[2] Keogh, J., and Giannini, M. 2004, OOP Demystified (Emeryville, CA: McGraw-Hill/Osborne).[3] Cline, M., Lomow, G., and Girou, M. 1999, C++ FAQs, 2nd ed. (Boston: Addison-Wesley).[4]

1.4 Vector and Matrix Objects The C++ Standard Library [1] includes a perfectly good vector template class. About the only criticism that one can make of it is that it is so feature-rich

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 25 — #47

i

1.4 Vector and Matrix Objects

i

25

that some compiler vendors neglect to squeeze the last little bit of performance out of its most elementary operations, for example returning an element by its subscript. That performance is extremely important in scientific applications; its occasional absence in C++ compilers is a main reason that many scientists still (as we write) program in C, or even in Fortran! Also included in the C++ Standard Library is the class valarray. At one time, this was supposed to be a vector-like class that was optimized for numerical computation, including some features associated with matrices and multidimensional arrays. However, as reported by one participant, The valarray classes were not designed very well. In fact, nobody tried to determine whether the final specification worked. This happened because nobody felt “responsible” for these classes. The people who introduced valarrays to the C++ standard library left the committee a long time before the standard was finished. [1]

The result of this history is that C++, at least now, has a good (but not always reliably optimized) class for vectors and no dependable class at all for matrices or higher-dimensional arrays. What to do? We will adopt a strategy that emphasizes flexibility and assumes only a minimal set of properties for vectors and matrices. We will then provide our own, basic, classes for vectors and matrices. For most compilers, these are at least as efficient as vector and other vector and matrix classes in common use. But if, for you, they’re not, then it is easy to change to a different set of classes, as we will explain.

1.4.1 Typedefs Flexibility is achieved by having several layers of typedef type-indirection, resolved at compile time so that there is no run-time performance penalty. The first level of type-indirection, not just for vectors and matrices but for virtually all variables, is that we use user-defined type names instead of C++ fundamental types. These are defined in nr3.h. If you ever encounter a compiler with peculiar builtin types, these definitions are the “hook” for making any necessary changes. The complete list of such definitions is NR Type

Usual Definition

Intent

Char Uchar Int Uint Llong Ullong Doub Ldoub Complex Bool

char unsigned char int unsigned int long long int unsigned long long int double long double complex bool

8-bit signed integer 8-bit unsigned integer 32-bit signed integer 32-bit unsigned integer 64-bit signed integer 64-bit unsigned integer 64-bit floating point [reserved for future use] 2  64-bit floating complex true or false

An example of when you might need to change the typedefs in nr3.h is if your compiler’s int is not 32 bits, or if it doesn’t recognize the type long long int.

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 26 — #48

i

26

i

Chapter 1. Preliminaries

You might need to substitute vendor-specific types like (in the case of Microsoft) __int32 and __int64. The second level of type-indirection returns us to the discussion of vectors and matrices. The vector and matrix types that appear in Numerical Recipes source code are as follows. Vectors: VecInt, VecUint, VecChar, VecUchar, VecCharp, VecLlong, VecUllong, VecDoub, VecDoubp, VecComplex, and VecBool. Matrices: MatInt, MatUint, MatChar, MatUchar, MatLlong, MatUllong, MatDoub, MatComplex, and MatBool. These should all be understandable, semantically, as vectors and matrices whose elements are the corresponding user-defined types, above. Those ending in a “p” have elements that are pointers, e.g., VecCharp is a vector of pointers to char, that is, char*. If you are wondering why the above list is not combinatorially complete, it is because we don’t happen to use all possible combinations of Vec, Mat, fundamental type, and pointer in this book. You can add further analogous types as you need them. Wait, there’s more! For every vector and matrix type above, we also define types with the same names plus one of the suffixes “_I”, “_O”, and “_IO”, for example VecDoub_IO. We use these suffixed types for specifying argument types in function definitions. The meaning, respectively, is that the argument is “input”, “output”, or “both input and output”. The _I types are automatically defined to be const. We discuss this further in 1.5.2 under the topic of const correctness. It may seem capricious for us to define such a long list of types when a much smaller number of templated types would do. The rationale is flexibility: You have a hook into redefining each and every one of the types individually, according to your needs for program efficiency, local coding standards, const-correctness, or whatever. In fact, in nr3.h, all these types are typedef’d to one vector and one matrix class, along the following lines: typedef typedef ... typedef typedef ... typedef typedef ... typedef typedef ...

NRvector VecInt, VecInt_O, VecInt_IO; const NRvector VecInt_I; NRvector VecDoub, VecDoub_O, VecDoub_IO; const NRvector VecDoub_I; NRmatrix MatInt, MatInt_O, MatInt_IO; const NRmatrix MatInt_I; NRmatrix MatDoub, MatDoub_O, MatDoub_IO; const NRmatrix MatDoub_I;

So (flexibility, again) you can change the definition of one particular type, like VecDoub, or else you can change the implementation of all vectors by changing the definition of NRvector. Or, you can just leave things the way we have them in nr3.h. That ought to work fine in 99.9% of all applications.

1.4.2 Required Methods for Vector and Matrix Classes The important thing about the vector and matrix classes is not what names they are typedef’d to, but what methods are assumed for them (and are provided in the NRvector and NRmatrix template classes). For vectors, the assumed methods are a  This

i

is a bit of history, and derives from Fortran 90’s very useful INTENT attributes.

i

i

i “nr3” — 2007/5/1 — 20:53 — page 27 — #49

i

1.4 Vector and Matrix Objects

i

27

subset of those in the C++ Standard Library vector class. If v is a vector of type NRvector, then we assume the methods: v() v(Int n) v(Int n, const T &a) v(Int n, const T *a) v(const NRvector &rhs) v.size() v.resize(Int newn) v.assign(Int newn, const T &a) v[Int i] v = rhs typedef T value_type;

Constructor, zero-length vector. Constructor, vector of length n. Constructor, initialize all elements to the value a. Constructor, initialize elements to values in a C-style array, a[0], a[1], : : : Copy constructor. Returns number of elements in v. Resizes v to size newn. We do not assume that contents are preserved. Resize v to size newn, and set all elements to the value a. Element of v by subscript, either an l-value and an r-value. Assignment operator. Resizes v if necessary and makes it a copy of the vector rhs. Makes T available externally (useful in templated functions or classes).

As we will discuss later in more detail, you can use any vector class you like with Numerical Recipes, as long as it provides the above basic functionality. For example, a brute force way to use the C++ Standard Library vector class instead of NRvector is by the preprocessor directive #define NRvector vector

(In fact, there is a compiler switch, _USESTDVECTOR_, in the file nr3.h that will do just this.) The methods for matrices are closely analogous. If vv is a matrix of type NRmatrix, then we assume the methods: vv() vv(Int n, Int m) vv(Int n, Int m, const T &a) vv(Int n, Int m, const T *a) vv(const NRmatrix &rhs) vv.nrows() vv.ncols() vv.resize(Int newn, Int newm) vv.assign(Int newn, Int newm, const t &a) vv[Int i] v[Int i][Int j] vv = rhs typedef T value_type;

Constructor, zero-length vector. Constructor, n  m matrix. Constructor, initialize all elements to the value a. Constructor, initialize elements by rows to the values in a C-style array. Copy constructor. Returns number of rows n. Returns number of columns m. Resizes vv to newnnewm. We do not assume that contents are preserved. Resizes vv to newn  newm, and sets all elements to the value a. Return a pointer to the first element in row i (not often used by itself). Element of vv by subscript, either an l-value and an r-value. Assignment operator. Resizes vv if necessary and makes it a copy of the matrix rhs. Makes T available externally.

For more precise specifications, see 1.4.3. There is one additional property that we assume of the vector and matrix classes, namely that all of an object’s elements are stored in sequential order. For a vector, this means that its elements can be addressed by pointer arithmetic relative to the first element. For example, if we have

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 28 — #50

i

28

i

Chapter 1. Preliminaries

VecDoub a(100); Doub *b = &a[0];

then a[i] and b[i] reference the same element, both as an l-value and as an rvalue. This capability is sometimes important for inner-loop efficiency, and it is also useful for interfacing with legacy code that can handle Doub* arrays, but not VecDoub vectors. Although the original C++ Standard Library did not guarantee this behavior, all known implementations of it do so, and the behavior is now required by an amendment to the standard [2]. For matrices, we analogously assume that storage is by rows within a single sequential block so that, for example, Int n=97, m=103; MatDoub a(n,m); Doub *b = &a[0][0];

implies that a[i][j] and b[m*i+j] are equivalent. A few of our routines need the capability of taking as an argument either a vector or else one row of a matrix. For simplicity, we usually code this using overloading, as, e.g., void someroutine(Doub *v, Int m) { ... } inline void someroutine(VecDoub &v) { someroutine(&v[0],v.size()); }

Version for a matrix row. Version for a vector.

For a vector v, a call looks like someroutine(v), while for row i of a matrix vv it is someroutine(&vv[i][0],vv.ncols()). While the simpler argument vv[i] would in fact work in our implementation of NRmatrix, it might not work in some other matrix class that guarantees sequential storage but has the return type for a single subscript different from T*.

1.4.3 Implementations in nr3.h For reference, here is a complete declaration of NRvector. template class NRvector { private: int nn; Size of array, indices 0..nn-1. T *v; Pointer to data array. public: NRvector(); Default constructor. explicit NRvector(int n); Construct vector of size n. NRvector(int n, const T &a); Initialize to constant value a. NRvector(int n, const T *a); Initialize to values in C-style array a. NRvector(const NRvector &rhs); Copy constructor. NRvector & operator=(const NRvector &rhs); Assignment operator. typedef T value_type; Make T available. inline T & operator[](const int i); Return element number i. inline const T & operator[](const int i) const; const version. inline int size() const; Return size of vector. void resize(int newn); Resize, losing contents. void assign(int newn, const T &a); Resize and assign a to every element. ~NRvector(); Destructor. };

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 29 — #51

1.4 Vector and Matrix Objects

i

29

The implementations are straightforward and can be found in the file nr3.h. The only issues requiring finesse are the consistent treatment of zero-length vectors and the avoidance of unnecessary resize operations. A complete declaration of NRmatrix is template class NRmatrix { private: int nn; Number of rows and columns. Index int mm; range is 0..nn-1, 0..mm-1. T **v; Storage for data. public: NRmatrix(); Default constructor. NRmatrix(int n, int m); Construct n  m matrix. NRmatrix(int n, int m, const T &a); Initialize to constant value a. NRmatrix(int n, int m, const T *a); Initialize to values in C-style array a. NRmatrix(const NRmatrix &rhs); Copy constructor. NRmatrix & operator=(const NRmatrix &rhs); Assignment operator. typedef T value_type; Make T available. inline T* operator[](const int i); Subscripting: pointer to row i. inline const T* operator[](const int i) const; const version. inline int nrows() const; Return number of rows. inline int ncols() const; Return number of columns. void resize(int newn, int newm); Resize, losing contents. void assign(int newn, int newm, const T &a); Resize and assign a to every element. ~NRmatrix(); Destructor. };

A couple of implementation details in NRmatrix are worth commenting on. The private variable **v points not to the data but rather to an array of pointers to the data rows. Memory allocation of this array is separate from the allocation of space for the actual data. The data space is allocated as a single block, not separately for each row. For matrices of zero size, we have to account for the separate possibilities that there are zero rows, or that there are a finite number of rows, but each with zero columns. So, for example, one of the constructors looks like this: template NRmatrix::NRmatrix(int n, int m) : nn(n), mm(m), v(n>0 ? new T*[n] : NULL) { int i,nel=m*n; if (v) v[0] = nel>0 ? new T[nel] : NULL; for (i=1;ival[count]=... count++; }

This data structure is good for an algorithm that primarily works with columns of the matrix, but it is not very efficient when one needs to loop over all elements of the matrix. A good general storage scheme is the compressed column storage format. It is sometimes called the Harwell-Boeing format, after the two large organizations that first systematically provided a standard collection of sparse matrices for research purposes. In this scheme, three vectors are used: val for the nonzero values as they are traversed column by column, row_ind for the corresponding row indices of each value, and col_ptr for the locations in the other two arrays that start a column. In other words, if val[k]=a[i][j], then row_ind[k]=i. The first nonzero in column j is at col_ptr[j]. The last is at col_ptr[j+1]-1. Note that col_ptr[0] is always 0, and by convention we define col_ptr[n] equal to the number of nonzeros. Note also that the dimension of the col_ptr array is N C 1, not N . The advantage of this scheme is that it requires storage of only about two times the number of nonzero matrix elements. (Other methods can require as much as three or five times.) As an example, consider the matrix 2

3:0 60:0 6 60:0 40:0 0:0

0:0 4:0 7:0 0:0 0:0

1:0 0:0 5:0 0:0 0:0

2:0 0:0 9:0 0:0 6:0

3 0:0 0:07 7 0:07 0:05 5:0

(2.7.27)

In compressed column storage mode, matrix (2.7.27) is represented by two arrays of length 9 and an array of length 6, as follows

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 84 — #106

i

84

i

Chapter 2. Solution of Linear Algebraic Equations

index k

0

1

2

3

4

5

6

7

8

val[k]

3.0

4.0

7.0

1.0

5.0

2.0

9.0

6.0

5.0

0

1

2

0

2

0

2

4

4

row_ind[k]

index i

0

1

2

3

4

5

col_ptr[i]

0

1

3

5

8

9

(2.7.28)

Notice that, according to the storage rules, the value of N (namely 5) is the maximum valid index in col_ptr. The value of col_ptr[5] is 9, the length of the other two arrays. The elements 1.0 and 5.0 in column number 2, for example, are located in positions col_ptr[2]

k < col_ptr[3]. Here is a data structure to handle this storage scheme: sparse.h

struct NRsparseMat Sparse matrix data structure for compressed column storage. { Int nrows; Number of rows. Int ncols; Number of columns. Int nvals; Maximum number of nonzeros. VecInt col_ptr; Pointers to start of columns. Length is ncols+1. VecInt row_ind; Row indices of nonzeros. VecDoub val; Array of nonzero values. NRsparseMat(); NRsparseMat(Int m,Int n,Int nnvals); VecDoub ax(const VecDoub &x) const; VecDoub atx(const VecDoub &x) const; NRsparseMat transpose() const;

Default constructor. Constructor. Initializes vector to zero. Multiply A by a vector x[0..ncols-1]. Multiply AT by a vector x[0..nrows-1]. Form AT .

};

The code for the constructors is standard: sparse.h

NRsparseMat::NRsparseMat() : nrows(0),ncols(0),nvals(0),col_ptr(), row_ind(),val() {} NRsparseMat::NRsparseMat(Int m,Int n,Int nnvals) : nrows(m),ncols(n), nvals(nnvals),col_ptr(n+1,0),row_ind(nnvals,0),val(nnvals,0.0) {}

The single most important use of a matrix in compressed column storage mode is to multiply a vector to its right. Don’t implement this by traversing the rows of A, which is extremely inefficient in this storage mode. Here’s the right way to do it: sparse.h

VecDoub NRsparseMat::ax(const VecDoub &x) const { VecDoub y(nrows,0.0); for (Int j=0;j1 && abs(c[m-1])0;j--) Equation (5.9.2). cder[j-1]=cder[j+1]+2*j*c[j]; con=2.0/(b-a); for (j=0;j0;j--) d[j]=d[j-1]-dd[j]; d[0] = -dd[0]+0.5*c[0]; return d; }

pcshft.h

void pcshft(Doub a, Doub b, VecDoub_IO &d) Polynomial coefficient shift. Given a coefficient array d[0..n-1], this routine generates a coPn-1 P k k efficient array g[0..n-1] such that n-1 kD0 dk y D kD0 gk x , where x and y are related by (5.8.10), i.e., the interval 1 < y < 1 is mapped to the interval a < x < b. The array g is returned in d. { Int k,j,n=d.size(); Doub cnst=2.0/(b-a), fac=cnst; for (j=1;j=0;j--) { c[j]=2.0*d[j]+c[j+2]; for (Int i=j+1;i 1"); while (nb > 1) { for (jb=0;jb= 1; } nb2 = n>>1; if (m != n) for (j=nb2;j= 1.0 || rsq == 0.0); or try again. fac=sqrt(-2.0*log(rsq)/rsq); Now make the Box-Muller transformation to storedval = v1*fac; get two normal deviates. Return one and return mu + sig*v2*fac; save the other for next time. } else { We have an extra deviate handy, fac = storedval; storedval = 0.; return mu + sig*fac; so return it. } } };

deviates.h

7.3.5 Rayleigh Deviates The Rayleigh distribution is defined for positive z by

.z > 0/ p.z/dz D z exp  21 z 2 dz

(7.3.15)

Since the indefinite integral can be done analytically, and the result easily inverted, a simple transformation method from a uniform deviate x results: p (7.3.16) z D 2 ln x; x  U.0; 1/ A Rayleigh deviate z can also be generated from two normal deviates y1 and y2 by q z D y12 C y22 ; y1 ; y2  N.0; 1/ (7.3.17) Indeed, the relation between equations (7.3.16) and (7.3.17) is immediately evident in the equation for the Box-Muller method, equation (7.3.12), if we square and sum that method’s two normal deviates y1 and y2 .

7.3.6 Rejection Method The rejection method is a powerful, general technique for generating random deviates whose distribution function p.x/dx (probability of a value occurring between x and x C dx) is known and computable. The rejection method does not require that the cumulative distribution function (indefinite integral of p.x/) be readily computable, much less the inverse of that function — which was required for the transformation method in the previous section. The rejection method is based on a simple geometrical argument (Figure 7.3.2):

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 366 — #388

i

366

i

Chapter 7. Random Numbers A first random deviate in ⌠x ⌡0

f(x)dx

reject x0 f (x)

f(x0 )

accept x0

second random deviate in

p(x) 0

x0

0

Figure 7.3.2. Rejection method for generating a random deviate x from a known probability distribution p.x/ that is everywhere less than some other function f .x/. The transformation method is first used to generate a random deviate x of the distribution f (compare Figure 7.3.1). A second uniform deviate is used to decide whether to accept or reject that x. If it is rejected, a new deviate of f is found, and so on. The ratio of accepted to rejected points is the ratio of the area under p to the area between p and f .

Draw a graph of the probability distribution p.x/ that you wish to generate, so that the area under the curve in any range of x corresponds to the desired probability of generating an x in that range. If we had some way of choosing a random point in two dimensions, with uniform probability in the area under your curve, then the x value of that random point would have the desired distribution. Now, on the same graph, draw any other curve f .x/ that has finite (not infinite) area and lies everywhere above your original probability distribution. (This is always possible, because your original curve encloses only unit area, by definition of probability.) We will call this f .x/ the comparison function. Imagine now that you have some way of choosing a random point in two dimensions that is uniform in the area under the comparison function. Whenever that point lies outside the area under the original probability distribution, we will reject it and choose another random point. Whenever it lies inside the area under the original probability distribution, we will accept it. It should be obvious that the accepted points are uniform in the accepted area, so that their x values have the desired distribution. It should also be obvious that the fraction of points rejected just depends on the ratio of the area of the comparison function to the area of the probability distribution function, not on the details of shape of either function. For example, a comparison function whose area is less than 2 will reject fewer than half the points, even if it approximates the probability function very badly at some values of x, e.g., remains finite in some region where p.x/ is zero. It remains only to suggest how to choose a uniform random point in two dimensions under the comparison function f .x/. A variant of the transformation method (7.3) does nicely: Be sure to have chosen a comparison function whose indefinite integral is known analytically, and is also analytically invertible to give x as a function of “area under the comparison function to the left of x.” Now pick a uniform deviate between 0 and A, where A is the total area under f .x/, and use it to get a corresponding x. Then pick a uniform deviate between 0 and f .x/ as the y value for the two-dimensional point. Finally, accept or reject according to whether it is respectively less than or greater than p.x/. So, to summarize, the rejection method for some given p.x/ requires that one find, once and for all, some reasonably good comparison function f .x/. Thereafter,

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 367 — #389

7.3 Deviates from Other Distributions

i

367

each deviate generated requires two uniform random deviates, one evaluation of f (to get the coordinate y) and one evaluation of p (to decide whether to accept or reject the point x; y). Figure 7.3.1 illustrates the whole process. Then, of course, this process may need to be repeated, on the average, A times before the final deviate is obtained.

7.3.7 Cauchy Deviates The “further trick” described following equation (7.3.14) in the context of the Box-Muller method is now seen to be a rejection method for getting trigonometric functions of a uniformly random angle. If we combine this with the explicit formula, equation (6.14.6), for the inverse cdf of the Cauchy distribution (see 6.14.2), we can generate Cauchy deviates quite efficiently. struct Cauchydev : Ran { Structure for Cauchy deviates. Doub mu,sig; Cauchydev(Doub mmu, Doub ssig, Ullong i) : Ran(i), mu(mmu), sig(ssig) {} Constructor arguments are , , and a random sequence seed. Doub dev() { Return a Cauchy deviate. Doub v1,v2; do { Find a random point in the unit semicircle. v1=2.0*doub()-1.0; v2=doub(); } while (SQR(v1)+SQR(v2) >= 1. || v2 == 0.); return mu + sig*v1/v2; Ratio of its coordinates is the tangent of a } random angle. };

deviates.h

7.3.8 Ratio-of-Uniforms Method In finding Cauchy deviates, we took the ratio of two uniform deviates chosen to lie within the unit circle. If we generalize to shapes other than the unit circle, and combine it with the principle of the rejection method, a powerful variant emerges. Kinderman and Monahan [1] showed that deviates of virtually any probability distribution p.x/ can be generated by the following rather amazing prescription:  Construct the region in the .u; v/ plane bounded by 0 u Œp.v=u/1=2 .  Choose two deviates, u and v, that lie uniformly in this region.  Return v=u as the deviate. Proof: We can represent the ordinary rejection method by the equation in the .x; p/ plane, Z p0 Dp.x/ dp 0 dx (7.3.18) p.x/dx D p 0 D0

Since the integrand is 1, we are justified in sampling uniformly in .x; p 0 / as long as p 0 is within the limits of the integral (that is, 0 < p 0 < p.x/). Now make the change of variable v Dx u u2 D p

i

(7.3.19)

i

i

i “nr3” — 2007/5/1 — 20:53 — page 368 — #390

i

368

i

Chapter 7. Random Numbers

0.75 0.5 0.25 v

0 -0.25 -0.5 -0.75 0

0.2

0.4

0.6

0.8

1

u

Figure 7.3.3. Ratio-of-uniforms method. The interior of this teardrop shape is the acceptance region for the normal distribution: If a random point is chosen inside this region, then the ratio v=u will be a normal deviate.

Then equation (7.3.18) becomes Z Z p0 Dp.x/ 0 dp dx D p.x/dx D p 0 D0

p uD p.x/

uD0

@.p; x/ du dv D 2 @.u; v/

Z

p uD p.v=u/

du dv uD0

(7.3.20) because (as you can work out) the Jacobian determinant is the constant 2. Since the new integrand is constant, uniform sampling in .u; v/ with the limits indicated for u is equivalent to the rejection method in .x; p/. The above limits on u very often define a region that is “teardrop” shaped. To see why, note that the locii of constant x D v=u are radial lines. Along each radial, the acceptance region goes from the origin to a point where u2 D p.x/. Since most probability distributions go to zero for both large and small x, the acceptance region accordingly shrinks toward the origin along radials, producing a teardrop. Of course, it is the exact shape of this teardrop that matters. Figure 7.3.3 shows the shape of the acceptance region for the case of the normal distribution. Typically this ratio-of-uniforms method is used when the desired region can be closely bounded by a rectangle, parallelogram, or some other shape that is easy to sample uniformly. Then, we go from sampling the easy shape to sampling the desired region by rejection of points outside the desired region. An important adjunct to the ratio-of-uniforms method is the idea of a squeeze. A squeeze is any easy-to-compute shape that tightly bounds the region of acceptance of a rejection method, either from the inside or from the outside. Best of all is when you have squeezes on both sides. Then you can immediately reject points that are outside the outer squeeze and immediately accept points that are inside the inner squeeze. Only when you have the bad luck of drawing a point between the two squeezes do you actually have to do the more lengthy computation of comparing with the actual rejection boundary. Squeezes are useful both in the ordinary rejection method and in the ratio-of-uniforms method.

7.3.9 Normal Deviates by Ratio-of-Uniforms Leva [2] has given an algorithm for normal deviates that uses the ratio-of-uniforms method with great success. He uses quadratic curves to provide both inner

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 369 — #391

7.3 Deviates from Other Distributions

i

369

and outer squeezes that hug the desired region in the .u; v/ plane (Figure 7.3.3). Only about 1% of the time is it necessary to calculate an exact boundary (requiring a logarithm). The resulting code looks so simple and “un-transcendental” that it may be hard to believe that exact normal deviates are generated. But they are! deviates.h

struct Normaldev : Ran { Structure for normal deviates. Doub mu,sig; Normaldev(Doub mmu, Doub ssig, Ullong i) : Ran(i), mu(mmu), sig(ssig){} Constructor arguments are , , and a random sequence seed. Doub dev() { Return a normal deviate. Doub u,v,x,y,q; do { u = doub(); v = 1.7156*(doub()-0.5); x = u - 0.449871; y = abs(v) + 0.386595; q = SQR(x) + y*(0.19600*y-0.25472*x); } while (q > 0.27597 && (q > 0.27846 || SQR(v) > -4.*log(u)*SQR(u))); return mu + sig*v/u; } };

Note that the while clause makes use of C’s (and C++’s) guarantee that logical expressions are evaluated conditionally: If the first operand is sufficient to determine the outcome, the second is not evaluated at all. With these rules, the logarithm is evaluated only when q is between 0:27597 and 0:27846. On average, each normal deviate uses 2.74 uniform deviates. By the way, even though the various constants are given only to six digits, the method is exact (to full double precision). Small perturbations of the bounding curves are of no consequence. The accuracy is implicit in the (rare) evaluations of the exact boundary.

7.3.10 Gamma Deviates The distribution Gamma.˛; ˇ/ was described in 6.14.9. The ˇ parameter enters only as a scaling, Gamma.˛; ˇ/ Š

1 Gamma.˛; 1/ ˇ

(7.3.21)

(Translation: To generate a Gamma.˛; ˇ/ deviate, generate a Gamma.˛; 1/ deviate and divide it by ˇ.) If ˛ is a small positive integer, a fast way to generate x  Gamma.˛; 1/ is to use the fact that it is distributed as the waiting time to the ˛th event in a Poisson random process of unit mean. Since the time between two consecutive events is just the exponential distribution Exponential .1/, you can simply add up ˛ exponentially distributed waiting times, i.e., logarithms of uniform deviates. Even better, since the sum of logarithms is the logarithm of the product, you really only have to compute the product of a uniform deviates and then take the log. Because this is such a special case, however, we don’t include it in the code below.

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 370 — #392

i

370

i

Chapter 7. Random Numbers

When ˛ < 1, the gamma distribution’s density function is not bounded, which is inconvenient. However, it turns out [4] that if y  Gamma.˛ C 1; 1/;

u  Uniform.0; 1/

(7.3.22)

then yu1=˛  Gamma.˛; 1/

(7.3.23)

We will use this in the code below. For ˛ > 1, Marsaglia and Tsang [5] give an elegant rejection method based on a simple transformation of the gamma distribution combined with a squeeze. After transformation, the gamma distribution can be bounded by a Gaussian curve whose area is never more than 5% greater than that of the gamma curve. The cost of a gamma deviate is thus only a little more than the cost of the normal deviate that is used to sample the comparison function. The following code gives the precise formulation; see the original paper for a full explanation. deviates.h

struct Gammadev : Normaldev { Structure for gamma deviates. Doub alph, oalph, bet; Doub a1,a2; Gammadev(Doub aalph, Doub bbet, Ullong i) : Normaldev(0.,1.,i), alph(aalph), oalph(aalph), bet(bbet) { Constructor arguments are ˛, ˇ , and a random sequence seed. if (alph 0.5*SQR(x) + a1*(1.-v+log(v))); Rarely evaluated. if (alph == oalph) return a1*v/bet; else { Case where ˛ < 1, per Ripley. do u=doub(); while (u == 0.); return pow(u,1./oalph)*a1*v/bet; } } };

There exists a sum rule for gamma deviates. If we have a set of independent deviates yi with possibly different ˛i ’s, but sharing a common value of ˇ, yi  Gamma.˛i ; ˇ/ then their sum is also a gamma deviate, X yi  Gamma.˛T ; ˇ/; y i

i

(7.3.24)

˛T D

X

˛i

(7.3.25)

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 371 — #393

i

i

371

7.3 Deviates from Other Distributions

If the ˛i ’s are integers, you can see how this relates to the discussion of Poisson waiting times above.

7.3.11 Distributions Easily Generated by Other Deviates From normal, gamma and uniform deviates, we get a bunch of other distributions for free. Important: When you are going to combine their results, be sure that all distinct instances of Normaldist, Gammadist, and Ran have different random seeds! (Ran and its derived classes are sufficiently robust that seeds i; i C 1; : : : are fine.) Chi-Square Deviates (cf. 6.14.8) This one is easy:    1 Š 2 Gamma ; 1 (7.3.26) Chisquare. / Š Gamma ; 2 2 2 Student-t Deviates (cf. 6.14.3) Deviates from the Student-t distribution can be generated by a method very similar to the Box-Muller method. The analog of equation (7.3.12) is q  1/ cos 2 u2 (7.3.27) y D .u2= 1 If u1 and u2 are independently uniform, U.0; 1/, then y  Student. ; 0; 1/

(7.3.28)

 C y  Student. ; ;  /

(7.3.29)

or Unfortunately, you can’t do the Box-Muller trick of getting two deviates at a time, because the Jacobian determinant analogous to equation (7.3.14) does not factorize. You might want to use the polar method anyway, just to get cos 2 u2 , but its advantage is now not so large. An alternative method uses the quotients of normal and gamma deviates. If we have  1 (7.3.30) x  N.0; 1/; y  Gamma ; 2 2 then p x =y  Student. ; 0; 1/ (7.3.31) Beta Deviates (cf. 6.14.11) If x  Gamma.˛; 1/; then

y  Gamma.ˇ; 1/

x  Beta.˛; ˇ/ xCy F-Distribution Deviates (cf. 6.14.10) If x  Beta. 12 1 ; 12 2 /

(7.3.32) (7.3.33)

(7.3.34)

(see equation 7.3.33), then

2 x  F. 1 ; 2 /

1 .1  x/

i

(7.3.35)

i

i

i “nr3” — 2007/5/1 — 20:53 — page 372 — #394

i

372

i

Chapter 7. Random Numbers 1 in

reject accept

0

1

2

3

4

5

Figure 7.3.4. Rejection method as applied to an integer-valued distribution. The method is performed on the step function shown as a dashed line, yielding a real-valued deviate. This deviate is rounded down to the next lower integer, which is output.

7.3.12 Poisson Deviates The Poisson distribution, Poisson./, previously discussed in 6.14.13, is a discrete distribution, so its deviates will be integers, k. To use the methods already discussed, it is convenient to convert the Poisson distribution into a continuous distribution by the following trick: Consider the finite probability p.k/ as being spread out uniformly into the interval from k to k C1. This defines a continuous distribution q .k/d k given by bkc e  dk (7.3.36) q .k/d k D bkcŠ where bkc represents the largest integer k. If we now use a rejection method, or any other method, to generate a (noninteger) deviate from (7.3.36), and then take the integer part of that deviate, it will be as if drawn from the discrete Poisson distribution. (See Figure 7.3.4.) This trick is general for any integer-valued probability distribution. Instead of the “floor” operator, one can equally well use “ceiling” or “nearest” — anything that spreads the probability over a unit interval. For  large enough, the distribution (7.3.36) is qualitatively bell-shaped (albeit with a bell made out of small, square steps). In that case, the ratio-of-uniforms method works well. It is not hard to find simple inner and outer squeezes in the .u; v/ plane of the form v 2 D Q.u/, where Q.u/ is a simple polynomial in u. The only trick is to allow a big enough gap between the squeezes to enclose the true, jagged, boundaries for all values of . (Look ahead to Figure 7.3.5 for a similar example.) For intermediate values of , the jaggedness is so large as to render squeezes impractical, but the ratio-of-uniforms method, unadorned, still works pretty well. For small , we can use an idea similar to that mentioned above for the gamma distribution in the case of integer a. When the sum of independent exponential

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 373 — #395

7.3 Deviates from Other Distributions

i

373

deviates first exceeds , their number (less 1) is a Poisson deviate k. Also, as explained for the gamma distribution, we can multiply uniform deviates from U.0; 1/ instead of adding deviates from Exponential .1/. These ideas produce the following routine. struct Poissondev : Ran { Structure for Poisson deviates. Doub lambda, sqlam, loglam, lamexp, lambold; VecDoub logfact; Int swch; Poissondev(Doub llambda, Ullong i) : Ran(i), lambda(llambda), logfact(1024,-1.), lambold(-1.) {} Constructor arguments are  and a random sequence seed. Int dev() { Return a Poisson deviate using the most recently set value of . Doub u,u2,v,v2,p,t,lfac; Int k; if (lambda < 5.) { Will use product of uniforms method. if (lambda != lambold) lamexp=exp(-lambda); k = -1; t=1.; do { ++k; t *= doub(); } while (t > lamexp); } else { Will use ratio-of-uniforms method. if (lambda != lambold) { sqlam = sqrt(lambda); loglam = log(lambda); } for (;;) { u = 0.64*doub(); v = -0.68 + 1.28*doub(); if (lambda > 13.5) { Outer squeeze for fast rejection. v2 = SQR(v); if (v >= 0.) {if (v2 > 6.5*u*(0.64-u)*(u+0.2)) continue;} else {if (v2 > 9.6*u*(0.66-u)*(u+0.07)) continue;} } k = Int(floor(sqlam*(v/u)+lambda+0.5)); if (k < 0) continue; u2 = SQR(u); if (lambda > 13.5) { Inner squeeze for fast acceptance. if (v >= 0.) {if (v2 < 15.2*u2*(0.61-u)*(0.8-u)) break;} else {if (v2 < 6.76*u2*(0.62-u)*(1.4-u)) break;} } if (k < 1024) { if (logfact[k] < 0.) logfact[k] = gammln(k+1.); lfac = logfact[k]; } else lfac = gammln(k+1.); p = sqlam*exp(-lambda + k*loglam - lfac); Only when we must. if (u2 < p) break; } } lambold = lambda; return k; } Int dev(Doub llambda) { Reset  and then return a Poisson deviate. lambda = llambda; return dev(); } };

i

deviates.h

i

i

i “nr3” — 2007/5/1 — 20:53 — page 374 — #396

i

374

i

Chapter 7. Random Numbers 0.6 0.4

v

0.2 0 -0.2 -0.4 -0.6 0

0.1

0.2

0.3 u

0.4

0.5

0.6

Figure 7.3.5. Ratio-of-uniforms method as applied to the generation of binomial deviates. Points are chosen randomly in the .u; v/-plane. The smooth curves are inner and outer squeezes. The jagged curves correspond to various binomial distributions with n > 64 and np > 30. An evaluation of the binomial probability is required only when the random point falls between the smooth curves.

In the regime  > 13:5, the above code uses about 3:3 uniform deviates per output Poisson deviate and does 0:4 evaluations of the exact probability (costing an exponential and, for large k, a call to gammln). Poissondev is slightly faster if you draw many deviates with the same value , using the dev function with no arguments, than if you vary  on each call, using the one-argument overloaded form of dev (which is provided for just that purpose). The difference is just an extra exponential ( < 5) or square root and logarithm (  5). Note also the object’s table of previously computed log-factorials. If your ’s are as large as  103 , you might want to make the table larger.

7.3.13 Binomial Deviates The generation of binomial deviates k  Binomial.n; p/ involves many of the same ideas as for Poisson deviates. The distribution is again integer-valued, so we use the same trick to convert it into a stepped continuous distribution. We can always restrict attention to the case p 0:5, since the distribution’s symmetries let us trivially recover the case p > 0:5. When n > 64 and np > 30, we use the ratio-of-uniforms method, with squeezes shown in Figure 7.3.5. The cost is about 3:2 uniform deviates, plus 0:4 evaluations of the exact probability, per binomial deviate. It would be foolish to waste much thought on the case where n > 64 and np < 30, because it is so easy simply to tabulate the cdf, say for 0 k < 64, and then loop over k’s until the right one is found. (A bisection search, implemented below, is even better.) With a cdf table of length 64, the neglected probability at the end of the table is never larger than  1020 . (At 109 deviates per second, you could run 3000 years before losing a deviate.) What is left is the interesting case n < 64, which we will explore in some detail, because it demonstrates the important concept of bit-parallel random comparison. Analogous to the methods for gamma deviates with small integer a and for Poisson deviates with small , is this direct method for binomial deviates: Generate n uniform deviates in U.0; 1/. Count the number of them < p. Return the count as

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 375 — #397

7.3 Deviates from Other Distributions

i

375

k  Binomial.n; p/. Indeed this is essentially the definition of a binomial process! The problem with the direct method is that it seems to require n uniform deviates, even when the mean value of k is much smaller. Would you be surprised if we told you that for n 64 you can achieve the same goal with at most seven 64-bit uniform deviates, on average? Here is how. Expand p < 1 into its first 5 bits, plus a residual, p D b1 21 C b2 22 C C b5 25 C pr 25

(7.3.37)

where each bi is 0 or 1, and 0 pr 1. Now imagine that you have generated and stored 64 uniform U.0; 1/ deviates, and that the 64-bit word P displays just the first bit of each of the 64. Compare each bit of P to b1 . If the bits are the same, then we don’t yet know whether that uniform deviate is less than or greater than p. But if the bits are different, then we know that the generator is less than p (in the case that b1 D 1) or greater than p (in the case that b1 D 0). If we keep a mask of “known” versus “unknown” cases, we can do these comparisons in a bit-parallel manner by bitwise logical operations (see code below to learn how). Now move on to the second bit, b2 , in the same way. At each stage we change half the remaining unknowns to knowns. After five stages (for n D 64) there will be two remaining unknowns, on average, each of which we finish off by generating a new uniform and comparing it to pr . (This requires a loop through the 64 bits; but since C++ has no bitwise “popcount” operation, we are stuck doing such a loop anyway. If you can do popcounts, you may be better off just doing more stages until the unknowns mask is zero.) The trick is that the bits used in the five stages are not actually the leading five bits of 64 generators, they are just five independent 64-bit random integers. The number five was chosen because it minimizes 64  2j C j , the expected number of deviates needed. So, the code for binomial deviates ends up with three separate methods: bitparallel direct, cdf lookup (by bisection), and squeezed ratio-of-uniforms. struct Binomialdev : Ran { Structure for binomial deviates. Doub pp,p,pb,expnp,np,glnp,plog,pclog,sq; Int n,swch; Ullong uz,uo,unfin,diff,rltp; Int pbits[5]; Doub cdf[64]; Doub logfact[1024]; Binomialdev(Int nn, Doub ppp, Ullong i) : Ran(i), pp(ppp), n(nn) { Constructor arguments are n, p, and a random sequence seed. Int j; pb = p = (pp = 0.) {if (v2 > 6.5*u*(0.645-u)*(u+0.2)) continue;} else {if (v2 > 8.4*u*(0.645-u)*(u+0.1)) continue;} k = Int(floor(sq*(v/u)+np+0.5)); if (k < 0) continue; u2 = SQR(u); Try squeeze for fast acceptance: if (v >= 0.) {if (v2 < 12.25*u2*(0.615-u)*(0.92-u)) break;} else {if (v2 < 7.84*u2*(0.615-u)*(1.2-u)) break;} b = sq*exp(glnp+k*plog+(n-k)*pclog Only when we must. - (n < 1024 ? logfact[k]+logfact[n-k] : gammln(k+1.)+gammln(n-k+1.))); if (u2 < b) break; } } if (p != pp) k = n - k; return k; } };

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 377 — #399

7.3 Deviates from Other Distributions

i

377

If you are in a situation where you are drawing only one or a few deviates each for many different values of n and/or p, you’ll need to restructure the code so that n and p can be changed without creating a new instance of the object and without reinitializing the underlying Ran generator.

7.3.14 When You Need Greater Speed In particular situations you can cut some corners to gain greater speed. Here are some suggestions.  All of the algorithms in this section can be speeded up significantly by using Ranq1 in 7.1 instead of Ran. We know of no reason not to do this. You can gain some further speed by coding Ranq1’s algorithm inline, thus eliminating the function calls.  If you are using Poissondev or Binomialdev with large values of  or n, then the above codes revert to calling gammln, which is slow. You can instead increase the length of the stored tables.  For Poisson deviates with  < 20, you may want to use a stored table of cdfs combined with bisection to find the value of k. The code in Binomialdev shows how to do this.  If your need is for binomial deviates with small n, you can easily modify the code in Binomialdev to get multiple deviates ( 64=n, in fact) from each execution of the bit-parallel code.  Do you need exact deviates, or would an approximation do? If your distribution of interest can be approximated by a normal distribution, consider substituting Normaldev, above, especially if you also code the uniform random generation inline.  If you sum exactly 12 uniform deviates U.0; 1/ and then subtract 6, you get a pretty good approximation of a normal deviate N.0; 1/. This is definitely slower then Normaldev (not to mention less accurate) on a general-purpose CPU. However, there are reported to be some special-purpose signal processing chips in which all the operations can be done with integer arithmetic and in parallel. See Gentle [3], Ripley [4], Devroye [6], Bratley [7], and Knuth [8] for many additional algorithms.

CITED REFERENCES AND FURTHER READING: Kinderman, A.J. and Monahan, J.F 1977, “Computer Generation of Random Variables Using the Ratio of Uniform Deviates,” ACM Transactions on Mathematical Software, vol. 3, pp. 257– 260.[1] Leva, J.L. 1992. “A Fast Normal Random Number Generator,” ACM Transactions on Mathematical Software, vol. 18, no. 4, pp. 449-453.[2] Gentle, J.E. 2003, Random Number Generation and Monte Carlo Methods, 2nd ed. (New York: Springer), Chapters 4–5.[3] Ripley, B.D. 1987, Stochastic Simulation (New York: Wiley).[4] Marsaglia, G. and Tsang W-W. 2000, “A Simple Method for Generating Gamma Variables,” ACM Transactions on Mathematical Software, vol. 26, no. 3, pp. 363–372.[5] Devroye, L. 1986, Non-Uniform Random Variate Generation (New York: Springer).[6]

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 378 — #400

i

378

i

Chapter 7. Random Numbers

Bratley, P., Fox, B.L., and Schrage, E.L. 1983, A Guide to Simulation, 2nd ed. (New York: Springer).[7]. Knuth, D.E. 1997, Seminumerical Algorithms, 3rd ed., vol. 2 of The Art of Computer Programming (Reading, MA: Addison-Wesley), pp. 125ff.[8]

7.4 Multivariate Normal Deviates A multivariate random deviate of dimension M is a point in M -dimensional space. Its coordinates are a vector, each of whose M components are random — but not, in general, independently so, or identically distributed. The special case of multivariate normal deviates is defined by the multidimensional Gaussian density function N.x j ; †/ D

.2 /M=2

1 expŒ 12 .x  / † 1 .x  / det.†/1=2

(7.4.1)

where the parameter  is a vector that is the mean of the distribution, and the parameter † is a symmetrical, positive-definite matrix that is the distribution’s covariance. There is a quite general way to construct a vector deviate x with a specified covariance † and mean , starting with a vector y of independent random deviates of zero mean and unit variance: First, use Cholesky decomposition (2.9) to factor † into a left triangular matrix L times its transpose, † D LLT

(7.4.2)

This is always possible because † is positive-definite, and you need do it only once for each distinct † of interest. Next, whenever you want a new deviate x, fill y with independent deviates of unit variance and then construct x D Ly C 

(7.4.3)

The proof is straightforward, with angle brackets denoting expectation values: Since the components yi are independent with unit variance, we have hy ˝ yi D 1

(7.4.4)

where 1 is the identity matrix. Then, h.x  / ˝ .x  /i D h.Ly/ ˝ .Ly/i D E D L.y ˝ y/LT D L hy ˝ yi LT

(7.4.5)

T

D LL D † As general as this procedure is, it is, however, rarely useful for anything except multivariate normal deviates. The reason is that while the components of x indeed have the right mean and covariance structure, their detailed distribution is not anything “nice.” The xi ’s are linear combinations of the yi ’s, and, in general, a linear combination of random variables is distributed as a complicated convolution of their individual distributions.

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 379 — #401

i

7.4 Multivariate Normal Deviates

i

379

For Gaussians, however, we do have “nice.” All linear combinations of normal deviates are themselves normally distributed, and completely defined by their mean and covariance structure. Thus, if we always fill the components of y with normal deviates, (7.4.6) yi  N.0; 1/ then the deviate (7.4.3) will be distributed according to equation (7.4.1). Implementation is straightforward, since the Cholesky structure both accomplishes the decomposition and provides a method for doing the matrix multiplication efficiently, taking advantage of L’s triangular structure. The generation of normal deviates is inline for efficiency, identical to Normaldev in 7.3. struct Multinormaldev : Ran { Structure for multivariate normal deviates. Int mm; VecDoub mean; MatDoub var; Cholesky chol; VecDoub spt, pt;

multinormaldev.h

Multinormaldev(Ullong j, VecDoub &mmean, MatDoub &vvar) : Ran(j), mm(mmean.size()), mean(mmean), var(vvar), chol(var), spt(mm), pt(mm) { Constructor. Arguments are the random generator seed, the (vector) mean, and the (matrix) covariance. Cholesky decomposition of the covariance is done here. if (var.ncols() != mm || var.nrows() != mm) throw("bad sizes"); } VecDoub &dev() { Return a multivariate normal deviate. Int i; Doub u,v,x,y,q; for (i=0;i 0.27597 && (q > 0.27846 || SQR(v) > -4.*log(u)*SQR(u))); spt[i] = v/u; } chol.elmult(spt,pt); Apply equation (7.4.3). for (i=0;i M C 1, define hj  0; M C 1 < j N  1, i.e., “zero-pad” the array of hj ’s so that j takes on the range 0 j N  1. Then the sum can be done as a DFT for the special values ! D !n given by !n  

i

2 n  N

n D 0; 1; : : : ;

N 1 2

(13.9.12)

i

i

i “nr3” — 2007/5/1 — 20:53 — page 695 — #717

i

i

695

13.9 Computing Fourier Integrals Using the FFT

For fixed M , the larger N is chosen, the finer the sampling in frequency space. The value M , on the other hand, determines the highest frequency sampled, since  decreases with increasing M (equation 13.9.3), and the largest value of ! is always just under (equation 13.9.12). In general it is advantageous to oversample by at least a factor of 4, i.e., N > 4M (see below). We can now rewrite equation (13.9.8) in its final form as n I.!n / D e i !n a W . /ŒDFT.h0 : : : hN 1 /n C ˛0 . /h0 C ˛1 . /h1 C ˛2 . /h2 C ˛3 . /h3 C : : : o  C e i !.ba/ ˛0 . /hM C ˛1 . /hM 1 C ˛2 . /hM 2 C ˛3 . /hM 3 C : : : (13.9.13) For cubic (or lower) polynomial interpolation, at most the terms explicitly shown above are nonzero; the ellipses (: : :) can therefore be ignored, and we need explicit forms only for the functions W; ˛0 ; ˛1 ; ˛2 ; ˛3 , calculated with equations (13.9.9) and (13.9.10). We have worked these out for you, in the trapezoidal (second-order) and cubic (fourth-order) cases. Here are the results, along with the first few terms of their power series expansions for small  : Trapezoidal order: W ./ D

2.1  cos / 1 2 1 4 1  C   6 1 2 12 360 20160

.1  cos / .  sin / Ci 2 2   1 2 1 2 1 1 4 1 1 1 1    C  6 C i   C 4  6  C 2 24 720 40320 6 120 5040 362880

˛0 ./ D 

˛1 D ˛2 D ˛3 D 0 Cubic order:  W ./ D

6 C 2 3 4

 .3  4 cos  C cos 2/ 1 

11 4 23  C 6 720 15120

.42 C 5 2 / C .6 C  2 /.8 cos   cos 2/ .12 C 6 3 / C .6 C  2 / sin 2 Ci 4 6 6 4   1 2 2 2 2 103 4 169 2 8 86  C    6 C i C   4 C 6  C 3 45 15120 226800 45 105 2835 467775

˛0 ./ D

14.3   2 /  7.6 C  2 / cos  30  5.6 C  2 / sin  Ci 4 6 6 4   7 2 1 2 7 5 7 7 11 13   C 4   6 C i   C 4  6 24 180 3456 259200 72 168 72576 5987520

˛1 ./ D

4.3   2 / C 2.6 C  2 / cos  12 C 2.6 C  2 / sin  Ci 4 3 3 4   1 2 1 2 1 5 1 7 11 13   4 C  6 C i  C   4 C 6  C 6 45 6048 64800 90 210 90720 7484400

˛2 ./ D

2.3   2 /  .6 C  2 / cos  6  .6 C  2 / sin  Ci 6 4 6 4   1 2 1 2 1 5 1 11 13 7   C 4   6 C i   C 4  6 24 180 24192 259200 360 840 362880 29937600

˛3 ./ D

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 696 — #718

i

696

i

Chapter 13. Fourier and Spectral Applications

The program dftcor, below, implements the endpoint corrections for the cubic case. Given input values of !; ; a; b; and an array with the eight values h0 ; : : : ; h3 , hM 3 ; : : : ; hM , it returns the real and imaginary parts of the endpoint corrections in equation (13.9.13), and the factor W . /. The code is turgid, but only because the formulas above are complicated. The formulas have cancellations to high powers of  . It is therefore necessary to compute the right-hand sides in double precision, even when the corrections are desired only to single precision. It is also necessary to use the series expansion for small values of  . The optimal cross-over value of  depends on your machine’s wordlength, but you can always find it experimentally as the largest value where the two methods give identical results to machine precision. dftintegrate.h

i

void dftcor(const Doub w, const Doub delta, const Doub a, const Doub b, VecDoub_I &endpts, Doub &corre, Doub &corim, Doub &corfac) { For an integral approximated by a discrete Fourier transform, this routine computes the correction factor that multiplies the DFT and the endpoint correction to be added. Input is the angular frequency w, stepsize delta, lower and upper limits of the integral a and b, while the array endpts contains the first 4 and last 4 function values. The correction factor W ./ is returned as corfac, while the real and imaginary parts of the endpoint correction are returned as corre and corim. Doub a0i,a0r,a1i,a1r,a2i,a2r,a3i,a3r,arg,c,cl,cr,s,sl,sr,t,t2,t4,t6, cth,ctth,spth2,sth,sth4i,stth,th,th2,th4,tmth2,tth4i; th=w*delta; if (a >= b || th < 0.0e0 || th > 3.1416e0) throw("bad arguments to dftcor"); if (abs(th) < 5.0e-2) { Use series. t=th; t2=t*t; t4=t2*t2; t6=t4*t2; corfac=1.0-(11.0/720.0)*t4+(23.0/15120.0)*t6; a0r=(-2.0/3.0)+t2/45.0+(103.0/15120.0)*t4-(169.0/226800.0)*t6; a1r=(7.0/24.0)-(7.0/180.0)*t2+(5.0/3456.0)*t4-(7.0/259200.0)*t6; a2r=(-1.0/6.0)+t2/45.0-(5.0/6048.0)*t4+t6/64800.0; a3r=(1.0/24.0)-t2/180.0+(5.0/24192.0)*t4-t6/259200.0; a0i=t*(2.0/45.0+(2.0/105.0)*t2-(8.0/2835.0)*t4+(86.0/467775.0)*t6); a1i=t*(7.0/72.0-t2/168.0+(11.0/72576.0)*t4-(13.0/5987520.0)*t6); a2i=t*(-7.0/90.0+t2/210.0-(11.0/90720.0)*t4+(13.0/7484400.0)*t6); a3i=t*(7.0/360.0-t2/840.0+(11.0/362880.0)*t4-(13.0/29937600.0)*t6); } else { Use trigonometric formulas. cth=cos(th); sth=sin(th); ctth=cth*cth-sth*sth; stth=2.0e0*sth*cth; th2=th*th; th4=th2*th2; tmth2=3.0e0-th2; spth2=6.0e0+th2; sth4i=1.0/(6.0e0*th4); tth4i=2.0e0*sth4i; corfac=tth4i*spth2*(3.0e0-4.0e0*cth+ctth); a0r=sth4i*(-42.0e0+5.0e0*th2+spth2*(8.0e0*cth-ctth)); a0i=sth4i*(th*(-12.0e0+6.0e0*th2)+spth2*stth); a1r=sth4i*(14.0e0*tmth2-7.0e0*spth2*cth); a1i=sth4i*(30.0e0*th-5.0e0*spth2*sth); a2r=tth4i*(-4.0e0*tmth2+2.0e0*spth2*cth); a2i=tth4i*(-12.0e0*th+2.0e0*spth2*sth); a3r=sth4i*(2.0e0*tmth2-spth2*cth); a3i=sth4i*(6.0e0*th-spth2*sth); } cl=a0r*endpts[0]+a1r*endpts[1]+a2r*endpts[2]+a3r*endpts[3]; sl=a0i*endpts[0]+a1i*endpts[1]+a2i*endpts[2]+a3i*endpts[3]; cr=a0r*endpts[7]+a1r*endpts[6]+a2r*endpts[5]+a3r*endpts[4]; sr= -a0i*endpts[7]-a1i*endpts[6]-a2i*endpts[5]-a3i*endpts[4];

i

i

i “nr3” — 2007/5/1 — 20:53 — page 697 — #719

i

13.9 Computing Fourier Integrals Using the FFT

i

697

arg=w*(b-a); c=cos(arg); s=sin(arg); corre=cl+c*cr-s*sr; corim=sl+s*cr+c*sr; }

Since the use of dftcor can be confusing, we also give an illustrative program dftint that uses dftcor to compute equation (13.9.1) for general a; b; !, and h.t /. Several points within this program bear mentioning: The constants M and NDFT correspond to M and N in the above discussion. On successive calls, we recompute the Fourier transform only if a or b or h.t / has changed. Since dftint is designed to work for any value of ! satisfying ! < , not just the special values returned by the DFT (equation 13.9.12), we do polynomial interpolation of degree MPOL on the DFT spectrum. You should be warned that a large factor of oversampling (N M ) is required for this interpolation to be accurate. After interpolation, we add the endpoint corrections from dftcor, which can be evaluated for any !. While dftcor is good at what it does, the routine dftint is illustrative only. It is not a general-purpose program, because it does not adapt its parameters M, NDFT, MPOL or its interpolation scheme to any particular function h.t /. You will have to experiment with your own application. void dftint(Doub func(const Doub), const Doub a, const Doub b, const Doub w, Doub &cosint, Doub &sinint) { Example program illustrating how to use the routine dftcor. The user supplies an external Rb function func that returns the quantity h.t/. The routine then returns a cos.!t/h.t/ dt as Rb cosint and a sin.!t/h.t/ dt as sinint. static Int init=0; static Doub (*funcold)(const Doub); static Doub aold = -1.e30,bold = -1.e30,delta; const Int M=64,NDFT=1024,MPOL=6; The values of M, NDFT, and MPOL are merely illustrative and should be optimized for your particular application. M is the number of subintervals, NDFT is the length of the FFT (a power of 2), and MPOL is the degree of polynomial interpolation used to obtain the desired frequency from the FFT. const Doub TWOPI=6.283185307179586476; Int j,nn; Doub c,cdft,corfac,corim,corre,en,s,sdft; static VecDoub data(NDFT),endpts(8); VecDoub cpol(MPOL),spol(MPOL),xpol(MPOL); if (init != 1 || a != aold || b != bold || func != funcold) { Do we need to initialize, or is only ! changed? init=1; aold=a; bold=b; funcold=func; delta=(b-a)/M; for (j=0;j=1) wlet.filt(a,nn,isign); Start at largest hierarchy, and work toward smallest. } else { for (nn=4;nn= 0) { Apply filter. for (i=0,j=0;j gc) fc += 1.0/n1; if (fd > gd) fd += 1.0/n1; d1=MAX(d1,abs(fa-ga)); d1=MAX(d1,abs(fb-gb)); d1=MAX(d1,abs(fc-gc)); d1=MAX(d1,abs(fd-gd)); } d2=0.0; for (j=0;j fa) ga += 1.0/n1; if (gb > fb) gb += 1.0/n1; if (gc > fc) gc += 1.0/n1; if (gd > fd) gd += 1.0/n1; d2=MAX(d2,abs(fa-ga)); d2=MAX(d2,abs(fb-gb)); d2=MAX(d2,abs(fc-gc)); d2=MAX(d2,abs(fd-gd)); } d=0.5*(d1+d2); Average the K-S statistics. sqen=sqrt(n1*n2/Doub(n1+n2)); pearsn(x1,y1,r1,dum,dumm); Get the linear correlation coefficient for each pearsn(x2,y2,r2,dum,dumm); sample. rr=sqrt(1.0-0.5*(r1*r1+r2*r2)); Estimate the probability using the K-S probability function. prob=ks.qks(d*sqen/(1.0+rr*(0.25-0.75/sqen))); }

CITED REFERENCES AND FURTHER READING: Fasano, G. and Franceschini, A. 1987, “A Multidimensional Version of the Kolmogorov-Smirnov Test,” Monthly Notices of the Royal Astronomical Society, vol. 225, pp. 155–170.[1] Peacock, J.A. 1983, “Two-Dimensional Goodness-of-Fit Testing in Astronomy,” Monthly Notices of the Royal Astronomical Society, vol. 202, pp. 615–627.[2] Spergel, D.N., Piran, T., Loeb, A., Goodman, J., and Bahcall, J.N. 1987, “A Simple Model for Neutrino Cooling of the LMC Supernova,” Science, vol. 237, pp. 1471–1473.[3]

14.9 Savitzky-Golay Smoothing Filters In 13.5 we learned something about the construction and application of digital filters, but little guidance was given on which particular filter to use. That, of course, depends on what you want to accomplish by filtering. One obvious use for low-pass filters is to smooth noisy data. The premise of data smoothing is that one is measuring a variable that is both slowly varying and also corrupted by random noise. Then it can sometimes be useful

i

i

i i

i “nr3” — 2007/5/1 — 20:53 — page 767 — #789

14.9 Savitzky-Golay Smoothing Filters

i

767

to replace each data point by some kind of local average of surrounding data points. Since nearby points measure very nearly the same underlying value, averaging can reduce the level of noise without (much) biasing the value obtained. We must comment editorially that the smoothing of data lies in a murky area, beyond the fringe of some better-posed, and therefore more highly recommended, techniques that are discussed elsewhere in this book. If you are fitting data to a parametric model, for example (see Chapter 15), it is almost always better to use raw data than to use data that have been pre-processed by a smoothing procedure. Another alternative to blind smoothing is so-called “optimal” or Wiener filtering, as discussed in 13.3 and more generally in 13.6. Data smoothing is probably most justified when it is used simply as a graphical technique, to guide the eye through a forest of data points all with large error bars, or as a means of making initial rough estimates of simple parameters from a graph. In this section we discuss a particular type of low-pass filter, well-adapted for data smoothing, and termed variously Savitzky-Golay [1], least-squares [2], or DISPO (Digital Smoothing Polynomial) [3] filters. Rather than having their properties defined in the Fourier domain and then translated to the time domain, Savitzky-Golay filters derive directly from a particular formulation of the data smoothing problem in the time domain, as we will now see. Savitzky-Golay filters were initially (and are still often) used to render visible the relative widths and heights of spectral lines in noisy spectrometric data. Recall that a digital filter is applied to a series of equally spaced data values fi  f .ti /, where ti  t0 C i  for some constant sample spacing  and i D : : :  2; 1; 0; 1; 2; : : : . We have seen (13.5) that the simplest type of digital filter (the nonrecursive or finite impulse response filter) replaces each data value fi by a linear combination gi of itself and some number of nearby neighbors, gi D

nR X

cn fi Cn

(14.9.1)

nDnL

Here nL is the number of points used “to the left” of a data point i , i.e., earlier than it, while nR is the number used to the right, i.e., later. A so-called causal filter would have nR D 0. As a starting point for understanding Savitzky-Golay filters, consider the simplest possible averaging procedure: For some fixed nL D nR , compute each gi as the average of the data points from fi nL to fi CnR . This is sometimes called moving window averaging and corresponds to equation (14.9.1) with constant cn D 1=.nL C nR C 1/. If the underlying function is constant, or is changing linearly with time (increasing or decreasing), then no bias is introduced into the result. Higher points at one end of the averaging interval are on the average balanced by lower points at the other end. A bias is introduced, however, if the underlying function has a nonzero second derivative. At a local maximum, for example, moving window averaging always reduces the function value. In the spectrometric application, a narrow spectral line has its height reduced and its width increased. Since these parameters are themselves of physical interest, the bias introduced is distinctly undesirable. Note, however, that moving window averaging does preserve the area under a spectral line, which is its zeroth moment, and also (if the window is symmetric with nL D nR ) its mean position in time, which is its first moment. What is violated is

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 768 — #790

i

768

i

Chapter 14. Statistical Description of Data

the second moment, equivalent to the line width. The idea of Savitzky-Golay filtering is to find filter coefficients cn that preserve higher moments. Equivalently, the idea is to approximate the underlying function within the moving window not by a constant (whose estimate is the average), but by a polynomial of higher order, typically quadratic or quartic: For each point fi , we least-squares fit a polynomial to all nL C nR C 1 points in the moving window, and then set gi to be the value of that polynomial at position i . (If you are not familiar with least-squares fitting, you might want to look ahead to Chapter 15.) We make no use of the value of the polynomial at any other point. When we move on to the next point fi C1 , we do a whole new least-squares fit using a shifted window. All these least-squares fits would be laborious if done as described. Luckily, since the process of least-squares fitting involves only a linear matrix inversion, the coefficients of a fitted polynomial are themselves linear in the values of the data. That means that we can do all the fitting in advance, for fictitious data consisting of all zeros except for a single 1, and then do the fits on the real data just by taking linear combinations. This is the key point, then: There are particular sets of filter coefficients cn for which equation (14.9.1) “automatically” accomplishes the process of polynomial least-squares fitting inside a moving window. To derive such coefficients, consider how g0 might be obtained: We want to fit a polynomial of degree M in i , namely a0 C a1 i C C aM i M , to the values fnL ; : : : ; fnR . Then g0 will be the value of that polynomial at i D 0, namely a0 . The design matrix for this problem (15.4) is Aij D i j

i D nL ; : : : ; nR ;

j D 0; : : : ; M

(14.9.2)

and the normal equations for the vector of aj ’s in terms of the vector of fi ’s is in matrix notation .AT A/ a D AT f

a D .AT A/1 .AT f /

or

(14.9.3)

We also have the specific forms n

nR nR o X X A A D Aki Akj D k i Cj T

ij

kDnL

(14.9.4)

kDnL

and n

T

A f

o j

D

nR X

Akj fk D

kDnL

nR X

k j fk

(14.9.5)

kDnL

Since the coefficient cn is the component a0 when f is replaced by the unit vector en , nL n < nR , we have M n n o o X cn D .AT A/1 .AT en / D .AT A/1 0

mD0

0m

nm

(14.9.6)

Equation (14.9.6) says that we need only one row of the inverse matrix. (Numerically we can get this by LU decomposition with only a single backsubstitution.) The function savgol, below, implements equation (14.9.6). As input, it takes the parameters nl D nL , nr D nR , and m D M (the desired order). Also input

i

i

i

i “nr3” — 2007/5/1 — 20:53 — page 769 — #791

i

769

14.9 Savitzky-Golay Smoothing Filters

Sample Savitzky-Golay Coefficients

M nL nR 2

2

2

2

3

1

2

4

0

2

5

5

4

4

4

5

i

0:086 0:343 0:486 0:343 0:086 0:143

0:171 0:343 0:371 0:257

0:086 0:143 0:086 0:257 0:886 0:084

0:021

0:103

0:161 0:196 0:207 0:196

0:161

0:103

0:021 0:084

4

0:035 0:128

0:070 0:315 0:417 0:315

0:070 0:128

5

0:042 0:105 0:023

0:140 0:280 0:333 0:280

0:140 0:023 0:105

0:035 0:042

is np, the physical length of the output array c, and a parameter ld that for data fitting should be zero. In fact, ld specifies which coefficient among the ai ’s should be returned, and we are here interested in a0 . For another purpose, namely the computation of numerical derivatives (already mentioned in 5.7), the useful choice is ld  1. With ld D 1, for example, the filtered first derivative is the convolution (14.9.1) divided by the stepsize . For ld D k > 1, the array c must be multiplied by kŠ to give derivative coefficients. For derivatives, one usually wants m D 4 or larger. void savgol(VecDoub_O &c, const Int np, const Int nl, const Int nr, const Int ld, const Int m) Returns in c[0..np-1], in wraparound order (N.B.!) consistent with the argument respns in routine convlv, a set of Savitzky-Golay filter coefficients. nl is the number of leftward (past) data points used, while nr is the number of rightward (future) data points, making the total number of data points used nl C nr C 1. ld is the order of the derivative desired (e.g., ld D 0 for smoothed function. For the derivative of order k, you must multiply the array c by kŠ.) m is the order of the smoothing polynomial, also equal to the highest conserved moment; usual values are m D 2 or m D 4. { Int j,k,imj,ipj,kk,mm; Doub fac,sum; if (np < nl+nr+1 || nl < 0 || nr < 0 || ld > m || nl+nr < m) throw("bad args in savgol"); VecInt indx(m+1); MatDoub a(m+1,m+1); VecDoub b(m+1); for (ipj=0;ipj