gsl-1.9: Fix documentation for new makeinfo version

11 files changed, 8759 insertions, 5706 deletions

diff --git a/gsl-1.9/doc/bspline.texi b/gsl-1.9/doc/bspline.texi
index 718e280..afe6ea1 100644
--- a/gsl-1.9/doc/bspline.texi
+++ b/gsl-1.9/doc/bspline.texi
@@ -149,7 +149,7 @@ Further information on the algorithms described in this section can be
 found in the following book,
 
 @itemize @asis
-C. de Boor, @cite{A Practical Guide to Splines} (1978), Springer-Verlag,
+@item C. de Boor, @cite{A Practical Guide to Splines} (1978), Springer-Verlag,
 ISBN 0-387-90356-9.
 @end itemize
 
diff --git a/gsl-1.9/doc/gsl-ref.info b/gsl-1.9/doc/gsl-ref.info
index 0423ca6..1a906a9 100644
--- a/gsl-1.9/doc/gsl-ref.info
+++ b/gsl-1.9/doc/gsl-ref.info
@@ -1,12 +1,7 @@
-This is gsl-ref.info, produced by makeinfo version 4.8 from
+This is gsl-ref.info, produced by makeinfo version 5.1 from
 gsl-ref.texi.
 
-INFO-DIR-SECTION Scientific software
-START-INFO-DIR-ENTRY
-* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
-END-INFO-DIR-ENTRY
-
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 2005, 2006, 2007 The GSL Team.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -20,577 +15,580 @@ License".
 
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
+INFO-DIR-SECTION Scientific software
+START-INFO-DIR-ENTRY
+* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
+END-INFO-DIR-ENTRY
 
 
 Indirect:
-gsl-ref.info-1: 939
-gsl-ref.info-2: 298842
-gsl-ref.info-3: 596860
-gsl-ref.info-4: 895867
-gsl-ref.info-5: 1072596
-gsl-ref.info-6: 1311271
+gsl-ref.info-1: 935
+gsl-ref.info-2: 301415
+gsl-ref.info-3: 603515
+gsl-ref.info-4: 901471
+gsl-ref.info-5: 1313050
 
 Tag Table:
 (Indirect)
-Node: Top939
-Node: Introduction3646
-Node: Routines available in GSL4298
-Node: GSL is Free Software6213
-Node: Obtaining GSL8605
-Node: No Warranty9746
-Node: Reporting Bugs10252
-Node: Further Information11136
-Node: Conventions used in this manual12149
-Node: Using the library12913
-Node: An Example Program13499
-Node: Compiling and Linking14203
-Node: Linking programs with the library15273
-Node: Linking with an alternative BLAS library16418
-Node: Shared Libraries17348
-Node: ANSI C Compliance18764
-Node: Inline functions19857
-Node: Long double20900
-Node: Portability functions22298
-Node: Alternative optimized functions23695
-Node: Support for different numeric types25153
-Node: Compatibility with C++28216
-Node: Aliasing of arrays28788
-Node: Thread-safety29539
-Node: Deprecated Functions30626
-Node: Code Reuse31251
-Node: Error Handling31895
-Node: Error Reporting32645
-Node: Error Codes34537
-Node: Error Handlers36393
-Node: Using GSL error reporting in your own functions40028
-Node: Error Reporting Examples41986
-Node: Mathematical Functions43190
-Node: Mathematical Constants43951
-Node: Infinities and Not-a-number45081
-Node: Elementary Functions46149
-Node: Small integer powers48404
-Node: Testing the Sign of Numbers49966
-Node: Testing for Odd and Even Numbers50397
-Node: Maximum and Minimum functions50953
-Node: Approximate Comparison of Floating Point Numbers53035
-Node: Complex Numbers54241
-Ref: Complex Numbers-Footnote-155549
-Node: Complex numbers55613
-Node: Properties of complex numbers57416
-Node: Complex arithmetic operators58403
-Node: Elementary Complex Functions61149
-Node: Complex Trigonometric Functions62969
-Node: Inverse Complex Trigonometric Functions64190
-Node: Complex Hyperbolic Functions66796
-Node: Inverse Complex Hyperbolic Functions68092
-Node: Complex Number References and Further Reading70080
-Node: Polynomials71476
-Node: Polynomial Evaluation72243
-Node: Divided Difference Representation of Polynomials72703
-Node: Quadratic Equations74372
-Node: Cubic Equations76312
-Node: General Polynomial Equations77683
-Node: Roots of Polynomials Examples80028
-Node: Roots of Polynomials References and Further Reading81417
-Node: Special Functions82362
-Node: Special Function Usage84356
-Node: The gsl_sf_result struct85539
-Node: Special Function Modes86803
-Node: Airy Functions and Derivatives87739
-Node: Airy Functions88435
-Node: Derivatives of Airy Functions89795
-Node: Zeros of Airy Functions91307
-Node: Zeros of Derivatives of Airy Functions92026
-Node: Bessel Functions92785
-Node: Regular Cylindrical Bessel Functions93977
-Node: Irregular Cylindrical Bessel Functions95301
-Node: Regular Modified Cylindrical Bessel Functions96757
-Node: Irregular Modified Cylindrical Bessel Functions99584
-Node: Regular Spherical Bessel Functions102552
-Node: Irregular Spherical Bessel Functions104764
-Node: Regular Modified Spherical Bessel Functions106451
-Node: Irregular Modified Spherical Bessel Functions108454
-Node: Regular Bessel Function - Fractional Order110517
-Node: Irregular Bessel Functions - Fractional Order111515
-Node: Regular Modified Bessel Functions - Fractional Order112097
-Node: Irregular Modified Bessel Functions - Fractional Order113022
-Node: Zeros of Regular Bessel Functions114258
-Node: Clausen Functions115361
-Node: Coulomb Functions115965
-Node: Normalized Hydrogenic Bound States116414
-Node: Coulomb Wave Functions117527
-Node: Coulomb Wave Function Normalization Constant120937
-Node: Coupling Coefficients121690
-Node: 3-j Symbols122413
-Node: 6-j Symbols123017
-Node: 9-j Symbols123641
-Node: Dawson Function124347
-Node: Debye Functions124914
-Node: Dilogarithm126688
-Node: Real Argument126983
-Node: Complex Argument127552
-Node: Elementary Operations128021
-Node: Elliptic Integrals128845
-Node: Definition of Legendre Forms129417
-Node: Definition of Carlson Forms130237
-Node: Legendre Form of Complete Elliptic Integrals130934
-Node: Legendre Form of Incomplete Elliptic Integrals132502
-Node: Carlson Forms134690
-Node: Elliptic Functions (Jacobi)136237
-Node: Error Functions136818
-Node: Error Function137269
-Node: Complementary Error Function137642
-Node: Log Complementary Error Function138102
-Node: Probability functions138554
-Node: Exponential Functions139807
-Node: Exponential Function140190
-Node: Relative Exponential Functions141413
-Node: Exponentiation With Error Estimate143084
-Node: Exponential Integrals144293
-Node: Exponential Integral144775
-Node: Ei(x)145425
-Node: Hyperbolic Integrals145873
-Node: Ei_3(x)146529
-Node: Trigonometric Integrals146921
-Node: Arctangent Integral147520
-Node: Fermi-Dirac Function147920
-Node: Complete Fermi-Dirac Integrals148290
-Node: Incomplete Fermi-Dirac Integrals150751
-Node: Gamma and Beta Functions151394
-Node: Gamma Functions151830
-Node: Factorials154951
-Node: Pochhammer Symbol157504
-Node: Incomplete Gamma Functions159016
-Node: Beta Functions160265
-Node: Incomplete Beta Function161017
-Node: Gegenbauer Functions161548
-Node: Hypergeometric Functions163198
-Node: Laguerre Functions167465
-Node: Lambert W Functions169028
-Node: Legendre Functions and Spherical Harmonics170066
-Node: Legendre Polynomials170655
-Node: Associated Legendre Polynomials and Spherical Harmonics172735
-Node: Conical Functions175536
-Node: Radial Functions for Hyperbolic Space177659
-Node: Logarithm and Related Functions179836
-Node: Mathieu Functions181460
-Node: Mathieu Function Workspace182809
-Node: Mathieu Function Characteristic Values183622
-Node: Angular Mathieu Functions184690
-Node: Radial Mathieu Functions185722
-Node: Power Function186960
-Node: Psi (Digamma) Function187887
-Node: Digamma Function188407
-Node: Trigamma Function189237
-Node: Polygamma Function189814
-Node: Synchrotron Functions190198
-Node: Transport Functions190961
-Node: Trigonometric Functions192108
-Node: Circular Trigonometric Functions192731
-Node: Trigonometric Functions for Complex Arguments193740
-Node: Hyperbolic Trigonometric Functions194774
-Node: Conversion Functions195377
-Node: Restriction Functions196160
-Node: Trigonometric Functions With Error Estimates197092
-Node: Zeta Functions198002
-Node: Riemann Zeta Function198460
-Node: Riemann Zeta Function Minus One199139
-Node: Hurwitz Zeta Function199910
-Node: Eta Function200415
-Node: Special Functions Examples200974
-Node: Special Functions References and Further Reading202668
-Node: Vectors and Matrices203775
-Node: Data types204534
-Node: Blocks205737
-Node: Block allocation206653
-Node: Reading and writing blocks208137
-Node: Example programs for blocks210201
-Node: Vectors210828
-Node: Vector allocation212714
-Node: Accessing vector elements214332
-Node: Initializing vector elements216574
-Node: Reading and writing vectors217268
-Node: Vector views219358
-Node: Copying vectors226800
-Node: Exchanging elements227660
-Node: Vector operations228218
-Node: Finding maximum and minimum elements of vectors229732
-Node: Vector properties231257
-Node: Example programs for vectors231880
-Node: Matrices234169
-Node: Matrix allocation237027
-Node: Accessing matrix elements238694
-Node: Initializing matrix elements240402
-Node: Reading and writing matrices241198
-Node: Matrix views243301
-Node: Creating row and column views250441
-Node: Copying matrices253612
-Node: Copying rows and columns254208
-Node: Exchanging rows and columns255885
-Node: Matrix operations257363
-Node: Finding maximum and minimum elements of matrices259003
-Node: Matrix properties260907
-Node: Example programs for matrices261655
-Node: Vector and Matrix References and Further Reading265726
-Node: Permutations266212
-Node: The Permutation struct267500
-Node: Permutation allocation268004
-Node: Accessing permutation elements269438
-Node: Permutation properties270201
-Node: Permutation functions270900
-Node: Applying Permutations272157
-Node: Reading and writing permutations274082
-Node: Permutations in cyclic form276264
-Node: Permutation Examples279689
-Node: Permutation References and Further Reading282232
-Node: Combinations282906
-Node: The Combination struct283751
-Node: Combination allocation284303
-Node: Accessing combination elements286088
-Node: Combination properties286667
-Node: Combination functions287553
-Node: Reading and writing combinations288493
-Node: Combination Examples290693
-Node: Combination References and Further Reading292001
-Node: Sorting292405
-Node: Sorting objects293355
-Node: Sorting vectors296266
-Node: Selecting the k smallest or largest elements298842
-Node: Computing the rank302176
-Node: Sorting Examples303377
-Node: Sorting References and Further Reading305021
-Node: BLAS Support305567
-Node: GSL BLAS Interface308542
-Node: Level 1 GSL BLAS Interface309029
-Node: Level 2 GSL BLAS Interface315772
-Node: Level 3 GSL BLAS Interface325066
-Node: BLAS Examples336202
-Node: BLAS References and Further Reading337623
-Node: Linear Algebra338982
-Node: LU Decomposition340164
-Node: QR Decomposition345372
-Node: QR Decomposition with Column Pivoting351174
-Node: Singular Value Decomposition355584
-Node: Cholesky Decomposition359174
-Node: Tridiagonal Decomposition of Real Symmetric Matrices361181
-Node: Tridiagonal Decomposition of Hermitian Matrices363029
-Node: Hessenberg Decomposition of Real Matrices364984
-Node: Bidiagonalization367329
-Node: Householder Transformations369739
-Node: Householder solver for linear systems371587
-Node: Tridiagonal Systems372492
-Node: Balancing375145
-Node: Linear Algebra Examples375946
-Node: Linear Algebra References and Further Reading377934
-Node: Eigensystems379424
-Node: Real Symmetric Matrices380603
-Node: Complex Hermitian Matrices382835
-Node: Real Nonsymmetric Matrices385343
-Node: Sorting Eigenvalues and Eigenvectors390537
-Node: Eigenvalue and Eigenvector Examples392404
-Node: Eigenvalue and Eigenvector References397790
-Node: Fast Fourier Transforms398498
-Node: Mathematical Definitions399707
-Node: Overview of complex data FFTs402112
-Node: Radix-2 FFT routines for complex data405055
-Node: Mixed-radix FFT routines for complex data409267
-Node: Overview of real data FFTs418596
-Node: Radix-2 FFT routines for real data421030
-Node: Mixed-radix FFT routines for real data424037
-Node: FFT References and Further Reading434617
-Node: Numerical Integration437486
-Node: Numerical Integration Introduction439031
-Node: Integrands without weight functions440965
-Node: Integrands with weight functions441794
-Node: Integrands with singular weight functions442505
-Node: QNG non-adaptive Gauss-Kronrod integration443423
-Node: QAG adaptive integration444694
-Node: QAGS adaptive integration with singularities447325
-Node: QAGP adaptive integration with known singular points449125
-Node: QAGI adaptive integration on infinite intervals450439
-Node: QAWC adaptive integration for Cauchy principal values452732
-Node: QAWS adaptive integration for singular functions453907
-Node: QAWO adaptive integration for oscillatory functions457129
-Node: QAWF adaptive integration for Fourier integrals460908
-Node: Numerical integration error codes463533
-Node: Numerical integration examples464301
-Node: Numerical integration References and Further Reading466346
-Node: Random Number Generation467075
-Node: General comments on random numbers468577
-Node: The Random Number Generator Interface470527
-Node: Random number generator initialization471885
-Node: Sampling from a random number generator473901
-Node: Auxiliary random number generator functions477066
-Node: Random number environment variables479386
-Node: Copying random number generator state481912
-Node: Reading and writing random number generator state482887
-Node: Random number generator algorithms484299
-Node: Unix random number generators494108
-Node: Other random number generators497826
-Node: Random Number Generator Performance506459
-Node: Random Number Generator Examples507777
-Node: Random Number References and Further Reading509333
-Node: Random Number Acknowledgements510630
-Node: Quasi-Random Sequences511116
-Node: Quasi-random number generator initialization512223
-Node: Sampling from a quasi-random number generator513238
-Node: Auxiliary quasi-random number generator functions513855
-Node: Saving and resorting quasi-random number generator state514801
-Node: Quasi-random number generator algorithms515609
-Node: Quasi-random number generator examples516384
-Node: Quasi-random number references517369
-Node: Random Number Distributions517895
-Node: Random Number Distribution Introduction521094
-Node: The Gaussian Distribution522889
-Node: The Gaussian Tail Distribution525551
-Node: The Bivariate Gaussian Distribution527220
-Node: The Exponential Distribution528543
-Node: The Laplace Distribution529682
-Node: The Exponential Power Distribution530779
-Node: The Cauchy Distribution532047
-Node: The Rayleigh Distribution533296
-Node: The Rayleigh Tail Distribution534468
-Node: The Landau Distribution535340
-Node: The Levy alpha-Stable Distributions536295
-Node: The Levy skew alpha-Stable Distribution537353
-Node: The Gamma Distribution538965
-Node: The Flat (Uniform) Distribution540622
-Node: The Lognormal Distribution541774
-Node: The Chi-squared Distribution543122
-Node: The F-distribution544526
-Node: The t-distribution546162
-Node: The Beta Distribution547556
-Node: The Logistic Distribution548715
-Node: The Pareto Distribution549844
-Node: Spherical Vector Distributions551014
-Node: The Weibull Distribution553848
-Node: The Type-1 Gumbel Distribution555042
-Node: The Type-2 Gumbel Distribution556279
-Node: The Dirichlet Distribution557510
-Node: General Discrete Distributions559178
-Node: The Poisson Distribution563043
-Node: The Bernoulli Distribution564051
-Node: The Binomial Distribution564802
-Node: The Multinomial Distribution566007
-Node: The Negative Binomial Distribution567776
-Node: The Pascal Distribution569141
-Node: The Geometric Distribution570299
-Node: The Hypergeometric Distribution571547
-Node: The Logarithmic Distribution573200
-Node: Shuffling and Sampling573991
-Node: Random Number Distribution Examples576810
-Node: Random Number Distribution References and Further Reading580006
-Node: Statistics582072
-Node: Mean and standard deviation and variance583351
-Node: Absolute deviation586396
-Node: Higher moments (skewness and kurtosis)587688
-Node: Autocorrelation589821
-Node: Covariance590635
-Node: Weighted Samples591616
-Node: Maximum and Minimum values596860
-Node: Median and Percentiles599599
-Node: Example statistical programs602014
-Node: Statistics References and Further Reading604673
-Node: Histograms605881
-Node: The histogram struct607641
-Node: Histogram allocation609444
-Node: Copying Histograms612405
-Node: Updating and accessing histogram elements613081
-Node: Searching histogram ranges616348
-Node: Histogram Statistics617347
-Node: Histogram Operations619207
-Node: Reading and writing histograms621279
-Node: Resampling from histograms624321
-Node: The histogram probability distribution struct625119
-Node: Example programs for histograms628150
-Node: Two dimensional histograms630213
-Node: The 2D histogram struct630934
-Node: 2D Histogram allocation632742
-Node: Copying 2D Histograms634813
-Node: Updating and accessing 2D histogram elements635518
-Node: Searching 2D histogram ranges639173
-Node: 2D Histogram Statistics640192
-Node: 2D Histogram Operations643051
-Node: Reading and writing 2D histograms645225
-Node: Resampling from 2D histograms648852
-Node: Example programs for 2D histograms651871
-Node: N-tuples653699
-Node: The ntuple struct654955
-Node: Creating ntuples655433
-Node: Opening an existing ntuple file656100
-Node: Writing ntuples656728
-Node: Reading ntuples657189
-Node: Closing an ntuple file657520
-Node: Histogramming ntuple values657860
-Node: Example ntuple programs659866
-Node: Ntuple References and Further Reading663195
-Node: Monte Carlo Integration663516
-Node: Monte Carlo Interface664761
-Node: PLAIN Monte Carlo667384
-Node: MISER669822
-Node: VEGAS675660
-Node: Monte Carlo Examples683995
-Node: Monte Carlo Integration References and Further Reading689938
-Node: Simulated Annealing690720
-Node: Simulated Annealing algorithm691927
-Node: Simulated Annealing functions693081
-Node: Examples with Simulated Annealing697607
-Node: Trivial example698161
-Node: Traveling Salesman Problem700812
-Node: Simulated Annealing References and Further Reading704125
-Node: Ordinary Differential Equations704536
-Node: Defining the ODE System705357
-Node: Stepping Functions707549
-Node: Adaptive Step-size Control711728
-Node: Evolution717186
-Node: ODE Example programs719864
-Node: ODE References and Further Reading724934
-Node: Interpolation725573
-Node: Introduction to Interpolation726586
-Node: Interpolation Functions727027
-Node: Interpolation Types728203
-Node: Index Look-up and Acceleration730813
-Node: Evaluation of Interpolating Functions732443
-Node: Higher-level Interface734827
-Node: Interpolation Example programs736866
-Node: Interpolation References and Further Reading740113
-Node: Numerical Differentiation740686
-Node: Numerical Differentiation functions741275
-Node: Numerical Differentiation Examples744133
-Node: Numerical Differentiation References745546
-Node: Chebyshev Approximations746097
-Node: Chebyshev Definitions747113
-Node: Creation and Calculation of Chebyshev Series747903
-Node: Chebyshev Series Evaluation748875
-Node: Derivatives and Integrals750259
-Node: Chebyshev Approximation examples751501
-Node: Chebyshev Approximation References and Further Reading752997
-Node: Series Acceleration753446
-Node: Acceleration functions754211
-Node: Acceleration functions without error estimation756536
-Node: Example of accelerating a series759146
-Node: Series Acceleration References761492
-Node: Wavelet Transforms762380
-Node: DWT Definitions762921
-Node: DWT Initialization763873
-Node: DWT Transform Functions766452
-Node: DWT in one dimension766987
-Node: DWT in two dimension769006
-Node: DWT Examples773607
-Node: DWT References775424
-Node: Discrete Hankel Transforms777587
-Node: Discrete Hankel Transform Definition778055
-Node: Discrete Hankel Transform Functions780194
-Node: Discrete Hankel Transform References781725
-Node: One dimensional Root-Finding782129
-Node: Root Finding Overview783389
-Node: Root Finding Caveats785247
-Node: Initializing the Solver787014
-Node: Providing the function to solve789647
-Node: Search Bounds and Guesses793413
-Node: Root Finding Iteration794274
-Node: Search Stopping Parameters796123
-Node: Root Bracketing Algorithms798637
-Node: Root Finding Algorithms using Derivatives801935
-Node: Root Finding Examples805438
-Node: Root Finding References and Further Reading812726
-Node: One dimensional Minimization813365
-Node: Minimization Overview814667
-Node: Minimization Caveats816373
-Node: Initializing the Minimizer817710
-Node: Providing the function to minimize819951
-Node: Minimization Iteration820429
-Node: Minimization Stopping Parameters822565
-Node: Minimization Algorithms824174
-Node: Minimization Examples826613
-Node: Minimization References and Further Reading829557
-Node: Multidimensional Root-Finding830013
-Node: Overview of Multidimensional Root Finding831502
-Node: Initializing the Multidimensional Solver833689
-Node: Providing the multidimensional system of equations to solve836887
-Node: Iteration of the multidimensional solver841792
-Node: Search Stopping Parameters for the multidimensional solver843977
-Node: Algorithms using Derivatives845714
-Node: Algorithms without Derivatives850460
-Node: Example programs for Multidimensional Root finding853548
-Node: References and Further Reading for Multidimensional Root Finding862161
-Node: Multidimensional Minimization863400
-Node: Multimin Overview864692
-Node: Multimin Caveats866664
-Node: Initializing the Multidimensional Minimizer867413
-Node: Providing a function to minimize870574
-Node: Multimin Iteration874239
-Node: Multimin Stopping Criteria876230
-Node: Multimin Algorithms877782
-Node: Multimin Examples882741
-Node: Multimin References and Further Reading889358
-Node: Least-Squares Fitting890221
-Node: Fitting Overview891220
-Node: Linear regression893436
-Node: Linear fitting without a constant term895867
-Node: Multi-parameter fitting898058
-Node: Fitting Examples902963
-Node: Fitting References and Further Reading909788
-Node: Nonlinear Least-Squares Fitting910610
-Node: Overview of Nonlinear Least-Squares Fitting912060
-Node: Initializing the Nonlinear Least-Squares Solver913527
-Node: Providing the Function to be Minimized916380
-Node: Iteration of the Minimization Algorithm919317
-Node: Search Stopping Parameters for Minimization Algorithms921167
-Node: Minimization Algorithms using Derivatives923262
-Node: Minimization Algorithms without Derivatives926510
-Node: Computing the covariance matrix of best fit parameters926902
-Node: Example programs for Nonlinear Least-Squares Fitting928936
-Node: References and Further Reading for Nonlinear Least-Squares Fitting936664
-Node: Basis Splines937400
-Node: Overview of B-splines937975
-Node: Initializing the B-splines solver939260
-Node: Constructing the knots vector940003
-Node: Evaluation of B-spline basis functions940790
-Node: Example programs for B-splines941523
-Node: References and Further Reading945220
-Node: Physical Constants945734
-Node: Fundamental Constants947144
-Node: Astronomy and Astrophysics948283
-Node: Atomic and Nuclear Physics948948
-Node: Measurement of Time950585
-Node: Imperial Units951015
-Node: Speed and Nautical Units951457
-Node: Printers Units951961
-Node: Volume Area and Length952284
-Node: Mass and Weight952970
-Node: Thermal Energy and Power953789
-Node: Pressure954212
-Node: Viscosity954825
-Node: Light and Illumination955101
-Node: Radioactivity955693
-Node: Force and Energy956028
-Node: Prefixes956432
-Node: Physical Constant Examples957175
-Node: Physical Constant References and Further Reading958964
-Node: IEEE floating-point arithmetic959675
-Node: Representation of floating point numbers960261
-Node: Setting up your IEEE environment964742
-Node: IEEE References and Further Reading971351
-Node: Debugging Numerical Programs972506
-Node: Using gdb972990
-Node: Examining floating point registers976333
-Node: Handling floating point exceptions977618
-Node: GCC warning options for numerical programs979030
-Node: Debugging References983223
-Node: Contributors to GSL983935
-Node: Autoconf Macros988118
-Node: GSL CBLAS Library992103
-Node: Level 1 CBLAS Functions992630
-Node: Level 2 CBLAS Functions997932
-Node: Level 3 CBLAS Functions1014602
-Node: GSL CBLAS Examples1024264
-Node: Free Software Needs Free Documentation1025826
-Node: GNU General Public License1030895
-Node: GNU Free Documentation License1050165
-Node: Function Index1072596
-Node: Variable Index1306453
-Node: Type Index1307625
-Node: Concept Index1311271
+Node: Top935
+Node: Introduction4107
+Node: Routines available in GSL4827
+Node: GSL is Free Software6407
+Node: Obtaining GSL8799
+Node: No Warranty9941
+Node: Reporting Bugs10447
+Node: Further Information11327
+Node: Conventions used in this manual12341
+Node: Using the library13105
+Node: An Example Program13828
+Node: Compiling and Linking14532
+Node: Linking programs with the library15605
+Node: Linking with an alternative BLAS library16750
+Node: Shared Libraries17681
+Node: ANSI C Compliance19097
+Node: Inline functions20190
+Node: Long double21234
+Node: Portability functions22632
+Node: Alternative optimized functions24030
+Node: Support for different numeric types25488
+Node: Compatibility with C++28552
+Node: Aliasing of arrays29124
+Node: Thread-safety29875
+Node: Deprecated Functions30963
+Node: Code Reuse31588
+Node: Error Handling32233
+Node: Error Reporting33033
+Node: Error Codes34925
+Node: Error Handlers36782
+Node: Using GSL error reporting in your own functions40420
+Node: Error Reporting Examples42380
+Node: Mathematical Functions43584
+Node: Mathematical Constants44377
+Node: Infinities and Not-a-number45507
+Node: Elementary Functions46578
+Node: Small integer powers48843
+Node: Testing the Sign of Numbers50407
+Node: Testing for Odd and Even Numbers50840
+Node: Maximum and Minimum functions51399
+Node: Approximate Comparison of Floating Point Numbers53487
+Node: Complex Numbers54694
+Ref: Complex Numbers-Footnote-156032
+Node: Complex numbers56096
+Node: Properties of complex numbers57902
+Node: Complex arithmetic operators58890
+Node: Elementary Complex Functions61636
+Node: Complex Trigonometric Functions63460
+Node: Inverse Complex Trigonometric Functions64681
+Node: Complex Hyperbolic Functions67294
+Node: Inverse Complex Hyperbolic Functions68590
+Node: Complex Number References and Further Reading70578
+Node: Polynomials71974
+Node: Polynomial Evaluation72778
+Node: Divided Difference Representation of Polynomials73238
+Node: Quadratic Equations74897
+Node: Cubic Equations76834
+Node: General Polynomial Equations78205
+Node: Roots of Polynomials Examples80562
+Node: Roots of Polynomials References and Further Reading81951
+Node: Special Functions82896
+Node: Special Function Usage85144
+Node: The gsl_sf_result struct86328
+Node: Special Function Modes87592
+Node: Airy Functions and Derivatives88526
+Node: Airy Functions89246
+Node: Derivatives of Airy Functions90606
+Node: Zeros of Airy Functions92118
+Node: Zeros of Derivatives of Airy Functions92837
+Node: Bessel Functions93596
+Node: Regular Cylindrical Bessel Functions94814
+Node: Irregular Cylindrical Bessel Functions96138
+Node: Regular Modified Cylindrical Bessel Functions97594
+Node: Irregular Modified Cylindrical Bessel Functions100422
+Node: Regular Spherical Bessel Functions103395
+Node: Irregular Spherical Bessel Functions105606
+Node: Regular Modified Spherical Bessel Functions107292
+Node: Irregular Modified Spherical Bessel Functions109293
+Node: Regular Bessel Function - Fractional Order111356
+Node: Irregular Bessel Functions - Fractional Order112354
+Node: Regular Modified Bessel Functions - Fractional Order112936
+Node: Irregular Modified Bessel Functions - Fractional Order113861
+Node: Zeros of Regular Bessel Functions115097
+Node: Clausen Functions116200
+Node: Coulomb Functions116804
+Node: Normalized Hydrogenic Bound States117263
+Node: Coulomb Wave Functions118376
+Node: Coulomb Wave Function Normalization Constant121788
+Node: Coupling Coefficients122541
+Node: 3-j Symbols123315
+Node: 6-j Symbols123919
+Node: 9-j Symbols124543
+Node: Dawson Function125249
+Node: Debye Functions125816
+Node: Dilogarithm127590
+Node: Real Argument127912
+Node: Complex Argument128481
+Node: Elementary Operations128951
+Node: Elliptic Integrals129775
+Node: Definition of Legendre Forms130370
+Node: Definition of Carlson Forms131190
+Node: Legendre Form of Complete Elliptic Integrals131887
+Node: Legendre Form of Incomplete Elliptic Integrals133440
+Node: Carlson Forms135627
+Node: Elliptic Functions (Jacobi)137174
+Node: Error Functions137755
+Node: Error Function138231
+Node: Complementary Error Function138604
+Node: Log Complementary Error Function139064
+Node: Probability functions139516
+Node: Exponential Functions140769
+Node: Exponential Function141164
+Node: Relative Exponential Functions142386
+Node: Exponentiation With Error Estimate144057
+Node: Exponential Integrals145266
+Node: Exponential Integral145822
+Node: Ei(x)146468
+Node: Hyperbolic Integrals146916
+Node: Ei_3(x)147571
+Node: Trigonometric Integrals147963
+Node: Arctangent Integral148562
+Node: Fermi-Dirac Function148962
+Node: Complete Fermi-Dirac Integrals149336
+Node: Incomplete Fermi-Dirac Integrals151797
+Node: Gamma and Beta Functions152440
+Node: Gamma Functions152937
+Node: Factorials156057
+Node: Pochhammer Symbol158610
+Node: Incomplete Gamma Functions160123
+Node: Beta Functions161372
+Node: Incomplete Beta Function162124
+Node: Gegenbauer Functions162655
+Node: Hypergeometric Functions164305
+Node: Laguerre Functions168573
+Node: Lambert W Functions170136
+Node: Legendre Functions and Spherical Harmonics171176
+Node: Legendre Polynomials171788
+Node: Associated Legendre Polynomials and Spherical Harmonics173869
+Node: Conical Functions176671
+Node: Radial Functions for Hyperbolic Space178794
+Node: Logarithm and Related Functions180971
+Node: Mathieu Functions182595
+Node: Mathieu Function Workspace183955
+Node: Mathieu Function Characteristic Values184767
+Node: Angular Mathieu Functions185835
+Node: Radial Mathieu Functions186867
+Node: Power Function188100
+Node: Psi (Digamma) Function189028
+Node: Digamma Function189581
+Node: Trigamma Function190411
+Node: Polygamma Function190988
+Node: Synchrotron Functions191372
+Node: Transport Functions192135
+Node: Trigonometric Functions193282
+Node: Circular Trigonometric Functions193928
+Node: Trigonometric Functions for Complex Arguments194937
+Node: Hyperbolic Trigonometric Functions195971
+Node: Conversion Functions196574
+Node: Restriction Functions197357
+Node: Trigonometric Functions With Error Estimates198288
+Node: Zeta Functions199198
+Node: Riemann Zeta Function199656
+Node: Riemann Zeta Function Minus One200335
+Node: Hurwitz Zeta Function201106
+Node: Eta Function201611
+Node: Special Functions Examples202170
+Node: Special Functions References and Further Reading203865
+Node: Vectors and Matrices204970
+Node: Data types205813
+Node: Blocks207016
+Node: Block allocation207949
+Node: Reading and writing blocks209433
+Node: Example programs for blocks211497
+Node: Vectors212124
+Node: Vector allocation214092
+Node: Accessing vector elements215711
+Node: Initializing vector elements217951
+Node: Reading and writing vectors218645
+Node: Vector views220735
+Node: Copying vectors228201
+Node: Exchanging elements229061
+Node: Vector operations229619
+Node: Finding maximum and minimum elements of vectors231137
+Node: Vector properties232663
+Node: Example programs for vectors233286
+Node: Matrices235575
+Node: Matrix allocation238515
+Node: Accessing matrix elements240183
+Node: Initializing matrix elements241891
+Node: Reading and writing matrices242688
+Node: Matrix views244791
+Node: Creating row and column views251927
+Node: Copying matrices255103
+Node: Copying rows and columns255699
+Node: Exchanging rows and columns257376
+Node: Matrix operations258854
+Node: Finding maximum and minimum elements of matrices260498
+Node: Matrix properties262398
+Node: Example programs for matrices263147
+Node: Vector and Matrix References and Further Reading267218
+Node: Permutations267704
+Node: The Permutation struct269041
+Node: Permutation allocation269544
+Node: Accessing permutation elements270980
+Node: Permutation properties271743
+Node: Permutation functions272442
+Node: Applying Permutations273699
+Node: Reading and writing permutations275626
+Node: Permutations in cyclic form277808
+Node: Permutation Examples281235
+Node: Permutation References and Further Reading283778
+Node: Combinations284452
+Node: The Combination struct285335
+Node: Combination allocation285886
+Node: Accessing combination elements287673
+Node: Combination properties288252
+Node: Combination functions289138
+Node: Reading and writing combinations290078
+Node: Combination Examples292277
+Node: Combination References and Further Reading293585
+Node: Sorting293988
+Node: Sorting objects294990
+Node: Sorting vectors297903
+Node: Selecting the k smallest or largest elements301415
+Node: Computing the rank304756
+Node: Sorting Examples305957
+Node: Sorting References and Further Reading307601
+Node: BLAS Support308147
+Node: GSL BLAS Interface311132
+Node: Level 1 GSL BLAS Interface311625
+Node: Level 2 GSL BLAS Interface318369
+Node: Level 3 GSL BLAS Interface327656
+Node: BLAS Examples338750
+Node: BLAS References and Further Reading340171
+Node: Linear Algebra341525
+Node: LU Decomposition342776
+Node: QR Decomposition347976
+Node: QR Decomposition with Column Pivoting353784
+Node: Singular Value Decomposition358203
+Node: Cholesky Decomposition361798
+Node: Tridiagonal Decomposition of Real Symmetric Matrices363808
+Node: Tridiagonal Decomposition of Hermitian Matrices365656
+Node: Hessenberg Decomposition of Real Matrices367611
+Node: Bidiagonalization369963
+Node: Householder Transformations372373
+Node: Householder solver for linear systems374221
+Node: Tridiagonal Systems375128
+Node: Balancing377782
+Node: Linear Algebra Examples378585
+Node: Linear Algebra References and Further Reading380574
+Node: Eigensystems382064
+Node: Real Symmetric Matrices383265
+Node: Complex Hermitian Matrices385497
+Node: Real Nonsymmetric Matrices388007
+Node: Sorting Eigenvalues and Eigenvectors393222
+Node: Eigenvalue and Eigenvector Examples395089
+Node: Eigenvalue and Eigenvector References400479
+Node: Fast Fourier Transforms401187
+Node: Mathematical Definitions402413
+Node: Overview of complex data FFTs404818
+Node: Radix-2 FFT routines for complex data407763
+Node: Mixed-radix FFT routines for complex data411982
+Node: Overview of real data FFTs421315
+Node: Radix-2 FFT routines for real data423750
+Node: Mixed-radix FFT routines for real data426751
+Node: FFT References and Further Reading437340
+Node: Numerical Integration440210
+Node: Numerical Integration Introduction441783
+Node: Integrands without weight functions443723
+Node: Integrands with weight functions444553
+Node: Integrands with singular weight functions445264
+Node: QNG non-adaptive Gauss-Kronrod integration446182
+Node: QAG adaptive integration447454
+Node: QAGS adaptive integration with singularities450097
+Node: QAGP adaptive integration with known singular points451897
+Node: QAGI adaptive integration on infinite intervals453211
+Node: QAWC adaptive integration for Cauchy principal values455491
+Node: QAWS adaptive integration for singular functions456661
+Node: QAWO adaptive integration for oscillatory functions459888
+Node: QAWF adaptive integration for Fourier integrals463677
+Node: Numerical integration error codes466301
+Node: Numerical integration examples467066
+Node: Numerical integration References and Further Reading469111
+Node: Random Number Generation469839
+Node: General comments on random numbers471373
+Node: The Random Number Generator Interface473325
+Node: Random number generator initialization474683
+Node: Sampling from a random number generator476698
+Node: Auxiliary random number generator functions479863
+Node: Random number environment variables482183
+Node: Copying random number generator state484708
+Node: Reading and writing random number generator state485682
+Node: Random number generator algorithms487094
+Node: Unix random number generators496909
+Node: Other random number generators500623
+Node: Random Number Generator Performance509260
+Node: Random Number Generator Examples510578
+Node: Random Number References and Further Reading512134
+Node: Random Number Acknowledgements513429
+Node: Quasi-Random Sequences513915
+Node: Quasi-random number generator initialization515035
+Node: Sampling from a quasi-random number generator516050
+Node: Auxiliary quasi-random number generator functions516667
+Node: Saving and resorting quasi-random number generator state517613
+Node: Quasi-random number generator algorithms518421
+Node: Quasi-random number generator examples519198
+Node: Quasi-random number references520183
+Node: Random Number Distributions520709
+Node: Random Number Distribution Introduction524040
+Node: The Gaussian Distribution525835
+Node: The Gaussian Tail Distribution528496
+Node: The Bivariate Gaussian Distribution530160
+Node: The Exponential Distribution531474
+Node: The Laplace Distribution532613
+Node: The Exponential Power Distribution533705
+Node: The Cauchy Distribution534973
+Node: The Rayleigh Distribution536222
+Node: The Rayleigh Tail Distribution537394
+Node: The Landau Distribution538267
+Node: The Levy alpha-Stable Distributions539222
+Node: The Levy skew alpha-Stable Distribution540280
+Node: The Gamma Distribution541892
+Node: The Flat (Uniform) Distribution543547
+Node: The Lognormal Distribution544695
+Node: The Chi-squared Distribution546043
+Node: The F-distribution547448
+Node: The t-distribution549085
+Node: The Beta Distribution550479
+Node: The Logistic Distribution551638
+Node: The Pareto Distribution552767
+Node: Spherical Vector Distributions553937
+Node: The Weibull Distribution556773
+Node: The Type-1 Gumbel Distribution557967
+Node: The Type-2 Gumbel Distribution559203
+Node: The Dirichlet Distribution560434
+Node: General Discrete Distributions562103
+Node: The Poisson Distribution565969
+Node: The Bernoulli Distribution566976
+Node: The Binomial Distribution567727
+Node: The Multinomial Distribution568930
+Node: The Negative Binomial Distribution570704
+Node: The Pascal Distribution572069
+Node: The Geometric Distribution573227
+Node: The Hypergeometric Distribution574475
+Node: The Logarithmic Distribution576128
+Node: Shuffling and Sampling576920
+Node: Random Number Distribution Examples579732
+Node: Random Number Distribution References and Further Reading582928
+Node: Statistics584995
+Node: Mean and standard deviation and variance586343
+Node: Absolute deviation589388
+Node: Higher moments (skewness and kurtosis)590680
+Node: Autocorrelation592813
+Node: Covariance593626
+Node: Weighted Samples594597
+Node: Maximum and Minimum values599841
+Node: Median and Percentiles603515
+Node: Example statistical programs605930
+Node: Statistics References and Further Reading608589
+Node: Histograms609797
+Node: The histogram struct611650
+Node: Histogram allocation613454
+Node: Copying Histograms616411
+Node: Updating and accessing histogram elements617087
+Node: Searching histogram ranges620356
+Node: Histogram Statistics621356
+Node: Histogram Operations623222
+Node: Reading and writing histograms625297
+Node: Resampling from histograms628339
+Node: The histogram probability distribution struct629138
+Node: Example programs for histograms632172
+Node: Two dimensional histograms634235
+Node: The 2D histogram struct634956
+Node: 2D Histogram allocation636766
+Node: Copying 2D Histograms638840
+Node: Updating and accessing 2D histogram elements639545
+Node: Searching 2D histogram ranges643202
+Node: 2D Histogram Statistics644223
+Node: 2D Histogram Operations647088
+Node: Reading and writing 2D histograms649266
+Node: Resampling from 2D histograms652893
+Node: Example programs for 2D histograms655914
+Node: N-tuples657741
+Node: The ntuple struct659064
+Node: Creating ntuples659543
+Node: Opening an existing ntuple file660210
+Node: Writing ntuples660839
+Node: Reading ntuples661300
+Node: Closing an ntuple file661631
+Node: Histogramming ntuple values661971
+Node: Example ntuple programs663979
+Node: Ntuple References and Further Reading667308
+Node: Monte Carlo Integration667629
+Node: Monte Carlo Interface668940
+Node: PLAIN Monte Carlo671567
+Node: MISER674006
+Node: VEGAS679849
+Node: Monte Carlo Examples688194
+Node: Monte Carlo Integration References and Further Reading694139
+Node: Simulated Annealing694921
+Node: Simulated Annealing algorithm696137
+Node: Simulated Annealing functions697289
+Node: Examples with Simulated Annealing701810
+Node: Trivial example702379
+Node: Traveling Salesman Problem705030
+Node: Simulated Annealing References and Further Reading708343
+Node: Ordinary Differential Equations708754
+Node: Defining the ODE System709621
+Node: Stepping Functions711817
+Node: Adaptive Step-size Control715998
+Node: Evolution721460
+Node: ODE Example programs724139
+Node: ODE References and Further Reading729209
+Node: Interpolation729848
+Node: Introduction to Interpolation730891
+Node: Interpolation Functions731332
+Node: Interpolation Types732508
+Node: Index Look-up and Acceleration735117
+Node: Evaluation of Interpolating Functions736747
+Node: Higher-level Interface739131
+Node: Interpolation Example programs741171
+Node: Interpolation References and Further Reading744422
+Node: Numerical Differentiation744994
+Node: Numerical Differentiation functions745589
+Node: Numerical Differentiation Examples748446
+Node: Numerical Differentiation References749859
+Node: Chebyshev Approximations750410
+Node: Chebyshev Definitions751444
+Node: Creation and Calculation of Chebyshev Series752233
+Node: Chebyshev Series Evaluation753205
+Node: Derivatives and Integrals754589
+Node: Chebyshev Approximation examples755827
+Node: Chebyshev Approximation References and Further Reading757323
+Node: Series Acceleration757773
+Node: Acceleration functions758550
+Node: Acceleration functions without error estimation760877
+Node: Example of accelerating a series763501
+Node: Series Acceleration References765847
+Node: Wavelet Transforms766735
+Node: DWT Definitions767334
+Node: DWT Initialization768286
+Node: DWT Transform Functions770863
+Node: DWT in one dimension771414
+Node: DWT in two dimension773435
+Node: DWT Examples778037
+Node: DWT References779854
+Node: Discrete Hankel Transforms782018
+Node: Discrete Hankel Transform Definition782492
+Node: Discrete Hankel Transform Functions784635
+Node: Discrete Hankel Transform References786167
+Node: One dimensional Root-Finding786571
+Node: Root Finding Overview787877
+Node: Root Finding Caveats789733
+Node: Initializing the Solver791502
+Node: Providing the function to solve794135
+Node: Search Bounds and Guesses797907
+Node: Root Finding Iteration798768
+Node: Search Stopping Parameters800619
+Node: Root Bracketing Algorithms803130
+Node: Root Finding Algorithms using Derivatives806428
+Node: Root Finding Examples809932
+Node: Root Finding References and Further Reading817220
+Node: One dimensional Minimization817859
+Node: Minimization Overview819202
+Node: Minimization Caveats820909
+Node: Initializing the Minimizer822247
+Node: Providing the function to minimize824488
+Node: Minimization Iteration824966
+Node: Minimization Stopping Parameters827104
+Node: Minimization Algorithms828709
+Node: Minimization Examples831138
+Node: Minimization References and Further Reading834082
+Node: Multidimensional Root-Finding834538
+Node: Overview of Multidimensional Root Finding836046
+Node: Initializing the Multidimensional Solver838233
+Node: Providing the multidimensional system of equations to solve841431
+Node: Iteration of the multidimensional solver846346
+Node: Search Stopping Parameters for the multidimensional solver848533
+Node: Algorithms using Derivatives850271
+Node: Algorithms without Derivatives855013
+Node: Example programs for Multidimensional Root finding858103
+Node: References and Further Reading for Multidimensional Root Finding866727
+Node: Multidimensional Minimization867966
+Node: Multimin Overview869300
+Node: Multimin Caveats871275
+Node: Initializing the Multidimensional Minimizer872024
+Node: Providing a function to minimize875184
+Node: Multimin Iteration878858
+Node: Multimin Stopping Criteria880844
+Node: Multimin Algorithms882398
+Node: Multimin Examples887363
+Node: Multimin References and Further Reading893984
+Node: Least-Squares Fitting894846
+Node: Fitting Overview895890
+Node: Linear regression898105
+Node: Linear fitting without a constant term901471
+Node: Multi-parameter fitting903663
+Node: Fitting Examples908571
+Node: Fitting References and Further Reading915396
+Node: Nonlinear Least-Squares Fitting916219
+Node: Overview of Nonlinear Least-Squares Fitting917688
+Node: Initializing the Nonlinear Least-Squares Solver919155
+Node: Providing the Function to be Minimized922008
+Node: Iteration of the Minimization Algorithm924954
+Node: Search Stopping Parameters for Minimization Algorithms926806
+Node: Minimization Algorithms using Derivatives928903
+Node: Minimization Algorithms without Derivatives932153
+Node: Computing the covariance matrix of best fit parameters932545
+Node: Example programs for Nonlinear Least-Squares Fitting934580
+Node: References and Further Reading for Nonlinear Least-Squares Fitting942311
+Node: Basis Splines943047
+Node: Overview of B-splines943623
+Node: Initializing the B-splines solver944919
+Node: Constructing the knots vector945666
+Node: Evaluation of B-spline basis functions946454
+Node: Example programs for B-splines947189
+Node: References and Further Reading950891
+Node: Physical Constants951405
+Node: Fundamental Constants952984
+Node: Astronomy and Astrophysics954124
+Node: Atomic and Nuclear Physics954789
+Node: Measurement of Time956426
+Node: Imperial Units956856
+Node: Speed and Nautical Units957298
+Node: Printers Units957802
+Node: Volume Area and Length958125
+Node: Mass and Weight958811
+Node: Thermal Energy and Power959630
+Node: Pressure960053
+Node: Viscosity960666
+Node: Light and Illumination960942
+Node: Radioactivity961534
+Node: Force and Energy961869
+Node: Prefixes962273
+Node: Physical Constant Examples963016
+Node: Physical Constant References and Further Reading964805
+Node: IEEE floating-point arithmetic965514
+Node: Representation of floating point numbers966106
+Node: Setting up your IEEE environment970592
+Node: IEEE References and Further Reading977182
+Node: Debugging Numerical Programs978342
+Node: Using gdb978859
+Node: Examining floating point registers982202
+Node: Handling floating point exceptions983487
+Node: GCC warning options for numerical programs984899
+Node: Debugging References989077
+Node: Contributors to GSL989789
+Node: Autoconf Macros993971
+Node: GSL CBLAS Library997959
+Node: Level 1 CBLAS Functions998511
+Node: Level 2 CBLAS Functions1003813
+Node: Level 3 CBLAS Functions1020443
+Node: GSL CBLAS Examples1030105
+Node: Free Software Needs Free Documentation1031668
+Node: GNU General Public License1036736
+Node: GNU Free Documentation License1056005
+Node: Function Index1078417
+Node: Variable Index1313050
+Node: Type Index1314222
+Node: Concept Index1317868
 
 End Tag Table
diff --git a/gsl-1.9/doc/gsl-ref.info-1 b/gsl-1.9/doc/gsl-ref.info-1
index 2d4e483..1f72f0e 100644
--- a/gsl-1.9/doc/gsl-ref.info-1
+++ b/gsl-1.9/doc/gsl-ref.info-1
@@ -1,12 +1,7 @@
-This is gsl-ref.info, produced by makeinfo version 4.8 from
+This is gsl-ref.info, produced by makeinfo version 5.1 from
 gsl-ref.texi.
 
-INFO-DIR-SECTION Scientific software
-START-INFO-DIR-ENTRY
-* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
-END-INFO-DIR-ENTRY
-
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 2005, 2006, 2007 The GSL Team.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -20,6 +15,10 @@ License".
 
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
+INFO-DIR-SECTION Scientific software
+START-INFO-DIR-ENTRY
+* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
+END-INFO-DIR-ENTRY
 
 
 File: gsl-ref.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)
@@ -33,10 +32,10 @@ numerical routines for scientific computing.  It corresponds to release
 <bug-gsl@gnu.org>.
 
    More information about GSL can be found at the project homepage,
-`http://www.gnu.org/software/gsl/'.
+<http://www.gnu.org/software/gsl/>.
 
    Printed copies of this manual can be purchased from Network Theory
-Ltd at `http://www.network-theory.co.uk/gsl/manual/'. The money raised
+Ltd at <http://www.network-theory.co.uk/gsl/manual/>.  The money raised
 from sales of the manual helps support the development of GSL.
 
    A Japanese translation of this manual is available from the GSL
@@ -57,60 +56,59 @@ License".
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
 
-
 * Menu:
 
-* Introduction::
-* Using the library::
-* Error Handling::
-* Mathematical Functions::
-* Complex Numbers::
-* Polynomials::
-* Special Functions::
-* Vectors and Matrices::
-* Permutations::
-* Combinations::
-* Sorting::
-* BLAS Support::
-* Linear Algebra::
-* Eigensystems::
-* Fast Fourier Transforms::
-* Numerical Integration::
-* Random Number Generation::
-* Quasi-Random Sequences::
-* Random Number Distributions::
-* Statistics::
-* Histograms::
-* N-tuples::
-* Monte Carlo Integration::
-* Simulated Annealing::
-* Ordinary Differential Equations::
-* Interpolation::
-* Numerical Differentiation::
-* Chebyshev Approximations::
-* Series Acceleration::
-* Wavelet Transforms::
-* Discrete Hankel Transforms::
-* One dimensional Root-Finding::
-* One dimensional Minimization::
-* Multidimensional Root-Finding::
-* Multidimensional Minimization::
-* Least-Squares Fitting::
-* Nonlinear Least-Squares Fitting::
+* Introduction::                
+* Using the library::           
+* Error Handling::              
+* Mathematical Functions::      
+* Complex Numbers::             
+* Polynomials::                 
+* Special Functions::           
+* Vectors and Matrices::        
+* Permutations::                
+* Combinations::                
+* Sorting::                     
+* BLAS Support::                
+* Linear Algebra::              
+* Eigensystems::                
+* Fast Fourier Transforms::     
+* Numerical Integration::       
+* Random Number Generation::    
+* Quasi-Random Sequences::      
+* Random Number Distributions::  
+* Statistics::                  
+* Histograms::                  
+* N-tuples::                    
+* Monte Carlo Integration::     
+* Simulated Annealing::         
+* Ordinary Differential Equations::  
+* Interpolation::               
+* Numerical Differentiation::   
+* Chebyshev Approximations::    
+* Series Acceleration::         
+* Wavelet Transforms::          
+* Discrete Hankel Transforms::  
+* One dimensional Root-Finding::  
+* One dimensional Minimization::  
+* Multidimensional Root-Finding::  
+* Multidimensional Minimization::  
+* Least-Squares Fitting::       
+* Nonlinear Least-Squares Fitting::  
 * Basis Splines::
-* Physical Constants::
-* IEEE floating-point arithmetic::
-* Debugging Numerical Programs::
-* Contributors to GSL::
-* Autoconf Macros::
-* GSL CBLAS Library::
-* Free Software Needs Free Documentation::
-* GNU General Public License::
-* GNU Free Documentation License::
-* Function Index::
-* Variable Index::
-* Type Index::
-* Concept Index::
+* Physical Constants::          
+* IEEE floating-point arithmetic::  
+* Debugging Numerical Programs::  
+* Contributors to GSL::         
+* Autoconf Macros::             
+* GSL CBLAS Library::           
+* Free Software Needs Free Documentation::  
+* GNU General Public License::  
+* GNU Free Documentation License::  
+* Function Index::              
+* Variable Index::              
+* Type Index::                  
+* Concept Index::               
 
 
 File: gsl-ref.info,  Node: Introduction,  Next: Using the library,  Prev: Top,  Up: Top
@@ -127,13 +125,13 @@ License.
 
 * Menu:
 
-* Routines available in GSL::
-* GSL is Free Software::
-* Obtaining GSL::
-* No Warranty::
-* Reporting Bugs::
-* Further Information::
-* Conventions used in this manual::
+* Routines available in GSL::   
+* GSL is Free Software::        
+* Obtaining GSL::               
+* No Warranty::                 
+* Reporting Bugs::              
+* Further Information::         
+* Conventions used in this manual::  
 
 
 File: gsl-ref.info,  Node: Routines available in GSL,  Next: GSL is Free Software,  Up: Introduction
@@ -144,23 +142,23 @@ File: gsl-ref.info,  Node: Routines available in GSL,  Next: GSL is Free Softwar
 The library covers a wide range of topics in numerical computing.
 Routines are available for the following areas,
 
-     Complex Numbers                  Roots of Polynomials             
-     Special Functions                Vectors and Matrices             
-     Permutations                     Combinations                     
-     Sorting                          BLAS Support                     
-     Linear Algebra                   CBLAS Library                    
-     Fast Fourier Transforms          Eigensystems                     
-     Random Numbers                   Quadrature                       
-     Random Distributions             Quasi-Random Sequences           
-     Histograms                       Statistics                       
-     Monte Carlo Integration          N-Tuples                         
-     Differential Equations           Simulated Annealing              
-     Numerical Differentiation        Interpolation                    
-     Series Acceleration              Chebyshev Approximations         
-     Root-Finding                     Discrete Hankel Transforms       
-     Least-Squares Fitting            Minimization                     
-     IEEE Floating-Point              Physical Constants               
-     Wavelets                                                          
+     Complex Numbers                  Roots of Polynomials
+     Special Functions                Vectors and Matrices
+     Permutations                     Combinations
+     Sorting                          BLAS Support
+     Linear Algebra                   CBLAS Library
+     Fast Fourier Transforms          Eigensystems
+     Random Numbers                   Quadrature
+     Random Distributions             Quasi-Random Sequences
+     Histograms                       Statistics
+     Monte Carlo Integration          N-Tuples
+     Differential Equations           Simulated Annealing
+     Numerical Differentiation        Interpolation
+     Series Acceleration              Chebyshev Approximations
+     Root-Finding                     Discrete Hankel Transforms
+     Least-Squares Fitting            Minimization
+     IEEE Floating-Point              Physical Constants
+     Wavelets
 
 The use of these routines is described in this manual.  Each chapter
 provides detailed definitions of the functions, followed by example
@@ -211,14 +209,14 @@ reputation.
    The precise conditions for the distribution of software related to
 the GNU Scientific Library are found in the GNU General Public License
 (*note GNU General Public License::).  Further information about this
-license is available from the GNU Project webpage `Frequently Asked
+license is available from the GNU Project webpage 'Frequently Asked
 Questions about the GNU GPL',
 
-     `http://www.gnu.org/copyleft/gpl-faq.html'
+     <http://www.gnu.org/copyleft/gpl-faq.html>
 
 The Free Software Foundation also operates a license consulting service
 for commercial users (contact details available from
-`http://www.fsf.org/').
+<http://www.fsf.org/>).
 
 
 File: gsl-ref.info,  Node: Obtaining GSL,  Next: No Warranty,  Prev: GSL is Free Software,  Up: Introduction
@@ -228,27 +226,26 @@ File: gsl-ref.info,  Node: Obtaining GSL,  Next: No Warranty,  Prev: GSL is Free
 
 The source code for the library can be obtained in different ways, by
 copying it from a friend, purchasing it on CDROM or downloading it from
-the internet. A list of public ftp servers which carry the source code
+the internet.  A list of public ftp servers which carry the source code
 can be found on the GNU website,
 
-     `http://www.gnu.org/software/gsl/'
+     <http://www.gnu.org/software/gsl/>
 
 The preferred platform for the library is a GNU system, which allows it
 to take advantage of additional features in the GNU C compiler and GNU C
 library.  However, the library is fully portable and should compile on
-most systems with a C compiler.  Precompiled versions of the library
-can be purchased from commercial redistributors listed on the website
-above.
+most systems with a C compiler.  Precompiled versions of the library can
+be purchased from commercial redistributors listed on the website above.
 
    Announcements of new releases, updates and other relevant events are
-made on the `info-gsl@gnu.org' mailing list.  To subscribe to this
+made on the 'info-gsl@gnu.org' mailing list.  To subscribe to this
 low-volume list, send an email of the following form:
 
      To: info-gsl-request@gnu.org
      Subject: subscribe
 
-You will receive a response asking you to reply in order to confirm
-your subscription.
+You will receive a response asking you to reply in order to confirm your
+subscription.
 
 
 File: gsl-ref.info,  Node: No Warranty,  Next: Reporting Bugs,  Prev: Obtaining GSL,  Up: Introduction
@@ -269,9 +266,9 @@ File: gsl-ref.info,  Node: Reporting Bugs,  Next: Further Information,  Prev: No
 1.5 Reporting Bugs
 ==================
 
-A list of known bugs can be found in the `BUGS' file included in the
-GSL distribution.  Details of compilation problems can be found in the
-`INSTALL' file.
+A list of known bugs can be found in the 'BUGS' file included in the GSL
+distribution.  Details of compilation problems can be found in the
+'INSTALL' file.
 
    If you find a bug which is not listed in these files, please report
 it to <bug-gsl@gnu.org>.
@@ -279,13 +276,9 @@ it to <bug-gsl@gnu.org>.
    All bug reports should include:
 
    * The version number of GSL
-
    * The hardware and operating system
-
    * The compiler used, including version number and compilation options
-
    * A description of the bug behavior
-
    * A short program which exercises the bug
 
 It is useful if you can check whether the same problem occurs when the
@@ -305,7 +298,7 @@ related projects, and mailing list archives are available from the
 website mentioned above.
 
    Any questions about the use and installation of the library can be
-asked on the mailing list `help-gsl@gnu.org'.  To subscribe to this
+asked on the mailing list 'help-gsl@gnu.org'.  To subscribe to this
 list, send an email of the following form:
 
      To: help-gsl-request@gnu.org
@@ -315,11 +308,11 @@ This mailing list can be used to ask questions not covered by this
 manual, and to contact the developers of the library.
 
    If you would like to refer to the GNU Scientific Library in a journal
-article, the recommended way is to cite this reference manual, e.g. `M.
+article, the recommended way is to cite this reference manual, e.g.  'M.
 Galassi et al, GNU Scientific Library Reference Manual (2nd Ed.), ISBN
 0954161734'.
 
-   If you want to give a url, use "`http://www.gnu.org/software/gsl/'".
+   If you want to give a url, use "<http://www.gnu.org/software/gsl/>".
 
 
 File: gsl-ref.info,  Node: Conventions used in this manual,  Prev: Further Information,  Up: Introduction
@@ -333,13 +326,13 @@ A command entered at the terminal is shown like this,
      $ command
 
 The first character on the line is the terminal prompt, and should not
-be typed.  The dollar sign `$' is used as the standard prompt in this
+be typed.  The dollar sign '$' is used as the standard prompt in this
 manual, although some systems may use a different character.
 
    The examples assume the use of the GNU operating system.  There may
 be minor differences in the output on other systems.  The commands for
 setting environment variables use the Bourne shell syntax of the
-standard GNU shell (`bash').
+standard GNU shell ('bash').
 
 
 File: gsl-ref.info,  Node: Using the library,  Next: Error Handling,  Prev: Introduction,  Up: Top
@@ -352,20 +345,20 @@ introduces its conventions.
 
 * Menu:
 
-* An Example Program::
-* Compiling and Linking::
-* Shared Libraries::
-* ANSI C Compliance::
-* Inline functions::
-* Long double::
-* Portability functions::
-* Alternative optimized functions::
-* Support for different numeric types::
-* Compatibility with C++::
-* Aliasing of arrays::
-* Thread-safety::
-* Deprecated Functions::
-* Code Reuse::
+* An Example Program::          
+* Compiling and Linking::       
+* Shared Libraries::            
+* ANSI C Compliance::           
+* Inline functions::            
+* Long double::                 
+* Portability functions::       
+* Alternative optimized functions::  
+* Support for different numeric types::  
+* Compatibility with C++::      
+* Aliasing of arrays::          
+* Thread-safety::               
+* Deprecated Functions::        
+* Code Reuse::                  
 
 
 File: gsl-ref.info,  Node: An Example Program,  Next: Compiling and Linking,  Up: Using the library
@@ -402,29 +395,28 @@ File: gsl-ref.info,  Node: Compiling and Linking,  Next: Shared Libraries,  Prev
 2.2 Compiling and Linking
 =========================
 
-The library header files are installed in their own `gsl' directory.
-You should write any preprocessor include statements with a `gsl/'
+The library header files are installed in their own 'gsl' directory.
+You should write any preprocessor include statements with a 'gsl/'
 directory prefix thus,
 
      #include <gsl/gsl_math.h>
 
 If the directory is not installed on the standard search path of your
 compiler you will also need to provide its location to the preprocessor
-as a command line flag.  The default location of the `gsl' directory is
-`/usr/local/include/gsl'.  A typical compilation command for a source
-file `example.c' with the GNU C compiler `gcc' is,
+as a command line flag.  The default location of the 'gsl' directory is
+'/usr/local/include/gsl'.  A typical compilation command for a source
+file 'example.c' with the GNU C compiler 'gcc' is,
 
      $ gcc -Wall -I/usr/local/include -c example.c
 
-This results in an object file `example.o'.   The default include path
-for `gcc' searches `/usr/local/include' automatically so the `-I'
-option can actually be omitted when GSL is installed in its default
-location.
+This results in an object file 'example.o'.  The default include path
+for 'gcc' searches '/usr/local/include' automatically so the '-I' option
+can actually be omitted when GSL is installed in its default location.
 
 * Menu:
 
-* Linking programs with the library::
-* Linking with an alternative BLAS library::
+* Linking programs with the library::  
+* Linking with an alternative BLAS library::  
 
 
 File: gsl-ref.info,  Node: Linking programs with the library,  Next: Linking with an alternative BLAS library,  Up: Compiling and Linking
@@ -432,25 +424,24 @@ File: gsl-ref.info,  Node: Linking programs with the library,  Next: Linking wit
 2.2.1 Linking programs with the library
 ---------------------------------------
 
-The library is installed as a single file, `libgsl.a'.  A shared
-version of the library `libgsl.so' is also installed on systems that
-support shared libraries.  The default location of these files is
-`/usr/local/lib'.  If this directory is not on the standard search path
+The library is installed as a single file, 'libgsl.a'.  A shared version
+of the library 'libgsl.so' is also installed on systems that support
+shared libraries.  The default location of these files is
+'/usr/local/lib'.  If this directory is not on the standard search path
 of your linker you will also need to provide its location as a command
 line flag.
 
-   To link against the library you need to specify both the main
-library and a supporting CBLAS library, which provides standard basic
-linear algebra subroutines.  A suitable CBLAS implementation is
-provided in the library `libgslcblas.a' if your system does not provide
-one.  The following example shows how to link an application with the
-library,
+   To link against the library you need to specify both the main library
+and a supporting CBLAS library, which provides standard basic linear
+algebra subroutines.  A suitable CBLAS implementation is provided in the
+library 'libgslcblas.a' if your system does not provide one.  The
+following example shows how to link an application with the library,
 
      $ gcc -L/usr/local/lib example.o -lgsl -lgslcblas -lm
 
-The default library path for `gcc' searches `/usr/local/lib'
-automatically so the `-L' option can be omitted when GSL is installed
-in its default location.
+The default library path for 'gcc' searches '/usr/local/lib'
+automatically so the '-L' option can be omitted when GSL is installed in
+its default location.
 
 
 File: gsl-ref.info,  Node: Linking with an alternative BLAS library,  Prev: Linking programs with the library,  Up: Compiling and Linking
@@ -459,21 +450,21 @@ File: gsl-ref.info,  Node: Linking with an alternative BLAS library,  Prev: Link
 ----------------------------------------------
 
 The following command line shows how you would link the same application
-with an alternative CBLAS library called `libcblas',
+with an alternative CBLAS library called 'libcblas',
 
      $ gcc example.o -lgsl -lcblas -lm
 
 For the best performance an optimized platform-specific CBLAS library
-should be used for `-lcblas'.  The library must conform to the CBLAS
+should be used for '-lcblas'.  The library must conform to the CBLAS
 standard.  The ATLAS package provides a portable high-performance BLAS
 library with a CBLAS interface.  It is free software and should be
-installed for any work requiring fast vector and matrix operations.
-The following command line will link with the ATLAS library and its
-CBLAS interface,
+installed for any work requiring fast vector and matrix operations.  The
+following command line will link with the ATLAS library and its CBLAS
+interface,
 
      $ gcc example.o -lgsl -lcblas -latlas -lm
 
-For more information see *Note BLAS Support::.
+For more information see *note BLAS Support::.
 
 
 File: gsl-ref.info,  Node: Shared Libraries,  Next: ANSI C Compliance,  Prev: Compiling and Linking,  Up: Using the library
@@ -482,7 +473,7 @@ File: gsl-ref.info,  Node: Shared Libraries,  Next: ANSI C Compliance,  Prev: Co
 ====================
 
 To run a program linked with the shared version of the library the
-operating system must be able to locate the corresponding `.so' file at
+operating system must be able to locate the corresponding '.so' file at
 runtime.  If the library cannot be found, the following error will
 occur:
 
@@ -491,28 +482,28 @@ occur:
      libgsl.so.0: cannot open shared object file: No such
      file or directory
 
-To avoid this error, define the shell variable `LD_LIBRARY_PATH' to
+To avoid this error, define the shell variable 'LD_LIBRARY_PATH' to
 include the directory where the library is installed.
 
-   For example, in the Bourne shell (`/bin/sh' or `/bin/bash'), the
+   For example, in the Bourne shell ('/bin/sh' or '/bin/bash'), the
 library search path can be set with the following commands:
 
      $ LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
      $ export LD_LIBRARY_PATH
      $ ./example
 
-In the C-shell (`/bin/csh' or `/bin/tcsh') the equivalent command is,
+In the C-shell ('/bin/csh' or '/bin/tcsh') the equivalent command is,
 
      % setenv LD_LIBRARY_PATH /usr/local/lib:$LD_LIBRARY_PATH
 
 The standard prompt for the C-shell in the example above is the percent
-character `%', and should not be typed as part of the command.
+character '%', and should not be typed as part of the command.
 
-   To save retyping these commands each session they should be placed
-in an individual or system-wide login file.
+   To save retyping these commands each session they should be placed in
+an individual or system-wide login file.
 
    To compile a statically linked version of the program, use the
-`-static' flag in `gcc',
+'-static' flag in 'gcc',
 
      $ gcc -static example.o -lgsl -lgslcblas -lm
 
@@ -526,12 +517,12 @@ The library is written in ANSI C and is intended to conform to the ANSI
 C standard (C89).  It should be portable to any system with a working
 ANSI C compiler.
 
-   The library does not rely on any non-ANSI extensions in the
-interface it exports to the user.  Programs you write using GSL can be
-ANSI compliant.  Extensions which can be used in a way compatible with
-pure ANSI C are supported, however, via conditional compilation.  This
-allows the library to take advantage of compiler extensions on those
-platforms which support them.
+   The library does not rely on any non-ANSI extensions in the interface
+it exports to the user.  Programs you write using GSL can be ANSI
+compliant.  Extensions which can be used in a way compatible with pure
+ANSI C are supported, however, via conditional compilation.  This allows
+the library to take advantage of compiler extensions on those platforms
+which support them.
 
    When an ANSI C feature is known to be broken on a particular system
 the library will exclude any related functions at compile-time.  This
@@ -539,8 +530,8 @@ should make it impossible to link a program that would use these
 functions and give incorrect results.
 
    To avoid namespace conflicts all exported function names and
-variables have the prefix `gsl_', while exported macros have the prefix
-`GSL_'.
+variables have the prefix 'gsl_', while exported macros have the prefix
+'GSL_'.
 
 
 File: gsl-ref.info,  Node: Inline functions,  Next: Long double,  Prev: ANSI C Compliance,  Up: Using the library
@@ -548,23 +539,23 @@ File: gsl-ref.info,  Node: Inline functions,  Next: Long double,  Prev: ANSI C C
 2.5 Inline functions
 ====================
 
-The `inline' keyword is not part of the original ANSI C standard (C89)
+The 'inline' keyword is not part of the original ANSI C standard (C89)
 and the library does not export any inline function definitions by
-default. However, the library provides optional inline versions of
+default.  However, the library provides optional inline versions of
 performance-critical functions by conditional compilation.  The inline
 versions of these functions can be included by defining the macro
-`HAVE_INLINE' when compiling an application,
+'HAVE_INLINE' when compiling an application,
 
      $ gcc -Wall -c -DHAVE_INLINE example.c
 
-If you use `autoconf' this macro can be defined automatically.  If you
-do not define the macro `HAVE_INLINE' then the slower non-inlined
+If you use 'autoconf' this macro can be defined automatically.  If you
+do not define the macro 'HAVE_INLINE' then the slower non-inlined
 versions of the functions will be used instead.
 
-   Note that the actual usage of the inline keyword is `extern inline',
+   Note that the actual usage of the inline keyword is 'extern inline',
 which eliminates unnecessary function definitions in GCC.  If the form
-`extern inline' causes problems with other compilers a stricter
-autoconf test can be used, see *Note Autoconf Macros::.
+'extern inline' causes problems with other compilers a stricter autoconf
+test can be used, see *note Autoconf Macros::.
 
 
 File: gsl-ref.info,  Node: Long double,  Next: Portability functions,  Prev: Inline functions,  Up: Using the library
@@ -572,29 +563,29 @@ File: gsl-ref.info,  Node: Long double,  Next: Portability functions,  Prev: Inl
 2.6 Long double
 ===============
 
-The extended numerical type `long double' is part of the ANSI C
-standard and should be available in every modern compiler.  However, the
-precision of `long double' is platform dependent, and this should be
+The extended numerical type 'long double' is part of the ANSI C standard
+and should be available in every modern compiler.  However, the
+precision of 'long double' is platform dependent, and this should be
 considered when using it.  The IEEE standard only specifies the minimum
-precision of extended precision numbers, while the precision of
-`double' is the same on all platforms.
+precision of extended precision numbers, while the precision of 'double'
+is the same on all platforms.
 
-   In some system libraries the `stdio.h' formatted input/output
-functions `printf' and `scanf' are not implemented correctly for `long
+   In some system libraries the 'stdio.h' formatted input/output
+functions 'printf' and 'scanf' are not implemented correctly for 'long
 double'.  Undefined or incorrect results are avoided by testing these
-functions during the `configure' stage of library compilation and
+functions during the 'configure' stage of library compilation and
 eliminating certain GSL functions which depend on them if necessary.
-The corresponding line in the `configure' output looks like this,
+The corresponding line in the 'configure' output looks like this,
 
      checking whether printf works with long double... no
 
-Consequently when `long double' formatted input/output does not work on
+Consequently when 'long double' formatted input/output does not work on
 a given system it should be impossible to link a program which uses GSL
 functions dependent on this.
 
    If it is necessary to work on a system which does not support
-formatted `long double' input/output then the options are to use binary
-formats or to convert `long double' results into `double' for reading
+formatted 'long double' input/output then the options are to use binary
+formats or to convert 'long double' results into 'double' for reading
 and writing.
 
 
@@ -609,9 +600,9 @@ the BSD math library.  You can write your application to use the native
 versions of these functions, and substitute the GSL versions via a
 preprocessor macro if they are unavailable on another platform.
 
-   For example, after determining whether the BSD function `hypot' is
+   For example, after determining whether the BSD function 'hypot' is
 available you can include the following macro definitions in a file
-`config.h' with your application,
+'config.h' with your application,
 
      /* Substitute gsl_hypot for missing system hypot */
 
@@ -619,16 +610,16 @@ available you can include the following macro definitions in a file
      #define hypot gsl_hypot
      #endif
 
-The application source files can then use the include command `#include
-<config.h>' to replace each occurrence of `hypot' by `gsl_hypot' when
-`hypot' is not available.  This substitution can be made automatically
-if you use `autoconf', see *Note Autoconf Macros::.
+The application source files can then use the include command '#include
+<config.h>' to replace each occurrence of 'hypot' by 'gsl_hypot' when
+'hypot' is not available.  This substitution can be made automatically
+if you use 'autoconf', see *note Autoconf Macros::.
 
-   In most circumstances the best strategy is to use the native
-versions of these functions when available, and fall back to GSL
-versions otherwise, since this allows your application to take
-advantage of any platform-specific optimizations in the system library.
-This is the strategy used within GSL itself.
+   In most circumstances the best strategy is to use the native versions
+of these functions when available, and fall back to GSL versions
+otherwise, since this allows your application to take advantage of any
+platform-specific optimizations in the system library.  This is the
+strategy used within GSL itself.
 
 
 File: gsl-ref.info,  Node: Alternative optimized functions,  Next: Support for different numeric types,  Prev: Portability functions,  Up: Using the library
@@ -655,7 +646,7 @@ distribution,
      #define gsl_ran_gaussian my_gaussian
      #endif
 
-These lines would be placed in the configuration header file `config.h'
+These lines would be placed in the configuration header file 'config.h'
 of the application, which should then be included by all the source
 files.  Note that the alternative implementations will not produce
 bit-for-bit identical results, and in the case of random number
@@ -671,9 +662,9 @@ File: gsl-ref.info,  Node: Support for different numeric types,  Next: Compatibi
 Many functions in the library are defined for different numeric types.
 This feature is implemented by varying the name of the function with a
 type-related modifier--a primitive form of C++ templates.  The modifier
-is inserted into the function name after the initial module prefix.
-The following table shows the function names defined for all the
-numeric types of an imaginary module `gsl_foo' with function `fn',
+is inserted into the function name after the initial module prefix.  The
+following table shows the function names defined for all the numeric
+types of an imaginary module 'gsl_foo' with function 'fn',
 
      gsl_foo_fn               double
      gsl_foo_long_double_fn   long double
@@ -687,16 +678,16 @@ numeric types of an imaginary module `gsl_foo' with function `fn',
      gsl_foo_char_fn          char
      gsl_foo_uchar_fn         unsigned char
 
-The normal numeric precision `double' is considered the default and
-does not require a suffix.  For example, the function `gsl_stats_mean'
+The normal numeric precision 'double' is considered the default and does
+not require a suffix.  For example, the function 'gsl_stats_mean'
 computes the mean of double precision numbers, while the function
-`gsl_stats_int_mean' computes the mean of integers.
+'gsl_stats_int_mean' computes the mean of integers.
 
    A corresponding scheme is used for library defined types, such as
-`gsl_vector' and `gsl_matrix'.  In this case the modifier is appended
-to the type name.  For example, if a module defines a new
-type-dependent struct or typedef `gsl_foo' it is modified for other
-types in the following way,
+'gsl_vector' and 'gsl_matrix'.  In this case the modifier is appended to
+the type name.  For example, if a module defines a new type-dependent
+struct or typedef 'gsl_foo' it is modified for other types in the
+following way,
 
      gsl_foo                  double
      gsl_foo_long_double      long double
@@ -735,13 +726,13 @@ File: gsl-ref.info,  Node: Compatibility with C++,  Next: Aliasing of arrays,  P
 2.10 Compatibility with C++
 ===========================
 
-The library header files automatically define functions to have `extern
+The library header files automatically define functions to have 'extern
 "C"' linkage when included in C++ programs.  This allows the functions
 to be called directly from C++.
 
    To use C++ exception handling within user-defined functions passed to
-the library as parameters, the library must be built with the
-additional `CFLAGS' compilation option `-fexceptions'.
+the library as parameters, the library must be built with the additional
+'CFLAGS' compilation option '-fexceptions'.
 
 
 File: gsl-ref.info,  Node: Aliasing of arrays,  Next: Thread-safety,  Prev: Compatibility with C++,  Up: Using the library
@@ -756,7 +747,7 @@ regions as a special case, and allows additional optimizations to be
 used.  If overlapping memory regions are passed as modifiable arguments
 then the results of such functions will be undefined.  If the arguments
 will not be modified (for example, if a function prototype declares them
-as `const' arguments) then overlapping or aliased memory regions can be
+as 'const' arguments) then overlapping or aliased memory regions can be
 safely used.
 
 
@@ -772,11 +763,11 @@ functions which use "workspace" objects as temporary storage the
 workspaces should be allocated on a per-thread basis.  For functions
 which use "table" objects as read-only memory the tables can be used by
 multiple threads simultaneously.  Table arguments are always declared
-`const' in function prototypes, to indicate that they may be safely
+'const' in function prototypes, to indicate that they may be safely
 accessed by different threads.
 
    There are a small number of static global variables which are used to
-control the overall behavior of the library (e.g. whether to use
+control the overall behavior of the library (e.g.  whether to use
 range-checking, the function to call on fatal error, etc).  These
 variables are set directly by the user, so they should be initialized
 once at program startup and not modified by different threads.
@@ -789,10 +780,10 @@ File: gsl-ref.info,  Node: Deprecated Functions,  Next: Code Reuse,  Prev: Threa
 
 From time to time, it may be necessary for the definitions of some
 functions to be altered or removed from the library.  In these
-circumstances the functions will first be declared "deprecated" and
-then removed from subsequent versions of the library.  Functions that
-are deprecated can be disabled in the current release by setting the
-preprocessor definition `GSL_DISABLE_DEPRECATED'.  This allows existing
+circumstances the functions will first be declared "deprecated" and then
+removed from subsequent versions of the library.  Functions that are
+deprecated can be disabled in the current release by setting the
+preprocessor definition 'GSL_DISABLE_DEPRECATED'.  This allows existing
 code to be tested for forwards compatibility.
 
 
@@ -805,10 +796,10 @@ Where possible the routines in the library have been written to avoid
 dependencies between modules and files.  This should make it possible to
 extract individual functions for use in your own applications, without
 needing to have the whole library installed.  You may need to define
-certain macros such as `GSL_ERROR' and remove some `#include'
-statements in order to compile the files as standalone units. Reuse of
-the library code in this way is encouraged, subject to the terms of the
-GNU General Public License.
+certain macros such as 'GSL_ERROR' and remove some '#include' statements
+in order to compile the files as standalone units.  Reuse of the library
+code in this way is encouraged, subject to the terms of the GNU General
+Public License.
 
 
 File: gsl-ref.info,  Node: Error Handling,  Next: Mathematical Functions,  Prev: Using the library,  Up: Top
@@ -824,15 +815,15 @@ your own error handling functions to modify the default behavior of the
 library.
 
    The functions described in this section are declared in the header
-file `gsl_errno.h'.
+file 'gsl_errno.h'.
 
 * Menu:
 
-* Error Reporting::
-* Error Codes::
-* Error Handlers::
-* Using GSL error reporting in your own functions::
-* Error Reporting Examples::
+* Error Reporting::             
+* Error Codes::                 
+* Error Handlers::              
+* Using GSL error reporting in your own functions::  
+* Error Reporting Examples::    
 
 
 File: gsl-ref.info,  Node: Error Reporting,  Next: Error Codes,  Up: Error Handling
@@ -842,7 +833,7 @@ File: gsl-ref.info,  Node: Error Reporting,  Next: Error Codes,  Up: Error Handl
 
 The library follows the thread-safe error reporting conventions of the
 POSIX Threads library.  Functions return a non-zero error code to
-indicate an error and `0' to indicate success.
+indicate an error and '0' to indicate success.
 
      int status = gsl_function (...)
 
@@ -860,24 +851,24 @@ check the return status of the functions that you call.
 
    Whenever a routine reports an error the return value specifies the
 type of error.  The return value is analogous to the value of the
-variable `errno' in the C library.  The caller can examine the return
+variable 'errno' in the C library.  The caller can examine the return
 code and decide what action to take, including ignoring the error if it
 is not considered serious.
 
    In addition to reporting errors by return codes the library also has
-an error handler function `gsl_error'.  This function is called by
-other library functions when they report an error, just before they
-return to the caller.  The default behavior of the error handler is to
-print a message and abort the program,
+an error handler function 'gsl_error'.  This function is called by other
+library functions when they report an error, just before they return to
+the caller.  The default behavior of the error handler is to print a
+message and abort the program,
 
      gsl: file.c:67: ERROR: invalid argument supplied by user
      Default GSL error handler invoked.
      Aborted
 
-   The purpose of the `gsl_error' handler is to provide a function
-where a breakpoint can be set that will catch library errors when
-running under the debugger.  It is not intended for use in production
-programs, which should handle any errors using the return codes.
+   The purpose of the 'gsl_error' handler is to provide a function where
+a breakpoint can be set that will catch library errors when running
+under the debugger.  It is not intended for use in production programs,
+which should handle any errors using the return codes.
 
 
 File: gsl-ref.info,  Node: Error Codes,  Next: Error Handlers,  Prev: Error Reporting,  Up: Error Handling
@@ -886,16 +877,16 @@ File: gsl-ref.info,  Node: Error Codes,  Next: Error Handlers,  Prev: Error Repo
 ===============
 
 The error code numbers returned by library functions are defined in the
-file `gsl_errno.h'.  They all have the prefix `GSL_' and expand to
-non-zero constant integer values. Error codes above 1024 are reserved
+file 'gsl_errno.h'.  They all have the prefix 'GSL_' and expand to
+non-zero constant integer values.  Error codes above 1024 are reserved
 for applications, and are not used by the library.  Many of the error
 codes use the same base name as the corresponding error code in the C
 library.  Here are some of the most common error codes,
 
  -- Macro: int GSL_EDOM
-     Domain error; used by mathematical functions when an argument
-     value does not fall into the domain over which the function is
-     defined (like EDOM in the C library)
+     Domain error; used by mathematical functions when an argument value
+     does not fall into the domain over which the function is defined
+     (like EDOM in the C library)
 
  -- Macro: int GSL_ERANGE
      Range error; used by mathematical functions when the result value
@@ -904,9 +895,9 @@ library.  Here are some of the most common error codes,
 
  -- Macro: int GSL_ENOMEM
      No memory available.  The system cannot allocate more virtual
-     memory because its capacity is full (like ENOMEM in the C
-     library).  This error is reported when a GSL routine encounters
-     problems when trying to allocate memory with `malloc'.
+     memory because its capacity is full (like ENOMEM in the C library).
+     This error is reported when a GSL routine encounters problems when
+     trying to allocate memory with 'malloc'.
 
  -- Macro: int GSL_EINVAL
      Invalid argument.  This is used to indicate various kinds of
@@ -914,16 +905,16 @@ library.  Here are some of the most common error codes,
      (like EINVAL in the C library).
 
    The error codes can be converted into an error message using the
-function `gsl_strerror'.
+function 'gsl_strerror'.
 
  -- Function: const char * gsl_strerror (const int GSL_ERRNO)
      This function returns a pointer to a string describing the error
-     code GSL_ERRNO. For example,
+     code GSL_ERRNO.  For example,
 
           printf ("error: %s\n", gsl_strerror (status));
 
-     would print an error message like `error: output range error' for a
-     status value of `GSL_ERANGE'.
+     would print an error message like 'error: output range error' for a
+     status value of 'GSL_ERANGE'.
 
 
 File: gsl-ref.info,  Node: Error Handlers,  Next: Using GSL error reporting in your own functions,  Prev: Error Codes,  Up: Error Handling
@@ -932,10 +923,10 @@ File: gsl-ref.info,  Node: Error Handlers,  Next: Using GSL error reporting in y
 ==================
 
 The default behavior of the GSL error handler is to print a short
-message and call `abort'.  When this default is in use programs will
-stop with a core-dump whenever a library routine reports an error.
-This is intended as a fail-safe default for programs which do not check
-the return status of library routines (we don't encourage you to write
+message and call 'abort'.  When this default is in use programs will
+stop with a core-dump whenever a library routine reports an error.  This
+is intended as a fail-safe default for programs which do not check the
+return status of library routines (we don't encourage you to write
 programs this way).
 
    If you turn off the default error handler it is your responsibility
@@ -945,18 +936,19 @@ For example, an alternative error handler could log all errors to a
 file, ignore certain error conditions (such as underflows), or start the
 debugger and attach it to the current process when an error occurs.
 
-   All GSL error handlers have the type `gsl_error_handler_t', which is
-defined in `gsl_errno.h',
+   All GSL error handlers have the type 'gsl_error_handler_t', which is
+defined in 'gsl_errno.h',
 
  -- Data Type: gsl_error_handler_t
+
      This is the type of GSL error handler functions.  An error handler
      will be passed four arguments which specify the reason for the
      error (a string), the name of the source file in which it occurred
      (also a string), the line number in that file (an integer) and the
-     error number (an integer).  The source file and line number are
-     set at compile time using the `__FILE__' and `__LINE__' directives
-     in the preprocessor.  An error handler function returns type
-     `void'.  Error handler functions should be defined like this,
+     error number (an integer).  The source file and line number are set
+     at compile time using the '__FILE__' and '__LINE__' directives in
+     the preprocessor.  An error handler function returns type 'void'.
+     Error handler functions should be defined like this,
 
           void handler (const char * reason,
                         const char * file,
@@ -964,19 +956,20 @@ defined in `gsl_errno.h',
                         int gsl_errno)
 
 To request the use of your own error handler you need to call the
-function `gsl_set_error_handler' which is also declared in
-`gsl_errno.h',
+function 'gsl_set_error_handler' which is also declared in
+'gsl_errno.h',
 
  -- Function: gsl_error_handler_t * gsl_set_error_handler
           (gsl_error_handler_t NEW_HANDLER)
+
      This function sets a new error handler, NEW_HANDLER, for the GSL
      library routines.  The previous handler is returned (so that you
      can restore it later).  Note that the pointer to a user defined
-     error handler function is stored in a static variable, so there
-     can be only one error handler per program.  This function should
-     be not be used in multi-threaded programs except to set up a
-     program-wide error handler from a master thread.  The following
-     example shows how to set and restore a new error handler,
+     error handler function is stored in a static variable, so there can
+     be only one error handler per program.  This function should be not
+     be used in multi-threaded programs except to set up a program-wide
+     error handler from a master thread.  The following example shows
+     how to set and restore a new error handler,
 
           /* save original handler, install new handler */
           old_handler = gsl_set_error_handler (&my_handler);
@@ -987,22 +980,22 @@ function `gsl_set_error_handler' which is also declared in
           /* restore original handler */
           gsl_set_error_handler (old_handler);
 
-     To use the default behavior (`abort' on error) set the error
-     handler to `NULL',
+     To use the default behavior ('abort' on error) set the error
+     handler to 'NULL',
 
           old_handler = gsl_set_error_handler (NULL);
 
  -- Function: gsl_error_handler_t * gsl_set_error_handler_off ()
      This function turns off the error handler by defining an error
-     handler which does nothing. This will cause the program to
+     handler which does nothing.  This will cause the program to
      continue after any error, so the return values from any library
      routines must be checked.  This is the recommended behavior for
-     production programs.  The previous handler is returned (so that
-     you can restore it later).
+     production programs.  The previous handler is returned (so that you
+     can restore it later).
 
    The error behavior can be changed for specific applications by
-recompiling the library with a customized definition of the `GSL_ERROR'
-macro in the file `gsl_errno.h'.
+recompiling the library with a customized definition of the 'GSL_ERROR'
+macro in the file 'gsl_errno.h'.
 
 
 File: gsl-ref.info,  Node: Using GSL error reporting in your own functions,  Next: Error Reporting Examples,  Prev: Error Handlers,  Up: Error Handling
@@ -1014,25 +1007,26 @@ If you are writing numerical functions in a program which also uses GSL
 code you may find it convenient to adopt the same error reporting
 conventions as in the library.
 
-   To report an error you need to call the function `gsl_error' with a
+   To report an error you need to call the function 'gsl_error' with a
 string describing the error and then return an appropriate error code
-from `gsl_errno.h', or a special value, such as `NaN'.  For convenience
-the file `gsl_errno.h' defines two macros which carry out these steps:
+from 'gsl_errno.h', or a special value, such as 'NaN'.  For convenience
+the file 'gsl_errno.h' defines two macros which carry out these steps:
 
  -- Macro: GSL_ERROR (REASON, GSL_ERRNO)
+
      This macro reports an error using the GSL conventions and returns a
-     status value of `gsl_errno'.  It expands to the following code
+     status value of 'gsl_errno'.  It expands to the following code
      fragment,
 
           gsl_error (reason, __FILE__, __LINE__, gsl_errno);
           return gsl_errno;
 
-     The macro definition in `gsl_errno.h' actually wraps the code in a
-     `do { ... } while (0)' block to prevent possible parsing problems.
+     The macro definition in 'gsl_errno.h' actually wraps the code in a
+     'do { ... } while (0)' block to prevent possible parsing problems.
 
    Here is an example of how the macro could be used to report that a
 routine did not achieve a requested tolerance.  To report the error the
-routine needs to return the error code `GSL_ETOL'.
+routine needs to return the error code 'GSL_ETOL'.
 
      if (residual > tolerance)
        {
@@ -1040,12 +1034,13 @@ routine needs to return the error code `GSL_ETOL'.
        }
 
  -- Macro: GSL_ERROR_VAL (REASON, GSL_ERRNO, VALUE)
-     This macro is the same as `GSL_ERROR' but returns a user-defined
+
+     This macro is the same as 'GSL_ERROR' but returns a user-defined
      value of VALUE instead of an error code.  It can be used for
      mathematical functions that return a floating point value.
 
-   The following example shows how to return a `NaN' at a mathematical
-singularity using the `GSL_ERROR_VAL' macro,
+   The following example shows how to return a 'NaN' at a mathematical
+singularity using the 'GSL_ERROR_VAL' macro,
 
      if (x == 0)
        {
@@ -1085,12 +1080,12 @@ function where an error might be reported,
        }
      ...
 
-The function `gsl_fft_complex_radix2' only accepts integer lengths
-which are a power of two.  If the variable `n' is not a power of two
-then the call to the library function will return `GSL_EINVAL',
-indicating that the length argument is invalid.  The function call to
-`gsl_set_error_handler_off' stops the default error handler from
-aborting the program.  The `else' clause catches any other possible
+The function 'gsl_fft_complex_radix2' only accepts integer lengths which
+are a power of two.  If the variable 'n' is not a power of two then the
+call to the library function will return 'GSL_EINVAL', indicating that
+the length argument is invalid.  The function call to
+'gsl_set_error_handler_off' stops the default error handler from
+aborting the program.  The 'else' clause catches any other possible
 errors.
 
 
@@ -1105,18 +1100,18 @@ given here can be used as a substitute when the system functions are not
 available.
 
    The functions and macros described in this chapter are defined in the
-header file `gsl_math.h'.
+header file 'gsl_math.h'.
 
 * Menu:
 
-* Mathematical Constants::
-* Infinities and Not-a-number::
-* Elementary Functions::
-* Small integer powers::
-* Testing the Sign of Numbers::
-* Testing for Odd and Even Numbers::
-* Maximum and Minimum functions::
-* Approximate Comparison of Floating Point Numbers::
+* Mathematical Constants::      
+* Infinities and Not-a-number::  
+* Elementary Functions::        
+* Small integer powers::        
+* Testing the Sign of Numbers::  
+* Testing for Odd and Even Numbers::  
+* Maximum and Minimum functions::  
+* Approximate Comparison of Floating Point Numbers::  
 
 
 File: gsl-ref.info,  Node: Mathematical Constants,  Next: Infinities and Not-a-number,  Up: Mathematical Functions
@@ -1125,60 +1120,59 @@ File: gsl-ref.info,  Node: Mathematical Constants,  Next: Infinities and Not-a-n
 ==========================
 
 The library ensures that the standard BSD mathematical constants are
-defined. For reference, here is a list of the constants:
+defined.  For reference, here is a list of the constants:
 
-`M_E'
+'M_E'
      The base of exponentials, e
 
-`M_LOG2E'
+'M_LOG2E'
      The base-2 logarithm of e, \log_2 (e)
 
-`M_LOG10E'
+'M_LOG10E'
      The base-10 logarithm of e, \log_10 (e)
 
-`M_SQRT2'
+'M_SQRT2'
      The square root of two, \sqrt 2
 
-`M_SQRT1_2'
+'M_SQRT1_2'
      The square root of one-half, \sqrt{1/2}
 
-`M_SQRT3'
+'M_SQRT3'
      The square root of three, \sqrt 3
 
-`M_PI'
+'M_PI'
      The constant pi, \pi
 
-`M_PI_2'
+'M_PI_2'
      Pi divided by two, \pi/2
 
-`M_PI_4'
+'M_PI_4'
      Pi divided by four, \pi/4
 
-`M_SQRTPI'
+'M_SQRTPI'
      The square root of pi, \sqrt\pi
 
-`M_2_SQRTPI'
+'M_2_SQRTPI'
      Two divided by the square root of pi, 2/\sqrt\pi
 
-`M_1_PI'
+'M_1_PI'
      The reciprocal of pi, 1/\pi
 
-`M_2_PI'
+'M_2_PI'
      Twice the reciprocal of pi, 2/\pi
 
-`M_LN10'
+'M_LN10'
      The natural logarithm of ten, \ln(10)
 
-`M_LN2'
+'M_LN2'
      The natural logarithm of two, \ln(2)
 
-`M_LNPI'
+'M_LNPI'
      The natural logarithm of pi, \ln(\pi)
 
-`M_EULER'
+'M_EULER'
      Euler's constant, \gamma
 
-
 
 File: gsl-ref.info,  Node: Infinities and Not-a-number,  Next: Elementary Functions,  Prev: Mathematical Constants,  Up: Mathematical Functions
 
@@ -1187,15 +1181,15 @@ File: gsl-ref.info,  Node: Infinities and Not-a-number,  Next: Elementary Functi
 
  -- Macro: GSL_POSINF
      This macro contains the IEEE representation of positive infinity,
-     +\infty. It is computed from the expression `+1.0/0.0'.
+     +\infty.  It is computed from the expression '+1.0/0.0'.
 
  -- Macro: GSL_NEGINF
      This macro contains the IEEE representation of negative infinity,
-     -\infty. It is computed from the expression `-1.0/0.0'.
+     -\infty.  It is computed from the expression '-1.0/0.0'.
 
  -- Macro: GSL_NAN
      This macro contains the IEEE representation of the Not-a-Number
-     symbol, `NaN'. It is computed from the ratio `0.0/0.0'.
+     symbol, 'NaN'.  It is computed from the ratio '0.0/0.0'.
 
  -- Function: int gsl_isnan (const double X)
      This function returns 1 if X is not-a-number.
@@ -1217,46 +1211,46 @@ File: gsl-ref.info,  Node: Elementary Functions,  Next: Small integer powers,  P
 The following routines provide portable implementations of functions
 found in the BSD math library.  When native versions are not available
 the functions described here can be used instead.  The substitution can
-be made automatically if you use `autoconf' to compile your application
+be made automatically if you use 'autoconf' to compile your application
 (*note Portability functions::).
 
  -- Function: double gsl_log1p (const double X)
      This function computes the value of \log(1+x) in a way that is
-     accurate for small X. It provides an alternative to the BSD math
-     function `log1p(x)'.
+     accurate for small X.  It provides an alternative to the BSD math
+     function 'log1p(x)'.
 
  -- Function: double gsl_expm1 (const double X)
      This function computes the value of \exp(x)-1 in a way that is
-     accurate for small X. It provides an alternative to the BSD math
-     function `expm1(x)'.
+     accurate for small X.  It provides an alternative to the BSD math
+     function 'expm1(x)'.
 
  -- Function: double gsl_hypot (const double X, const double Y)
      This function computes the value of \sqrt{x^2 + y^2} in a way that
-     avoids overflow. It provides an alternative to the BSD math
-     function `hypot(x,y)'.
+     avoids overflow.  It provides an alternative to the BSD math
+     function 'hypot(x,y)'.
 
  -- Function: double gsl_acosh (const double X)
-     This function computes the value of \arccosh(x). It provides an
-     alternative to the standard math function `acosh(x)'.
+     This function computes the value of \arccosh(x).  It provides an
+     alternative to the standard math function 'acosh(x)'.
 
  -- Function: double gsl_asinh (const double X)
-     This function computes the value of \arcsinh(x). It provides an
-     alternative to the standard math function `asinh(x)'.
+     This function computes the value of \arcsinh(x).  It provides an
+     alternative to the standard math function 'asinh(x)'.
 
  -- Function: double gsl_atanh (const double X)
-     This function computes the value of \arctanh(x). It provides an
-     alternative to the standard math function `atanh(x)'.
+     This function computes the value of \arctanh(x).  It provides an
+     alternative to the standard math function 'atanh(x)'.
 
  -- Function: double gsl_ldexp (double X, int E)
-     This function computes the value of x * 2^e. It provides an
-     alternative to the standard math function `ldexp(x,e)'.
+     This function computes the value of x * 2^e.  It provides an
+     alternative to the standard math function 'ldexp(x,e)'.
 
  -- Function: double gsl_frexp (double X, int * E)
      This function splits the number x into its normalized fraction f
-     and exponent e, such that x = f * 2^e and 0.5 <= f < 1. The
-     function returns f and stores the exponent in e. If x is zero,
-     both f and e are set to zero. This function provides an
-     alternative to the standard math function `frexp(x, e)'.
+     and exponent e, such that x = f * 2^e and 0.5 <= f < 1.  The
+     function returns f and stores the exponent in e.  If x is zero,
+     both f and e are set to zero.  This function provides an
+     alternative to the standard math function 'frexp(x, e)'.
 
 
 File: gsl-ref.info,  Node: Small integer powers,  Next: Testing the Sign of Numbers,  Prev: Elementary Functions,  Up: Mathematical Functions
@@ -1272,9 +1266,9 @@ functions do not check for overflow or underflow conditions.
  -- Function: double gsl_pow_int (double X, int N)
      This routine computes the power x^n for integer N.  The power is
      computed efficiently--for example, x^8 is computed as ((x^2)^2)^2,
-     requiring only 3 multiplications.  A version of this function
-     which also computes the numerical error in the result is available
-     as `gsl_sf_pow_int_e'.
+     requiring only 3 multiplications.  A version of this function which
+     also computes the numerical error in the result is available as
+     'gsl_sf_pow_int_e'.
 
  -- Function: double gsl_pow_2 (const double X)
  -- Function: double gsl_pow_3 (const double X)
@@ -1285,8 +1279,8 @@ functions do not check for overflow or underflow conditions.
  -- Function: double gsl_pow_8 (const double X)
  -- Function: double gsl_pow_9 (const double X)
      These functions can be used to compute small integer powers x^2,
-     x^3, etc. efficiently. The functions will be inlined when possible
-     so that use of these functions should be as efficient as
+     x^3, etc.  efficiently.  The functions will be inlined when
+     possible so that use of these functions should be as efficient as
      explicitly writing the corresponding product expression.
 
      #include <gsl/gsl_math.h>
@@ -1299,9 +1293,9 @@ File: gsl-ref.info,  Node: Testing the Sign of Numbers,  Next: Testing for Odd a
 ===============================
 
  -- Macro: GSL_SIGN (x)
-     This macro returns the sign of X. It is defined as `((x) >= 0 ? 1
-     : -1)'. Note that with this definition the sign of zero is positive
-     (regardless of its IEEE sign bit).
+     This macro returns the sign of X.  It is defined as '((x) >= 0 ? 1
+     : -1)'.  Note that with this definition the sign of zero is
+     positive (regardless of its IEEE sign bit).
 
 
 File: gsl-ref.info,  Node: Testing for Odd and Even Numbers,  Next: Maximum and Minimum functions,  Prev: Testing the Sign of Numbers,  Up: Mathematical Functions
@@ -1310,12 +1304,12 @@ File: gsl-ref.info,  Node: Testing for Odd and Even Numbers,  Next: Maximum and
 ====================================
 
  -- Macro: GSL_IS_ODD (n)
-     This macro evaluates to 1 if N is odd and 0 if N is even. The
+     This macro evaluates to 1 if N is odd and 0 if N is even.  The
      argument N must be of integer type.
 
  -- Macro: GSL_IS_EVEN (n)
-     This macro is the opposite of `GSL_IS_ODD(n)'. It evaluates to 1 if
-     N is even and 0 if N is odd. The argument N must be of integer
+     This macro is the opposite of 'GSL_IS_ODD(n)'.  It evaluates to 1
+     if N is even and 0 if N is odd.  The argument N must be of integer
      type.
 
 
@@ -1325,33 +1319,33 @@ File: gsl-ref.info,  Node: Maximum and Minimum functions,  Next: Approximate Com
 =================================
 
  -- Macro: GSL_MAX (a, b)
-     This macro returns the maximum of A and B. It is defined as `((a)
+     This macro returns the maximum of A and B.  It is defined as '((a)
      > (b) ? (a):(b))'.
 
  -- Macro: GSL_MIN (a, b)
-     This macro returns the minimum of A and B. It is defined as `((a)
+     This macro returns the minimum of A and B.  It is defined as '((a)
      < (b) ? (a):(b))'.
 
  -- Function: extern inline double GSL_MAX_DBL (double A, double B)
-     This function returns the maximum of the double precision numbers
-     A and B using an inline function. The use of a function allows for
-     type checking of the arguments as an extra safety feature. On
+     This function returns the maximum of the double precision numbers A
+     and B using an inline function.  The use of a function allows for
+     type checking of the arguments as an extra safety feature.  On
      platforms where inline functions are not available the macro
-     `GSL_MAX' will be automatically substituted.
+     'GSL_MAX' will be automatically substituted.
 
  -- Function: extern inline double GSL_MIN_DBL (double A, double B)
-     This function returns the minimum of the double precision numbers
-     A and B using an inline function. The use of a function allows for
-     type checking of the arguments as an extra safety feature. On
+     This function returns the minimum of the double precision numbers A
+     and B using an inline function.  The use of a function allows for
+     type checking of the arguments as an extra safety feature.  On
      platforms where inline functions are not available the macro
-     `GSL_MIN' will be automatically substituted.
+     'GSL_MIN' will be automatically substituted.
 
  -- Function: extern inline int GSL_MAX_INT (int A, int B)
  -- Function: extern inline int GSL_MIN_INT (int A, int B)
-     These functions return the maximum or minimum of the integers A
-     and B using an inline function.  On platforms where inline
-     functions are not available the macros `GSL_MAX' or `GSL_MIN' will
-     be automatically substituted.
+     These functions return the maximum or minimum of the integers A and
+     B using an inline function.  On platforms where inline functions
+     are not available the macros 'GSL_MAX' or 'GSL_MIN' will be
+     automatically substituted.
 
  -- Function: extern inline long double GSL_MAX_LDBL (long double A,
           long double B)
@@ -1359,7 +1353,7 @@ File: gsl-ref.info,  Node: Maximum and Minimum functions,  Next: Approximate Com
           long double B)
      These functions return the maximum or minimum of the long doubles A
      and B using an inline function.  On platforms where inline
-     functions are not available the macros `GSL_MAX' or `GSL_MIN' will
+     functions are not available the macros 'GSL_MAX' or 'GSL_MIN' will
      be automatically substituted.
 
 
@@ -1371,22 +1365,22 @@ File: gsl-ref.info,  Node: Approximate Comparison of Floating Point Numbers,  Pr
 It is sometimes useful to be able to compare two floating point numbers
 approximately, to allow for rounding and truncation errors.  The
 following function implements the approximate floating-point comparison
-algorithm proposed by D.E. Knuth in Section 4.2.2 of `Seminumerical
+algorithm proposed by D.E. Knuth in Section 4.2.2 of 'Seminumerical
 Algorithms' (3rd edition).
 
  -- Function: int gsl_fcmp (double X, double Y, double EPSILON)
-     This function determines whether x and y are approximately equal
-     to a relative accuracy EPSILON.
+     This function determines whether x and y are approximately equal to
+     a relative accuracy EPSILON.
 
      The relative accuracy is measured using an interval of size 2
      \delta, where \delta = 2^k \epsilon and k is the maximum base-2
-     exponent of x and y as computed by the function `frexp'.
+     exponent of x and y as computed by the function 'frexp'.
 
      If x and y lie within this interval, they are considered
-     approximately equal and the function returns 0. Otherwise if x <
+     approximately equal and the function returns 0.  Otherwise if x <
      y, the function returns -1, or if x > y, the function returns +1.
 
-     The implementation is based on the package `fcmp' by T.C. Belding.
+     The implementation is based on the package 'fcmp' by T.C. Belding.
 
 
 File: gsl-ref.info,  Node: Complex Numbers,  Next: Polynomials,  Prev: Mathematical Functions,  Up: Top
@@ -1396,31 +1390,31 @@ File: gsl-ref.info,  Node: Complex Numbers,  Next: Polynomials,  Prev: Mathemati
 
 The functions described in this chapter provide support for complex
 numbers.  The algorithms take care to avoid unnecessary intermediate
-underflows and overflows, allowing the functions to be evaluated over
-as much of the complex plane as possible.
+underflows and overflows, allowing the functions to be evaluated over as
+much of the complex plane as possible.
 
    For multiple-valued functions the branch cuts have been chosen to
-follow the conventions of Abramowitz and Stegun in the `Handbook of
-Mathematical Functions'. The functions return principal values which are
-the same as those in GNU Calc, which in turn are the same as those in
-`Common Lisp, The Language (Second Edition)'(1) and the HP-28/48 series
-of calculators.
+follow the conventions of Abramowitz and Stegun in the 'Handbook of
+Mathematical Functions'.  The functions return principal values which
+are the same as those in GNU Calc, which in turn are the same as those
+in 'Common Lisp, The Language (Second Edition)'(1) and the HP-28/48
+series of calculators.
 
-   The complex types are defined in the header file `gsl_complex.h',
+   The complex types are defined in the header file 'gsl_complex.h',
 while the corresponding complex functions and arithmetic operations are
-defined in `gsl_complex_math.h'.
+defined in 'gsl_complex_math.h'.
 
 * Menu:
 
-* Complex numbers::
-* Properties of complex numbers::
-* Complex arithmetic operators::
-* Elementary Complex Functions::
-* Complex Trigonometric Functions::
-* Inverse Complex Trigonometric Functions::
-* Complex Hyperbolic Functions::
-* Inverse Complex Hyperbolic Functions::
-* Complex Number References and Further Reading::
+* Complex numbers::             
+* Properties of complex numbers::  
+* Complex arithmetic operators::  
+* Elementary Complex Functions::  
+* Complex Trigonometric Functions::  
+* Inverse Complex Trigonometric Functions::  
+* Complex Hyperbolic Functions::  
+* Inverse Complex Hyperbolic Functions::  
+* Complex Number References and Further Reading::  
 
    ---------- Footnotes ----------
 
@@ -1432,13 +1426,13 @@ File: gsl-ref.info,  Node: Complex numbers,  Next: Properties of complex numbers
 5.1 Complex numbers
 ===================
 
-Complex numbers are represented using the type `gsl_complex'. The
+Complex numbers are represented using the type 'gsl_complex'.  The
 internal representation of this type may vary across platforms and
-should not be accessed directly. The functions and macros described
+should not be accessed directly.  The functions and macros described
 below allow complex numbers to be manipulated in a portable way.
 
-   For reference, the default form of the `gsl_complex' type is given
-by the following struct,
+   For reference, the default form of the 'gsl_complex' type is given by
+the following struct,
 
      typedef struct
      {
@@ -1446,9 +1440,9 @@ by the following struct,
      } gsl_complex;
 
 The real and imaginary part are stored in contiguous elements of a two
-element array. This eliminates any padding between the real and
-imaginary parts, `dat[0]' and `dat[1]', allowing the struct to be
-mapped correctly onto packed complex arrays.
+element array.  This eliminates any padding between the real and
+imaginary parts, 'dat[0]' and 'dat[1]', allowing the struct to be mapped
+correctly onto packed complex arrays.
 
  -- Function: gsl_complex gsl_complex_rect (double X, double Y)
      This function uses the rectangular cartesian components (X,Y) to
@@ -1498,9 +1492,9 @@ File: gsl-ref.info,  Node: Properties of complex numbers,  Next: Complex arithme
  -- Function: double gsl_complex_logabs (gsl_complex Z)
      This function returns the natural logarithm of the magnitude of the
      complex number Z, \log|z|.  It allows an accurate evaluation of
-     \log|z| when |z| is close to one. The direct evaluation of
-     `log(gsl_complex_abs(z))' would lead to a loss of precision in
-     this case.
+     \log|z| when |z| is close to one.  The direct evaluation of
+     'log(gsl_complex_abs(z))' would lead to a loss of precision in this
+     case.
 
 
 File: gsl-ref.info,  Node: Complex arithmetic operators,  Next: Elementary Complex Functions,  Prev: Properties of complex numbers,  Up: Complex Numbers
@@ -1576,30 +1570,30 @@ File: gsl-ref.info,  Node: Elementary Complex Functions,  Next: Complex Trigonom
 
  -- Function: gsl_complex gsl_complex_sqrt (gsl_complex Z)
      This function returns the square root of the complex number Z,
-     \sqrt z. The branch cut is the negative real axis. The result
+     \sqrt z.  The branch cut is the negative real axis.  The result
      always lies in the right half of the complex plane.
 
  -- Function: gsl_complex gsl_complex_sqrt_real (double X)
-     This function returns the complex square root of the real number
-     X, where X may be negative.
+     This function returns the complex square root of the real number X,
+     where X may be negative.
 
  -- Function: gsl_complex gsl_complex_pow (gsl_complex Z, gsl_complex A)
      The function returns the complex number Z raised to the complex
-     power A, z^a. This is computed as \exp(\log(z)*a) using complex
+     power A, z^a.  This is computed as \exp(\log(z)*a) using complex
      logarithms and complex exponentials.
 
  -- Function: gsl_complex gsl_complex_pow_real (gsl_complex Z, double X)
-     This function returns the complex number Z raised to the real
-     power X, z^x.
+     This function returns the complex number Z raised to the real power
+     X, z^x.
 
  -- Function: gsl_complex gsl_complex_exp (gsl_complex Z)
      This function returns the complex exponential of the complex number
      Z, \exp(z).
 
  -- Function: gsl_complex gsl_complex_log (gsl_complex Z)
-     This function returns the complex natural logarithm (base e) of
-     the complex number Z, \log(z).  The branch cut is the negative
-     real axis.
+     This function returns the complex natural logarithm (base e) of the
+     complex number Z, \log(z).  The branch cut is the negative real
+     axis.
 
  -- Function: gsl_complex gsl_complex_log10 (gsl_complex Z)
      This function returns the complex base-10 logarithm of the complex
@@ -1608,7 +1602,7 @@ File: gsl-ref.info,  Node: Elementary Complex Functions,  Next: Complex Trigonom
  -- Function: gsl_complex gsl_complex_log_b (gsl_complex Z, gsl_complex
           B)
      This function returns the complex base-B logarithm of the complex
-     number Z, \log_b(z). This quantity is computed as the ratio
+     number Z, \log_b(z).  This quantity is computed as the ratio
      \log(z)/\log(b).
 
 
@@ -1649,32 +1643,32 @@ File: gsl-ref.info,  Node: Inverse Complex Trigonometric Functions,  Next: Compl
 
  -- Function: gsl_complex gsl_complex_arcsin (gsl_complex Z)
      This function returns the complex arcsine of the complex number Z,
-     \arcsin(z). The branch cuts are on the real axis, less than -1 and
+     \arcsin(z).  The branch cuts are on the real axis, less than -1 and
      greater than 1.
 
  -- Function: gsl_complex gsl_complex_arcsin_real (double Z)
      This function returns the complex arcsine of the real number Z,
-     \arcsin(z). For z between -1 and 1, the function returns a real
-     value in the range [-\pi/2,\pi/2]. For z less than -1 the result
+     \arcsin(z).  For z between -1 and 1, the function returns a real
+     value in the range [-\pi/2,\pi/2].  For z less than -1 the result
      has a real part of -\pi/2 and a positive imaginary part.  For z
      greater than 1 the result has a real part of \pi/2 and a negative
      imaginary part.
 
  -- Function: gsl_complex gsl_complex_arccos (gsl_complex Z)
      This function returns the complex arccosine of the complex number
-     Z, \arccos(z). The branch cuts are on the real axis, less than -1
+     Z, \arccos(z).  The branch cuts are on the real axis, less than -1
      and greater than 1.
 
  -- Function: gsl_complex gsl_complex_arccos_real (double Z)
      This function returns the complex arccosine of the real number Z,
-     \arccos(z). For z between -1 and 1, the function returns a real
-     value in the range [0,\pi]. For z less than -1 the result has a
-     real part of \pi and a negative imaginary part.  For z greater
-     than 1 the result is purely imaginary and positive.
+     \arccos(z).  For z between -1 and 1, the function returns a real
+     value in the range [0,\pi].  For z less than -1 the result has a
+     real part of \pi and a negative imaginary part.  For z greater than
+     1 the result is purely imaginary and positive.
 
  -- Function: gsl_complex gsl_complex_arctan (gsl_complex Z)
      This function returns the complex arctangent of the complex number
-     Z, \arctan(z). The branch cuts are on the imaginary axis, below -i
+     Z, \arctan(z).  The branch cuts are on the imaginary axis, below -i
      and above i.
 
  -- Function: gsl_complex gsl_complex_arcsec (gsl_complex Z)
@@ -1686,8 +1680,8 @@ File: gsl-ref.info,  Node: Inverse Complex Trigonometric Functions,  Next: Compl
      \arcsec(z) = \arccos(1/z).
 
  -- Function: gsl_complex gsl_complex_arccsc (gsl_complex Z)
-     This function returns the complex arccosecant of the complex
-     number Z, \arccsc(z) = \arcsin(1/z).
+     This function returns the complex arccosecant of the complex number
+     Z, \arccsc(z) = \arcsin(1/z).
 
  -- Function: gsl_complex gsl_complex_arccsc_real (double Z)
      This function returns the complex arccosecant of the real number Z,
@@ -1712,8 +1706,8 @@ File: gsl-ref.info,  Node: Complex Hyperbolic Functions,  Next: Inverse Complex
      number Z, \cosh(z) = (\exp(z) + \exp(-z))/2.
 
  -- Function: gsl_complex gsl_complex_tanh (gsl_complex Z)
-     This function returns the complex hyperbolic tangent of the
-     complex number Z, \tanh(z) = \sinh(z)/\cosh(z).
+     This function returns the complex hyperbolic tangent of the complex
+     number Z, \tanh(z) = \sinh(z)/\cosh(z).
 
  -- Function: gsl_complex gsl_complex_sech (gsl_complex Z)
      This function returns the complex hyperbolic secant of the complex
@@ -1734,15 +1728,15 @@ File: gsl-ref.info,  Node: Inverse Complex Hyperbolic Functions,  Next: Complex
 ========================================
 
  -- Function: gsl_complex gsl_complex_arcsinh (gsl_complex Z)
-     This function returns the complex hyperbolic arcsine of the
-     complex number Z, \arcsinh(z).  The branch cuts are on the
-     imaginary axis, below -i and above i.
+     This function returns the complex hyperbolic arcsine of the complex
+     number Z, \arcsinh(z).  The branch cuts are on the imaginary axis,
+     below -i and above i.
 
  -- Function: gsl_complex gsl_complex_arccosh (gsl_complex Z)
      This function returns the complex hyperbolic arccosine of the
-     complex number Z, \arccosh(z).  The branch cut is on the real
-     axis, less than 1.  Note that in this case we use the negative
-     square root in formula 4.6.21 of Abramowitz & Stegun giving
+     complex number Z, \arccosh(z).  The branch cut is on the real axis,
+     less than 1.  Note that in this case we use the negative square
+     root in formula 4.6.21 of Abramowitz & Stegun giving
      \arccosh(z)=\log(z-\sqrt{z^2-1}).
 
  -- Function: gsl_complex gsl_complex_arccosh_real (double Z)
@@ -1781,18 +1775,18 @@ based on the following papers,
 
      T. E. Hull, Thomas F. Fairgrieve, Ping Tak Peter Tang,
      "Implementing Complex Elementary Functions Using Exception
-     Handling", `ACM Transactions on Mathematical Software', Volume 20
+     Handling", 'ACM Transactions on Mathematical Software', Volume 20
      (1994), pp 215-244, Corrigenda, p553
 
      T. E. Hull, Thomas F. Fairgrieve, Ping Tak Peter Tang,
      "Implementing the complex arcsin and arccosine functions using
-     exception handling", `ACM Transactions on Mathematical Software',
+     exception handling", 'ACM Transactions on Mathematical Software',
      Volume 23 (1997) pp 299-335
 
 The general formulas and details of branch cuts can be found in the
 following books,
 
-     Abramowitz and Stegun, `Handbook of Mathematical Functions',
+     Abramowitz and Stegun, 'Handbook of Mathematical Functions',
      "Circular Functions in Terms of Real and Imaginary Parts", Formulas
      4.3.55-58, "Inverse Circular Functions in Terms of Real and
      Imaginary Parts", Formulas 4.4.37-39, "Hyperbolic Functions in
@@ -1800,7 +1794,7 @@ following books,
      Hyperbolic Functions--relation to Inverse Circular Functions",
      Formulas 4.6.14-19.
 
-     Dave Gillespie, `Calc Manual', Free Software Foundation, ISBN
+     Dave Gillespie, 'Calc Manual', Free Software Foundation, ISBN
      1-882114-18-3
 
 
@@ -1814,17 +1808,17 @@ There are routines for finding real and complex roots of quadratic and
 cubic equations using analytic methods.  An iterative polynomial solver
 is also available for finding the roots of general polynomials with real
 coefficients (of any order).  The functions are declared in the header
-file `gsl_poly.h'.
+file 'gsl_poly.h'.
 
 * Menu:
 
-* Polynomial Evaluation::
-* Divided Difference Representation of Polynomials::
-* Quadratic Equations::
-* Cubic Equations::
-* General Polynomial Equations::
-* Roots of Polynomials Examples::
-* Roots of Polynomials References and Further Reading::
+* Polynomial Evaluation::       
+* Divided Difference Representation of Polynomials::  
+* Quadratic Equations::         
+* Cubic Equations::             
+* General Polynomial Equations::  
+* Roots of Polynomials Examples::  
+* Roots of Polynomials References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Polynomial Evaluation,  Next: Divided Difference Representation of Polynomials,  Up: Polynomials
@@ -1852,15 +1846,13 @@ described in Abramowitz & Stegun sections 25.1.4 and 25.2.26.
           const double YA[], size_t SIZE)
      This function computes a divided-difference representation of the
      interpolating polynomial for the points (XA, YA) stored in the
-     arrays XA and YA of length SIZE.  On output the
-     divided-differences of (XA,YA) are stored in the array DD, also of
-     length SIZE.
+     arrays XA and YA of length SIZE.  On output the divided-differences
+     of (XA,YA) are stored in the array DD, also of length SIZE.
 
  -- Function: double gsl_poly_dd_eval (const double DD[], const double
           XA[], const size_t SIZE, const double X)
-     This function evaluates the polynomial stored in
-     divided-difference form in the arrays DD and XA of length SIZE at
-     the point X.
+     This function evaluates the polynomial stored in divided-difference
+     form in the arrays DD and XA of length SIZE at the point X.
 
  -- Function: int gsl_poly_dd_taylor (double C[], double XP, const
           double DD[], const double XA[], size_t SIZE, double W[])
@@ -1886,23 +1878,22 @@ File: gsl-ref.info,  Node: Quadratic Equations,  Next: Cubic Equations,  Prev: D
      The number of real roots (either zero, one or two) is returned, and
      their locations are stored in X0 and X1.  If no real roots are
      found then X0 and X1 are not modified.  If one real root is found
-     (i.e. if a=0) then it is stored in X0.  When two real roots are
-     found they are stored in X0 and X1 in ascending order.  The case
-     of coincident roots is not considered special.  For example
-     (x-1)^2=0 will have two roots, which happen to have exactly equal
-     values.
+     (i.e.  if a=0) then it is stored in X0.  When two real roots are
+     found they are stored in X0 and X1 in ascending order.  The case of
+     coincident roots is not considered special.  For example (x-1)^2=0
+     will have two roots, which happen to have exactly equal values.
 
      The number of roots found depends on the sign of the discriminant
      b^2 - 4 a c.  This will be subject to rounding and cancellation
      errors when computed in double precision, and will also be subject
-     to errors if the coefficients of the polynomial are inexact.
-     These errors may cause a discrete change in the number of roots.
+     to errors if the coefficients of the polynomial are inexact.  These
+     errors may cause a discrete change in the number of roots.
      However, for polynomials with small integer coefficients the
      discriminant can always be computed exactly.
 
-
  -- Function: int gsl_poly_complex_solve_quadratic (double A, double B,
           double C, gsl_complex * Z0, gsl_complex * Z1)
+
      This function finds the complex roots of the quadratic equation,
 
           a z^2 + b z + c = 0
@@ -1911,8 +1902,7 @@ File: gsl-ref.info,  Node: Quadratic Equations,  Next: Cubic Equations,  Prev: D
      locations of the roots are stored in Z0 and Z1.  The roots are
      returned in ascending order, sorted first by their real components
      and then by their imaginary components.  If only one real root is
-     found (i.e. if a=0) then it is stored in Z0.
-
+     found (i.e.  if a=0) then it is stored in Z0.
 
 
 File: gsl-ref.info,  Node: Cubic Equations,  Next: General Polynomial Equations,  Prev: Quadratic Equations,  Up: Polynomials
@@ -1922,6 +1912,7 @@ File: gsl-ref.info,  Node: Cubic Equations,  Next: General Polynomial Equations,
 
  -- Function: int gsl_poly_solve_cubic (double A, double B, double C,
           double * X0, double * X1, double * X2)
+
      This function finds the real roots of the cubic equation,
 
           x^3 + a x^2 + b x + c = 0
@@ -1934,10 +1925,10 @@ File: gsl-ref.info,  Node: Cubic Equations,  Next: General Polynomial Equations,
      considered special.  For example, the equation (x-1)^3=0 will have
      three roots with exactly equal values.
 
-
  -- Function: int gsl_poly_complex_solve_cubic (double A, double B,
           double C, gsl_complex * Z0, gsl_complex * Z1, gsl_complex *
           Z2)
+
      This function finds the complex roots of the cubic equation,
 
           z^3 + a z^2 + b z + c = 0
@@ -1947,7 +1938,6 @@ File: gsl-ref.info,  Node: Cubic Equations,  Next: General Polynomial Equations,
      returned in ascending order, sorted first by their real components
      and then by their imaginary components.
 
-
 
 File: gsl-ref.info,  Node: General Polynomial Equations,  Next: Roots of Polynomials Examples,  Prev: Cubic Equations,  Up: Polynomials
 
@@ -1960,13 +1950,13 @@ algorithm described in this section uses an iterative method to find the
 approximate locations of roots of higher order polynomials.
 
  -- Function: gsl_poly_complex_workspace *
-gsl_poly_complex_workspace_alloc (size_t N)
-     This function allocates space for a `gsl_poly_complex_workspace'
+          gsl_poly_complex_workspace_alloc (size_t N)
+     This function allocates space for a 'gsl_poly_complex_workspace'
      struct and a workspace suitable for solving a polynomial with N
-     coefficients using the routine `gsl_poly_complex_solve'.
+     coefficients using the routine 'gsl_poly_complex_solve'.
 
      The function returns a pointer to the newly allocated
-     `gsl_poly_complex_workspace' if no errors were detected, and a null
+     'gsl_poly_complex_workspace' if no errors were detected, and a null
      pointer in the case of error.
 
  -- Function: void gsl_poly_complex_workspace_free
@@ -1984,15 +1974,15 @@ gsl_poly_complex_workspace_alloc (size_t N)
      complex array Z of length 2(n-1), alternating real and imaginary
      parts.
 
-     The function returns `GSL_SUCCESS' if all the roots are found. If
+     The function returns 'GSL_SUCCESS' if all the roots are found.  If
      the QR reduction does not converge, the error handler is invoked
-     with an error code of `GSL_EFAILED'.  Note that due to finite
+     with an error code of 'GSL_EFAILED'.  Note that due to finite
      precision, roots of higher multiplicity are returned as a cluster
-     of simple roots with reduced accuracy.  The solution of
-     polynomials with higher-order roots requires specialized
-     algorithms that take the multiplicity structure into account (see
-     e.g. Z. Zeng, Algorithm 835, ACM Transactions on Mathematical
-     Software, Volume 30, Issue 2 (2004), pp 218-236).
+     of simple roots with reduced accuracy.  The solution of polynomials
+     with higher-order roots requires specialized algorithms that take
+     the multiplicity structure into account (see e.g.  Z. Zeng,
+     Algorithm 835, ACM Transactions on Mathematical Software, Volume
+     30, Issue 2 (2004), pp 218-236).
 
 
 File: gsl-ref.info,  Node: Roots of Polynomials Examples,  Next: Roots of Polynomials References and Further Reading,  Prev: General Polynomial Equations,  Up: Polynomials
@@ -2055,20 +2045,20 @@ The balanced-QR method and its error analysis are described in the
 following papers,
 
      R.S. Martin, G. Peters and J.H. Wilkinson, "The QR Algorithm for
-     Real Hessenberg Matrices", `Numerische Mathematik', 14 (1970),
+     Real Hessenberg Matrices", 'Numerische Mathematik', 14 (1970),
      219-231.
 
      B.N. Parlett and C. Reinsch, "Balancing a Matrix for Calculation of
-     Eigenvalues and Eigenvectors", `Numerische Mathematik', 13 (1969),
+     Eigenvalues and Eigenvectors", 'Numerische Mathematik', 13 (1969),
      293-304.
 
      A. Edelman and H. Murakami, "Polynomial roots from companion matrix
-     eigenvalues", `Mathematics of Computation', Vol. 64, No. 210
+     eigenvalues", 'Mathematics of Computation', Vol. 64, No. 210
      (1995), 763-776.
 
 The formulas for divided differences are given in Abramowitz and Stegun,
 
-     Abramowitz and Stegun, `Handbook of Mathematical Functions',
+     Abramowitz and Stegun, 'Handbook of Mathematical Functions',
      Sections 25.1.4 and 25.2.26.
 
 
@@ -2090,45 +2080,45 @@ Zeta functions.  Each routine also computes an estimate of the numerical
 error in the calculated value of the function.
 
    The functions in this chapter are declared in individual header
-files, such as `gsl_sf_airy.h', `gsl_sf_bessel.h', etc.  The complete
-set of header files can be included using the file `gsl_sf.h'.
+files, such as 'gsl_sf_airy.h', 'gsl_sf_bessel.h', etc.  The complete
+set of header files can be included using the file 'gsl_sf.h'.
 
 * Menu:
 
-* Special Function Usage::
-* The gsl_sf_result struct::
-* Special Function Modes::
-* Airy Functions and Derivatives::
-* Bessel Functions::
-* Clausen Functions::
-* Coulomb Functions::
-* Coupling Coefficients::
-* Dawson Function::
-* Debye Functions::
-* Dilogarithm::
-* Elementary Operations::
-* Elliptic Integrals::
-* Elliptic Functions (Jacobi)::
-* Error Functions::
-* Exponential Functions::
-* Exponential Integrals::
-* Fermi-Dirac Function::
-* Gamma and Beta Functions::
-* Gegenbauer Functions::
-* Hypergeometric Functions::
-* Laguerre Functions::
-* Lambert W Functions::
-* Legendre Functions and Spherical Harmonics::
-* Logarithm and Related Functions::
+* Special Function Usage::      
+* The gsl_sf_result struct::    
+* Special Function Modes::      
+* Airy Functions and Derivatives::  
+* Bessel Functions::            
+* Clausen Functions::           
+* Coulomb Functions::           
+* Coupling Coefficients::       
+* Dawson Function::             
+* Debye Functions::             
+* Dilogarithm::                 
+* Elementary Operations::       
+* Elliptic Integrals::          
+* Elliptic Functions (Jacobi)::  
+* Error Functions::             
+* Exponential Functions::       
+* Exponential Integrals::       
+* Fermi-Dirac Function::        
+* Gamma and Beta Functions::    
+* Gegenbauer Functions::        
+* Hypergeometric Functions::    
+* Laguerre Functions::          
+* Lambert W Functions::         
+* Legendre Functions and Spherical Harmonics::  
+* Logarithm and Related Functions::  
 * Mathieu Functions::
-* Power Function::
-* Psi (Digamma) Function::
-* Synchrotron Functions::
-* Transport Functions::
-* Trigonometric Functions::
-* Zeta Functions::
-* Special Functions Examples::
-* Special Functions References and Further Reading::
+* Power Function::              
+* Psi (Digamma) Function::      
+* Synchrotron Functions::       
+* Transport Functions::         
+* Trigonometric Functions::     
+* Zeta Functions::              
+* Special Functions Examples::  
+* Special Functions References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Special Function Usage,  Next: The gsl_sf_result struct,  Up: Special Functions
@@ -2154,10 +2144,10 @@ error-handling form stores the value and error in a modifiable argument,
      gsl_sf_result result;
      int status = gsl_sf_bessel_J0_e (x, &result);
 
-The error-handling functions have the suffix `_e'. The returned status
+The error-handling functions have the suffix '_e'.  The returned status
 value indicates error conditions such as overflow, underflow or loss of
 precision.  If there are no errors the error-handling functions return
-`GSL_SUCCESS'.
+'GSL_SUCCESS'.
 
 
 File: gsl-ref.info,  Node: The gsl_sf_result struct,  Next: Special Function Modes,  Prev: Special Function Usage,  Up: Special Functions
@@ -2168,9 +2158,9 @@ File: gsl-ref.info,  Node: The gsl_sf_result struct,  Next: Special Function Mod
 The error handling form of the special functions always calculate an
 error estimate along with the value of the result.  Therefore,
 structures are provided for amalgamating a value and error estimate.
-These structures are declared in the header file `gsl_sf_result.h'.
+These structures are declared in the header file 'gsl_sf_result.h'.
 
-   The `gsl_sf_result' struct contains value and error fields.
+   The 'gsl_sf_result' struct contains value and error fields.
 
      typedef struct
      {
@@ -2185,8 +2175,8 @@ of the absolute error in the value.
 by a function.  In this case, it may be possible to return a scaling
 exponent as well as an error/value pair in order to save the result from
 exceeding the dynamic range of the built-in types.  The
-`gsl_sf_result_e10' struct contains value and error fields as well as
-an exponent field such that the actual result is obtained as `result *
+'gsl_sf_result_e10' struct contains value and error fields as well as an
+exponent field such that the actual result is obtained as 'result *
 10^(e10)'.
 
      typedef struct
@@ -2205,17 +2195,15 @@ File: gsl-ref.info,  Node: Special Function Modes,  Next: Airy Functions and Der
 The goal of the library is to achieve double precision accuracy wherever
 possible.  However the cost of evaluating some special functions to
 double precision can be significant, particularly where very high order
-terms are required.  In these cases a `mode' argument allows the
+terms are required.  In these cases a 'mode' argument allows the
 accuracy of the function to be reduced in order to improve performance.
 The following precision levels are available for the mode argument,
 
-`GSL_PREC_DOUBLE'
+'GSL_PREC_DOUBLE'
      Double-precision, a relative accuracy of approximately 2 * 10^-16.
-
-`GSL_PREC_SINGLE'
+'GSL_PREC_SINGLE'
      Single-precision, a relative accuracy of approximately 10^-7.
-
-`GSL_PREC_APPROX'
+'GSL_PREC_APPROX'
      Approximate values, a relative accuracy of approximately 5 * 10^-4.
 
 The approximate mode provides the fastest evaluation at the lowest
@@ -2233,15 +2221,15 @@ representations,
      Ai(x) = (1/\pi) \int_0^\infty \cos((1/3) t^3 + xt) dt
      Bi(x) = (1/\pi) \int_0^\infty (e^(-(1/3) t^3) + \sin((1/3) t^3 + xt)) dt
 
-For further information see Abramowitz & Stegun, Section 10.4. The Airy
-functions are defined in the header file `gsl_sf_airy.h'.
+For further information see Abramowitz & Stegun, Section 10.4.  The Airy
+functions are defined in the header file 'gsl_sf_airy.h'.
 
 * Menu:
 
-* Airy Functions::
-* Derivatives of Airy Functions::
-* Zeros of Airy Functions::
-* Zeros of Derivatives of Airy Functions::
+* Airy Functions::              
+* Derivatives of Airy Functions::  
+* Zeros of Airy Functions::     
+* Zeros of Derivatives of Airy Functions::  
 
 
 File: gsl-ref.info,  Node: Airy Functions,  Next: Derivatives of Airy Functions,  Up: Airy Functions and Derivatives
@@ -2264,16 +2252,16 @@ File: gsl-ref.info,  Node: Airy Functions,  Next: Derivatives of Airy Functions,
  -- Function: double gsl_sf_airy_Ai_scaled (double X, gsl_mode_t MODE)
  -- Function: int gsl_sf_airy_Ai_scaled_e (double X, gsl_mode_t MODE,
           gsl_sf_result * RESULT)
-     These routines compute a scaled version of the Airy function
-     S_A(x) Ai(x).  For x>0 the scaling factor S_A(x) is \exp(+(2/3)
-     x^(3/2)), and is 1 for x<0.
+     These routines compute a scaled version of the Airy function S_A(x)
+     Ai(x).  For x>0 the scaling factor S_A(x) is \exp(+(2/3) x^(3/2)),
+     and is 1 for x<0.
 
  -- Function: double gsl_sf_airy_Bi_scaled (double X, gsl_mode_t MODE)
  -- Function: int gsl_sf_airy_Bi_scaled_e (double X, gsl_mode_t MODE,
           gsl_sf_result * RESULT)
-     These routines compute a scaled version of the Airy function
-     S_B(x) Bi(x).  For x>0 the scaling factor S_B(x) is exp(-(2/3)
-     x^(3/2)), and is 1 for x<0.
+     These routines compute a scaled version of the Airy function S_B(x)
+     Bi(x).  For x>0 the scaling factor S_B(x) is exp(-(2/3) x^(3/2)),
+     and is 1 for x<0.
 
 
 File: gsl-ref.info,  Node: Derivatives of Airy Functions,  Next: Zeros of Airy Functions,  Prev: Airy Functions,  Up: Airy Functions and Derivatives
@@ -2298,8 +2286,8 @@ File: gsl-ref.info,  Node: Derivatives of Airy Functions,  Next: Zeros of Airy F
  -- Function: int gsl_sf_airy_Ai_deriv_scaled_e (double X, gsl_mode_t
           MODE, gsl_sf_result * RESULT)
      These routines compute the scaled Airy function derivative S_A(x)
-     Ai'(x).  For x>0 the scaling factor S_A(x) is \exp(+(2/3)
-     x^(3/2)), and is 1 for x<0.
+     Ai'(x).  For x>0 the scaling factor S_A(x) is \exp(+(2/3) x^(3/2)),
+     and is 1 for x<0.
 
  -- Function: double gsl_sf_airy_Bi_deriv_scaled (double X, gsl_mode_t
           MODE)
@@ -2316,14 +2304,14 @@ File: gsl-ref.info,  Node: Zeros of Airy Functions,  Next: Zeros of Derivatives
 -----------------------------
 
  -- Function: double gsl_sf_airy_zero_Ai (unsigned int S)
- -- Function: int gsl_sf_airy_zero_Ai_e (unsigned int S, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_airy_zero_Ai_e (unsigned int S, gsl_sf_result *
+          RESULT)
      These routines compute the location of the S-th zero of the Airy
      function Ai(x).
 
  -- Function: double gsl_sf_airy_zero_Bi (unsigned int S)
- -- Function: int gsl_sf_airy_zero_Bi_e (unsigned int S, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_airy_zero_Bi_e (unsigned int S, gsl_sf_result *
+          RESULT)
      These routines compute the location of the S-th zero of the Airy
      function Bi(x).
 
@@ -2356,23 +2344,23 @@ functions J_n(x), Y_n(x), Modified cylindrical Bessel functions I_n(x),
 K_n(x), Spherical Bessel functions j_l(x), y_l(x), and Modified
 Spherical Bessel functions i_l(x), k_l(x).  For more information see
 Abramowitz & Stegun, Chapters 9 and 10.  The Bessel functions are
-defined in the header file `gsl_sf_bessel.h'.
+defined in the header file 'gsl_sf_bessel.h'.
 
 * Menu:
 
-* Regular Cylindrical Bessel Functions::
-* Irregular Cylindrical Bessel Functions::
-* Regular Modified Cylindrical Bessel Functions::
-* Irregular Modified Cylindrical Bessel Functions::
-* Regular Spherical Bessel Functions::
-* Irregular Spherical Bessel Functions::
-* Regular Modified Spherical Bessel Functions::
-* Irregular Modified Spherical Bessel Functions::
-* Regular Bessel Function - Fractional Order::
-* Irregular Bessel Functions - Fractional Order::
-* Regular Modified Bessel Functions - Fractional Order::
-* Irregular Modified Bessel Functions - Fractional Order::
-* Zeros of Regular Bessel Functions::
+* Regular Cylindrical Bessel Functions::  
+* Irregular Cylindrical Bessel Functions::  
+* Regular Modified Cylindrical Bessel Functions::  
+* Irregular Modified Cylindrical Bessel Functions::  
+* Regular Spherical Bessel Functions::  
+* Irregular Spherical Bessel Functions::  
+* Regular Modified Spherical Bessel Functions::  
+* Irregular Modified Spherical Bessel Functions::  
+* Regular Bessel Function - Fractional Order::  
+* Irregular Bessel Functions - Fractional Order::  
+* Regular Modified Bessel Functions - Fractional Order::  
+* Irregular Modified Bessel Functions - Fractional Order::  
+* Zeros of Regular Bessel Functions::  
 
 
 File: gsl-ref.info,  Node: Regular Cylindrical Bessel Functions,  Next: Irregular Cylindrical Bessel Functions,  Up: Bessel Functions
@@ -2412,13 +2400,13 @@ File: gsl-ref.info,  Node: Irregular Cylindrical Bessel Functions,  Next: Regula
 
  -- Function: double gsl_sf_bessel_Y0 (double X)
  -- Function: int gsl_sf_bessel_Y0_e (double X, gsl_sf_result * RESULT)
-     These routines compute the irregular cylindrical Bessel function
-     of zeroth order, Y_0(x), for x>0.
+     These routines compute the irregular cylindrical Bessel function of
+     zeroth order, Y_0(x), for x>0.
 
  -- Function: double gsl_sf_bessel_Y1 (double X)
  -- Function: int gsl_sf_bessel_Y1_e (double X, gsl_sf_result * RESULT)
-     These routines compute the irregular cylindrical Bessel function
-     of first order, Y_1(x), for x>0.
+     These routines compute the irregular cylindrical Bessel function of
+     first order, Y_1(x), for x>0.
 
  -- Function: double gsl_sf_bessel_Yn (int N,double X)
  -- Function: int gsl_sf_bessel_Yn_e (int N,double X, gsl_sf_result *
@@ -2488,7 +2476,7 @@ File: gsl-ref.info,  Node: Regular Modified Cylindrical Bessel Functions,  Next:
           double X, double RESULT_ARRAY[])
      This routine computes the values of the scaled regular cylindrical
      Bessel functions \exp(-|x|) I_n(x) for n from NMIN to NMAX
-     inclusive, storing the results in the array RESULT_ARRAY. The
+     inclusive, storing the results in the array RESULT_ARRAY.  The
      start of the range NMIN must be positive or zero.  The values are
      computed using recurrence relations for efficiency, and therefore
      may differ slightly from the exact values.
@@ -2519,9 +2507,9 @@ File: gsl-ref.info,  Node: Irregular Modified Cylindrical Bessel Functions,  Nex
           double RESULT_ARRAY[])
      This routine computes the values of the irregular modified
      cylindrical Bessel functions K_n(x) for n from NMIN to NMAX
-     inclusive, storing the results in the array RESULT_ARRAY. The
-     start of the range NMIN must be positive or zero. The domain of
-     the function is x>0. The values are computed using recurrence
+     inclusive, storing the results in the array RESULT_ARRAY.  The
+     start of the range NMIN must be positive or zero.  The domain of
+     the function is x>0.  The values are computed using recurrence
      relations for efficiency, and therefore may differ slightly from
      the exact values.
 
@@ -2546,10 +2534,10 @@ File: gsl-ref.info,  Node: Irregular Modified Cylindrical Bessel Functions,  Nex
  -- Function: int gsl_sf_bessel_Kn_scaled_array (int NMIN, int NMAX,
           double X, double RESULT_ARRAY[])
      This routine computes the values of the scaled irregular
-     cylindrical Bessel functions \exp(x) K_n(x) for n from NMIN to
-     NMAX inclusive, storing the results in the array RESULT_ARRAY. The
+     cylindrical Bessel functions \exp(x) K_n(x) for n from NMIN to NMAX
+     inclusive, storing the results in the array RESULT_ARRAY.  The
      start of the range NMIN must be positive or zero.  The domain of
-     the function is x>0. The values are computed using recurrence
+     the function is x>0.  The values are computed using recurrence
      relations for efficiency, and therefore may differ slightly from
      the exact values.
 
@@ -2583,8 +2571,8 @@ File: gsl-ref.info,  Node: Regular Spherical Bessel Functions,  Next: Irregular
  -- Function: int gsl_sf_bessel_jl_array (int LMAX, double X, double
           RESULT_ARRAY[])
      This routine computes the values of the regular spherical Bessel
-     functions j_l(x) for l from 0 to LMAX inclusive  for lmax >= 0 and
-     x >= 0, storing the results in the array RESULT_ARRAY.  The values
+     functions j_l(x) for l from 0 to LMAX inclusive for lmax >= 0 and x
+     >= 0, storing the results in the array RESULT_ARRAY.  The values
      are computed using recurrence relations for efficiency, and
      therefore may differ slightly from the exact values.
 
@@ -2594,7 +2582,7 @@ File: gsl-ref.info,  Node: Regular Spherical Bessel Functions,  Next: Irregular
      regular spherical Bessel functions j_l(x) for l from 0 to LMAX
      inclusive for lmax >= 0 and x >= 0, storing the results in the
      array RESULT_ARRAY.  The Steed/Barnett algorithm is described in
-     `Comp. Phys. Comm.' 21, 297 (1981).  Steed's method is more stable
+     'Comp. Phys. Comm.' 21, 297 (1981).  Steed's method is more stable
      than the recurrence used in the other functions but is also slower.
 
 
@@ -2627,7 +2615,7 @@ File: gsl-ref.info,  Node: Irregular Spherical Bessel Functions,  Next: Regular
  -- Function: int gsl_sf_bessel_yl_array (int LMAX, double X, double
           RESULT_ARRAY[])
      This routine computes the values of the irregular spherical Bessel
-     functions y_l(x) for l from 0 to LMAX inclusive  for lmax >= 0,
+     functions y_l(x) for l from 0 to LMAX inclusive for lmax >= 0,
      storing the results in the array RESULT_ARRAY.  The values are
      computed using recurrence relations for efficiency, and therefore
      may differ slightly from the exact values.
@@ -2658,19 +2646,19 @@ the modified Bessel functions of fractional order, i_l(x) =
  -- Function: int gsl_sf_bessel_i2_scaled_e (double X, gsl_sf_result *
           RESULT)
      These routines compute the scaled regular modified spherical Bessel
-     function of second order,  \exp(-|x|) i_2(x)
+     function of second order, \exp(-|x|) i_2(x)
 
  -- Function: double gsl_sf_bessel_il_scaled (int L, double X)
  -- Function: int gsl_sf_bessel_il_scaled_e (int L, double X,
           gsl_sf_result * RESULT)
      These routines compute the scaled regular modified spherical Bessel
-     function of order L,  \exp(-|x|) i_l(x)
+     function of order L, \exp(-|x|) i_l(x)
 
  -- Function: int gsl_sf_bessel_il_scaled_array (int LMAX, double X,
           double RESULT_ARRAY[])
      This routine computes the values of the scaled regular modified
-     cylindrical Bessel functions \exp(-|x|) i_l(x) for l from 0 to
-     LMAX inclusive for lmax >= 0, storing the results in the array
+     cylindrical Bessel functions \exp(-|x|) i_l(x) for l from 0 to LMAX
+     inclusive for lmax >= 0, storing the results in the array
      RESULT_ARRAY.  The values are computed using recurrence relations
      for efficiency, and therefore may differ slightly from the exact
      values.
@@ -2734,9 +2722,9 @@ File: gsl-ref.info,  Node: Regular Bessel Function - Fractional Order,  Next: Ir
           MODE, size_t SIZE, double V[])
      This function computes the regular cylindrical Bessel function of
      fractional order \nu, J_\nu(x), evaluated at a series of x values.
-     The array V of length SIZE contains the x values.  They are
-     assumed to be strictly ordered and positive.  The array is
-     over-written with the values of J_\nu(x_i).
+     The array V of length SIZE contains the x values.  They are assumed
+     to be strictly ordered and positive.  The array is over-written
+     with the values of J_\nu(x_i).
 
 
 File: gsl-ref.info,  Node: Irregular Bessel Functions - Fractional Order,  Next: Regular Modified Bessel Functions - Fractional Order,  Prev: Regular Bessel Function - Fractional Order,  Up: Bessel Functions
@@ -2801,14 +2789,14 @@ File: gsl-ref.info,  Node: Zeros of Regular Bessel Functions,  Prev: Irregular M
 ----------------------------------------
 
  -- Function: double gsl_sf_bessel_zero_J0 (unsigned int S)
- -- Function: int gsl_sf_bessel_zero_J0_e (unsigned int S,
-          gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_bessel_zero_J0_e (unsigned int S, gsl_sf_result
+          * RESULT)
      These routines compute the location of the S-th positive zero of
      the Bessel function J_0(x).
 
  -- Function: double gsl_sf_bessel_zero_J1 (unsigned int S)
- -- Function: int gsl_sf_bessel_zero_J1_e (unsigned int S,
-          gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_bessel_zero_J1_e (unsigned int S, gsl_sf_result
+          * RESULT)
      These routines compute the location of the S-th positive zero of
      the Bessel function J_1(x).
 
@@ -2831,7 +2819,7 @@ The Clausen function is defined by the following integral,
 
 It is related to the dilogarithm by Cl_2(\theta) = \Im
 Li_2(\exp(i\theta)).  The Clausen functions are declared in the header
-file `gsl_sf_clausen.h'.
+file 'gsl_sf_clausen.h'.
 
  -- Function: double gsl_sf_clausen (double X)
  -- Function: int gsl_sf_clausen_e (double X, gsl_sf_result * RESULT)
@@ -2844,14 +2832,14 @@ File: gsl-ref.info,  Node: Coulomb Functions,  Next: Coupling Coefficients,  Pre
 =====================
 
 The prototypes of the Coulomb functions are declared in the header file
-`gsl_sf_coulomb.h'.  Both bound state and scattering solutions are
+'gsl_sf_coulomb.h'.  Both bound state and scattering solutions are
 available.
 
 * Menu:
 
-* Normalized Hydrogenic Bound States::
-* Coulomb Wave Functions::
-* Coulomb Wave Function Normalization Constant::
+* Normalized Hydrogenic Bound States::  
+* Coulomb Wave Functions::      
+* Coulomb Wave Function Normalization Constant::  
 
 
 File: gsl-ref.info,  Node: Normalized Hydrogenic Bound States,  Next: Coulomb Wave Functions,  Up: Coulomb Functions
@@ -2888,8 +2876,8 @@ File: gsl-ref.info,  Node: Coulomb Wave Functions,  Next: Coulomb Wave Function
 The Coulomb wave functions F_L(\eta,x), G_L(\eta,x) are described in
 Abramowitz & Stegun, Chapter 14.  Because there can be a large dynamic
 range of values for these functions, overflows are handled gracefully.
-If an overflow occurs, `GSL_EOVRFLW' is signalled and exponent(s) are
-returned through the modifiable parameters EXP_F, EXP_G. The full
+If an overflow occurs, 'GSL_EOVRFLW' is signalled and exponent(s) are
+returned through the modifiable parameters EXP_F, EXP_G.  The full
 solution can be reconstructed from the following relations,
 
      F_L(eta,x)  =  fc[k_L] * exp(exp_F)
@@ -2898,18 +2886,17 @@ solution can be reconstructed from the following relations,
      F_L'(eta,x) = fcp[k_L] * exp(exp_F)
      G_L'(eta,x) = gcp[k_L] * exp(exp_G)
 
-
- -- Function: int gsl_sf_coulomb_wave_FG_e (double ETA, double X,
-          double L_F, int K, gsl_sf_result * F, gsl_sf_result * FP,
+ -- Function: int gsl_sf_coulomb_wave_FG_e (double ETA, double X, double
+          L_F, int K, gsl_sf_result * F, gsl_sf_result * FP,
           gsl_sf_result * G, gsl_sf_result * GP, double * EXP_F, double
           * EXP_G)
      This function computes the Coulomb wave functions F_L(\eta,x),
      G_{L-k}(\eta,x) and their derivatives F'_L(\eta,x),
      G'_{L-k}(\eta,x) with respect to x.  The parameters are restricted
      to L, L-k > -1/2, x > 0 and integer k.  Note that L itself is not
-     restricted to being an integer. The results are stored in the
+     restricted to being an integer.  The results are stored in the
      parameters F, G for the function values and FP, GP for the
-     derivative values.  If an overflow occurs, `GSL_EOVRFLW' is
+     derivative values.  If an overflow occurs, 'GSL_EOVRFLW' is
      returned and scaling exponents are stored in the modifiable
      parameters EXP_F, EXP_G.
 
@@ -2922,20 +2909,20 @@ solution can be reconstructed from the following relations,
  -- Function: int gsl_sf_coulomb_wave_FG_array (double L_MIN, int KMAX,
           double ETA, double X, double FC_ARRAY[], double GC_ARRAY[],
           double * F_EXPONENT, double * G_EXPONENT)
-     This function computes the functions F_L(\eta,x), G_L(\eta,x) for
-     L = Lmin \dots Lmin + kmax storing the results in FC_ARRAY and
+     This function computes the functions F_L(\eta,x), G_L(\eta,x) for L
+     = Lmin \dots Lmin + kmax storing the results in FC_ARRAY and
      GC_ARRAY.  In the case of overflow the exponents are stored in
      F_EXPONENT and G_EXPONENT.
 
- -- Function: int gsl_sf_coulomb_wave_FGp_array (double L_MIN, int
-          KMAX, double ETA, double X, double FC_ARRAY[], double
-          FCP_ARRAY[], double GC_ARRAY[], double GCP_ARRAY[], double *
-          F_EXPONENT, double * G_EXPONENT)
+ -- Function: int gsl_sf_coulomb_wave_FGp_array (double L_MIN, int KMAX,
+          double ETA, double X, double FC_ARRAY[], double FCP_ARRAY[],
+          double GC_ARRAY[], double GCP_ARRAY[], double * F_EXPONENT,
+          double * G_EXPONENT)
      This function computes the functions F_L(\eta,x), G_L(\eta,x) and
      their derivatives F'_L(\eta,x), G'_L(\eta,x) for L = Lmin \dots
      Lmin + kmax storing the results in FC_ARRAY, GC_ARRAY, FCP_ARRAY
-     and GCP_ARRAY.  In the case of overflow the exponents are stored
-     in F_EXPONENT and G_EXPONENT.
+     and GCP_ARRAY.  In the case of overflow the exponents are stored in
+     F_EXPONENT and G_EXPONENT.
 
  -- Function: int gsl_sf_coulomb_wave_sphF_array (double L_MIN, int
           KMAX, double ETA, double X, double FC_ARRAY[], double
@@ -2943,7 +2930,7 @@ solution can be reconstructed from the following relations,
      This function computes the Coulomb wave function divided by the
      argument F_L(\eta, x)/x for L = Lmin \dots Lmin + kmax, storing the
      results in FC_ARRAY.  In the case of overflow the exponent is
-     stored in F_EXPONENT. This function reduces to spherical Bessel
+     stored in F_EXPONENT.  This function reduces to spherical Bessel
      functions in the limit \eta \to 0.
 
 
@@ -2960,8 +2947,8 @@ Abramowitz 14.1.7.
      This function computes the Coulomb wave function normalization
      constant C_L(\eta) for L > -1.
 
- -- Function: int gsl_sf_coulomb_CL_array (double LMIN, int KMAX,
-          double ETA, double CL[])
+ -- Function: int gsl_sf_coulomb_CL_array (double LMIN, int KMAX, double
+          ETA, double CL[])
      This function computes the Coulomb wave function normalization
      constant C_L(\eta) for L = Lmin \dots Lmin + kmax, Lmin > -1.
 
@@ -2977,13 +2964,13 @@ coupling coefficient functions are integer or half-integer, the
 arguments of the following functions are, by convention, integers equal
 to twice the actual spin value.  For information on the 3-j coefficients
 see Abramowitz & Stegun, Section 27.9.  The functions described in this
-section are declared in the header file `gsl_sf_coupling.h'.
+section are declared in the header file 'gsl_sf_coupling.h'.
 
 * Menu:
 
-* 3-j Symbols::
-* 6-j Symbols::
-* 9-j Symbols::
+* 3-j Symbols::                 
+* 6-j Symbols::                 
+* 9-j Symbols::                 
 
 
 File: gsl-ref.info,  Node: 3-j Symbols,  Next: 6-j Symbols,  Up: Coupling Coefficients
@@ -3001,8 +2988,8 @@ File: gsl-ref.info,  Node: 3-j Symbols,  Next: 6-j Symbols,  Up: Coupling Coeffi
           (ja jb jc
            ma mb mc)
 
-     where the arguments are given in half-integer units, ja =
-     TWO_JA/2, ma = TWO_MA/2, etc.
+     where the arguments are given in half-integer units, ja = TWO_JA/2,
+     ma = TWO_MA/2, etc.
 
 
 File: gsl-ref.info,  Node: 6-j Symbols,  Next: 9-j Symbols,  Prev: 3-j Symbols,  Up: Coupling Coefficients
@@ -3020,8 +3007,8 @@ File: gsl-ref.info,  Node: 6-j Symbols,  Next: 9-j Symbols,  Prev: 3-j Symbols,
           {ja jb jc
            jd je jf}
 
-     where the arguments are given in half-integer units, ja =
-     TWO_JA/2, ma = TWO_MA/2, etc.
+     where the arguments are given in half-integer units, ja = TWO_JA/2,
+     ma = TWO_MA/2, etc.
 
 
 File: gsl-ref.info,  Node: 9-j Symbols,  Prev: 6-j Symbols,  Up: Coupling Coefficients
@@ -3041,8 +3028,8 @@ File: gsl-ref.info,  Node: 9-j Symbols,  Prev: 6-j Symbols,  Up: Coupling Coeffi
            jd je jf
            jg jh ji}
 
-     where the arguments are given in half-integer units, ja =
-     TWO_JA/2, ma = TWO_MA/2, etc.
+     where the arguments are given in half-integer units, ja = TWO_JA/2,
+     ma = TWO_MA/2, etc.
 
 
 File: gsl-ref.info,  Node: Dawson Function,  Next: Debye Functions,  Prev: Coupling Coefficients,  Up: Special Functions
@@ -3053,7 +3040,7 @@ File: gsl-ref.info,  Node: Dawson Function,  Next: Debye Functions,  Prev: Coupl
 The Dawson integral is defined by \exp(-x^2) \int_0^x dt \exp(t^2).  A
 table of Dawson's integral can be found in Abramowitz & Stegun, Table
 7.5.  The Dawson functions are declared in the header file
-`gsl_sf_dawson.h'.
+'gsl_sf_dawson.h'.
 
  -- Function: double gsl_sf_dawson (double X)
  -- Function: int gsl_sf_dawson_e (double X, gsl_sf_result * RESULT)
@@ -3070,7 +3057,7 @@ The Debye functions D_n(x) are defined by the following integral,
      D_n(x) = n/x^n \int_0^x dt (t^n/(e^t - 1))
 
 For further information see Abramowitz & Stegun, Section 27.1.  The
-Debye functions are declared in the header file `gsl_sf_debye.h'.
+Debye functions are declared in the header file 'gsl_sf_debye.h'.
 
  -- Function: double gsl_sf_debye_1 (double X)
  -- Function: int gsl_sf_debye_1_e (double X, gsl_sf_result * RESULT)
@@ -3109,12 +3096,12 @@ File: gsl-ref.info,  Node: Dilogarithm,  Next: Elementary Operations,  Prev: Deb
 ================
 
 The functions described in this section are declared in the header file
-`gsl_sf_dilog.h'.
+'gsl_sf_dilog.h'.
 
 * Menu:
 
-* Real Argument::
-* Complex Argument::
+* Real Argument::               
+* Complex Argument::            
 
 
 File: gsl-ref.info,  Node: Real Argument,  Next: Complex Argument,  Up: Dilogarithm
@@ -3124,13 +3111,12 @@ File: gsl-ref.info,  Node: Real Argument,  Next: Complex Argument,  Up: Dilogari
 
  -- Function: double gsl_sf_dilog (double X)
  -- Function: int gsl_sf_dilog_e (double X, gsl_sf_result * RESULT)
-     These routines compute the dilogarithm for a real argument. In
+     These routines compute the dilogarithm for a real argument.  In
      Lewin's notation this is Li_2(x), the real part of the dilogarithm
      of a real x.  It is defined by the integral representation Li_2(x)
      = - \Re \int_0^x ds \log(1-s) / s.  Note that \Im(Li_2(x)) = 0 for
      x <= 1, and -\pi\log(x) for x > 1.
 
-
 
 File: gsl-ref.info,  Node: Complex Argument,  Prev: Real Argument,  Up: Dilogarithm
 
@@ -3140,7 +3126,7 @@ File: gsl-ref.info,  Node: Complex Argument,  Prev: Real Argument,  Up: Dilogari
  -- Function: int gsl_sf_complex_dilog_e (double R, double THETA,
           gsl_sf_result * RESULT_RE, gsl_sf_result * RESULT_IM)
      This function computes the full complex-valued dilogarithm for the
-     complex argument z = r \exp(i \theta). The real and imaginary
+     complex argument z = r \exp(i \theta).  The real and imaginary
      parts of the result are returned in RESULT_RE, RESULT_IM.
 
 
@@ -3151,18 +3137,18 @@ File: gsl-ref.info,  Node: Elementary Operations,  Next: Elliptic Integrals,  Pr
 
 The following functions allow for the propagation of errors when
 combining quantities by multiplication.  The functions are declared in
-the header file `gsl_sf_elementary.h'.
+the header file 'gsl_sf_elementary.h'.
 
- -- Function: int gsl_sf_multiply_e (double X, double Y, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_multiply_e (double X, double Y, gsl_sf_result *
+          RESULT)
      This function multiplies X and Y storing the product and its
      associated error in RESULT.
 
  -- Function: int gsl_sf_multiply_err_e (double X, double DX, double Y,
           double DY, gsl_sf_result * RESULT)
-     This function multiplies X and Y with associated absolute errors
-     DX and DY.  The product xy +/- xy \sqrt((dx/x)^2 +(dy/y)^2) is
-     stored in RESULT.
+     This function multiplies X and Y with associated absolute errors DX
+     and DY.  The product xy +/- xy \sqrt((dx/x)^2 +(dy/y)^2) is stored
+     in RESULT.
 
 
 File: gsl-ref.info,  Node: Elliptic Integrals,  Next: Elliptic Functions (Jacobi),  Prev: Elementary Operations,  Up: Special Functions
@@ -3171,16 +3157,16 @@ File: gsl-ref.info,  Node: Elliptic Integrals,  Next: Elliptic Functions (Jacobi
 =======================
 
 The functions described in this section are declared in the header file
-`gsl_sf_ellint.h'.  Further information about the elliptic integrals
-can be found in Abramowitz & Stegun, Chapter 17.
+'gsl_sf_ellint.h'.  Further information about the elliptic integrals can
+be found in Abramowitz & Stegun, Chapter 17.
 
 * Menu:
 
-* Definition of Legendre Forms::
-* Definition of Carlson Forms::
-* Legendre Form of Complete Elliptic Integrals::
-* Legendre Form of Incomplete Elliptic Integrals::
-* Carlson Forms::
+* Definition of Legendre Forms::  
+* Definition of Carlson Forms::  
+* Legendre Form of Complete Elliptic Integrals::  
+* Legendre Form of Incomplete Elliptic Integrals::  
+* Carlson Forms::               
 
 
 File: gsl-ref.info,  Node: Definition of Legendre Forms,  Next: Definition of Carlson Forms,  Up: Elliptic Integrals
@@ -3197,13 +3183,13 @@ The Legendre forms of elliptic integrals F(\phi,k), E(\phi,k) and
 
      Pi(\phi,k,n) = \int_0^\phi dt 1/((1 + n \sin^2(t))\sqrt(1 - k^2 \sin^2(t)))
 
-The complete Legendre forms are denoted by K(k) = F(\pi/2, k) and E(k)
-= E(\pi/2, k).
+The complete Legendre forms are denoted by K(k) = F(\pi/2, k) and E(k) =
+E(\pi/2, k).
 
-   The notation used here is based on Carlson, `Numerische Mathematik'
+   The notation used here is based on Carlson, 'Numerische Mathematik'
 33 (1979) 1 and differs slightly from that used by Abramowitz & Stegun,
-where the functions are given in terms of the parameter m = k^2 and n
-is replaced by -n.
+where the functions are given in terms of the parameter m = k^2 and n is
+replaced by -n.
 
 
 File: gsl-ref.info,  Node: Definition of Carlson Forms,  Next: Legendre Form of Complete Elliptic Integrals,  Prev: Definition of Legendre Forms,  Up: Elliptic Integrals
@@ -3233,27 +3219,24 @@ File: gsl-ref.info,  Node: Legendre Form of Complete Elliptic Integrals,  Next:
  -- Function: int gsl_sf_ellint_Kcomp_e (double K, gsl_mode_t MODE,
           gsl_sf_result * RESULT)
      These routines compute the complete elliptic integral K(k) to the
-     accuracy specified by the mode variable MODE.  Note that
-     Abramowitz & Stegun define this function in terms of the parameter
-     m = k^2.
+     accuracy specified by the mode variable MODE.  Note that Abramowitz
+     & Stegun define this function in terms of the parameter m = k^2.
 
  -- Function: double gsl_sf_ellint_Ecomp (double K, gsl_mode_t MODE)
  -- Function: int gsl_sf_ellint_Ecomp_e (double K, gsl_mode_t MODE,
           gsl_sf_result * RESULT)
      These routines compute the complete elliptic integral E(k) to the
-     accuracy specified by the mode variable MODE.  Note that
-     Abramowitz & Stegun define this function in terms of the parameter
-     m = k^2.
+     accuracy specified by the mode variable MODE.  Note that Abramowitz
+     & Stegun define this function in terms of the parameter m = k^2.
 
- -- Function: double gsl_sf_ellint_Pcomp (double K, double N,
-          gsl_mode_t MODE)
+ -- Function: double gsl_sf_ellint_Pcomp (double K, double N, gsl_mode_t
+          MODE)
  -- Function: int gsl_sf_ellint_Pcomp_e (double K, double N, gsl_mode_t
           MODE, gsl_sf_result * RESULT)
      These routines compute the complete elliptic integral \Pi(k,n) to
      the accuracy specified by the mode variable MODE.  Note that
-     Abramowitz & Stegun define this function in terms of the
-     parameters m = k^2 and \sin^2(\alpha) = k^2, with the change of
-     sign n \to -n.
+     Abramowitz & Stegun define this function in terms of the parameters
+     m = k^2 and \sin^2(\alpha) = k^2, with the change of sign n \to -n.
 
 
 File: gsl-ref.info,  Node: Legendre Form of Incomplete Elliptic Integrals,  Next: Carlson Forms,  Prev: Legendre Form of Complete Elliptic Integrals,  Up: Elliptic Integrals
@@ -3300,7 +3283,6 @@ File: gsl-ref.info,  Node: Legendre Form of Incomplete Elliptic Integrals,  Next
           D(\phi,k,n) = (1/3)(\sin(\phi))^3 RD (1-\sin^2(\phi), 1-k^2 \sin^2(\phi), 1).
      The argument N is not used and will be removed in a future release.
 
-
 
 File: gsl-ref.info,  Node: Carlson Forms,  Prev: Legendre Form of Incomplete Elliptic Integrals,  Up: Elliptic Integrals
 
@@ -3343,7 +3325,7 @@ File: gsl-ref.info,  Node: Elliptic Functions (Jacobi),  Next: Error Functions,
 
 The Jacobian Elliptic functions are defined in Abramowitz & Stegun,
 Chapter 16.  The functions are declared in the header file
-`gsl_sf_elljac.h'.
+'gsl_sf_elljac.h'.
 
  -- Function: int gsl_sf_elljac_e (double U, double M, double * SN,
           double * CN, double * DN)
@@ -3358,14 +3340,14 @@ File: gsl-ref.info,  Node: Error Functions,  Next: Exponential Functions,  Prev:
 
 The error function is described in Abramowitz & Stegun, Chapter 7.  The
 functions in this section are declared in the header file
-`gsl_sf_erf.h'.
+'gsl_sf_erf.h'.
 
 * Menu:
 
-* Error Function::
-* Complementary Error Function::
-* Log Complementary Error Function::
-* Probability functions::
+* Error Function::              
+* Complementary Error Function::  
+* Log Complementary Error Function::  
+* Probability functions::       
 
 
 File: gsl-ref.info,  Node: Error Function,  Next: Complementary Error Function,  Up: Error Functions
@@ -3386,8 +3368,8 @@ File: gsl-ref.info,  Node: Complementary Error Function,  Next: Log Complementar
 
  -- Function: double gsl_sf_erfc (double X)
  -- Function: int gsl_sf_erfc_e (double X, gsl_sf_result * RESULT)
-     These routines compute the complementary error function erfc(x) =
-     1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2).
+     These routines compute the complementary error function erfc(x) = 1
+     - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2).
 
 
 File: gsl-ref.info,  Node: Log Complementary Error Function,  Next: Probability functions,  Prev: Complementary Error Function,  Up: Error Functions
@@ -3424,8 +3406,8 @@ inverse Mill's ratio, is defined as,
 
      h(x) = Z(x)/Q(x) = \sqrt{2/\pi} \exp(-x^2 / 2) / \erfc(x/\sqrt 2)
 
-It decreases rapidly as x approaches -\infty and asymptotes to h(x)
-\sim x as x approaches +\infty.
+It decreases rapidly as x approaches -\infty and asymptotes to h(x) \sim
+x as x approaches +\infty.
 
  -- Function: double gsl_sf_hazard (double X)
  -- Function: int gsl_sf_hazard_e (double X, gsl_sf_result * RESULT)
@@ -3439,13 +3421,13 @@ File: gsl-ref.info,  Node: Exponential Functions,  Next: Exponential Integrals,
 ==========================
 
 The functions described in this section are declared in the header file
-`gsl_sf_exp.h'.
+'gsl_sf_exp.h'.
 
 * Menu:
 
-* Exponential Function::
-* Relative Exponential Functions::
-* Exponentiation With Error Estimate::
+* Exponential Function::        
+* Relative Exponential Functions::  
+* Exponentiation With Error Estimate::  
 
 
 File: gsl-ref.info,  Node: Exponential Function,  Next: Relative Exponential Functions,  Up: Exponential Functions
@@ -3461,20 +3443,20 @@ File: gsl-ref.info,  Node: Exponential Function,  Next: Relative Exponential Fun
  -- Function: int gsl_sf_exp_e10_e (double X, gsl_sf_result_e10 *
           RESULT)
      This function computes the exponential \exp(x) using the
-     `gsl_sf_result_e10' type to return a result with extended range.
+     'gsl_sf_result_e10' type to return a result with extended range.
      This function may be useful if the value of \exp(x) would overflow
-     the  numeric range of `double'.
+     the numeric range of 'double'.
 
  -- Function: double gsl_sf_exp_mult (double X, double Y)
- -- Function: int gsl_sf_exp_mult_e (double X, double Y, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_exp_mult_e (double X, double Y, gsl_sf_result *
+          RESULT)
      These routines exponentiate X and multiply by the factor Y to
      return the product y \exp(x).
 
- -- Function: int gsl_sf_exp_mult_e10_e (const double X, const double
-          Y, gsl_sf_result_e10 * RESULT)
+ -- Function: int gsl_sf_exp_mult_e10_e (const double X, const double Y,
+          gsl_sf_result_e10 * RESULT)
      This function computes the product y \exp(x) using the
-     `gsl_sf_result_e10' type to return a result with extended numeric
+     'gsl_sf_result_e10' type to return a result with extended numeric
      range.
 
 
@@ -3506,8 +3488,8 @@ File: gsl-ref.info,  Node: Relative Exponential Functions,  Next: Exponentiation
  -- Function: int gsl_sf_exprel_n_e (int N, double X, gsl_sf_result *
           RESULT)
      These routines compute the N-relative exponential, which is the
-     N-th generalization of the functions `gsl_sf_exprel' and
-     `gsl_sf_exprel2'.  The N-relative exponential is given by,
+     N-th generalization of the functions 'gsl_sf_exprel' and
+     'gsl_sf_exprel2'.  The N-relative exponential is given by,
 
           exprel_N(x) = N!/x^N (\exp(x) - \sum_{k=0}^{N-1} x^k/k!)
                       = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ...
@@ -3519,26 +3501,26 @@ File: gsl-ref.info,  Node: Exponentiation With Error Estimate,  Prev: Relative E
 7.16.3 Exponentiation With Error Estimate
 -----------------------------------------
 
- -- Function: int gsl_sf_exp_err_e (double X, double DX, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_exp_err_e (double X, double DX, gsl_sf_result *
+          RESULT)
      This function exponentiates X with an associated absolute error DX.
 
  -- Function: int gsl_sf_exp_err_e10_e (double X, double DX,
           gsl_sf_result_e10 * RESULT)
      This function exponentiates a quantity X with an associated
-     absolute error DX using the `gsl_sf_result_e10' type to return a
+     absolute error DX using the 'gsl_sf_result_e10' type to return a
      result with extended range.
 
  -- Function: int gsl_sf_exp_mult_err_e (double X, double DX, double Y,
           double DY, gsl_sf_result * RESULT)
-     This routine computes the product y \exp(x) for the quantities X,
-     Y with associated absolute errors DX, DY.
+     This routine computes the product y \exp(x) for the quantities X, Y
+     with associated absolute errors DX, DY.
 
- -- Function: int gsl_sf_exp_mult_err_e10_e (double X, double DX,
-          double Y, double DY, gsl_sf_result_e10 * RESULT)
-     This routine computes the product y \exp(x) for the quantities X,
-     Y with associated absolute errors DX, DY using the
-     `gsl_sf_result_e10' type to return a result with extended range.
+ -- Function: int gsl_sf_exp_mult_err_e10_e (double X, double DX, double
+          Y, double DY, gsl_sf_result_e10 * RESULT)
+     This routine computes the product y \exp(x) for the quantities X, Y
+     with associated absolute errors DX, DY using the
+     'gsl_sf_result_e10' type to return a result with extended range.
 
 
 File: gsl-ref.info,  Node: Exponential Integrals,  Next: Fermi-Dirac Function,  Prev: Exponential Functions,  Up: Special Functions
@@ -3548,16 +3530,16 @@ File: gsl-ref.info,  Node: Exponential Integrals,  Next: Fermi-Dirac Function,
 
 Information on the exponential integrals can be found in Abramowitz &
 Stegun, Chapter 5.  These functions are declared in the header file
-`gsl_sf_expint.h'.
+'gsl_sf_expint.h'.
 
 * Menu:
 
-* Exponential Integral::
-* Ei(x)::
-* Hyperbolic Integrals::
-* Ei_3(x)::
-* Trigonometric Integrals::
-* Arctangent Integral::
+* Exponential Integral::        
+* Ei(x)::                       
+* Hyperbolic Integrals::        
+* Ei_3(x)::                     
+* Trigonometric Integrals::     
+* Arctangent Integral::         
 
 
 File: gsl-ref.info,  Node: Exponential Integral,  Next: Ei(x),  Up: Exponential Integrals
@@ -3571,8 +3553,6 @@ File: gsl-ref.info,  Node: Exponential Integral,  Next: Ei(x),  Up: Exponential
 
           E_1(x) := \Re \int_1^\infty dt \exp(-xt)/t.
 
-
-
  -- Function: double gsl_sf_expint_E2 (double X)
  -- Function: int gsl_sf_expint_E2_e (double X, gsl_sf_result * RESULT)
      These routines compute the second-order exponential integral
@@ -3580,8 +3560,6 @@ File: gsl-ref.info,  Node: Exponential Integral,  Next: Ei(x),  Up: Exponential
 
           E_2(x) := \Re \int_1^\infty dt \exp(-xt)/t^2.
 
-
-
 
 File: gsl-ref.info,  Node: Ei(x),  Next: Hyperbolic Integrals,  Prev: Exponential Integral,  Up: Exponential Integrals
 
@@ -3609,9 +3587,9 @@ File: gsl-ref.info,  Node: Hyperbolic Integrals,  Next: Ei_3(x),  Prev: Ei(x),
 
  -- Function: double gsl_sf_Chi (double X)
  -- Function: int gsl_sf_Chi_e (double X, gsl_sf_result * RESULT)
-     These routines compute the integral  Chi(x) := \Re[ \gamma_E +
-     \log(x) + \int_0^x dt (\cosh[t]-1)/t] , where \gamma_E is the
-     Euler constant (available as the macro `M_EULER').
+     These routines compute the integral Chi(x) := \Re[ \gamma_E +
+     \log(x) + \int_0^x dt (\cosh[t]-1)/t] , where \gamma_E is the Euler
+     constant (available as the macro 'M_EULER').
 
 
 File: gsl-ref.info,  Node: Ei_3(x),  Next: Trigonometric Integrals,  Prev: Hyperbolic Integrals,  Up: Exponential Integrals
@@ -3621,8 +3599,8 @@ File: gsl-ref.info,  Node: Ei_3(x),  Next: Trigonometric Integrals,  Prev: Hyper
 
  -- Function: double gsl_sf_expint_3 (double X)
  -- Function: int gsl_sf_expint_3_e (double X, gsl_sf_result * RESULT)
-     These routines compute the third-order exponential integral
-     Ei_3(x) = \int_0^xdt \exp(-t^3) for x >= 0.
+     These routines compute the third-order exponential integral Ei_3(x)
+     = \int_0^xdt \exp(-t^3) for x >= 0.
 
 
 File: gsl-ref.info,  Node: Trigonometric Integrals,  Next: Arctangent Integral,  Prev: Ei_3(x),  Up: Exponential Integrals
@@ -3648,8 +3626,8 @@ File: gsl-ref.info,  Node: Arctangent Integral,  Prev: Trigonometric Integrals,
 
  -- Function: double gsl_sf_atanint (double X)
  -- Function: int gsl_sf_atanint_e (double X, gsl_sf_result * RESULT)
-     These routines compute the Arctangent integral, which is defined
-     as AtanInt(x) = \int_0^x dt \arctan(t)/t.
+     These routines compute the Arctangent integral, which is defined as
+     AtanInt(x) = \int_0^x dt \arctan(t)/t.
 
 
 File: gsl-ref.info,  Node: Fermi-Dirac Function,  Next: Gamma and Beta Functions,  Prev: Exponential Integrals,  Up: Special Functions
@@ -3658,12 +3636,12 @@ File: gsl-ref.info,  Node: Fermi-Dirac Function,  Next: Gamma and Beta Functions
 =========================
 
 The functions described in this section are declared in the header file
-`gsl_sf_fermi_dirac.h'.
+'gsl_sf_fermi_dirac.h'.
 
 * Menu:
 
-* Complete Fermi-Dirac Integrals::
-* Incomplete Fermi-Dirac Integrals::
+* Complete Fermi-Dirac Integrals::  
+* Incomplete Fermi-Dirac Integrals::  
 
 
 File: gsl-ref.info,  Node: Complete Fermi-Dirac Integrals,  Next: Incomplete Fermi-Dirac Integrals,  Up: Fermi-Dirac Function
@@ -3747,17 +3725,17 @@ File: gsl-ref.info,  Node: Gamma and Beta Functions,  Next: Gegenbauer Functions
 7.19 Gamma and Beta Functions
 =============================
 
-The  functions described in this section are declared in the header
-file `gsl_sf_gamma.h'.
+The functions described in this section are declared in the header file
+'gsl_sf_gamma.h'.
 
 * Menu:
 
-* Gamma Functions::
-* Factorials::
-* Pochhammer Symbol::
-* Incomplete Gamma Functions::
-* Beta Functions::
-* Incomplete Beta Function::
+* Gamma Functions::             
+* Factorials::                  
+* Pochhammer Symbol::           
+* Incomplete Gamma Functions::  
+* Beta Functions::              
+* Incomplete Beta Function::    
 
 
 File: gsl-ref.info,  Node: Gamma Functions,  Next: Factorials,  Up: Gamma and Beta Functions
@@ -3769,39 +3747,39 @@ The Gamma function is defined by the following integral,
 
      \Gamma(x) = \int_0^\infty dt  t^{x-1} \exp(-t)
 
-It is related to the factorial function by \Gamma(n)=(n-1)!  for
-positive integer n.  Further information on the Gamma function can be
-found in Abramowitz & Stegun, Chapter 6.  The functions described in
-this section are declared in the header file `gsl_sf_gamma.h'.
+It is related to the factorial function by \Gamma(n)=(n-1)! for positive
+integer n.  Further information on the Gamma function can be found in
+Abramowitz & Stegun, Chapter 6.  The functions described in this section
+are declared in the header file 'gsl_sf_gamma.h'.
 
  -- Function: double gsl_sf_gamma (double X)
  -- Function: int gsl_sf_gamma_e (double X, gsl_sf_result * RESULT)
      These routines compute the Gamma function \Gamma(x), subject to x
      not being a negative integer or zero.  The function is computed
-     using the real Lanczos method. The maximum value of x such that
+     using the real Lanczos method.  The maximum value of x such that
      \Gamma(x) is not considered an overflow is given by the macro
-     `GSL_SF_GAMMA_XMAX' and is 171.0.
+     'GSL_SF_GAMMA_XMAX' and is 171.0.
 
  -- Function: double gsl_sf_lngamma (double X)
  -- Function: int gsl_sf_lngamma_e (double X, gsl_sf_result * RESULT)
      These routines compute the logarithm of the Gamma function,
-     \log(\Gamma(x)), subject to x not being a negative integer or
-     zero.  For x<0 the real part of \log(\Gamma(x)) is returned, which
-     is equivalent to \log(|\Gamma(x)|).  The function is computed
-     using the real Lanczos method.
+     \log(\Gamma(x)), subject to x not being a negative integer or zero.
+     For x<0 the real part of \log(\Gamma(x)) is returned, which is
+     equivalent to \log(|\Gamma(x)|).  The function is computed using
+     the real Lanczos method.
 
  -- Function: int gsl_sf_lngamma_sgn_e (double X, gsl_sf_result *
           RESULT_LG, double * SGN)
      This routine computes the sign of the gamma function and the
      logarithm of its magnitude, subject to x not being a negative
      integer or zero.  The function is computed using the real Lanczos
-     method.  The value of the gamma function can be reconstructed
-     using the relation \Gamma(x) = sgn * \exp(resultlg).
+     method.  The value of the gamma function can be reconstructed using
+     the relation \Gamma(x) = sgn * \exp(resultlg).
 
  -- Function: double gsl_sf_gammastar (double X)
  -- Function: int gsl_sf_gammastar_e (double X, gsl_sf_result * RESULT)
-     These routines compute the regulated Gamma Function \Gamma^*(x)
-     for x > 0. The regulated gamma function is given by,
+     These routines compute the regulated Gamma Function \Gamma^*(x) for
+     x > 0.  The regulated gamma function is given by,
 
           \Gamma^*(x) = \Gamma(x)/(\sqrt{2\pi} x^{(x-1/2)} \exp(-x))
                       = (1 + (1/12x) + ...)  for x \to \infty
@@ -3814,13 +3792,13 @@ this section are declared in the header file `gsl_sf_gamma.h'.
 
  -- Function: int gsl_sf_lngamma_complex_e (double ZR, double ZI,
           gsl_sf_result * LNR, gsl_sf_result * ARG)
-     This routine computes \log(\Gamma(z)) for complex z=z_r+i z_i and
-     z not a negative integer or zero, using the complex Lanczos
-     method.  The returned parameters are lnr = \log|\Gamma(z)| and arg
-     = \arg(\Gamma(z)) in (-\pi,\pi].  Note that the phase part (ARG)
-     is not well-determined when |z| is very large, due to inevitable
+     This routine computes \log(\Gamma(z)) for complex z=z_r+i z_i and z
+     not a negative integer or zero, using the complex Lanczos method.
+     The returned parameters are lnr = \log|\Gamma(z)| and arg =
+     \arg(\Gamma(z)) in (-\pi,\pi].  Note that the phase part (ARG) is
+     not well-determined when |z| is very large, due to inevitable
      roundoff in restricting to (-\pi,\pi].  This will result in a
-     `GSL_ELOSS' error when it occurs.  The absolute value part (LNR),
+     'GSL_ELOSS' error when it occurs.  The absolute value part (LNR),
      however, never suffers from loss of precision.
 
 
@@ -3830,53 +3808,52 @@ File: gsl-ref.info,  Node: Factorials,  Next: Pochhammer Symbol,  Prev: Gamma Fu
 -----------------
 
 Although factorials can be computed from the Gamma function, using the
-relation n! = \Gamma(n+1) for non-negative integer n, it is usually
-more efficient to call the functions in this section, particularly for
-small values of n, whose factorial values are maintained in hardcoded
-tables.
+relation n! = \Gamma(n+1) for non-negative integer n, it is usually more
+efficient to call the functions in this section, particularly for small
+values of n, whose factorial values are maintained in hardcoded tables.
 
  -- Function: double gsl_sf_fact (unsigned int N)
  -- Function: int gsl_sf_fact_e (unsigned int N, gsl_sf_result * RESULT)
      These routines compute the factorial n!.  The factorial is related
      to the Gamma function by n! = \Gamma(n+1).  The maximum value of n
      such that n! is not considered an overflow is given by the macro
-     `GSL_SF_FACT_NMAX' and is 170.
+     'GSL_SF_FACT_NMAX' and is 170.
 
  -- Function: double gsl_sf_doublefact (unsigned int N)
  -- Function: int gsl_sf_doublefact_e (unsigned int N, gsl_sf_result *
           RESULT)
      These routines compute the double factorial n!! = n(n-2)(n-4)
      \dots.  The maximum value of n such that n!! is not considered an
-     overflow is given by the macro `GSL_SF_DOUBLEFACT_NMAX' and is 297.
+     overflow is given by the macro 'GSL_SF_DOUBLEFACT_NMAX' and is 297.
 
  -- Function: double gsl_sf_lnfact (unsigned int N)
  -- Function: int gsl_sf_lnfact_e (unsigned int N, gsl_sf_result *
           RESULT)
      These routines compute the logarithm of the factorial of N,
      \log(n!).  The algorithm is faster than computing \ln(\Gamma(n+1))
-     via `gsl_sf_lngamma' for n < 170, but defers for larger N.
+     via 'gsl_sf_lngamma' for n < 170, but defers for larger N.
 
  -- Function: double gsl_sf_lndoublefact (unsigned int N)
- -- Function: int gsl_sf_lndoublefact_e (unsigned int N, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_lndoublefact_e (unsigned int N, gsl_sf_result *
+          RESULT)
      These routines compute the logarithm of the double factorial of N,
      \log(n!!).
 
  -- Function: double gsl_sf_choose (unsigned int N, unsigned int M)
  -- Function: int gsl_sf_choose_e (unsigned int N, unsigned int M,
           gsl_sf_result * RESULT)
-     These routines compute the combinatorial factor `n choose m' =
+     These routines compute the combinatorial factor 'n choose m' =
      n!/(m!(n-m)!)
 
  -- Function: double gsl_sf_lnchoose (unsigned int N, unsigned int M)
  -- Function: int gsl_sf_lnchoose_e (unsigned int N, unsigned int M,
           gsl_sf_result * RESULT)
-     These routines compute the logarithm of `n choose m'.  This is
+     These routines compute the logarithm of 'n choose m'.  This is
      equivalent to the sum \log(n!) - \log(m!) - \log((n-m)!).
 
  -- Function: double gsl_sf_taylorcoeff (int N, double X)
- -- Function: int gsl_sf_taylorcoeff_e (int N, double X, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_taylorcoeff_e (int N, double X, gsl_sf_result *
+          RESULT)
      These routines compute the Taylor coefficient x^n / n! for x >= 0,
      n >= 0.
 
@@ -3891,7 +3868,7 @@ File: gsl-ref.info,  Node: Pochhammer Symbol,  Next: Incomplete Gamma Functions,
           RESULT)
      These routines compute the Pochhammer symbol (a)_x = \Gamma(a +
      x)/\Gamma(a), subject to a and a+x not being negative integers or
-     zero. The Pochhammer symbol is also known as the Apell symbol and
+     zero.  The Pochhammer symbol is also known as the Apell symbol and
      sometimes written as (a,x).
 
  -- Function: double gsl_sf_lnpoch (double A, double X)
@@ -3900,8 +3877,8 @@ File: gsl-ref.info,  Node: Pochhammer Symbol,  Next: Incomplete Gamma Functions,
      These routines compute the logarithm of the Pochhammer symbol,
      \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)) for a > 0, a+x > 0.
 
- -- Function: int gsl_sf_lnpoch_sgn_e (double A, double X,
-          gsl_sf_result * RESULT, double * SGN)
+ -- Function: int gsl_sf_lnpoch_sgn_e (double A, double X, gsl_sf_result
+          * RESULT, double * SGN)
      These routines compute the sign of the Pochhammer symbol and the
      logarithm of its magnitude.  The computed parameters are result =
      \log(|(a)_x|) and sgn = \sgn((a)_x) where (a)_x = \Gamma(a +
@@ -3911,8 +3888,8 @@ File: gsl-ref.info,  Node: Pochhammer Symbol,  Next: Incomplete Gamma Functions,
  -- Function: double gsl_sf_pochrel (double A, double X)
  -- Function: int gsl_sf_pochrel_e (double A, double X, gsl_sf_result *
           RESULT)
-     These routines compute the relative Pochhammer symbol ((a)_x -
-     1)/x where (a)_x = \Gamma(a + x)/\Gamma(a).
+     These routines compute the relative Pochhammer symbol ((a)_x - 1)/x
+     where (a)_x = \Gamma(a + x)/\Gamma(a).
 
 
 File: gsl-ref.info,  Node: Incomplete Gamma Functions,  Next: Beta Functions,  Prev: Pochhammer Symbol,  Up: Gamma and Beta Functions
@@ -3924,15 +3901,15 @@ File: gsl-ref.info,  Node: Incomplete Gamma Functions,  Next: Beta Functions,  P
  -- Function: int gsl_sf_gamma_inc_e (double A, double X, gsl_sf_result
           * RESULT)
      These functions compute the unnormalized incomplete Gamma Function
-     \Gamma(a,x) = \int_x^\infty dt t^{a-1} \exp(-t) for a real and x
-     >= 0.
+     \Gamma(a,x) = \int_x^\infty dt t^{a-1} \exp(-t) for a real and x >=
+     0.
 
  -- Function: double gsl_sf_gamma_inc_Q (double A, double X)
  -- Function: int gsl_sf_gamma_inc_Q_e (double A, double X,
           gsl_sf_result * RESULT)
      These routines compute the normalized incomplete Gamma Function
-     Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^{a-1} \exp(-t) for a > 0,
-     x >= 0.
+     Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^{a-1} \exp(-t) for a > 0, x
+     >= 0.
 
  -- Function: double gsl_sf_gamma_inc_P (double A, double X)
  -- Function: int gsl_sf_gamma_inc_P_e (double A, double X,
@@ -3985,7 +3962,7 @@ File: gsl-ref.info,  Node: Gegenbauer Functions,  Next: Hypergeometric Functions
 The Gegenbauer polynomials are defined in Abramowitz & Stegun, Chapter
 22, where they are known as Ultraspherical polynomials.  The functions
 described in this section are declared in the header file
-`gsl_sf_gegenbauer.h'.
+'gsl_sf_gegenbauer.h'.
 
  -- Function: double gsl_sf_gegenpoly_1 (double LAMBDA, double X)
  -- Function: double gsl_sf_gegenpoly_2 (double LAMBDA, double X)
@@ -4009,8 +3986,8 @@ described in this section are declared in the header file
  -- Function: int gsl_sf_gegenpoly_array (int NMAX, double LAMBDA,
           double X, double RESULT_ARRAY[])
      This function computes an array of Gegenbauer polynomials
-     C^{(\lambda)}_n(x) for n = 0, 1, 2, \dots, nmax, subject to
-     \lambda > -1/2, nmax >= 0.
+     C^{(\lambda)}_n(x) for n = 0, 1, 2, \dots, nmax, subject to \lambda
+     > -1/2, nmax >= 0.
 
 
 File: gsl-ref.info,  Node: Hypergeometric Functions,  Next: Laguerre Functions,  Prev: Gegenbauer Functions,  Up: Special Functions
@@ -4020,11 +3997,11 @@ File: gsl-ref.info,  Node: Hypergeometric Functions,  Next: Laguerre Functions,
 
 Hypergeometric functions are described in Abramowitz & Stegun, Chapters
 13 and 15.  These functions are declared in the header file
-`gsl_sf_hyperg.h'.
+'gsl_sf_hyperg.h'.
 
  -- Function: double gsl_sf_hyperg_0F1 (double C, double X)
- -- Function: int gsl_sf_hyperg_0F1_e (double C, double X,
-          gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_hyperg_0F1_e (double C, double X, gsl_sf_result
+          * RESULT)
      These routines compute the hypergeometric function 0F1(c,x).
 
  -- Function: double gsl_sf_hyperg_1F1_int (int M, int N, double X)
@@ -4048,7 +4025,7 @@ Hypergeometric functions are described in Abramowitz & Stegun, Chapters
  -- Function: int gsl_sf_hyperg_U_int_e10_e (int M, int N, double X,
           gsl_sf_result_e10 * RESULT)
      This routine computes the confluent hypergeometric function
-     U(m,n,x) for integer parameters M, N using the `gsl_sf_result_e10'
+     U(m,n,x) for integer parameters M, N using the 'gsl_sf_result_e10'
      type to return a result with extended range.
 
  -- Function: double gsl_sf_hyperg_U (double A, double B, double X)
@@ -4060,8 +4037,8 @@ Hypergeometric functions are described in Abramowitz & Stegun, Chapters
  -- Function: int gsl_sf_hyperg_U_e10_e (double A, double B, double X,
           gsl_sf_result_e10 * RESULT)
      This routine computes the confluent hypergeometric function
-     U(a,b,x) using the `gsl_sf_result_e10' type to return a result
-     with extended range.
+     U(a,b,x) using the 'gsl_sf_result_e10' type to return a result with
+     extended range.
 
  -- Function: double gsl_sf_hyperg_2F1 (double A, double B, double C,
           double X)
@@ -4071,29 +4048,29 @@ Hypergeometric functions are described in Abramowitz & Stegun, Chapters
      2F1(a,b,c,x) for |x| < 1.
 
      If the arguments (a,b,c,x) are too close to a singularity then the
-     function can return the error code `GSL_EMAXITER' when the series
+     function can return the error code 'GSL_EMAXITER' when the series
      approximation converges too slowly.  This occurs in the region of
      x=1, c - a - b = m for integer m.
 
  -- Function: double gsl_sf_hyperg_2F1_conj (double AR, double AI,
           double C, double X)
- -- Function: int gsl_sf_hyperg_2F1_conj_e (double AR, double AI,
-          double C, double X, gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_hyperg_2F1_conj_e (double AR, double AI, double
+          C, double X, gsl_sf_result * RESULT)
      These routines compute the Gauss hypergeometric function 2F1(a_R +
      i a_I, a_R - i a_I, c, x) with complex parameters for |x| < 1.
      exceptions:
 
  -- Function: double gsl_sf_hyperg_2F1_renorm (double A, double B,
           double C, double X)
- -- Function: int gsl_sf_hyperg_2F1_renorm_e (double A, double B,
-          double C, double X, gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_hyperg_2F1_renorm_e (double A, double B, double
+          C, double X, gsl_sf_result * RESULT)
      These routines compute the renormalized Gauss hypergeometric
      function 2F1(a,b,c,x) / \Gamma(c) for |x| < 1.
 
  -- Function: double gsl_sf_hyperg_2F1_conj_renorm (double AR, double
           AI, double C, double X)
- -- Function: int gsl_sf_hyperg_2F1_conj_renorm_e (double AR, double
-          AI, double C, double X, gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_hyperg_2F1_conj_renorm_e (double AR, double AI,
+          double C, double X, gsl_sf_result * RESULT)
      These routines compute the renormalized Gauss hypergeometric
      function 2F1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c) for |x| <
      1.
@@ -4101,8 +4078,8 @@ Hypergeometric functions are described in Abramowitz & Stegun, Chapters
  -- Function: double gsl_sf_hyperg_2F0 (double A, double B, double X)
  -- Function: int gsl_sf_hyperg_2F0_e (double A, double B, double X,
           gsl_sf_result * RESULT)
-     These routines compute the hypergeometric function 2F0(a,b,x).
-     The series representation is a divergent hypergeometric series.
+     These routines compute the hypergeometric function 2F0(a,b,x).  The
+     series representation is a divergent hypergeometric series.
      However, for x < 0 we have 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x)
 
 
@@ -4112,24 +4089,24 @@ File: gsl-ref.info,  Node: Laguerre Functions,  Next: Lambert W Functions,  Prev
 =======================
 
 The generalized Laguerre polynomials are defined in terms of confluent
-hypergeometric functions as L^a_n(x) = ((a+1)_n / n!) 1F1(-n,a+1,x),
-and are sometimes referred to as the associated Laguerre polynomials.
-They are related to the plain Laguerre polynomials L_n(x) by L^0_n(x) =
+hypergeometric functions as L^a_n(x) = ((a+1)_n / n!) 1F1(-n,a+1,x), and
+are sometimes referred to as the associated Laguerre polynomials.  They
+are related to the plain Laguerre polynomials L_n(x) by L^0_n(x) =
 L_n(x) and L^k_n(x) = (-1)^k (d^k/dx^k) L_(n+k)(x).  For more
 information see Abramowitz & Stegun, Chapter 22.
 
    The functions described in this section are declared in the header
-file `gsl_sf_laguerre.h'.
+file 'gsl_sf_laguerre.h'.
 
  -- Function: double gsl_sf_laguerre_1 (double A, double X)
  -- Function: double gsl_sf_laguerre_2 (double A, double X)
  -- Function: double gsl_sf_laguerre_3 (double A, double X)
- -- Function: int gsl_sf_laguerre_1_e (double A, double X,
-          gsl_sf_result * RESULT)
- -- Function: int gsl_sf_laguerre_2_e (double A, double X,
-          gsl_sf_result * RESULT)
- -- Function: int gsl_sf_laguerre_3_e (double A, double X,
-          gsl_sf_result * RESULT)
+ -- Function: int gsl_sf_laguerre_1_e (double A, double X, gsl_sf_result
+          * RESULT)
+ -- Function: int gsl_sf_laguerre_2_e (double A, double X, gsl_sf_result
+          * RESULT)
+ -- Function: int gsl_sf_laguerre_3_e (double A, double X, gsl_sf_result
+          * RESULT)
      These routines evaluate the generalized Laguerre polynomials
      L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.
 
@@ -4140,19 +4117,18 @@ file `gsl_sf_laguerre.h'.
      These routines evaluate the generalized Laguerre polynomials
      L^a_n(x) for a > -1, n >= 0.
 
-
 
 File: gsl-ref.info,  Node: Lambert W Functions,  Next: Legendre Functions and Spherical Harmonics,  Prev: Laguerre Functions,  Up: Special Functions
 
 7.23 Lambert W Functions
 ========================
 
-Lambert's W functions, W(x), are defined to be solutions of the
-equation W(x) \exp(W(x)) = x. This function has multiple branches for x
-< 0; however, it has only two real-valued branches. We define W_0(x) to
-be the principal branch, where W > -1 for x < 0, and W_{-1}(x) to be
-the other real branch, where W < -1 for x < 0.  The Lambert functions
-are declared in the header file `gsl_sf_lambert.h'.
+Lambert's W functions, W(x), are defined to be solutions of the equation
+W(x) \exp(W(x)) = x.  This function has multiple branches for x < 0;
+however, it has only two real-valued branches.  We define W_0(x) to be
+the principal branch, where W > -1 for x < 0, and W_{-1}(x) to be the
+other real branch, where W < -1 for x < 0.  The Lambert functions are
+declared in the header file 'gsl_sf_lambert.h'.
 
  -- Function: double gsl_sf_lambert_W0 (double X)
  -- Function: int gsl_sf_lambert_W0_e (double X, gsl_sf_result * RESULT)
@@ -4173,14 +4149,14 @@ File: gsl-ref.info,  Node: Legendre Functions and Spherical Harmonics,  Next: Lo
 
 The Legendre Functions and Legendre Polynomials are described in
 Abramowitz & Stegun, Chapter 8.  These functions are declared in the
-header file `gsl_sf_legendre.h'.
+header file 'gsl_sf_legendre.h'.
 
 * Menu:
 
-* Legendre Polynomials::
-* Associated Legendre Polynomials and Spherical Harmonics::
-* Conical Functions::
-* Radial Functions for Hyperbolic Space::
+* Legendre Polynomials::        
+* Associated Legendre Polynomials and Spherical Harmonics::  
+* Conical Functions::           
+* Radial Functions for Hyperbolic Space::  
 
 
 File: gsl-ref.info,  Node: Legendre Polynomials,  Next: Associated Legendre Polynomials and Spherical Harmonics,  Up: Legendre Functions and Spherical Harmonics
@@ -4201,8 +4177,8 @@ File: gsl-ref.info,  Node: Legendre Polynomials,  Next: Associated Legendre Poly
      explicit representations for l=1, 2, 3.
 
  -- Function: double gsl_sf_legendre_Pl (int L, double X)
- -- Function: int gsl_sf_legendre_Pl_e (int L, double X, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_legendre_Pl_e (int L, double X, gsl_sf_result *
+          RESULT)
      These functions evaluate the Legendre polynomial P_l(x) for a
      specific value of L, X subject to l >= 0, |x| <= 1
 
@@ -4210,6 +4186,7 @@ File: gsl-ref.info,  Node: Legendre Polynomials,  Next: Associated Legendre Poly
           RESULT_ARRAY[])
  -- Function: int gsl_sf_legendre_Pl_deriv_array (int LMAX, double X,
           double RESULT_ARRAY[], double RESULT_DERIV_ARRAY[])
+
      These functions compute an array of Legendre polynomials P_l(x),
      and optionally their derivatives dP_l(x)/dx, for l = 0, \dots,
      lmax, |x| <= 1
@@ -4227,8 +4204,8 @@ File: gsl-ref.info,  Node: Legendre Polynomials,  Next: Associated Legendre Poly
      != 1.
 
  -- Function: double gsl_sf_legendre_Ql (int L, double X)
- -- Function: int gsl_sf_legendre_Ql_e (int L, double X, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_legendre_Ql_e (int L, double X, gsl_sf_result *
+          RESULT)
      These routines compute the Legendre function Q_l(x) for x > -1, x
      != 1 and l >= 0.
 
@@ -4243,11 +4220,11 @@ P_l^m(x).  Note that this function grows combinatorially with l and can
 overflow for l larger than about 150.  There is no trouble for small m,
 but overflow occurs when m and l are both large.  Rather than allow
 overflows, these functions refuse to calculate P_l^m(x) and return
-`GSL_EOVRFLW' when they can sense that l and m are too big.
+'GSL_EOVRFLW' when they can sense that l and m are too big.
 
    If you want to calculate a spherical harmonic, then _do not_ use
-these functions.  Instead use `gsl_sf_legendre_sphPlm' below, which
-uses a similar recursion, but with the normalized functions.
+these functions.  Instead use 'gsl_sf_legendre_sphPlm' below, which uses
+a similar recursion, but with the normalized functions.
 
  -- Function: double gsl_sf_legendre_Plm (int L, int M, double X)
  -- Function: int gsl_sf_legendre_Plm_e (int L, int M, double X,
@@ -4260,8 +4237,8 @@ uses a similar recursion, but with the normalized functions.
  -- Function: int gsl_sf_legendre_Plm_deriv_array (int LMAX, int M,
           double X, double RESULT_ARRAY[], double RESULT_DERIV_ARRAY[])
      These functions compute an array of Legendre polynomials P_l^m(x),
-     and optionally their derivatives dP_l^m(x)/dx, for m >= 0, l =
-     |m|, ..., lmax, |x| <= 1.
+     and optionally their derivatives dP_l^m(x)/dx, for m >= 0, l = |m|,
+     ..., lmax, |x| <= 1.
 
  -- Function: double gsl_sf_legendre_sphPlm (int L, int M, double X)
  -- Function: int gsl_sf_legendre_sphPlm_e (int L, int M, double X,
@@ -4269,7 +4246,7 @@ uses a similar recursion, but with the normalized functions.
      These routines compute the normalized associated Legendre
      polynomial $\sqrt{(2l+1)/(4\pi)} \sqrt{(l-m)!/(l+m)!} P_l^m(x)$
      suitable for use in spherical harmonics.  The parameters must
-     satisfy m >= 0, l >= m, |x| <= 1. Theses routines avoid the
+     satisfy m >= 0, l >= m, |x| <= 1.  Theses routines avoid the
      overflows that occur for the standard normalization of P_l^m(x).
 
  -- Function: int gsl_sf_legendre_sphPlm_array (int LMAX, int M, double
@@ -4277,9 +4254,9 @@ uses a similar recursion, but with the normalized functions.
  -- Function: int gsl_sf_legendre_sphPlm_deriv_array (int LMAX, int M,
           double X, double RESULT_ARRAY[], double RESULT_DERIV_ARRAY[])
      These functions compute an array of normalized associated Legendre
-     functions $\sqrt{(2l+1)/(4\pi)} \sqrt{(l-m)!/(l+m)!} P_l^m(x)$,
-     and optionally their derivatives, for m >= 0, l = |m|, ..., lmax,
-     |x| <= 1.0
+     functions $\sqrt{(2l+1)/(4\pi)} \sqrt{(l-m)!/(l+m)!} P_l^m(x)$, and
+     optionally their derivatives, for m >= 0, l = |m|, ..., lmax, |x|
+     <= 1.0
 
  -- Function: int gsl_sf_legendre_array_size (const int LMAX, const int
           M)
@@ -4361,8 +4338,8 @@ limit, \lambda \to \infty, \eta \to 0, \lambda\eta fixed.
      Laplacian on the 3-dimensional hyperbolic space,
      L^{H3d}_1(\lambda,\eta) := 1/\sqrt{\lambda^2 + 1} \sin(\lambda
      \eta)/(\lambda \sinh(\eta)) (\coth(\eta) - \lambda
-     \cot(\lambda\eta)) for \eta >= 0.  In the flat limit this takes
-     the form L^{H3d}_1(\lambda,\eta) = j_1(\lambda\eta).
+     \cot(\lambda\eta)) for \eta >= 0.  In the flat limit this takes the
+     form L^{H3d}_1(\lambda,\eta) = j_1(\lambda\eta).
 
  -- Function: double gsl_sf_legendre_H3d (int L, double LAMBDA, double
           ETA)
@@ -4386,7 +4363,7 @@ File: gsl-ref.info,  Node: Logarithm and Related Functions,  Next: Mathieu Funct
 
 Information on the properties of the Logarithm function can be found in
 Abramowitz & Stegun, Chapter 4.  The functions described in this section
-are declared in the header file `gsl_sf_log.h'.
+are declared in the header file 'gsl_sf_log.h'.
 
  -- Function: double gsl_sf_log (double X)
  -- Function: int gsl_sf_log_e (double X, gsl_sf_result * RESULT)
@@ -4429,25 +4406,25 @@ are the solutions of the following two differential equations:
 
 The angular Mathieu functions ce_r(x,q), se_r(x,q) are the even and odd
 periodic solutions of the first equation, which is known as Mathieu's
-equation. These exist only for the discrete sequence of  characteristic
+equation.  These exist only for the discrete sequence of characteristic
 values a=a_r(q) (even-periodic) and a=b_r(q) (odd-periodic).
 
-   The radial Mathieu functions Mc^{(j)}_{r}(z,q), Ms^{(j)}_{r}(z,q)
-are the solutions of the second equation, which is referred to as
-Mathieu's modified equation.  The radial Mathieu functions of the
-first, second, third and fourth kind are denoted by the parameter j,
-which takes the value 1, 2, 3 or 4.
+   The radial Mathieu functions Mc^{(j)}_{r}(z,q), Ms^{(j)}_{r}(z,q) are
+the solutions of the second equation, which is referred to as Mathieu's
+modified equation.  The radial Mathieu functions of the first, second,
+third and fourth kind are denoted by the parameter j, which takes the
+value 1, 2, 3 or 4.
 
    For more information on the Mathieu functions, see Abramowitz and
 Stegun, Chapter 20.  These functions are defined in the header file
-`gsl_sf_mathieu.h'.
+'gsl_sf_mathieu.h'.
 
 * Menu:
 
-* Mathieu Function Workspace::
-* Mathieu Function Characteristic Values::
-* Angular Mathieu Functions::
-* Radial Mathieu Functions::
+* Mathieu Function Workspace::  
+* Mathieu Function Characteristic Values::  
+* Angular Mathieu Functions::   
+* Radial Mathieu Functions::    
 
 
 File: gsl-ref.info,  Node: Mathieu Function Workspace,  Next: Mathieu Function Characteristic Values,  Up: Mathieu Functions
@@ -4455,18 +4432,17 @@ File: gsl-ref.info,  Node: Mathieu Function Workspace,  Next: Mathieu Function C
 7.26.1 Mathieu Function Workspace
 ---------------------------------
 
-The Mathieu functions can be computed for a single order or for
-multiple orders, using array-based routines.  The array-based routines
-require a preallocated workspace.
+The Mathieu functions can be computed for a single order or for multiple
+orders, using array-based routines.  The array-based routines require a
+preallocated workspace.
 
- -- Function: gsl_sf_mathieu_workspace * gsl_sf_mathieu_alloc (size_t
-          N, double QMAX)
+ -- Function: gsl_sf_mathieu_workspace * gsl_sf_mathieu_alloc (size_t N,
+          double QMAX)
      This function returns a workspace for the array versions of the
      Mathieu routines.  The arguments N and QMAX specify the maximum
      order and q-value of Mathieu functions which can be computed with
      this workspace.
 
-
  -- Function: void gsl_sf_mathieu_free (gsl_sf_mathieu_workspace *WORK)
      This function frees the workspace WORK.
 
@@ -4490,8 +4466,8 @@ File: gsl-ref.info,  Node: Mathieu Function Characteristic Values,  Next: Angula
           double Q, gsl_sf_mathieu_workspace *WORK, double
           RESULT_ARRAY[])
      These routines compute a series of Mathieu characteristic values
-     a_n(q), b_n(q) for n from ORDER_MIN to ORDER_MAX inclusive,
-     storing the results in the array RESULT_ARRAY.
+     a_n(q), b_n(q) for n from ORDER_MIN to ORDER_MAX inclusive, storing
+     the results in the array RESULT_ARRAY.
 
 
 File: gsl-ref.info,  Node: Angular Mathieu Functions,  Next: Radial Mathieu Functions,  Prev: Mathieu Function Characteristic Values,  Up: Mathieu Functions
@@ -4506,11 +4482,11 @@ File: gsl-ref.info,  Node: Angular Mathieu Functions,  Next: Radial Mathieu Func
      These routines compute the angular Mathieu functions ce_n(q,x) and
      se_n(q,x), respectively.
 
- -- Function: int gsl_sf_mathieu_ce_array (int NMIN, int NMAX, double
-          Q, double X, gsl_sf_mathieu_workspace *WORK, double
+ -- Function: int gsl_sf_mathieu_ce_array (int NMIN, int NMAX, double Q,
+          double X, gsl_sf_mathieu_workspace *WORK, double
           RESULT_ARRAY[])
- -- Function: int gsl_sf_mathieu_se_array (int NMIN, int NMAX, double
-          Q, double X, gsl_sf_mathieu_workspace *WORK, double
+ -- Function: int gsl_sf_mathieu_se_array (int NMIN, int NMAX, double Q,
+          double X, gsl_sf_mathieu_workspace *WORK, double
           RESULT_ARRAY[])
      These routines compute a series of the angular Mathieu functions
      ce_n(q,x) and se_n(q,x) of order n from NMIN to NMAX inclusive,
@@ -4529,10 +4505,9 @@ File: gsl-ref.info,  Node: Radial Mathieu Functions,  Prev: Angular Mathieu Func
      These routines compute the radial J-th kind Mathieu functions
      Mc_n^{(j)}(q,x) and Ms_n^{(j)}(q,x) of order N.
 
-     The allowed values of J are 1 and 2.  The functions for j = 3,4
-     can be computed as M_n^{(3)} = M_n^{(1)} + iM_n^{(2)} and
-     M_n^{(4)} = M_n^{(1)} - iM_n^{(2)}, where M_n^{(j)} = Mc_n^{(j)} or
-     Ms_n^{(j)}.
+     The allowed values of J are 1 and 2.  The functions for j = 3,4 can
+     be computed as M_n^{(3)} = M_n^{(1)} + iM_n^{(2)} and M_n^{(4)} =
+     M_n^{(1)} - iM_n^{(2)}, where M_n^{(j)} = Mc_n^{(j)} or Ms_n^{(j)}.
 
  -- Function: int gsl_sf_mathieu_Mc_array (int J, int NMIN, int NMAX,
           double Q, double X, gsl_sf_mathieu_workspace *WORK, double
@@ -4541,8 +4516,8 @@ File: gsl-ref.info,  Node: Radial Mathieu Functions,  Prev: Angular Mathieu Func
           double Q, double X, gsl_sf_mathieu_workspace *WORK, double
           RESULT_ARRAY[])
      These routines compute a series of the radial Mathieu functions of
-     kind J, with order from NMIN to NMAX inclusive, storing the
-     results in the array RESULT_ARRAY.
+     kind J, with order from NMIN to NMAX inclusive, storing the results
+     in the array RESULT_ARRAY.
 
 
 File: gsl-ref.info,  Node: Power Function,  Next: Psi (Digamma) Function,  Prev: Mathieu Functions,  Up: Special Functions
@@ -4550,15 +4525,15 @@ File: gsl-ref.info,  Node: Power Function,  Next: Psi (Digamma) Function,  Prev:
 7.27 Power Function
 ===================
 
-The following functions are equivalent to the function `gsl_pow_int'
+The following functions are equivalent to the function 'gsl_pow_int'
 (*note Small integer powers::) with an error estimate.  These functions
-are declared in the header file `gsl_sf_pow_int.h'.
+are declared in the header file 'gsl_sf_pow_int.h'.
 
  -- Function: double gsl_sf_pow_int (double X, int N)
  -- Function: int gsl_sf_pow_int_e (double X, int N, gsl_sf_result *
           RESULT)
      These routines compute the power x^n for integer N.  The power is
-     computed using the minimum number of multiplications. For example,
+     computed using the minimum number of multiplications.  For example,
      x^8 is computed as ((x^2)^2)^2, requiring only 3 multiplications.
      For reasons of efficiency, these functions do not check for
      overflow or underflow conditions.
@@ -4578,13 +4553,13 @@ The polygamma functions of order n are defined by
      \psi^{(n)}(x) = (d/dx)^n \psi(x) = (d/dx)^{n+1} \log(\Gamma(x))
 
 where \psi(x) = \Gamma'(x)/\Gamma(x) is known as the digamma function.
-These functions are declared in the header file `gsl_sf_psi.h'.
+These functions are declared in the header file 'gsl_sf_psi.h'.
 
 * Menu:
 
-* Digamma Function::
-* Trigamma Function::
-* Polygamma Function::
+* Digamma Function::            
+* Trigamma Function::           
+* Polygamma Function::          
 
 
 File: gsl-ref.info,  Node: Digamma Function,  Next: Trigamma Function,  Up: Psi (Digamma) Function
@@ -4604,8 +4579,8 @@ File: gsl-ref.info,  Node: Digamma Function,  Next: Trigamma Function,  Up: Psi
 
  -- Function: double gsl_sf_psi_1piy (double Y)
  -- Function: int gsl_sf_psi_1piy_e (double Y, gsl_sf_result * RESULT)
-     These routines compute the real part of the digamma function on
-     the line 1+i y, \Re[\psi(1 + i y)].
+     These routines compute the real part of the digamma function on the
+     line 1+i y, \Re[\psi(1 + i y)].
 
 
 File: gsl-ref.info,  Node: Trigamma Function,  Next: Polygamma Function,  Prev: Digamma Function,  Up: Psi (Digamma) Function
@@ -4642,7 +4617,7 @@ File: gsl-ref.info,  Node: Synchrotron Functions,  Next: Transport Functions,  P
 ==========================
 
 The functions described in this section are declared in the header file
-`gsl_sf_synchrotron.h'.
+'gsl_sf_synchrotron.h'.
 
  -- Function: double gsl_sf_synchrotron_1 (double X)
  -- Function: int gsl_sf_synchrotron_1_e (double X, gsl_sf_result *
@@ -4653,8 +4628,8 @@ The functions described in this section are declared in the header file
  -- Function: double gsl_sf_synchrotron_2 (double X)
  -- Function: int gsl_sf_synchrotron_2_e (double X, gsl_sf_result *
           RESULT)
-     These routines compute the second synchrotron function x
-     K_{2/3}(x) for x >= 0.
+     These routines compute the second synchrotron function x K_{2/3}(x)
+     for x >= 0.
 
 
 File: gsl-ref.info,  Node: Transport Functions,  Next: Trigonometric Functions,  Prev: Synchrotron Functions,  Up: Special Functions
@@ -4664,7 +4639,7 @@ File: gsl-ref.info,  Node: Transport Functions,  Next: Trigonometric Functions,
 
 The transport functions J(n,x) are defined by the integral
 representations J(n,x) := \int_0^x dt t^n e^t /(e^t - 1)^2.  They are
-declared in the header file `gsl_sf_transport.h'.
+declared in the header file 'gsl_sf_transport.h'.
 
  -- Function: double gsl_sf_transport_2 (double X)
  -- Function: int gsl_sf_transport_2_e (double X, gsl_sf_result *
@@ -4694,16 +4669,16 @@ File: gsl-ref.info,  Node: Trigonometric Functions,  Next: Zeta Functions,  Prev
 
 The library includes its own trigonometric functions in order to provide
 consistency across platforms and reliable error estimates.  These
-functions are declared in the header file `gsl_sf_trig.h'.
+functions are declared in the header file 'gsl_sf_trig.h'.
 
 * Menu:
 
-* Circular Trigonometric Functions::
-* Trigonometric Functions for Complex Arguments::
-* Hyperbolic Trigonometric Functions::
-* Conversion Functions::
-* Restriction Functions::
-* Trigonometric Functions With Error Estimates::
+* Circular Trigonometric Functions::  
+* Trigonometric Functions for Complex Arguments::  
+* Hyperbolic Trigonometric Functions::  
+* Conversion Functions::        
+* Restriction Functions::       
+* Trigonometric Functions With Error Estimates::  
 
 
 File: gsl-ref.info,  Node: Circular Trigonometric Functions,  Next: Trigonometric Functions for Complex Arguments,  Up: Trigonometric Functions
@@ -4796,7 +4771,7 @@ File: gsl-ref.info,  Node: Restriction Functions,  Next: Trigonometric Functions
      (-\pi,\pi].
 
      Note that the mathematical value of \pi is slightly greater than
-     `M_PI', so the machine numbers `M_PI' and `-M_PI' are included in
+     'M_PI', so the machine numbers 'M_PI' and '-M_PI' are included in
      the range.
 
  -- Function: double gsl_sf_angle_restrict_pos (double THETA)
@@ -4804,8 +4779,7 @@ File: gsl-ref.info,  Node: Restriction Functions,  Next: Trigonometric Functions
      These routines force the angle THETA to lie in the range [0, 2\pi).
 
      Note that the mathematical value of 2\pi is slightly greater than
-     `2*M_PI', so the machine number `2*M_PI' is included in the range.
-
+     '2*M_PI', so the machine number '2*M_PI' is included in the range.
 
 
 File: gsl-ref.info,  Node: Trigonometric Functions With Error Estimates,  Prev: Restriction Functions,  Up: Trigonometric Functions
@@ -4813,15 +4787,15 @@ File: gsl-ref.info,  Node: Trigonometric Functions With Error Estimates,  Prev:
 7.31.6 Trigonometric Functions With Error Estimates
 ---------------------------------------------------
 
- -- Function: int gsl_sf_sin_err_e (double X, double DX, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_sin_err_e (double X, double DX, gsl_sf_result *
+          RESULT)
      This routine computes the sine of an angle X with an associated
      absolute error DX, \sin(x \pm dx).  Note that this function is
      provided in the error-handling form only since its purpose is to
      compute the propagated error.
 
- -- Function: int gsl_sf_cos_err_e (double X, double DX, gsl_sf_result
-          * RESULT)
+ -- Function: int gsl_sf_cos_err_e (double X, double DX, gsl_sf_result *
+          RESULT)
      This routine computes the cosine of an angle X with an associated
      absolute error DX, \cos(x \pm dx).  Note that this function is
      provided in the error-handling form only since its purpose is to
@@ -4835,7 +4809,7 @@ File: gsl-ref.info,  Node: Zeta Functions,  Next: Special Functions Examples,  P
 
 The Riemann zeta function is defined in Abramowitz & Stegun, Section
 23.2.  The functions described in this section are declared in the
-header file `gsl_sf_zeta.h'.
+header file 'gsl_sf_zeta.h'.
 
 * Menu:
 
@@ -4870,8 +4844,8 @@ File: gsl-ref.info,  Node: Riemann Zeta Function Minus One,  Next: Hurwitz Zeta
 --------------------------------------
 
 For large positive argument, the Riemann zeta function approaches one.
-In this region the fractional part is interesting, and therefore we
-need a function to evaluate it explicitly.
+In this region the fractional part is interesting, and therefore we need
+a function to evaluate it explicitly.
 
  -- Function: double gsl_sf_zetam1_int (int N)
  -- Function: int gsl_sf_zetam1_int_e (int N, gsl_sf_result * RESULT)
@@ -4893,8 +4867,8 @@ The Hurwitz zeta function is defined by \zeta(s,q) = \sum_0^\infty
  -- Function: double gsl_sf_hzeta (double S, double Q)
  -- Function: int gsl_sf_hzeta_e (double S, double Q, gsl_sf_result *
           RESULT)
-     These routines compute the Hurwitz zeta function \zeta(s,q) for s
-     > 1, q > 0.
+     These routines compute the Hurwitz zeta function \zeta(s,q) for s >
+     1, q > 0.
 
 
 File: gsl-ref.info,  Node: Eta Function,  Prev: Hurwitz Zeta Function,  Up: Zeta Functions
@@ -4953,7 +4927,7 @@ Here are the results of running the program,
      exact   = -0.177596771314338292
 
 The next program computes the same quantity using the natural form of
-the function. In this case the error term RESULT.ERR and return status
+the function.  In this case the error term RESULT.ERR and return status
 are not accessible.
 
      #include <stdio.h>
@@ -4984,14 +4958,14 @@ File: gsl-ref.info,  Node: Special Functions References and Further Reading,  Pr
 7.34 References and Further Reading
 ===================================
 
-The library follows the conventions of `Abramowitz & Stegun' where
+The library follows the conventions of 'Abramowitz & Stegun' where
 possible,
-     Abramowitz & Stegun (eds.), `Handbook of Mathematical Functions'
+     Abramowitz & Stegun (eds.), 'Handbook of Mathematical Functions'
 
 The following papers contain information on the algorithms used to
-compute the special functions, 
+compute the special functions,
      MISCFUN: A software package to compute uncommon special functions.
-     `ACM Trans. Math. Soft.', vol. 22, 1996, 288-301
+     'ACM Trans. Math. Soft.', vol. 22, 1996, 288-301
 
      G.N. Watson, A Treatise on the Theory of Bessel Functions, 2nd
      Edition (Cambridge University Press, 1944).
@@ -5007,7 +4981,6 @@ compute the special functions,
      Y.Y. Luke, Algorithms for the Computation of Mathematical
      Functions, Academic Press, New York (1977).
 
-
 
 File: gsl-ref.info,  Node: Vectors and Matrices,  Next: Permutations,  Prev: Special Functions,  Up: Top
 
@@ -5015,7 +4988,7 @@ File: gsl-ref.info,  Node: Vectors and Matrices,  Next: Permutations,  Prev: Spe
 **********************
 
 The functions described in this chapter provide a simple vector and
-matrix interface to ordinary C arrays. The memory management of these
+matrix interface to ordinary C arrays.  The memory management of these
 arrays is implemented using a single underlying type, known as a block.
 By writing your functions in terms of vectors and matrices you can pass
 a single structure containing both data and dimensions as an argument
@@ -5024,11 +4997,11 @@ compatible with the vector and matrix formats used by BLAS routines.
 
 * Menu:
 
-* Data types::
-* Blocks::
-* Vectors::
-* Matrices::
-* Vector and Matrix References and Further Reading::
+* Data types::                  
+* Blocks::                      
+* Vectors::                     
+* Matrices::                    
+* Vector and Matrix References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Data types,  Next: Blocks,  Up: Vectors and Matrices
@@ -5037,10 +5010,10 @@ File: gsl-ref.info,  Node: Data types,  Next: Blocks,  Up: Vectors and Matrices
 ==============
 
 All the functions are available for each of the standard data-types.
-The versions for `double' have the prefix `gsl_block', `gsl_vector' and
-`gsl_matrix'.  Similarly the versions for single-precision `float'
-arrays have the prefix `gsl_block_float', `gsl_vector_float' and
-`gsl_matrix_float'.  The full list of available types is given below,
+The versions for 'double' have the prefix 'gsl_block', 'gsl_vector' and
+'gsl_matrix'.  Similarly the versions for single-precision 'float'
+arrays have the prefix 'gsl_block_float', 'gsl_vector_float' and
+'gsl_matrix_float'.  The full list of available types is given below,
 
      gsl_block                       double
      gsl_block_float                 float
@@ -5057,7 +5030,7 @@ arrays have the prefix `gsl_block_float', `gsl_vector_float' and
      gsl_block_complex_float         complex float
      gsl_block_complex_long_double   complex long double
 
-Corresponding types exist for the `gsl_vector' and `gsl_matrix'
+Corresponding types exist for the 'gsl_vector' and 'gsl_matrix'
 functions.
 
 
@@ -5066,10 +5039,9 @@ File: gsl-ref.info,  Node: Blocks,  Next: Vectors,  Prev: Data types,  Up: Vecto
 8.2 Blocks
 ==========
 
-For consistency all memory is allocated through a `gsl_block'
-structure.  The structure contains two components, the size of an area
-of memory and a pointer to the memory.  The `gsl_block' structure looks
-like this,
+For consistency all memory is allocated through a 'gsl_block' structure.
+The structure contains two components, the size of an area of memory and
+a pointer to the memory.  The 'gsl_block' structure looks like this,
 
      typedef struct
      {
@@ -5077,20 +5049,20 @@ like this,
        double * data;
      } gsl_block;
 
-Vectors and matrices are made by "slicing" an underlying block. A slice
+Vectors and matrices are made by "slicing" an underlying block.  A slice
 is a set of elements formed from an initial offset and a combination of
-indices and step-sizes. In the case of a matrix the step-size for the
+indices and step-sizes.  In the case of a matrix the step-size for the
 column index represents the row-length.  The step-size for a vector is
 known as the "stride".
 
    The functions for allocating and deallocating blocks are defined in
-`gsl_block.h'
+'gsl_block.h'
 
 * Menu:
 
-* Block allocation::
-* Reading and writing blocks::
-* Example programs for blocks::
+* Block allocation::            
+* Reading and writing blocks::  
+* Example programs for blocks::  
 
 
 File: gsl-ref.info,  Node: Block allocation,  Next: Reading and writing blocks,  Up: Blocks
@@ -5099,18 +5071,18 @@ File: gsl-ref.info,  Node: Block allocation,  Next: Reading and writing blocks,
 ----------------------
 
 The functions for allocating memory to a block follow the style of
-`malloc' and `free'.  In addition they also perform their own error
-checking.  If there is insufficient memory available to allocate a
-block then the functions call the GSL error handler (with an error
-number of `GSL_ENOMEM') in addition to returning a null pointer.  Thus
-if you use the library error handler to abort your program then it
-isn't necessary to check every `alloc'.
+'malloc' and 'free'.  In addition they also perform their own error
+checking.  If there is insufficient memory available to allocate a block
+then the functions call the GSL error handler (with an error number of
+'GSL_ENOMEM') in addition to returning a null pointer.  Thus if you use
+the library error handler to abort your program then it isn't necessary
+to check every 'alloc'.
 
  -- Function: gsl_block * gsl_block_alloc (size_t N)
      This function allocates memory for a block of N double-precision
      elements, returning a pointer to the block struct.  The block is
      not initialized and so the values of its elements are undefined.
-     Use the function `gsl_block_calloc' if you want to ensure that all
+     Use the function 'gsl_block_calloc' if you want to ensure that all
      the elements are initialized to zero.
 
      A null pointer is returned if insufficient memory is available to
@@ -5122,7 +5094,7 @@ isn't necessary to check every `alloc'.
 
  -- Function: void gsl_block_free (gsl_block * B)
      This function frees the memory used by a block B previously
-     allocated with `gsl_block_alloc' or `gsl_block_calloc'.  The block
+     allocated with 'gsl_block_alloc' or 'gsl_block_calloc'.  The block
      B must be a valid block object (a null pointer is not allowed).
 
 
@@ -5137,33 +5109,33 @@ as binary data or formatted text.
  -- Function: int gsl_block_fwrite (FILE * STREAM, const gsl_block * B)
      This function writes the elements of the block B to the stream
      STREAM in binary format.  The return value is 0 for success and
-     `GSL_EFAILED' if there was a problem writing to the file.  Since
+     'GSL_EFAILED' if there was a problem writing to the file.  Since
      the data is written in the native binary format it may not be
      portable between different architectures.
 
  -- Function: int gsl_block_fread (FILE * STREAM, gsl_block * B)
-     This function reads into the block B from the open stream STREAM
-     in binary format.  The block B must be preallocated with the
-     correct length since the function uses the size of B to determine
-     how many bytes to read.  The return value is 0 for success and
-     `GSL_EFAILED' if there was a problem reading from the file.  The
-     data is assumed to have been written in the native binary format
-     on the same architecture.
-
- -- Function: int gsl_block_fprintf (FILE * STREAM, const gsl_block *
-          B, const char * FORMAT)
+     This function reads into the block B from the open stream STREAM in
+     binary format.  The block B must be preallocated with the correct
+     length since the function uses the size of B to determine how many
+     bytes to read.  The return value is 0 for success and 'GSL_EFAILED'
+     if there was a problem reading from the file.  The data is assumed
+     to have been written in the native binary format on the same
+     architecture.
+
+ -- Function: int gsl_block_fprintf (FILE * STREAM, const gsl_block * B,
+          const char * FORMAT)
      This function writes the elements of the block B line-by-line to
      the stream STREAM using the format specifier FORMAT, which should
-     be one of the `%g', `%e' or `%f' formats for floating point
-     numbers and `%d' for integers.  The function returns 0 for success
-     and `GSL_EFAILED' if there was a problem writing to the file.
+     be one of the '%g', '%e' or '%f' formats for floating point numbers
+     and '%d' for integers.  The function returns 0 for success and
+     'GSL_EFAILED' if there was a problem writing to the file.
 
  -- Function: int gsl_block_fscanf (FILE * STREAM, gsl_block * B)
      This function reads formatted data from the stream STREAM into the
      block B.  The block B must be preallocated with the correct length
-     since the function uses the size of B to determine how many
-     numbers to read.  The function returns 0 for success and
-     `GSL_EFAILED' if there was a problem reading from the file.
+     since the function uses the size of B to determine how many numbers
+     to read.  The function returns 0 for success and 'GSL_EFAILED' if
+     there was a problem reading from the file.
 
 
 File: gsl-ref.info,  Node: Example programs for blocks,  Prev: Reading and writing blocks,  Up: Blocks
@@ -5199,14 +5171,14 @@ File: gsl-ref.info,  Node: Vectors,  Next: Matrices,  Prev: Blocks,  Up: Vectors
 8.3 Vectors
 ===========
 
-Vectors are defined by a `gsl_vector' structure which describes a slice
+Vectors are defined by a 'gsl_vector' structure which describes a slice
 of a block.  Different vectors can be created which point to the same
-block.  A vector slice is a set of equally-spaced elements of an area
-of memory.
+block.  A vector slice is a set of equally-spaced elements of an area of
+memory.
 
-   The `gsl_vector' structure contains five components, the "size", the
-"stride", a pointer to the memory where the elements are stored, DATA,
-a pointer to the block owned by the vector, BLOCK, if any, and an
+   The 'gsl_vector' structure contains five components, the "size", the
+"stride", a pointer to the memory where the elements are stored, DATA, a
+pointer to the block owned by the vector, BLOCK, if any, and an
 ownership flag, OWNER.  The structure is very simple and looks like
 this,
 
@@ -5220,32 +5192,32 @@ this,
      } gsl_vector;
 
 The SIZE is simply the number of vector elements.  The range of valid
-indices runs from 0 to `size-1'.  The STRIDE is the step-size from one
+indices runs from 0 to 'size-1'.  The STRIDE is the step-size from one
 element to the next in physical memory, measured in units of the
 appropriate datatype.  The pointer DATA gives the location of the first
 element of the vector in memory.  The pointer BLOCK stores the location
 of the memory block in which the vector elements are located (if any).
-If the vector owns this block then the OWNER field is set to one and
-the block will be deallocated when the vector is freed.  If the vector
+If the vector owns this block then the OWNER field is set to one and the
+block will be deallocated when the vector is freed.  If the vector
 points to a block owned by another object then the OWNER field is zero
 and any underlying block will not be deallocated with the vector.
 
    The functions for allocating and accessing vectors are defined in
-`gsl_vector.h'
+'gsl_vector.h'
 
 * Menu:
 
-* Vector allocation::
-* Accessing vector elements::
-* Initializing vector elements::
-* Reading and writing vectors::
-* Vector views::
-* Copying vectors::
-* Exchanging elements::
-* Vector operations::
-* Finding maximum and minimum elements of vectors::
-* Vector properties::
-* Example programs for vectors::
+* Vector allocation::           
+* Accessing vector elements::   
+* Initializing vector elements::  
+* Reading and writing vectors::  
+* Vector views::                
+* Copying vectors::             
+* Exchanging elements::         
+* Vector operations::           
+* Finding maximum and minimum elements of vectors::  
+* Vector properties::           
+* Example programs for vectors::  
 
 
 File: gsl-ref.info,  Node: Vector allocation,  Next: Accessing vector elements,  Up: Vectors
@@ -5254,18 +5226,18 @@ File: gsl-ref.info,  Node: Vector allocation,  Next: Accessing vector elements,
 -----------------------
 
 The functions for allocating memory to a vector follow the style of
-`malloc' and `free'.  In addition they also perform their own error
+'malloc' and 'free'.  In addition they also perform their own error
 checking.  If there is insufficient memory available to allocate a
 vector then the functions call the GSL error handler (with an error
-number of `GSL_ENOMEM') in addition to returning a null pointer.  Thus
-if you use the library error handler to abort your program then it
-isn't necessary to check every `alloc'.
+number of 'GSL_ENOMEM') in addition to returning a null pointer.  Thus
+if you use the library error handler to abort your program then it isn't
+necessary to check every 'alloc'.
 
  -- Function: gsl_vector * gsl_vector_alloc (size_t N)
      This function creates a vector of length N, returning a pointer to
-     a newly initialized vector struct. A new block is allocated for the
-     elements of the vector, and stored in the BLOCK component of the
-     vector struct.  The block is "owned" by the vector, and will be
+     a newly initialized vector struct.  A new block is allocated for
+     the elements of the vector, and stored in the BLOCK component of
+     the vector struct.  The block is "owned" by the vector, and will be
      deallocated when the vector is deallocated.
 
  -- Function: gsl_vector * gsl_vector_calloc (size_t N)
@@ -5273,12 +5245,12 @@ isn't necessary to check every `alloc'.
      initializes all the elements of the vector to zero.
 
  -- Function: void gsl_vector_free (gsl_vector * V)
-     This function frees a previously allocated vector V.  If the
-     vector was created using `gsl_vector_alloc' then the block
-     underlying the vector will also be deallocated.  If the vector has
-     been created from another object then the memory is still owned by
-     that object and will not be deallocated.  The vector V must be a
-     valid vector object (a null pointer is not allowed).
+     This function frees a previously allocated vector V.  If the vector
+     was created using 'gsl_vector_alloc' then the block underlying the
+     vector will also be deallocated.  If the vector has been created
+     from another object then the memory is still owned by that object
+     and will not be deallocated.  The vector V must be a valid vector
+     object (a null pointer is not allowed).
 
 
 File: gsl-ref.info,  Node: Accessing vector elements,  Next: Initializing vector elements,  Prev: Vector allocation,  Up: Vectors
@@ -5286,25 +5258,24 @@ File: gsl-ref.info,  Node: Accessing vector elements,  Next: Initializing vector
 8.3.2 Accessing vector elements
 -------------------------------
 
-Unlike FORTRAN compilers, C compilers do not usually provide support
-for range checking of vectors and matrices.  Range checking is
-available in the GNU C Compiler bounds-checking extension, but it is not
-part of the default installation of GCC.  The functions
-`gsl_vector_get' and `gsl_vector_set' can perform portable range
-checking for you and report an error if you attempt to access elements
-outside the allowed range.
+Unlike FORTRAN compilers, C compilers do not usually provide support for
+range checking of vectors and matrices.  Range checking is available in
+the GNU C Compiler bounds-checking extension, but it is not part of the
+default installation of GCC. The functions 'gsl_vector_get' and
+'gsl_vector_set' can perform portable range checking for you and report
+an error if you attempt to access elements outside the allowed range.
 
    The functions for accessing the elements of a vector or matrix are
-defined in `gsl_vector.h' and declared `extern inline' to eliminate
+defined in 'gsl_vector.h' and declared 'extern inline' to eliminate
 function-call overhead.  You must compile your program with the macro
-`HAVE_INLINE' defined to use these functions.
+'HAVE_INLINE' defined to use these functions.
 
    If necessary you can turn off range checking completely without
 modifying any source files by recompiling your program with the
-preprocessor definition `GSL_RANGE_CHECK_OFF'.  Provided your compiler
-supports inline functions the effect of turning off range checking is
-to replace calls to `gsl_vector_get(v,i)' by `v->data[i*v->stride]' and
-calls to `gsl_vector_set(v,i,x)' by `v->data[i*v->stride]=x'.  Thus
+preprocessor definition 'GSL_RANGE_CHECK_OFF'.  Provided your compiler
+supports inline functions the effect of turning off range checking is to
+replace calls to 'gsl_vector_get(v,i)' by 'v->data[i*v->stride]' and
+calls to 'gsl_vector_set(v,i,x)' by 'v->data[i*v->stride]=x'.  Thus
 there should be no performance penalty for using the range checking
 functions when range checking is turned off.
 
@@ -5319,10 +5290,10 @@ functions when range checking is turned off.
      handler is invoked.
 
  -- Function: double * gsl_vector_ptr (gsl_vector * V, size_t I)
- -- Function: const double * gsl_vector_const_ptr (const gsl_vector *
-          V, size_t I)
-     These functions return a pointer to the I-th element of a vector
-     V.  If I lies outside the allowed range of 0 to N-1 then the error
+ -- Function: const double * gsl_vector_const_ptr (const gsl_vector * V,
+          size_t I)
+     These functions return a pointer to the I-th element of a vector V.
+     If I lies outside the allowed range of 0 to N-1 then the error
      handler is invoked and a null pointer is returned.
 
 
@@ -5355,7 +5326,7 @@ as binary data or formatted text.
           V)
      This function writes the elements of the vector V to the stream
      STREAM in binary format.  The return value is 0 for success and
-     `GSL_EFAILED' if there was a problem writing to the file.  Since
+     'GSL_EFAILED' if there was a problem writing to the file.  Since
      the data is written in the native binary format it may not be
      portable between different architectures.
 
@@ -5364,24 +5335,24 @@ as binary data or formatted text.
      in binary format.  The vector V must be preallocated with the
      correct length since the function uses the size of V to determine
      how many bytes to read.  The return value is 0 for success and
-     `GSL_EFAILED' if there was a problem reading from the file.  The
-     data is assumed to have been written in the native binary format
-     on the same architecture.
+     'GSL_EFAILED' if there was a problem reading from the file.  The
+     data is assumed to have been written in the native binary format on
+     the same architecture.
 
  -- Function: int gsl_vector_fprintf (FILE * STREAM, const gsl_vector *
           V, const char * FORMAT)
      This function writes the elements of the vector V line-by-line to
      the stream STREAM using the format specifier FORMAT, which should
-     be one of the `%g', `%e' or `%f' formats for floating point
-     numbers and `%d' for integers.  The function returns 0 for success
-     and `GSL_EFAILED' if there was a problem writing to the file.
+     be one of the '%g', '%e' or '%f' formats for floating point numbers
+     and '%d' for integers.  The function returns 0 for success and
+     'GSL_EFAILED' if there was a problem writing to the file.
 
  -- Function: int gsl_vector_fscanf (FILE * STREAM, gsl_vector * V)
      This function reads formatted data from the stream STREAM into the
      vector V.  The vector V must be preallocated with the correct
      length since the function uses the size of V to determine how many
      numbers to read.  The function returns 0 for success and
-     `GSL_EFAILED' if there was a problem reading from the file.
+     'GSL_EFAILED' if there was a problem reading from the file.
 
 
 File: gsl-ref.info,  Node: Vector views,  Next: Copying vectors,  Prev: Reading and writing vectors,  Up: Vectors
@@ -5398,17 +5369,17 @@ vector.
    A vector view is a temporary object, stored on the stack, which can
 be used to operate on a subset of vector elements.  Vector views can be
 defined for both constant and non-constant vectors, using separate types
-that preserve constness.  A vector view has the type `gsl_vector_view'
-and a constant vector view has the type `gsl_vector_const_view'.  In
-both cases the elements of the view can be accessed as a `gsl_vector'
-using the `vector' component of the view object.  A pointer to a vector
-of type `gsl_vector *' or `const gsl_vector *' can be obtained by
-taking the address of this component with the `&' operator.
+that preserve constness.  A vector view has the type 'gsl_vector_view'
+and a constant vector view has the type 'gsl_vector_const_view'.  In
+both cases the elements of the view can be accessed as a 'gsl_vector'
+using the 'vector' component of the view object.  A pointer to a vector
+of type 'gsl_vector *' or 'const gsl_vector *' can be obtained by taking
+the address of this component with the '&' operator.
 
    When using this pointer it is important to ensure that the view
 itself remains in scope--the simplest way to do so is by always writing
-the pointer as `&'VIEW`.vector', and never storing this value in
-another variable.
+the pointer as '&'VIEW'.vector', and never storing this value in another
+variable.
 
  -- Function: gsl_vector_view gsl_vector_subvector (gsl_vector * V,
           size_t OFFSET, size_t N)
@@ -5417,48 +5388,48 @@ another variable.
      These functions return a vector view of a subvector of another
      vector V.  The start of the new vector is offset by OFFSET elements
      from the start of the original vector.  The new vector has N
-     elements.  Mathematically, the I-th element of the new vector V'
-     is given by,
+     elements.  Mathematically, the I-th element of the new vector V' is
+     given by,
 
           v'(i) = v->data[(offset + i)*v->stride]
 
-     where the index I runs from 0 to `n-1'.
+     where the index I runs from 0 to 'n-1'.
 
-     The `data' pointer of the returned vector struct is set to null if
+     The 'data' pointer of the returned vector struct is set to null if
      the combined parameters (OFFSET,N) overrun the end of the original
      vector.
 
      The new vector is only a view of the block underlying the original
      vector, V.  The block containing the elements of V is not owned by
      the new vector.  When the view goes out of scope the original
-     vector V and its block will continue to exist.  The original
-     memory can only be deallocated by freeing the original vector.  Of
-     course, the original vector should not be deallocated while the
-     view is still in use.
+     vector V and its block will continue to exist.  The original memory
+     can only be deallocated by freeing the original vector.  Of course,
+     the original vector should not be deallocated while the view is
+     still in use.
 
-     The function `gsl_vector_const_subvector' is equivalent to
-     `gsl_vector_subvector' but can be used for vectors which are
-     declared `const'.
+     The function 'gsl_vector_const_subvector' is equivalent to
+     'gsl_vector_subvector' but can be used for vectors which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_vector_subvector_with_stride
           (gsl_vector * V, size_t OFFSET, size_t STRIDE, size_t N)
  -- Function: gsl_vector_const_view
-gsl_vector_const_subvector_with_stride (const gsl_vector * V, size_t
-          OFFSET, size_t STRIDE, size_t N)
+          gsl_vector_const_subvector_with_stride (const gsl_vector * V,
+          size_t OFFSET, size_t STRIDE, size_t N)
      These functions return a vector view of a subvector of another
-     vector V with an additional stride argument. The subvector is
-     formed in the same way as for `gsl_vector_subvector' but the new
+     vector V with an additional stride argument.  The subvector is
+     formed in the same way as for 'gsl_vector_subvector' but the new
      vector has N elements with a step-size of STRIDE from one element
      to the next in the original vector.  Mathematically, the I-th
      element of the new vector V' is given by,
 
           v'(i) = v->data[(offset + i*stride)*v->stride]
 
-     where the index I runs from 0 to `n-1'.
+     where the index I runs from 0 to 'n-1'.
 
      Note that subvector views give direct access to the underlying
-     elements of the original vector. For example, the following code
-     will zero the even elements of the vector `v' of length `n', while
+     elements of the original vector.  For example, the following code
+     will zero the even elements of the vector 'v' of length 'n', while
      leaving the odd elements untouched,
 
           gsl_vector_view v_even
@@ -5467,86 +5438,86 @@ gsl_vector_const_subvector_with_stride (const gsl_vector * V, size_t
 
      A vector view can be passed to any subroutine which takes a vector
      argument just as a directly allocated vector would be, using
-     `&'VIEW`.vector'.  For example, the following code computes the
-     norm of the odd elements of `v' using the BLAS routine DNRM2,
+     '&'VIEW'.vector'.  For example, the following code computes the
+     norm of the odd elements of 'v' using the BLAS routine DNRM2,
 
           gsl_vector_view v_odd
             = gsl_vector_subvector_with_stride (v, 1, 2, n/2);
           double r = gsl_blas_dnrm2 (&v_odd.vector);
 
-     The function `gsl_vector_const_subvector_with_stride' is equivalent
-     to `gsl_vector_subvector_with_stride' but can be used for vectors
-     which are declared `const'.
+     The function 'gsl_vector_const_subvector_with_stride' is equivalent
+     to 'gsl_vector_subvector_with_stride' but can be used for vectors
+     which are declared 'const'.
 
  -- Function: gsl_vector_view gsl_vector_complex_real
           (gsl_vector_complex * V)
- -- Function: gsl_vector_const_view gsl_vector_complex_const_real
-          (const gsl_vector_complex * V)
+ -- Function: gsl_vector_const_view gsl_vector_complex_const_real (const
+          gsl_vector_complex * V)
      These functions return a vector view of the real parts of the
      complex vector V.
 
-     The function `gsl_vector_complex_const_real' is equivalent to
-     `gsl_vector_complex_real' but can be used for vectors which are
-     declared `const'.
+     The function 'gsl_vector_complex_const_real' is equivalent to
+     'gsl_vector_complex_real' but can be used for vectors which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_vector_complex_imag
           (gsl_vector_complex * V)
- -- Function: gsl_vector_const_view gsl_vector_complex_const_imag
-          (const gsl_vector_complex * V)
+ -- Function: gsl_vector_const_view gsl_vector_complex_const_imag (const
+          gsl_vector_complex * V)
      These functions return a vector view of the imaginary parts of the
      complex vector V.
 
-     The function `gsl_vector_complex_const_imag' is equivalent to
-     `gsl_vector_complex_imag' but can be used for vectors which are
-     declared `const'.
+     The function 'gsl_vector_complex_const_imag' is equivalent to
+     'gsl_vector_complex_imag' but can be used for vectors which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_vector_view_array (double * BASE,
           size_t N)
  -- Function: gsl_vector_const_view gsl_vector_const_view_array (const
           double * BASE, size_t N)
-     These functions return a vector view of an array.  The start of
-     the new vector is given by BASE and has N elements.
-     Mathematically, the I-th element of the new vector V' is given by,
+     These functions return a vector view of an array.  The start of the
+     new vector is given by BASE and has N elements.  Mathematically,
+     the I-th element of the new vector V' is given by,
 
           v'(i) = base[i]
 
-     where the index I runs from 0 to `n-1'.
+     where the index I runs from 0 to 'n-1'.
 
      The array containing the elements of V is not owned by the new
      vector view.  When the view goes out of scope the original array
      will continue to exist.  The original memory can only be
      deallocated by freeing the original pointer BASE.  Of course, the
-     original array should not be deallocated while the view is still
-     in use.
+     original array should not be deallocated while the view is still in
+     use.
 
-     The function `gsl_vector_const_view_array' is equivalent to
-     `gsl_vector_view_array' but can be used for arrays which are
-     declared `const'.
+     The function 'gsl_vector_const_view_array' is equivalent to
+     'gsl_vector_view_array' but can be used for arrays which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_vector_view_array_with_stride (double
           * BASE, size_t STRIDE, size_t N)
  -- Function: gsl_vector_const_view
-gsl_vector_const_view_array_with_stride (const double * BASE, size_t
-          STRIDE, size_t N)
+          gsl_vector_const_view_array_with_stride (const double * BASE,
+          size_t STRIDE, size_t N)
      These functions return a vector view of an array BASE with an
-     additional stride argument. The subvector is formed in the same
-     way as for `gsl_vector_view_array' but the new vector has N
-     elements with a step-size of STRIDE from one element to the next
-     in the original array.  Mathematically, the I-th element of the new
+     additional stride argument.  The subvector is formed in the same
+     way as for 'gsl_vector_view_array' but the new vector has N
+     elements with a step-size of STRIDE from one element to the next in
+     the original array.  Mathematically, the I-th element of the new
      vector V' is given by,
 
           v'(i) = base[i*stride]
 
-     where the index I runs from 0 to `n-1'.
+     where the index I runs from 0 to 'n-1'.
 
      Note that the view gives direct access to the underlying elements
      of the original array.  A vector view can be passed to any
      subroutine which takes a vector argument just as a directly
-     allocated vector would be, using `&'VIEW`.vector'.
+     allocated vector would be, using '&'VIEW'.vector'.
 
-     The function `gsl_vector_const_view_array_with_stride' is
-     equivalent to `gsl_vector_view_array_with_stride' but can be used
-     for arrays which are declared `const'.
+     The function 'gsl_vector_const_view_array_with_stride' is
+     equivalent to 'gsl_vector_view_array_with_stride' but can be used
+     for arrays which are declared 'const'.
 
 
 File: gsl-ref.info,  Node: Copying vectors,  Next: Exchanging elements,  Prev: Vector views,  Up: Vectors
@@ -5560,10 +5531,10 @@ However, it is useful to have a small number of utility functions which
 do not require the full BLAS code.  The following functions fall into
 this category.
 
- -- Function: int gsl_vector_memcpy (gsl_vector * DEST, const
-          gsl_vector * SRC)
-     This function copies the elements of the vector SRC into the
-     vector DEST.  The two vectors must have the same length.
+ -- Function: int gsl_vector_memcpy (gsl_vector * DEST, const gsl_vector
+          * SRC)
+     This function copies the elements of the vector SRC into the vector
+     DEST.  The two vectors must have the same length.
 
  -- Function: int gsl_vector_swap (gsl_vector * V, gsl_vector * W)
      This function exchanges the elements of the vectors V and W by
@@ -5596,22 +5567,22 @@ The following operations are only defined for real vectors.
 
  -- Function: int gsl_vector_add (gsl_vector * A, const gsl_vector * B)
      This function adds the elements of vector B to the elements of
-     vector A, a'_i = a_i + b_i. The two vectors must have the same
+     vector A, a'_i = a_i + b_i.  The two vectors must have the same
      length.
 
  -- Function: int gsl_vector_sub (gsl_vector * A, const gsl_vector * B)
      This function subtracts the elements of vector B from the elements
-     of vector A, a'_i = a_i - b_i. The two vectors must have the same
+     of vector A, a'_i = a_i - b_i.  The two vectors must have the same
      length.
 
  -- Function: int gsl_vector_mul (gsl_vector * A, const gsl_vector * B)
      This function multiplies the elements of vector A by the elements
-     of vector B, a'_i = a_i * b_i. The two vectors must have the same
+     of vector B, a'_i = a_i * b_i.  The two vectors must have the same
      length.
 
  -- Function: int gsl_vector_div (gsl_vector * A, const gsl_vector * B)
      This function divides the elements of vector A by the elements of
-     vector B, a'_i = a_i / b_i. The two vectors must have the same
+     vector B, a'_i = a_i / b_i.  The two vectors must have the same
      length.
 
  -- Function: int gsl_vector_scale (gsl_vector * A, const double X)
@@ -5650,12 +5621,12 @@ File: gsl-ref.info,  Node: Finding maximum and minimum elements of vectors,  Nex
      V.  When there are several equal minimum elements then the lowest
      index is returned.
 
- -- Function: void gsl_vector_minmax_index (const gsl_vector * V,
-          size_t * IMIN, size_t * IMAX)
-     This function returns the indices of the minimum and maximum
-     values in the vector V, storing them in IMIN and IMAX. When there
-     are several equal minimum or maximum elements then the lowest
-     indices are returned.
+ -- Function: void gsl_vector_minmax_index (const gsl_vector * V, size_t
+          * IMIN, size_t * IMAX)
+     This function returns the indices of the minimum and maximum values
+     in the vector V, storing them in IMIN and IMAX.  When there are
+     several equal minimum or maximum elements then the lowest indices
+     are returned.
 
 
 File: gsl-ref.info,  Node: Vector properties,  Next: Example programs for vectors,  Prev: Finding maximum and minimum elements of vectors,  Up: Vectors
@@ -5669,7 +5640,7 @@ File: gsl-ref.info,  Node: Vector properties,  Next: Example programs for vector
      These functions return 1 if all the elements of the vector V are
      zero, strictly positive, or strictly negative respectively, and 0
      otherwise.  To test for a non-negative vector, use the expression
-     `!gsl_vector_isneg(v)'.
+     '!gsl_vector_isneg(v)'.
 
 
 File: gsl-ref.info,  Node: Example programs for vectors,  Prev: Vector properties,  Up: Vectors
@@ -5678,8 +5649,8 @@ File: gsl-ref.info,  Node: Example programs for vectors,  Prev: Vector propertie
 -----------------------------------
 
 This program shows how to allocate, initialize and read from a vector
-using the functions `gsl_vector_alloc', `gsl_vector_set' and
-`gsl_vector_get'.
+using the functions 'gsl_vector_alloc', 'gsl_vector_set' and
+'gsl_vector_get'.
 
      #include <stdio.h>
      #include <gsl/gsl_vector.h>
@@ -5705,8 +5676,8 @@ using the functions `gsl_vector_alloc', `gsl_vector_set' and
      }
 
 Here is the output from the program.  The final loop attempts to read
-outside the range of the vector `v', and the error is trapped by the
-range-checking code in `gsl_vector_get'.
+outside the range of the vector 'v', and the error is trapped by the
+range-checking code in 'gsl_vector_get'.
 
      $ ./a.out
      v_0 = 1.23
@@ -5742,10 +5713,10 @@ The next program shows how to write a vector to a file.
        return 0;
      }
 
-After running this program the file `test.dat' should contain the
-elements of `v', written using the format specifier `%.5g'.  The vector
-could then be read back in using the function `gsl_vector_fscanf (f,
-v)' as follows:
+After running this program the file 'test.dat' should contain the
+elements of 'v', written using the format specifier '%.5g'.  The vector
+could then be read back in using the function 'gsl_vector_fscanf (f, v)'
+as follows:
 
      #include <stdio.h>
      #include <gsl/gsl_vector.h>
@@ -5777,16 +5748,16 @@ File: gsl-ref.info,  Node: Matrices,  Next: Vector and Matrix References and Fur
 8.4 Matrices
 ============
 
-Matrices are defined by a `gsl_matrix' structure which describes a
+Matrices are defined by a 'gsl_matrix' structure which describes a
 generalized slice of a block.  Like a vector it represents a set of
 elements in an area of memory, but uses two indices instead of one.
 
-   The `gsl_matrix' structure contains six components, the two
+   The 'gsl_matrix' structure contains six components, the two
 dimensions of the matrix, a physical dimension, a pointer to the memory
 where the elements of the matrix are stored, DATA, a pointer to the
 block owned by the matrix BLOCK, if any, and an ownership flag, OWNER.
 The physical dimension determines the memory layout and can differ from
-the matrix dimension to allow the use of submatrices.  The `gsl_matrix'
+the matrix dimension to allow the use of submatrices.  The 'gsl_matrix'
 structure is very simple and looks like this,
 
      typedef struct
@@ -5801,13 +5772,12 @@ structure is very simple and looks like this,
 
 Matrices are stored in row-major order, meaning that each row of
 elements forms a contiguous block in memory.  This is the standard
-"C-language ordering" of two-dimensional arrays. Note that FORTRAN
-stores arrays in column-major order. The number of rows is SIZE1.  The
-range of valid row indices runs from 0 to `size1-1'.  Similarly SIZE2
-is the number of columns.  The range of valid column indices runs from
-0 to `size2-1'.  The physical row dimension TDA, or "trailing
-dimension", specifies the size of a row of the matrix as laid out in
-memory.
+"C-language ordering" of two-dimensional arrays.  Note that FORTRAN
+stores arrays in column-major order.  The number of rows is SIZE1.  The
+range of valid row indices runs from 0 to 'size1-1'.  Similarly SIZE2 is
+the number of columns.  The range of valid column indices runs from 0 to
+'size2-1'.  The physical row dimension TDA, or "trailing dimension",
+specifies the size of a row of the matrix as laid out in memory.
 
    For example, in the following matrix SIZE1 is 3, SIZE2 is 4, and TDA
 is 8.  The physical memory layout of the matrix begins in the top left
@@ -5817,7 +5787,7 @@ hand-corner and proceeds from left to right along each row in turn.
      10 11 12 13 XX XX XX XX
      20 21 22 23 XX XX XX XX
 
-Each unused memory location is represented by "`XX'".  The pointer DATA
+Each unused memory location is represented by "'XX'".  The pointer DATA
 gives the location of the first element of the matrix in memory.  The
 pointer BLOCK stores the location of the memory block in which the
 elements of the matrix are located (if any).  If the matrix owns this
@@ -5827,23 +5797,23 @@ a block owned by another object then the OWNER field is zero and any
 underlying block will not be freed.
 
    The functions for allocating and accessing matrices are defined in
-`gsl_matrix.h'
+'gsl_matrix.h'
 
 * Menu:
 
-* Matrix allocation::
-* Accessing matrix elements::
-* Initializing matrix elements::
-* Reading and writing matrices::
-* Matrix views::
-* Creating row and column views::
-* Copying matrices::
-* Copying rows and columns::
-* Exchanging rows and columns::
-* Matrix operations::
-* Finding maximum and minimum elements of matrices::
-* Matrix properties::
-* Example programs for matrices::
+* Matrix allocation::           
+* Accessing matrix elements::   
+* Initializing matrix elements::  
+* Reading and writing matrices::  
+* Matrix views::                
+* Creating row and column views::  
+* Copying matrices::            
+* Copying rows and columns::    
+* Exchanging rows and columns::  
+* Matrix operations::           
+* Finding maximum and minimum elements of matrices::  
+* Matrix properties::           
+* Example programs for matrices::  
 
 
 File: gsl-ref.info,  Node: Matrix allocation,  Next: Accessing matrix elements,  Up: Matrices
@@ -5852,16 +5822,16 @@ File: gsl-ref.info,  Node: Matrix allocation,  Next: Accessing matrix elements,
 -----------------------
 
 The functions for allocating memory to a matrix follow the style of
-`malloc' and `free'.  They also perform their own error checking.  If
+'malloc' and 'free'.  They also perform their own error checking.  If
 there is insufficient memory available to allocate a vector then the
 functions call the GSL error handler (with an error number of
-`GSL_ENOMEM') in addition to returning a null pointer.  Thus if you use
+'GSL_ENOMEM') in addition to returning a null pointer.  Thus if you use
 the library error handler to abort your program then it isn't necessary
-to check every `alloc'.
+to check every 'alloc'.
 
  -- Function: gsl_matrix * gsl_matrix_alloc (size_t N1, size_t N2)
      This function creates a matrix of size N1 rows by N2 columns,
-     returning a pointer to a newly initialized matrix struct. A new
+     returning a pointer to a newly initialized matrix struct.  A new
      block is allocated for the elements of the matrix, and stored in
      the BLOCK component of the matrix struct.  The block is "owned" by
      the matrix, and will be deallocated when the matrix is deallocated.
@@ -5871,12 +5841,12 @@ to check every `alloc'.
      columns and initializes all the elements of the matrix to zero.
 
  -- Function: void gsl_matrix_free (gsl_matrix * M)
-     This function frees a previously allocated matrix M.  If the
-     matrix was created using `gsl_matrix_alloc' then the block
-     underlying the matrix will also be deallocated.  If the matrix has
-     been created from another object then the memory is still owned by
-     that object and will not be deallocated.  The matrix M must be a
-     valid matrix object (a null pointer is not allowed).
+     This function frees a previously allocated matrix M.  If the matrix
+     was created using 'gsl_matrix_alloc' then the block underlying the
+     matrix will also be deallocated.  If the matrix has been created
+     from another object then the memory is still owned by that object
+     and will not be deallocated.  The matrix M must be a valid matrix
+     object (a null pointer is not allowed).
 
 
 File: gsl-ref.info,  Node: Accessing matrix elements,  Next: Initializing matrix elements,  Prev: Matrix allocation,  Up: Matrices
@@ -5887,12 +5857,12 @@ File: gsl-ref.info,  Node: Accessing matrix elements,  Next: Initializing matrix
 The functions for accessing the elements of a matrix use the same range
 checking system as vectors.  You can turn off range checking by
 recompiling your program with the preprocessor definition
-`GSL_RANGE_CHECK_OFF'.
+'GSL_RANGE_CHECK_OFF'.
 
    The elements of the matrix are stored in "C-order", where the second
 index moves continuously through memory.  More precisely, the element
-accessed by the function `gsl_matrix_get(m,i,j)' and
-`gsl_matrix_set(m,i,j,x)' is
+accessed by the function 'gsl_matrix_get(m,i,j)' and
+'gsl_matrix_set(m,i,j,x)' is
 
      m->data[i * m->tda + j]
 
@@ -5901,8 +5871,8 @@ where TDA is the physical row-length of the matrix.
  -- Function: double gsl_matrix_get (const gsl_matrix * M, size_t I,
           size_t J)
      This function returns the (i,j)-th element of a matrix M.  If I or
-     J lie outside the allowed range of 0 to N1-1 and 0 to N2-1 then
-     the error handler is invoked and 0 is returned.
+     J lie outside the allowed range of 0 to N1-1 and 0 to N2-1 then the
+     error handler is invoked and 0 is returned.
 
  -- Function: void gsl_matrix_set (gsl_matrix * M, size_t I, size_t J,
           double X)
@@ -5912,12 +5882,12 @@ where TDA is the physical row-length of the matrix.
 
  -- Function: double * gsl_matrix_ptr (gsl_matrix * M, size_t I, size_t
           J)
- -- Function: const double * gsl_matrix_const_ptr (const gsl_matrix *
-          M, size_t I, size_t J)
+ -- Function: const double * gsl_matrix_const_ptr (const gsl_matrix * M,
+          size_t I, size_t J)
      These functions return a pointer to the (i,j)-th element of a
-     matrix M.  If I or J lie outside the allowed range of 0 to N1-1
-     and 0 to N2-1 then the error handler is invoked and a null pointer
-     is returned.
+     matrix M.  If I or J lie outside the allowed range of 0 to N1-1 and
+     0 to N2-1 then the error handler is invoked and a null pointer is
+     returned.
 
 
 File: gsl-ref.info,  Node: Initializing matrix elements,  Next: Reading and writing matrices,  Prev: Accessing matrix elements,  Up: Matrices
@@ -5934,7 +5904,7 @@ File: gsl-ref.info,  Node: Initializing matrix elements,  Next: Reading and writ
  -- Function: void gsl_matrix_set_identity (gsl_matrix * M)
      This function sets the elements of the matrix M to the
      corresponding elements of the identity matrix, m(i,j) =
-     \delta(i,j), i.e. a unit diagonal with all off-diagonal elements
+     \delta(i,j), i.e.  a unit diagonal with all off-diagonal elements
      zero.  This applies to both square and rectangular matrices.
 
 
@@ -5950,7 +5920,7 @@ file as binary data or formatted text.
           M)
      This function writes the elements of the matrix M to the stream
      STREAM in binary format.  The return value is 0 for success and
-     `GSL_EFAILED' if there was a problem writing to the file.  Since
+     'GSL_EFAILED' if there was a problem writing to the file.  Since
      the data is written in the native binary format it may not be
      portable between different architectures.
 
@@ -5959,7 +5929,7 @@ file as binary data or formatted text.
      in binary format.  The matrix M must be preallocated with the
      correct dimensions since the function uses the size of M to
      determine how many bytes to read.  The return value is 0 for
-     success and `GSL_EFAILED' if there was a problem reading from the
+     success and 'GSL_EFAILED' if there was a problem reading from the
      file.  The data is assumed to have been written in the native
      binary format on the same architecture.
 
@@ -5967,16 +5937,16 @@ file as binary data or formatted text.
           M, const char * FORMAT)
      This function writes the elements of the matrix M line-by-line to
      the stream STREAM using the format specifier FORMAT, which should
-     be one of the `%g', `%e' or `%f' formats for floating point
-     numbers and `%d' for integers.  The function returns 0 for success
-     and `GSL_EFAILED' if there was a problem writing to the file.
+     be one of the '%g', '%e' or '%f' formats for floating point numbers
+     and '%d' for integers.  The function returns 0 for success and
+     'GSL_EFAILED' if there was a problem writing to the file.
 
  -- Function: int gsl_matrix_fscanf (FILE * STREAM, gsl_matrix * M)
      This function reads formatted data from the stream STREAM into the
      matrix M.  The matrix M must be preallocated with the correct
      dimensions since the function uses the size of M to determine how
      many numbers to read.  The function returns 0 for success and
-     `GSL_EFAILED' if there was a problem reading from the file.
+     'GSL_EFAILED' if there was a problem reading from the file.
 
 
 File: gsl-ref.info,  Node: Matrix views,  Next: Creating row and column views,  Prev: Reading and writing matrices,  Up: Matrices
@@ -5987,13 +5957,13 @@ File: gsl-ref.info,  Node: Matrix views,  Next: Creating row and column views,
 A matrix view is a temporary object, stored on the stack, which can be
 used to operate on a subset of matrix elements.  Matrix views can be
 defined for both constant and non-constant matrices using separate types
-that preserve constness.  A matrix view has the type `gsl_matrix_view'
-and a constant matrix view has the type `gsl_matrix_const_view'.  In
-both cases the elements of the view can by accessed using the `matrix'
-component of the view object.  A pointer `gsl_matrix *' or `const
-gsl_matrix *' can be obtained by taking the address of the `matrix'
-component with the `&' operator.  In addition to matrix views it is
-also possible to create vector views of a matrix, such as row or column
+that preserve constness.  A matrix view has the type 'gsl_matrix_view'
+and a constant matrix view has the type 'gsl_matrix_const_view'.  In
+both cases the elements of the view can by accessed using the 'matrix'
+component of the view object.  A pointer 'gsl_matrix *' or 'const
+gsl_matrix *' can be obtained by taking the address of the 'matrix'
+component with the '&' operator.  In addition to matrix views it is also
+possible to create vector views of a matrix, such as row or column
 views.
 
  -- Function: gsl_matrix_view gsl_matrix_submatrix (gsl_matrix * M,
@@ -6003,16 +5973,15 @@ views.
      These functions return a matrix view of a submatrix of the matrix
      M.  The upper-left element of the submatrix is the element (K1,K2)
      of the original matrix.  The submatrix has N1 rows and N2 columns.
-     The physical number of columns in memory given by TDA is
-     unchanged.  Mathematically, the (i,j)-th element of the new matrix
-     is given by,
+     The physical number of columns in memory given by TDA is unchanged.
+     Mathematically, the (i,j)-th element of the new matrix is given by,
 
           m'(i,j) = m->data[(k1*m->tda + k2) + i*m->tda + j]
 
-     where the index I runs from 0 to `n1-1' and the index J runs from
-     0 to `n2-1'.
+     where the index I runs from 0 to 'n1-1' and the index J runs from 0
+     to 'n2-1'.
 
-     The `data' pointer of the returned matrix struct is set to null if
+     The 'data' pointer of the returned matrix struct is set to null if
      the combined parameters (I,J,N1,N2,TDA) overrun the ends of the
      original matrix.
 
@@ -6024,23 +5993,23 @@ views.
      matrix.  Of course, the original matrix should not be deallocated
      while the view is still in use.
 
-     The function `gsl_matrix_const_submatrix' is equivalent to
-     `gsl_matrix_submatrix' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_submatrix' is equivalent to
+     'gsl_matrix_submatrix' but can be used for matrices which are
+     declared 'const'.
 
  -- Function: gsl_matrix_view gsl_matrix_view_array (double * BASE,
           size_t N1, size_t N2)
  -- Function: gsl_matrix_const_view gsl_matrix_const_view_array (const
           double * BASE, size_t N1, size_t N2)
-     These functions return a matrix view of the array BASE.  The
-     matrix has N1 rows and N2 columns.  The physical number of columns
-     in memory is also given by N2.  Mathematically, the (i,j)-th
-     element of the new matrix is given by,
+     These functions return a matrix view of the array BASE.  The matrix
+     has N1 rows and N2 columns.  The physical number of columns in
+     memory is also given by N2.  Mathematically, the (i,j)-th element
+     of the new matrix is given by,
 
           m'(i,j) = base[i*n2 + j]
 
-     where the index I runs from 0 to `n1-1' and the index J runs from
-     0 to `n2-1'.
+     where the index I runs from 0 to 'n1-1' and the index J runs from 0
+     to 'n2-1'.
 
      The new matrix is only a view of the array BASE.  When the view
      goes out of scope the original array BASE will continue to exist.
@@ -6048,15 +6017,14 @@ views.
      array.  Of course, the original array should not be deallocated
      while the view is still in use.
 
-     The function `gsl_matrix_const_view_array' is equivalent to
-     `gsl_matrix_view_array' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_view_array' is equivalent to
+     'gsl_matrix_view_array' but can be used for matrices which are
+     declared 'const'.
 
  -- Function: gsl_matrix_view gsl_matrix_view_array_with_tda (double *
           BASE, size_t N1, size_t N2, size_t TDA)
- -- Function: gsl_matrix_const_view
-          gsl_matrix_const_view_array_with_tda (const double * BASE,
-          size_t N1, size_t N2, size_t TDA)
+ -- Function: gsl_matrix_const_view gsl_matrix_const_view_array_with_tda
+          (const double * BASE, size_t N1, size_t N2, size_t TDA)
      These functions return a matrix view of the array BASE with a
      physical number of columns TDA which may differ from the
      corresponding dimension of the matrix.  The matrix has N1 rows and
@@ -6066,8 +6034,8 @@ views.
 
           m'(i,j) = base[i*tda + j]
 
-     where the index I runs from 0 to `n1-1' and the index J runs from
-     0 to `n2-1'.
+     where the index I runs from 0 to 'n1-1' and the index J runs from 0
+     to 'n2-1'.
 
      The new matrix is only a view of the array BASE.  When the view
      goes out of scope the original array BASE will continue to exist.
@@ -6075,23 +6043,23 @@ views.
      array.  Of course, the original array should not be deallocated
      while the view is still in use.
 
-     The function `gsl_matrix_const_view_array_with_tda' is equivalent
-     to `gsl_matrix_view_array_with_tda' but can be used for matrices
-     which are declared `const'.
+     The function 'gsl_matrix_const_view_array_with_tda' is equivalent
+     to 'gsl_matrix_view_array_with_tda' but can be used for matrices
+     which are declared 'const'.
 
  -- Function: gsl_matrix_view gsl_matrix_view_vector (gsl_vector * V,
           size_t N1, size_t N2)
  -- Function: gsl_matrix_const_view gsl_matrix_const_view_vector (const
           gsl_vector * V, size_t N1, size_t N2)
      These functions return a matrix view of the vector V.  The matrix
-     has N1 rows and N2 columns. The vector must have unit stride. The
+     has N1 rows and N2 columns.  The vector must have unit stride.  The
      physical number of columns in memory is also given by N2.
      Mathematically, the (i,j)-th element of the new matrix is given by,
 
           m'(i,j) = v->data[i*n2 + j]
 
-     where the index I runs from 0 to `n1-1' and the index J runs from
-     0 to `n2-1'.
+     where the index I runs from 0 to 'n1-1' and the index J runs from 0
+     to 'n2-1'.
 
      The new matrix is only a view of the vector V.  When the view goes
      out of scope the original vector V will continue to exist.  The
@@ -6099,15 +6067,15 @@ views.
      vector.  Of course, the original vector should not be deallocated
      while the view is still in use.
 
-     The function `gsl_matrix_const_view_vector' is equivalent to
-     `gsl_matrix_view_vector' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_view_vector' is equivalent to
+     'gsl_matrix_view_vector' but can be used for matrices which are
+     declared 'const'.
 
  -- Function: gsl_matrix_view gsl_matrix_view_vector_with_tda
           (gsl_vector * V, size_t N1, size_t N2, size_t TDA)
  -- Function: gsl_matrix_const_view
-gsl_matrix_const_view_vector_with_tda (const gsl_vector * V, size_t N1,
-          size_t N2, size_t TDA)
+          gsl_matrix_const_view_vector_with_tda (const gsl_vector * V,
+          size_t N1, size_t N2, size_t TDA)
      These functions return a matrix view of the vector V with a
      physical number of columns TDA which may differ from the
      corresponding matrix dimension.  The vector must have unit stride.
@@ -6117,8 +6085,8 @@ gsl_matrix_const_view_vector_with_tda (const gsl_vector * V, size_t N1,
 
           m'(i,j) = v->data[i*tda + j]
 
-     where the index I runs from 0 to `n1-1' and the index J runs from
-     0 to `n2-1'.
+     where the index I runs from 0 to 'n1-1' and the index J runs from 0
+     to 'n2-1'.
 
      The new matrix is only a view of the vector V.  When the view goes
      out of scope the original vector V will continue to exist.  The
@@ -6126,9 +6094,9 @@ gsl_matrix_const_view_vector_with_tda (const gsl_vector * V, size_t N1,
      vector.  Of course, the original vector should not be deallocated
      while the view is still in use.
 
-     The function `gsl_matrix_const_view_vector_with_tda' is equivalent
-     to `gsl_matrix_view_vector_with_tda' but can be used for matrices
-     which are declared `const'.
+     The function 'gsl_matrix_const_view_vector_with_tda' is equivalent
+     to 'gsl_matrix_view_vector_with_tda' but can be used for matrices
+     which are declared 'const'.
 
 
 File: gsl-ref.info,  Node: Creating row and column views,  Next: Copying matrices,  Prev: Matrix views,  Up: Matrices
@@ -6147,60 +6115,60 @@ block.
  -- Function: gsl_vector_const_view gsl_matrix_const_row (const
           gsl_matrix * M, size_t I)
      These functions return a vector view of the I-th row of the matrix
-     M.  The `data' pointer of the new vector is set to null if I is
-     out of range.
+     M.  The 'data' pointer of the new vector is set to null if I is out
+     of range.
 
-     The function `gsl_vector_const_row' is equivalent to
-     `gsl_matrix_row' but can be used for matrices which are declared
-     `const'.
+     The function 'gsl_vector_const_row' is equivalent to
+     'gsl_matrix_row' but can be used for matrices which are declared
+     'const'.
 
  -- Function: gsl_vector_view gsl_matrix_column (gsl_matrix * M, size_t
           J)
  -- Function: gsl_vector_const_view gsl_matrix_const_column (const
           gsl_matrix * M, size_t J)
      These functions return a vector view of the J-th column of the
-     matrix M.  The `data' pointer of the new vector is set to null if
-     J is out of range.
+     matrix M.  The 'data' pointer of the new vector is set to null if J
+     is out of range.
 
-     The function `gsl_vector_const_column' is equivalent to
-     `gsl_matrix_column' but can be used for matrices which are declared
-     `const'.
+     The function 'gsl_vector_const_column' is equivalent to
+     'gsl_matrix_column' but can be used for matrices which are declared
+     'const'.
 
  -- Function: gsl_vector_view gsl_matrix_diagonal (gsl_matrix * M)
  -- Function: gsl_vector_const_view gsl_matrix_const_diagonal (const
           gsl_matrix * M)
      These functions returns a vector view of the diagonal of the matrix
-     M. The matrix M is not required to be square. For a rectangular
+     M.  The matrix M is not required to be square.  For a rectangular
      matrix the length of the diagonal is the same as the smaller
      dimension of the matrix.
 
-     The function `gsl_matrix_const_diagonal' is equivalent to
-     `gsl_matrix_diagonal' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_diagonal' is equivalent to
+     'gsl_matrix_diagonal' but can be used for matrices which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_matrix_subdiagonal (gsl_matrix * M,
           size_t K)
  -- Function: gsl_vector_const_view gsl_matrix_const_subdiagonal (const
           gsl_matrix * M, size_t K)
-     These functions return a vector view of the K-th subdiagonal of
-     the matrix M. The matrix M is not required to be square.  The
-     diagonal of the matrix corresponds to k = 0.
+     These functions return a vector view of the K-th subdiagonal of the
+     matrix M.  The matrix M is not required to be square.  The diagonal
+     of the matrix corresponds to k = 0.
 
-     The function `gsl_matrix_const_subdiagonal' is equivalent to
-     `gsl_matrix_subdiagonal' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_subdiagonal' is equivalent to
+     'gsl_matrix_subdiagonal' but can be used for matrices which are
+     declared 'const'.
 
  -- Function: gsl_vector_view gsl_matrix_superdiagonal (gsl_matrix * M,
           size_t K)
  -- Function: gsl_vector_const_view gsl_matrix_const_superdiagonal
           (const gsl_matrix * M, size_t K)
      These functions return a vector view of the K-th superdiagonal of
-     the matrix M. The matrix M is not required to be square. The
+     the matrix M.  The matrix M is not required to be square.  The
      diagonal of the matrix corresponds to k = 0.
 
-     The function `gsl_matrix_const_superdiagonal' is equivalent to
-     `gsl_matrix_superdiagonal' but can be used for matrices which are
-     declared `const'.
+     The function 'gsl_matrix_const_superdiagonal' is equivalent to
+     'gsl_matrix_superdiagonal' but can be used for matrices which are
+     declared 'const'.
 
 
 File: gsl-ref.info,  Node: Copying matrices,  Next: Copying rows and columns,  Prev: Creating row and column views,  Up: Matrices
@@ -6208,10 +6176,10 @@ File: gsl-ref.info,  Node: Copying matrices,  Next: Copying rows and columns,  P
 8.4.7 Copying matrices
 ----------------------
 
- -- Function: int gsl_matrix_memcpy (gsl_matrix * DEST, const
-          gsl_matrix * SRC)
-     This function copies the elements of the matrix SRC into the
-     matrix DEST.  The two matrices must have the same size.
+ -- Function: int gsl_matrix_memcpy (gsl_matrix * DEST, const gsl_matrix
+          * SRC)
+     This function copies the elements of the matrix SRC into the matrix
+     DEST.  The two matrices must have the same size.
 
  -- Function: int gsl_matrix_swap (gsl_matrix * M1, gsl_matrix * M2)
      This function exchanges the elements of the matrices M1 and M2 by
@@ -6228,25 +6196,25 @@ into a vector.  This allows the elements of the vector and the matrix to
 be modified independently.  Note that if the matrix and the vector point
 to overlapping regions of memory then the result will be undefined.  The
 same effect can be achieved with more generality using
-`gsl_vector_memcpy' with vector views of rows and columns.
+'gsl_vector_memcpy' with vector views of rows and columns.
 
- -- Function: int gsl_matrix_get_row (gsl_vector * V, const gsl_matrix
-          * M, size_t I)
+ -- Function: int gsl_matrix_get_row (gsl_vector * V, const gsl_matrix *
+          M, size_t I)
      This function copies the elements of the I-th row of the matrix M
      into the vector V.  The length of the vector must be the same as
      the length of the row.
 
- -- Function: int gsl_matrix_get_col (gsl_vector * V, const gsl_matrix
-          * M, size_t J)
+ -- Function: int gsl_matrix_get_col (gsl_vector * V, const gsl_matrix *
+          M, size_t J)
      This function copies the elements of the J-th column of the matrix
      M into the vector V.  The length of the vector must be the same as
      the length of the column.
 
  -- Function: int gsl_matrix_set_row (gsl_matrix * M, size_t I, const
           gsl_vector * V)
-     This function copies the elements of the vector V into the I-th
-     row of the matrix M.  The length of the vector must be the same as
-     the length of the row.
+     This function copies the elements of the vector V into the I-th row
+     of the matrix M.  The length of the vector must be the same as the
+     length of the row.
 
  -- Function: int gsl_matrix_set_col (gsl_matrix * M, size_t J, const
           gsl_vector * V)
@@ -6263,8 +6231,8 @@ File: gsl-ref.info,  Node: Exchanging rows and columns,  Next: Matrix operations
 The following functions can be used to exchange the rows and columns of
 a matrix.
 
- -- Function: int gsl_matrix_swap_rows (gsl_matrix * M, size_t I,
-          size_t J)
+ -- Function: int gsl_matrix_swap_rows (gsl_matrix * M, size_t I, size_t
+          J)
      This function exchanges the I-th and J-th rows of the matrix M
      in-place.
 
@@ -6281,15 +6249,15 @@ a matrix.
 
  -- Function: int gsl_matrix_transpose_memcpy (gsl_matrix * DEST, const
           gsl_matrix * SRC)
-     This function makes the matrix DEST the transpose of the matrix
-     SRC by copying the elements of SRC into DEST.  This function works
-     for all matrices provided that the dimensions of the matrix DEST
-     match the transposed dimensions of the matrix SRC.
+     This function makes the matrix DEST the transpose of the matrix SRC
+     by copying the elements of SRC into DEST.  This function works for
+     all matrices provided that the dimensions of the matrix DEST match
+     the transposed dimensions of the matrix SRC.
 
  -- Function: int gsl_matrix_transpose (gsl_matrix * M)
-     This function replaces the matrix M by its transpose by copying
-     the elements of the matrix in-place.  The matrix must be square
-     for this operation to be possible.
+     This function replaces the matrix M by its transpose by copying the
+     elements of the matrix in-place.  The matrix must be square for
+     this operation to be possible.
 
 
 File: gsl-ref.info,  Node: Matrix operations,  Next: Finding maximum and minimum elements of matrices,  Prev: Exchanging rows and columns,  Up: Matrices
@@ -6301,25 +6269,25 @@ The following operations are defined for real and complex matrices.
 
  -- Function: int gsl_matrix_add (gsl_matrix * A, const gsl_matrix * B)
      This function adds the elements of matrix B to the elements of
-     matrix A, a'(i,j) = a(i,j) + b(i,j). The two matrices must have the
-     same dimensions.
+     matrix A, a'(i,j) = a(i,j) + b(i,j).  The two matrices must have
+     the same dimensions.
 
  -- Function: int gsl_matrix_sub (gsl_matrix * A, const gsl_matrix * B)
      This function subtracts the elements of matrix B from the elements
-     of matrix A, a'(i,j) = a(i,j) - b(i,j). The two matrices must have
+     of matrix A, a'(i,j) = a(i,j) - b(i,j).  The two matrices must have
      the same dimensions.
 
  -- Function: int gsl_matrix_mul_elements (gsl_matrix * A, const
           gsl_matrix * B)
      This function multiplies the elements of matrix A by the elements
-     of matrix B, a'(i,j) = a(i,j) * b(i,j). The two matrices must have
+     of matrix B, a'(i,j) = a(i,j) * b(i,j).  The two matrices must have
      the same dimensions.
 
  -- Function: int gsl_matrix_div_elements (gsl_matrix * A, const
           gsl_matrix * B)
      This function divides the elements of matrix A by the elements of
-     matrix B, a'(i,j) = a(i,j) / b(i,j). The two matrices must have the
-     same dimensions.
+     matrix B, a'(i,j) = a(i,j) / b(i,j).  The two matrices must have
+     the same dimensions.
 
  -- Function: int gsl_matrix_scale (gsl_matrix * A, const double X)
      This function multiplies the elements of matrix A by the constant
@@ -6363,13 +6331,12 @@ The following operations are only defined for real matrices.
      equal minimum elements then the first element found is returned,
      searching in row-major order.
 
- -- Function: void gsl_matrix_minmax_index (const gsl_matrix * M,
-          size_t * IMIN, size_t * JMIN, size_t * IMAX, size_t * JMAX)
-     This function returns the indices of the minimum and maximum
-     values in the matrix M, storing them in (IMIN,JMIN) and
-     (IMAX,JMAX). When there are several equal minimum or maximum
-     elements then the first elements found are returned, searching in
-     row-major order.
+ -- Function: void gsl_matrix_minmax_index (const gsl_matrix * M, size_t
+          * IMIN, size_t * JMIN, size_t * IMAX, size_t * JMAX)
+     This function returns the indices of the minimum and maximum values
+     in the matrix M, storing them in (IMIN,JMIN) and (IMAX,JMAX).  When
+     there are several equal minimum or maximum elements then the first
+     elements found are returned, searching in row-major order.
 
 
 File: gsl-ref.info,  Node: Matrix properties,  Next: Example programs for matrices,  Prev: Finding maximum and minimum elements of matrices,  Up: Matrices
@@ -6382,8 +6349,8 @@ File: gsl-ref.info,  Node: Matrix properties,  Next: Example programs for matric
  -- Function: int gsl_matrix_isneg (const gsl_matrix * M)
      These functions return 1 if all the elements of the matrix M are
      zero, strictly positive, or strictly negative respectively, and 0
-     otherwise. To test for a non-negative matrix, use the expression
-     `!gsl_matrix_isneg(m)'.  To test whether a matrix is
+     otherwise.  To test for a non-negative matrix, use the expression
+     '!gsl_matrix_isneg(m)'.  To test whether a matrix is
      positive-definite, use the Cholesky decomposition (*note Cholesky
      Decomposition::).
 
@@ -6394,8 +6361,8 @@ File: gsl-ref.info,  Node: Example programs for matrices,  Prev: Matrix properti
 ------------------------------------
 
 The program below shows how to allocate, initialize and read from a
-matrix using the functions `gsl_matrix_alloc', `gsl_matrix_set' and
-`gsl_matrix_get'.
+matrix using the functions 'gsl_matrix_alloc', 'gsl_matrix_set' and
+'gsl_matrix_get'.
 
      #include <stdio.h>
      #include <gsl/gsl_matrix.h>
@@ -6421,8 +6388,8 @@ matrix using the functions `gsl_matrix_alloc', `gsl_matrix_set' and
      }
 
 Here is the output from the program.  The final loop attempts to read
-outside the range of the matrix `m', and the error is trapped by the
-range-checking code in `gsl_matrix_get'.
+outside the range of the matrix 'm', and the error is trapped by the
+range-checking code in 'gsl_matrix_get'.
 
      $ ./a.out
      m(0,0) = 0.23
@@ -6480,10 +6447,10 @@ The next program shows how to write a matrix to a file.
        return (k > 0);
      }
 
-After running this program the file `test.dat' should contain the
-elements of `m', written in binary format.  The matrix which is read
-back in using the function `gsl_matrix_fread' should be exactly equal
-to the original matrix.
+After running this program the file 'test.dat' should contain the
+elements of 'm', written in binary format.  The matrix which is read
+back in using the function 'gsl_matrix_fread' should be exactly equal to
+the original matrix.
 
    The following program demonstrates the use of vector views.  The
 program computes the column norms of a matrix.
@@ -6550,11 +6517,11 @@ File: gsl-ref.info,  Node: Vector and Matrix References and Further Reading,  Pr
 8.5 References and Further Reading
 ==================================
 
-The block, vector and matrix objects in GSL follow the `valarray' model
+The block, vector and matrix objects in GSL follow the 'valarray' model
 of C++.  A description of this model can be found in the following
 reference,
 
-     B. Stroustrup, `The C++ Programming Language' (3rd Ed), Section
+     B. Stroustrup, 'The C++ Programming Language' (3rd Ed), Section
      22.4 Vector Arithmetic.  Addison-Wesley 1997, ISBN 0-201-88954-4.
 
 
@@ -6564,7 +6531,7 @@ File: gsl-ref.info,  Node: Permutations,  Next: Combinations,  Prev: Vectors and
 **************
 
 This chapter describes functions for creating and manipulating
-permutations. A permutation p is represented by an array of n integers
+permutations.  A permutation p is represented by an array of n integers
 in the range 0 to n-1, where each value p_i occurs once and only once.
 The application of a permutation p to a vector v yields a new vector v'
 where v'_i = v_{p_i}.  For example, the array (0,1,3,2) represents a
@@ -6577,20 +6544,20 @@ considered as applying to row-vectors in the form v' = v P rather than
 column-vectors, when permuting the elements of a vector.
 
    The functions described in this chapter are defined in the header
-file `gsl_permutation.h'.
+file 'gsl_permutation.h'.
 
 * Menu:
 
-* The Permutation struct::
-* Permutation allocation::
-* Accessing permutation elements::
-* Permutation properties::
-* Permutation functions::
-* Applying Permutations::
-* Reading and writing permutations::
-* Permutations in cyclic form::
-* Permutation Examples::
-* Permutation References and Further Reading::
+* The Permutation struct::      
+* Permutation allocation::      
+* Accessing permutation elements::  
+* Permutation properties::      
+* Permutation functions::       
+* Applying Permutations::       
+* Reading and writing permutations::  
+* Permutations in cyclic form::  
+* Permutation Examples::        
+* Permutation References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: The Permutation struct,  Next: Permutation allocation,  Up: Permutations
@@ -6600,8 +6567,8 @@ File: gsl-ref.info,  Node: The Permutation struct,  Next: Permutation allocation
 
 A permutation is defined by a structure containing two components, the
 size of the permutation and a pointer to the permutation array.  The
-elements of the permutation array are all of type `size_t'.  The
-`gsl_permutation' structure looks like this,
+elements of the permutation array are all of type 'size_t'.  The
+'gsl_permutation' structure looks like this,
 
      typedef struct
      {
@@ -6609,7 +6576,6 @@ elements of the permutation array are all of type `size_t'.  The
        size_t * data;
      } gsl_permutation;
 
-
 
 File: gsl-ref.info,  Node: Permutation allocation,  Next: Accessing permutation elements,  Prev: The Permutation struct,  Up: Permutations
 
@@ -6619,14 +6585,14 @@ File: gsl-ref.info,  Node: Permutation allocation,  Next: Accessing permutation
  -- Function: gsl_permutation * gsl_permutation_alloc (size_t N)
      This function allocates memory for a new permutation of size N.
      The permutation is not initialized and its elements are undefined.
-     Use the function `gsl_permutation_calloc' if you want to create a
-     permutation which is initialized to the identity. A null pointer is
-     returned if insufficient memory is available to create the
+     Use the function 'gsl_permutation_calloc' if you want to create a
+     permutation which is initialized to the identity.  A null pointer
+     is returned if insufficient memory is available to create the
      permutation.
 
  -- Function: gsl_permutation * gsl_permutation_calloc (size_t N)
      This function allocates memory for a new permutation of size N and
-     initializes it to the identity. A null pointer is returned if
+     initializes it to the identity.  A null pointer is returned if
      insufficient memory is available to create the permutation.
 
  -- Function: void gsl_permutation_init (gsl_permutation * P)
@@ -6694,9 +6660,9 @@ File: gsl-ref.info,  Node: Permutation functions,  Next: Applying Permutations,
      the result in INV.
 
  -- Function: int gsl_permutation_next (gsl_permutation * P)
-     This function advances the permutation P to the next permutation
-     in lexicographic order and returns `GSL_SUCCESS'.  If no further
-     permutations are available it returns `GSL_FAILURE' and leaves P
+     This function advances the permutation P to the next permutation in
+     lexicographic order and returns 'GSL_SUCCESS'.  If no further
+     permutations are available it returns 'GSL_FAILURE' and leaves P
      unmodified.  Starting with the identity permutation and repeatedly
      applying this function will iterate through all possible
      permutations of a given order.
@@ -6704,8 +6670,8 @@ File: gsl-ref.info,  Node: Permutation functions,  Next: Applying Permutations,
  -- Function: int gsl_permutation_prev (gsl_permutation * P)
      This function steps backwards from the permutation P to the
      previous permutation in lexicographic order, returning
-     `GSL_SUCCESS'.  If no previous permutation is available it returns
-     `GSL_FAILURE' and leaves P unmodified.
+     'GSL_SUCCESS'.  If no previous permutation is available it returns
+     'GSL_FAILURE' and leaves P unmodified.
 
 
 File: gsl-ref.info,  Node: Applying Permutations,  Next: Reading and writing permutations,  Prev: Permutation functions,  Up: Permutations
@@ -6715,13 +6681,13 @@ File: gsl-ref.info,  Node: Applying Permutations,  Next: Reading and writing per
 
  -- Function: int gsl_permute (const size_t * P, double * DATA, size_t
           STRIDE, size_t N)
-     This function applies the permutation P to the array DATA of size
-     N with stride STRIDE.
+     This function applies the permutation P to the array DATA of size N
+     with stride STRIDE.
 
  -- Function: int gsl_permute_inverse (const size_t * P, double * DATA,
           size_t STRIDE, size_t N)
-     This function applies the inverse of the permutation P to the
-     array DATA of size N with stride STRIDE.
+     This function applies the inverse of the permutation P to the array
+     DATA of size N with stride STRIDE.
 
  -- Function: int gsl_permute_vector (const gsl_permutation * P,
           gsl_vector * V)
@@ -6729,24 +6695,24 @@ File: gsl-ref.info,  Node: Applying Permutations,  Next: Reading and writing per
      vector V, considered as a row-vector acted on by a permutation
      matrix from the right, v' = v P.  The j-th column of the
      permutation matrix P is given by the p_j-th column of the identity
-     matrix. The permutation P and the vector V must have the same
+     matrix.  The permutation P and the vector V must have the same
      length.
 
- -- Function: int gsl_permute_vector_inverse (const gsl_permutation *
-          P, gsl_vector * V)
+ -- Function: int gsl_permute_vector_inverse (const gsl_permutation * P,
+          gsl_vector * V)
      This function applies the inverse of the permutation P to the
-     elements of the vector V, considered as a row-vector acted on by
-     an inverse permutation matrix from the right, v' = v P^T.  Note
-     that for permutation matrices the inverse is the same as the
-     transpose.  The j-th column of the permutation matrix P is given by
-     the p_j-th column of the identity matrix. The permutation P and
-     the vector V must have the same length.
+     elements of the vector V, considered as a row-vector acted on by an
+     inverse permutation matrix from the right, v' = v P^T.  Note that
+     for permutation matrices the inverse is the same as the transpose.
+     The j-th column of the permutation matrix P is given by the p_j-th
+     column of the identity matrix.  The permutation P and the vector V
+     must have the same length.
 
  -- Function: int gsl_permutation_mul (gsl_permutation * P, const
           gsl_permutation * PA, const gsl_permutation * PB)
-     This function combines the two permutations PA and PB into a
-     single permutation P, where p = pa . pb. The permutation P is
-     equivalent to applying pb first and then PA.
+     This function combines the two permutations PA and PB into a single
+     permutation P, where p = pa . pb.  The permutation P is equivalent
+     to applying pb first and then PA.
 
 
 File: gsl-ref.info,  Node: Reading and writing permutations,  Next: Permutations in cyclic form,  Prev: Applying Permutations,  Up: Permutations
@@ -6760,10 +6726,10 @@ file as binary data or formatted text.
  -- Function: int gsl_permutation_fwrite (FILE * STREAM, const
           gsl_permutation * P)
      This function writes the elements of the permutation P to the
-     stream STREAM in binary format.  The function returns
-     `GSL_EFAILED' if there was a problem writing to the file.  Since
-     the data is written in the native binary format it may not be
-     portable between different architectures.
+     stream STREAM in binary format.  The function returns 'GSL_EFAILED'
+     if there was a problem writing to the file.  Since the data is
+     written in the native binary format it may not be portable between
+     different architectures.
 
  -- Function: int gsl_permutation_fread (FILE * STREAM, gsl_permutation
           * P)
@@ -6771,25 +6737,25 @@ file as binary data or formatted text.
      STREAM in binary format.  The permutation P must be preallocated
      with the correct length since the function uses the size of P to
      determine how many bytes to read.  The function returns
-     `GSL_EFAILED' if there was a problem reading from the file.  The
-     data is assumed to have been written in the native binary format
-     on the same architecture.
+     'GSL_EFAILED' if there was a problem reading from the file.  The
+     data is assumed to have been written in the native binary format on
+     the same architecture.
 
  -- Function: int gsl_permutation_fprintf (FILE * STREAM, const
           gsl_permutation * P, const char * FORMAT)
-     This function writes the elements of the permutation P
-     line-by-line to the stream STREAM using the format specifier
-     FORMAT, which should be suitable for a type of SIZE_T.  On a GNU
-     system the type modifier `Z' represents `size_t', so `"%Zu\n"' is
-     a suitable format.  The function returns `GSL_EFAILED' if there
-     was a problem writing to the file.
-
- -- Function: int gsl_permutation_fscanf (FILE * STREAM,
-          gsl_permutation * P)
+     This function writes the elements of the permutation P line-by-line
+     to the stream STREAM using the format specifier FORMAT, which
+     should be suitable for a type of SIZE_T.  On a GNU system the type
+     modifier 'Z' represents 'size_t', so '"%Zu\n"' is a suitable
+     format.  The function returns 'GSL_EFAILED' if there was a problem
+     writing to the file.
+
+ -- Function: int gsl_permutation_fscanf (FILE * STREAM, gsl_permutation
+          * P)
      This function reads formatted data from the stream STREAM into the
      permutation P.  The permutation P must be preallocated with the
      correct length since the function uses the size of P to determine
-     how many numbers to read.  The function returns `GSL_EFAILED' if
+     how many numbers to read.  The function returns 'GSL_EFAILED' if
      there was a problem reading from the file.
 
 
@@ -6805,56 +6771,54 @@ been described above.  The cyclic notation expresses a permutation as a
 series of circular rearrangements of groups of elements, or "cycles".
 
    For example, under the cycle (1 2 3), 1 is replaced by 2, 2 is
-replaced by 3 and 3 is replaced by 1 in a circular fashion. Cycles of
-different sets of elements can be combined independently, for example
-(1 2 3) (4 5) combines the cycle (1 2 3) with the cycle (4 5), which is
-an exchange of elements 4 and 5.  A cycle of length one represents an
+replaced by 3 and 3 is replaced by 1 in a circular fashion.  Cycles of
+different sets of elements can be combined independently, for example (1
+2 3) (4 5) combines the cycle (1 2 3) with the cycle (4 5), which is an
+exchange of elements 4 and 5.  A cycle of length one represents an
 element which is unchanged by the permutation and is referred to as a
 "singleton".
 
    It can be shown that every permutation can be decomposed into
 combinations of cycles.  The decomposition is not unique, but can always
 be rearranged into a standard "canonical form" by a reordering of
-elements.  The library uses the canonical form defined in Knuth's `Art
+elements.  The library uses the canonical form defined in Knuth's 'Art
 of Computer Programming' (Vol 1, 3rd Ed, 1997) Section 1.3.3, p.178.
 
    The procedure for obtaining the canonical form given by Knuth is,
 
   1. Write all singleton cycles explicitly
-
   2. Within each cycle, put the smallest number first
-
   3. Order the cycles in decreasing order of the first number in the
      cycle.
 
 For example, the linear representation (2 4 3 0 1) is represented as (1
-4) (0 2 3) in canonical form. The permutation corresponds to an
+4) (0 2 3) in canonical form.  The permutation corresponds to an
 exchange of elements 1 and 4, and rotation of elements 0, 2 and 3.
 
    The important property of the canonical form is that it can be
-reconstructed from the contents of each cycle without the brackets. In
+reconstructed from the contents of each cycle without the brackets.  In
 addition, by removing the brackets it can be considered as a linear
-representation of a different permutation. In the example given above
+representation of a different permutation.  In the example given above
 the permutation (2 4 3 0 1) would become (1 4 0 2 3).  This mapping has
 many applications in the theory of permutations.
 
- -- Function: int gsl_permutation_linear_to_canonical (gsl_permutation
-          * Q, const gsl_permutation * P)
+ -- Function: int gsl_permutation_linear_to_canonical (gsl_permutation *
+          Q, const gsl_permutation * P)
      This function computes the canonical form of the permutation P and
      stores it in the output argument Q.
 
- -- Function: int gsl_permutation_canonical_to_linear (gsl_permutation
-          * P, const gsl_permutation * Q)
+ -- Function: int gsl_permutation_canonical_to_linear (gsl_permutation *
+          P, const gsl_permutation * Q)
      This function converts a permutation Q in canonical form back into
      linear form storing it in the output argument P.
 
- -- Function: size_t gsl_permutation_inversions (const gsl_permutation
-          * P)
-     This function counts the number of inversions in the permutation
-     P.  An inversion is any pair of elements that are not in order.
-     For example, the permutation 2031 has three inversions,
-     corresponding to the pairs (2,0) (2,1) and (3,1).  The identity
-     permutation has no inversions.
+ -- Function: size_t gsl_permutation_inversions (const gsl_permutation *
+          P)
+     This function counts the number of inversions in the permutation P.
+     An inversion is any pair of elements that are not in order.  For
+     example, the permutation 2031 has three inversions, corresponding
+     to the pairs (2,0) (2,1) and (3,1).  The identity permutation has
+     no inversions.
 
  -- Function: size_t gsl_permutation_linear_cycles (const
           gsl_permutation * P)
@@ -6923,9 +6887,8 @@ Here is the output from the program,
       random permutation: 1 3 5 2 7 6 0 4 9 8
      inverse permutation: 6 0 3 1 7 2 5 4 9 8
 
-The random permutation `p[i]' and its inverse `q[i]' are related
-through the identity `p[q[i]] = i', which can be verified from the
-output.
+The random permutation 'p[i]' and its inverse 'q[i]' are related through
+the identity 'p[q[i]] = i', which can be verified from the output.
 
    The next example program steps forwards through all possible third
 order permutations, starting from the identity,
@@ -6964,8 +6927,8 @@ Here is the output from the program,
 
 The permutations are generated in lexicographic order.  To reverse the
 sequence, begin with the final permutation (which is the reverse of the
-identity) and replace `gsl_permutation_next' with
-`gsl_permutation_prev'.
+identity) and replace 'gsl_permutation_next' with
+'gsl_permutation_prev'.
 
 
 File: gsl-ref.info,  Node: Permutation References and Further Reading,  Prev: Permutation Examples,  Up: Permutations
@@ -6973,17 +6936,17 @@ File: gsl-ref.info,  Node: Permutation References and Further Reading,  Prev: Pe
 9.10 References and Further Reading
 ===================================
 
-The subject of permutations is covered extensively in Knuth's `Sorting
+The subject of permutations is covered extensively in Knuth's 'Sorting
 and Searching',
 
-     Donald E. Knuth, `The Art of Computer Programming: Sorting and
+     Donald E. Knuth, 'The Art of Computer Programming: Sorting and
      Searching' (Vol 3, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896850.
 
 For the definition of the "canonical form" see,
 
-     Donald E. Knuth, `The Art of Computer Programming: Fundamental
+     Donald E. Knuth, 'The Art of Computer Programming: Fundamental
      Algorithms' (Vol 1, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896850.
-     Section 1.3.3, `An Unusual Correspondence', p.178-179.
+     Section 1.3.3, 'An Unusual Correspondence', p.178-179.
 
 
 File: gsl-ref.info,  Node: Combinations,  Next: Sorting,  Prev: Permutations,  Up: Top
@@ -6992,24 +6955,24 @@ File: gsl-ref.info,  Node: Combinations,  Next: Sorting,  Prev: Permutations,  U
 ***************
 
 This chapter describes functions for creating and manipulating
-combinations. A combination c is represented by an array of k integers
+combinations.  A combination c is represented by an array of k integers
 in the range 0 to n-1, where each value c_i occurs at most once.  The
 combination c corresponds to indices of k elements chosen from an n
 element vector.  Combinations are useful for iterating over all
 k-element subsets of a set.
 
    The functions described in this chapter are defined in the header
-file `gsl_combination.h'.
+file 'gsl_combination.h'.
 
 * Menu:
 
-* The Combination struct::
-* Combination allocation::
-* Accessing combination elements::
-* Combination properties::
-* Combination functions::
-* Reading and writing combinations::
-* Combination Examples::
+* The Combination struct::      
+* Combination allocation::      
+* Accessing combination elements::  
+* Combination properties::      
+* Combination functions::       
+* Reading and writing combinations::  
+* Combination Examples::        
 * Combination References and Further Reading::
 
 
@@ -7019,10 +6982,9 @@ File: gsl-ref.info,  Node: The Combination struct,  Next: Combination allocation
 ===========================
 
 A combination is defined by a structure containing three components, the
-values of n and k, and a pointer to the combination array.  The
-elements of the combination array are all of type `size_t', and are
-stored in increasing order.  The `gsl_combination' structure looks like
-this,
+values of n and k, and a pointer to the combination array.  The elements
+of the combination array are all of type 'size_t', and are stored in
+increasing order.  The 'gsl_combination' structure looks like this,
 
      typedef struct
      {
@@ -7031,7 +6993,6 @@ this,
        size_t *data;
      } gsl_combination;
 
-
 
 File: gsl-ref.info,  Node: Combination allocation,  Next: Accessing combination elements,  Prev: The Combination struct,  Up: Combinations
 
@@ -7042,16 +7003,16 @@ File: gsl-ref.info,  Node: Combination allocation,  Next: Accessing combination
           K)
      This function allocates memory for a new combination with
      parameters N, K.  The combination is not initialized and its
-     elements are undefined.  Use the function `gsl_combination_calloc'
+     elements are undefined.  Use the function 'gsl_combination_calloc'
      if you want to create a combination which is initialized to the
-     lexicographically first combination. A null pointer is returned if
+     lexicographically first combination.  A null pointer is returned if
      insufficient memory is available to create the combination.
 
- -- Function: gsl_combination * gsl_combination_calloc (size_t N,
-          size_t K)
+ -- Function: gsl_combination * gsl_combination_calloc (size_t N, size_t
+          K)
      This function allocates memory for a new combination with
      parameters N, K and initializes it to the lexicographically first
-     combination. A null pointer is returned if insufficient memory is
+     combination.  A null pointer is returned if insufficient memory is
      available to create the combination.
 
  -- Function: void gsl_combination_init_first (gsl_combination * C)
@@ -7095,8 +7056,8 @@ File: gsl-ref.info,  Node: Combination properties,  Next: Combination functions,
      This function returns the range (n) of the combination C.
 
  -- Function: size_t gsl_combination_k (const gsl_combination * C)
-     This function returns the number of elements (k) in the
-     combination C.
+     This function returns the number of elements (k) in the combination
+     C.
 
  -- Function: size_t * gsl_combination_data (const gsl_combination * C)
      This function returns a pointer to the array of elements in the
@@ -7114,9 +7075,9 @@ File: gsl-ref.info,  Node: Combination functions,  Next: Reading and writing com
 ==========================
 
  -- Function: int gsl_combination_next (gsl_combination * C)
-     This function advances the combination C to the next combination
-     in lexicographic order and returns `GSL_SUCCESS'.  If no further
-     combinations are available it returns `GSL_FAILURE' and leaves C
+     This function advances the combination C to the next combination in
+     lexicographic order and returns 'GSL_SUCCESS'.  If no further
+     combinations are available it returns 'GSL_FAILURE' and leaves C
      unmodified.  Starting with the first combination and repeatedly
      applying this function will iterate through all possible
      combinations of a given order.
@@ -7124,8 +7085,8 @@ File: gsl-ref.info,  Node: Combination functions,  Next: Reading and writing com
  -- Function: int gsl_combination_prev (gsl_combination * C)
      This function steps backwards from the combination C to the
      previous combination in lexicographic order, returning
-     `GSL_SUCCESS'.  If no previous combination is available it returns
-     `GSL_FAILURE' and leaves C unmodified.
+     'GSL_SUCCESS'.  If no previous combination is available it returns
+     'GSL_FAILURE' and leaves C unmodified.
 
 
 File: gsl-ref.info,  Node: Reading and writing combinations,  Next: Combination Examples,  Prev: Combination functions,  Up: Combinations
@@ -7139,37 +7100,37 @@ file as binary data or formatted text.
  -- Function: int gsl_combination_fwrite (FILE * STREAM, const
           gsl_combination * C)
      This function writes the elements of the combination C to the
-     stream STREAM in binary format.  The function returns
-     `GSL_EFAILED' if there was a problem writing to the file.  Since
-     the data is written in the native binary format it may not be
-     portable between different architectures.
+     stream STREAM in binary format.  The function returns 'GSL_EFAILED'
+     if there was a problem writing to the file.  Since the data is
+     written in the native binary format it may not be portable between
+     different architectures.
 
  -- Function: int gsl_combination_fread (FILE * STREAM, gsl_combination
           * C)
      This function reads elements from the open stream STREAM into the
      combination C in binary format.  The combination C must be
-     preallocated with correct values of n and k since the function
-     uses the size of C to determine how many bytes to read.  The
-     function returns `GSL_EFAILED' if there was a problem reading from
-     the file.  The data is assumed to have been written in the native
-     binary format on the same architecture.
+     preallocated with correct values of n and k since the function uses
+     the size of C to determine how many bytes to read.  The function
+     returns 'GSL_EFAILED' if there was a problem reading from the file.
+     The data is assumed to have been written in the native binary
+     format on the same architecture.
 
  -- Function: int gsl_combination_fprintf (FILE * STREAM, const
           gsl_combination * C, const char * FORMAT)
-     This function writes the elements of the combination C
-     line-by-line to the stream STREAM using the format specifier
-     FORMAT, which should be suitable for a type of SIZE_T.  On a GNU
-     system the type modifier `Z' represents `size_t', so `"%Zu\n"' is
-     a suitable format.  The function returns `GSL_EFAILED' if there
-     was a problem writing to the file.
-
- -- Function: int gsl_combination_fscanf (FILE * STREAM,
-          gsl_combination * C)
+     This function writes the elements of the combination C line-by-line
+     to the stream STREAM using the format specifier FORMAT, which
+     should be suitable for a type of SIZE_T.  On a GNU system the type
+     modifier 'Z' represents 'size_t', so '"%Zu\n"' is a suitable
+     format.  The function returns 'GSL_EFAILED' if there was a problem
+     writing to the file.
+
+ -- Function: int gsl_combination_fscanf (FILE * STREAM, gsl_combination
+          * C)
      This function reads formatted data from the stream STREAM into the
-     combination C.  The combination C must be preallocated with
-     correct values of n and k since the function uses the size of C to
+     combination C.  The combination C must be preallocated with correct
+     values of n and k since the function uses the size of C to
      determine how many numbers to read.  The function returns
-     `GSL_EFAILED' if there was a problem reading from the file.
+     'GSL_EFAILED' if there was a problem reading from the file.
 
 
 File: gsl-ref.info,  Node: Combination Examples,  Next: Combination References and Further Reading,  Prev: Reading and writing combinations,  Up: Combinations
@@ -7239,11 +7200,10 @@ File: gsl-ref.info,  Node: Combination References and Further Reading,  Prev: Co
 
 Further information on combinations can be found in,
 
-     Donald L. Kreher, Douglas R. Stinson, `Combinatorial Algorithms:
+     Donald L. Kreher, Douglas R. Stinson, 'Combinatorial Algorithms:
      Generation, Enumeration and Search', 1998, CRC Press LLC, ISBN
      084933988X
 
-
 
 File: gsl-ref.info,  Node: Sorting,  Next: BLAS Support,  Prev: Combinations,  Up: Top
 
@@ -7252,8 +7212,8 @@ File: gsl-ref.info,  Node: Sorting,  Next: BLAS Support,  Prev: Combinations,  U
 
 This chapter describes functions for sorting data, both directly and
 indirectly (using an index).  All the functions use the "heapsort"
-algorithm.  Heapsort is an O(N \log N) algorithm which operates
-in-place and does not require any additional storage.  It also provides
+algorithm.  Heapsort is an O(N \log N) algorithm which operates in-place
+and does not require any additional storage.  It also provides
 consistent performance, the running time for its worst-case (ordered
 data) being not significantly longer than the average and best cases.
 Note that the heapsort algorithm does not preserve the relative ordering
@@ -7263,12 +7223,12 @@ when using these functions.
 
 * Menu:
 
-* Sorting objects::
-* Sorting vectors::
-* Selecting the k smallest or largest elements::
-* Computing the rank::
-* Sorting Examples::
-* Sorting References and Further Reading::
+* Sorting objects::             
+* Sorting vectors::             
+* Selecting the k smallest or largest elements::  
+* Computing the rank::          
+* Sorting Examples::            
+* Sorting References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Sorting objects,  Next: Sorting vectors,  Up: Sorting
@@ -7277,17 +7237,18 @@ File: gsl-ref.info,  Node: Sorting objects,  Next: Sorting vectors,  Up: Sorting
 ====================
 
 The following function provides a simple alternative to the standard
-library function `qsort'.  It is intended for systems lacking `qsort',
-not as a replacement for it.  The function `qsort' should be used
+library function 'qsort'.  It is intended for systems lacking 'qsort',
+not as a replacement for it.  The function 'qsort' should be used
 whenever possible, as it will be faster and can provide stable ordering
-of equal elements.  Documentation for `qsort' is available in the `GNU
-C Library Reference Manual'.
+of equal elements.  Documentation for 'qsort' is available in the 'GNU C
+Library Reference Manual'.
 
    The functions described in this section are defined in the header
-file `gsl_heapsort.h'.
+file 'gsl_heapsort.h'.
 
  -- Function: void gsl_heapsort (void * ARRAY, size_t COUNT, size_t
           SIZE, gsl_comparison_fn_t COMPARE)
+
      This function sorts the COUNT elements of the array ARRAY, each of
      size SIZE, into ascending order using the comparison function
      COMPARE.  The type of the comparison function is defined by,
@@ -7296,7 +7257,7 @@ file `gsl_heapsort.h'.
                                       const void * b)
 
      A comparison function should return a negative integer if the first
-     argument is less than the second argument, `0' if the two arguments
+     argument is less than the second argument, '0' if the two arguments
      are equal and a positive integer if the first argument is greater
      than the second argument.
 
@@ -7320,7 +7281,7 @@ file `gsl_heapsort.h'.
           gsl_heapsort (array, count, sizeof(double),
                         compare_doubles);
 
-     Note that unlike `qsort' the heapsort algorithm cannot be made into
+     Note that unlike 'qsort' the heapsort algorithm cannot be made into
      a stable sort by pointer arithmetic.  The trick of comparing
      pointers for equal elements in the comparison function does not
      work for the heapsort algorithm.  The heapsort algorithm performs
@@ -7329,15 +7290,16 @@ file `gsl_heapsort.h'.
 
  -- Function: int gsl_heapsort_index (size_t * P, const void * ARRAY,
           size_t COUNT, size_t SIZE, gsl_comparison_fn_t COMPARE)
+
      This function indirectly sorts the COUNT elements of the array
-     ARRAY, each of size SIZE, into ascending order using the
-     comparison function COMPARE.  The resulting permutation is stored
-     in P, an array of length N.  The elements of P give the index of
-     the array element which would have been stored in that position if
-     the array had been sorted in place.  The first element of P gives
-     the index of the least element in ARRAY, and the last element of P
-     gives the index of the greatest element in ARRAY.  The array
-     itself is not changed.
+     ARRAY, each of size SIZE, into ascending order using the comparison
+     function COMPARE.  The resulting permutation is stored in P, an
+     array of length N.  The elements of P give the index of the array
+     element which would have been stored in that position if the array
+     had been sorted in place.  The first element of P gives the index
+     of the least element in ARRAY, and the last element of P gives the
+     index of the greatest element in ARRAY.  The array itself is not
+     changed.
 
 
 File: gsl-ref.info,  Node: Sorting vectors,  Next: Selecting the k smallest or largest elements,  Prev: Sorting objects,  Up: Sorting
@@ -7347,13 +7309,13 @@ File: gsl-ref.info,  Node: Sorting vectors,  Next: Selecting the k smallest or l
 
 The following functions will sort the elements of an array or vector,
 either directly or indirectly.  They are defined for all real and
-integer types using the normal suffix rules.  For example, the `float'
-versions of the array functions are `gsl_sort_float' and
-`gsl_sort_float_index'.  The corresponding vector functions are
-`gsl_sort_vector_float' and `gsl_sort_vector_float_index'.  The
-prototypes are available in the header files `gsl_sort_float.h'
-`gsl_sort_vector_float.h'.  The complete set of prototypes can be
-included using the header files `gsl_sort.h' and `gsl_sort_vector.h'.
+integer types using the normal suffix rules.  For example, the 'float'
+versions of the array functions are 'gsl_sort_float' and
+'gsl_sort_float_index'.  The corresponding vector functions are
+'gsl_sort_vector_float' and 'gsl_sort_vector_float_index'.  The
+prototypes are available in the header files 'gsl_sort_float.h'
+'gsl_sort_vector_float.h'.  The complete set of prototypes can be
+included using the header files 'gsl_sort.h' and 'gsl_sort_vector.h'.
 
    There are no functions for sorting complex arrays or vectors, since
 the ordering of complex numbers is not uniquely defined.  To sort a
@@ -7375,17 +7337,17 @@ complex vector.
      This function indirectly sorts the N elements of the array DATA
      with stride STRIDE into ascending order, storing the resulting
      permutation in P.  The array P must be allocated with a sufficient
-     length to store the N elements of the permutation.  The elements
-     of P give the index of the array element which would have been
-     stored in that position if the array had been sorted in place.
-     The array DATA is not changed.
+     length to store the N elements of the permutation.  The elements of
+     P give the index of the array element which would have been stored
+     in that position if the array had been sorted in place.  The array
+     DATA is not changed.
 
  -- Function: int gsl_sort_vector_index (gsl_permutation * P, const
           gsl_vector * V)
      This function indirectly sorts the elements of the vector V into
      ascending order, storing the resulting permutation in P.  The
-     elements of P give the index of the vector element which would
-     have been stored in that position if the vector had been sorted in
+     elements of P give the index of the vector element which would have
+     been stored in that position if the vector had been sorted in
      place.  The first element of P gives the index of the least element
      in V, and the last element of P gives the index of the greatest
      element in V.  The vector V is not changed.
diff --git a/gsl-1.9/doc/gsl-ref.info-2 b/gsl-1.9/doc/gsl-ref.info-2
index 3fd15e9..f27f665 100644
--- a/gsl-1.9/doc/gsl-ref.info-2
+++ b/gsl-1.9/doc/gsl-ref.info-2
@@ -1,12 +1,7 @@
-This is gsl-ref.info, produced by makeinfo version 4.8 from
+This is gsl-ref.info, produced by makeinfo version 5.1 from
 gsl-ref.texi.
 
-INFO-DIR-SECTION Scientific software
-START-INFO-DIR-ENTRY
-* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
-END-INFO-DIR-ENTRY
-
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 2005, 2006, 2007 The GSL Team.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -20,6 +15,10 @@ License".
 
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
+INFO-DIR-SECTION Scientific software
+START-INFO-DIR-ENTRY
+* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
+END-INFO-DIR-ENTRY
 
 
 File: gsl-ref.info,  Node: Selecting the k smallest or largest elements,  Next: Computing the rank,  Prev: Sorting vectors,  Up: Sorting
@@ -27,47 +26,47 @@ File: gsl-ref.info,  Node: Selecting the k smallest or largest elements,  Next:
 11.3 Selecting the k smallest or largest elements
 =================================================
 
-The functions described in this section select the k smallest or
-largest elements of a data set of size N.  The routines use an O(kN)
-direct insertion algorithm which is suited to subsets that are small
-compared with the total size of the dataset. For example, the routines
-are useful for selecting the 10 largest values from one million data
-points, but not for selecting the largest 100,000 values.  If the
-subset is a significant part of the total dataset it may be faster to
-sort all the elements of the dataset directly with an O(N \log N)
-algorithm and obtain the smallest or largest values that way.
+The functions described in this section select the k smallest or largest
+elements of a data set of size N.  The routines use an O(kN) direct
+insertion algorithm which is suited to subsets that are small compared
+with the total size of the dataset.  For example, the routines are
+useful for selecting the 10 largest values from one million data points,
+but not for selecting the largest 100,000 values.  If the subset is a
+significant part of the total dataset it may be faster to sort all the
+elements of the dataset directly with an O(N \log N) algorithm and
+obtain the smallest or largest values that way.
 
  -- Function: int gsl_sort_smallest (double * DEST, size_t K, const
           double * SRC, size_t STRIDE, size_t N)
      This function copies the K smallest elements of the array SRC, of
      size N and stride STRIDE, in ascending numerical order into the
-     array DEST.  The size K of the subset must be less than or equal
-     to N.  The data SRC is not modified by this operation.
+     array DEST.  The size K of the subset must be less than or equal to
+     N.  The data SRC is not modified by this operation.
 
  -- Function: int gsl_sort_largest (double * DEST, size_t K, const
           double * SRC, size_t STRIDE, size_t N)
      This function copies the K largest elements of the array SRC, of
      size N and stride STRIDE, in descending numerical order into the
-     array DEST. K must be less than or equal to N. The data SRC is not
-     modified by this operation.
+     array DEST.  K must be less than or equal to N.  The data SRC is
+     not modified by this operation.
 
  -- Function: int gsl_sort_vector_smallest (double * DEST, size_t K,
           const gsl_vector * V)
  -- Function: int gsl_sort_vector_largest (double * DEST, size_t K,
           const gsl_vector * V)
      These functions copy the K smallest or largest elements of the
-     vector V into the array DEST. K must be less than or equal to the
+     vector V into the array DEST.  K must be less than or equal to the
      length of the vector V.
 
-   The following functions find the indices of the k smallest or
-largest elements of a dataset,
+   The following functions find the indices of the k smallest or largest
+elements of a dataset,
 
  -- Function: int gsl_sort_smallest_index (size_t * P, size_t K, const
           double * SRC, size_t STRIDE, size_t N)
      This function stores the indices of the K smallest elements of the
      array SRC, of size N and stride STRIDE, in the array P.  The
      indices are chosen so that the corresponding data is in ascending
-     numerical order.  K must be less than or equal to N. The data SRC
+     numerical order.  K must be less than or equal to N.  The data SRC
      is not modified by this operation.
 
  -- Function: int gsl_sort_largest_index (size_t * P, size_t K, const
@@ -75,7 +74,7 @@ largest elements of a dataset,
      This function stores the indices of the K largest elements of the
      array SRC, of size N and stride STRIDE, in the array P.  The
      indices are chosen so that the corresponding data is in descending
-     numerical order.  K must be less than or equal to N. The data SRC
+     numerical order.  K must be less than or equal to N.  The data SRC
      is not modified by this operation.
 
  -- Function: int gsl_sort_vector_smallest_index (size_t * P, size_t K,
@@ -83,7 +82,7 @@ largest elements of a dataset,
  -- Function: int gsl_sort_vector_largest_index (size_t * P, size_t K,
           const gsl_vector * V)
      These functions store the indices of the K smallest or largest
-     elements of the vector V in the array P. K must be less than or
+     elements of the vector V in the array P.  K must be less than or
      equal to the length of the vector V.
 
 
@@ -103,7 +102,7 @@ following algorithm,
      }
 
 This can be computed directly from the function
-`gsl_permutation_inverse(rank,p)'.
+'gsl_permutation_inverse(rank,p)'.
 
    The following function will print the rank of each element of the
 vector V,
@@ -147,7 +146,7 @@ elements of the vector V in ascending order,
          printf ("order = %d, value = %g\n", i, vpi);
      }
 
-The next example uses the function `gsl_sort_smallest' to select the 5
+The next example uses the function 'gsl_sort_smallest' to select the 5
 smallest numbers from 100000 uniform random variates stored in an array,
 
      #include <gsl/gsl_rng.h>
@@ -204,15 +203,15 @@ File: gsl-ref.info,  Node: Sorting References and Further Reading,  Prev: Sortin
 11.6 References and Further Reading
 ===================================
 
-The subject of sorting is covered extensively in Knuth's `Sorting and
+The subject of sorting is covered extensively in Knuth's 'Sorting and
 Searching',
 
-     Donald E. Knuth, `The Art of Computer Programming: Sorting and
+     Donald E. Knuth, 'The Art of Computer Programming: Sorting and
      Searching' (Vol 3, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896850.
 
 The Heapsort algorithm is described in the following book,
 
-     Robert Sedgewick, `Algorithms in C', Addison-Wesley, ISBN
+     Robert Sedgewick, 'Algorithms in C', Addison-Wesley, ISBN
      0201514257.
 
 
@@ -230,34 +229,31 @@ the C-language BLAS standard, referred to here as "CBLAS", and a
 higher-level interface for operations on GSL vectors and matrices.
 Users who are interested in simple operations on GSL vector and matrix
 objects should use the high-level layer, which is declared in the file
-`gsl_blas.h'.  This should satisfy the needs of most users.  Note that
+'gsl_blas.h'.  This should satisfy the needs of most users.  Note that
 GSL matrices are implemented using dense-storage so the interface only
 includes the corresponding dense-storage BLAS functions.  The full BLAS
 functionality for band-format and packed-format matrices is available
 through the low-level CBLAS interface.
 
-   The interface for the `gsl_cblas' layer is specified in the file
-`gsl_cblas.h'.  This interface corresponds to the BLAS Technical
-Forum's draft standard for the C interface to legacy BLAS
-implementations. Users who have access to other conforming CBLAS
-implementations can use these in place of the version provided by the
-library.  Note that users who have only a Fortran BLAS library can use
-a CBLAS conformant wrapper to convert it into a CBLAS library.  A
-reference CBLAS wrapper for legacy Fortran implementations exists as
-part of the draft CBLAS standard and can be obtained from Netlib.  The
-complete set of CBLAS functions is listed in an appendix (*note GSL
-CBLAS Library::).
+   The interface for the 'gsl_cblas' layer is specified in the file
+'gsl_cblas.h'.  This interface corresponds to the BLAS Technical Forum's
+draft standard for the C interface to legacy BLAS implementations.
+Users who have access to other conforming CBLAS implementations can use
+these in place of the version provided by the library.  Note that users
+who have only a Fortran BLAS library can use a CBLAS conformant wrapper
+to convert it into a CBLAS library.  A reference CBLAS wrapper for
+legacy Fortran implementations exists as part of the draft CBLAS
+standard and can be obtained from Netlib.  The complete set of CBLAS
+functions is listed in an appendix (*note GSL CBLAS Library::).
 
    There are three levels of BLAS operations,
 
 Level 1
-     Vector operations, e.g. y = \alpha x + y
-
+     Vector operations, e.g.  y = \alpha x + y
 Level 2
-     Matrix-vector operations, e.g. y = \alpha A x + \beta y
-
+     Matrix-vector operations, e.g.  y = \alpha A x + \beta y
 Level 3
-     Matrix-matrix operations, e.g. C = \alpha A B + C
+     Matrix-matrix operations, e.g.  C = \alpha A B + C
 
 Each routine has a name which specifies the operation, the type of
 matrices involved and their precisions.  Some of the most common
@@ -265,19 +261,14 @@ operations and their names are given below,
 
 DOT
      scalar product, x^T y
-
 AXPY
      vector sum, \alpha x + y
-
 MV
      matrix-vector product, A x
-
 SV
      matrix-vector solve, inv(A) x
-
 MM
      matrix-matrix product, A B
-
 SM
      matrix-matrix solve, inv(A) B
 
@@ -285,34 +276,24 @@ The types of matrices are,
 
 GE
      general
-
 GB
      general band
-
 SY
      symmetric
-
 SB
      symmetric band
-
 SP
      symmetric packed
-
 HE
      hermitian
-
 HB
      hermitian band
-
 HP
      hermitian packed
-
 TR
      triangular
-
 TB
      triangular band
-
 TP
      triangular packed
 
@@ -320,13 +301,10 @@ Each operation is defined for four precisions,
 
 S
      single real
-
 D
      double real
-
 C
      single complex
-
 Z
      double complex
 
@@ -336,9 +314,9 @@ matrix-matrix multiply".
 
 * Menu:
 
-* GSL BLAS Interface::
-* BLAS Examples::
-* BLAS References and Further Reading::
+* GSL BLAS Interface::          
+* BLAS Examples::               
+* BLAS References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: GSL BLAS Interface,  Next: BLAS Examples,  Up: BLAS Support
@@ -349,13 +327,13 @@ File: gsl-ref.info,  Node: GSL BLAS Interface,  Next: BLAS Examples,  Up: BLAS S
 GSL provides dense vector and matrix objects, based on the relevant
 built-in types.  The library provides an interface to the BLAS
 operations which apply to these objects.  The interface to this
-functionality is given in the file `gsl_blas.h'.
+functionality is given in the file 'gsl_blas.h'.
 
 * Menu:
 
-* Level 1 GSL BLAS Interface::
-* Level 2 GSL BLAS Interface::
-* Level 3 GSL BLAS Interface::
+* Level 1 GSL BLAS Interface::  
+* Level 2 GSL BLAS Interface::  
+* Level 3 GSL BLAS Interface::  
 
 
 File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS Interface,  Up: GSL BLAS Interface
@@ -363,10 +341,10 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
 12.1.1 Level 1
 --------------
 
- -- Function: int gsl_blas_sdsdot (float ALPHA, const gsl_vector_float
-          * X, const gsl_vector_float * Y, float * RESULT)
-     This function computes the sum \alpha + x^T y for the vectors X
-     and Y, returning the result in RESULT.
+ -- Function: int gsl_blas_sdsdot (float ALPHA, const gsl_vector_float *
+          X, const gsl_vector_float * Y, float * RESULT)
+     This function computes the sum \alpha + x^T y for the vectors X and
+     Y, returning the result in RESULT.
 
  -- Function: int gsl_blas_sdot (const gsl_vector_float * X, const
           gsl_vector_float * Y, float * RESULT)
@@ -404,8 +382,8 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
 
  -- Function: float gsl_blas_sasum (const gsl_vector_float * X)
  -- Function: double gsl_blas_dasum (const gsl_vector * X)
-     These functions compute the absolute sum \sum |x_i| of the
-     elements of the vector X.
+     These functions compute the absolute sum \sum |x_i| of the elements
+     of the vector X.
 
  -- Function: float gsl_blas_scasum (const gsl_vector_complex_float * X)
  -- Function: double gsl_blas_dzasum (const gsl_vector_complex * X)
@@ -420,14 +398,14 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
  -- Function: CBLAS_INDEX_t gsl_blas_izamax (const gsl_vector_complex *
           X)
      These functions return the index of the largest element of the
-     vector X. The largest element is determined by its absolute
+     vector X.  The largest element is determined by its absolute
      magnitude for real vectors and by the sum of the magnitudes of the
      real and imaginary parts |\Re(x_i)| + |\Im(x_i)| for complex
      vectors.  If the largest value occurs several times then the index
      of the first occurrence is returned.
 
- -- Function: int gsl_blas_sswap (gsl_vector_float * X,
-          gsl_vector_float * Y)
+ -- Function: int gsl_blas_sswap (gsl_vector_float * X, gsl_vector_float
+          * Y)
  -- Function: int gsl_blas_dswap (gsl_vector * X, gsl_vector * Y)
  -- Function: int gsl_blas_cswap (gsl_vector_complex_float * X,
           gsl_vector_complex_float * Y)
@@ -469,8 +447,8 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
      These functions rescale the vector X by the multiplicative factor
      ALPHA.
 
- -- Function: int gsl_blas_srotg (float A[], float B[], float C[],
-          float S[])
+ -- Function: int gsl_blas_srotg (float A[], float B[], float C[], float
+          S[])
  -- Function: int gsl_blas_drotg (double A[], double B[], double C[],
           double S[])
      These functions compute a Givens rotation (c,s) which zeroes the
@@ -485,8 +463,8 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
           * Y, float C, float S)
  -- Function: int gsl_blas_drot (gsl_vector * X, gsl_vector * Y, const
           double C, const double S)
-     These functions apply a Givens rotation (x', y') = (c x + s y, -s
-     x + c y) to the vectors X, Y.
+     These functions apply a Givens rotation (x', y') = (c x + s y, -s x
+     + c y) to the vectors X, Y.
 
  -- Function: int gsl_blas_srotmg (float D1[], float D2[], float B1[],
           float B2, float P[])
@@ -496,8 +474,8 @@ File: gsl-ref.info,  Node: Level 1 GSL BLAS Interface,  Next: Level 2 GSL BLAS I
      modified Givens transformation is defined in the original Level-1
      BLAS specification, given in the references.
 
- -- Function: int gsl_blas_srotm (gsl_vector_float * X,
-          gsl_vector_float * Y, const float P[])
+ -- Function: int gsl_blas_srotm (gsl_vector_float * X, gsl_vector_float
+          * Y, const float P[])
  -- Function: int gsl_blas_drotm (gsl_vector * X, gsl_vector * Y, const
           double P[])
      These functions apply a modified Givens transformation.
@@ -508,9 +486,9 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
 12.1.2 Level 2
 --------------
 
- -- Function: int gsl_blas_sgemv (CBLAS_TRANSPOSE_t TRANSA, float
-          ALPHA, const gsl_matrix_float * A, const gsl_vector_float *
-          X, float BETA, gsl_vector_float * Y)
+ -- Function: int gsl_blas_sgemv (CBLAS_TRANSPOSE_t TRANSA, float ALPHA,
+          const gsl_matrix_float * A, const gsl_vector_float * X, float
+          BETA, gsl_vector_float * Y)
  -- Function: int gsl_blas_dgemv (CBLAS_TRANSPOSE_t TRANSA, double
           ALPHA, const gsl_matrix * A, const gsl_vector * X, double
           BETA, gsl_vector * Y)
@@ -524,7 +502,7 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
           gsl_vector_complex * Y)
      These functions compute the matrix-vector product and sum y =
      \alpha op(A) x + \beta y, where op(A) = A, A^T, A^H for TRANSA =
-     `CblasNoTrans', `CblasTrans', `CblasConjTrans'.
+     'CblasNoTrans', 'CblasTrans', 'CblasConjTrans'.
 
  -- Function: int gsl_blas_strmv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_float * A,
@@ -533,19 +511,19 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix * A, gsl_vector *
           X)
  -- Function: int gsl_blas_ctrmv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
-          TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex_float *
-          A, gsl_vector_complex_float * X)
+          TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex_float * A,
+          gsl_vector_complex_float * X)
  -- Function: int gsl_blas_ztrmv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex * A,
           gsl_vector_complex * X)
      These functions compute the matrix-vector product x = op(A) x for
      the triangular matrix A, where op(A) = A, A^T, A^H for TRANSA =
-     `CblasNoTrans', `CblasTrans', `CblasConjTrans'.  When UPLO is
-     `CblasUpper' then the upper triangle of A is used, and when UPLO
-     is `CblasLower' then the lower triangle of A is used.  If DIAG is
-     `CblasNonUnit' then the diagonal of the matrix is used, but if
-     DIAG is `CblasUnit' then the diagonal elements of the matrix A are
-     taken as unity and are not referenced.
+     'CblasNoTrans', 'CblasTrans', 'CblasConjTrans'.  When UPLO is
+     'CblasUpper' then the upper triangle of A is used, and when UPLO is
+     'CblasLower' then the lower triangle of A is used.  If DIAG is
+     'CblasNonUnit' then the diagonal of the matrix is used, but if DIAG
+     is 'CblasUnit' then the diagonal elements of the matrix A are taken
+     as unity and are not referenced.
 
  -- Function: int gsl_blas_strsv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_float * A,
@@ -554,31 +532,31 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix * A, gsl_vector *
           X)
  -- Function: int gsl_blas_ctrsv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
-          TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex_float *
-          A, gsl_vector_complex_float * X)
+          TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex_float * A,
+          gsl_vector_complex_float * X)
  -- Function: int gsl_blas_ztrsv (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANSA, CBLAS_DIAG_t DIAG, const gsl_matrix_complex * A,
           gsl_vector_complex * X)
      These functions compute inv(op(A)) x for X, where op(A) = A, A^T,
-     A^H for TRANSA = `CblasNoTrans', `CblasTrans', `CblasConjTrans'.
-     When UPLO is `CblasUpper' then the upper triangle of A is used,
-     and when UPLO is `CblasLower' then the lower triangle of A is
-     used.  If DIAG is `CblasNonUnit' then the diagonal of the matrix
-     is used, but if DIAG is `CblasUnit' then the diagonal elements of
-     the matrix A are taken as unity and are not referenced.
+     A^H for TRANSA = 'CblasNoTrans', 'CblasTrans', 'CblasConjTrans'.
+     When UPLO is 'CblasUpper' then the upper triangle of A is used, and
+     when UPLO is 'CblasLower' then the lower triangle of A is used.  If
+     DIAG is 'CblasNonUnit' then the diagonal of the matrix is used, but
+     if DIAG is 'CblasUnit' then the diagonal elements of the matrix A
+     are taken as unity and are not referenced.
 
  -- Function: int gsl_blas_ssymv (CBLAS_UPLO_t UPLO, float ALPHA, const
           gsl_matrix_float * A, const gsl_vector_float * X, float BETA,
           gsl_vector_float * Y)
- -- Function: int gsl_blas_dsymv (CBLAS_UPLO_t UPLO, double ALPHA,
-          const gsl_matrix * A, const gsl_vector * X, double BETA,
-          gsl_vector * Y)
+ -- Function: int gsl_blas_dsymv (CBLAS_UPLO_t UPLO, double ALPHA, const
+          gsl_matrix * A, const gsl_vector * X, double BETA, gsl_vector
+          * Y)
      These functions compute the matrix-vector product and sum y =
      \alpha A x + \beta y for the symmetric matrix A.  Since the matrix
-     A is symmetric only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of A are used, and when UPLO is `CblasLower' then the
-     lower triangle and diagonal of A are used.
+     A is symmetric only its upper half or lower half need to be stored.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.
 
  -- Function: int gsl_blas_chemv (CBLAS_UPLO_t UPLO, const
           gsl_complex_float ALPHA, const gsl_matrix_complex_float * A,
@@ -589,20 +567,19 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
           * X, const gsl_complex BETA, gsl_vector_complex * Y)
      These functions compute the matrix-vector product and sum y =
      \alpha A x + \beta y for the hermitian matrix A.  Since the matrix
-     A is hermitian only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of A are used, and when UPLO is `CblasLower' then the
-     lower triangle and diagonal of A are used.  The imaginary elements
-     of the diagonal are automatically assumed to be zero and are not
-     referenced.
+     A is hermitian only its upper half or lower half need to be stored.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.  The imaginary elements of the diagonal are
+     automatically assumed to be zero and are not referenced.
 
  -- Function: int gsl_blas_sger (float ALPHA, const gsl_vector_float *
           X, const gsl_vector_float * Y, gsl_matrix_float * A)
  -- Function: int gsl_blas_dger (double ALPHA, const gsl_vector * X,
           const gsl_vector * Y, gsl_matrix * A)
  -- Function: int gsl_blas_cgeru (const gsl_complex_float ALPHA, const
-          gsl_vector_complex_float * X, const gsl_vector_complex_float
-          * Y, gsl_matrix_complex_float * A)
+          gsl_vector_complex_float * X, const gsl_vector_complex_float *
+          Y, gsl_matrix_complex_float * A)
  -- Function: int gsl_blas_zgeru (const gsl_complex ALPHA, const
           gsl_vector_complex * X, const gsl_vector_complex * Y,
           gsl_matrix_complex * A)
@@ -610,8 +587,8 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
      the matrix A.
 
  -- Function: int gsl_blas_cgerc (const gsl_complex_float ALPHA, const
-          gsl_vector_complex_float * X, const gsl_vector_complex_float
-          * Y, gsl_matrix_complex_float * A)
+          gsl_vector_complex_float * X, const gsl_vector_complex_float *
+          Y, gsl_matrix_complex_float * A)
  -- Function: int gsl_blas_zgerc (const gsl_complex ALPHA, const
           gsl_vector_complex * X, const gsl_vector_complex * Y,
           gsl_matrix_complex * A)
@@ -623,50 +600,50 @@ File: gsl-ref.info,  Node: Level 2 GSL BLAS Interface,  Next: Level 3 GSL BLAS I
  -- Function: int gsl_blas_dsyr (CBLAS_UPLO_t UPLO, double ALPHA, const
           gsl_vector * X, gsl_matrix * A)
      These functions compute the symmetric rank-1 update A = \alpha x
-     x^T + A of the symmetric matrix A.  Since the matrix A is
-     symmetric only its upper half or lower half need to be stored.
-     When UPLO is `CblasUpper' then the upper triangle and diagonal of
-     A are used, and when UPLO is `CblasLower' then the lower triangle
-     and diagonal of A are used.
+     x^T + A of the symmetric matrix A.  Since the matrix A is symmetric
+     only its upper half or lower half need to be stored.  When UPLO is
+     'CblasUpper' then the upper triangle and diagonal of A are used,
+     and when UPLO is 'CblasLower' then the lower triangle and diagonal
+     of A are used.
 
  -- Function: int gsl_blas_cher (CBLAS_UPLO_t UPLO, float ALPHA, const
           gsl_vector_complex_float * X, gsl_matrix_complex_float * A)
  -- Function: int gsl_blas_zher (CBLAS_UPLO_t UPLO, double ALPHA, const
           gsl_vector_complex * X, gsl_matrix_complex * A)
      These functions compute the hermitian rank-1 update A = \alpha x
-     x^H + A of the hermitian matrix A.  Since the matrix A is
-     hermitian only its upper half or lower half need to be stored.
-     When UPLO is `CblasUpper' then the upper triangle and diagonal of
-     A are used, and when UPLO is `CblasLower' then the lower triangle
-     and diagonal of A are used.  The imaginary elements of the
-     diagonal are automatically set to zero.
+     x^H + A of the hermitian matrix A.  Since the matrix A is hermitian
+     only its upper half or lower half need to be stored.  When UPLO is
+     'CblasUpper' then the upper triangle and diagonal of A are used,
+     and when UPLO is 'CblasLower' then the lower triangle and diagonal
+     of A are used.  The imaginary elements of the diagonal are
+     automatically set to zero.
 
  -- Function: int gsl_blas_ssyr2 (CBLAS_UPLO_t UPLO, float ALPHA, const
           gsl_vector_float * X, const gsl_vector_float * Y,
           gsl_matrix_float * A)
- -- Function: int gsl_blas_dsyr2 (CBLAS_UPLO_t UPLO, double ALPHA,
-          const gsl_vector * X, const gsl_vector * Y, gsl_matrix * A)
+ -- Function: int gsl_blas_dsyr2 (CBLAS_UPLO_t UPLO, double ALPHA, const
+          gsl_vector * X, const gsl_vector * Y, gsl_matrix * A)
      These functions compute the symmetric rank-2 update A = \alpha x
-     y^T + \alpha y x^T + A of the symmetric matrix A.  Since the
-     matrix A is symmetric only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of A are used, and when UPLO is `CblasLower' then the
-     lower triangle and diagonal of A are used.
+     y^T + \alpha y x^T + A of the symmetric matrix A.  Since the matrix
+     A is symmetric only its upper half or lower half need to be stored.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.
 
  -- Function: int gsl_blas_cher2 (CBLAS_UPLO_t UPLO, const
           gsl_complex_float ALPHA, const gsl_vector_complex_float * X,
-          const gsl_vector_complex_float * Y, gsl_matrix_complex_float
-          * A)
+          const gsl_vector_complex_float * Y, gsl_matrix_complex_float *
+          A)
  -- Function: int gsl_blas_zher2 (CBLAS_UPLO_t UPLO, const gsl_complex
           ALPHA, const gsl_vector_complex * X, const gsl_vector_complex
           * Y, gsl_matrix_complex * A)
      These functions compute the hermitian rank-2 update A = \alpha x
-     y^H + \alpha^* y x^H A of the hermitian matrix A.  Since the
-     matrix A is hermitian only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of A are used, and when UPLO is `CblasLower' then the
-     lower triangle and diagonal of A are used.  The imaginary elements
-     of the diagonal are automatically set to zero.
+     y^H + \alpha^* y x^H A of the hermitian matrix A.  Since the matrix
+     A is hermitian only its upper half or lower half need to be stored.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.  The imaginary elements of the diagonal are
+     automatically set to zero.
 
 
 File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS Interface,  Up: GSL BLAS Interface
@@ -682,17 +659,16 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           CBLAS_TRANSPOSE_t TRANSB, double ALPHA, const gsl_matrix * A,
           const gsl_matrix * B, double BETA, gsl_matrix * C)
  -- Function: int gsl_blas_cgemm (CBLAS_TRANSPOSE_t TRANSA,
-          CBLAS_TRANSPOSE_t TRANSB, const gsl_complex_float ALPHA,
-          const gsl_matrix_complex_float * A, const
-          gsl_matrix_complex_float * B, const gsl_complex_float BETA,
-          gsl_matrix_complex_float * C)
+          CBLAS_TRANSPOSE_t TRANSB, const gsl_complex_float ALPHA, const
+          gsl_matrix_complex_float * A, const gsl_matrix_complex_float *
+          B, const gsl_complex_float BETA, gsl_matrix_complex_float * C)
  -- Function: int gsl_blas_zgemm (CBLAS_TRANSPOSE_t TRANSA,
           CBLAS_TRANSPOSE_t TRANSB, const gsl_complex ALPHA, const
           gsl_matrix_complex * A, const gsl_matrix_complex * B, const
           gsl_complex BETA, gsl_matrix_complex * C)
      These functions compute the matrix-matrix product and sum C =
-     \alpha op(A) op(B) + \beta C where op(A) = A, A^T, A^H for TRANSA
-     = `CblasNoTrans', `CblasTrans', `CblasConjTrans' and similarly for
+     \alpha op(A) op(B) + \beta C where op(A) = A, A^T, A^H for TRANSA =
+     'CblasNoTrans', 'CblasTrans', 'CblasConjTrans' and similarly for
      the parameter TRANSB.
 
  -- Function: int gsl_blas_ssymm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
@@ -710,11 +686,11 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           gsl_matrix_complex * B, const gsl_complex BETA,
           gsl_matrix_complex * C)
      These functions compute the matrix-matrix product and sum C =
-     \alpha A B + \beta C for SIDE is `CblasLeft' and C = \alpha B A +
-     \beta C for SIDE is `CblasRight', where the matrix A is symmetric.
-     When UPLO is `CblasUpper' then the upper triangle and diagonal of
-     A are used, and when UPLO is `CblasLower' then the lower triangle
-     and diagonal of A are used.
+     \alpha A B + \beta C for SIDE is 'CblasLeft' and C = \alpha B A +
+     \beta C for SIDE is 'CblasRight', where the matrix A is symmetric.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.
 
  -- Function: int gsl_blas_chemm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
           const gsl_complex_float ALPHA, const gsl_matrix_complex_float
@@ -725,12 +701,12 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           gsl_matrix_complex * B, const gsl_complex BETA,
           gsl_matrix_complex * C)
      These functions compute the matrix-matrix product and sum C =
-     \alpha A B + \beta C for SIDE is `CblasLeft' and C = \alpha B A +
-     \beta C for SIDE is `CblasRight', where the matrix A is hermitian.
-     When UPLO is `CblasUpper' then the upper triangle and diagonal of
-     A are used, and when UPLO is `CblasLower' then the lower triangle
-     and diagonal of A are used.  The imaginary elements of the
-     diagonal are automatically set to zero.
+     \alpha A B + \beta C for SIDE is 'CblasLeft' and C = \alpha B A +
+     \beta C for SIDE is 'CblasRight', where the matrix A is hermitian.
+     When UPLO is 'CblasUpper' then the upper triangle and diagonal of A
+     are used, and when UPLO is 'CblasLower' then the lower triangle and
+     diagonal of A are used.  The imaginary elements of the diagonal are
+     automatically set to zero.
 
  -- Function: int gsl_blas_strmm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
           CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, float ALPHA,
@@ -743,18 +719,17 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           gsl_complex_float ALPHA, const gsl_matrix_complex_float * A,
           gsl_matrix_complex_float * B)
  -- Function: int gsl_blas_ztrmm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
-          CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, const
-          gsl_complex ALPHA, const gsl_matrix_complex * A,
-          gsl_matrix_complex * B)
+          CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, const gsl_complex
+          ALPHA, const gsl_matrix_complex * A, gsl_matrix_complex * B)
      These functions compute the matrix-matrix product B = \alpha op(A)
-     B for SIDE is `CblasLeft' and B = \alpha B op(A) for SIDE is
-     `CblasRight'.  The matrix A is triangular and op(A) = A, A^T, A^H
-     for TRANSA = `CblasNoTrans', `CblasTrans', `CblasConjTrans'. When
-     UPLO is `CblasUpper' then the upper triangle of A is used, and
-     when UPLO is `CblasLower' then the lower triangle of A is used.
-     If DIAG is `CblasNonUnit' then the diagonal of A is used, but if
-     DIAG is `CblasUnit' then the diagonal elements of the matrix A are
-     taken as unity and are not referenced.
+     B for SIDE is 'CblasLeft' and B = \alpha B op(A) for SIDE is
+     'CblasRight'.  The matrix A is triangular and op(A) = A, A^T, A^H
+     for TRANSA = 'CblasNoTrans', 'CblasTrans', 'CblasConjTrans'.  When
+     UPLO is 'CblasUpper' then the upper triangle of A is used, and when
+     UPLO is 'CblasLower' then the lower triangle of A is used.  If DIAG
+     is 'CblasNonUnit' then the diagonal of A is used, but if DIAG is
+     'CblasUnit' then the diagonal elements of the matrix A are taken as
+     unity and are not referenced.
 
  -- Function: int gsl_blas_strsm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
           CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, float ALPHA,
@@ -767,19 +742,17 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           gsl_complex_float ALPHA, const gsl_matrix_complex_float * A,
           gsl_matrix_complex_float * B)
  -- Function: int gsl_blas_ztrsm (CBLAS_SIDE_t SIDE, CBLAS_UPLO_t UPLO,
-          CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, const
-          gsl_complex ALPHA, const gsl_matrix_complex * A,
-          gsl_matrix_complex * B)
+          CBLAS_TRANSPOSE_t TRANSA, CBLAS_DIAG_t DIAG, const gsl_complex
+          ALPHA, const gsl_matrix_complex * A, gsl_matrix_complex * B)
      These functions compute the inverse-matrix matrix product B =
-     \alpha op(inv(A))B for SIDE is `CblasLeft' and B = \alpha B
-     op(inv(A)) for SIDE is `CblasRight'.  The matrix A is triangular
-     and op(A) = A, A^T, A^H for TRANSA = `CblasNoTrans', `CblasTrans',
-     `CblasConjTrans'. When UPLO is `CblasUpper' then the upper
-     triangle of A is used, and when UPLO is `CblasLower' then the
-     lower triangle of A is used.  If DIAG is `CblasNonUnit' then the
-     diagonal of A is used, but if DIAG is `CblasUnit' then the
-     diagonal elements of the matrix A are taken as unity and are not
-     referenced.
+     \alpha op(inv(A))B for SIDE is 'CblasLeft' and B = \alpha B
+     op(inv(A)) for SIDE is 'CblasRight'.  The matrix A is triangular
+     and op(A) = A, A^T, A^H for TRANSA = 'CblasNoTrans', 'CblasTrans',
+     'CblasConjTrans'.  When UPLO is 'CblasUpper' then the upper
+     triangle of A is used, and when UPLO is 'CblasLower' then the lower
+     triangle of A is used.  If DIAG is 'CblasNonUnit' then the diagonal
+     of A is used, but if DIAG is 'CblasUnit' then the diagonal elements
+     of the matrix A are taken as unity and are not referenced.
 
  -- Function: int gsl_blas_ssyrk (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANS, float ALPHA, const gsl_matrix_float * A, float BETA,
@@ -795,11 +768,11 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           TRANS, const gsl_complex ALPHA, const gsl_matrix_complex * A,
           const gsl_complex BETA, gsl_matrix_complex * C)
      These functions compute a rank-k update of the symmetric matrix C,
-     C = \alpha A A^T + \beta C when TRANS is `CblasNoTrans' and C =
-     \alpha A^T A + \beta C when TRANS is `CblasTrans'.  Since the
+     C = \alpha A A^T + \beta C when TRANS is 'CblasNoTrans' and C =
+     \alpha A^T A + \beta C when TRANS is 'CblasTrans'.  Since the
      matrix C is symmetric only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of C are used, and when UPLO is `CblasLower' then the
+     stored.  When UPLO is 'CblasUpper' then the upper triangle and
+     diagonal of C are used, and when UPLO is 'CblasLower' then the
      lower triangle and diagonal of C are used.
 
  -- Function: int gsl_blas_cherk (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
@@ -809,11 +782,11 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           TRANS, double ALPHA, const gsl_matrix_complex * A, double
           BETA, gsl_matrix_complex * C)
      These functions compute a rank-k update of the hermitian matrix C,
-     C = \alpha A A^H + \beta C when TRANS is `CblasNoTrans' and C =
-     \alpha A^H A + \beta C when TRANS is `CblasTrans'.  Since the
+     C = \alpha A A^H + \beta C when TRANS is 'CblasNoTrans' and C =
+     \alpha A^H A + \beta C when TRANS is 'CblasTrans'.  Since the
      matrix C is hermitian only its upper half or lower half need to be
-     stored.  When UPLO is `CblasUpper' then the upper triangle and
-     diagonal of C are used, and when UPLO is `CblasLower' then the
+     stored.  When UPLO is 'CblasUpper' then the upper triangle and
+     diagonal of C are used, and when UPLO is 'CblasLower' then the
      lower triangle and diagonal of C are used.  The imaginary elements
      of the diagonal are automatically set to zero.
 
@@ -825,37 +798,36 @@ File: gsl-ref.info,  Node: Level 3 GSL BLAS Interface,  Prev: Level 2 GSL BLAS I
           B, double BETA, gsl_matrix * C)
  -- Function: int gsl_blas_csyr2k (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANS, const gsl_complex_float ALPHA, const
-          gsl_matrix_complex_float * A, const gsl_matrix_complex_float
-          * B, const gsl_complex_float BETA, gsl_matrix_complex_float *
-          C)
+          gsl_matrix_complex_float * A, const gsl_matrix_complex_float *
+          B, const gsl_complex_float BETA, gsl_matrix_complex_float * C)
  -- Function: int gsl_blas_zsyr2k (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANS, const gsl_complex ALPHA, const gsl_matrix_complex * A,
           const gsl_matrix_complex * B, const gsl_complex BETA,
           gsl_matrix_complex * C)
      These functions compute a rank-2k update of the symmetric matrix C,
      C = \alpha A B^T + \alpha B A^T + \beta C when TRANS is
-     `CblasNoTrans' and C = \alpha A^T B + \alpha B^T A + \beta C when
-     TRANS is `CblasTrans'.  Since the matrix C is symmetric only its
+     'CblasNoTrans' and C = \alpha A^T B + \alpha B^T A + \beta C when
+     TRANS is 'CblasTrans'.  Since the matrix C is symmetric only its
      upper half or lower half need to be stored.  When UPLO is
-     `CblasUpper' then the upper triangle and diagonal of C are used,
-     and when UPLO is `CblasLower' then the lower triangle and diagonal
+     'CblasUpper' then the upper triangle and diagonal of C are used,
+     and when UPLO is 'CblasLower' then the lower triangle and diagonal
      of C are used.
 
  -- Function: int gsl_blas_cher2k (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANS, const gsl_complex_float ALPHA, const
-          gsl_matrix_complex_float * A, const gsl_matrix_complex_float
-          * B, float BETA, gsl_matrix_complex_float * C)
+          gsl_matrix_complex_float * A, const gsl_matrix_complex_float *
+          B, float BETA, gsl_matrix_complex_float * C)
  -- Function: int gsl_blas_zher2k (CBLAS_UPLO_t UPLO, CBLAS_TRANSPOSE_t
           TRANS, const gsl_complex ALPHA, const gsl_matrix_complex * A,
           const gsl_matrix_complex * B, double BETA, gsl_matrix_complex
           * C)
      These functions compute a rank-2k update of the hermitian matrix C,
      C = \alpha A B^H + \alpha^* B A^H + \beta C when TRANS is
-     `CblasNoTrans' and C = \alpha A^H B + \alpha^* B^H A + \beta C when
-     TRANS is `CblasConjTrans'.  Since the matrix C is hermitian only
+     'CblasNoTrans' and C = \alpha A^H B + \alpha^* B^H A + \beta C when
+     TRANS is 'CblasConjTrans'.  Since the matrix C is hermitian only
      its upper half or lower half need to be stored.  When UPLO is
-     `CblasUpper' then the upper triangle and diagonal of C are used,
-     and when UPLO is `CblasLower' then the lower triangle and diagonal
+     'CblasUpper' then the upper triangle and diagonal of C are used,
+     and when UPLO is 'CblasLower' then the lower triangle and diagonal
      of C are used.  The imaginary elements of the diagonal are
      automatically set to zero.
 
@@ -920,33 +892,31 @@ File: gsl-ref.info,  Node: BLAS References and Further Reading,  Prev: BLAS Exam
 ===================================
 
 Information on the BLAS standards, including both the legacy and draft
-interface standards, is available online from the BLAS Homepage and
-BLAS Technical Forum web-site.
+interface standards, is available online from the BLAS Homepage and BLAS
+Technical Forum web-site.
 
-     `BLAS Homepage'
-     `http://www.netlib.org/blas/'
-
-     `BLAS Technical Forum'
-     `http://www.netlib.org/cgi-bin/checkout/blast/blast.pl'
+     'BLAS Homepage'
+     <http://www.netlib.org/blas/>
+     'BLAS Technical Forum'
+     <http://www.netlib.org/cgi-bin/checkout/blast/blast.pl>
 
 The following papers contain the specifications for Level 1, Level 2 and
 Level 3 BLAS.
 
      C. Lawson, R. Hanson, D. Kincaid, F. Krogh, "Basic Linear Algebra
-     Subprograms for Fortran Usage", `ACM Transactions on Mathematical
+     Subprograms for Fortran Usage", 'ACM Transactions on Mathematical
      Software', Vol. 5 (1979), Pages 308-325.
 
      J.J. Dongarra, J. DuCroz, S. Hammarling, R. Hanson, "An Extended
-     Set of Fortran Basic Linear Algebra Subprograms", `ACM
-     Transactions on Mathematical Software', Vol. 14, No. 1 (1988),
-     Pages 1-32.
+     Set of Fortran Basic Linear Algebra Subprograms", 'ACM Transactions
+     on Mathematical Software', Vol. 14, No. 1 (1988), Pages 1-32.
 
-     J.J. Dongarra, I. Duff, J. DuCroz, S. Hammarling, "A Set of Level
-     3 Basic Linear Algebra Subprograms", `ACM Transactions on
+     J.J. Dongarra, I. Duff, J. DuCroz, S. Hammarling, "A Set of Level 3
+     Basic Linear Algebra Subprograms", 'ACM Transactions on
      Mathematical Software', Vol. 16 (1990), Pages 1-28.
 
 Postscript versions of the latter two papers are available from
-`http://www.netlib.org/blas/'. A CBLAS wrapper for Fortran BLAS
+<http://www.netlib.org/blas/>.  A CBLAS wrapper for Fortran BLAS
 libraries is available from the same location.
 
 
@@ -956,34 +926,34 @@ File: gsl-ref.info,  Node: Linear Algebra,  Next: Eigensystems,  Prev: BLAS Supp
 *****************
 
 This chapter describes functions for solving linear systems.  The
-library provides linear algebra operations which operate directly on
-the `gsl_vector' and `gsl_matrix' objects.  These routines use the
-standard algorithms from Golub & Van Loan's `Matrix Computations'.
+library provides linear algebra operations which operate directly on the
+'gsl_vector' and 'gsl_matrix' objects.  These routines use the standard
+algorithms from Golub & Van Loan's 'Matrix Computations'.
 
    When dealing with very large systems the routines found in LAPACK
 should be considered.  These support specialized data representations
 and other optimizations.
 
    The functions described in this chapter are declared in the header
-file `gsl_linalg.h'.
+file 'gsl_linalg.h'.
 
 * Menu:
 
-* LU Decomposition::
-* QR Decomposition::
-* QR Decomposition with Column Pivoting::
-* Singular Value Decomposition::
-* Cholesky Decomposition::
-* Tridiagonal Decomposition of Real Symmetric Matrices::
-* Tridiagonal Decomposition of Hermitian Matrices::
+* LU Decomposition::            
+* QR Decomposition::            
+* QR Decomposition with Column Pivoting::  
+* Singular Value Decomposition::  
+* Cholesky Decomposition::      
+* Tridiagonal Decomposition of Real Symmetric Matrices::  
+* Tridiagonal Decomposition of Hermitian Matrices::  
 * Hessenberg Decomposition of Real Matrices::
-* Bidiagonalization::
-* Householder Transformations::
-* Householder solver for linear systems::
-* Tridiagonal Systems::
+* Bidiagonalization::           
+* Householder Transformations::  
+* Householder solver for linear systems::  
+* Tridiagonal Systems::         
 * Balancing::
-* Linear Algebra Examples::
-* Linear Algebra References and Further Reading::
+* Linear Algebra Examples::     
+* Linear Algebra References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: LU Decomposition,  Next: QR Decomposition,  Up: Linear Algebra
@@ -996,68 +966,67 @@ triangular matrices,
 
      P A = L U
 
-where P is a permutation matrix, L is unit lower triangular matrix and
-U is upper triangular matrix. For square matrices this decomposition
-can be used to convert the linear system A x = b into a pair of
-triangular systems (L y = P b, U x = y), which can be solved by forward
-and back-substitution.  Note that the LU decomposition is valid for
-singular matrices.
+where P is a permutation matrix, L is unit lower triangular matrix and U
+is upper triangular matrix.  For square matrices this decomposition can
+be used to convert the linear system A x = b into a pair of triangular
+systems (L y = P b, U x = y), which can be solved by forward and
+back-substitution.  Note that the LU decomposition is valid for singular
+matrices.
 
  -- Function: int gsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation
           * P, int * SIGNUM)
  -- Function: int gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A,
           gsl_permutation * P, int * SIGNUM)
      These functions factorize the square matrix A into the LU
-     decomposition PA = LU.  On output the diagonal and upper
-     triangular part of the input matrix A contain the matrix U. The
-     lower triangular part of the input matrix (excluding the diagonal)
+     decomposition PA = LU.  On output the diagonal and upper triangular
+     part of the input matrix A contain the matrix U.  The lower
+     triangular part of the input matrix (excluding the diagonal)
      contains L.  The diagonal elements of L are unity, and are not
      stored.
 
-     The permutation matrix P is encoded in the permutation P. The j-th
+     The permutation matrix P is encoded in the permutation P.  The j-th
      column of the matrix P is given by the k-th column of the identity
      matrix, where k = p_j the j-th element of the permutation vector.
-     The sign of the permutation is given by SIGNUM. It has the value
+     The sign of the permutation is given by SIGNUM.  It has the value
      (-1)^n, where n is the number of interchanges in the permutation.
 
      The algorithm used in the decomposition is Gaussian Elimination
-     with partial pivoting (Golub & Van Loan, `Matrix Computations',
+     with partial pivoting (Golub & Van Loan, 'Matrix Computations',
      Algorithm 3.4.1).
 
  -- Function: int gsl_linalg_LU_solve (const gsl_matrix * LU, const
           gsl_permutation * P, const gsl_vector * B, gsl_vector * X)
  -- Function: int gsl_linalg_complex_LU_solve (const gsl_matrix_complex
-          * LU, const gsl_permutation * P, const gsl_vector_complex *
-          B, gsl_vector_complex * X)
+          * LU, const gsl_permutation * P, const gsl_vector_complex * B,
+          gsl_vector_complex * X)
      These functions solve the square system A x = b using the LU
-     decomposition of A into (LU, P) given by `gsl_linalg_LU_decomp' or
-     `gsl_linalg_complex_LU_decomp'.
+     decomposition of A into (LU, P) given by 'gsl_linalg_LU_decomp' or
+     'gsl_linalg_complex_LU_decomp'.
 
  -- Function: int gsl_linalg_LU_svx (const gsl_matrix * LU, const
           gsl_permutation * P, gsl_vector * X)
  -- Function: int gsl_linalg_complex_LU_svx (const gsl_matrix_complex *
           LU, const gsl_permutation * P, gsl_vector_complex * X)
      These functions solve the square system A x = b in-place using the
-     LU decomposition of A into (LU,P). On input X should contain the
+     LU decomposition of A into (LU,P).  On input X should contain the
      right-hand side b, which is replaced by the solution on output.
 
  -- Function: int gsl_linalg_LU_refine (const gsl_matrix * A, const
-          gsl_matrix * LU, const gsl_permutation * P, const gsl_vector
-          * B, gsl_vector * X, gsl_vector * RESIDUAL)
- -- Function: int gsl_linalg_complex_LU_refine (const
-          gsl_matrix_complex * A, const gsl_matrix_complex * LU, const
-          gsl_permutation * P, const gsl_vector_complex * B,
-          gsl_vector_complex * X, gsl_vector_complex * RESIDUAL)
+          gsl_matrix * LU, const gsl_permutation * P, const gsl_vector *
+          B, gsl_vector * X, gsl_vector * RESIDUAL)
+ -- Function: int gsl_linalg_complex_LU_refine (const gsl_matrix_complex
+          * A, const gsl_matrix_complex * LU, const gsl_permutation * P,
+          const gsl_vector_complex * B, gsl_vector_complex * X,
+          gsl_vector_complex * RESIDUAL)
      These functions apply an iterative improvement to X, the solution
-     of A x = b, using the LU decomposition of A into (LU,P). The
+     of A x = b, using the LU decomposition of A into (LU,P).  The
      initial residual r = A x - b is also computed and stored in
      RESIDUAL.
 
  -- Function: int gsl_linalg_LU_invert (const gsl_matrix * LU, const
           gsl_permutation * P, gsl_matrix * INVERSE)
- -- Function: int gsl_linalg_complex_LU_invert (const
-          gsl_matrix_complex * LU, const gsl_permutation * P,
-          gsl_matrix_complex * INVERSE)
+ -- Function: int gsl_linalg_complex_LU_invert (const gsl_matrix_complex
+          * LU, const gsl_permutation * P, gsl_matrix_complex * INVERSE)
      These functions compute the inverse of a matrix A from its LU
      decomposition (LU,P), storing the result in the matrix INVERSE.
      The inverse is computed by solving the system A x = b for each
@@ -1071,7 +1040,7 @@ singular matrices.
  -- Function: gsl_complex gsl_linalg_complex_LU_det (gsl_matrix_complex
           * LU, int SIGNUM)
      These functions compute the determinant of a matrix A from its LU
-     decomposition, LU. The determinant is computed as the product of
+     decomposition, LU.  The determinant is computed as the product of
      the diagonal elements of U and the sign of the row permutation
      SIGNUM.
 
@@ -1079,16 +1048,15 @@ singular matrices.
  -- Function: double gsl_linalg_complex_LU_lndet (gsl_matrix_complex *
           LU)
      These functions compute the logarithm of the absolute value of the
-     determinant of a matrix A, \ln|\det(A)|, from its LU
-     decomposition, LU.  This function may be useful if the direct
-     computation of the determinant would overflow or underflow.
+     determinant of a matrix A, \ln|\det(A)|, from its LU decomposition,
+     LU.  This function may be useful if the direct computation of the
+     determinant would overflow or underflow.
 
  -- Function: int gsl_linalg_LU_sgndet (gsl_matrix * LU, int SIGNUM)
  -- Function: gsl_complex gsl_linalg_complex_LU_sgndet
           (gsl_matrix_complex * LU, int SIGNUM)
-     These functions compute the sign or phase factor of the
-     determinant of a matrix A, \det(A)/|\det(A)|, from its LU
-     decomposition, LU.
+     These functions compute the sign or phase factor of the determinant
+     of a matrix A, \det(A)/|\det(A)|, from its LU decomposition, LU.
 
 
 File: gsl-ref.info,  Node: QR Decomposition,  Next: QR Decomposition with Column Pivoting,  Prev: LU Decomposition,  Up: Linear Algebra
@@ -1097,47 +1065,46 @@ File: gsl-ref.info,  Node: QR Decomposition,  Next: QR Decomposition with Column
 =====================
 
 A general rectangular M-by-N matrix A has a QR decomposition into the
-product of an orthogonal M-by-M square matrix Q (where Q^T Q = I) and
-an M-by-N right-triangular matrix R,
+product of an orthogonal M-by-M square matrix Q (where Q^T Q = I) and an
+M-by-N right-triangular matrix R,
 
      A = Q R
 
-This decomposition can be used to convert the linear system A x = b
-into the triangular system R x = Q^T b, which can be solved by
-back-substitution. Another use of the QR decomposition is to compute an
-orthonormal basis for a set of vectors. The first N columns of Q form
+This decomposition can be used to convert the linear system A x = b into
+the triangular system R x = Q^T b, which can be solved by
+back-substitution.  Another use of the QR decomposition is to compute an
+orthonormal basis for a set of vectors.  The first N columns of Q form
 an orthonormal basis for the range of A, ran(A), when A has full column
 rank.
 
  -- Function: int gsl_linalg_QR_decomp (gsl_matrix * A, gsl_vector *
           TAU)
      This function factorizes the M-by-N matrix A into the QR
-     decomposition A = Q R.  On output the diagonal and upper
-     triangular part of the input matrix contain the matrix R. The
-     vector TAU and the columns of the lower triangular part of the
-     matrix A contain the Householder coefficients and Householder
-     vectors which encode the orthogonal matrix Q.  The vector TAU must
-     be of length k=\min(M,N). The matrix Q is related to these
-     components by, Q = Q_k ... Q_2 Q_1 where Q_i = I - \tau_i v_i
-     v_i^T and v_i is the Householder vector v_i =
-     (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)). This is the same storage
-     scheme as used by LAPACK.
+     decomposition A = Q R.  On output the diagonal and upper triangular
+     part of the input matrix contain the matrix R.  The vector TAU and
+     the columns of the lower triangular part of the matrix A contain
+     the Householder coefficients and Householder vectors which encode
+     the orthogonal matrix Q.  The vector TAU must be of length
+     k=\min(M,N).  The matrix Q is related to these components by, Q =
+     Q_k ... Q_2 Q_1 where Q_i = I - \tau_i v_i v_i^T and v_i is the
+     Householder vector v_i = (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)).
+     This is the same storage scheme as used by LAPACK.
 
      The algorithm used to perform the decomposition is Householder QR
-     (Golub & Van Loan, `Matrix Computations', Algorithm 5.2.1).
+     (Golub & Van Loan, 'Matrix Computations', Algorithm 5.2.1).
 
  -- Function: int gsl_linalg_QR_solve (const gsl_matrix * QR, const
           gsl_vector * TAU, const gsl_vector * B, gsl_vector * X)
      This function solves the square system A x = b using the QR
-     decomposition of A into (QR, TAU) given by `gsl_linalg_QR_decomp'.
+     decomposition of A into (QR, TAU) given by 'gsl_linalg_QR_decomp'.
      The least-squares solution for rectangular systems can be found
-     using `gsl_linalg_QR_lssolve'.
+     using 'gsl_linalg_QR_lssolve'.
 
  -- Function: int gsl_linalg_QR_svx (const gsl_matrix * QR, const
           gsl_vector * TAU, gsl_vector * X)
      This function solves the square system A x = b in-place using the
      QR decomposition of A into (QR,TAU) given by
-     `gsl_linalg_QR_decomp'. On input X should contain the right-hand
+     'gsl_linalg_QR_decomp'.  On input X should contain the right-hand
      side b, which is replaced by the solution on output.
 
  -- Function: int gsl_linalg_QR_lssolve (const gsl_matrix * QR, const
@@ -1147,7 +1114,7 @@ rank.
      overdetermined system A x = b where the matrix A has more rows than
      columns.  The least squares solution minimizes the Euclidean norm
      of the residual, ||Ax - b||.The routine uses the QR decomposition
-     of A into (QR, TAU) given by `gsl_linalg_QR_decomp'.  The solution
+     of A into (QR, TAU) given by 'gsl_linalg_QR_decomp'.  The solution
      is returned in X.  The residual is computed as a by-product and
      stored in RESIDUAL.
 
@@ -1155,8 +1122,8 @@ rank.
           gsl_vector * TAU, gsl_vector * V)
      This function applies the matrix Q^T encoded in the decomposition
      (QR,TAU) to the vector V, storing the result Q^T v in V.  The
-     matrix multiplication is carried out directly using the encoding
-     of the Householder vectors without needing to form the full matrix
+     matrix multiplication is carried out directly using the encoding of
+     the Householder vectors without needing to form the full matrix
      Q^T.
 
  -- Function: int gsl_linalg_QR_Qvec (const gsl_matrix * QR, const
@@ -1168,34 +1135,34 @@ rank.
 
  -- Function: int gsl_linalg_QR_Rsolve (const gsl_matrix * QR, const
           gsl_vector * B, gsl_vector * X)
-     This function solves the triangular system R x = b for X. It may
-     be useful if the product b' = Q^T b has already been computed
-     using `gsl_linalg_QR_QTvec'.
+     This function solves the triangular system R x = b for X.  It may
+     be useful if the product b' = Q^T b has already been computed using
+     'gsl_linalg_QR_QTvec'.
 
  -- Function: int gsl_linalg_QR_Rsvx (const gsl_matrix * QR, gsl_vector
           * X)
      This function solves the triangular system R x = b for X in-place.
      On input X should contain the right-hand side b and is replaced by
-     the solution on output. This function may be useful if the product
-     b' = Q^T b has already been computed using `gsl_linalg_QR_QTvec'.
+     the solution on output.  This function may be useful if the product
+     b' = Q^T b has already been computed using 'gsl_linalg_QR_QTvec'.
 
  -- Function: int gsl_linalg_QR_unpack (const gsl_matrix * QR, const
           gsl_vector * TAU, gsl_matrix * Q, gsl_matrix * R)
      This function unpacks the encoded QR decomposition (QR,TAU) into
      the matrices Q and R, where Q is M-by-M and R is M-by-N.
 
- -- Function: int gsl_linalg_QR_QRsolve (gsl_matrix * Q, gsl_matrix *
-          R, const gsl_vector * B, gsl_vector * X)
-     This function solves the system R x = Q^T b for X. It can be used
-     when the QR decomposition of a matrix is available in unpacked
-     form as (Q, R).
+ -- Function: int gsl_linalg_QR_QRsolve (gsl_matrix * Q, gsl_matrix * R,
+          const gsl_vector * B, gsl_vector * X)
+     This function solves the system R x = Q^T b for X.  It can be used
+     when the QR decomposition of a matrix is available in unpacked form
+     as (Q, R).
 
  -- Function: int gsl_linalg_QR_update (gsl_matrix * Q, gsl_matrix * R,
           gsl_vector * W, const gsl_vector * V)
      This function performs a rank-1 update w v^T of the QR
-     decomposition (Q, R). The update is given by Q'R' = Q R + w v^T
+     decomposition (Q, R).  The update is given by Q'R' = Q R + w v^T
      where the output matrices Q' and R' are also orthogonal and right
-     triangular. Note that W is destroyed by the update.
+     triangular.  Note that W is destroyed by the update.
 
  -- Function: int gsl_linalg_R_solve (const gsl_matrix * R, const
           gsl_vector * B, gsl_vector * X)
@@ -1204,7 +1171,7 @@ rank.
 
  -- Function: int gsl_linalg_R_svx (const gsl_matrix * R, gsl_vector *
           X)
-     This function solves the triangular system R x = b in-place. On
+     This function solves the triangular system R x = b in-place.  On
      input X should contain the right-hand side b, which is replaced by
      the solution on output.
 
@@ -1220,31 +1187,31 @@ introducing a column permutation P,
      A P = Q R
 
 The first r columns of Q form an orthonormal basis for the range of A
-for a matrix with column rank r.  This decomposition can also be used
-to convert the linear system A x = b into the triangular system R y =
-Q^T b, x = P y, which can be solved by back-substitution and
-permutation.  We denote the QR decomposition with column pivoting by
-QRP^T since A = Q R P^T.
+for a matrix with column rank r.  This decomposition can also be used to
+convert the linear system A x = b into the triangular system R y = Q^T
+b, x = P y, which can be solved by back-substitution and permutation.
+We denote the QR decomposition with column pivoting by QRP^T since A = Q
+R P^T.
 
  -- Function: int gsl_linalg_QRPT_decomp (gsl_matrix * A, gsl_vector *
           TAU, gsl_permutation * P, int * SIGNUM, gsl_vector * NORM)
      This function factorizes the M-by-N matrix A into the QRP^T
      decomposition A = Q R P^T.  On output the diagonal and upper
-     triangular part of the input matrix contain the matrix R. The
+     triangular part of the input matrix contain the matrix R.  The
      permutation matrix P is stored in the permutation P.  The sign of
-     the permutation is given by SIGNUM. It has the value (-1)^n, where
-     n is the number of interchanges in the permutation. The vector TAU
+     the permutation is given by SIGNUM.  It has the value (-1)^n, where
+     n is the number of interchanges in the permutation.  The vector TAU
      and the columns of the lower triangular part of the matrix A
      contain the Householder coefficients and vectors which encode the
-     orthogonal matrix Q.  The vector TAU must be of length
-     k=\min(M,N). The matrix Q is related to these components by, Q =
-     Q_k ... Q_2 Q_1 where Q_i = I - \tau_i v_i v_i^T and v_i is the
-     Householder vector v_i = (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)).
-     This is the same storage scheme as used by LAPACK.  The vector
-     NORM is a workspace of length N used for column pivoting.
+     orthogonal matrix Q.  The vector TAU must be of length k=\min(M,N).
+     The matrix Q is related to these components by, Q = Q_k ... Q_2 Q_1
+     where Q_i = I - \tau_i v_i v_i^T and v_i is the Householder vector
+     v_i = (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)).  This is the same
+     storage scheme as used by LAPACK.  The vector NORM is a workspace
+     of length N used for column pivoting.
 
      The algorithm used to perform the decomposition is Householder QR
-     with column pivoting (Golub & Van Loan, `Matrix Computations',
+     with column pivoting (Golub & Van Loan, 'Matrix Computations',
      Algorithm 5.4.1).
 
  -- Function: int gsl_linalg_QRPT_decomp2 (const gsl_matrix * A,
@@ -1259,29 +1226,29 @@ QRP^T since A = Q R P^T.
           * B, gsl_vector * X)
      This function solves the square system A x = b using the QRP^T
      decomposition of A into (QR, TAU, P) given by
-     `gsl_linalg_QRPT_decomp'.
+     'gsl_linalg_QRPT_decomp'.
 
  -- Function: int gsl_linalg_QRPT_svx (const gsl_matrix * QR, const
           gsl_vector * TAU, const gsl_permutation * P, gsl_vector * X)
      This function solves the square system A x = b in-place using the
-     QRP^T decomposition of A into (QR,TAU,P). On input X should
-     contain the right-hand side b, which is replaced by the solution
-     on output.
+     QRP^T decomposition of A into (QR,TAU,P).  On input X should
+     contain the right-hand side b, which is replaced by the solution on
+     output.
 
  -- Function: int gsl_linalg_QRPT_QRsolve (const gsl_matrix * Q, const
           gsl_matrix * R, const gsl_permutation * P, const gsl_vector *
           B, gsl_vector * X)
-     This function solves the square system R P^T x = Q^T b for X. It
+     This function solves the square system R P^T x = Q^T b for X.  It
      can be used when the QR decomposition of a matrix is available in
      unpacked form as (Q, R).
 
  -- Function: int gsl_linalg_QRPT_update (gsl_matrix * Q, gsl_matrix *
-          R, const gsl_permutation * P, gsl_vector * U, const
-          gsl_vector * V)
+          R, const gsl_permutation * P, gsl_vector * U, const gsl_vector
+          * V)
      This function performs a rank-1 update w v^T of the QRP^T
-     decomposition (Q, R, P). The update is given by Q'R' = Q R + w v^T
+     decomposition (Q, R, P).  The update is given by Q'R' = Q R + w v^T
      where the output matrices Q' and R' are also orthogonal and right
-     triangular. Note that W is destroyed by the update. The
+     triangular.  Note that W is destroyed by the update.  The
      permutation P is not changed.
 
  -- Function: int gsl_linalg_QRPT_Rsolve (const gsl_matrix * QR, const
@@ -1291,9 +1258,9 @@ QRP^T since A = Q R P^T.
 
  -- Function: int gsl_linalg_QRPT_Rsvx (const gsl_matrix * QR, const
           gsl_permutation * P, gsl_vector * X)
-     This function solves the triangular system R P^T x = b in-place
-     for the N-by-N matrix R contained in QR. On input X should contain
-     the right-hand side b, which is replaced by the solution on output.
+     This function solves the triangular system R P^T x = b in-place for
+     the N-by-N matrix R contained in QR.  On input X should contain the
+     right-hand side b, which is replaced by the solution on output.
 
 
 File: gsl-ref.info,  Node: Singular Value Decomposition,  Next: Cholesky Decomposition,  Prev: QR Decomposition with Column Pivoting,  Up: Linear Algebra
@@ -1301,10 +1268,10 @@ File: gsl-ref.info,  Node: Singular Value Decomposition,  Next: Cholesky Decompo
 13.4 Singular Value Decomposition
 =================================
 
-A general rectangular M-by-N matrix A has a singular value
-decomposition (SVD) into the product of an M-by-N orthogonal matrix U,
-an N-by-N diagonal matrix of singular values S and the transpose of an
-N-by-N orthogonal square matrix V,
+A general rectangular M-by-N matrix A has a singular value decomposition
+(SVD) into the product of an M-by-N orthogonal matrix U, an N-by-N
+diagonal matrix of singular values S and the transpose of an N-by-N
+orthogonal square matrix V,
 
      A = U S V^T
 
@@ -1314,8 +1281,8 @@ generally chosen to form a non-increasing sequence \sigma_1 >= \sigma_2
 
    The singular value decomposition of a matrix has many practical uses.
 The condition number of the matrix is given by the ratio of the largest
-singular value to the smallest singular value. The presence of a zero
-singular value indicates that the matrix is singular. The number of
+singular value to the smallest singular value.  The presence of a zero
+singular value indicates that the matrix is singular.  The number of
 non-zero singular values indicates the rank of the matrix.  In practice
 singular value decomposition of a rank-deficient matrix will not produce
 exact zeroes for singular values, due to finite numerical precision.
@@ -1329,18 +1296,18 @@ singular values.
  -- Function: int gsl_linalg_SV_decomp (gsl_matrix * A, gsl_matrix * V,
           gsl_vector * S, gsl_vector * WORK)
      This function factorizes the M-by-N matrix A into the singular
-     value decomposition A = U S V^T for M >= N.  On output the matrix
-     A is replaced by U. The diagonal elements of the singular value
-     matrix S are stored in the vector S. The singular values are
+     value decomposition A = U S V^T for M >= N.  On output the matrix A
+     is replaced by U.  The diagonal elements of the singular value
+     matrix S are stored in the vector S.  The singular values are
      non-negative and form a non-increasing sequence from S_1 to S_N.
-     The matrix V contains the elements of V in untransposed form. To
+     The matrix V contains the elements of V in untransposed form.  To
      form the product U S V^T it is necessary to take the transpose of
      V.  A workspace of length N is required in WORK.
 
      This routine uses the Golub-Reinsch SVD algorithm.
 
- -- Function: int gsl_linalg_SV_decomp_mod (gsl_matrix * A, gsl_matrix
-          * X, gsl_matrix * V, gsl_vector * S, gsl_vector * WORK)
+ -- Function: int gsl_linalg_SV_decomp_mod (gsl_matrix * A, gsl_matrix *
+          X, gsl_matrix * V, gsl_vector * S, gsl_vector * WORK)
      This function computes the SVD using the modified Golub-Reinsch
      algorithm, which is faster for M>>N.  It requires the vector WORK
      of length N and the N-by-N matrix X as additional working space.
@@ -1355,7 +1322,7 @@ singular values.
  -- Function: int gsl_linalg_SV_solve (gsl_matrix * U, gsl_matrix * V,
           gsl_vector * S, const gsl_vector * B, gsl_vector * X)
      This function solves the system A x = b using the singular value
-     decomposition (U, S, V) of A given by `gsl_linalg_SV_decomp'.
+     decomposition (U, S, V) of A given by 'gsl_linalg_SV_decomp'.
 
      Only non-zero singular values are used in computing the solution.
      The parts of the solution corresponding to singular values of zero
@@ -1378,33 +1345,34 @@ transpose L^T,
 
      A = L L^T
 
-This is sometimes referred to as taking the square-root of a matrix. The
-Cholesky decomposition can only be carried out when all the eigenvalues
-of the matrix are positive.  This decomposition can be used to convert
-the linear system A x = b into a pair of triangular systems (L y = b,
-L^T x = y), which can be solved by forward and back-substitution.
+This is sometimes referred to as taking the square-root of a matrix.
+The Cholesky decomposition can only be carried out when all the
+eigenvalues of the matrix are positive.  This decomposition can be used
+to convert the linear system A x = b into a pair of triangular systems
+(L y = b, L^T x = y), which can be solved by forward and
+back-substitution.
 
  -- Function: int gsl_linalg_cholesky_decomp (gsl_matrix * A)
      This function factorizes the positive-definite symmetric square
-     matrix A into the Cholesky decomposition A = L L^T. On input only
+     matrix A into the Cholesky decomposition A = L L^T.  On input only
      the diagonal and lower-triangular part of the matrix A are needed.
      On output the diagonal and lower triangular part of the input
-     matrix A contain the matrix L. The upper triangular part of the
+     matrix A contain the matrix L.  The upper triangular part of the
      input matrix contains L^T, the diagonal terms being identical for
      both L and L^T.  If the matrix is not positive-definite then the
-     decomposition will fail, returning the error code `GSL_EDOM'.
+     decomposition will fail, returning the error code 'GSL_EDOM'.
 
  -- Function: int gsl_linalg_cholesky_solve (const gsl_matrix *
           CHOLESKY, const gsl_vector * B, gsl_vector * X)
      This function solves the system A x = b using the Cholesky
      decomposition of A into the matrix CHOLESKY given by
-     `gsl_linalg_cholesky_decomp'.
+     'gsl_linalg_cholesky_decomp'.
 
  -- Function: int gsl_linalg_cholesky_svx (const gsl_matrix * CHOLESKY,
           gsl_vector * X)
-     This function solves the system A x = b in-place using the
-     Cholesky decomposition of A into the matrix CHOLESKY given by
-     `gsl_linalg_cholesky_decomp'. On input X should contain the
+     This function solves the system A x = b in-place using the Cholesky
+     decomposition of A into the matrix CHOLESKY given by
+     'gsl_linalg_cholesky_decomp'.  On input X should contain the
      right-hand side b, which is replaced by the solution on output.
 
 
@@ -1420,8 +1388,8 @@ into the form,
 
 where Q is an orthogonal matrix and T is a symmetric tridiagonal matrix.
 
- -- Function: int gsl_linalg_symmtd_decomp (gsl_matrix * A, gsl_vector
-          * TAU)
+ -- Function: int gsl_linalg_symmtd_decomp (gsl_matrix * A, gsl_vector *
+          TAU)
      This function factorizes the symmetric square matrix A into the
      symmetric tridiagonal decomposition Q T Q^T.  On output the
      diagonal and subdiagonal part of the input matrix A contain the
@@ -1435,7 +1403,7 @@ where Q is an orthogonal matrix and T is a symmetric tridiagonal matrix.
           gsl_vector * TAU, gsl_matrix * Q, gsl_vector * DIAG,
           gsl_vector * SUBDIAG)
      This function unpacks the encoded symmetric tridiagonal
-     decomposition (A, TAU) obtained from `gsl_linalg_symmtd_decomp'
+     decomposition (A, TAU) obtained from 'gsl_linalg_symmtd_decomp'
      into the orthogonal matrix Q, the vector of diagonal elements DIAG
      and the vector of subdiagonal elements SUBDIAG.
 
@@ -1443,7 +1411,7 @@ where Q is an orthogonal matrix and T is a symmetric tridiagonal matrix.
           gsl_vector * DIAG, gsl_vector * SUBDIAG)
      This function unpacks the diagonal and subdiagonal of the encoded
      symmetric tridiagonal decomposition (A, TAU) obtained from
-     `gsl_linalg_symmtd_decomp' into the vectors DIAG and SUBDIAG.
+     'gsl_linalg_symmtd_decomp' into the vectors DIAG and SUBDIAG.
 
 
 File: gsl-ref.info,  Node: Tridiagonal Decomposition of Hermitian Matrices,  Next: Hessenberg Decomposition of Real Matrices,  Prev: Tridiagonal Decomposition of Real Symmetric Matrices,  Up: Linear Algebra
@@ -1462,12 +1430,12 @@ matrix.
  -- Function: int gsl_linalg_hermtd_decomp (gsl_matrix_complex * A,
           gsl_vector_complex * TAU)
      This function factorizes the hermitian matrix A into the symmetric
-     tridiagonal decomposition U T U^T.  On output the real parts of
-     the diagonal and subdiagonal part of the input matrix A contain
-     the tridiagonal matrix T.  The remaining lower triangular part of
-     the input matrix contains the Householder vectors which, together
-     with the Householder coefficients TAU, encode the orthogonal matrix
-     Q. This storage scheme is the same as used by LAPACK.  The upper
+     tridiagonal decomposition U T U^T.  On output the real parts of the
+     diagonal and subdiagonal part of the input matrix A contain the
+     tridiagonal matrix T.  The remaining lower triangular part of the
+     input matrix contains the Householder vectors which, together with
+     the Householder coefficients TAU, encode the orthogonal matrix Q.
+     This storage scheme is the same as used by LAPACK.  The upper
      triangular part of A and imaginary parts of the diagonal are not
      referenced.
 
@@ -1475,15 +1443,15 @@ matrix.
           A, const gsl_vector_complex * TAU, gsl_matrix_complex * Q,
           gsl_vector * DIAG, gsl_vector * SUBDIAG)
      This function unpacks the encoded tridiagonal decomposition (A,
-     TAU) obtained from `gsl_linalg_hermtd_decomp' into the unitary
+     TAU) obtained from 'gsl_linalg_hermtd_decomp' into the unitary
      matrix U, the real vector of diagonal elements DIAG and the real
      vector of subdiagonal elements SUBDIAG.
 
- -- Function: int gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex
-          * A, gsl_vector * DIAG, gsl_vector * SUBDIAG)
+ -- Function: int gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex *
+          A, gsl_vector * DIAG, gsl_vector * SUBDIAG)
      This function unpacks the diagonal and subdiagonal of the encoded
      tridiagonal decomposition (A, TAU) obtained from the
-     `gsl_linalg_hermtd_decomp' into the real vectors DIAG and SUBDIAG.
+     'gsl_linalg_hermtd_decomp' into the real vectors DIAG and SUBDIAG.
 
 
 File: gsl-ref.info,  Node: Hessenberg Decomposition of Real Matrices,  Next: Bidiagonalization,  Prev: Tridiagonal Decomposition of Hermitian Matrices,  Up: Linear Algebra
@@ -1497,40 +1465,40 @@ transformations into the form
      A = U H U^T
 
    where U is orthogonal and H is an upper Hessenberg matrix, meaning
-that it has zeros below the first subdiagonal. The Hessenberg reduction
+that it has zeros below the first subdiagonal.  The Hessenberg reduction
 is the first step in the Schur decomposition for the nonsymmetric
 eigenvalue problem, but has applications in other areas as well.
 
  -- Function: int gsl_linalg_hessenberg (gsl_matrix * A, gsl_vector *
           TAU)
-     This function computes the Hessenberg decomposition of the matrix
-     A by applying the similarity transformation H = U^T A U.  On
-     output, H is stored in the upper portion of A. The information
-     required to construct the matrix U is stored in the lower
-     triangular portion of A. U is a product of N - 2 Householder
-     matrices. The Householder vectors are stored in the lower portion
-     of A (below the subdiagonal) and the Householder coefficients are
-     stored in the vector TAU.  TAU must be of length N.
+     This function computes the Hessenberg decomposition of the matrix A
+     by applying the similarity transformation H = U^T A U.  On output,
+     H is stored in the upper portion of A.  The information required to
+     construct the matrix U is stored in the lower triangular portion of
+     A.  U is a product of N - 2 Householder matrices.  The Householder
+     vectors are stored in the lower portion of A (below the
+     subdiagonal) and the Householder coefficients are stored in the
+     vector TAU.  TAU must be of length N.
 
  -- Function: int gsl_linalg_hessenberg_unpack (gsl_matrix * H,
           gsl_vector * TAU, gsl_matrix * U)
      This function constructs the orthogonal matrix U from the
-     information stored in the Hessenberg matrix H along with the
-     vector TAU. H and TAU are outputs from `gsl_linalg_hessenberg'.
+     information stored in the Hessenberg matrix H along with the vector
+     TAU.  H and TAU are outputs from 'gsl_linalg_hessenberg'.
 
  -- Function: int gsl_linalg_hessenberg_unpack_accum (gsl_matrix * H,
           gsl_vector * TAU, gsl_matrix * V)
-     This function is similar to `gsl_linalg_hessenberg_unpack', except
+     This function is similar to 'gsl_linalg_hessenberg_unpack', except
      it accumulates the matrix U into V, so that V' = VU.  The matrix V
      must be initialized prior to calling this function.  Setting V to
      the identity matrix provides the same result as
-     `gsl_linalg_hessenberg_unpack'. If H is order N, then V must have
+     'gsl_linalg_hessenberg_unpack'.  If H is order N, then V must have
      N columns but may have any number of rows.
 
  -- Function: void gsl_linalg_hessenberg_set_zero (gsl_matrix * H)
      This function sets the lower triangular portion of H, below the
-     subdiagonal, to zero. It is useful for clearing out the
-     Householder vectors after calling `gsl_linalg_hessenberg'.
+     subdiagonal, to zero.  It is useful for clearing out the
+     Householder vectors after calling 'gsl_linalg_hessenberg'.
 
 
 File: gsl-ref.info,  Node: Bidiagonalization,  Next: Householder Transformations,  Prev: Hessenberg Decomposition of Real Matrices,  Up: Linear Algebra
@@ -1547,37 +1515,37 @@ where U and V are orthogonal matrices and B is a N-by-N bidiagonal
 matrix with non-zero entries only on the diagonal and superdiagonal.
 The size of U is M-by-N and the size of V is N-by-N.
 
- -- Function: int gsl_linalg_bidiag_decomp (gsl_matrix * A, gsl_vector
-          * TAU_U, gsl_vector * TAU_V)
-     This function factorizes the M-by-N matrix A into bidiagonal form
-     U B V^T.  The diagonal and superdiagonal of the matrix B are
-     stored in the diagonal and superdiagonal of A.  The orthogonal
-     matrices U and V are stored as compressed Householder vectors in
-     the remaining elements of A.  The Householder coefficients are
-     stored in the vectors TAU_U and TAU_V.  The length of TAU_U must
-     equal the number of elements in the diagonal of A and the length
-     of TAU_V should be one element shorter.
+ -- Function: int gsl_linalg_bidiag_decomp (gsl_matrix * A, gsl_vector *
+          TAU_U, gsl_vector * TAU_V)
+     This function factorizes the M-by-N matrix A into bidiagonal form U
+     B V^T.  The diagonal and superdiagonal of the matrix B are stored
+     in the diagonal and superdiagonal of A.  The orthogonal matrices U
+     and V are stored as compressed Householder vectors in the remaining
+     elements of A.  The Householder coefficients are stored in the
+     vectors TAU_U and TAU_V.  The length of TAU_U must equal the number
+     of elements in the diagonal of A and the length of TAU_V should be
+     one element shorter.
 
  -- Function: int gsl_linalg_bidiag_unpack (const gsl_matrix * A, const
           gsl_vector * TAU_U, gsl_matrix * U, const gsl_vector * TAU_V,
           gsl_matrix * V, gsl_vector * DIAG, gsl_vector * SUPERDIAG)
      This function unpacks the bidiagonal decomposition of A given by
-     `gsl_linalg_bidiag_decomp', (A, TAU_U, TAU_V) into the separate
+     'gsl_linalg_bidiag_decomp', (A, TAU_U, TAU_V) into the separate
      orthogonal matrices U, V and the diagonal vector DIAG and
-     superdiagonal SUPERDIAG.  Note that U is stored as a compact
-     M-by-N orthogonal matrix satisfying U^T U = I for efficiency.
+     superdiagonal SUPERDIAG.  Note that U is stored as a compact M-by-N
+     orthogonal matrix satisfying U^T U = I for efficiency.
 
  -- Function: int gsl_linalg_bidiag_unpack2 (gsl_matrix * A, gsl_vector
           * TAU_U, gsl_vector * TAU_V, gsl_matrix * V)
      This function unpacks the bidiagonal decomposition of A given by
-     `gsl_linalg_bidiag_decomp', (A, TAU_U, TAU_V) into the separate
+     'gsl_linalg_bidiag_decomp', (A, TAU_U, TAU_V) into the separate
      orthogonal matrices U, V and the diagonal vector DIAG and
      superdiagonal SUPERDIAG.  The matrix U is stored in-place in A.
 
  -- Function: int gsl_linalg_bidiag_unpack_B (const gsl_matrix * A,
           gsl_vector * DIAG, gsl_vector * SUPERDIAG)
      This function unpacks the diagonal and superdiagonal of the
-     bidiagonal decomposition of A given by `gsl_linalg_bidiag_decomp',
+     bidiagonal decomposition of A given by 'gsl_linalg_bidiag_decomp',
      into the diagonal vector DIAG and superdiagonal vector SUPERDIAG.
 
 
@@ -1593,9 +1561,9 @@ Householder matrix P takes the form,
      P = I - \tau v v^T
 
 where v is a vector (called the "Householder vector") and \tau = 2/(v^T
-v).  The functions described in this section use the rank-1 structure
-of the Householder matrix to create and apply Householder
-transformations efficiently.
+v).  The functions described in this section use the rank-1 structure of
+the Householder matrix to create and apply Householder transformations
+efficiently.
 
  -- Function: double gsl_linalg_householder_transform (gsl_vector * V)
      This function prepares a Householder transformation P = I - \tau v
@@ -1612,8 +1580,8 @@ transformations efficiently.
  -- Function: int gsl_linalg_householder_mh (double tau, const
           gsl_vector * v, gsl_matrix * A)
      This function applies the Householder matrix P defined by the
-     scalar TAU and the vector V to the right-hand side of the matrix
-     A. On output the result A P is stored in A.
+     scalar TAU and the vector V to the right-hand side of the matrix A.
+     On output the result A P is stored in A.
 
  -- Function: int gsl_linalg_householder_hv (double tau, const
           gsl_vector * v, gsl_vector * w)
@@ -1630,8 +1598,8 @@ File: gsl-ref.info,  Node: Householder solver for linear systems,  Next: Tridiag
  -- Function: int gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector
           * B, gsl_vector * X)
      This function solves the system A x = b directly using Householder
-     transformations. On output the solution is stored in X and B is
-     not modified. The matrix A is destroyed by the Householder
+     transformations.  On output the solution is stored in X and B is
+     not modified.  The matrix A is destroyed by the Householder
      transformations.
 
  -- Function: int gsl_linalg_HH_svx (gsl_matrix * A, gsl_vector * X)
@@ -1647,10 +1615,10 @@ File: gsl-ref.info,  Node: Tridiagonal Systems,  Next: Balancing,  Prev: Househo
 =========================
 
  -- Function: int gsl_linalg_solve_tridiag (const gsl_vector * DIAG,
-          const gsl_vector * E, const gsl_vector * F, const gsl_vector
-          * B, gsl_vector * X)
+          const gsl_vector * E, const gsl_vector * F, const gsl_vector *
+          B, gsl_vector * X)
      This function solves the general N-by-N system A x = b where A is
-     tridiagonal (N >= 2). The super-diagonal and sub-diagonal vectors
+     tridiagonal (N >= 2).  The super-diagonal and sub-diagonal vectors
      E and F must be one element shorter than the diagonal vector DIAG.
      The form of A for the 4-by-4 case is shown below,
 
@@ -1660,8 +1628,8 @@ File: gsl-ref.info,  Node: Tridiagonal Systems,  Next: Balancing,  Prev: Househo
               (  0   0  f_2 d_3 )
 
  -- Function: int gsl_linalg_solve_symm_tridiag (const gsl_vector *
-          DIAG, const gsl_vector * E, const gsl_vector * B, gsl_vector
-          * X)
+          DIAG, const gsl_vector * E, const gsl_vector * B, gsl_vector *
+          X)
      This function solves the general N-by-N system A x = b where A is
      symmetric tridiagonal (N >= 2).  The off-diagonal vector E must be
      one element shorter than the diagonal vector DIAG.  The form of A
@@ -1675,9 +1643,9 @@ File: gsl-ref.info,  Node: Tridiagonal Systems,  Next: Balancing,  Prev: Househo
      which can cause division by zero if the matrix is not positive
      definite.
 
- -- Function: int gsl_linalg_solve_cyc_tridiag (const gsl_vector *
-          DIAG, const gsl_vector * E, const gsl_vector * F, const
-          gsl_vector * B, gsl_vector * X)
+ -- Function: int gsl_linalg_solve_cyc_tridiag (const gsl_vector * DIAG,
+          const gsl_vector * E, const gsl_vector * F, const gsl_vector *
+          B, gsl_vector * X)
      This function solves the general N-by-N system A x = b where A is
      cyclic tridiagonal (N >= 3).  The cyclic super-diagonal and
      sub-diagonal vectors E and F must have the same number of elements
@@ -1690,8 +1658,8 @@ File: gsl-ref.info,  Node: Tridiagonal Systems,  Next: Balancing,  Prev: Househo
               ( e_3  0  f_2 d_3 )
 
  -- Function: int gsl_linalg_solve_symm_cyc_tridiag (const gsl_vector *
-          DIAG, const gsl_vector * E, const gsl_vector * B, gsl_vector
-          * X)
+          DIAG, const gsl_vector * E, const gsl_vector * B, gsl_vector *
+          X)
      This function solves the general N-by-N system A x = b where A is
      symmetric cyclic tridiagonal (N >= 3).  The cyclic off-diagonal
      vector E must have the same number of elements as the diagonal
@@ -1709,15 +1677,15 @@ File: gsl-ref.info,  Node: Balancing,  Next: Linear Algebra Examples,  Prev: Tri
 ===============
 
 The process of balancing a matrix applies similarity transformations to
-make the rows and columns have comparable norms. This is useful, for
+make the rows and columns have comparable norms.  This is useful, for
 example, to reduce roundoff errors in the solution of eigenvalue
-problems. Balancing a matrix A consists of replacing A with a similar
+problems.  Balancing a matrix A consists of replacing A with a similar
 matrix
 
      A' = D^(-1) A D
 
-   where D is a diagonal matrix whose entries are powers of the
-floating point radix.
+   where D is a diagonal matrix whose entries are powers of the floating
+point radix.
 
  -- Function: int gsl_linalg_balance_matrix (gsl_matrix * A, gsl_vector
           * D)
@@ -1731,7 +1699,7 @@ File: gsl-ref.info,  Node: Linear Algebra Examples,  Next: Linear Algebra Refere
 13.14 Examples
 ==============
 
-The following program solves the linear system A x = b. The system to
+The following program solves the linear system A x = b.  The system to
 be solved is,
 
      [ 0.18 0.60 0.57 0.96 ] [x0]   [1.0]
@@ -1814,15 +1782,15 @@ File: gsl-ref.info,  Node: Linear Algebra References and Further Reading,  Prev:
 Further information on the algorithms described in this section can be
 found in the following book,
 
-     G. H. Golub, C. F. Van Loan, `Matrix Computations' (3rd Ed, 1996),
+     G. H. Golub, C. F. Van Loan, 'Matrix Computations' (3rd Ed, 1996),
      Johns Hopkins University Press, ISBN 0-8018-5414-8.
 
 The LAPACK library is described in the following manual,
 
-     `LAPACK Users' Guide' (Third Edition, 1999), Published by SIAM,
+     'LAPACK Users' Guide' (Third Edition, 1999), Published by SIAM,
      ISBN 0-89871-447-8.
 
-     `http://www.netlib.org/lapack'
+     <http://www.netlib.org/lapack>
 
 The LAPACK source code can be found at the website above, along with an
 online copy of the users guide.
@@ -1831,20 +1799,20 @@ The Modified Golub-Reinsch algorithm is described in the following
 paper,
 
      T.F. Chan, "An Improved Algorithm for Computing the Singular Value
-     Decomposition", `ACM Transactions on Mathematical Software', 8
+     Decomposition", 'ACM Transactions on Mathematical Software', 8
      (1982), pp 72-83.
 
 The Jacobi algorithm for singular value decomposition is described in
 the following papers,
 
      J.C. Nash, "A one-sided transformation method for the singular
-     value decomposition and algebraic eigenproblem", `Computer
+     value decomposition and algebraic eigenproblem", 'Computer
      Journal', Volume 18, Number 1 (1973), p 74-76
 
      James Demmel, Kresimir Veselic, "Jacobi's Method is more accurate
-     than QR", `Lapack Working Note 15' (LAWN-15), October 1989.
-     Available from netlib, `http://www.netlib.org/lapack/' in the
-     `lawns' or `lawnspdf' directories.
+     than QR", 'Lapack Working Note 15' (LAWN-15), October 1989.
+     Available from netlib, <http://www.netlib.org/lapack/> in the
+     'lawns' or 'lawnspdf' directories.
 
 
 File: gsl-ref.info,  Node: Eigensystems,  Next: Fast Fourier Transforms,  Prev: Linear Algebra,  Up: Top
@@ -1854,28 +1822,28 @@ File: gsl-ref.info,  Node: Eigensystems,  Next: Fast Fourier Transforms,  Prev:
 
 This chapter describes functions for computing eigenvalues and
 eigenvectors of matrices.  There are routines for real symmetric, real
-nonsymmetric, and complex hermitian matrices. Eigenvalues can be
-computed with or without eigenvectors. The hermitian matrix algorithms
-used are symmetric bidiagonalization followed by QR reduction. The
+nonsymmetric, and complex hermitian matrices.  Eigenvalues can be
+computed with or without eigenvectors.  The hermitian matrix algorithms
+used are symmetric bidiagonalization followed by QR reduction.  The
 nonsymmetric algorithm is the Francis QR double-shift.
 
    These routines are intended for "small" systems where simple
-algorithms are acceptable.  Anyone interested in finding eigenvalues
-and eigenvectors of large matrices will want to use the sophisticated
-routines found in LAPACK. The Fortran version of LAPACK is recommended
+algorithms are acceptable.  Anyone interested in finding eigenvalues and
+eigenvectors of large matrices will want to use the sophisticated
+routines found in LAPACK.  The Fortran version of LAPACK is recommended
 as the standard package for large-scale linear algebra.
 
    The functions described in this chapter are declared in the header
-file `gsl_eigen.h'.
+file 'gsl_eigen.h'.
 
 * Menu:
 
-* Real Symmetric Matrices::
-* Complex Hermitian Matrices::
-* Real Nonsymmetric Matrices::
-* Sorting Eigenvalues and Eigenvectors::
-* Eigenvalue and Eigenvector Examples::
-* Eigenvalue and Eigenvector References::
+* Real Symmetric Matrices::     
+* Complex Hermitian Matrices::  
+* Real Nonsymmetric Matrices::     
+* Sorting Eigenvalues and Eigenvectors::  
+* Eigenvalue and Eigenvector Examples::  
+* Eigenvalue and Eigenvector References::  
 
 
 File: gsl-ref.info,  Node: Real Symmetric Matrices,  Next: Complex Hermitian Matrices,  Up: Eigensystems
@@ -1897,9 +1865,9 @@ File: gsl-ref.info,  Node: Real Symmetric Matrices,  Next: Complex Hermitian Mat
      This function computes the eigenvalues of the real symmetric matrix
      A.  Additional workspace of the appropriate size must be provided
      in W.  The diagonal and lower triangular part of A are destroyed
-     during the computation, but the strict upper triangular part is
-     not referenced.  The eigenvalues are stored in the vector EVAL and
-     are unordered.
+     during the computation, but the strict upper triangular part is not
+     referenced.  The eigenvalues are stored in the vector EVAL and are
+     unordered.
 
  -- Function: gsl_eigen_symmv_workspace * gsl_eigen_symmv_alloc (const
           size_t N)
@@ -1914,8 +1882,8 @@ File: gsl-ref.info,  Node: Real Symmetric Matrices,  Next: Complex Hermitian Mat
           gsl_matrix * EVEC, gsl_eigen_symmv_workspace * W)
      This function computes the eigenvalues and eigenvectors of the real
      symmetric matrix A.  Additional workspace of the appropriate size
-     must be provided in W.  The diagonal and lower triangular part of
-     A are destroyed during the computation, but the strict upper
+     must be provided in W.  The diagonal and lower triangular part of A
+     are destroyed during the computation, but the strict upper
      triangular part is not referenced.  The eigenvalues are stored in
      the vector EVAL and are unordered.  The corresponding eigenvectors
      are stored in the columns of the matrix EVEC.  For example, the
@@ -1945,14 +1913,14 @@ File: gsl-ref.info,  Node: Complex Hermitian Matrices,  Next: Real Nonsymmetric
      provided in W.  The diagonal and lower triangular part of A are
      destroyed during the computation, but the strict upper triangular
      part is not referenced.  The imaginary parts of the diagonal are
-     assumed to be zero and are not referenced. The eigenvalues are
+     assumed to be zero and are not referenced.  The eigenvalues are
      stored in the vector EVAL and are unordered.
 
  -- Function: gsl_eigen_hermv_workspace * gsl_eigen_hermv_alloc (const
           size_t N)
      This function allocates a workspace for computing eigenvalues and
-     eigenvectors of N-by-N complex hermitian matrices.  The size of
-     the workspace is O(5n).
+     eigenvectors of N-by-N complex hermitian matrices.  The size of the
+     workspace is O(5n).
 
  -- Function: void gsl_eigen_hermv_free (gsl_eigen_hermv_workspace * W)
      This function frees the memory associated with the workspace W.
@@ -1964,7 +1932,7 @@ File: gsl-ref.info,  Node: Complex Hermitian Matrices,  Next: Real Nonsymmetric
      complex hermitian matrix A.  Additional workspace of the
      appropriate size must be provided in W.  The diagonal and lower
      triangular part of A are destroyed during the computation, but the
-     strict upper triangular part is not referenced. The imaginary
+     strict upper triangular part is not referenced.  The imaginary
      parts of the diagonal are assumed to be zero and are not
      referenced.  The eigenvalues are stored in the vector EVAL and are
      unordered.  The corresponding complex eigenvectors are stored in
@@ -1979,106 +1947,106 @@ File: gsl-ref.info,  Node: Real Nonsymmetric Matrices,  Next: Sorting Eigenvalue
 14.3 Real Nonsymmetric Matrices
 ===============================
 
-The solution of the real nonsymmetric eigensystem problem for a matrix
-A involves computing the Schur decomposition
+The solution of the real nonsymmetric eigensystem problem for a matrix A
+involves computing the Schur decomposition
 
      A = Z T Z^T
 
    where Z is an orthogonal matrix of Schur vectors and T, the Schur
 form, is quasi upper triangular with diagonal 1-by-1 blocks which are
 real eigenvalues of A, and diagonal 2-by-2 blocks whose eigenvalues are
-complex conjugate eigenvalues of A. The algorithm used is the double
+complex conjugate eigenvalues of A.  The algorithm used is the double
 shift Francis method.
 
  -- Function: gsl_eigen_nonsymm_workspace * gsl_eigen_nonsymm_alloc
           (const size_t N)
      This function allocates a workspace for computing eigenvalues of
-     N-by-N real nonsymmetric matrices. The size of the workspace is
+     N-by-N real nonsymmetric matrices.  The size of the workspace is
      O(2n).
 
- -- Function: void gsl_eigen_nonsymm_free (gsl_eigen_nonsymm_workspace
-          * W)
+ -- Function: void gsl_eigen_nonsymm_free (gsl_eigen_nonsymm_workspace *
+          W)
      This function frees the memory associated with the workspace W.
 
  -- Function: void gsl_eigen_nonsymm_params (const int COMPUTE_T, const
           int BALANCE, gsl_eigen_nonsymm_workspace * W)
      This function sets some parameters which determine how the
      eigenvalue problem is solved in subsequent calls to
-     `gsl_eigen_nonsymm'.
+     'gsl_eigen_nonsymm'.
 
-     If COMPUTE_T is set to 1, the full Schur form T will be computed
-     by `gsl_eigen_nonsymm'. If it is set to 0, T will not be computed
-     (this is the default setting). Computing the full Schur form T
+     If COMPUTE_T is set to 1, the full Schur form T will be computed by
+     'gsl_eigen_nonsymm'.  If it is set to 0, T will not be computed
+     (this is the default setting).  Computing the full Schur form T
      requires approximately 1.5-2 times the number of flops.
 
      If BALANCE is set to 1, a balancing transformation is applied to
-     the matrix prior to computing eigenvalues. This transformation is
+     the matrix prior to computing eigenvalues.  This transformation is
      designed to make the rows and columns of the matrix have comparable
      norms, and can result in more accurate eigenvalues for matrices
-     whose entries vary widely in magnitude. See *Note Balancing:: for
-     more information. Note that the balancing transformation does not
+     whose entries vary widely in magnitude.  See *note Balancing:: for
+     more information.  Note that the balancing transformation does not
      preserve the orthogonality of the Schur vectors, so if you wish to
-     compute the Schur vectors with `gsl_eigen_nonsymm_Z' you will
+     compute the Schur vectors with 'gsl_eigen_nonsymm_Z' you will
      obtain the Schur vectors of the balanced matrix instead of the
-     original matrix. The relationship will be
+     original matrix.  The relationship will be
 
           T = Q^t D^(-1) A D Q
 
      where Q is the matrix of Schur vectors for the balanced matrix, and
-     D is the balancing transformation. Then `gsl_eigen_nonsymm_Z' will
+     D is the balancing transformation.  Then 'gsl_eigen_nonsymm_Z' will
      compute a matrix Z which satisfies
 
           T = Z^(-1) A Z
 
-     with Z = D Q. Note that Z will not be orthogonal. For this reason,
-     balancing is not performed by default.
+     with Z = D Q.  Note that Z will not be orthogonal.  For this
+     reason, balancing is not performed by default.
 
  -- Function: int gsl_eigen_nonsymm (gsl_matrix * A, gsl_vector_complex
           * EVAL, gsl_eigen_nonsymm_workspace * W)
      This function computes the eigenvalues of the real nonsymmetric
-     matrix A and stores them in the vector EVAL. If T is desired, it
+     matrix A and stores them in the vector EVAL.  If T is desired, it
      is stored in the upper portion of A on output.  Otherwise, on
      output, the diagonal of A will contain the 1-by-1 real eigenvalues
      and 2-by-2 complex conjugate eigenvalue systems, and the rest of A
-     is destroyed. In rare cases, this function will fail to find all
-     eigenvalues. If this happens, an error code is returned and the
-     number of converged eigenvalues is stored in `w->n_evals'.  The
+     is destroyed.  In rare cases, this function will fail to find all
+     eigenvalues.  If this happens, an error code is returned and the
+     number of converged eigenvalues is stored in 'w->n_evals'.  The
      converged eigenvalues are stored in the beginning of EVAL.
 
  -- Function: int gsl_eigen_nonsymm_Z (gsl_matrix * A,
           gsl_vector_complex * EVAL, gsl_matrix * Z,
           gsl_eigen_nonsymm_workspace * W)
-     This function is identical to `gsl_eigen_nonsymm' except it also
+     This function is identical to 'gsl_eigen_nonsymm' except it also
      computes the Schur vectors and stores them into Z.
 
  -- Function: gsl_eigen_nonsymmv_workspace * gsl_eigen_nonsymmv_alloc
           (const size_t N)
      This function allocates a workspace for computing eigenvalues and
-     eigenvectors of N-by-N real nonsymmetric matrices. The size of the
+     eigenvectors of N-by-N real nonsymmetric matrices.  The size of the
      workspace is O(5n).
 
- -- Function: void gsl_eigen_nonsymmv_free
-          (gsl_eigen_nonsymmv_workspace * W)
+ -- Function: void gsl_eigen_nonsymmv_free (gsl_eigen_nonsymmv_workspace
+          * W)
      This function frees the memory associated with the workspace W.
 
- -- Function: int gsl_eigen_nonsymmv (gsl_matrix * A,
-          gsl_vector_complex * EVAL, gsl_matrix_complex * EVEC,
+ -- Function: int gsl_eigen_nonsymmv (gsl_matrix * A, gsl_vector_complex
+          * EVAL, gsl_matrix_complex * EVEC,
           gsl_eigen_nonsymmv_workspace * W)
      This function computes eigenvalues and right eigenvectors of the
-     N-by-N real nonsymmetric matrix A. It first calls
-     `gsl_eigen_nonsymm' to compute the eigenvalues, Schur form T, and
-     Schur vectors. Then it finds eigenvectors of T and backtransforms
-     them using the Schur vectors. The Schur vectors are destroyed in
-     the process, but can be saved by using `gsl_eigen_nonsymmv_Z'. The
-     computed eigenvectors are normalized to have Euclidean norm 1. On
-     output, the upper portion of A contains the Schur form T. If
-     `gsl_eigen_nonsymm' fails, no eigenvectors are computed, and an
+     N-by-N real nonsymmetric matrix A.  It first calls
+     'gsl_eigen_nonsymm' to compute the eigenvalues, Schur form T, and
+     Schur vectors.  Then it finds eigenvectors of T and backtransforms
+     them using the Schur vectors.  The Schur vectors are destroyed in
+     the process, but can be saved by using 'gsl_eigen_nonsymmv_Z'.  The
+     computed eigenvectors are normalized to have Euclidean norm 1.  On
+     output, the upper portion of A contains the Schur form T.  If
+     'gsl_eigen_nonsymm' fails, no eigenvectors are computed, and an
      error code is returned.
 
  -- Function: int gsl_eigen_nonsymmv_Z (gsl_matrix * A,
           gsl_vector_complex * EVAL, gsl_matrix_complex * EVEC,
           gsl_matrix * Z, gsl_eigen_nonsymmv_workspace * W)
-     This function is identical to `gsl_eigen_nonsymmv' except it also
+     This function is identical to 'gsl_eigen_nonsymmv' except it also
      saves the Schur vectors into Z.
 
 
@@ -2094,19 +2062,15 @@ File: gsl-ref.info,  Node: Sorting Eigenvalues and Eigenvectors,  Next: Eigenval
      columns of the matrix EVEC into ascending or descending order
      according to the value of the parameter SORT_TYPE,
 
-    `GSL_EIGEN_SORT_VAL_ASC'
+     'GSL_EIGEN_SORT_VAL_ASC'
           ascending order in numerical value
-
-    `GSL_EIGEN_SORT_VAL_DESC'
+     'GSL_EIGEN_SORT_VAL_DESC'
           descending order in numerical value
-
-    `GSL_EIGEN_SORT_ABS_ASC'
+     'GSL_EIGEN_SORT_ABS_ASC'
           ascending order in magnitude
-
-    `GSL_EIGEN_SORT_ABS_DESC'
+     'GSL_EIGEN_SORT_ABS_DESC'
           descending order in magnitude
 
-
  -- Function: int gsl_eigen_hermv_sort (gsl_vector * EVAL,
           gsl_matrix_complex * EVEC, gsl_eigen_sort_t SORT_TYPE)
      This function simultaneously sorts the eigenvalues stored in the
@@ -2218,7 +2182,7 @@ sign of an eigenvector is arbitrary.
 
    The following program illustrates the use of the nonsymmetric
 eigensolver, by computing the eigenvalues and eigenvectors of the
-Vandermonde matrix V(x;i,j) = x_i^n - j with x = (-1,-2,3,4).
+Vandermonde matrix V(x;i,j) = x_i^{n - j} with x = (-1,-2,3,4).
 
      #include <stdio.h>
      #include <gsl/gsl_math.h>
@@ -2319,8 +2283,9 @@ This can be compared with the corresponding output from GNU OCTAVE,
         0.35660 + 0.00000i
         0.91937 + 0.00000i
         0.08118 + 0.00000i
+
    Note that the eigenvectors corresponding to the eigenvalue 5.54555 +
-3.08545i are slightly different. This is because they differ by the
+3.08545i are slightly different.  This is because they differ by the
 multiplicative constant 0.9999984 + 0.0017674i which has magnitude 1.
 
 
@@ -2332,15 +2297,15 @@ File: gsl-ref.info,  Node: Eigenvalue and Eigenvector References,  Prev: Eigenva
 Further information on the algorithms described in this section can be
 found in the following book,
 
-     G. H. Golub, C. F. Van Loan, `Matrix Computations' (3rd Ed, 1996),
+     G. H. Golub, C. F. Van Loan, 'Matrix Computations' (3rd Ed, 1996),
      Johns Hopkins University Press, ISBN 0-8018-5414-8.
 
 The LAPACK library is described in,
 
-     `LAPACK Users' Guide' (Third Edition, 1999), Published by SIAM,
+     'LAPACK Users' Guide' (Third Edition, 1999), Published by SIAM,
      ISBN 0-89871-447-8.
 
-     `http://www.netlib.org/lapack'
+     <http://www.netlib.org/lapack>
 
 The LAPACK source code can be found at the website above along with an
 online copy of the users guide.
@@ -2358,21 +2323,21 @@ efficiency there are separate versions of the routines for real data and
 for complex data.  The mixed-radix routines are a reimplementation of
 the FFTPACK library of Paul Swarztrauber.  Fortran code for FFTPACK is
 available on Netlib (FFTPACK also includes some routines for sine and
-cosine transforms but these are currently not available in GSL).  For
+cosine transforms but these are currently not available in GSL). For
 details and derivations of the underlying algorithms consult the
-document `GSL FFT Algorithms' (*note FFT References and Further
+document 'GSL FFT Algorithms' (*note FFT References and Further
 Reading::)
 
 * Menu:
 
-* Mathematical Definitions::
-* Overview of complex data FFTs::
-* Radix-2 FFT routines for complex data::
-* Mixed-radix FFT routines for complex data::
-* Overview of real data FFTs::
-* Radix-2 FFT routines for real data::
-* Mixed-radix FFT routines for real data::
-* FFT References and Further Reading::
+* Mathematical Definitions::    
+* Overview of complex data FFTs::  
+* Radix-2 FFT routines for complex data::  
+* Mixed-radix FFT routines for complex data::  
+* Overview of real data FFTs::  
+* Radix-2 FFT routines for real data::  
+* Mixed-radix FFT routines for real data::  
+* FFT References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Mathematical Definitions,  Next: Overview of complex data FFTs,  Up: Fast Fourier Transforms
@@ -2388,14 +2353,13 @@ discrete fourier transform (DFT),
    The DFT usually arises as an approximation to the continuous fourier
 transform when functions are sampled at discrete intervals in space or
 time.  The naive evaluation of the discrete fourier transform is a
-matrix-vector multiplication W\vec{z}. A general matrix-vector
+matrix-vector multiplication W\vec{z}.  A general matrix-vector
 multiplication takes O(N^2) operations for N data-points.  Fast fourier
 transform algorithms use a divide-and-conquer strategy to factorize the
-matrix W into smaller sub-matrices, corresponding to the integer
-factors of the length N.  If N can be factorized into a product of
-integers f_1 f_2 ... f_n then the DFT can be computed in O(N \sum f_i)
-operations.  For a radix-2 FFT this gives an operation count of O(N
-\log_2 N).
+matrix W into smaller sub-matrices, corresponding to the integer factors
+of the length N.  If N can be factorized into a product of integers f_1
+f_2 ... f_n then the DFT can be computed in O(N \sum f_i) operations.
+For a radix-2 FFT this gives an operation count of O(N \log_2 N).
 
    All the FFT functions offer three types of transform: forwards,
 inverse and backwards, based on the same mathematical definitions.  The
@@ -2408,20 +2372,20 @@ and the definition of the "inverse fourier transform", x = IFFT(z), is,
      z_j = {1 \over N} \sum_{k=0}^{N-1} x_k \exp(2\pi i j k / N).
 
 The factor of 1/N makes this a true inverse.  For example, a call to
-`gsl_fft_complex_forward' followed by a call to
-`gsl_fft_complex_inverse' should return the original data (within
+'gsl_fft_complex_forward' followed by a call to
+'gsl_fft_complex_inverse' should return the original data (within
 numerical errors).
 
    In general there are two possible choices for the sign of the
-exponential in the transform/ inverse-transform pair. GSL follows the
+exponential in the transform/ inverse-transform pair.  GSL follows the
 same convention as FFTPACK, using a negative exponential for the forward
 transform.  The advantage of this convention is that the inverse
-transform recreates the original function with simple fourier
-synthesis.  Numerical Recipes uses the opposite convention, a positive
-exponential in the forward transform.
+transform recreates the original function with simple fourier synthesis.
+Numerical Recipes uses the opposite convention, a positive exponential
+in the forward transform.
 
-   The "backwards FFT" is simply our terminology for an unscaled
-version of the inverse FFT,
+   The "backwards FFT" is simply our terminology for an unscaled version
+of the inverse FFT,
 
      z^{backwards}_j = \sum_{k=0}^{N-1} x_k \exp(2\pi i j k / N).
 
@@ -2444,7 +2408,7 @@ length 6,
      double x[3*2];
      gsl_complex_packed_array data = x;
 
-can be used to hold an array of three complex numbers, `z[3]', in the
+can be used to hold an array of three complex numbers, 'z[3]', in the
 following way,
 
      data[0] = Re(z[0])
@@ -2455,16 +2419,16 @@ following way,
      data[5] = Im(z[2])
 
 The array indices for the data have the same ordering as those in the
-definition of the DFT--i.e. there are no index transformations or
+definition of the DFT--i.e.  there are no index transformations or
 permutations of the data.
 
    A "stride" parameter allows the user to perform transforms on the
-elements `z[stride*i]' instead of `z[i]'.  A stride greater than 1 can
-be used to take an in-place FFT of the column of a matrix. A stride of
+elements 'z[stride*i]' instead of 'z[i]'.  A stride greater than 1 can
+be used to take an in-place FFT of the column of a matrix.  A stride of
 1 accesses the array without any additional spacing between elements.
 
-   To perform an FFT on a vector argument, such as `gsl_vector_complex
-* v', use the following definitions (or their equivalents) when calling
+   To perform an FFT on a vector argument, such as 'gsl_vector_complex *
+v', use the following definitions (or their equivalents) when calling
 the functions described in this chapter:
 
      gsl_complex_packed_array data = v->data;
@@ -2476,9 +2440,9 @@ appearing in the DFT does not correspond directly to a physical
 frequency.  If the time-step of the DFT is \Delta then the
 frequency-domain includes both positive and negative frequencies,
 ranging from -1/(2\Delta) through 0 to +1/(2\Delta).  The positive
-frequencies are stored from the beginning of the array up to the
-middle, and the negative frequencies are stored backwards from the end
-of the array.
+frequencies are stored from the beginning of the array up to the middle,
+and the negative frequencies are stored backwards from the end of the
+array.
 
    Here is a table which shows the layout of the array DATA, and the
 correspondence between the time-domain data z, and the frequency-domain
@@ -2511,50 +2475,57 @@ File: gsl-ref.info,  Node: Radix-2 FFT routines for complex data,  Next: Mixed-r
 The radix-2 algorithms described in this section are simple and compact,
 although not necessarily the most efficient.  They use the Cooley-Tukey
 algorithm to compute in-place complex FFTs for lengths which are a power
-of 2--no additional storage is required.  The corresponding
-self-sorting mixed-radix routines offer better performance at the
-expense of requiring additional working space.
+of 2--no additional storage is required.  The corresponding self-sorting
+mixed-radix routines offer better performance at the expense of
+requiring additional working space.
 
    All the functions described in this section are declared in the
-header file `gsl_fft_complex.h'.
+header file 'gsl_fft_complex.h'.
 
  -- Function: int gsl_fft_complex_radix2_forward
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
  -- Function: int gsl_fft_complex_radix2_transform
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N,
           gsl_fft_direction SIGN)
+
  -- Function: int gsl_fft_complex_radix2_backward
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
  -- Function: int gsl_fft_complex_radix2_inverse
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
      These functions compute forward, backward and inverse FFTs of
-     length N with stride STRIDE, on the packed complex array DATA
-     using an in-place radix-2 decimation-in-time algorithm.  The
-     length of the transform N is restricted to powers of two.  For the
-     `transform' version of the function the SIGN argument can be
-     either `forward' (-1) or `backward' (+1).
-
-     The functions return a value of `GSL_SUCCESS' if no errors were
-     detected, or `GSL_EDOM' if the length of the data N is not a power
+     length N with stride STRIDE, on the packed complex array DATA using
+     an in-place radix-2 decimation-in-time algorithm.  The length of
+     the transform N is restricted to powers of two.  For the
+     'transform' version of the function the SIGN argument can be either
+     'forward' (-1) or 'backward' (+1).
+
+     The functions return a value of 'GSL_SUCCESS' if no errors were
+     detected, or 'GSL_EDOM' if the length of the data N is not a power
      of two.
 
  -- Function: int gsl_fft_complex_radix2_dif_forward
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
  -- Function: int gsl_fft_complex_radix2_dif_transform
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N,
           gsl_fft_direction SIGN)
+
  -- Function: int gsl_fft_complex_radix2_dif_backward
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
  -- Function: int gsl_fft_complex_radix2_dif_inverse
           (gsl_complex_packed_array DATA, size_t STRIDE, size_t N)
+
      These are decimation-in-frequency versions of the radix-2 FFT
      functions.
 
-
-   Here is an example program which computes the FFT of a short pulse
-in a sample of length 128.  To make the resulting fourier transform
-real the pulse is defined for equal positive and negative times (-10
-... 10), where the negative times wrap around the end of the array.
+   Here is an example program which computes the FFT of a short pulse in
+a sample of length 128.  To make the resulting fourier transform real
+the pulse is defined for equal positive and negative times (-10 ... 10),
+where the negative times wrap around the end of the array.
 
      #include <stdio.h>
      #include <math.h>
@@ -2601,16 +2572,16 @@ real the pulse is defined for equal positive and negative times (-10
      }
 
 Note that we have assumed that the program is using the default error
-handler (which calls `abort' for any errors).  If you are not using a
+handler (which calls 'abort' for any errors).  If you are not using a
 safe error handler you would need to check the return status of
-`gsl_fft_complex_radix2_forward'.
+'gsl_fft_complex_radix2_forward'.
 
    The transformed data is rescaled by 1/\sqrt N so that it fits on the
 same plot as the input.  Only the real part is shown, by the choice of
-the input data the imaginary part is zero.  Allowing for the
-wrap-around of negative times at t=128, and working in units of k/N,
-the DFT approximates the continuum fourier transform, giving a
-modulated sine function.
+the input data the imaginary part is zero.  Allowing for the wrap-around
+of negative times at t=128, and working in units of k/N, the DFT
+approximates the continuum fourier transform, giving a modulated sine
+function.
 
 
 File: gsl-ref.info,  Node: Mixed-radix FFT routines for complex data,  Next: Overview of real data FFTs,  Prev: Radix-2 FFT routines for complex data,  Up: Fast Fourier Transforms
@@ -2621,7 +2592,7 @@ File: gsl-ref.info,  Node: Mixed-radix FFT routines for complex data,  Next: Ove
 This section describes mixed-radix FFT algorithms for complex data.  The
 mixed-radix functions work for FFTs of any length.  They are a
 reimplementation of Paul Swarztrauber's Fortran FFTPACK library.  The
-theory is explained in the review article `Self-sorting Mixed-radix
+theory is explained in the review article 'Self-sorting Mixed-radix
 FFTs' by Clive Temperton.  The routines here use the same indexing
 scheme and basic algorithms as FFTPACK.
 
@@ -2631,49 +2602,48 @@ There are efficient modules for factors of 2, 3, 4, 5, 6 and 7.  The
 modules for the composite factors of 4 and 6 are faster than combining
 the modules for 2*2 and 2*3.
 
-   For factors which are not implemented as modules there is a
-fall-back to a general length-n module which uses Singleton's method for
+   For factors which are not implemented as modules there is a fall-back
+to a general length-n module which uses Singleton's method for
 efficiently computing a DFT. This module is O(n^2), and slower than a
 dedicated module would be but works for any length n.  Of course,
 lengths which use the general length-n module will still be factorized
 as much as possible.  For example, a length of 143 will be factorized
-into 11*13.  Large prime factors are the worst case scenario, e.g. as
-found in n=2*3*99991, and should be avoided because their O(n^2)
-scaling will dominate the run-time (consult the document `GSL FFT
-Algorithms' included in the GSL distribution if you encounter this
-problem).
+into 11*13.  Large prime factors are the worst case scenario, e.g.  as
+found in n=2*3*99991, and should be avoided because their O(n^2) scaling
+will dominate the run-time (consult the document 'GSL FFT Algorithms'
+included in the GSL distribution if you encounter this problem).
 
    The mixed-radix initialization function
-`gsl_fft_complex_wavetable_alloc' returns the list of factors chosen by
+'gsl_fft_complex_wavetable_alloc' returns the list of factors chosen by
 the library for a given length N.  It can be used to check how well the
 length has been factorized, and estimate the run-time.  To a first
 approximation the run-time scales as N \sum f_i, where the f_i are the
 factors of N.  For programs under user control you may wish to issue a
 warning that the transform will be slow when the length is poorly
 factorized.  If you frequently encounter data lengths which cannot be
-factorized using the existing small-prime modules consult `GSL FFT
+factorized using the existing small-prime modules consult 'GSL FFT
 Algorithms' for details on adding support for other factors.
 
    All the functions described in this section are declared in the
-header file `gsl_fft_complex.h'.
+header file 'gsl_fft_complex.h'.
 
  -- Function: gsl_fft_complex_wavetable *
-gsl_fft_complex_wavetable_alloc (size_t N)
+          gsl_fft_complex_wavetable_alloc (size_t N)
      This function prepares a trigonometric lookup table for a complex
-     FFT of length N. The function returns a pointer to the newly
-     allocated `gsl_fft_complex_wavetable' if no errors were detected,
+     FFT of length N.  The function returns a pointer to the newly
+     allocated 'gsl_fft_complex_wavetable' if no errors were detected,
      and a null pointer in the case of error.  The length N is
      factorized into a product of subtransforms, and the factors and
-     their trigonometric coefficients are stored in the wavetable. The
-     trigonometric coefficients are computed using direct calls to
-     `sin' and `cos', for accuracy.  Recursion relations could be used
-     to compute the lookup table faster, but if an application performs
+     their trigonometric coefficients are stored in the wavetable.  The
+     trigonometric coefficients are computed using direct calls to 'sin'
+     and 'cos', for accuracy.  Recursion relations could be used to
+     compute the lookup table faster, but if an application performs
      many FFTs of the same length then this computation is a one-off
      overhead which does not affect the final throughput.
 
-     The wavetable structure can be used repeatedly for any transform
-     of the same length.  The table is not modified by calls to any of
-     the other FFT functions.  The same wavetable can be used for both
+     The wavetable structure can be used repeatedly for any transform of
+     the same length.  The table is not modified by calls to any of the
+     other FFT functions.  The same wavetable can be used for both
      forward and backward (or inverse) transforms of a given length.
 
  -- Function: void gsl_fft_complex_wavetable_free
@@ -2682,94 +2652,92 @@ gsl_fft_complex_wavetable_alloc (size_t N)
      WAVETABLE.  The wavetable can be freed if no further FFTs of the
      same length will be needed.
 
-These functions operate on a `gsl_fft_complex_wavetable' structure
-which contains internal parameters for the FFT.  It is not necessary to
-set any of the components directly but it can sometimes be useful to
-examine them.  For example, the chosen factorization of the FFT length
-is given and can be used to provide an estimate of the run-time or
-numerical error. The wavetable structure is declared in the header file
-`gsl_fft_complex.h'.
+These functions operate on a 'gsl_fft_complex_wavetable' structure which
+contains internal parameters for the FFT. It is not necessary to set any
+of the components directly but it can sometimes be useful to examine
+them.  For example, the chosen factorization of the FFT length is given
+and can be used to provide an estimate of the run-time or numerical
+error.  The wavetable structure is declared in the header file
+'gsl_fft_complex.h'.
 
  -- Data Type: gsl_fft_complex_wavetable
      This is a structure that holds the factorization and trigonometric
      lookup tables for the mixed radix fft algorithm.  It has the
      following components:
 
-    `size_t n'
+     'size_t n'
           This is the number of complex data points
 
-    `size_t nf'
-          This is the number of factors that the length `n' was
+     'size_t nf'
+          This is the number of factors that the length 'n' was
           decomposed into.
 
-    `size_t factor[64]'
-          This is the array of factors.  Only the first `nf' elements
+     'size_t factor[64]'
+          This is the array of factors.  Only the first 'nf' elements
           are used.
 
-    `gsl_complex * trig'
-          This is a pointer to a preallocated trigonometric lookup
-          table of `n' complex elements.
+     'gsl_complex * trig'
+          This is a pointer to a preallocated trigonometric lookup table
+          of 'n' complex elements.
 
-    `gsl_complex * twiddle[64]'
-          This is an array of pointers into `trig', giving the twiddle
+     'gsl_complex * twiddle[64]'
+          This is an array of pointers into 'trig', giving the twiddle
           factors for each pass.
 
 The mixed radix algorithms require additional working space to hold the
 intermediate steps of the transform.
 
  -- Function: gsl_fft_complex_workspace *
-gsl_fft_complex_workspace_alloc (size_t N)
+          gsl_fft_complex_workspace_alloc (size_t N)
      This function allocates a workspace for a complex transform of
      length N.
 
  -- Function: void gsl_fft_complex_workspace_free
           (gsl_fft_complex_workspace * WORKSPACE)
      This function frees the memory associated with the workspace
-     WORKSPACE. The workspace can be freed if no further FFTs of the
+     WORKSPACE.  The workspace can be freed if no further FFTs of the
      same length will be needed.
 
 The following functions compute the transform,
 
  -- Function: int gsl_fft_complex_forward (gsl_complex_packed_array
-          DATA, size_t STRIDE, size_t N, const
-          gsl_fft_complex_wavetable * WAVETABLE,
-          gsl_fft_complex_workspace * WORK)
+          DATA, size_t STRIDE, size_t N, const gsl_fft_complex_wavetable
+          * WAVETABLE, gsl_fft_complex_workspace * WORK)
  -- Function: int gsl_fft_complex_transform (gsl_complex_packed_array
-          DATA, size_t STRIDE, size_t N, const
-          gsl_fft_complex_wavetable * WAVETABLE,
-          gsl_fft_complex_workspace * WORK, gsl_fft_direction SIGN)
+          DATA, size_t STRIDE, size_t N, const gsl_fft_complex_wavetable
+          * WAVETABLE, gsl_fft_complex_workspace * WORK,
+          gsl_fft_direction SIGN)
  -- Function: int gsl_fft_complex_backward (gsl_complex_packed_array
-          DATA, size_t STRIDE, size_t N, const
-          gsl_fft_complex_wavetable * WAVETABLE,
-          gsl_fft_complex_workspace * WORK)
+          DATA, size_t STRIDE, size_t N, const gsl_fft_complex_wavetable
+          * WAVETABLE, gsl_fft_complex_workspace * WORK)
  -- Function: int gsl_fft_complex_inverse (gsl_complex_packed_array
-          DATA, size_t STRIDE, size_t N, const
-          gsl_fft_complex_wavetable * WAVETABLE,
-          gsl_fft_complex_workspace * WORK)
+          DATA, size_t STRIDE, size_t N, const gsl_fft_complex_wavetable
+          * WAVETABLE, gsl_fft_complex_workspace * WORK)
+
      These functions compute forward, backward and inverse FFTs of
      length N with stride STRIDE, on the packed complex array DATA,
-     using a mixed radix decimation-in-frequency algorithm.  There is
-     no restriction on the length N.  Efficient modules are provided
-     for subtransforms of length 2, 3, 4, 5, 6 and 7.  Any remaining
-     factors are computed with a slow, O(n^2), general-n module. The
-     caller must supply a WAVETABLE containing the trigonometric lookup
-     tables and a workspace WORK.  For the `transform' version of the
-     function the SIGN argument can be either `forward' (-1) or
-     `backward' (+1).
-
-     The functions return a value of `0' if no errors were detected. The
-     following `gsl_errno' conditions are defined for these functions:
-
-    `GSL_EDOM'
-          The length of the data N is not a positive integer (i.e. N is
+     using a mixed radix decimation-in-frequency algorithm.  There is no
+     restriction on the length N.  Efficient modules are provided for
+     subtransforms of length 2, 3, 4, 5, 6 and 7.  Any remaining factors
+     are computed with a slow, O(n^2), general-n module.  The caller
+     must supply a WAVETABLE containing the trigonometric lookup tables
+     and a workspace WORK.  For the 'transform' version of the function
+     the SIGN argument can be either 'forward' (-1) or 'backward' (+1).
+
+     The functions return a value of '0' if no errors were detected.
+     The following 'gsl_errno' conditions are defined for these
+     functions:
+
+     'GSL_EDOM'
+          The length of the data N is not a positive integer (i.e.  N is
           zero).
 
-    `GSL_EINVAL'
+     'GSL_EINVAL'
           The length of the data N and the length used to compute the
           given WAVETABLE do not match.
 
-   Here is an example program which computes the FFT of a short pulse
-in a sample of length 630 (=2*3*3*5*7) using the mixed-radix algorithm.
+   Here is an example program which computes the FFT of a short pulse in
+a sample of length 630 (=2*3*3*5*7) using the mixed-radix algorithm.
 
      #include <stdio.h>
      #include <math.h>
@@ -2832,10 +2800,10 @@ in a sample of length 630 (=2*3*3*5*7) using the mixed-radix algorithm.
        return 0;
      }
 
-Note that we have assumed that the program is using the default `gsl'
-error handler (which calls `abort' for any errors).  If you are not
+Note that we have assumed that the program is using the default 'gsl'
+error handler (which calls 'abort' for any errors).  If you are not
 using a safe error handler you would need to check the return status of
-all the `gsl' routines.
+all the 'gsl' routines.
 
 
 File: gsl-ref.info,  Node: Overview of real data FFTs,  Next: Radix-2 FFT routines for real data,  Prev: Mixed-radix FFT routines for complex data,  Up: Fast Fourier Transforms
@@ -2854,17 +2822,17 @@ A sequence with this symmetry is called "conjugate-complex" or
 "half-complex".  This different structure requires different storage
 layouts for the forward transform (from real to half-complex) and
 inverse transform (from half-complex back to real).  As a consequence
-the routines are divided into two sets: functions in `gsl_fft_real'
-which operate on real sequences and functions in `gsl_fft_halfcomplex'
+the routines are divided into two sets: functions in 'gsl_fft_real'
+which operate on real sequences and functions in 'gsl_fft_halfcomplex'
 which operate on half-complex sequences.
 
-   Functions in `gsl_fft_real' compute the frequency coefficients of a
-real sequence.  The half-complex coefficients c of a real sequence x
-are given by fourier analysis,
+   Functions in 'gsl_fft_real' compute the frequency coefficients of a
+real sequence.  The half-complex coefficients c of a real sequence x are
+given by fourier analysis,
 
      c_k = \sum_{j=0}^{N-1} x_j \exp(-2 \pi i j k /N)
 
-Functions in `gsl_fft_halfcomplex' compute inverse or backwards
+Functions in 'gsl_fft_halfcomplex' compute inverse or backwards
 transforms.  They reconstruct real sequences by fourier synthesis from
 their half-complex frequency coefficients, c,
 
@@ -2872,7 +2840,7 @@ their half-complex frequency coefficients, c,
 
 The symmetry of the half-complex sequence implies that only half of the
 complex numbers in the output need to be stored.  The remaining half can
-be reconstructed using the half-complex symmetry condition. This works
+be reconstructed using the half-complex symmetry condition.  This works
 for all lengths, even and odd--when the length is even the middle value
 where k=N/2 is also real.  Thus only N real numbers are required to
 store the half-complex sequence, and the transform of a real sequence
@@ -2898,21 +2866,22 @@ the Cooley-Tukey algorithm to compute in-place FFTs for lengths which
 are a power of 2.
 
    The radix-2 FFT functions for real data are declared in the header
-files `gsl_fft_real.h'
+files 'gsl_fft_real.h'
 
  -- Function: int gsl_fft_real_radix2_transform (double DATA[], size_t
           STRIDE, size_t N)
+
      This function computes an in-place radix-2 FFT of length N and
-     stride STRIDE on the real array DATA.  The output is a
-     half-complex sequence, which is stored in-place.  The arrangement
-     of the half-complex terms uses the following scheme: for k < N/2
-     the real part of the k-th term is stored in location k, and the
-     corresponding imaginary part is stored in location N-k.  Terms
-     with k > N/2 can be reconstructed using the symmetry z_k =
-     z^*_{N-k}.  The terms for k=0 and k=N/2 are both purely real, and
-     count as a special case.  Their real parts are stored in locations
-     0 and N/2 respectively, while their imaginary parts which are zero
-     are not stored.
+     stride STRIDE on the real array DATA.  The output is a half-complex
+     sequence, which is stored in-place.  The arrangement of the
+     half-complex terms uses the following scheme: for k < N/2 the real
+     part of the k-th term is stored in location k, and the
+     corresponding imaginary part is stored in location N-k.  Terms with
+     k > N/2 can be reconstructed using the symmetry z_k = z^*_{N-k}.
+     The terms for k=0 and k=N/2 are both purely real, and count as a
+     special case.  Their real parts are stored in locations 0 and N/2
+     respectively, while their imaginary parts which are zero are not
+     stored.
 
      The following table shows the correspondence between the output
      DATA and the equivalent results obtained by considering the input
@@ -2935,22 +2904,21 @@ files `gsl_fft_real.h'
           complex[N-1].real  =    data[1]
           complex[N-1].imag  =   -data[N-1]
      Note that the output data can be converted into the full complex
-     sequence using the function `gsl_fft_halfcomplex_unpack' described
+     sequence using the function 'gsl_fft_halfcomplex_unpack' described
      in the next section.
 
    The radix-2 FFT functions for halfcomplex data are declared in the
-header file `gsl_fft_halfcomplex.h'.
+header file 'gsl_fft_halfcomplex.h'.
 
  -- Function: int gsl_fft_halfcomplex_radix2_inverse (double DATA[],
           size_t STRIDE, size_t N)
  -- Function: int gsl_fft_halfcomplex_radix2_backward (double DATA[],
           size_t STRIDE, size_t N)
-     These functions compute the inverse or backwards in-place radix-2
-     FFT of length N and stride STRIDE on the half-complex sequence
-     DATA stored according the output scheme used by
-     `gsl_fft_real_radix2'.  The result is a real array stored in
-     natural order.
 
+     These functions compute the inverse or backwards in-place radix-2
+     FFT of length N and stride STRIDE on the half-complex sequence DATA
+     stored according the output scheme used by 'gsl_fft_real_radix2'.
+     The result is a real array stored in natural order.
 
 
 File: gsl-ref.info,  Node: Mixed-radix FFT routines for real data,  Next: FFT References and Further Reading,  Prev: Radix-2 FFT routines for real data,  Up: Fast Fourier Transforms
@@ -2962,7 +2930,7 @@ This section describes mixed-radix FFT algorithms for real data.  The
 mixed-radix functions work for FFTs of any length.  They are a
 reimplementation of the real-FFT routines in the Fortran FFTPACK library
 by Paul Swarztrauber.  The theory behind the algorithm is explained in
-the article `Fast Mixed-Radix Real Fourier Transforms' by Clive
+the article 'Fast Mixed-Radix Real Fourier Transforms' by Clive
 Temperton.  The routines here use the same indexing scheme and basic
 algorithms as FFTPACK.
 
@@ -2980,10 +2948,10 @@ since the symmetry z_k = z_{N-k}^* implies that this is purely real too.
    The storage scheme is best shown by some examples.  The table below
 shows the output for an odd-length sequence, n=5.  The two columns give
 the correspondence between the 5 values in the half-complex sequence
-returned by `gsl_fft_real_transform', HALFCOMPLEX[] and the values
+returned by 'gsl_fft_real_transform', HALFCOMPLEX[] and the values
 COMPLEX[] that would be returned if the same real input sequence were
-passed to `gsl_fft_complex_backward' as a complex sequence (with
-imaginary parts set to `0'),
+passed to 'gsl_fft_complex_backward' as a complex sequence (with
+imaginary parts set to '0'),
 
      complex[0].real  =  halfcomplex[0]
      complex[0].imag  =  0
@@ -2996,9 +2964,9 @@ imaginary parts set to `0'),
      complex[4].real  =  halfcomplex[1]
      complex[4].imag  = -halfcomplex[2]
 
-The upper elements of the COMPLEX array, `complex[3]' and `complex[4]'
+The upper elements of the COMPLEX array, 'complex[3]' and 'complex[4]'
 are filled in using the symmetry condition.  The imaginary part of the
-zero-frequency term `complex[0].imag' is known to be zero by the
+zero-frequency term 'complex[0].imag' is known to be zero by the
 symmetry.
 
    The next table shows the output for an even-length sequence, n=6 In
@@ -3017,40 +2985,40 @@ the even case there are two values which are purely real,
      complex[5].real  =  halfcomplex[1]
      complex[5].imag  = -halfcomplex[2]
 
-The upper elements of the COMPLEX array, `complex[4]' and `complex[5]'
-are filled in using the symmetry condition.  Both `complex[0].imag' and
-`complex[3].imag' are known to be zero.
+The upper elements of the COMPLEX array, 'complex[4]' and 'complex[5]'
+are filled in using the symmetry condition.  Both 'complex[0].imag' and
+'complex[3].imag' are known to be zero.
 
-   All these functions are declared in the header files
-`gsl_fft_real.h' and `gsl_fft_halfcomplex.h'.
+   All these functions are declared in the header files 'gsl_fft_real.h'
+and 'gsl_fft_halfcomplex.h'.
 
  -- Function: gsl_fft_real_wavetable * gsl_fft_real_wavetable_alloc
           (size_t N)
  -- Function: gsl_fft_halfcomplex_wavetable *
-gsl_fft_halfcomplex_wavetable_alloc (size_t N)
+          gsl_fft_halfcomplex_wavetable_alloc (size_t N)
      These functions prepare trigonometric lookup tables for an FFT of
      size n real elements.  The functions return a pointer to the newly
      allocated struct if no errors were detected, and a null pointer in
      the case of error.  The length N is factorized into a product of
-     subtransforms, and the factors and their trigonometric
-     coefficients are stored in the wavetable. The trigonometric
-     coefficients are computed using direct calls to `sin' and `cos',
-     for accuracy.  Recursion relations could be used to compute the
-     lookup table faster, but if an application performs many FFTs of
-     the same length then computing the wavetable is a one-off overhead
-     which does not affect the final throughput.
-
-     The wavetable structure can be used repeatedly for any transform
-     of the same length.  The table is not modified by calls to any of
-     the other FFT functions.  The appropriate type of wavetable must
-     be used for forward real or inverse half-complex transforms.
-
- -- Function: void gsl_fft_real_wavetable_free (gsl_fft_real_wavetable
-          * WAVETABLE)
+     subtransforms, and the factors and their trigonometric coefficients
+     are stored in the wavetable.  The trigonometric coefficients are
+     computed using direct calls to 'sin' and 'cos', for accuracy.
+     Recursion relations could be used to compute the lookup table
+     faster, but if an application performs many FFTs of the same length
+     then computing the wavetable is a one-off overhead which does not
+     affect the final throughput.
+
+     The wavetable structure can be used repeatedly for any transform of
+     the same length.  The table is not modified by calls to any of the
+     other FFT functions.  The appropriate type of wavetable must be
+     used for forward real or inverse half-complex transforms.
+
+ -- Function: void gsl_fft_real_wavetable_free (gsl_fft_real_wavetable *
+          WAVETABLE)
  -- Function: void gsl_fft_halfcomplex_wavetable_free
           (gsl_fft_halfcomplex_wavetable * WAVETABLE)
      These functions free the memory associated with the wavetable
-     WAVETABLE. The wavetable can be freed if no further FFTs of the
+     WAVETABLE.  The wavetable can be freed if no further FFTs of the
      same length will be needed.
 
 The mixed radix algorithms require additional working space to hold the
@@ -3062,10 +3030,10 @@ intermediate steps of the transform,
      N.  The same workspace can be used for both forward real and
      inverse halfcomplex transforms.
 
- -- Function: void gsl_fft_real_workspace_free (gsl_fft_real_workspace
-          * WORKSPACE)
+ -- Function: void gsl_fft_real_workspace_free (gsl_fft_real_workspace *
+          WORKSPACE)
      This function frees the memory associated with the workspace
-     WORKSPACE. The workspace can be freed if no further FFTs of the
+     WORKSPACE.  The workspace can be freed if no further FFTs of the
      same length will be needed.
 
 The following functions compute the transforms of real and half-complex
@@ -3079,8 +3047,8 @@ data,
           WAVETABLE, gsl_fft_real_workspace * WORK)
      These functions compute the FFT of DATA, a real or half-complex
      array of length N, using a mixed radix decimation-in-frequency
-     algorithm.  For `gsl_fft_real_transform' DATA is an array of
-     time-ordered real data.  For `gsl_fft_halfcomplex_transform' DATA
+     algorithm.  For 'gsl_fft_real_transform' DATA is an array of
+     time-ordered real data.  For 'gsl_fft_halfcomplex_transform' DATA
      contains fourier coefficients in the half-complex ordering
      described above.  There is no restriction on the length N.
      Efficient modules are provided for subtransforms of length 2, 3, 4
@@ -3091,9 +3059,10 @@ data,
  -- Function: int gsl_fft_real_unpack (const double REAL_COEFFICIENT[],
           gsl_complex_packed_array COMPLEX_COEFFICIENT, size_t STRIDE,
           size_t N)
+
      This function converts a single real array, REAL_COEFFICIENT into
      an equivalent complex array, COMPLEX_COEFFICIENT, (with imaginary
-     part set to zero), suitable for `gsl_fft_complex' routines.  The
+     part set to zero), suitable for 'gsl_fft_complex' routines.  The
      algorithm for the conversion is simply,
 
           for (i = 0; i < n; i++)
@@ -3107,12 +3076,12 @@ data,
  -- Function: int gsl_fft_halfcomplex_unpack (const double
           HALFCOMPLEX_COEFFICIENT[], gsl_complex_packed_array
           COMPLEX_COEFFICIENT, size_t STRIDE, size_t N)
+
      This function converts HALFCOMPLEX_COEFFICIENT, an array of
-     half-complex coefficients as returned by `gsl_fft_real_transform',
+     half-complex coefficients as returned by 'gsl_fft_real_transform',
      into an ordinary complex array, COMPLEX_COEFFICIENT.  It fills in
-     the complex array using the symmetry z_k = z_{N-k}^* to
-     reconstruct the redundant elements.  The algorithm for the
-     conversion is,
+     the complex array using the symmetry z_k = z_{N-k}^* to reconstruct
+     the redundant elements.  The algorithm for the conversion is,
 
           complex_coefficient[0].real
             = halfcomplex_coefficient[0];
@@ -3139,11 +3108,11 @@ data,
                 = 0.0;
             }
 
-   Here is an example program using `gsl_fft_real_transform' and
-`gsl_fft_halfcomplex_inverse'.  It generates a real signal in the shape
-of a square pulse.  The pulse is fourier transformed to frequency
-space, and all but the lowest ten frequency components are removed from
-the array of fourier coefficients returned by `gsl_fft_real_transform'.
+   Here is an example program using 'gsl_fft_real_transform' and
+'gsl_fft_halfcomplex_inverse'.  It generates a real signal in the shape
+of a square pulse.  The pulse is fourier transformed to frequency space,
+and all but the lowest ten frequency components are removed from the
+array of fourier coefficients returned by 'gsl_fft_real_transform'.
 
    The remaining fourier coefficients are transformed back to the
 time-domain, to give a filtered version of the square pulse.  Since
@@ -3218,66 +3187,66 @@ File: gsl-ref.info,  Node: FFT References and Further Reading,  Prev: Mixed-radi
 ===================================
 
 A good starting point for learning more about the FFT is the review
-article `Fast Fourier Transforms: A Tutorial Review and A State of the
+article 'Fast Fourier Transforms: A Tutorial Review and A State of the
 Art' by Duhamel and Vetterli,
 
      P. Duhamel and M. Vetterli.  Fast fourier transforms: A tutorial
-     review and a state of the art.  `Signal Processing', 19:259-299,
+     review and a state of the art.  'Signal Processing', 19:259-299,
      1990.
 
 To find out about the algorithms used in the GSL routines you may want
-to consult the document `GSL FFT Algorithms' (it is included in GSL, as
-`doc/fftalgorithms.tex').  This has general information on FFTs and
+to consult the document 'GSL FFT Algorithms' (it is included in GSL, as
+'doc/fftalgorithms.tex').  This has general information on FFTs and
 explicit derivations of the implementation for each routine.  There are
-also references to the relevant literature.  For convenience some of
-the more important references are reproduced below.
+also references to the relevant literature.  For convenience some of the
+more important references are reproduced below.
 
 There are several introductory books on the FFT with example programs,
-such as `The Fast Fourier Transform' by Brigham and `DFT/FFT and
+such as 'The Fast Fourier Transform' by Brigham and 'DFT/FFT and
 Convolution Algorithms' by Burrus and Parks,
 
-     E. Oran Brigham.  `The Fast Fourier Transform'.  Prentice Hall,
+     E. Oran Brigham.  'The Fast Fourier Transform'.  Prentice Hall,
      1974.
 
-     C. S. Burrus and T. W. Parks.  `DFT/FFT and Convolution
+     C. S. Burrus and T. W. Parks.  'DFT/FFT and Convolution
      Algorithms'.  Wiley, 1984.
 
-Both these introductory books cover the radix-2 FFT in some detail.
-The mixed-radix algorithm at the heart of the FFTPACK routines is
-reviewed in Clive Temperton's paper,
+Both these introductory books cover the radix-2 FFT in some detail.  The
+mixed-radix algorithm at the heart of the FFTPACK routines is reviewed
+in Clive Temperton's paper,
 
      Clive Temperton.  Self-sorting mixed-radix fast fourier transforms.
-     `Journal of Computational Physics', 52(1):1-23, 1983.
+     'Journal of Computational Physics', 52(1):1-23, 1983.
 
 The derivation of FFTs for real-valued data is explained in the
 following two articles,
 
      Henrik V. Sorenson, Douglas L. Jones, Michael T. Heideman, and C.
      Sidney Burrus.  Real-valued fast fourier transform algorithms.
-     `IEEE Transactions on Acoustics, Speech, and Signal Processing',
+     'IEEE Transactions on Acoustics, Speech, and Signal Processing',
      ASSP-35(6):849-863, 1987.
 
      Clive Temperton.  Fast mixed-radix real fourier transforms.
-     `Journal of Computational Physics', 52:340-350, 1983.
+     'Journal of Computational Physics', 52:340-350, 1983.
 
 In 1979 the IEEE published a compendium of carefully-reviewed Fortran
-FFT programs in `Programs for Digital Signal Processing'.  It is a
+FFT programs in 'Programs for Digital Signal Processing'.  It is a
 useful reference for implementations of many different FFT algorithms,
 
-     Digital Signal Processing Committee and IEEE Acoustics, Speech,
-     and Signal Processing Committee, editors.  `Programs for Digital
-     Signal Processing'.  IEEE Press, 1979.
+     Digital Signal Processing Committee and IEEE Acoustics, Speech, and
+     Signal Processing Committee, editors.  'Programs for Digital Signal
+     Processing'.  IEEE Press, 1979.
 
 For large-scale FFT work we recommend the use of the dedicated FFTW
 library by Frigo and Johnson.  The FFTW library is self-optimizing--it
 automatically tunes itself for each hardware platform in order to
 achieve maximum performance.  It is available under the GNU GPL.
 
-     FFTW Website, `http://www.fftw.org/'
+     FFTW Website, <http://www.fftw.org/>
 
 The source code for FFTPACK is available from Netlib,
 
-     FFTPACK, `http://www.netlib.org/fftpack/'
+     FFTPACK, <http://www.netlib.org/fftpack/>
 
 
 File: gsl-ref.info,  Node: Numerical Integration,  Next: Random Number Generation,  Prev: Fast Fourier Transforms,  Up: Top
@@ -3297,23 +3266,23 @@ Doncker-Kapenga, Uberhuber and Kahaner.  Fortran code for QUADPACK is
 available on Netlib.
 
    The functions described in this chapter are declared in the header
-file `gsl_integration.h'.
+file 'gsl_integration.h'.
 
 * Menu:
 
-* Numerical Integration Introduction::
-* QNG non-adaptive Gauss-Kronrod integration::
-* QAG adaptive integration::
-* QAGS adaptive integration with singularities::
-* QAGP adaptive integration with known singular points::
-* QAGI adaptive integration on infinite intervals::
-* QAWC adaptive integration for Cauchy principal values::
-* QAWS adaptive integration for singular functions::
-* QAWO adaptive integration for oscillatory functions::
-* QAWF adaptive integration for Fourier integrals::
-* Numerical integration error codes::
-* Numerical integration examples::
-* Numerical integration References and Further Reading::
+* Numerical Integration Introduction::  
+* QNG non-adaptive Gauss-Kronrod integration::  
+* QAG adaptive integration::    
+* QAGS adaptive integration with singularities::  
+* QAGP adaptive integration with known singular points::  
+* QAGI adaptive integration on infinite intervals::  
+* QAWC adaptive integration for Cauchy principal values::  
+* QAWS adaptive integration for singular functions::  
+* QAWO adaptive integration for oscillatory functions::  
+* QAWF adaptive integration for Fourier integrals::  
+* Numerical integration error codes::  
+* Numerical integration examples::  
+* Numerical integration References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Numerical Integration Introduction,  Next: QNG non-adaptive Gauss-Kronrod integration,  Up: Numerical Integration
@@ -3333,8 +3302,8 @@ specify the following accuracy requirement,
      |RESULT - I|  <= max(epsabs, epsrel |I|)
 
 where RESULT is the numerical approximation obtained by the algorithm.
-The algorithms attempt to estimate the absolute error ABSERR = |RESULT
-- I| in such a way that the following inequality holds,
+The algorithms attempt to estimate the absolute error ABSERR = |RESULT -
+I| in such a way that the following inequality holds,
 
      |RESULT - I| <= ABSERR <= max(epsabs, epsrel |I|)
 
@@ -3345,20 +3314,20 @@ stage.
    The algorithms in QUADPACK use a naming convention based on the
 following letters,
 
-     `Q' - quadrature routine
+     'Q' - quadrature routine
 
-     `N' - non-adaptive integrator
-     `A' - adaptive integrator
+     'N' - non-adaptive integrator
+     'A' - adaptive integrator
 
-     `G' - general integrand (user-defined)
-     `W' - weight function with integrand
+     'G' - general integrand (user-defined)
+     'W' - weight function with integrand
 
-     `S' - singularities can be more readily integrated
-     `P' - points of special difficulty can be supplied
-     `I' - infinite range of integration
-     `O' - oscillatory weight function, cos or sin
-     `F' - Fourier integral
-     `C' - Cauchy principal value
+     'S' - singularities can be more readily integrated
+     'P' - points of special difficulty can be supplied
+     'I' - infinite range of integration
+     'O' - oscillatory weight function, cos or sin
+     'F' - Fourier integral
+     'C' - Cauchy principal value
 
 The algorithms are built on pairs of quadrature rules, a higher order
 rule and a lower order rule.  The higher order rule is used to compute
@@ -3368,9 +3337,9 @@ order rule gives an estimate of the error in the approximation.
 
 * Menu:
 
-* Integrands without weight functions::
-* Integrands with weight functions::
-* Integrands with singular weight functions::
+* Integrands without weight functions::  
+* Integrands with weight functions::  
+* Integrands with singular weight functions::  
 
 
 File: gsl-ref.info,  Node: Integrands without weight functions,  Next: Integrands with weight functions,  Up: Numerical Integration Introduction
@@ -3381,10 +3350,10 @@ File: gsl-ref.info,  Node: Integrands without weight functions,  Next: Integrand
 The algorithms for general functions (without a weight function) are
 based on Gauss-Kronrod rules.
 
-   A Gauss-Kronrod rule begins with a classical Gaussian quadrature
-rule of order m.  This is extended with additional points between each
-of the abscissae to give a higher order Kronrod rule of order 2m+1.
-The Kronrod rule is efficient because it reuses existing function
+   A Gauss-Kronrod rule begins with a classical Gaussian quadrature rule
+of order m.  This is extended with additional points between each of the
+abscissae to give a higher order Kronrod rule of order 2m+1.  The
+Kronrod rule is efficient because it reuses existing function
 evaluations from the Gaussian rule.
 
    The higher order Kronrod rule is used as the best approximation to
@@ -3400,12 +3369,11 @@ File: gsl-ref.info,  Node: Integrands with weight functions,  Next: Integrands w
 For integrands with weight functions the algorithms use Clenshaw-Curtis
 quadrature rules.
 
-   A Clenshaw-Curtis rule begins with an n-th order Chebyshev
-polynomial approximation to the integrand.  This polynomial can be
-integrated exactly to give an approximation to the integral of the
-original function.  The Chebyshev expansion can be extended to higher
-orders to improve the approximation and provide an estimate of the
-error.
+   A Clenshaw-Curtis rule begins with an n-th order Chebyshev polynomial
+approximation to the integrand.  This polynomial can be integrated
+exactly to give an approximation to the integral of the original
+function.  The Chebyshev expansion can be extended to higher orders to
+improve the approximation and provide an estimate of the error.
 
 
 File: gsl-ref.info,  Node: Integrands with singular weight functions,  Prev: Integrands with weight functions,  Up: Numerical Integration Introduction
@@ -3436,9 +3404,10 @@ The QNG algorithm is a non-adaptive procedure which uses fixed
 Gauss-Kronrod abscissae to sample the integrand at a maximum of 87
 points.  It is provided for fast integration of smooth functions.
 
- -- Function: int gsl_integration_qng (const gsl_function * F, double
-          A, double B, double EPSABS, double EPSREL, double * RESULT,
+ -- Function: int gsl_integration_qng (const gsl_function * F, double A,
+          double B, double EPSABS, double EPSREL, double * RESULT,
           double * ABSERR, size_t * NEVAL)
+
      This function applies the Gauss-Kronrod 10-point, 21-point,
      43-point and 87-point integration rules in succession until an
      estimate of the integral of f over (a,b) is achieved within the
@@ -3460,12 +3429,12 @@ integration region is divided into subintervals, and on each iteration
 the subinterval with the largest estimated error is bisected.  This
 reduces the overall error rapidly, as the subintervals become
 concentrated around local difficulties in the integrand.  These
-subintervals are managed by a `gsl_integration_workspace' struct, which
+subintervals are managed by a 'gsl_integration_workspace' struct, which
 handles the memory for the subinterval ranges, results and error
 estimates.
 
  -- Function: gsl_integration_workspace *
-gsl_integration_workspace_alloc (size_t N)
+          gsl_integration_workspace_alloc (size_t N)
      This function allocates a workspace sufficient to hold N double
      precision intervals, their integration results and error estimates.
 
@@ -3473,17 +3442,18 @@ gsl_integration_workspace_alloc (size_t N)
           (gsl_integration_workspace * W)
      This function frees the memory associated with the workspace W.
 
- -- Function: int gsl_integration_qag (const gsl_function * F, double
-          A, double B, double EPSABS, double EPSREL, size_t LIMIT, int
-          KEY, gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+ -- Function: int gsl_integration_qag (const gsl_function * F, double A,
+          double B, double EPSABS, double EPSREL, size_t LIMIT, int KEY,
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
+
      This function applies an integration rule adaptively until an
      estimate of the integral of f over (a,b) is achieved within the
-     desired absolute and relative error limits, EPSABS and EPSREL.
-     The function returns the final approximation, RESULT, and an
-     estimate of the absolute error, ABSERR.  The integration rule is
-     determined by the value of KEY, which should be chosen from the
-     following symbolic names,
+     desired absolute and relative error limits, EPSABS and EPSREL.  The
+     function returns the final approximation, RESULT, and an estimate
+     of the absolute error, ABSERR.  The integration rule is determined
+     by the value of KEY, which should be chosen from the following
+     symbolic names,
 
           GSL_INTEG_GAUSS15  (key = 1)
           GSL_INTEG_GAUSS21  (key = 2)
@@ -3520,8 +3490,9 @@ integrable singularities.
 
  -- Function: int gsl_integration_qags (const gsl_function * F, double
           A, double B, double EPSABS, double EPSREL, size_t LIMIT,
-          gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
+
      This function applies the Gauss-Kronrod 21-point integration rule
      adaptively until an estimate of the integral of f over (a,b) is
      achieved within the desired absolute and relative error limits,
@@ -3535,24 +3506,24 @@ integrable singularities.
      is given by LIMIT, which may not exceed the allocated size of the
      workspace.
 
-
 
 File: gsl-ref.info,  Node: QAGP adaptive integration with known singular points,  Next: QAGI adaptive integration on infinite intervals,  Prev: QAGS adaptive integration with singularities,  Up: Numerical Integration
 
 16.5 QAGP adaptive integration with known singular points
 =========================================================
 
- -- Function: int gsl_integration_qagp (const gsl_function * F, double
-          * PTS, size_t NPTS, double EPSABS, double EPSREL, size_t
-          LIMIT, gsl_integration_workspace * WORKSPACE, double *
-          RESULT, double * ABSERR)
+ -- Function: int gsl_integration_qagp (const gsl_function * F, double *
+          PTS, size_t NPTS, double EPSABS, double EPSREL, size_t LIMIT,
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
+
      This function applies the adaptive integration algorithm QAGS
      taking account of the user-supplied locations of singular points.
      The array PTS of length NPTS should contain the endpoints of the
      integration ranges defined by the integration region and locations
      of the singularities.  For example, to integrate over the region
-     (a,b) with break-points at x_1, x_2, x_3 (where a < x_1 < x_2 <
-     x_3 < b) the following PTS array should be used
+     (a,b) with break-points at x_1, x_2, x_3 (where a < x_1 < x_2 < x_3
+     < b) the following PTS array should be used
 
           pts[0] = a
           pts[1] = x_1
@@ -3563,8 +3534,7 @@ File: gsl-ref.info,  Node: QAGP adaptive integration with known singular points,
      with NPTS = 5.
 
      If you know the locations of the singular points in the integration
-     region then this routine will be faster than `QAGS'.
-
+     region then this routine will be faster than 'QAGS'.
 
 
 File: gsl-ref.info,  Node: QAGI adaptive integration on infinite intervals,  Next: QAWC adaptive integration for Cauchy principal values,  Prev: QAGP adaptive integration with known singular points,  Up: Numerical Integration
@@ -3572,10 +3542,10 @@ File: gsl-ref.info,  Node: QAGI adaptive integration on infinite intervals,  Nex
 16.6 QAGI adaptive integration on infinite intervals
 ====================================================
 
- -- Function: int gsl_integration_qagi (gsl_function * F, double
-          EPSABS, double EPSREL, size_t LIMIT,
-          gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+ -- Function: int gsl_integration_qagi (gsl_function * F, double EPSABS,
+          double EPSREL, size_t LIMIT, gsl_integration_workspace *
+          WORKSPACE, double * RESULT, double * ABSERR)
+
      This function computes the integral of the function F over the
      infinite interval (-\infty,+\infty).  The integral is mapped onto
      the semi-open interval (0,1] using the transformation x = (1-t)/t,
@@ -3584,15 +3554,15 @@ File: gsl-ref.info,  Node: QAGI adaptive integration on infinite intervals,  Nex
                \int_0^1 dt (f((1-t)/t) + f((-1+t)/t))/t^2.
 
      It is then integrated using the QAGS algorithm.  The normal
-     21-point Gauss-Kronrod rule of QAGS is replaced by a 15-point
-     rule, because the transformation can generate an integrable
-     singularity at the origin.  In this case a lower-order rule is
-     more efficient.
+     21-point Gauss-Kronrod rule of QAGS is replaced by a 15-point rule,
+     because the transformation can generate an integrable singularity
+     at the origin.  In this case a lower-order rule is more efficient.
 
  -- Function: int gsl_integration_qagiu (gsl_function * F, double A,
           double EPSABS, double EPSREL, size_t LIMIT,
-          gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
+
      This function computes the integral of the function F over the
      semi-infinite interval (a,+\infty).  The integral is mapped onto
      the semi-open interval (0,1] using the transformation x = a +
@@ -3605,8 +3575,8 @@ File: gsl-ref.info,  Node: QAGI adaptive integration on infinite intervals,  Nex
 
  -- Function: int gsl_integration_qagil (gsl_function * F, double B,
           double EPSABS, double EPSREL, size_t LIMIT,
-          gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
      This function computes the integral of the function F over the
      semi-infinite interval (-\infty,b).  The integral is mapped onto
      the semi-open interval (0,1] using the transformation x = b -
@@ -3625,21 +3595,20 @@ File: gsl-ref.info,  Node: QAWC adaptive integration for Cauchy principal values
 
  -- Function: int gsl_integration_qawc (gsl_function * F, double A,
           double B, double C, double EPSABS, double EPSREL, size_t
-          LIMIT, gsl_integration_workspace * WORKSPACE, double *
-          RESULT, double * ABSERR)
+          LIMIT, gsl_integration_workspace * WORKSPACE, double * RESULT,
+          double * ABSERR)
+
      This function computes the Cauchy principal value of the integral
      of f over (a,b), with a singularity at C,
 
           I = \int_a^b dx f(x) / (x - c)
 
-     The adaptive bisection algorithm of QAG is used, with
-     modifications to ensure that subdivisions do not occur at the
-     singular point x = c.  When a subinterval contains the point x = c
-     or is close to it then a special 25-point modified Clenshaw-Curtis
-     rule is used to control the singularity.  Further away from the
-     singularity the algorithm uses an ordinary 15-point Gauss-Kronrod
-     integration rule.
-
+     The adaptive bisection algorithm of QAG is used, with modifications
+     to ensure that subdivisions do not occur at the singular point x =
+     c.  When a subinterval contains the point x = c or is close to it
+     then a special 25-point modified Clenshaw-Curtis rule is used to
+     control the singularity.  Further away from the singularity the
+     algorithm uses an ordinary 15-point Gauss-Kronrod integration rule.
 
 
 File: gsl-ref.info,  Node: QAWS adaptive integration for singular functions,  Next: QAWO adaptive integration for oscillatory functions,  Prev: QAWC adaptive integration for Cauchy principal values,  Up: Numerical Integration
@@ -3649,13 +3618,14 @@ File: gsl-ref.info,  Node: QAWS adaptive integration for singular functions,  Ne
 
 The QAWS algorithm is designed for integrands with algebraic-logarithmic
 singularities at the end-points of an integration region.  In order to
-work efficiently the algorithm requires a precomputed table of
-Chebyshev moments.
+work efficiently the algorithm requires a precomputed table of Chebyshev
+moments.
 
  -- Function: gsl_integration_qaws_table *
-gsl_integration_qaws_table_alloc (double ALPHA, double BETA, int MU,
-          int NU)
-     This function allocates space for a `gsl_integration_qaws_table'
+          gsl_integration_qaws_table_alloc (double ALPHA, double BETA,
+          int MU, int NU)
+
+     This function allocates space for a 'gsl_integration_qaws_table'
      struct describing a singular weight function W(x) with the
      parameters (\alpha, \beta, \mu, \nu),
 
@@ -3675,25 +3645,26 @@ gsl_integration_qaws_table_alloc (double ALPHA, double BETA, int MU,
      integration range.
 
      The function returns a pointer to the newly allocated table
-     `gsl_integration_qaws_table' if no errors were detected, and 0 in
+     'gsl_integration_qaws_table' if no errors were detected, and 0 in
      the case of error.
 
  -- Function: int gsl_integration_qaws_table_set
           (gsl_integration_qaws_table * T, double ALPHA, double BETA,
           int MU, int NU)
      This function modifies the parameters (\alpha, \beta, \mu, \nu) of
-     an existing `gsl_integration_qaws_table' struct T.
+     an existing 'gsl_integration_qaws_table' struct T.
 
  -- Function: void gsl_integration_qaws_table_free
           (gsl_integration_qaws_table * T)
      This function frees all the memory associated with the
-     `gsl_integration_qaws_table' struct T.
+     'gsl_integration_qaws_table' struct T.
 
  -- Function: int gsl_integration_qaws (gsl_function * F, const double
           A, const double B, gsl_integration_qaws_table * T, const
           double EPSABS, const double EPSREL, const size_t LIMIT,
-          gsl_integration_workspace * WORKSPACE, double * RESULT,
-          double * ABSERR)
+          gsl_integration_workspace * WORKSPACE, double * RESULT, double
+          * ABSERR)
+
      This function computes the integral of the function f(x) over the
      interval (a,b) with the singular weight function (x-a)^\alpha
      (b-x)^\beta \log^\mu (x-a) \log^\nu (b-x).  The parameters of the
@@ -3704,11 +3675,9 @@ gsl_integration_qaws_table_alloc (double ALPHA, double BETA, int MU,
 
      The adaptive bisection algorithm of QAG is used.  When a
      subinterval contains one of the endpoints then a special 25-point
-     modified Clenshaw-Curtis rule is used to control the
-     singularities.  For subintervals which do not include the
-     endpoints an ordinary 15-point Gauss-Kronrod integration rule is
-     used.
-
+     modified Clenshaw-Curtis rule is used to control the singularities.
+     For subintervals which do not include the endpoints an ordinary
+     15-point Gauss-Kronrod integration rule is used.
 
 
 File: gsl-ref.info,  Node: QAWO adaptive integration for oscillatory functions,  Next: QAWF adaptive integration for Fourier integrals,  Prev: QAWS adaptive integration for singular functions,  Up: Numerical Integration
@@ -3722,9 +3691,10 @@ the algorithm requires a table of Chebyshev moments which must be
 pre-computed with calls to the functions below.
 
  -- Function: gsl_integration_qawo_table *
-gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
+          gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
           gsl_integration_qawo_enum SINE, size_t N)
-     This function allocates space for a `gsl_integration_qawo_table'
+
+     This function allocates space for a 'gsl_integration_qawo_table'
      struct and its associated workspace describing a sine or cosine
      weight function W(x) with the parameters (\omega, L),
 
@@ -3739,16 +3709,15 @@ gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
           GSL_INTEG_COSINE
           GSL_INTEG_SINE
 
-     The `gsl_integration_qawo_table' is a table of the trigonometric
+     The 'gsl_integration_qawo_table' is a table of the trigonometric
      coefficients required in the integration process.  The parameter N
      determines the number of levels of coefficients that are computed.
      Each level corresponds to one bisection of the interval L, so that
      N levels are sufficient for subintervals down to the length L/2^n.
-     The integration routine `gsl_integration_qawo' returns the error
-     `GSL_ETABLE' if the number of levels is insufficient for the
+     The integration routine 'gsl_integration_qawo' returns the error
+     'GSL_ETABLE' if the number of levels is insufficient for the
      requested accuracy.
 
-
  -- Function: int gsl_integration_qawo_table_set
           (gsl_integration_qawo_table * T, double OMEGA, double L, enum
           gsl_integration_qawo_enum SINE)
@@ -3769,9 +3738,10 @@ gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
           LIMIT, gsl_integration_workspace * WORKSPACE,
           gsl_integration_qawo_table * WF, double * RESULT, double *
           ABSERR)
+
      This function uses an adaptive algorithm to compute the integral of
-     f over (a,b) with the weight function \sin(\omega x) or
-     \cos(\omega x) defined by the table WF,
+     f over (a,b) with the weight function \sin(\omega x) or \cos(\omega
+     x) defined by the table WF,
 
           I = \int_a^b dx f(x) sin(omega x)
           I = \int_a^b dx f(x) cos(omega x)
@@ -3779,8 +3749,8 @@ gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
      The results are extrapolated using the epsilon-algorithm to
      accelerate the convergence of the integral.  The function returns
      the final approximation from the extrapolation, RESULT, and an
-     estimate of the absolute error, ABSERR.  The subintervals and
-     their results are stored in the memory provided by WORKSPACE.  The
+     estimate of the absolute error, ABSERR.  The subintervals and their
+     results are stored in the memory provided by WORKSPACE.  The
      maximum number of subintervals is given by LIMIT, which may not
      exceed the allocated size of the workspace.
 
@@ -3790,7 +3760,6 @@ gsl_integration_qawo_table_alloc (double OMEGA, double L, enum
      widths where d\omega < 4 are computed using a 15-point
      Gauss-Kronrod integration.
 
-
 
 File: gsl-ref.info,  Node: QAWF adaptive integration for Fourier integrals,  Next: Numerical integration error codes,  Prev: QAWO adaptive integration for oscillatory functions,  Up: Numerical Integration
 
@@ -3803,6 +3772,7 @@ File: gsl-ref.info,  Node: QAWF adaptive integration for Fourier integrals,  Nex
           gsl_integration_workspace * CYCLE_WORKSPACE,
           gsl_integration_qawo_table * WF, double * RESULT, double *
           ABSERR)
+
      This function attempts to compute a Fourier integral of the
      function F over the semi-infinite interval [a,+\infty).
 
@@ -3845,11 +3815,10 @@ File: gsl-ref.info,  Node: QAWF adaptive integration for Fourier integrals,  Nex
      where E_k is the estimated error on the interval C_k.
 
      The subintervals and their results are stored in the memory
-     provided by WORKSPACE.  The maximum number of subintervals is
-     given by LIMIT, which may not exceed the allocated size of the
-     workspace.  The integration over each subinterval uses the memory
-     provided by CYCLE_WORKSPACE as workspace for the QAWO algorithm.
-
+     provided by WORKSPACE.  The maximum number of subintervals is given
+     by LIMIT, which may not exceed the allocated size of the workspace.
+     The integration over each subinterval uses the memory provided by
+     CYCLE_WORKSPACE as workspace for the QAWO algorithm.
 
 
 File: gsl-ref.info,  Node: Numerical integration error codes,  Next: Numerical integration examples,  Prev: QAWF adaptive integration for Fourier integrals,  Up: Numerical Integration
@@ -3860,18 +3829,15 @@ File: gsl-ref.info,  Node: Numerical integration error codes,  Next: Numerical i
 In addition to the standard error codes for invalid arguments the
 functions can return the following values,
 
-`GSL_EMAXITER'
+'GSL_EMAXITER'
      the maximum number of subdivisions was exceeded.
-
-`GSL_EROUND'
-     cannot reach tolerance because of roundoff error, or roundoff
-     error was detected in the extrapolation table.
-
-`GSL_ESING'
+'GSL_EROUND'
+     cannot reach tolerance because of roundoff error, or roundoff error
+     was detected in the extrapolation table.
+'GSL_ESING'
      a non-integrable singularity or other bad integrand behavior was
      found in the integration interval.
-
-`GSL_EDIVERGE'
+'GSL_EDIVERGE'
      the integral is divergent, or too slowly convergent to be
      integrated numerically.
 
@@ -3881,14 +3847,14 @@ File: gsl-ref.info,  Node: Numerical integration examples,  Next: Numerical inte
 16.12 Examples
 ==============
 
-The integrator `QAGS' will handle a large class of definite integrals.
+The integrator 'QAGS' will handle a large class of definite integrals.
 For example, consider the following integral, which has a
 algebraic-logarithmic singularity at the origin,
 
      \int_0^1 x^{-1/2} log(x) dx = -4
 
 The program below computes this integral to a relative accuracy bound of
-`1e-7'.
+'1e-7'.
 
      #include <stdio.h>
      #include <math.h>
@@ -3938,10 +3904,10 @@ subdivisions.
      actual error    =  0.000000000000026201
      intervals =  8
 
-In fact, the extrapolation procedure used by `QAGS' produces an
-accuracy of almost twice as many digits.  The error estimate returned by
-the extrapolation procedure is larger than the actual error, giving a
-margin of safety of one order of magnitude.
+In fact, the extrapolation procedure used by 'QAGS' produces an accuracy
+of almost twice as many digits.  The error estimate returned by the
+extrapolation procedure is larger than the actual error, giving a margin
+of safety of one order of magnitude.
 
 
 File: gsl-ref.info,  Node: Numerical integration References and Further Reading,  Prev: Numerical integration examples,  Up: Numerical Integration
@@ -3956,10 +3922,9 @@ includes useful advice on numerical integration and many references to
 the numerical integration literature used in developing QUADPACK.
 
      R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, D.K. Kahaner.
-     `QUADPACK A subroutine package for automatic integration' Springer
+     'QUADPACK A subroutine package for automatic integration' Springer
      Verlag, 1983.
 
-
 
 File: gsl-ref.info,  Node: Random Number Generation,  Next: Quasi-Random Sequences,  Prev: Numerical Integration,  Up: Top
 
@@ -3976,25 +3941,25 @@ programs.  Additional functions are available for transforming uniform
 random numbers into samples from continuous or discrete probability
 distributions such as the Gaussian, log-normal or Poisson distributions.
 
-   These functions are declared in the header file `gsl_rng.h'.
+   These functions are declared in the header file 'gsl_rng.h'.
 
 * Menu:
 
-* General comments on random numbers::
-* The Random Number Generator Interface::
-* Random number generator initialization::
-* Sampling from a random number generator::
-* Auxiliary random number generator functions::
-* Random number environment variables::
-* Copying random number generator state::
-* Reading and writing random number generator state::
-* Random number generator algorithms::
-* Unix random number generators::
-* Other random number generators::
-* Random Number Generator Performance::
-* Random Number Generator Examples::
-* Random Number References and Further Reading::
-* Random Number Acknowledgements::
+* General comments on random numbers::  
+* The Random Number Generator Interface::  
+* Random number generator initialization::  
+* Sampling from a random number generator::  
+* Auxiliary random number generator functions::  
+* Random number environment variables::  
+* Copying random number generator state::   
+* Reading and writing random number generator state::   
+* Random number generator algorithms::  
+* Unix random number generators::  
+* Other random number generators::  
+* Random Number Generator Performance::  
+* Random Number Generator Examples::  
+* Random Number References and Further Reading::  
+* Random Number Acknowledgements::  
 
 
 File: gsl-ref.info,  Node: General comments on random numbers,  Next: The Random Number Generator Interface,  Up: Random Number Generation
@@ -4003,7 +3968,7 @@ File: gsl-ref.info,  Node: General comments on random numbers,  Next: The Random
 =======================================
 
 In 1988, Park and Miller wrote a paper entitled "Random number
-generators: good ones are hard to find." [Commun. ACM, 31, 1192-1201].
+generators: good ones are hard to find."  [Commun. ACM, 31, 1192-1201].
 Fortunately, some excellent random number generators are available,
 though poor ones are still in common use.  You may be happy with the
 system-supplied random number generator on your computer, but you should
@@ -4014,7 +3979,7 @@ the hall to the coffee machine and back.
 
    A very nice review of random number generators was written by Pierre
 L'Ecuyer, as Chapter 4 of the book: Handbook on Simulation, Jerry Banks,
-ed. (Wiley, 1997).  The chapter is available in postscript from
+ed.  (Wiley, 1997).  The chapter is available in postscript from
 L'Ecuyer's ftp site (see references).  Knuth's volume on Seminumerical
 Algorithms (originally published in 1968) devotes 170 pages to random
 number generators, and has recently been updated in its 3rd edition
@@ -4050,12 +4015,12 @@ generators, you do not need to know the details of what comprises the
 state, and besides that varies from algorithm to algorithm.
 
    The random number generator library uses two special structs,
-`gsl_rng_type' which holds static information about each type of
-generator and `gsl_rng' which describes an instance of a generator
-created from a given `gsl_rng_type'.
+'gsl_rng_type' which holds static information about each type of
+generator and 'gsl_rng' which describes an instance of a generator
+created from a given 'gsl_rng_type'.
 
    The functions described in this section are declared in the header
-file `gsl_rng.h'.
+file 'gsl_rng.h'.
 
 
 File: gsl-ref.info,  Node: Random number generator initialization,  Next: Sampling from a random number generator,  Prev: The Random Number Generator Interface,  Up: Random Number Generation
@@ -4065,34 +4030,34 @@ File: gsl-ref.info,  Node: Random number generator initialization,  Next: Sampli
 
  -- Function: gsl_rng * gsl_rng_alloc (const gsl_rng_type * T)
      This function returns a pointer to a newly-created instance of a
-     random number generator of type T.  For example, the following
-     code creates an instance of the Tausworthe generator,
+     random number generator of type T.  For example, the following code
+     creates an instance of the Tausworthe generator,
 
           gsl_rng * r = gsl_rng_alloc (gsl_rng_taus);
 
      If there is insufficient memory to create the generator then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
      The generator is automatically initialized with the default seed,
-     `gsl_rng_default_seed'.  This is zero by default but can be changed
-     either directly or by using the environment variable `GSL_RNG_SEED'
+     'gsl_rng_default_seed'.  This is zero by default but can be changed
+     either directly or by using the environment variable 'GSL_RNG_SEED'
      (*note Random number environment variables::).
 
-     The details of the available generator types are described later
-     in this chapter.
+     The details of the available generator types are described later in
+     this chapter.
 
  -- Function: void gsl_rng_set (const gsl_rng * R, unsigned long int S)
-     This function initializes (or `seeds') the random number
-     generator.  If the generator is seeded with the same value of S on
-     two different runs, the same stream of random numbers will be
-     generated by successive calls to the routines below.  If different
-     values of S are supplied, then the generated streams of random
-     numbers should be completely different.  If the seed S is zero
-     then the standard seed from the original implementation is used
-     instead.  For example, the original Fortran source code for the
-     `ranlux' generator used a seed of 314159265, and so choosing S
-     equal to zero reproduces this when using `gsl_rng_ranlux'.
+     This function initializes (or 'seeds') the random number generator.
+     If the generator is seeded with the same value of S on two
+     different runs, the same stream of random numbers will be generated
+     by successive calls to the routines below.  If different values of
+     S are supplied, then the generated streams of random numbers should
+     be completely different.  If the seed S is zero then the standard
+     seed from the original implementation is used instead.  For
+     example, the original Fortran source code for the 'ranlux'
+     generator used a seed of 314159265, and so choosing S equal to zero
+     reproduces this when using 'gsl_rng_ranlux'.
 
  -- Function: void gsl_rng_free (gsl_rng * R)
      This function frees all the memory associated with the generator R.
@@ -4112,25 +4077,25 @@ obtain non-uniform distributions *note Random Number Distributions::.
      minimum and maximum values depend on the algorithm used, but all
      integers in the range [MIN,MAX] are equally likely.  The values of
      MIN and MAX can determined using the auxiliary functions
-     `gsl_rng_max (r)' and `gsl_rng_min (r)'.
+     'gsl_rng_max (r)' and 'gsl_rng_min (r)'.
 
  -- Function: double gsl_rng_uniform (const gsl_rng * R)
      This function returns a double precision floating point number
      uniformly distributed in the range [0,1).  The range includes 0.0
      but excludes 1.0.  The value is typically obtained by dividing the
-     result of `gsl_rng_get(r)' by `gsl_rng_max(r) + 1.0' in double
+     result of 'gsl_rng_get(r)' by 'gsl_rng_max(r) + 1.0' in double
      precision.  Some generators compute this ratio internally so that
      they can provide floating point numbers with more than 32 bits of
      randomness (the maximum number of bits that can be portably
-     represented in a single `unsigned long int').
+     represented in a single 'unsigned long int').
 
  -- Function: double gsl_rng_uniform_pos (const gsl_rng * R)
      This function returns a positive double precision floating point
-     number uniformly distributed in the range (0,1), excluding both
-     0.0 and 1.0.  The number is obtained by sampling the generator
-     with the algorithm of `gsl_rng_uniform' until a non-zero value is
-     obtained.  You can use this function if you need to avoid a
-     singularity at 0.0.
+     number uniformly distributed in the range (0,1), excluding both 0.0
+     and 1.0.  The number is obtained by sampling the generator with the
+     algorithm of 'gsl_rng_uniform' until a non-zero value is obtained.
+     You can use this function if you need to avoid a singularity at
+     0.0.
 
  -- Function: unsigned long int gsl_rng_uniform_int (const gsl_rng * R,
           unsigned long int N)
@@ -4142,16 +4107,16 @@ obtain non-uniform distributions *note Random Number Distributions::.
 
      Note that this function is designed for sampling from ranges
      smaller than the range of the underlying generator.  The parameter
-     N must be less than or equal to the range of the generator R.  If
-     N is larger than the range of the generator then the function
-     calls the error handler with an error code of `GSL_EINVAL' and
-     returns zero.
+     N must be less than or equal to the range of the generator R.  If N
+     is larger than the range of the generator then the function calls
+     the error handler with an error code of 'GSL_EINVAL' and returns
+     zero.
 
      In particular, this function is not intended for generating the
-     full range of unsigned integer values [0,2^32-1]. Instead choose a
+     full range of unsigned integer values [0,2^32-1].  Instead choose a
      generator with the maximal integer range and zero mimimum value,
-     such as `gsl_rng_ranlxd1', `gsl_rng_mt19937' or `gsl_rng_taus',
-     and sample it directly using `gsl_rng_get'.  The range of each
+     such as 'gsl_rng_ranlxd1', 'gsl_rng_mt19937' or 'gsl_rng_taus', and
+     sample it directly using 'gsl_rng_get'.  The range of each
      generator can be found using the auxiliary functions described in
      the next section.
 
@@ -4161,9 +4126,9 @@ File: gsl-ref.info,  Node: Auxiliary random number generator functions,  Next: R
 17.5 Auxiliary random number generator functions
 ================================================
 
-The following functions provide information about an existing
-generator.  You should use them in preference to hard-coding the
-generator parameters into your own code.
+The following functions provide information about an existing generator.
+You should use them in preference to hard-coding the generator
+parameters into your own code.
 
  -- Function: const char * gsl_rng_name (const gsl_rng * R)
      This function returns a pointer to the name of the generator.  For
@@ -4172,14 +4137,14 @@ generator parameters into your own code.
           printf ("r is a '%s' generator\n",
                   gsl_rng_name (r));
 
-     would print something like `r is a 'taus' generator'.
+     would print something like 'r is a 'taus' generator'.
 
  -- Function: unsigned long int gsl_rng_max (const gsl_rng * R)
-     `gsl_rng_max' returns the largest value that `gsl_rng_get' can
+     'gsl_rng_max' returns the largest value that 'gsl_rng_get' can
      return.
 
  -- Function: unsigned long int gsl_rng_min (const gsl_rng * R)
-     `gsl_rng_min' returns the smallest value that `gsl_rng_get' can
+     'gsl_rng_min' returns the smallest value that 'gsl_rng_get' can
      return.  Usually this value is zero.  There are some generators
      with algorithms that cannot return zero, and for these generators
      the minimum value is 1.
@@ -4197,7 +4162,7 @@ generator parameters into your own code.
 
  -- Function: const gsl_rng_type ** gsl_rng_types_setup (void)
      This function returns a pointer to an array of all the available
-     generator types, terminated by a null pointer. The function should
+     generator types, terminated by a null pointer.  The function should
      be called once at the start of the program, if needed.  The
      following code fragment shows how to iterate over the array of
      generator types to print the names of the available algorithms,
@@ -4220,32 +4185,31 @@ File: gsl-ref.info,  Node: Random number environment variables,  Next: Copying r
 ========================================
 
 The library allows you to choose a default generator and seed from the
-environment variables `GSL_RNG_TYPE' and `GSL_RNG_SEED' and the
-function `gsl_rng_env_setup'.  This makes it easy try out different
-generators and seeds without having to recompile your program.
+environment variables 'GSL_RNG_TYPE' and 'GSL_RNG_SEED' and the function
+'gsl_rng_env_setup'.  This makes it easy try out different generators
+and seeds without having to recompile your program.
 
  -- Function: const gsl_rng_type * gsl_rng_env_setup (void)
-     This function reads the environment variables `GSL_RNG_TYPE' and
-     `GSL_RNG_SEED' and uses their values to set the corresponding
-     library variables `gsl_rng_default' and `gsl_rng_default_seed'.
+     This function reads the environment variables 'GSL_RNG_TYPE' and
+     'GSL_RNG_SEED' and uses their values to set the corresponding
+     library variables 'gsl_rng_default' and 'gsl_rng_default_seed'.
      These global variables are defined as follows,
 
           extern const gsl_rng_type *gsl_rng_default
           extern unsigned long int gsl_rng_default_seed
 
-     The environment variable `GSL_RNG_TYPE' should be the name of a
-     generator, such as `taus' or `mt19937'.  The environment variable
-     `GSL_RNG_SEED' should contain the desired seed value.  It is
-     converted to an `unsigned long int' using the C library function
-     `strtoul'.
-
-     If you don't specify a generator for `GSL_RNG_TYPE' then
-     `gsl_rng_mt19937' is used as the default.  The initial value of
-     `gsl_rng_default_seed' is zero.
+     The environment variable 'GSL_RNG_TYPE' should be the name of a
+     generator, such as 'taus' or 'mt19937'.  The environment variable
+     'GSL_RNG_SEED' should contain the desired seed value.  It is
+     converted to an 'unsigned long int' using the C library function
+     'strtoul'.
 
+     If you don't specify a generator for 'GSL_RNG_TYPE' then
+     'gsl_rng_mt19937' is used as the default.  The initial value of
+     'gsl_rng_default_seed' is zero.
 
 Here is a short program which shows how to create a global generator
-using the environment variables `GSL_RNG_TYPE' and `GSL_RNG_SEED',
+using the environment variables 'GSL_RNG_TYPE' and 'GSL_RNG_SEED',
 
      #include <stdio.h>
      #include <gsl/gsl_rng.h>
@@ -4271,7 +4235,7 @@ using the environment variables `GSL_RNG_TYPE' and `GSL_RNG_SEED',
      }
 
 Running the program without any environment variables uses the initial
-defaults, an `mt19937' generator with a seed of 0,
+defaults, an 'mt19937' generator with a seed of 0,
 
      $ ./a.out
      generator type: mt19937
@@ -4294,15 +4258,15 @@ File: gsl-ref.info,  Node: Copying random number generator state,  Next: Reading
 17.7 Copying random number generator state
 ==========================================
 
-The above methods do not expose the random number `state' which changes
+The above methods do not expose the random number 'state' which changes
 from call to call.  It is often useful to be able to save and restore
 the state.  To permit these practices, a few somewhat more advanced
 functions are supplied.  These include:
 
  -- Function: int gsl_rng_memcpy (gsl_rng * DEST, const gsl_rng * SRC)
      This function copies the random number generator SRC into the
-     pre-existing generator DEST, making DEST into an exact copy of
-     SRC.  The two generators must be of the same type.
+     pre-existing generator DEST, making DEST into an exact copy of SRC.
+     The two generators must be of the same type.
 
  -- Function: gsl_rng * gsl_rng_clone (const gsl_rng * R)
      This function returns a pointer to a newly created generator which
@@ -4314,13 +4278,13 @@ File: gsl-ref.info,  Node: Reading and writing random number generator state,  N
 17.8 Reading and writing random number generator state
 ======================================================
 
-The library provides functions for reading and writing the random
-number state to a file as binary data or formatted text.
+The library provides functions for reading and writing the random number
+state to a file as binary data or formatted text.
 
  -- Function: int gsl_rng_fwrite (FILE * STREAM, const gsl_rng * R)
      This function writes the random number state of the random number
      generator R to the stream STREAM in binary format.  The return
-     value is 0 for success and `GSL_EFAILED' if there was a problem
+     value is 0 for success and 'GSL_EFAILED' if there was a problem
      writing to the file.  Since the data is written in the native
      binary format it may not be portable between different
      architectures.
@@ -4330,7 +4294,7 @@ number state to a file as binary data or formatted text.
      generator R from the open stream STREAM in binary format.  The
      random number generator R must be preinitialized with the correct
      random number generator type since type information is not saved.
-     The return value is 0 for success and `GSL_EFAILED' if there was a
+     The return value is 0 for success and 'GSL_EFAILED' if there was a
      problem reading from the file.  The data is assumed to have been
      written in the native binary format on the same architecture.
 
@@ -4362,70 +4326,72 @@ randomness.
      statistical tests.  It uses 624 words of state per generator and is
      comparable in speed to the other generators.  The original
      generator used a default seed of 4357 and choosing S equal to zero
-     in `gsl_rng_set' reproduces this.  Later versions switched to 5489
+     in 'gsl_rng_set' reproduces this.  Later versions switched to 5489
      as the default seed, you can choose this explicitly via
-     `gsl_rng_set' instead if you require it.
+     'gsl_rng_set' instead if you require it.
 
      For more information see,
           Makoto Matsumoto and Takuji Nishimura, "Mersenne Twister: A
           623-dimensionally equidistributed uniform pseudorandom number
-          generator". `ACM Transactions on Modeling and Computer
-          Simulation', Vol. 8, No. 1 (Jan. 1998), Pages 3-30
+          generator".  'ACM Transactions on Modeling and Computer
+          Simulation', Vol. 8, No. 1 (Jan.  1998), Pages 3-30
 
-     The generator `gsl_rng_mt19937' uses the second revision of the
+     The generator 'gsl_rng_mt19937' uses the second revision of the
      seeding procedure published by the two authors above in 2002.  The
-     original seeding procedures could cause spurious artifacts for
-     some seed values. They are still available through the alternative
-     generators `gsl_rng_mt19937_1999' and `gsl_rng_mt19937_1998'.
+     original seeding procedures could cause spurious artifacts for some
+     seed values.  They are still available through the alternative
+     generators 'gsl_rng_mt19937_1999' and 'gsl_rng_mt19937_1998'.
 
  -- Generator: gsl_rng_ranlxs0
  -- Generator: gsl_rng_ranlxs1
  -- Generator: gsl_rng_ranlxs2
-     The generator `ranlxs0' is a second-generation version of the
+
+     The generator 'ranlxs0' is a second-generation version of the
      RANLUX algorithm of Lu"scher, which produces "luxury random
      numbers".  This generator provides single precision output (24
-     bits) at three luxury levels `ranlxs0', `ranlxs1' and `ranlxs2',
-     in increasing order of strength.  It uses double-precision
-     floating point arithmetic internally and can be significantly
-     faster than the integer version of `ranlux', particularly on
-     64-bit architectures.  The period of the generator is about
-     10^171.  The algorithm has mathematically proven properties and
-     can provide truly decorrelated numbers at a known level of
-     randomness.  The higher luxury levels provide increased
-     decorrelation between samples as an additional safety margin.
+     bits) at three luxury levels 'ranlxs0', 'ranlxs1' and 'ranlxs2', in
+     increasing order of strength.  It uses double-precision floating
+     point arithmetic internally and can be significantly faster than
+     the integer version of 'ranlux', particularly on 64-bit
+     architectures.  The period of the generator is about 10^171.  The
+     algorithm has mathematically proven properties and can provide
+     truly decorrelated numbers at a known level of randomness.  The
+     higher luxury levels provide increased decorrelation between
+     samples as an additional safety margin.
 
  -- Generator: gsl_rng_ranlxd1
  -- Generator: gsl_rng_ranlxd2
+
      These generators produce double precision output (48 bits) from the
-     RANLXS generator.  The library provides two luxury levels
-     `ranlxd1' and `ranlxd2', in increasing order of strength.
+     RANLXS generator.  The library provides two luxury levels 'ranlxd1'
+     and 'ranlxd2', in increasing order of strength.
 
  -- Generator: gsl_rng_ranlux
  -- Generator: gsl_rng_ranlux389
-     The `ranlux' generator is an implementation of the original
+
+     The 'ranlux' generator is an implementation of the original
      algorithm developed by Lu"scher.  It uses a
      lagged-fibonacci-with-skipping algorithm to produce "luxury random
      numbers".  It is a 24-bit generator, originally designed for
      single-precision IEEE floating point numbers.  This implementation
      is based on integer arithmetic, while the second-generation
      versions RANLXS and RANLXD described above provide floating-point
-     implementations which will be faster on many platforms.  The
-     period of the generator is about 10^171.  The algorithm has
-     mathematically proven properties and it can provide truly
-     decorrelated numbers at a known level of randomness.  The default
-     level of decorrelation recommended by Lu"scher is provided by
-     `gsl_rng_ranlux', while `gsl_rng_ranlux389' gives the highest
-     level of randomness, with all 24 bits decorrelated.  Both types of
-     generator use 24 words of state per generator.
+     implementations which will be faster on many platforms.  The period
+     of the generator is about 10^171.  The algorithm has mathematically
+     proven properties and it can provide truly decorrelated numbers at
+     a known level of randomness.  The default level of decorrelation
+     recommended by Lu"scher is provided by 'gsl_rng_ranlux', while
+     'gsl_rng_ranlux389' gives the highest level of randomness, with all
+     24 bits decorrelated.  Both types of generator use 24 words of
+     state per generator.
 
      For more information see,
           M. Lu"scher, "A portable high-quality random number generator
-          for lattice field theory calculations", `Computer Physics
+          for lattice field theory calculations", 'Computer Physics
           Communications', 79 (1994) 100-110.
-
           F. James, "RANLUX: A Fortran implementation of the
           high-quality pseudo-random number generator of Lu"scher",
-          `Computer Physics Communications', 79 (1994) 111-114
+          'Computer Physics Communications', 79 (1994) 111-114
 
  -- Generator: gsl_rng_cmrg
      This is a combined multiple recursive generator by L'Ecuyer.  Its
@@ -4447,7 +4413,7 @@ randomness.
      generator.  For more information see,
 
           P. L'Ecuyer, "Combined Multiple Recursive Random Number
-          Generators", `Operations Research', 44, 5 (1996), 816-822.
+          Generators", 'Operations Research', 44, 5 (1996), 816-822.
 
  -- Generator: gsl_rng_mrg
      This is a fifth-order multiple recursive generator by L'Ecuyer,
@@ -4462,7 +4428,7 @@ randomness.
      state per generator.  More information can be found in the
      following paper,
           P. L'Ecuyer, F. Blouin, and R. Coutre, "A search for good
-          multiple recursive random number generators", `ACM
+          multiple recursive random number generators", 'ACM
           Transactions on Modeling and Computer Simulation' 3, 87-98
           (1993).
 
@@ -4482,29 +4448,29 @@ randomness.
      computed modulo 2^32.  In the formulas above ^^ denotes
      "exclusive-or".  Note that the algorithm relies on the properties
      of 32-bit unsigned integers and has been implemented using a
-     bitmask of `0xFFFFFFFF' to make it work on 64 bit machines.
+     bitmask of '0xFFFFFFFF' to make it work on 64 bit machines.
 
      The period of this generator is 2^88 (about 10^26).  It uses 3
      words of state per generator.  For more information see,
 
           P. L'Ecuyer, "Maximally Equidistributed Combined Tausworthe
-          Generators", `Mathematics of Computation', 65, 213 (1996),
+          Generators", 'Mathematics of Computation', 65, 213 (1996),
           203-213.
 
-     The generator `gsl_rng_taus2' uses the same algorithm as
-     `gsl_rng_taus' but with an improved seeding procedure described in
+     The generator 'gsl_rng_taus2' uses the same algorithm as
+     'gsl_rng_taus' but with an improved seeding procedure described in
      the paper,
 
           P. L'Ecuyer, "Tables of Maximally Equidistributed Combined
-          LFSR Generators", `Mathematics of Computation', 68, 225
+          LFSR Generators", 'Mathematics of Computation', 68, 225
           (1999), 261-269
 
-     The generator `gsl_rng_taus2' should now be used in preference to
-     `gsl_rng_taus'.
+     The generator 'gsl_rng_taus2' should now be used in preference to
+     'gsl_rng_taus'.
 
  -- Generator: gsl_rng_gfsr4
-     The `gfsr4' generator is like a lagged-fibonacci generator, and
-     produces each number as an `xor''d sum of four previous values.
+     The 'gfsr4' generator is like a lagged-fibonacci generator, and
+     produces each number as an 'xor''d sum of four previous values.
 
           r_n = r_{n-A} ^^ r_{n-B} ^^ r_{n-C} ^^ r_{n-D}
 
@@ -4520,11 +4486,11 @@ randomness.
      of Ziff's article: A=471, B=1586, C=6988, D=9689.
 
      If the offsets are appropriately chosen (such as the one ones in
-     this implementation), then the sequence is said to be maximal;
-     that means that the period is 2^D - 1, where D is the longest lag.
-     (It is one less than 2^D because it is not permitted to have all
-     zeros in the `ra[]' array.)  For this implementation with D=9689
-     that works out to about 10^2917.
+     this implementation), then the sequence is said to be maximal; that
+     means that the period is 2^D - 1, where D is the longest lag.  (It
+     is one less than 2^D because it is not permitted to have all zeros
+     in the 'ra[]' array.)  For this implementation with D=9689 that
+     works out to about 10^2917.
 
      Note that the implementation of this generator using a 32-bit
      integer amounts to 32 parallel implementations of one-bit
@@ -4537,7 +4503,7 @@ randomness.
 
      For more information see,
           Robert M. Ziff, "Four-tap shift-register-sequence
-          random-number generators", `Computers in Physics', 12(4),
+          random-number generators", 'Computers in Physics', 12(4),
           Jul/Aug 1998, pp 385-392.
 
 
@@ -4546,19 +4512,19 @@ File: gsl-ref.info,  Node: Unix random number generators,  Next: Other random nu
 17.10 Unix random number generators
 ===================================
 
-The standard Unix random number generators `rand', `random' and
-`rand48' are provided as part of GSL. Although these generators are
-widely available individually often they aren't all available on the
-same platform.  This makes it difficult to write portable code using
-them and so we have included the complete set of Unix generators in GSL
-for convenience.  Note that these generators don't produce high-quality
+The standard Unix random number generators 'rand', 'random' and 'rand48'
+are provided as part of GSL. Although these generators are widely
+available individually often they aren't all available on the same
+platform.  This makes it difficult to write portable code using them and
+so we have included the complete set of Unix generators in GSL for
+convenience.  Note that these generators don't produce high-quality
 randomness and aren't suitable for work requiring accurate statistics.
 However, if you won't be measuring statistical quantities and just want
 to introduce some variation into your program then these generators are
 quite acceptable.
 
  -- Generator: gsl_rng_rand
-     This is the BSD `rand' generator.  Its sequence is
+     This is the BSD 'rand' generator.  Its sequence is
 
           x_{n+1} = (a x_n + c) mod m
 
@@ -4569,20 +4535,20 @@ quite acceptable.
  -- Generator: gsl_rng_random_bsd
  -- Generator: gsl_rng_random_libc5
  -- Generator: gsl_rng_random_glibc2
-     These generators implement the `random' family of functions, a set
+     These generators implement the 'random' family of functions, a set
      of linear feedback shift register generators originally used in BSD
-     Unix.  There are several versions of `random' in use today: the
-     original BSD version (e.g. on SunOS4), a libc5 version (found on
+     Unix.  There are several versions of 'random' in use today: the
+     original BSD version (e.g.  on SunOS4), a libc5 version (found on
      older GNU/Linux systems) and a glibc2 version.  Each version uses a
      different seeding procedure, and thus produces different sequences.
 
      The original BSD routines accepted a variable length buffer for the
      generator state, with longer buffers providing higher-quality
-     randomness.  The `random' function implemented algorithms for
+     randomness.  The 'random' function implemented algorithms for
      buffer lengths of 8, 32, 64, 128 and 256 bytes, and the algorithm
      with the largest length that would fit into the user-supplied
-     buffer was used.  To support these algorithms additional
-     generators are available with the following names,
+     buffer was used.  To support these algorithms additional generators
+     are available with the following names,
 
           gsl_rng_random8_bsd
           gsl_rng_random32_bsd
@@ -4590,31 +4556,30 @@ quite acceptable.
           gsl_rng_random128_bsd
           gsl_rng_random256_bsd
 
-     where the numeric suffix indicates the buffer length.  The
-     original BSD `random' function used a 128-byte default buffer and
-     so `gsl_rng_random_bsd' has been made equivalent to
-     `gsl_rng_random128_bsd'.  Corresponding versions of the `libc5'
-     and `glibc2' generators are also available, with the names
-     `gsl_rng_random8_libc5', `gsl_rng_random8_glibc2', etc.
+     where the numeric suffix indicates the buffer length.  The original
+     BSD 'random' function used a 128-byte default buffer and so
+     'gsl_rng_random_bsd' has been made equivalent to
+     'gsl_rng_random128_bsd'.  Corresponding versions of the 'libc5' and
+     'glibc2' generators are also available, with the names
+     'gsl_rng_random8_libc5', 'gsl_rng_random8_glibc2', etc.
 
  -- Generator: gsl_rng_rand48
-     This is the Unix `rand48' generator.  Its sequence is
+     This is the Unix 'rand48' generator.  Its sequence is
 
           x_{n+1} = (a x_n + c) mod m
 
      defined on 48-bit unsigned integers with a = 25214903917, c = 11
      and m = 2^48.  The seed specifies the upper 32 bits of the initial
-     value, x_1, with the lower 16 bits set to `0x330E'.  The function
-     `gsl_rng_get' returns the upper 32 bits from each term of the
+     value, x_1, with the lower 16 bits set to '0x330E'.  The function
+     'gsl_rng_get' returns the upper 32 bits from each term of the
      sequence.  This does not have a direct parallel in the original
-     `rand48' functions, but forcing the result to type `long int'
-     reproduces the output of `mrand48'.  The function
-     `gsl_rng_uniform' uses the full 48 bits of internal state to return
-     the double precision number x_n/m, which is equivalent to the
-     function `drand48'.  Note that some versions of the GNU C Library
-     contained a bug in `mrand48' function which caused it to produce
-     different results (only the lower 16-bits of the return value were
-     set).
+     'rand48' functions, but forcing the result to type 'long int'
+     reproduces the output of 'mrand48'.  The function 'gsl_rng_uniform'
+     uses the full 48 bits of internal state to return the double
+     precision number x_n/m, which is equivalent to the function
+     'drand48'.  Note that some versions of the GNU C Library contained
+     a bug in 'mrand48' function which caused it to produce different
+     results (only the lower 16-bits of the return value were set).
 
 
 File: gsl-ref.info,  Node: Other random number generators,  Next: Random Number Generator Performance,  Prev: Unix random number generators,  Up: Random Number Generation
@@ -4639,14 +4604,14 @@ having any randomness.  Thus if you want to produce a random bitstream
 it is best to avoid using the least significant bits.
 
  -- Generator: gsl_rng_ranf
-     This is the CRAY random number generator `RANF'.  Its sequence is
+     This is the CRAY random number generator 'RANF'.  Its sequence is
 
           x_{n+1} = (a x_n) mod m
 
-     defined on 48-bit unsigned integers with a = 44485709377909 and m
-     = 2^48.  The seed specifies the lower 32 bits of the initial value,
+     defined on 48-bit unsigned integers with a = 44485709377909 and m =
+     2^48.  The seed specifies the lower 32 bits of the initial value,
      x_1, with the lowest bit set to prevent the seed taking an even
-     value.  The upper 16 bits of x_1 are set to 0. A consequence of
+     value.  The upper 16 bits of x_1 are set to 0.  A consequence of
      this procedure is that the pairs of seeds 2 and 3, 4 and 5, etc
      produce the same sequences.
 
@@ -4659,12 +4624,12 @@ it is best to avoid using the least significant bits.
      modular inverse of a mod m.  This is done for compatibility with
      the original CRAY implementation.
 
-     Note that you can only seed the generator with integers up to
-     2^32, while the original CRAY implementation uses non-portable
-     wide integers which can cover all 2^48 states of the generator.
+     Note that you can only seed the generator with integers up to 2^32,
+     while the original CRAY implementation uses non-portable wide
+     integers which can cover all 2^48 states of the generator.
 
-     The function `gsl_rng_get' returns the upper 32 bits from each term
-     of the sequence.  The function `gsl_rng_uniform' uses the full 48
+     The function 'gsl_rng_get' returns the upper 32 bits from each term
+     of the sequence.  The function 'gsl_rng_uniform' uses the full 48
      bits to return the double precision number x_n/m.
 
      The period of this generator is 2^46.
@@ -4687,7 +4652,7 @@ it is best to avoid using the least significant bits.
 
      For more information see,
           S. Kirkpatrick and E. Stoll, "A very fast shift-register
-          sequence random number generator", `Journal of Computational
+          sequence random number generator", 'Journal of Computational
           Physics', 40, 517-526 (1981)
 
  -- Generator: gsl_rng_tt800
@@ -4699,17 +4664,17 @@ it is best to avoid using the least significant bits.
 
      For more information see,
           Makoto Matsumoto and Yoshiharu Kurita, "Twisted GFSR
-          Generators II", `ACM Transactions on Modelling and Computer
+          Generators II", 'ACM Transactions on Modelling and Computer
           Simulation', Vol. 4, No. 3, 1994, pages 254-266.
 
  -- Generator: gsl_rng_vax
-     This is the VAX generator `MTH$RANDOM'.  Its sequence is,
+     This is the VAX generator 'MTH$RANDOM'.  Its sequence is,
 
           x_{n+1} = (a x_n + c) mod m
 
-     with a = 69069, c = 1 and m = 2^32.  The seed specifies the
-     initial value, x_1.  The period of this generator is 2^32 and it
-     uses 1 word of storage per generator.
+     with a = 69069, c = 1 and m = 2^32.  The seed specifies the initial
+     value, x_1.  The period of this generator is 2^32 and it uses 1
+     word of storage per generator.
 
  -- Generator: gsl_rng_transputer
      This is the random number generator from the INMOS Transputer
@@ -4721,7 +4686,7 @@ it is best to avoid using the least significant bits.
      value, x_1.
 
  -- Generator: gsl_rng_randu
-     This is the IBM `RANDU' generator.  Its sequence is
+     This is the IBM 'RANDU' generator.  Its sequence is
 
           x_{n+1} = (a x_n) mod m
 
@@ -4745,16 +4710,16 @@ it is best to avoid using the least significant bits.
      acronym "GGL" (I'm not sure what that stands for).
 
      For more information see,
-          Park and Miller, "Random Number Generators: Good ones are
-          hard to find", `Communications of the ACM', October 1988,
-          Volume 31, No 10, pages 1192-1201.
+          Park and Miller, "Random Number Generators: Good ones are hard
+          to find", 'Communications of the ACM', October 1988, Volume
+          31, No 10, pages 1192-1201.
 
  -- Generator: gsl_rng_uni
  -- Generator: gsl_rng_uni32
      This is a reimplementation of the 16-bit SLATEC random number
      generator RUNIF. A generalization of the generator to 32 bits is
-     provided by `gsl_rng_uni32'.  The original source code is
-     available from NETLIB.
+     provided by 'gsl_rng_uni32'.  The original source code is available
+     from NETLIB.
 
  -- Generator: gsl_rng_slatec
      This is the SLATEC random number generator RAND. It is ancient.
@@ -4767,15 +4732,15 @@ it is best to avoid using the least significant bits.
           t = u_{n-273} + u_{n-607}
           u_n  = t - floor(t)
 
-     The original source code is available from NETLIB.  For more
+     The original source code is available from NETLIB. For more
      information see,
           W. Petersen, "Lagged Fibonacci Random Number Generators for
-          the NEC SX-3", `International Journal of High Speed
-          Computing' (1994).
+          the NEC SX-3", 'International Journal of High Speed Computing'
+          (1994).
 
  -- Generator: gsl_rng_knuthran2
      This is a second-order multiple recursive generator described by
-     Knuth in `Seminumerical Algorithms', 3rd Ed., page 108.  Its
+     Knuth in 'Seminumerical Algorithms', 3rd Ed., page 108.  Its
      sequence is,
 
           x_n = (a_1 x_{n-1} + a_2 x_{n-2}) mod m
@@ -4785,10 +4750,10 @@ it is best to avoid using the least significant bits.
  -- Generator: gsl_rng_knuthran2002
  -- Generator: gsl_rng_knuthran
      This is a second-order multiple recursive generator described by
-     Knuth in `Seminumerical Algorithms', 3rd Ed., Section 3.6.  Knuth
-     provides its C code.  The updated routine `gsl_rng_knuthran2002'
-     is from the revised 9th printing and corrects some weaknesses in
-     the earlier version, which is implemented as `gsl_rng_knuthran'.
+     Knuth in 'Seminumerical Algorithms', 3rd Ed., Section 3.6.  Knuth
+     provides its C code.  The updated routine 'gsl_rng_knuthran2002' is
+     from the revised 9th printing and corrects some weaknesses in the
+     earlier version, which is implemented as 'gsl_rng_knuthran'.
 
  -- Generator: gsl_rng_borosh13
  -- Generator: gsl_rng_fishman18
@@ -4796,7 +4761,7 @@ it is best to avoid using the least significant bits.
  -- Generator: gsl_rng_lecuyer21
  -- Generator: gsl_rng_waterman14
      These multiplicative generators are taken from Knuth's
-     `Seminumerical Algorithms', 3rd Ed., pages 106-108. Their sequence
+     'Seminumerical Algorithms', 3rd Ed., pages 106-108.  Their sequence
      is,
 
           x_{n+1} = (a x_n) mod m
@@ -4808,19 +4773,18 @@ it is best to avoid using the least significant bits.
      1566083941, m = 2^32.
 
  -- Generator: gsl_rng_fishman2x
-     This is the L'Ecuyer-Fishman random number generator. It is taken
-     from Knuth's `Seminumerical Algorithms', 3rd Ed., page 108. Its
+     This is the L'Ecuyer-Fishman random number generator.  It is taken
+     from Knuth's 'Seminumerical Algorithms', 3rd Ed., page 108.  Its
      sequence is,
 
           z_{n+1} = (x_n - y_n) mod m
 
-     with m = 2^31 - 1.  x_n and y_n are given by the `fishman20' and
-     `lecuyer21' algorithms.  The seed specifies the initial value, x_1.
-
+     with m = 2^31 - 1.  x_n and y_n are given by the 'fishman20' and
+     'lecuyer21' algorithms.  The seed specifies the initial value, x_1.
 
  -- Generator: gsl_rng_coveyou
-     This is the Coveyou random number generator. It is taken from
-     Knuth's `Seminumerical Algorithms', 3rd Ed., Section 3.2.2. Its
+     This is the Coveyou random number generator.  It is taken from
+     Knuth's 'Seminumerical Algorithms', 3rd Ed., Section 3.2.2.  Its
      sequence is,
 
           x_{n+1} = (x_n (x_n + 1)) mod m
@@ -4835,7 +4799,7 @@ File: gsl-ref.info,  Node: Random Number Generator Performance,  Next: Random Nu
 
 The following table shows the relative performance of a selection the
 available random number generators.  The fastest simulation quality
-generators are `taus', `gfsr4' and `mt19937'.  The generators which
+generators are 'taus', 'gfsr4' and 'mt19937'.  The generators which
 offer the best mathematically-proven quality are those based on the
 RANLUX algorithm.
 
@@ -4908,11 +4872,11 @@ Here is the output of the program,
      0.73995
 
 The numbers depend on the seed used by the generator.  The default seed
-can be changed with the `GSL_RNG_SEED' environment variable to produce
-a different stream of numbers.  The generator itself can be changed
-using the environment variable `GSL_RNG_TYPE'.  Here is the output of
-the program using a seed value of 123 and the multiple-recursive
-generator `mrg',
+can be changed with the 'GSL_RNG_SEED' environment variable to produce a
+different stream of numbers.  The generator itself can be changed using
+the environment variable 'GSL_RNG_TYPE'.  Here is the output of the
+program using a seed value of 123 and the multiple-recursive generator
+'mrg',
 
      $ GSL_RNG_SEED=123 GSL_RNG_TYPE=mrg ./a.out
      GSL_RNG_TYPE=mrg
@@ -4935,9 +4899,9 @@ File: gsl-ref.info,  Node: Random Number References and Further Reading,  Next:
 ====================================
 
 The subject of random number generation and testing is reviewed
-extensively in Knuth's `Seminumerical Algorithms'.
+extensively in Knuth's 'Seminumerical Algorithms'.
 
-     Donald E. Knuth, `The Art of Computer Programming: Seminumerical
+     Donald E. Knuth, 'The Art of Computer Programming: Seminumerical
      Algorithms' (Vol 2, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896842.
 
 Further information is available in the review paper written by Pierre
@@ -4946,15 +4910,14 @@ L'Ecuyer,
      P. L'Ecuyer, "Random Number Generation", Chapter 4 of the Handbook
      on Simulation, Jerry Banks Ed., Wiley, 1998, 93-137.
 
-     `http://www.iro.umontreal.ca/~lecuyer/papers.html' in the file
-     `handsim.ps'.
+     <http://www.iro.umontreal.ca/~lecuyer/papers.html> in the file
+     'handsim.ps'.
 
 The source code for the DIEHARD random number generator tests is also
 available online,
 
-     `DIEHARD source code' G. Marsaglia,
-
-     `http://stat.fsu.edu/pub/diehard/'
+     'DIEHARD source code' G. Marsaglia,
+     <http://stat.fsu.edu/pub/diehard/>
 
 A comprehensive set of random number generator tests is available from
 NIST,
@@ -4962,8 +4925,7 @@ NIST,
      NIST Special Publication 800-22, "A Statistical Test Suite for the
      Validation of Random Number Generators and Pseudo Random Number
      Generators for Cryptographic Applications".
-
-     `http://csrc.nist.gov/rng/'
+     <http://csrc.nist.gov/rng/>
 
 
 File: gsl-ref.info,  Node: Random Number Acknowledgements,  Prev: Random Number References and Further Reading,  Up: Random Number Generation
@@ -4985,24 +4947,24 @@ File: gsl-ref.info,  Node: Quasi-Random Sequences,  Next: Random Number Distribu
 
 This chapter describes functions for generating quasi-random sequences
 in arbitrary dimensions.  A quasi-random sequence progressively covers a
-d-dimensional space with a set of points that are uniformly
-distributed.  Quasi-random sequences are also known as low-discrepancy
-sequences.  The quasi-random sequence generators use an interface that
-is similar to the interface for random number generators, except that
-seeding is not required--each generator produces a single sequence.
+d-dimensional space with a set of points that are uniformly distributed.
+Quasi-random sequences are also known as low-discrepancy sequences.  The
+quasi-random sequence generators use an interface that is similar to the
+interface for random number generators, except that seeding is not
+required--each generator produces a single sequence.
 
    The functions described in this section are declared in the header
-file `gsl_qrng.h'.
+file 'gsl_qrng.h'.
 
 * Menu:
 
-* Quasi-random number generator initialization::
-* Sampling from a quasi-random number generator::
-* Auxiliary quasi-random number generator functions::
-* Saving and resorting quasi-random number generator state::
-* Quasi-random number generator algorithms::
-* Quasi-random number generator examples::
-* Quasi-random number references::
+* Quasi-random number generator initialization::  
+* Sampling from a quasi-random number generator::  
+* Auxiliary quasi-random number generator functions::  
+* Saving and resorting quasi-random number generator state::  
+* Quasi-random number generator algorithms::  
+* Quasi-random number generator examples::  
+* Quasi-random number references::  
 
 
 File: gsl-ref.info,  Node: Quasi-random number generator initialization,  Next: Sampling from a quasi-random number generator,  Up: Quasi-Random Sequences
@@ -5016,7 +4978,7 @@ File: gsl-ref.info,  Node: Quasi-random number generator initialization,  Next:
      quasi-random sequence generator of type T and dimension D.  If
      there is insufficient memory to create the generator then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: void gsl_qrng_free (gsl_qrng * Q)
      This function frees all the memory associated with the generator Q.
@@ -5034,9 +4996,9 @@ File: gsl-ref.info,  Node: Sampling from a quasi-random number generator,  Next:
 
  -- Function: int gsl_qrng_get (const gsl_qrng * Q, double X[])
      This function stores the next point from the sequence generator Q
-     in the array X.  The space available for X must match the
-     dimension of the generator.  The point X will lie in the range 0 <
-     x_i < 1 for each x_i.
+     in the array X.  The space available for X must match the dimension
+     of the generator.  The point X will lie in the range 0 < x_i < 1
+     for each x_i.
 
 
 File: gsl-ref.info,  Node: Auxiliary quasi-random number generator functions,  Next: Saving and resorting quasi-random number generator state,  Prev: Sampling from a quasi-random number generator,  Up: Quasi-Random Sequences
@@ -5084,12 +5046,12 @@ The following quasi-random sequence algorithms are available,
 
  -- Generator: gsl_qrng_niederreiter_2
      This generator uses the algorithm described in Bratley, Fox,
-     Niederreiter, `ACM Trans. Model. Comp. Sim.' 2, 195 (1992). It is
+     Niederreiter, 'ACM Trans. Model. Comp. Sim.' 2, 195 (1992).  It is
      valid up to 12 dimensions.
 
  -- Generator: gsl_qrng_sobol
      This generator uses the Sobol sequence described in Antonov,
-     Saleev, `USSR Comput. Maths. Math. Phys.' 19, 252 (1980). It is
+     Saleev, 'USSR Comput. Maths. Math. Phys.' 19, 252 (1980).  It is
      valid up to 40 dimensions.
 
 
@@ -5147,7 +5109,7 @@ the algorithms described in the following paper,
 
      P. Bratley and B.L. Fox and H. Niederreiter, "Algorithm 738:
      Programs to Generate Niederreiter's Low-discrepancy Sequences",
-     `ACM Transactions on Mathematical Software', Vol. 20, No. 4,
+     'ACM Transactions on Mathematical Software', Vol. 20, No. 4,
      December, 1994, p. 494-495.
 
 
@@ -5177,59 +5139,58 @@ inverses are computed separately for the upper and lower tails of the
 distribution, allowing full accuracy to be retained for small results.
 
    The functions for random variates and probability density functions
-described in this section are declared in `gsl_randist.h'.  The
+described in this section are declared in 'gsl_randist.h'.  The
 corresponding cumulative distribution functions are declared in
-`gsl_cdf.h'.
+'gsl_cdf.h'.
 
-   Note that the discrete random variate functions always return a
-value of type `unsigned int', and on most platforms this has a maximum
-value of 2^32-1 ~=~ 4.29e9. They should only be called with a safe
-range of parameters (where there is a negligible probability of a
-variate exceeding this limit) to prevent incorrect results due to
-overflow.
+   Note that the discrete random variate functions always return a value
+of type 'unsigned int', and on most platforms this has a maximum value
+of 2^32-1 ~=~ 4.29e9.  They should only be called with a safe range of
+parameters (where there is a negligible probability of a variate
+exceeding this limit) to prevent incorrect results due to overflow.
 
 * Menu:
 
-* Random Number Distribution Introduction::
-* The Gaussian Distribution::
-* The Gaussian Tail Distribution::
-* The Bivariate Gaussian Distribution::
-* The Exponential Distribution::
-* The Laplace Distribution::
-* The Exponential Power Distribution::
-* The Cauchy Distribution::
-* The Rayleigh Distribution::
-* The Rayleigh Tail Distribution::
-* The Landau Distribution::
-* The Levy alpha-Stable Distributions::
-* The Levy skew alpha-Stable Distribution::
-* The Gamma Distribution::
-* The Flat (Uniform) Distribution::
-* The Lognormal Distribution::
-* The Chi-squared Distribution::
-* The F-distribution::
-* The t-distribution::
-* The Beta Distribution::
-* The Logistic Distribution::
-* The Pareto Distribution::
-* Spherical Vector Distributions::
-* The Weibull Distribution::
-* The Type-1 Gumbel Distribution::
-* The Type-2 Gumbel Distribution::
-* The Dirichlet Distribution::
-* General Discrete Distributions::
-* The Poisson Distribution::
-* The Bernoulli Distribution::
-* The Binomial Distribution::
-* The Multinomial Distribution::
-* The Negative Binomial Distribution::
-* The Pascal Distribution::
-* The Geometric Distribution::
-* The Hypergeometric Distribution::
-* The Logarithmic Distribution::
-* Shuffling and Sampling::
-* Random Number Distribution Examples::
-* Random Number Distribution References and Further Reading::
+* Random Number Distribution Introduction::  
+* The Gaussian Distribution::   
+* The Gaussian Tail Distribution::  
+* The Bivariate Gaussian Distribution::  
+* The Exponential Distribution::  
+* The Laplace Distribution::    
+* The Exponential Power Distribution::  
+* The Cauchy Distribution::     
+* The Rayleigh Distribution::   
+* The Rayleigh Tail Distribution::  
+* The Landau Distribution::     
+* The Levy alpha-Stable Distributions::  
+* The Levy skew alpha-Stable Distribution::  
+* The Gamma Distribution::      
+* The Flat (Uniform) Distribution::  
+* The Lognormal Distribution::  
+* The Chi-squared Distribution::  
+* The F-distribution::          
+* The t-distribution::          
+* The Beta Distribution::       
+* The Logistic Distribution::   
+* The Pareto Distribution::     
+* Spherical Vector Distributions::  
+* The Weibull Distribution::    
+* The Type-1 Gumbel Distribution::  
+* The Type-2 Gumbel Distribution::  
+* The Dirichlet Distribution::  
+* General Discrete Distributions::  
+* The Poisson Distribution::    
+* The Bernoulli Distribution::  
+* The Binomial Distribution::   
+* The Multinomial Distribution::  
+* The Negative Binomial Distribution::  
+* The Pascal Distribution::     
+* The Geometric Distribution::  
+* The Hypergeometric Distribution::  
+* The Logarithmic Distribution::  
+* Shuffling and Sampling::      
+* Random Number Distribution Examples::  
+* Random Number Distribution References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Random Number Distribution Introduction,  Next: The Gaussian Distribution,  Up: Random Number Distributions
@@ -5269,8 +5230,8 @@ defined as,
 
      P(k) = \sum_{i <= k} p(i)
 
-where the sum is over the allowed range of the distribution less than
-or equal to k.
+where the sum is over the allowed range of the distribution less than or
+equal to k.
 
    The cumulative distribution for the upper tail of a discrete
 distribution Q(k) is defined as
@@ -5297,10 +5258,10 @@ File: gsl-ref.info,  Node: The Gaussian Distribution,  Next: The Gaussian Tail D
           p(x) dx = {1 \over \sqrt{2 \pi \sigma^2}} \exp (-x^2 / 2\sigma^2) dx
 
      for x in the range -\infty to +\infty.  Use the transformation z =
-     \mu + x on the numbers returned by `gsl_ran_gaussian' to obtain a
+     \mu + x on the numbers returned by 'gsl_ran_gaussian' to obtain a
      Gaussian distribution with mean \mu.  This function uses the
-     Box-Mueller algorithm which requires two calls to the random
-     number generator R.
+     Box-Mueller algorithm which requires two calls to the random number
+     generator R.
 
  -- Function: double gsl_ran_gaussian_pdf (double X, double SIGMA)
      This function computes the probability density p(x) at X for a
@@ -5320,24 +5281,24 @@ File: gsl-ref.info,  Node: The Gaussian Distribution,  Next: The Gaussian Tail D
  -- Function: double gsl_ran_ugaussian (const gsl_rng * R)
  -- Function: double gsl_ran_ugaussian_pdf (double X)
  -- Function: double gsl_ran_ugaussian_ratio_method (const gsl_rng * R)
-     These functions compute results for the unit Gaussian
-     distribution.  They are equivalent to the functions above with a
-     standard deviation of one, SIGMA = 1.
+     These functions compute results for the unit Gaussian distribution.
+     They are equivalent to the functions above with a standard
+     deviation of one, SIGMA = 1.
 
  -- Function: double gsl_cdf_gaussian_P (double X, double SIGMA)
  -- Function: double gsl_cdf_gaussian_Q (double X, double SIGMA)
  -- Function: double gsl_cdf_gaussian_Pinv (double P, double SIGMA)
  -- Function: double gsl_cdf_gaussian_Qinv (double Q, double SIGMA)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Gaussian distribution with
-     standard deviation SIGMA.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Gaussian distribution with standard
+     deviation SIGMA.
 
  -- Function: double gsl_cdf_ugaussian_P (double X)
  -- Function: double gsl_cdf_ugaussian_Q (double X)
  -- Function: double gsl_cdf_ugaussian_Pinv (double P)
  -- Function: double gsl_cdf_ugaussian_Qinv (double Q)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the unit Gaussian distribution.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the unit Gaussian distribution.
 
 
 File: gsl-ref.info,  Node: The Gaussian Tail Distribution,  Next: The Bivariate Gaussian Distribution,  Prev: The Gaussian Distribution,  Up: Random Number Distributions
@@ -5345,15 +5306,14 @@ File: gsl-ref.info,  Node: The Gaussian Tail Distribution,  Next: The Bivariate
 19.3 The Gaussian Tail Distribution
 ===================================
 
- -- Function: double gsl_ran_gaussian_tail (const gsl_rng * R, double
-          A, double SIGMA)
+ -- Function: double gsl_ran_gaussian_tail (const gsl_rng * R, double A,
+          double SIGMA)
      This function provides random variates from the upper tail of a
      Gaussian distribution with standard deviation SIGMA.  The values
-     returned are larger than the lower limit A, which must be
-     positive.  The method is based on Marsaglia's famous
-     rectangle-wedge-tail algorithm (Ann.  Math. Stat. 32, 894-899
-     (1961)), with this aspect explained in Knuth, v2, 3rd ed, p139,586
-     (exercise 11).
+     returned are larger than the lower limit A, which must be positive.
+     The method is based on Marsaglia's famous rectangle-wedge-tail
+     algorithm (Ann.  Math.  Stat.  32, 894-899 (1961)), with this
+     aspect explained in Knuth, v2, 3rd ed, p139,586 (exercise 11).
 
      The probability distribution for Gaussian tail random variates is,
 
@@ -5363,7 +5323,6 @@ File: gsl-ref.info,  Node: The Gaussian Tail Distribution,  Next: The Bivariate
 
           N(a;\sigma) = (1/2) erfc(a / sqrt(2 sigma^2)).
 
-
  -- Function: double gsl_ran_gaussian_tail_pdf (double X, double A,
           double SIGMA)
      This function computes the probability density p(x) at X for a
@@ -5384,9 +5343,8 @@ File: gsl-ref.info,  Node: The Bivariate Gaussian Distribution,  Next: The Expon
 19.4 The Bivariate Gaussian Distribution
 ========================================
 
- -- Function: void gsl_ran_bivariate_gaussian (const gsl_rng * R,
-          double SIGMA_X, double SIGMA_Y, double RHO, double * X,
-          double * Y)
+ -- Function: void gsl_ran_bivariate_gaussian (const gsl_rng * R, double
+          SIGMA_X, double SIGMA_Y, double RHO, double * X, double * Y)
      This function generates a pair of correlated Gaussian variates,
      with mean zero, correlation coefficient RHO and standard deviations
      SIGMA_X and SIGMA_Y in the x and y directions.  The probability
@@ -5397,12 +5355,12 @@ File: gsl-ref.info,  Node: The Bivariate Gaussian Distribution,  Next: The Expon
      for x,y in the range -\infty to +\infty.  The correlation
      coefficient RHO should lie between 1 and -1.
 
- -- Function: double gsl_ran_bivariate_gaussian_pdf (double X, double
-          Y, double SIGMA_X, double SIGMA_Y, double RHO)
+ -- Function: double gsl_ran_bivariate_gaussian_pdf (double X, double Y,
+          double SIGMA_X, double SIGMA_Y, double RHO)
      This function computes the probability density p(x,y) at (X,Y) for
-     a bivariate Gaussian distribution with standard deviations
-     SIGMA_X, SIGMA_Y and correlation coefficient RHO, using the
-     formula given above.
+     a bivariate Gaussian distribution with standard deviations SIGMA_X,
+     SIGMA_Y and correlation coefficient RHO, using the formula given
+     above.
 
 
 
@@ -5413,7 +5371,7 @@ File: gsl-ref.info,  Node: The Exponential Distribution,  Next: The Laplace Dist
 
  -- Function: double gsl_ran_exponential (const gsl_rng * R, double MU)
      This function returns a random variate from the exponential
-     distribution with mean MU. The distribution is,
+     distribution with mean MU.  The distribution is,
 
           p(x) dx = {1 \over \mu} \exp(-x/\mu) dx
 
@@ -5429,9 +5387,9 @@ File: gsl-ref.info,  Node: The Exponential Distribution,  Next: The Laplace Dist
  -- Function: double gsl_cdf_exponential_Q (double X, double MU)
  -- Function: double gsl_cdf_exponential_Pinv (double P, double MU)
  -- Function: double gsl_cdf_exponential_Qinv (double Q, double MU)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the exponential distribution
-     with mean MU.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the exponential distribution with mean
+     MU.
 
 
 File: gsl-ref.info,  Node: The Laplace Distribution,  Next: The Exponential Power Distribution,  Prev: The Exponential Distribution,  Up: Random Number Distributions
@@ -5456,9 +5414,8 @@ File: gsl-ref.info,  Node: The Laplace Distribution,  Next: The Exponential Powe
  -- Function: double gsl_cdf_laplace_Q (double X, double A)
  -- Function: double gsl_cdf_laplace_Pinv (double P, double A)
  -- Function: double gsl_cdf_laplace_Qinv (double Q, double A)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Laplace distribution with
-     width A.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Laplace distribution with width A.
 
 
 File: gsl-ref.info,  Node: The Exponential Power Distribution,  Next: The Cauchy Distribution,  Prev: The Laplace Distribution,  Up: Random Number Distributions
@@ -5466,8 +5423,8 @@ File: gsl-ref.info,  Node: The Exponential Power Distribution,  Next: The Cauchy
 19.7 The Exponential Power Distribution
 =======================================
 
- -- Function: double gsl_ran_exppow (const gsl_rng * R, double A,
-          double B)
+ -- Function: double gsl_ran_exppow (const gsl_rng * R, double A, double
+          B)
      This function returns a random variate from the exponential power
      distribution with scale parameter A and exponent B.  The
      distribution is,
@@ -5475,8 +5432,8 @@ File: gsl-ref.info,  Node: The Exponential Power Distribution,  Next: The Cauchy
           p(x) dx = {1 \over 2 a \Gamma(1+1/b)} \exp(-|x/a|^b) dx
 
      for x >= 0.  For b = 1 this reduces to the Laplace distribution.
-     For b = 2 it has the same form as a gaussian distribution, but
-     with a = \sqrt{2} \sigma.
+     For b = 2 it has the same form as a gaussian distribution, but with
+     a = \sqrt{2} \sigma.
 
  -- Function: double gsl_ran_exppow_pdf (double X, double A, double B)
      This function computes the probability density p(x) at X for an
@@ -5486,9 +5443,9 @@ File: gsl-ref.info,  Node: The Exponential Power Distribution,  Next: The Cauchy
 
  -- Function: double gsl_cdf_exppow_P (double X, double A, double B)
  -- Function: double gsl_cdf_exppow_Q (double X, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) for the exponential power distribution with parameters
-     A and B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) for the exponential power distribution with parameters A and
+     B.
 
 
 File: gsl-ref.info,  Node: The Cauchy Distribution,  Next: The Rayleigh Distribution,  Prev: The Exponential Power Distribution,  Up: Random Number Distributions
@@ -5497,9 +5454,9 @@ File: gsl-ref.info,  Node: The Cauchy Distribution,  Next: The Rayleigh Distribu
 ============================
 
  -- Function: double gsl_ran_cauchy (const gsl_rng * R, double A)
-     This function returns a random variate from the Cauchy
-     distribution with scale parameter A.  The probability distribution
-     for Cauchy random variates is,
+     This function returns a random variate from the Cauchy distribution
+     with scale parameter A.  The probability distribution for Cauchy
+     random variates is,
 
           p(x) dx = {1 \over a\pi (1 + (x/a)^2) } dx
 
@@ -5508,17 +5465,17 @@ File: gsl-ref.info,  Node: The Cauchy Distribution,  Next: The Rayleigh Distribu
 
  -- Function: double gsl_ran_cauchy_pdf (double X, double A)
      This function computes the probability density p(x) at X for a
-     Cauchy distribution with scale parameter A, using the formula
-     given above.
+     Cauchy distribution with scale parameter A, using the formula given
+     above.
 
 
  -- Function: double gsl_cdf_cauchy_P (double X, double A)
  -- Function: double gsl_cdf_cauchy_Q (double X, double A)
  -- Function: double gsl_cdf_cauchy_Pinv (double P, double A)
  -- Function: double gsl_cdf_cauchy_Qinv (double Q, double A)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Cauchy distribution with
-     scale parameter A.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Cauchy distribution with scale
+     parameter A.
 
 
 File: gsl-ref.info,  Node: The Rayleigh Distribution,  Next: The Rayleigh Tail Distribution,  Prev: The Cauchy Distribution,  Up: Random Number Distributions
@@ -5536,17 +5493,17 @@ File: gsl-ref.info,  Node: The Rayleigh Distribution,  Next: The Rayleigh Tail D
 
  -- Function: double gsl_ran_rayleigh_pdf (double X, double SIGMA)
      This function computes the probability density p(x) at X for a
-     Rayleigh distribution with scale parameter SIGMA, using the
-     formula given above.
+     Rayleigh distribution with scale parameter SIGMA, using the formula
+     given above.
 
 
  -- Function: double gsl_cdf_rayleigh_P (double X, double SIGMA)
  -- Function: double gsl_cdf_rayleigh_Q (double X, double SIGMA)
  -- Function: double gsl_cdf_rayleigh_Pinv (double P, double SIGMA)
  -- Function: double gsl_cdf_rayleigh_Qinv (double Q, double SIGMA)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Rayleigh distribution with
-     scale parameter SIGMA.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Rayleigh distribution with scale
+     parameter SIGMA.
 
 
 File: gsl-ref.info,  Node: The Rayleigh Tail Distribution,  Next: The Landau Distribution,  Prev: The Rayleigh Distribution,  Up: Random Number Distributions
@@ -5554,8 +5511,8 @@ File: gsl-ref.info,  Node: The Rayleigh Tail Distribution,  Next: The Landau Dis
 19.10 The Rayleigh Tail Distribution
 ====================================
 
- -- Function: double gsl_ran_rayleigh_tail (const gsl_rng * R, double
-          A, double SIGMA)
+ -- Function: double gsl_ran_rayleigh_tail (const gsl_rng * R, double A,
+          double SIGMA)
      This function returns a random variate from the tail of the
      Rayleigh distribution with scale parameter SIGMA and a lower limit
      of A.  The distribution is,
@@ -5609,10 +5566,10 @@ File: gsl-ref.info,  Node: The Levy alpha-Stable Distributions,  Next: The Levy
           p(x) = {1 \over 2 \pi} \int_{-\infty}^{+\infty} dt \exp(-it x - |c t|^alpha)
 
      There is no explicit solution for the form of p(x) and the library
-     does not define a corresponding `pdf' function.  For \alpha = 1
-     the distribution reduces to the Cauchy distribution.  For \alpha =
-     2 it is a Gaussian distribution with \sigma = \sqrt{2} c.  For
-     \alpha < 1 the tails of the distribution become extremely wide.
+     does not define a corresponding 'pdf' function.  For \alpha = 1 the
+     distribution reduces to the Cauchy distribution.  For \alpha = 2 it
+     is a Gaussian distribution with \sigma = \sqrt{2} c.  For \alpha <
+     1 the tails of the distribution become extremely wide.
 
      The algorithm only works for 0 < alpha <= 2.
 
@@ -5635,20 +5592,19 @@ File: gsl-ref.info,  Node: The Levy skew alpha-Stable Distribution,  Next: The G
 
      When \alpha = 1 the term \tan(\pi \alpha/2) is replaced by
      -(2/\pi)\log|t|.  There is no explicit solution for the form of
-     p(x) and the library does not define a corresponding `pdf'
+     p(x) and the library does not define a corresponding 'pdf'
      function.  For \alpha = 2 the distribution reduces to a Gaussian
      distribution with \sigma = \sqrt{2} c and the skewness parameter
-     has no effect.  For \alpha < 1 the tails of the distribution
-     become extremely wide.  The symmetric distribution corresponds to
-     \beta = 0.
+     has no effect.  For \alpha < 1 the tails of the distribution become
+     extremely wide.  The symmetric distribution corresponds to \beta =
+     0.
 
      The algorithm only works for 0 < alpha <= 2.
 
    The Levy alpha-stable distributions have the property that if N
 alpha-stable variates are drawn from the distribution p(c, \alpha,
-\beta) then the sum Y = X_1 + X_2 + \dots + X_N will also be
-distributed as an alpha-stable variate, p(N^(1/\alpha) c, \alpha,
-\beta).
+\beta) then the sum Y = X_1 + X_2 + \dots + X_N will also be distributed
+as an alpha-stable variate, p(N^(1/\alpha) c, \alpha, \beta).
 
 
 
@@ -5659,8 +5615,8 @@ File: gsl-ref.info,  Node: The Gamma Distribution,  Next: The Flat (Uniform) Dis
 
  -- Function: double gsl_ran_gamma (const gsl_rng * R, double A, double
           B)
-     This function returns a random variate from the gamma
-     distribution.  The distribution function is,
+     This function returns a random variate from the gamma distribution.
+     The distribution function is,
 
           p(x) dx = {1 \over \Gamma(a) b^a} x^{a-1} e^{-x/b} dx
 
@@ -5671,7 +5627,7 @@ File: gsl-ref.info,  Node: The Gamma Distribution,  Next: The Flat (Uniform) Dis
 
      The variates are computed using the Marsaglia-Tsang fast gamma
      method.  This function for this method was previously called
-     `gsl_ran_gamma_mt' and can still be accessed using this name.
+     'gsl_ran_gamma_mt' and can still be accessed using this name.
 
  -- Function: double gsl_ran_gamma_knuth (const gsl_rng * R, double A,
           double B)
@@ -5680,17 +5636,17 @@ File: gsl-ref.info,  Node: The Gamma Distribution,  Next: The Flat (Uniform) Dis
 
  -- Function: double gsl_ran_gamma_pdf (double X, double A, double B)
      This function computes the probability density p(x) at X for a
-     gamma distribution with parameters A and B, using the formula
-     given above.
+     gamma distribution with parameters A and B, using the formula given
+     above.
 
 
  -- Function: double gsl_cdf_gamma_P (double X, double A, double B)
  -- Function: double gsl_cdf_gamma_Q (double X, double A, double B)
  -- Function: double gsl_cdf_gamma_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_gamma_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the gamma distribution with
-     parameters A and B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the gamma distribution with parameters
+     A and B.
 
 
 File: gsl-ref.info,  Node: The Flat (Uniform) Distribution,  Next: The Lognormal Distribution,  Prev: The Gamma Distribution,  Up: Random Number Distributions
@@ -5701,7 +5657,7 @@ File: gsl-ref.info,  Node: The Flat (Uniform) Distribution,  Next: The Lognormal
  -- Function: double gsl_ran_flat (const gsl_rng * R, double A, double
           B)
      This function returns a random variate from the flat (uniform)
-     distribution from A to B. The distribution is,
+     distribution from A to B.  The distribution is,
 
           p(x) dx = {1 \over (b-a)} dx
 
@@ -5716,9 +5672,8 @@ File: gsl-ref.info,  Node: The Flat (Uniform) Distribution,  Next: The Lognormal
  -- Function: double gsl_cdf_flat_Q (double X, double A, double B)
  -- Function: double gsl_cdf_flat_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_flat_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for a uniform distribution from A to
-     B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for a uniform distribution from A to B.
 
 
 File: gsl-ref.info,  Node: The Lognormal Distribution,  Next: The Chi-squared Distribution,  Prev: The Flat (Uniform) Distribution,  Up: Random Number Distributions
@@ -5750,8 +5705,8 @@ File: gsl-ref.info,  Node: The Lognormal Distribution,  Next: The Chi-squared Di
           double SIGMA)
  -- Function: double gsl_cdf_lognormal_Qinv (double Q, double ZETA,
           double SIGMA)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the lognormal distribution with
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the lognormal distribution with
      parameters ZETA and SIGMA.
 
 
@@ -5770,7 +5725,7 @@ has a chi-squared distribution with n degrees of freedom.
 
  -- Function: double gsl_ran_chisq (const gsl_rng * R, double NU)
      This function returns a random variate from the chi-squared
-     distribution with NU degrees of freedom. The distribution function
+     distribution with NU degrees of freedom.  The distribution function
      is,
 
           p(x) dx = {1 \over 2 \Gamma(\nu/2) } (x/2)^{\nu/2 - 1} \exp(-x/2) dx
@@ -5787,9 +5742,9 @@ has a chi-squared distribution with n degrees of freedom.
  -- Function: double gsl_cdf_chisq_Q (double X, double NU)
  -- Function: double gsl_cdf_chisq_Pinv (double P, double NU)
  -- Function: double gsl_cdf_chisq_Qinv (double Q, double NU)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the chi-squared distribution
-     with NU degrees of freedom.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the chi-squared distribution with NU
+     degrees of freedom.
 
 
 File: gsl-ref.info,  Node: The F-distribution,  Next: The t-distribution,  Prev: The Chi-squared Distribution,  Up: Random Number Distributions
@@ -5797,9 +5752,8 @@ File: gsl-ref.info,  Node: The F-distribution,  Next: The t-distribution,  Prev:
 19.18 The F-distribution
 ========================
 
-The F-distribution arises in statistics.  If Y_1 and Y_2 are
-chi-squared deviates with \nu_1 and \nu_2 degrees of freedom then the
-ratio,
+The F-distribution arises in statistics.  If Y_1 and Y_2 are chi-squared
+deviates with \nu_1 and \nu_2 degrees of freedom then the ratio,
 
      X = { (Y_1 / \nu_1) \over (Y_2 / \nu_2) }
 
@@ -5807,8 +5761,8 @@ has an F-distribution F(x;\nu_1,\nu_2).
 
  -- Function: double gsl_ran_fdist (const gsl_rng * R, double NU1,
           double NU2)
-     This function returns a random variate from the F-distribution
-     with degrees of freedom NU1 and NU2. The distribution function is,
+     This function returns a random variate from the F-distribution with
+     degrees of freedom NU1 and NU2.  The distribution function is,
 
           p(x) dx =
              { \Gamma((\nu_1 + \nu_2)/2)
@@ -5831,9 +5785,9 @@ has an F-distribution F(x;\nu_1,\nu_2).
           NU2)
  -- Function: double gsl_cdf_fdist_Qinv (double Q, double NU1, double
           NU2)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the F-distribution with NU1 and
-     NU2 degrees of freedom.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the F-distribution with NU1 and NU2
+     degrees of freedom.
 
 
 File: gsl-ref.info,  Node: The t-distribution,  Next: The Beta Distribution,  Prev: The F-distribution,  Up: Random Number Distributions
@@ -5868,9 +5822,9 @@ has a t-distribution t(x;\nu) with \nu degrees of freedom.
  -- Function: double gsl_cdf_tdist_Q (double X, double NU)
  -- Function: double gsl_cdf_tdist_Pinv (double P, double NU)
  -- Function: double gsl_cdf_tdist_Qinv (double Q, double NU)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the t-distribution with NU
-     degrees of freedom.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the t-distribution with NU degrees of
+     freedom.
 
 
 File: gsl-ref.info,  Node: The Beta Distribution,  Next: The Logistic Distribution,  Prev: The t-distribution,  Up: Random Number Distributions
@@ -5888,8 +5842,8 @@ File: gsl-ref.info,  Node: The Beta Distribution,  Next: The Logistic Distributi
      for 0 <= x <= 1.
 
  -- Function: double gsl_ran_beta_pdf (double X, double A, double B)
-     This function computes the probability density p(x) at X for a
-     beta distribution with parameters A and B, using the formula given
+     This function computes the probability density p(x) at X for a beta
+     distribution with parameters A and B, using the formula given
      above.
 
 
@@ -5897,9 +5851,9 @@ File: gsl-ref.info,  Node: The Beta Distribution,  Next: The Logistic Distributi
  -- Function: double gsl_cdf_beta_Q (double X, double A, double B)
  -- Function: double gsl_cdf_beta_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_beta_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the beta distribution with
-     parameters A and B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the beta distribution with parameters A
+     and B.
 
 
 File: gsl-ref.info,  Node: The Logistic Distribution,  Next: The Pareto Distribution,  Prev: The Beta Distribution,  Up: Random Number Distributions
@@ -5925,9 +5879,9 @@ File: gsl-ref.info,  Node: The Logistic Distribution,  Next: The Pareto Distribu
  -- Function: double gsl_cdf_logistic_Q (double X, double A)
  -- Function: double gsl_cdf_logistic_Pinv (double P, double A)
  -- Function: double gsl_cdf_logistic_Qinv (double Q, double A)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the logistic distribution with
-     scale parameter A.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the logistic distribution with scale
+     parameter A.
 
 
 File: gsl-ref.info,  Node: The Pareto Distribution,  Next: Spherical Vector Distributions,  Prev: The Logistic Distribution,  Up: Random Number Distributions
@@ -5935,10 +5889,10 @@ File: gsl-ref.info,  Node: The Pareto Distribution,  Next: Spherical Vector Dist
 19.22 The Pareto Distribution
 =============================
 
- -- Function: double gsl_ran_pareto (const gsl_rng * R, double A,
-          double B)
-     This function returns a random variate from the Pareto
-     distribution of order A.  The distribution function is,
+ -- Function: double gsl_ran_pareto (const gsl_rng * R, double A, double
+          B)
+     This function returns a random variate from the Pareto distribution
+     of order A.  The distribution function is,
 
           p(x) dx = (a/b) / (x/b)^{a+1} dx
 
@@ -5954,9 +5908,9 @@ File: gsl-ref.info,  Node: The Pareto Distribution,  Next: Spherical Vector Dist
  -- Function: double gsl_cdf_pareto_Q (double X, double A, double B)
  -- Function: double gsl_cdf_pareto_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_pareto_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Pareto distribution with
-     exponent A and scale B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Pareto distribution with exponent A
+     and scale B.
 
 
 File: gsl-ref.info,  Node: Spherical Vector Distributions,  Next: The Weibull Distribution,  Prev: The Pareto Distribution,  Up: Random Number Distributions
@@ -5968,14 +5922,14 @@ The spherical distributions generate random vectors, located on a
 spherical surface.  They can be used as random directions, for example
 in the steps of a random walk.
 
- -- Function: void gsl_ran_dir_2d (const gsl_rng * R, double * X,
-          double * Y)
- -- Function: void gsl_ran_dir_2d_trig_method (const gsl_rng * R,
-          double * X, double * Y)
+ -- Function: void gsl_ran_dir_2d (const gsl_rng * R, double * X, double
+          * Y)
+ -- Function: void gsl_ran_dir_2d_trig_method (const gsl_rng * R, double
+          * X, double * Y)
      This function returns a random direction vector v = (X,Y) in two
-     dimensions.  The vector is normalized such that |v|^2 = x^2 + y^2
-     = 1.  The obvious way to do this is to take a uniform random
-     number between 0 and 2\pi and let X and Y be the sine and cosine
+     dimensions.  The vector is normalized such that |v|^2 = x^2 + y^2 =
+     1.  The obvious way to do this is to take a uniform random number
+     between 0 and 2\pi and let X and Y be the sine and cosine
      respectively.  Two trig functions would have been expensive in the
      old days, but with modern hardware implementations, this is
      sometimes the fastest way to go.  This is the case for the Pentium
@@ -5989,17 +5943,18 @@ in the steps of a random walk.
      and V are chosen at random from the interior of a unit circle, and
      then x=(u^2-v^2)/(u^2+v^2) and y=2uv/(u^2+v^2).
 
- -- Function: void gsl_ran_dir_3d (const gsl_rng * R, double * X,
-          double * Y, double * Z)
+ -- Function: void gsl_ran_dir_3d (const gsl_rng * R, double * X, double
+          * Y, double * Z)
      This function returns a random direction vector v = (X,Y,Z) in
-     three dimensions.  The vector is normalized such that |v|^2 = x^2
-     + y^2 + z^2 = 1.  The method employed is due to Robert E. Knop
-     (CACM 13, 326 (1970)), and explained in Knuth, v2, 3rd ed, p136.
-     It uses the surprising fact that the distribution projected along
-     any axis is actually uniform (this is only true for 3 dimensions).
+     three dimensions.  The vector is normalized such that |v|^2 = x^2 +
+     y^2 + z^2 = 1.  The method employed is due to Robert E. Knop (CACM
+     13, 326 (1970)), and explained in Knuth, v2, 3rd ed, p136.  It uses
+     the surprising fact that the distribution projected along any axis
+     is actually uniform (this is only true for 3 dimensions).
+
+ -- Function: void gsl_ran_dir_nd (const gsl_rng * R, size_t N, double *
+          X)
 
- -- Function: void gsl_ran_dir_nd (const gsl_rng * R, size_t N, double
-          * X)
      This function returns a random direction vector v =
      (x_1,x_2,...,x_n) in N dimensions.  The vector is normalized such
      that |v|^2 = x_1^2 + x_2^2 + ... + x_n^2 = 1.  The method uses the
@@ -6026,17 +5981,17 @@ File: gsl-ref.info,  Node: The Weibull Distribution,  Next: The Type-1 Gumbel Di
 
  -- Function: double gsl_ran_weibull_pdf (double X, double A, double B)
      This function computes the probability density p(x) at X for a
-     Weibull distribution with scale A and exponent B, using the
-     formula given above.
+     Weibull distribution with scale A and exponent B, using the formula
+     given above.
 
 
  -- Function: double gsl_cdf_weibull_P (double X, double A, double B)
  -- Function: double gsl_cdf_weibull_Q (double X, double A, double B)
  -- Function: double gsl_cdf_weibull_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_weibull_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Weibull distribution with
-     scale A and exponent B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Weibull distribution with scale A
+     and exponent B.
 
 
 File: gsl-ref.info,  Node: The Type-1 Gumbel Distribution,  Next: The Type-2 Gumbel Distribution,  Prev: The Weibull Distribution,  Up: Random Number Distributions
@@ -6046,7 +6001,7 @@ File: gsl-ref.info,  Node: The Type-1 Gumbel Distribution,  Next: The Type-2 Gum
 
  -- Function: double gsl_ran_gumbel1 (const gsl_rng * R, double A,
           double B)
-     This function returns  a random variate from the Type-1 Gumbel
+     This function returns a random variate from the Type-1 Gumbel
      distribution.  The Type-1 Gumbel distribution function is,
 
           p(x) dx = a b \exp(-(b \exp(-ax) + ax)) dx
@@ -6063,9 +6018,9 @@ File: gsl-ref.info,  Node: The Type-1 Gumbel Distribution,  Next: The Type-2 Gum
  -- Function: double gsl_cdf_gumbel1_Q (double X, double A, double B)
  -- Function: double gsl_cdf_gumbel1_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_gumbel1_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Type-1 Gumbel distribution
-     with parameters A and B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Type-1 Gumbel distribution with
+     parameters A and B.
 
 
 File: gsl-ref.info,  Node: The Type-2 Gumbel Distribution,  Next: The Dirichlet Distribution,  Prev: The Type-1 Gumbel Distribution,  Up: Random Number Distributions
@@ -6092,9 +6047,9 @@ File: gsl-ref.info,  Node: The Type-2 Gumbel Distribution,  Next: The Dirichlet
  -- Function: double gsl_cdf_gumbel2_Q (double X, double A, double B)
  -- Function: double gsl_cdf_gumbel2_Pinv (double P, double A, double B)
  -- Function: double gsl_cdf_gumbel2_Qinv (double Q, double A, double B)
-     These functions compute the cumulative distribution functions
-     P(x), Q(x) and their inverses for the Type-2 Gumbel distribution
-     with parameters A and B.
+     These functions compute the cumulative distribution functions P(x),
+     Q(x) and their inverses for the Type-2 Gumbel distribution with
+     parameters A and B.
 
 
 File: gsl-ref.info,  Node: The Dirichlet Distribution,  Next: General Discrete Distributions,  Prev: The Type-2 Gumbel Distribution,  Up: Random Number Distributions
@@ -6102,22 +6057,22 @@ File: gsl-ref.info,  Node: The Dirichlet Distribution,  Next: General Discrete D
 19.27 The Dirichlet Distribution
 ================================
 
- -- Function: void gsl_ran_dirichlet (const gsl_rng * R, size_t K,
-          const double ALPHA[], double THETA[])
+ -- Function: void gsl_ran_dirichlet (const gsl_rng * R, size_t K, const
+          double ALPHA[], double THETA[])
      This function returns an array of K random variates from a
-     Dirichlet distribution of order K-1. The distribution function is
+     Dirichlet distribution of order K-1.  The distribution function is
 
           p(\theta_1, ..., \theta_K) d\theta_1 ... d\theta_K =
             (1/Z) \prod_{i=1}^K \theta_i^{\alpha_i - 1} \delta(1 -\sum_{i=1}^K \theta_i) d\theta_1 ... d\theta_K
 
-     for theta_i >= 0 and alpha_i >= 0.  The delta function ensures
-     that \sum \theta_i = 1.  The normalization factor Z is
+     for theta_i >= 0 and alpha_i >= 0.  The delta function ensures that
+     \sum \theta_i = 1.  The normalization factor Z is
 
           Z = {\prod_{i=1}^K \Gamma(\alpha_i)} / {\Gamma( \sum_{i=1}^K \alpha_i)}
 
      The random variates are generated by sampling K values from gamma
      distributions with parameters a=alpha_i, b=1, and renormalizing.
-     See A.M. Law, W.D. Kelton, `Simulation Modeling and Analysis'
+     See A.M. Law, W.D. Kelton, 'Simulation Modeling and Analysis'
      (1991).
 
  -- Function: double gsl_ran_dirichlet_pdf (size_t K, const double
@@ -6148,8 +6103,8 @@ generating a cumulative probability array with K+1 elements:
      C[k+1] = C[k]+P[k].
 
 Note that this construction produces C[K]=1.  Now choose a uniform
-deviate u between 0 and 1, and find the value of k such that C[k] <= u
-< C[k+1].  Although this in principle requires of order \log K steps per
+deviate u between 0 and 1, and find the value of k such that C[k] <= u <
+C[k+1].  Although this in principle requires of order \log K steps per
 random number generation, they are fast steps, and if you use something
 like \lfloor uK \rfloor as a starting point, you can often do pretty
 well.
@@ -6159,23 +6114,22 @@ preprocess the probability list, and save the result in some form of
 lookup table; then the individual calls for a random discrete event can
 go rapidly.  An approach invented by G. Marsaglia (Generating discrete
 random numbers in a computer, Comm ACM 6, 37-38 (1963)) is very clever,
-and readers interested in examples of good algorithm design are
-directed to this short and well-written paper.  Unfortunately, for
-large K, Marsaglia's lookup table can be quite large.
+and readers interested in examples of good algorithm design are directed
+to this short and well-written paper.  Unfortunately, for large K,
+Marsaglia's lookup table can be quite large.
 
    A much better approach is due to Alastair J. Walker (An efficient
 method for generating discrete random variables with general
-distributions, ACM Trans on Mathematical Software 3, 253-256 (1977);
-see also Knuth, v2, 3rd ed, p120-121,139).  This requires two lookup
-tables, one floating point and one integer, but both only of size K.
-After preprocessing, the random numbers are generated in O(1) time,
-even for large K.  The preprocessing suggested by Walker requires
-O(K^2) effort, but that is not actually necessary, and the
-implementation provided here only takes O(K) effort.  In general, more
-preprocessing leads to faster generation of the individual random
-numbers, but a diminishing return is reached pretty early.  Knuth points
-out that the optimal preprocessing is combinatorially difficult for
-large K.
+distributions, ACM Trans on Mathematical Software 3, 253-256 (1977); see
+also Knuth, v2, 3rd ed, p120-121,139).  This requires two lookup tables,
+one floating point and one integer, but both only of size K.  After
+preprocessing, the random numbers are generated in O(1) time, even for
+large K.  The preprocessing suggested by Walker requires O(K^2) effort,
+but that is not actually necessary, and the implementation provided here
+only takes O(K) effort.  In general, more preprocessing leads to faster
+generation of the individual random numbers, but a diminishing return is
+reached pretty early.  Knuth points out that the optimal preprocessing
+is combinatorially difficult for large K.
 
    This method can be used to speed up some of the discrete random
 number generators below, such as the binomial distribution.  To use it
@@ -6190,7 +6144,7 @@ to be made, since it only takes a finite set of K outcomes.
      elements must all be positive, but they needn't add up to one (so
      you can think of them more generally as "weights")--the
      preprocessor will normalize appropriately.  This return value is
-     used as an argument for the `gsl_ran_discrete' function below.
+     used as an argument for the 'gsl_ran_discrete' function below.
 
  -- Function: size_t gsl_ran_discrete (const gsl_rng * R, const
           gsl_ran_discrete_t * G)
@@ -6202,8 +6156,8 @@ to be made, since it only takes a finite set of K outcomes.
      Returns the probability P[k] of observing the variable K.  Since
      P[k] is not stored as part of the lookup table, it must be
      recomputed; this computation takes O(K), so if K is large and you
-     care about the original array P[k] used to create the lookup
-     table, then you should just keep this original array P[k] around.
+     care about the original array P[k] used to create the lookup table,
+     then you should just keep this original array P[k] around.
 
  -- Function: void gsl_ran_discrete_free (gsl_ran_discrete_t * G)
      De-allocates the lookup table pointed to by G.
@@ -6225,14 +6179,14 @@ File: gsl-ref.info,  Node: The Poisson Distribution,  Next: The Bernoulli Distri
      for k >= 0.
 
  -- Function: double gsl_ran_poisson_pdf (unsigned int K, double MU)
-     This function computes the probability p(k) of obtaining  K from a
+     This function computes the probability p(k) of obtaining K from a
      Poisson distribution with mean MU, using the formula given above.
 
 
  -- Function: double gsl_cdf_poisson_P (unsigned int K, double MU)
  -- Function: double gsl_cdf_poisson_Q (unsigned int K, double MU)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k) for the Poisson distribution with parameter MU.
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the Poisson distribution with parameter MU.
 
 
 File: gsl-ref.info,  Node: The Bernoulli Distribution,  Next: The Binomial Distribution,  Prev: The Poisson Distribution,  Up: Random Number Distributions
@@ -6249,7 +6203,6 @@ File: gsl-ref.info,  Node: The Bernoulli Distribution,  Next: The Binomial Distr
           p(0) = 1 - p
           p(1) = p
 
-
  -- Function: double gsl_ran_bernoulli_pdf (unsigned int K, double P)
      This function computes the probability p(k) of obtaining K from a
      Bernoulli distribution with probability parameter P, using the
@@ -6284,8 +6237,8 @@ File: gsl-ref.info,  Node: The Binomial Distribution,  Next: The Multinomial Dis
           unsigned int N)
  -- Function: double gsl_cdf_binomial_Q (unsigned int K, double P,
           unsigned int N)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k)  for the binomial distribution with parameters P and N.
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the binomial distribution with parameters P and N.
 
 
 File: gsl-ref.info,  Node: The Multinomial Distribution,  Next: The Negative Binomial Distribution,  Prev: The Binomial Distribution,  Up: Random Number Distributions
@@ -6295,9 +6248,10 @@ File: gsl-ref.info,  Node: The Multinomial Distribution,  Next: The Negative Bin
 
  -- Function: void gsl_ran_multinomial (const gsl_rng * R, size_t K,
           unsigned int N, const double P[], unsigned int N[])
+
      This function computes a random sample N[] from the multinomial
      distribution formed by N trials from an underlying distribution
-     P[K]. The distribution function for N[] is,
+     P[K].  The distribution function for N[] is,
 
           P(n_1, n_2, ..., n_K) =
             (N!/(n_1! n_2! ... n_K!)) p_1^n_1 p_2^n_2 ... p_K^n_K
@@ -6309,16 +6263,16 @@ File: gsl-ref.info,  Node: The Multinomial Distribution,  Next: The Negative Bin
      normalized appropriately.  The arrays N[] and P[] must both be of
      length K.
 
-     Random variates are generated using the conditional binomial
-     method (see C.S. David, `The computer generation of multinomial
-     random variates', Comp. Stat. Data Anal. 16 (1993) 205-217 for
+     Random variates are generated using the conditional binomial method
+     (see C.S. David, 'The computer generation of multinomial random
+     variates', Comp.  Stat.  Data Anal.  16 (1993) 205-217 for
      details).
 
  -- Function: double gsl_ran_multinomial_pdf (size_t K, const double
           P[], const unsigned int N[])
      This function computes the probability P(n_1, n_2, ..., n_K) of
-     sampling N[K] from a multinomial distribution with parameters
-     P[K], using the formula given above.
+     sampling N[K] from a multinomial distribution with parameters P[K],
+     using the formula given above.
 
  -- Function: double gsl_ran_multinomial_lnpdf (size_t K, const double
           P[], const unsigned int N[])
@@ -6332,8 +6286,8 @@ File: gsl-ref.info,  Node: The Negative Binomial Distribution,  Next: The Pascal
 19.33 The Negative Binomial Distribution
 ========================================
 
- -- Function: unsigned int gsl_ran_negative_binomial (const gsl_rng *
-          R, double P, double N)
+ -- Function: unsigned int gsl_ran_negative_binomial (const gsl_rng * R,
+          double P, double N)
      This function returns a random integer from the negative binomial
      distribution, the number of failures occurring before N successes
      in independent trials with probability P of success.  The
@@ -6350,13 +6304,13 @@ File: gsl-ref.info,  Node: The Negative Binomial Distribution,  Next: The Pascal
      formula given above.
 
 
- -- Function: double gsl_cdf_negative_binomial_P (unsigned int K,
-          double P, double N)
- -- Function: double gsl_cdf_negative_binomial_Q (unsigned int K,
-          double P, double N)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k) for the negative binomial distribution with parameters
-     P and N.
+ -- Function: double gsl_cdf_negative_binomial_P (unsigned int K, double
+          P, double N)
+ -- Function: double gsl_cdf_negative_binomial_Q (unsigned int K, double
+          P, double N)
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the negative binomial distribution with parameters P and
+     N.
 
 
 File: gsl-ref.info,  Node: The Pascal Distribution,  Next: The Geometric Distribution,  Prev: The Negative Binomial Distribution,  Up: Random Number Distributions
@@ -6385,8 +6339,8 @@ File: gsl-ref.info,  Node: The Pascal Distribution,  Next: The Geometric Distrib
           unsigned int N)
  -- Function: double gsl_cdf_pascal_Q (unsigned int K, double P,
           unsigned int N)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k) for the Pascal distribution with parameters P and N.
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the Pascal distribution with parameters P and N.
 
 
 File: gsl-ref.info,  Node: The Geometric Distribution,  Next: The Hypergeometric Distribution,  Prev: The Pascal Distribution,  Up: Random Number Distributions
@@ -6415,8 +6369,8 @@ File: gsl-ref.info,  Node: The Geometric Distribution,  Next: The Hypergeometric
 
  -- Function: double gsl_cdf_geometric_P (unsigned int K, double P)
  -- Function: double gsl_cdf_geometric_Q (unsigned int K, double P)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k) for the geometric distribution with parameter P.
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the geometric distribution with parameter P.
 
 
 File: gsl-ref.info,  Node: The Hypergeometric Distribution,  Next: The Logarithmic Distribution,  Prev: The Geometric Distribution,  Up: Random Number Distributions
@@ -6451,9 +6405,9 @@ File: gsl-ref.info,  Node: The Hypergeometric Distribution,  Next: The Logarithm
           int N1, unsigned int N2, unsigned int T)
  -- Function: double gsl_cdf_hypergeometric_Q (unsigned int K, unsigned
           int N1, unsigned int N2, unsigned int T)
-     These functions compute the cumulative distribution functions
-     P(k), Q(k) for the hypergeometric distribution with parameters N1,
-     N2 and T.
+     These functions compute the cumulative distribution functions P(k),
+     Q(k) for the hypergeometric distribution with parameters N1, N2 and
+     T.
 
 
 File: gsl-ref.info,  Node: The Logarithmic Distribution,  Next: Shuffling and Sampling,  Prev: The Hypergeometric Distribution,  Up: Random Number Distributions
@@ -6492,10 +6446,11 @@ short period.  For more information see Knuth, v2, 3rd ed, Section
 
  -- Function: void gsl_ran_shuffle (const gsl_rng * R, void * BASE,
           size_t N, size_t SIZE)
+
      This function randomly shuffles the order of N objects, each of
      size SIZE, stored in the array BASE[0..N-1].  The output of the
      random number generator R is used to produce the permutation.  The
-     algorithm generates all possible n!  permutations with equal
+     algorithm generates all possible n! permutations with equal
      probability, assuming a perfect source of random numbers.
 
      The following code shows how to shuffle the numbers from 0 to 51,
@@ -6509,20 +6464,18 @@ short period.  For more information see Knuth, v2, 3rd ed, Section
 
           gsl_ran_shuffle (r, a, 52, sizeof (int));
 
-
- -- Function: int gsl_ran_choose (const gsl_rng * R, void * DEST,
-          size_t K, void * SRC, size_t N, size_t SIZE)
-     This function fills the array DEST[k] with K objects taken
-     randomly from the N elements of the array SRC[0..N-1].  The
-     objects are each of size SIZE.  The output of the random number
-     generator R is used to make the selection.  The algorithm ensures
-     all possible samples are equally likely, assuming a perfect source
-     of randomness.
+ -- Function: int gsl_ran_choose (const gsl_rng * R, void * DEST, size_t
+          K, void * SRC, size_t N, size_t SIZE)
+     This function fills the array DEST[k] with K objects taken randomly
+     from the N elements of the array SRC[0..N-1].  The objects are each
+     of size SIZE.  The output of the random number generator R is used
+     to make the selection.  The algorithm ensures all possible samples
+     are equally likely, assuming a perfect source of randomness.
 
      The objects are sampled _without_ replacement, thus each object can
-     only appear once in DEST[k].  It is required that K be less than
-     or equal to `n'.  The objects in DEST will be in the same relative
-     order as those in SRC.  You will need to call `gsl_ran_shuffle(r,
+     only appear once in DEST[k].  It is required that K be less than or
+     equal to 'n'.  The objects in DEST will be in the same relative
+     order as those in SRC.  You will need to call 'gsl_ran_shuffle(r,
      dest, n, size)' if you want to randomize the order.
 
      The following code shows how to select a random sample of three
@@ -6537,13 +6490,12 @@ short period.  For more information see Knuth, v2, 3rd ed, Section
 
           gsl_ran_choose (r, a, 3, b, 100, sizeof (double));
 
-
  -- Function: void gsl_ran_sample (const gsl_rng * R, void * DEST,
           size_t K, void * SRC, size_t N, size_t SIZE)
-     This function is like `gsl_ran_choose' but samples K items from
-     the original array of N items SRC with replacement, so the same
-     object can appear more than once in the output sequence DEST.
-     There is no requirement that K be less than N in this case.
+     This function is like 'gsl_ran_choose' but samples K items from the
+     original array of N items SRC with replacement, so the same object
+     can appear more than once in the output sequence DEST.  There is no
+     requirement that K be less than N in this case.
 
 
 File: gsl-ref.info,  Node: Random Number Distribution Examples,  Next: Random Number Distribution References and Further Reading,  Prev: Shuffling and Sampling,  Up: Random Number Distributions
@@ -6591,7 +6543,7 @@ Poisson distribution with a mean of 3.
        return 0;
      }
 
-If the library and header files are installed under `/usr/local' (the
+If the library and header files are installed under '/usr/local' (the
 default location) then the program can be compiled with these options,
 
      $ gcc -Wall demo.c -lgsl -lgslcblas -lm
@@ -6602,8 +6554,8 @@ Here is the output of the program,
       2 5 5 2 1 0 3 4 1 1
 
 The variates depend on the seed used by the generator.  The seed for the
-default generator type `gsl_rng_default' can be changed with the
-`GSL_RNG_SEED' environment variable to produce a different stream of
+default generator type 'gsl_rng_default' can be changed with the
+'GSL_RNG_SEED' environment variable to produce a different stream of
 variates,
 
      $ GSL_RNG_SEED=123 ./a.out
@@ -6642,8 +6594,8 @@ The following program generates a random walk in two dimensions.
        return 0;
      }
 
-Here is the output from the program, three 10-step random walks from
-the origin,
+Here is the output from the program, three 10-step random walks from the
+origin,
 
    The following program computes the upper and lower cumulative
 distribution functions for the standard normal distribution at x=2.
@@ -6686,49 +6638,49 @@ File: gsl-ref.info,  Node: Random Number Distribution References and Further Rea
 ====================================
 
 For an encyclopaedic coverage of the subject readers are advised to
-consult the book `Non-Uniform Random Variate Generation' by Luc
-Devroye.  It covers every imaginable distribution and provides hundreds
-of algorithms.
+consult the book 'Non-Uniform Random Variate Generation' by Luc Devroye.
+It covers every imaginable distribution and provides hundreds of
+algorithms.
 
-     Luc Devroye, `Non-Uniform Random Variate Generation',
+     Luc Devroye, 'Non-Uniform Random Variate Generation',
      Springer-Verlag, ISBN 0-387-96305-7.
 
 The subject of random variate generation is also reviewed by Knuth, who
 describes algorithms for all the major distributions.
 
-     Donald E. Knuth, `The Art of Computer Programming: Seminumerical
+     Donald E. Knuth, 'The Art of Computer Programming: Seminumerical
      Algorithms' (Vol 2, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896842.
 
 The Particle Data Group provides a short review of techniques for
 generating distributions of random numbers in the "Monte Carlo" section
 of its Annual Review of Particle Physics.
 
-     `Review of Particle Properties' R.M. Barnett et al., Physical
-     Review D54, 1 (1996) `http://pdg.lbl.gov/'.
+     'Review of Particle Properties' R.M. Barnett et al., Physical
+     Review D54, 1 (1996) <http://pdg.lbl.gov/>.
 
 The Review of Particle Physics is available online in postscript and pdf
 format.
 
 An overview of methods used to compute cumulative distribution functions
-can be found in `Statistical Computing' by W.J. Kennedy and J.E.
-Gentle. Another general reference is `Elements of Statistical
-Computing' by R.A. Thisted.
+can be found in 'Statistical Computing' by W.J. Kennedy and J.E. Gentle.
+Another general reference is 'Elements of Statistical Computing' by R.A.
+Thisted.
 
-     William E. Kennedy and James E. Gentle, `Statistical Computing'
+     William E. Kennedy and James E. Gentle, 'Statistical Computing'
      (1980), Marcel Dekker, ISBN 0-8247-6898-1.
 
-     Ronald A. Thisted, `Elements of Statistical Computing' (1988),
+     Ronald A. Thisted, 'Elements of Statistical Computing' (1988),
      Chapman & Hall, ISBN 0-412-01371-1.
 
 The cumulative distribution functions for the Gaussian distribution are
 based on the following papers,
 
-     `Rational Chebyshev Approximations Using Linear Equations', W.J.
-     Cody, W. Fraser, J.F. Hart. Numerische Mathematik 12, 242-251
+     'Rational Chebyshev Approximations Using Linear Equations', W.J.
+     Cody, W. Fraser, J.F. Hart.  Numerische Mathematik 12, 242-251
      (1968).
 
-     `Rational Chebyshev Approximations for the Error Function', W.J.
-     Cody. Mathematics of Computation 23, n107, 631-637 (July 1969).
+     'Rational Chebyshev Approximations for the Error Function', W.J.
+     Cody.  Mathematics of Computation 23, n107, 631-637 (July 1969).
 
 
 File: gsl-ref.info,  Node: Statistics,  Next: Histograms,  Prev: Random Number Distributions,  Up: Top
@@ -6746,23 +6698,23 @@ intermediate values that might overflow.
 
    The functions are available in versions for datasets in the standard
 floating-point and integer types.  The versions for double precision
-floating-point data have the prefix `gsl_stats' and are declared in the
-header file `gsl_statistics_double.h'.  The versions for integer data
-have the prefix `gsl_stats_int' and are declared in the header file
-`gsl_statistics_int.h'.
+floating-point data have the prefix 'gsl_stats' and are declared in the
+header file 'gsl_statistics_double.h'.  The versions for integer data
+have the prefix 'gsl_stats_int' and are declared in the header file
+'gsl_statistics_int.h'.
 
 * Menu:
 
-* Mean and standard deviation and variance::
-* Absolute deviation::
-* Higher moments (skewness and kurtosis)::
-* Autocorrelation::
-* Covariance::
-* Weighted Samples::
-* Maximum and Minimum values::
-* Median and Percentiles::
-* Example statistical programs::
-* Statistics References and Further Reading::
+* Mean and standard deviation and variance::  
+* Absolute deviation::          
+* Higher moments (skewness and kurtosis)::  
+* Autocorrelation::             
+* Covariance::                  
+* Weighted Samples::            
+* Maximum and Minimum values::  
+* Median and Percentiles::      
+* Example statistical programs::  
+* Statistics References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Mean and standard deviation and variance,  Next: Absolute deviation,  Up: Statistics
@@ -6770,8 +6722,8 @@ File: gsl-ref.info,  Node: Mean and standard deviation and variance,  Next: Abso
 20.1 Mean, Standard Deviation and Variance
 ==========================================
 
- -- Function: double gsl_stats_mean (const double DATA[], size_t
-          STRIDE, size_t N)
+ -- Function: double gsl_stats_mean (const double DATA[], size_t STRIDE,
+          size_t N)
      This function returns the arithmetic mean of DATA, a dataset of
      length N with stride STRIDE.  The arithmetic mean, or "sample
      mean", is denoted by \Hat\mu and defined as,
@@ -6784,9 +6736,9 @@ File: gsl-ref.info,  Node: Mean and standard deviation and variance,  Next: Abso
 
  -- Function: double gsl_stats_variance (const double DATA[], size_t
           STRIDE, size_t N)
-     This function returns the estimated, or "sample", variance of
-     DATA, a dataset of length N with stride STRIDE.  The estimated
-     variance is denoted by \Hat\sigma^2 and is defined by,
+     This function returns the estimated, or "sample", variance of DATA,
+     a dataset of length N with stride STRIDE.  The estimated variance
+     is denoted by \Hat\sigma^2 and is defined by,
 
           \Hat\sigma^2 = (1/(N-1)) \sum (x_i - \Hat\mu)^2
 
@@ -6796,9 +6748,9 @@ File: gsl-ref.info,  Node: Mean and standard deviation and variance,  Next: Abso
      \sigma^2.  For samples drawn from a gaussian distribution the
      variance of \Hat\sigma^2 itself is 2 \sigma^4 / N.
 
-     This function computes the mean via a call to `gsl_stats_mean'.  If
+     This function computes the mean via a call to 'gsl_stats_mean'.  If
      you have already computed the mean then you can pass it directly to
-     `gsl_stats_variance_m'.
+     'gsl_stats_variance_m'.
 
  -- Function: double gsl_stats_variance_m (const double DATA[], size_t
           STRIDE, size_t N, double MEAN)
@@ -6810,26 +6762,26 @@ File: gsl-ref.info,  Node: Mean and standard deviation and variance,  Next: Abso
 
  -- Function: double gsl_stats_sd (const double DATA[], size_t STRIDE,
           size_t N)
- -- Function: double gsl_stats_sd_m (const double DATA[], size_t
-          STRIDE, size_t N, double MEAN)
+ -- Function: double gsl_stats_sd_m (const double DATA[], size_t STRIDE,
+          size_t N, double MEAN)
      The standard deviation is defined as the square root of the
      variance.  These functions return the square root of the
      corresponding variance functions above.
 
  -- Function: double gsl_stats_variance_with_fixed_mean (const double
           DATA[], size_t STRIDE, size_t N, double MEAN)
-     This function computes an unbiased estimate of the variance of
-     DATA when the population mean MEAN of the underlying distribution
-     is known _a priori_.  In this case the estimator for the variance
-     uses the factor 1/N and the sample mean \Hat\mu is replaced by the
-     known population mean \mu,
+     This function computes an unbiased estimate of the variance of DATA
+     when the population mean MEAN of the underlying distribution is
+     known _a priori_.  In this case the estimator for the variance uses
+     the factor 1/N and the sample mean \Hat\mu is replaced by the known
+     population mean \mu,
 
           \Hat\sigma^2 = (1/N) \sum (x_i - \mu)^2
 
  -- Function: double gsl_stats_sd_with_fixed_mean (const double DATA[],
           size_t STRIDE, size_t N, double MEAN)
-     This function calculates the standard deviation of DATA for a
-     fixed population mean MEAN.  The result is the square root of the
+     This function calculates the standard deviation of DATA for a fixed
+     population mean MEAN.  The result is the square root of the
      corresponding variance function.
 
 
@@ -6847,9 +6799,9 @@ File: gsl-ref.info,  Node: Absolute deviation,  Next: Higher moments (skewness a
           absdev  = (1/N) \sum |x_i - \Hat\mu|
 
      where x_i are the elements of the dataset DATA.  The absolute
-     deviation from the mean provides a more robust measure of the
-     width of a distribution than the variance.  This function computes
-     the mean of DATA via a call to `gsl_stats_mean'.
+     deviation from the mean provides a more robust measure of the width
+     of a distribution than the variance.  This function computes the
+     mean of DATA via a call to 'gsl_stats_mean'.
 
  -- Function: double gsl_stats_absdev_m (const double DATA[], size_t
           STRIDE, size_t N, double MEAN)
@@ -6869,8 +6821,8 @@ File: gsl-ref.info,  Node: Higher moments (skewness and kurtosis),  Next: Autoco
 20.3 Higher moments (skewness and kurtosis)
 ===========================================
 
- -- Function: double gsl_stats_skew (const double DATA[], size_t
-          STRIDE, size_t N)
+ -- Function: double gsl_stats_skew (const double DATA[], size_t STRIDE,
+          size_t N)
      This function computes the skewness of DATA, a dataset of length N
      with stride STRIDE.  The skewness is defined as,
 
@@ -6880,7 +6832,7 @@ File: gsl-ref.info,  Node: Higher moments (skewness and kurtosis),  Next: Autoco
      measures the asymmetry of the tails of a distribution.
 
      The function computes the mean and estimated standard deviation of
-     DATA via calls to `gsl_stats_mean' and `gsl_stats_sd'.
+     DATA via calls to 'gsl_stats_mean' and 'gsl_stats_sd'.
 
  -- Function: double gsl_stats_skew_m_sd (const double DATA[], size_t
           STRIDE, size_t N, double MEAN, double SD)
@@ -6934,7 +6886,6 @@ File: gsl-ref.info,  Node: Autocorrelation,  Next: Covariance,  Prev: Higher mom
      This function computes the lag-1 autocorrelation of the dataset
      DATA using the given value of the mean MEAN.
 
-
 
 File: gsl-ref.info,  Node: Covariance,  Next: Weighted Samples,  Prev: Autocorrelation,  Up: Statistics
 
@@ -6949,14 +6900,13 @@ File: gsl-ref.info,  Node: Covariance,  Next: Weighted Samples,  Prev: Autocorre
 
           covar = (1/(n - 1)) \sum_{i = 1}^{n} (x_i - \Hat x) (y_i - \Hat y)
 
- -- Function: double gsl_stats_covariance_m (const double DATA1[],
-          const size_t STRIDE1, const double DATA2[], const size_t
-          STRIDE2, const size_t N, const double MEAN1, const double
-          MEAN2)
+ -- Function: double gsl_stats_covariance_m (const double DATA1[], const
+          size_t STRIDE1, const double DATA2[], const size_t STRIDE2,
+          const size_t N, const double MEAN1, const double MEAN2)
      This function computes the covariance of the datasets DATA1 and
      DATA2 using the given values of the means, MEAN1 and MEAN2.  This
-     is useful if you have already computed the means of DATA1 and
-     DATA2 and want to avoid recomputing them.
+     is useful if you have already computed the means of DATA1 and DATA2
+     and want to avoid recomputing them.
 
 
 File: gsl-ref.info,  Node: Weighted Samples,  Next: Maximum and Minimum values,  Prev: Covariance,  Up: Statistics
@@ -6968,9 +6918,9 @@ The functions described in this section allow the computation of
 statistics for weighted samples.  The functions accept an array of
 samples, x_i, with associated weights, w_i.  Each sample x_i is
 considered as having been drawn from a Gaussian distribution with
-variance \sigma_i^2.  The sample weight w_i is defined as the
-reciprocal of this variance, w_i = 1/\sigma_i^2.  Setting a weight to
-zero corresponds to removing a sample from a dataset.
+variance \sigma_i^2.  The sample weight w_i is defined as the reciprocal
+of this variance, w_i = 1/\sigma_i^2.  Setting a weight to zero
+corresponds to removing a sample from a dataset.
 
  -- Function: double gsl_stats_wmean (const double W[], size_t WSTRIDE,
           const double DATA[], size_t STRIDE, size_t N)
@@ -7004,12 +6954,12 @@ zero corresponds to removing a sample from a dataset.
           const double DATA[], size_t STRIDE, size_t N)
      The standard deviation is defined as the square root of the
      variance.  This function returns the square root of the
-     corresponding variance function `gsl_stats_wvariance' above.
+     corresponding variance function 'gsl_stats_wvariance' above.
 
  -- Function: double gsl_stats_wsd_m (const double W[], size_t WSTRIDE,
           const double DATA[], size_t STRIDE, size_t N, double WMEAN)
      This function returns the square root of the corresponding variance
-     function `gsl_stats_wvariance_m' above.
+     function 'gsl_stats_wvariance_m' above.
 
  -- Function: double gsl_stats_wvariance_with_fixed_mean (const double
           W[], size_t WSTRIDE, const double DATA[], size_t STRIDE,
@@ -7069,3 +7019,61 @@ zero corresponds to removing a sample from a dataset.
      using the given values of the weighted mean and weighted standard
      deviation, WMEAN and WSD.
 
+
+File: gsl-ref.info,  Node: Maximum and Minimum values,  Next: Median and Percentiles,  Prev: Weighted Samples,  Up: Statistics
+
+20.7 Maximum and Minimum values
+===============================
+
+The following functions find the maximum and minimum values of a dataset
+(or their indices).  If the data contains 'NaN's then a 'NaN' will be
+returned, since the maximum or minimum value is undefined.  For
+functions which return an index, the location of the first 'NaN' in the
+array is returned.
+
+ -- Function: double gsl_stats_max (const double DATA[], size_t STRIDE,
+          size_t N)
+     This function returns the maximum value in DATA, a dataset of
+     length N with stride STRIDE.  The maximum value is defined as the
+     value of the element x_i which satisfies x_i >= x_j for all j.
+
+     If you want instead to find the element with the largest absolute
+     magnitude you will need to apply 'fabs' or 'abs' to your data
+     before calling this function.
+
+ -- Function: double gsl_stats_min (const double DATA[], size_t STRIDE,
+          size_t N)
+     This function returns the minimum value in DATA, a dataset of
+     length N with stride STRIDE.  The minimum value is defined as the
+     value of the element x_i which satisfies x_i <= x_j for all j.
+
+     If you want instead to find the element with the smallest absolute
+     magnitude you will need to apply 'fabs' or 'abs' to your data
+     before calling this function.
+
+ -- Function: void gsl_stats_minmax (double * MIN, double * MAX, const
+          double DATA[], size_t STRIDE, size_t N)
+     This function finds both the minimum and maximum values MIN, MAX in
+     DATA in a single pass.
+
+ -- Function: size_t gsl_stats_max_index (const double DATA[], size_t
+          STRIDE, size_t N)
+     This function returns the index of the maximum value in DATA, a
+     dataset of length N with stride STRIDE.  The maximum value is
+     defined as the value of the element x_i which satisfies x_i >= x_j
+     for all j.  When there are several equal maximum elements then the
+     first one is chosen.
+
+ -- Function: size_t gsl_stats_min_index (const double DATA[], size_t
+          STRIDE, size_t N)
+     This function returns the index of the minimum value in DATA, a
+     dataset of length N with stride STRIDE.  The minimum value is
+     defined as the value of the element x_i which satisfies x_i >= x_j
+     for all j.  When there are several equal minimum elements then the
+     first one is chosen.
+
+ -- Function: void gsl_stats_minmax_index (size_t * MIN_INDEX, size_t *
+          MAX_INDEX, const double DATA[], size_t STRIDE, size_t N)
+     This function returns the indexes MIN_INDEX, MAX_INDEX of the
+     minimum and maximum values in DATA in a single pass.
+
diff --git a/gsl-1.9/doc/gsl-ref.info-3 b/gsl-1.9/doc/gsl-ref.info-3
index d30fefa..e838abc 100644
--- a/gsl-1.9/doc/gsl-ref.info-3
+++ b/gsl-1.9/doc/gsl-ref.info-3
@@ -1,12 +1,7 @@
-This is gsl-ref.info, produced by makeinfo version 4.8 from
+This is gsl-ref.info, produced by makeinfo version 5.1 from
 gsl-ref.texi.
 
-INFO-DIR-SECTION Scientific software
-START-INFO-DIR-ENTRY
-* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
-END-INFO-DIR-ENTRY
-
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 2005, 2006, 2007 The GSL Team.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -20,64 +15,10 @@ License".
 
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
-
-
-File: gsl-ref.info,  Node: Maximum and Minimum values,  Next: Median and Percentiles,  Prev: Weighted Samples,  Up: Statistics
-
-20.7 Maximum and Minimum values
-===============================
-
-The following functions find the maximum and minimum values of a
-dataset (or their indices).  If the data contains `NaN's then a `NaN'
-will be returned, since the maximum or minimum value is undefined.  For
-functions which return an index, the location of the first `NaN' in the
-array is returned.
-
- -- Function: double gsl_stats_max (const double DATA[], size_t STRIDE,
-          size_t N)
-     This function returns the maximum value in DATA, a dataset of
-     length N with stride STRIDE.  The maximum value is defined as the
-     value of the element x_i which satisfies x_i >= x_j for all j.
-
-     If you want instead to find the element with the largest absolute
-     magnitude you will need to apply `fabs' or `abs' to your data
-     before calling this function.
-
- -- Function: double gsl_stats_min (const double DATA[], size_t STRIDE,
-          size_t N)
-     This function returns the minimum value in DATA, a dataset of
-     length N with stride STRIDE.  The minimum value is defined as the
-     value of the element x_i which satisfies x_i <= x_j for all j.
-
-     If you want instead to find the element with the smallest absolute
-     magnitude you will need to apply `fabs' or `abs' to your data
-     before calling this function.
-
- -- Function: void gsl_stats_minmax (double * MIN, double * MAX, const
-          double DATA[], size_t STRIDE, size_t N)
-     This function finds both the minimum and maximum values MIN, MAX
-     in DATA in a single pass.
-
- -- Function: size_t gsl_stats_max_index (const double DATA[], size_t
-          STRIDE, size_t N)
-     This function returns the index of the maximum value in DATA, a
-     dataset of length N with stride STRIDE.  The maximum value is
-     defined as the value of the element x_i which satisfies x_i >= x_j
-     for all j.  When there are several equal maximum elements then the
-     first one is chosen.
-
- -- Function: size_t gsl_stats_min_index (const double DATA[], size_t
-          STRIDE, size_t N)
-     This function returns the index of the minimum value in DATA, a
-     dataset of length N with stride STRIDE.  The minimum value is
-     defined as the value of the element x_i which satisfies x_i >= x_j
-     for all j.  When there are several equal minimum elements then the
-     first one is chosen.
-
- -- Function: void gsl_stats_minmax_index (size_t * MIN_INDEX, size_t *
-          MAX_INDEX, const double DATA[], size_t STRIDE, size_t N)
-     This function returns the indexes MIN_INDEX, MAX_INDEX of the
-     minimum and maximum values in DATA in a single pass.
+INFO-DIR-SECTION Scientific software
+START-INFO-DIR-ENTRY
+* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
+END-INFO-DIR-ENTRY
 
 
 File: gsl-ref.info,  Node: Median and Percentiles,  Next: Example statistical programs,  Prev: Maximum and Minimum values,  Up: Statistics
@@ -86,16 +27,16 @@ File: gsl-ref.info,  Node: Median and Percentiles,  Next: Example statistical pr
 ===========================
 
 The median and percentile functions described in this section operate on
-sorted data.  For convenience we use "quantiles", measured on a scale
-of 0 to 1, instead of percentiles (which use a scale of 0 to 100).
+sorted data.  For convenience we use "quantiles", measured on a scale of
+0 to 1, instead of percentiles (which use a scale of 0 to 100).
 
  -- Function: double gsl_stats_median_from_sorted_data (const double
           SORTED_DATA[], size_t STRIDE, size_t N)
-     This function returns the median value of SORTED_DATA, a dataset
-     of length N with stride STRIDE.  The elements of the array must be
-     in ascending numerical order.  There are no checks to see whether
-     the data are sorted, so the function `gsl_sort' should always be
-     used first.
+     This function returns the median value of SORTED_DATA, a dataset of
+     length N with stride STRIDE.  The elements of the array must be in
+     ascending numerical order.  There are no checks to see whether the
+     data are sorted, so the function 'gsl_sort' should always be used
+     first.
 
      When the dataset has an odd number of elements the median is the
      value of element (n-1)/2.  When the dataset has an even number of
@@ -114,20 +55,20 @@ of 0 to 1, instead of percentiles (which use a scale of 0 to 100).
      the value 0.75.
 
      There are no checks to see whether the data are sorted, so the
-     function `gsl_sort' should always be used first.
+     function 'gsl_sort' should always be used first.
 
      The quantile is found by interpolation, using the formula
 
           quantile = (1 - \delta) x_i + \delta x_{i+1}
 
-     where i is `floor'((n - 1)f) and \delta is (n-1)f - i.
+     where i is 'floor'((n - 1)f) and \delta is (n-1)f - i.
 
-     Thus the minimum value of the array (`data[0*stride]') is given by
-     F equal to zero, the maximum value (`data[(n-1)*stride]') is given
+     Thus the minimum value of the array ('data[0*stride]') is given by
+     F equal to zero, the maximum value ('data[(n-1)*stride]') is given
      by F equal to one and the median value is given by F equal to 0.5.
-     Since the algorithm for computing quantiles involves
-     interpolation this function always returns a floating-point
-     number, even for integer data types.
+     Since the algorithm for computing quantiles involves interpolation
+     this function always returns a floating-point number, even for
+     integer data types.
 
 
 File: gsl-ref.info,  Node: Example statistical programs,  Next: Statistics References and Further Reading,  Prev: Median and Percentiles,  Up: Statistics
@@ -223,10 +164,10 @@ File: gsl-ref.info,  Node: Statistics References and Further Reading,  Prev: Exa
 ====================================
 
 The standard reference for almost any topic in statistics is the
-multi-volume `Advanced Theory of Statistics' by Kendall and Stuart.
+multi-volume 'Advanced Theory of Statistics' by Kendall and Stuart.
 
-     Maurice Kendall, Alan Stuart, and J. Keith Ord.  `The Advanced
-     Theory of Statistics' (multiple volumes) reprinted as `Kendall's
+     Maurice Kendall, Alan Stuart, and J. Keith Ord.  'The Advanced
+     Theory of Statistics' (multiple volumes) reprinted as 'Kendall's
      Advanced Theory of Statistics'.  Wiley, ISBN 047023380X.
 
 Many statistical concepts can be more easily understood by a Bayesian
@@ -234,17 +175,17 @@ approach.  The following book by Gelman, Carlin, Stern and Rubin gives a
 comprehensive coverage of the subject.
 
      Andrew Gelman, John B. Carlin, Hal S. Stern, Donald B. Rubin.
-     `Bayesian Data Analysis'.  Chapman & Hall, ISBN 0412039915.
+     'Bayesian Data Analysis'.  Chapman & Hall, ISBN 0412039915.
 
 For physicists the Particle Data Group provides useful reviews of
 Probability and Statistics in the "Mathematical Tools" section of its
 Annual Review of Particle Physics.
 
-     `Review of Particle Properties' R.M. Barnett et al., Physical
+     'Review of Particle Properties' R.M. Barnett et al., Physical
      Review D54, 1 (1996)
 
 The Review of Particle Physics is available online at the website
-`http://pdg.lbl.gov/'.
+<http://pdg.lbl.gov/>.
 
 
 File: gsl-ref.info,  Node: Histograms,  Next: N-tuples,  Prev: Statistics,  Up: Top
@@ -254,45 +195,45 @@ File: gsl-ref.info,  Node: Histograms,  Next: N-tuples,  Prev: Statistics,  Up:
 
 This chapter describes functions for creating histograms.  Histograms
 provide a convenient way of summarizing the distribution of a set of
-data. A histogram consists of a set of "bins" which count the number of
+data.  A histogram consists of a set of "bins" which count the number of
 events falling into a given range of a continuous variable x.  In GSL
 the bins of a histogram contain floating-point numbers, so they can be
-used to record both integer and non-integer distributions.  The bins
-can use arbitrary sets of ranges (uniformly spaced bins are the
-default).  Both one and two-dimensional histograms are supported.
+used to record both integer and non-integer distributions.  The bins can
+use arbitrary sets of ranges (uniformly spaced bins are the default).
+Both one and two-dimensional histograms are supported.
 
    Once a histogram has been created it can also be converted into a
 probability distribution function.  The library provides efficient
 routines for selecting random samples from probability distributions.
 This can be useful for generating simulations based on real data.
 
-   The functions are declared in the header files `gsl_histogram.h' and
-`gsl_histogram2d.h'.
+   The functions are declared in the header files 'gsl_histogram.h' and
+'gsl_histogram2d.h'.
 
 * Menu:
 
-* The histogram struct::
-* Histogram allocation::
-* Copying Histograms::
-* Updating and accessing histogram elements::
-* Searching histogram ranges::
-* Histogram Statistics::
-* Histogram Operations::
-* Reading and writing histograms::
-* Resampling from histograms::
-* The histogram probability distribution struct::
-* Example programs for histograms::
-* Two dimensional histograms::
-* The 2D histogram struct::
-* 2D Histogram allocation::
-* Copying 2D Histograms::
-* Updating and accessing 2D histogram elements::
-* Searching 2D histogram ranges::
-* 2D Histogram Statistics::
-* 2D Histogram Operations::
-* Reading and writing 2D histograms::
-* Resampling from 2D histograms::
-* Example programs for 2D histograms::
+* The histogram struct::        
+* Histogram allocation::        
+* Copying Histograms::          
+* Updating and accessing histogram elements::  
+* Searching histogram ranges::  
+* Histogram Statistics::        
+* Histogram Operations::        
+* Reading and writing histograms::  
+* Resampling from histograms::  
+* The histogram probability distribution struct::  
+* Example programs for histograms::  
+* Two dimensional histograms::  
+* The 2D histogram struct::     
+* 2D Histogram allocation::     
+* Copying 2D Histograms::       
+* Updating and accessing 2D histogram elements::  
+* Searching 2D histogram ranges::  
+* 2D Histogram Statistics::     
+* 2D Histogram Operations::     
+* Reading and writing 2D histograms::  
+* Resampling from 2D histograms::  
+* Example programs for 2D histograms::  
 
 
 File: gsl-ref.info,  Node: The histogram struct,  Next: Histogram allocation,  Up: Histograms
@@ -303,14 +244,12 @@ File: gsl-ref.info,  Node: The histogram struct,  Next: Histogram allocation,  U
 A histogram is defined by the following struct,
 
  -- Data Type: gsl_histogram
-    `size_t n'
+     'size_t n'
           This is the number of histogram bins
-
-    `double * range'
+     'double * range'
           The ranges of the bins are stored in an array of N+1 elements
           pointed to by RANGE.
-
-    `double * bin'
+     'double * bin'
           The counts for each bin are stored in an array of N elements
           pointed to by BIN.  The bins are floating-point numbers, so
           you can increment them by non-integer values if necessary.
@@ -330,15 +269,15 @@ number-line for x,
         r[0]      r[1]      r[2]      r[3]      r[4]      r[5]
 
 In this picture the values of the RANGE array are denoted by r.  On the
-left-hand side of each bin the square bracket `[' denotes an inclusive
-lower bound (r <= x), and the round parentheses `)' on the right-hand
+left-hand side of each bin the square bracket '[' denotes an inclusive
+lower bound (r <= x), and the round parentheses ')' on the right-hand
 side denote an exclusive upper bound (x < r).  Thus any samples which
 fall on the upper end of the histogram are excluded.  If you want to
-include this value for the last bin you will need to add an extra bin
-to your histogram.
+include this value for the last bin you will need to add an extra bin to
+your histogram.
 
-   The `gsl_histogram' struct and its associated functions are defined
-in the header file `gsl_histogram.h'.
+   The 'gsl_histogram' struct and its associated functions are defined
+in the header file 'gsl_histogram.h'.
 
 
 File: gsl-ref.info,  Node: Histogram allocation,  Next: Copying Histograms,  Prev: The histogram struct,  Up: Histograms
@@ -347,29 +286,29 @@ File: gsl-ref.info,  Node: Histogram allocation,  Next: Copying Histograms,  Pre
 =========================
 
 The functions for allocating memory to a histogram follow the style of
-`malloc' and `free'.  In addition they also perform their own error
+'malloc' and 'free'.  In addition they also perform their own error
 checking.  If there is insufficient memory available to allocate a
 histogram then the functions call the error handler (with an error
-number of `GSL_ENOMEM') in addition to returning a null pointer.  Thus
-if you use the library error handler to abort your program then it
-isn't necessary to check every histogram `alloc'.
+number of 'GSL_ENOMEM') in addition to returning a null pointer.  Thus
+if you use the library error handler to abort your program then it isn't
+necessary to check every histogram 'alloc'.
 
  -- Function: gsl_histogram * gsl_histogram_alloc (size_t N)
      This function allocates memory for a histogram with N bins, and
-     returns a pointer to a newly created `gsl_histogram' struct.  If
+     returns a pointer to a newly created 'gsl_histogram' struct.  If
      insufficient memory is available a null pointer is returned and the
-     error handler is invoked with an error code of `GSL_ENOMEM'. The
+     error handler is invoked with an error code of 'GSL_ENOMEM'.  The
      bins and ranges are not initialized, and should be prepared using
      one of the range-setting functions below in order to make the
      histogram ready for use.
 
  -- Function: int gsl_histogram_set_ranges (gsl_histogram * H, const
           double RANGE[], size_t SIZE)
-     This function sets the ranges of the existing histogram H using
-     the array RANGE of size SIZE.  The values of the histogram bins
-     are reset to zero.  The `range' array should contain the desired
-     bin limits.  The ranges can be arbitrary, subject to the
-     restriction that they are monotonically increasing.
+     This function sets the ranges of the existing histogram H using the
+     array RANGE of size SIZE.  The values of the histogram bins are
+     reset to zero.  The 'range' array should contain the desired bin
+     limits.  The ranges can be arbitrary, subject to the restriction
+     that they are monotonically increasing.
 
      The following example shows how to create a histogram with
      logarithmic bins with ranges [1,10), [10,100) and [100,1000).
@@ -391,9 +330,8 @@ isn't necessary to check every histogram `alloc'.
  -- Function: int gsl_histogram_set_ranges_uniform (gsl_histogram * H,
           double XMIN, double XMAX)
      This function sets the ranges of the existing histogram H to cover
-     the range XMIN to XMAX uniformly.  The values of the histogram
-     bins are reset to zero.  The bin ranges are shown in the table
-     below,
+     the range XMIN to XMAX uniformly.  The values of the histogram bins
+     are reset to zero.  The bin ranges are shown in the table below,
           bin[0] corresponds to xmin <= x < xmin + d
           bin[1] corresponds to xmin + d <= x < xmin + 2 d
           ......
@@ -417,8 +355,8 @@ File: gsl-ref.info,  Node: Copying Histograms,  Next: Updating and accessing his
      histogram DEST, making DEST into an exact copy of SRC.  The two
      histograms must be of the same size.
 
- -- Function: gsl_histogram * gsl_histogram_clone (const gsl_histogram
-          * SRC)
+ -- Function: gsl_histogram * gsl_histogram_clone (const gsl_histogram *
+          SRC)
      This function returns a pointer to a newly created histogram which
      is an exact copy of the histogram SRC.
 
@@ -439,17 +377,17 @@ identify the bin which covers the appropriate range.
 
      If X lies in the valid range of the histogram then the function
      returns zero to indicate success.  If X is less than the lower
-     limit of the histogram then the function returns `GSL_EDOM', and
+     limit of the histogram then the function returns 'GSL_EDOM', and
      none of bins are modified.  Similarly, if the value of X is greater
      than or equal to the upper limit of the histogram then the function
-     returns `GSL_EDOM', and none of the bins are modified.  The error
+     returns 'GSL_EDOM', and none of the bins are modified.  The error
      handler is not called, however, since it is often necessary to
      compute histograms for a small range of a larger dataset, ignoring
      the values outside the range of interest.
 
- -- Function: int gsl_histogram_accumulate (gsl_histogram * H, double
-          X, double WEIGHT)
-     This function is similar to `gsl_histogram_increment' but increases
+ -- Function: int gsl_histogram_accumulate (gsl_histogram * H, double X,
+          double WEIGHT)
+     This function is similar to 'gsl_histogram_increment' but increases
      the value of the appropriate bin in the histogram H by the
      floating-point number WEIGHT.
 
@@ -457,7 +395,7 @@ identify the bin which covers the appropriate range.
           I)
      This function returns the contents of the I-th bin of the histogram
      H.  If I lies outside the valid range of indices for the histogram
-     then the error handler is called with an error code of `GSL_EDOM'
+     then the error handler is called with an error code of 'GSL_EDOM'
      and the function returns 0.
 
  -- Function: int gsl_histogram_get_range (const gsl_histogram * H,
@@ -465,13 +403,13 @@ identify the bin which covers the appropriate range.
      This function finds the upper and lower range limits of the I-th
      bin of the histogram H.  If the index I is valid then the
      corresponding range limits are stored in LOWER and UPPER.  The
-     lower limit is inclusive (i.e. events with this coordinate are
-     included in the bin) and the upper limit is exclusive (i.e. events
+     lower limit is inclusive (i.e.  events with this coordinate are
+     included in the bin) and the upper limit is exclusive (i.e.  events
      with the coordinate of the upper limit are excluded and fall in the
      neighboring higher bin, if it exists).  The function returns 0 to
      indicate success.  If I lies outside the valid range of indices for
      the histogram then the error handler is called and the function
-     returns an error code of `GSL_EDOM'.
+     returns an error code of 'GSL_EDOM'.
 
  -- Function: double gsl_histogram_max (const gsl_histogram * H)
  -- Function: double gsl_histogram_min (const gsl_histogram * H)
@@ -479,7 +417,7 @@ identify the bin which covers the appropriate range.
      These functions return the maximum upper and minimum lower range
      limits and the number of bins of the histogram H.  They provide a
      way of determining these values without accessing the
-     `gsl_histogram' struct directly.
+     'gsl_histogram' struct directly.
 
  -- Function: void gsl_histogram_reset (gsl_histogram * H)
      This function resets all the bins in the histogram H to zero.
@@ -493,16 +431,16 @@ File: gsl-ref.info,  Node: Searching histogram ranges,  Next: Histogram Statisti
 The following functions are used by the access and update routines to
 locate the bin which corresponds to a given x coordinate.
 
- -- Function: int gsl_histogram_find (const gsl_histogram * H, double
-          X, size_t * I)
+ -- Function: int gsl_histogram_find (const gsl_histogram * H, double X,
+          size_t * I)
      This function finds and sets the index I to the bin number which
      covers the coordinate X in the histogram H.  The bin is located
-     using a binary search. The search includes an optimization for
+     using a binary search.  The search includes an optimization for
      histograms with uniform range, and will return the correct bin
      immediately in this case.  If X is found in the range of the
      histogram then the function sets the index I and returns
-     `GSL_SUCCESS'.  If X lies outside the valid range of the histogram
-     then the function returns `GSL_EDOM' and the error handler is
+     'GSL_SUCCESS'.  If X lies outside the valid range of the histogram
+     then the function returns 'GSL_EDOM' and the error handler is
      invoked.
 
 
@@ -517,7 +455,7 @@ File: gsl-ref.info,  Node: Histogram Statistics,  Next: Histogram Operations,  P
 
  -- Function: size_t gsl_histogram_max_bin (const gsl_histogram * H)
      This function returns the index of the bin containing the maximum
-     value. In the case where several bins contain the same maximum
+     value.  In the case where several bins contain the same maximum
      value the smallest index is returned.
 
  -- Function: double gsl_histogram_min_val (const gsl_histogram * H)
@@ -526,24 +464,24 @@ File: gsl-ref.info,  Node: Histogram Statistics,  Next: Histogram Operations,  P
 
  -- Function: size_t gsl_histogram_min_bin (const gsl_histogram * H)
      This function returns the index of the bin containing the minimum
-     value. In the case where several bins contain the same maximum
+     value.  In the case where several bins contain the same maximum
      value the smallest index is returned.
 
  -- Function: double gsl_histogram_mean (const gsl_histogram * H)
      This function returns the mean of the histogrammed variable, where
-     the histogram is regarded as a probability distribution. Negative
+     the histogram is regarded as a probability distribution.  Negative
      bin values are ignored for the purposes of this calculation.  The
      accuracy of the result is limited by the bin width.
 
  -- Function: double gsl_histogram_sigma (const gsl_histogram * H)
      This function returns the standard deviation of the histogrammed
      variable, where the histogram is regarded as a probability
-     distribution. Negative bin values are ignored for the purposes of
-     this calculation. The accuracy of the result is limited by the bin
+     distribution.  Negative bin values are ignored for the purposes of
+     this calculation.  The accuracy of the result is limited by the bin
      width.
 
  -- Function: double gsl_histogram_sum (const gsl_histogram * H)
-     This function returns the sum of all bin values. Negative bin
+     This function returns the sum of all bin values.  Negative bin
      values are included in the sum.
 
 
@@ -560,13 +498,13 @@ File: gsl-ref.info,  Node: Histogram Operations,  Next: Reading and writing hist
  -- Function: int gsl_histogram_add (gsl_histogram * H1, const
           gsl_histogram * H2)
      This function adds the contents of the bins in histogram H2 to the
-     corresponding bins of histogram H1,  i.e. h'_1(i) = h_1(i) +
+     corresponding bins of histogram H1, i.e.  h'_1(i) = h_1(i) +
      h_2(i).  The two histograms must have identical bin ranges.
 
  -- Function: int gsl_histogram_sub (gsl_histogram * H1, const
           gsl_histogram * H2)
      This function subtracts the contents of the bins in histogram H2
-     from the corresponding bins of histogram H1, i.e. h'_1(i) = h_1(i)
+     from the corresponding bins of histogram H1, i.e.  h'_1(i) = h_1(i)
      - h_2(i).  The two histograms must have identical bin ranges.
 
  -- Function: int gsl_histogram_mul (gsl_histogram * H1, const
@@ -584,12 +522,12 @@ File: gsl-ref.info,  Node: Histogram Operations,  Next: Reading and writing hist
      bin ranges.
 
  -- Function: int gsl_histogram_scale (gsl_histogram * H, double SCALE)
-     This function multiplies the contents of the bins of histogram H
-     by the constant SCALE, i.e. h'_1(i) = h_1(i) * scale.
+     This function multiplies the contents of the bins of histogram H by
+     the constant SCALE, i.e.  h'_1(i) = h_1(i) * scale.
 
  -- Function: int gsl_histogram_shift (gsl_histogram * H, double OFFSET)
-     This function shifts the contents of the bins of histogram H by
-     the constant OFFSET, i.e. h'_1(i) = h_1(i) + offset.
+     This function shifts the contents of the bins of histogram H by the
+     constant OFFSET, i.e.  h'_1(i) = h_1(i) + offset.
 
 
 File: gsl-ref.info,  Node: Reading and writing histograms,  Next: Resampling from histograms,  Prev: Histogram Operations,  Up: Histograms
@@ -604,17 +542,17 @@ file as binary data or formatted text.
           gsl_histogram * H)
      This function writes the ranges and bins of the histogram H to the
      stream STREAM in binary format.  The return value is 0 for success
-     and `GSL_EFAILED' if there was a problem writing to the file.
-     Since the data is written in the native binary format it may not
-     be portable between different architectures.
+     and 'GSL_EFAILED' if there was a problem writing to the file.
+     Since the data is written in the native binary format it may not be
+     portable between different architectures.
 
  -- Function: int gsl_histogram_fread (FILE * STREAM, gsl_histogram * H)
      This function reads into the histogram H from the open stream
-     STREAM in binary format.  The histogram H must be preallocated
-     with the correct size since the function uses the number of bins
-     in H to determine how many bytes to read.  The return value is 0
-     for success and `GSL_EFAILED' if there was a problem reading from
-     the file.  The data is assumed to have been written in the native
+     STREAM in binary format.  The histogram H must be preallocated with
+     the correct size since the function uses the number of bins in H to
+     determine how many bytes to read.  The return value is 0 for
+     success and 'GSL_EFAILED' if there was a problem reading from the
+     file.  The data is assumed to have been written in the native
      binary format on the same architecture.
 
  -- Function: int gsl_histogram_fprintf (FILE * STREAM, const
@@ -622,11 +560,11 @@ file as binary data or formatted text.
           BIN_FORMAT)
      This function writes the ranges and bins of the histogram H
      line-by-line to the stream STREAM using the format specifiers
-     RANGE_FORMAT and BIN_FORMAT.  These should be one of the `%g',
-     `%e' or `%f' formats for floating point numbers.  The function
-     returns 0 for success and `GSL_EFAILED' if there was a problem
-     writing to the file.  The histogram output is formatted in three
-     columns, and the columns are separated by spaces, like this,
+     RANGE_FORMAT and BIN_FORMAT.  These should be one of the '%g', '%e'
+     or '%f' formats for floating point numbers.  The function returns 0
+     for success and 'GSL_EFAILED' if there was a problem writing to the
+     file.  The histogram output is formatted in three columns, and the
+     columns are separated by spaces, like this,
 
           range[0] range[1] bin[0]
           range[1] range[2] bin[1]
@@ -646,10 +584,10 @@ file as binary data or formatted text.
           H)
      This function reads formatted data from the stream STREAM into the
      histogram H.  The data is assumed to be in the three-column format
-     used by `gsl_histogram_fprintf'.  The histogram H must be
+     used by 'gsl_histogram_fprintf'.  The histogram H must be
      preallocated with the correct length since the function uses the
      size of H to determine how many numbers to read.  The function
-     returns 0 for success and `GSL_EFAILED' if there was a problem
+     returns 0 for success and 'GSL_EFAILED' if there was a problem
      reading from the file.
 
 
@@ -667,8 +605,8 @@ has the one-dimensional form p(x)dx where,
      p(x) = n_i/ (N w_i)
 
 In this equation n_i is the number of events in the bin which contains
-x, w_i is the width of the bin and N is the total number of events.
-The distribution of events within each bin is assumed to be uniform.
+x, w_i is the width of the bin and N is the total number of events.  The
+distribution of events within each bin is assumed to be uniform.
 
 
 File: gsl-ref.info,  Node: The histogram probability distribution struct,  Next: Example programs for histograms,  Prev: Resampling from histograms,  Up: Histograms
@@ -677,62 +615,60 @@ File: gsl-ref.info,  Node: The histogram probability distribution struct,  Next:
 ===================================================
 
 The probability distribution function for a histogram consists of a set
-of "bins" which measure the probability of an event falling into a
-given range of a continuous variable x. A probability distribution
-function is defined by the following struct, which actually stores the
-cumulative probability distribution function.  This is the natural
-quantity for generating samples via the inverse transform method,
-because there is a one-to-one mapping between the cumulative
-probability distribution and the range [0,1].  It can be shown that by
-taking a uniform random number in this range and finding its
-corresponding coordinate in the cumulative probability distribution we
-obtain samples with the desired probability distribution.
+of "bins" which measure the probability of an event falling into a given
+range of a continuous variable x.  A probability distribution function
+is defined by the following struct, which actually stores the cumulative
+probability distribution function.  This is the natural quantity for
+generating samples via the inverse transform method, because there is a
+one-to-one mapping between the cumulative probability distribution and
+the range [0,1].  It can be shown that by taking a uniform random number
+in this range and finding its corresponding coordinate in the cumulative
+probability distribution we obtain samples with the desired probability
+distribution.
 
  -- Data Type: gsl_histogram_pdf
-    `size_t n'
+     'size_t n'
           This is the number of bins used to approximate the probability
           distribution function.
-
-    `double * range'
+     'double * range'
           The ranges of the bins are stored in an array of N+1 elements
           pointed to by RANGE.
-
-    `double * sum'
+     'double * sum'
           The cumulative probability for the bins is stored in an array
           of N elements pointed to by SUM.
 
-The following functions allow you to create a `gsl_histogram_pdf'
-struct which represents this probability distribution and generate
-random samples from it.
+The following functions allow you to create a 'gsl_histogram_pdf' struct
+which represents this probability distribution and generate random
+samples from it.
 
  -- Function: gsl_histogram_pdf * gsl_histogram_pdf_alloc (size_t N)
      This function allocates memory for a probability distribution with
      N bins and returns a pointer to a newly initialized
-     `gsl_histogram_pdf' struct. If insufficient memory is available a
+     'gsl_histogram_pdf' struct.  If insufficient memory is available a
      null pointer is returned and the error handler is invoked with an
-     error code of `GSL_ENOMEM'.
+     error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_histogram_pdf_init (gsl_histogram_pdf * P, const
           gsl_histogram * H)
      This function initializes the probability distribution P with the
-     contents of the histogram H. If any of the bins of H are negative
-     then the error handler is invoked with an error code of `GSL_EDOM'
+     contents of the histogram H.  If any of the bins of H are negative
+     then the error handler is invoked with an error code of 'GSL_EDOM'
      because a probability distribution cannot contain negative values.
 
  -- Function: void gsl_histogram_pdf_free (gsl_histogram_pdf * P)
-     This function frees the probability distribution function P and
-     all of the memory associated with it.
+     This function frees the probability distribution function P and all
+     of the memory associated with it.
 
- -- Function: double gsl_histogram_pdf_sample (const gsl_histogram_pdf
-          * P, double R)
-     This function uses R, a uniform random number between zero and
-     one, to compute a single random sample from the probability
-     distribution P.  The algorithm used to compute the sample s is
-     given by the following formula,
+ -- Function: double gsl_histogram_pdf_sample (const gsl_histogram_pdf *
+          P, double R)
+     This function uses R, a uniform random number between zero and one,
+     to compute a single random sample from the probability distribution
+     P.  The algorithm used to compute the sample s is given by the
+     following formula,
 
           s = range[i] + delta * (range[i+1] - range[i])
 
-     where i is the index which satisfies sum[i] <=  r < sum[i+1] and
+     where i is the index which satisfies sum[i] <= r < sum[i+1] and
      delta is (r - sum[i])/(sum[i+1] - sum[i]).
 
 
@@ -742,12 +678,12 @@ File: gsl-ref.info,  Node: Example programs for histograms,  Next: Two dimension
 =====================================
 
 The following program shows how to make a simple histogram of a column
-of numerical data supplied on `stdin'.  The program takes three
+of numerical data supplied on 'stdin'.  The program takes three
 arguments, specifying the upper and lower bounds of the histogram and
-the number of bins.  It then reads numbers from `stdin', one line at a
+the number of bins.  It then reads numbers from 'stdin', one line at a
 time, and adds them to the histogram.  When there is no more data to
 read it prints out the accumulated histogram using
-`gsl_histogram_fprintf'.
+'gsl_histogram_fprintf'.
 
      #include <stdio.h>
      #include <stdlib.h>
@@ -788,15 +724,14 @@ read it prints out the accumulated histogram using
      }
 
 Here is an example of the program in use.  We generate 10000 random
-samples from a Cauchy distribution with a width of 30 and histogram
-them over the range -100 to 100, using 200 bins.
+samples from a Cauchy distribution with a width of 30 and histogram them
+over the range -100 to 100, using 200 bins.
 
      $ gsl-randist 0 10000 cauchy 30
         | gsl-histogram -100 100 200 > histogram.dat
 
-A plot of the resulting histogram shows the familiar shape of the
-Cauchy distribution and the fluctuations caused by the finite sample
-size.
+A plot of the resulting histogram shows the familiar shape of the Cauchy
+distribution and the fluctuations caused by the finite sample size.
 
      $ awk '{print $1, $3 ; print $2, $3}' histogram.dat
         | graph -T X
@@ -810,11 +745,11 @@ File: gsl-ref.info,  Node: Two dimensional histograms,  Next: The 2D histogram s
 A two dimensional histogram consists of a set of "bins" which count the
 number of events falling in a given area of the (x,y) plane.  The
 simplest way to use a two dimensional histogram is to record
-two-dimensional position information, n(x,y).  Another possibility is
-to form a "joint distribution" by recording related variables.  For
-example a detector might record both the position of an event (x) and
-the amount of energy it deposited E.  These could be histogrammed as
-the joint distribution n(x,E).
+two-dimensional position information, n(x,y).  Another possibility is to
+form a "joint distribution" by recording related variables.  For example
+a detector might record both the position of an event (x) and the amount
+of energy it deposited E.  These could be histogrammed as the joint
+distribution n(x,E).
 
 
 File: gsl-ref.info,  Node: The 2D histogram struct,  Next: 2D Histogram allocation,  Prev: Two dimensional histograms,  Up: Histograms
@@ -825,29 +760,26 @@ File: gsl-ref.info,  Node: The 2D histogram struct,  Next: 2D Histogram allocati
 Two dimensional histograms are defined by the following struct,
 
  -- Data Type: gsl_histogram2d
-    `size_t nx, ny'
+     'size_t nx, ny'
           This is the number of histogram bins in the x and y
           directions.
-
-    `double * xrange'
+     'double * xrange'
           The ranges of the bins in the x-direction are stored in an
           array of NX + 1 elements pointed to by XRANGE.
-
-    `double * yrange'
+     'double * yrange'
           The ranges of the bins in the y-direction are stored in an
           array of NY + 1 elements pointed to by YRANGE.
-
-    `double * bin'
+     'double * bin'
           The counts for each bin are stored in an array pointed to by
           BIN.  The bins are floating-point numbers, so you can
           increment them by non-integer values if necessary.  The array
-          BIN stores the two dimensional array of bins in a single
-          block of memory according to the mapping `bin(i,j)' = `bin[i
-          * ny + j]'.
+          BIN stores the two dimensional array of bins in a single block
+          of memory according to the mapping 'bin(i,j)' = 'bin[i * ny +
+          j]'.
 
-The range for `bin(i,j)' is given by `xrange[i]' to `xrange[i+1]' in
-the x-direction and `yrange[j]' to `yrange[j+1]' in the y-direction.
-Each bin is inclusive at the lower end and exclusive at the upper end.
+The range for 'bin(i,j)' is given by 'xrange[i]' to 'xrange[i+1]' in the
+x-direction and 'yrange[j]' to 'yrange[j+1]' in the y-direction.  Each
+bin is inclusive at the lower end and exclusive at the upper end.
 Mathematically this means that the bins are defined by the following
 inequality,
      bin(i,j) corresponds to xrange[i] <= x < xrange[i+1]
@@ -857,8 +789,8 @@ Note that any samples which fall on the upper sides of the histogram are
 excluded.  If you want to include these values for the side bins you
 will need to add an extra row or column to your histogram.
 
-   The `gsl_histogram2d' struct and its associated functions are
-defined in the header file `gsl_histogram2d.h'.
+   The 'gsl_histogram2d' struct and its associated functions are defined
+in the header file 'gsl_histogram2d.h'.
 
 
 File: gsl-ref.info,  Node: 2D Histogram allocation,  Next: Copying 2D Histograms,  Prev: The 2D histogram struct,  Up: Histograms
@@ -867,29 +799,29 @@ File: gsl-ref.info,  Node: 2D Histogram allocation,  Next: Copying 2D Histograms
 =============================
 
 The functions for allocating memory to a 2D histogram follow the style
-of `malloc' and `free'.  In addition they also perform their own error
+of 'malloc' and 'free'.  In addition they also perform their own error
 checking.  If there is insufficient memory available to allocate a
 histogram then the functions call the error handler (with an error
-number of `GSL_ENOMEM') in addition to returning a null pointer.  Thus
-if you use the library error handler to abort your program then it
-isn't necessary to check every 2D histogram `alloc'.
+number of 'GSL_ENOMEM') in addition to returning a null pointer.  Thus
+if you use the library error handler to abort your program then it isn't
+necessary to check every 2D histogram 'alloc'.
 
- -- Function: gsl_histogram2d * gsl_histogram2d_alloc (size_t NX,
-          size_t NY)
+ -- Function: gsl_histogram2d * gsl_histogram2d_alloc (size_t NX, size_t
+          NY)
      This function allocates memory for a two-dimensional histogram with
      NX bins in the x direction and NY bins in the y direction.  The
-     function returns a pointer to a newly created `gsl_histogram2d'
-     struct. If insufficient memory is available a null pointer is
+     function returns a pointer to a newly created 'gsl_histogram2d'
+     struct.  If insufficient memory is available a null pointer is
      returned and the error handler is invoked with an error code of
-     `GSL_ENOMEM'. The bins and ranges must be initialized with one of
+     'GSL_ENOMEM'.  The bins and ranges must be initialized with one of
      the functions below before the histogram is ready for use.
 
- -- Function: int gsl_histogram2d_set_ranges (gsl_histogram2d * H,
-          const double XRANGE[], size_t XSIZE, const double YRANGE[],
-          size_t YSIZE)
-     This function sets the ranges of the existing histogram H using
-     the arrays XRANGE and YRANGE of size XSIZE and YSIZE respectively.
-     The values of the histogram bins are reset to zero.
+ -- Function: int gsl_histogram2d_set_ranges (gsl_histogram2d * H, const
+          double XRANGE[], size_t XSIZE, const double YRANGE[], size_t
+          YSIZE)
+     This function sets the ranges of the existing histogram H using the
+     arrays XRANGE and YRANGE of size XSIZE and YSIZE respectively.  The
+     values of the histogram bins are reset to zero.
 
  -- Function: int gsl_histogram2d_set_ranges_uniform (gsl_histogram2d *
           H, double XMIN, double XMAX, double YMIN, double YMAX)
@@ -925,27 +857,27 @@ File: gsl-ref.info,  Node: Updating and accessing 2D histogram elements,  Next:
 ==================================================
 
 You can access the bins of a two-dimensional histogram either by
-specifying a pair of (x,y) coordinates or by using the bin indices
-(i,j) directly.  The functions for accessing the histogram through
-(x,y) coordinates use binary searches in the x and y directions to
-identify the bin which covers the appropriate range.
+specifying a pair of (x,y) coordinates or by using the bin indices (i,j)
+directly.  The functions for accessing the histogram through (x,y)
+coordinates use binary searches in the x and y directions to identify
+the bin which covers the appropriate range.
 
- -- Function: int gsl_histogram2d_increment (gsl_histogram2d * H,
-          double X, double Y)
+ -- Function: int gsl_histogram2d_increment (gsl_histogram2d * H, double
+          X, double Y)
      This function updates the histogram H by adding one (1.0) to the
      bin whose x and y ranges contain the coordinates (X,Y).
 
      If the point (x,y) lies inside the valid ranges of the histogram
      then the function returns zero to indicate success.  If (x,y) lies
      outside the limits of the histogram then the function returns
-     `GSL_EDOM', and none of the bins are modified.  The error handler
+     'GSL_EDOM', and none of the bins are modified.  The error handler
      is not called, since it is often necessary to compute histograms
      for a small range of a larger dataset, ignoring any coordinates
      outside the range of interest.
 
  -- Function: int gsl_histogram2d_accumulate (gsl_histogram2d * H,
           double X, double Y, double WEIGHT)
-     This function is similar to `gsl_histogram2d_increment' but
+     This function is similar to 'gsl_histogram2d_increment' but
      increases the value of the appropriate bin in the histogram H by
      the floating-point number WEIGHT.
 
@@ -954,22 +886,22 @@ identify the bin which covers the appropriate range.
      This function returns the contents of the (I,J)-th bin of the
      histogram H.  If (I,J) lies outside the valid range of indices for
      the histogram then the error handler is called with an error code
-     of `GSL_EDOM' and the function returns 0.
+     of 'GSL_EDOM' and the function returns 0.
 
- -- Function: int gsl_histogram2d_get_xrange (const gsl_histogram2d *
-          H, size_t I, double * XLOWER, double * XUPPER)
- -- Function: int gsl_histogram2d_get_yrange (const gsl_histogram2d *
-          H, size_t J, double * YLOWER, double * YUPPER)
+ -- Function: int gsl_histogram2d_get_xrange (const gsl_histogram2d * H,
+          size_t I, double * XLOWER, double * XUPPER)
+ -- Function: int gsl_histogram2d_get_yrange (const gsl_histogram2d * H,
+          size_t J, double * YLOWER, double * YUPPER)
      These functions find the upper and lower range limits of the I-th
      and J-th bins in the x and y directions of the histogram H.  The
      range limits are stored in XLOWER and XUPPER or YLOWER and YUPPER.
-     The lower limits are inclusive (i.e. events with these
-     coordinates are included in the bin) and the upper limits are
-     exclusive (i.e. events with the value of the upper limit are not
-     included and fall in the neighboring higher bin, if it exists).
-     The functions return 0 to indicate success.  If I or J lies
-     outside the valid range of indices for the histogram then the
-     error handler is called with an error code of `GSL_EDOM'.
+     The lower limits are inclusive (i.e.  events with these coordinates
+     are included in the bin) and the upper limits are exclusive (i.e.
+     events with the value of the upper limit are not included and fall
+     in the neighboring higher bin, if it exists).  The functions return
+     0 to indicate success.  If I or J lies outside the valid range of
+     indices for the histogram then the error handler is called with an
+     error code of 'GSL_EDOM'.
 
  -- Function: double gsl_histogram2d_xmax (const gsl_histogram2d * H)
  -- Function: double gsl_histogram2d_xmin (const gsl_histogram2d * H)
@@ -980,7 +912,7 @@ identify the bin which covers the appropriate range.
      These functions return the maximum upper and minimum lower range
      limits and the number of bins for the x and y directions of the
      histogram H.  They provide a way of determining these values
-     without accessing the `gsl_histogram2d' struct directly.
+     without accessing the 'gsl_histogram2d' struct directly.
 
  -- Function: void gsl_histogram2d_reset (gsl_histogram2d * H)
      This function resets all the bins of the histogram H to zero.
@@ -997,13 +929,13 @@ locate the bin which corresponds to a given (x,y) coordinate.
  -- Function: int gsl_histogram2d_find (const gsl_histogram2d * H,
           double X, double Y, size_t * I, size_t * J)
      This function finds and sets the indices I and J to the to the bin
-     which covers the coordinates (X,Y). The bin is located using a
+     which covers the coordinates (X,Y).  The bin is located using a
      binary search.  The search includes an optimization for histograms
-     with uniform ranges, and will return the correct bin immediately
-     in this case. If (x,y) is found then the function sets the indices
-     (I,J) and returns `GSL_SUCCESS'.  If (x,y) lies outside the valid
-     range of the histogram then the function returns `GSL_EDOM' and
-     the error handler is invoked.
+     with uniform ranges, and will return the correct bin immediately in
+     this case.  If (x,y) is found then the function sets the indices
+     (I,J) and returns 'GSL_SUCCESS'.  If (x,y) lies outside the valid
+     range of the histogram then the function returns 'GSL_EDOM' and the
+     error handler is invoked.
 
 
 File: gsl-ref.info,  Node: 2D Histogram Statistics,  Next: 2D Histogram Operations,  Prev: Searching 2D histogram ranges,  Up: Histograms
@@ -1018,7 +950,7 @@ File: gsl-ref.info,  Node: 2D Histogram Statistics,  Next: 2D Histogram Operatio
  -- Function: void gsl_histogram2d_max_bin (const gsl_histogram2d * H,
           size_t * I, size_t * J)
      This function finds the indices of the bin containing the maximum
-     value in the histogram H and stores the result in (I,J). In the
+     value in the histogram H and stores the result in (I,J).  In the
      case where several bins contain the same maximum value the first
      bin found is returned.
 
@@ -1029,7 +961,7 @@ File: gsl-ref.info,  Node: 2D Histogram Statistics,  Next: 2D Histogram Operatio
  -- Function: void gsl_histogram2d_min_bin (const gsl_histogram2d * H,
           size_t * I, size_t * J)
      This function finds the indices of the bin containing the minimum
-     value in the histogram H and stores the result in (I,J). In the
+     value in the histogram H and stores the result in (I,J).  In the
      case where several bins contain the same maximum value the first
      bin found is returned.
 
@@ -1048,23 +980,23 @@ File: gsl-ref.info,  Node: 2D Histogram Statistics,  Next: 2D Histogram Operatio
  -- Function: double gsl_histogram2d_xsigma (const gsl_histogram2d * H)
      This function returns the standard deviation of the histogrammed x
      variable, where the histogram is regarded as a probability
-     distribution. Negative bin values are ignored for the purposes of
+     distribution.  Negative bin values are ignored for the purposes of
      this calculation.
 
  -- Function: double gsl_histogram2d_ysigma (const gsl_histogram2d * H)
      This function returns the standard deviation of the histogrammed y
      variable, where the histogram is regarded as a probability
-     distribution. Negative bin values are ignored for the purposes of
+     distribution.  Negative bin values are ignored for the purposes of
      this calculation.
 
  -- Function: double gsl_histogram2d_cov (const gsl_histogram2d * H)
      This function returns the covariance of the histogrammed x and y
      variables, where the histogram is regarded as a probability
-     distribution. Negative bin values are ignored for the purposes of
+     distribution.  Negative bin values are ignored for the purposes of
      this calculation.
 
  -- Function: double gsl_histogram2d_sum (const gsl_histogram2d * H)
-     This function returns the sum of all bin values. Negative bin
+     This function returns the sum of all bin values.  Negative bin
      values are included in the sum.
 
 
@@ -1081,13 +1013,13 @@ File: gsl-ref.info,  Node: 2D Histogram Operations,  Next: Reading and writing 2
  -- Function: int gsl_histogram2d_add (gsl_histogram2d * H1, const
           gsl_histogram2d * H2)
      This function adds the contents of the bins in histogram H2 to the
-     corresponding bins of histogram H1, i.e. h'_1(i,j) = h_1(i,j) +
+     corresponding bins of histogram H1, i.e.  h'_1(i,j) = h_1(i,j) +
      h_2(i,j).  The two histograms must have identical bin ranges.
 
  -- Function: int gsl_histogram2d_sub (gsl_histogram2d * H1, const
           gsl_histogram2d * H2)
      This function subtracts the contents of the bins in histogram H2
-     from the corresponding bins of histogram H1, i.e. h'_1(i,j) =
+     from the corresponding bins of histogram H1, i.e.  h'_1(i,j) =
      h_1(i,j) - h_2(i,j).  The two histograms must have identical bin
      ranges.
 
@@ -1107,13 +1039,13 @@ File: gsl-ref.info,  Node: 2D Histogram Operations,  Next: Reading and writing 2
 
  -- Function: int gsl_histogram2d_scale (gsl_histogram2d * H, double
           SCALE)
-     This function multiplies the contents of the bins of histogram H
-     by the constant SCALE, i.e. h'_1(i,j) = h_1(i,j) scale.
+     This function multiplies the contents of the bins of histogram H by
+     the constant SCALE, i.e.  h'_1(i,j) = h_1(i,j) scale.
 
  -- Function: int gsl_histogram2d_shift (gsl_histogram2d * H, double
           OFFSET)
-     This function shifts the contents of the bins of histogram H by
-     the constant OFFSET, i.e. h'_1(i,j) = h_1(i,j) + offset.
+     This function shifts the contents of the bins of histogram H by the
+     constant OFFSET, i.e.  h'_1(i,j) = h_1(i,j) + offset.
 
 
 File: gsl-ref.info,  Node: Reading and writing 2D histograms,  Next: Resampling from 2D histograms,  Prev: 2D Histogram Operations,  Up: Histograms
@@ -1128,9 +1060,9 @@ histograms to a file as binary data or formatted text.
           gsl_histogram2d * H)
      This function writes the ranges and bins of the histogram H to the
      stream STREAM in binary format.  The return value is 0 for success
-     and `GSL_EFAILED' if there was a problem writing to the file.
-     Since the data is written in the native binary format it may not
-     be portable between different architectures.
+     and 'GSL_EFAILED' if there was a problem writing to the file.
+     Since the data is written in the native binary format it may not be
+     portable between different architectures.
 
  -- Function: int gsl_histogram2d_fread (FILE * STREAM, gsl_histogram2d
           * H)
@@ -1138,7 +1070,7 @@ histograms to a file as binary data or formatted text.
      binary format.  The histogram H must be preallocated with the
      correct size since the function uses the number of x and y bins in
      H to determine how many bytes to read.  The return value is 0 for
-     success and `GSL_EFAILED' if there was a problem reading from the
+     success and 'GSL_EFAILED' if there was a problem reading from the
      file.  The data is assumed to have been written in the native
      binary format on the same architecture.
 
@@ -1147,11 +1079,11 @@ histograms to a file as binary data or formatted text.
           BIN_FORMAT)
      This function writes the ranges and bins of the histogram H
      line-by-line to the stream STREAM using the format specifiers
-     RANGE_FORMAT and BIN_FORMAT.  These should be one of the `%g',
-     `%e' or `%f' formats for floating point numbers.  The function
-     returns 0 for success and `GSL_EFAILED' if there was a problem
-     writing to the file.  The histogram output is formatted in five
-     columns, and the columns are separated by spaces, like this,
+     RANGE_FORMAT and BIN_FORMAT.  These should be one of the '%g', '%e'
+     or '%f' formats for floating point numbers.  The function returns 0
+     for success and 'GSL_EFAILED' if there was a problem writing to the
+     file.  The histogram output is formatted in five columns, and the
+     columns are separated by spaces, like this,
 
           xrange[0] xrange[1] yrange[0] yrange[1] bin(0,0)
           xrange[0] xrange[1] yrange[1] yrange[2] bin(0,1)
@@ -1179,14 +1111,14 @@ histograms to a file as binary data or formatted text.
      these values but this allows the histogram to be manipulated with
      line-oriented tools.
 
- -- Function: int gsl_histogram2d_fscanf (FILE * STREAM,
-          gsl_histogram2d * H)
+ -- Function: int gsl_histogram2d_fscanf (FILE * STREAM, gsl_histogram2d
+          * H)
      This function reads formatted data from the stream STREAM into the
      histogram H.  The data is assumed to be in the five-column format
-     used by `gsl_histogram_fprintf'.  The histogram H must be
+     used by 'gsl_histogram_fprintf'.  The histogram H must be
      preallocated with the correct lengths since the function uses the
      sizes of H to determine how many numbers to read.  The function
-     returns 0 for success and `GSL_EFAILED' if there was a problem
+     returns 0 for success and 'GSL_EFAILED' if there was a problem
      reading from the file.
 
 
@@ -1198,9 +1130,9 @@ File: gsl-ref.info,  Node: Resampling from 2D histograms,  Next: Example program
 As in the one-dimensional case, a two-dimensional histogram made by
 counting events can be regarded as a measurement of a probability
 distribution.  Allowing for statistical error, the height of each bin
-represents the probability of an event where (x,y) falls in the range
-of that bin.  For a two-dimensional histogram the probability
-distribution takes the form p(x,y) dx dy where,
+represents the probability of an event where (x,y) falls in the range of
+that bin.  For a two-dimensional histogram the probability distribution
+takes the form p(x,y) dx dy where,
 
      p(x,y) = n_{ij}/ (N A_{ij})
 
@@ -1210,23 +1142,20 @@ of events.  The distribution of events within each bin is assumed to be
 uniform.
 
  -- Data Type: gsl_histogram2d_pdf
-    `size_t nx, ny'
+     'size_t nx, ny'
           This is the number of histogram bins used to approximate the
           probability distribution function in the x and y directions.
-
-    `double * xrange'
+     'double * xrange'
           The ranges of the bins in the x-direction are stored in an
           array of NX + 1 elements pointed to by XRANGE.
-
-    `double * yrange'
+     'double * yrange'
           The ranges of the bins in the y-direction are stored in an
           array of NY + 1 pointed to by YRANGE.
-
-    `double * sum'
+     'double * sum'
           The cumulative probability for the bins is stored in an array
           of NX*NY elements pointed to by SUM.
 
-The following functions allow you to create a `gsl_histogram2d_pdf'
+The following functions allow you to create a 'gsl_histogram2d_pdf'
 struct which represents a two dimensional probability distribution and
 generate random samples from it.
 
@@ -1234,16 +1163,16 @@ generate random samples from it.
           NX, size_t NY)
      This function allocates memory for a two-dimensional probability
      distribution of size NX-by-NY and returns a pointer to a newly
-     initialized `gsl_histogram2d_pdf' struct. If insufficient memory
+     initialized 'gsl_histogram2d_pdf' struct.  If insufficient memory
      is available a null pointer is returned and the error handler is
-     invoked with an error code of `GSL_ENOMEM'.
+     invoked with an error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_histogram2d_pdf_init (gsl_histogram2d_pdf * P,
           const gsl_histogram2d * H)
      This function initializes the two-dimensional probability
-     distribution calculated P from the histogram H.  If any of the
-     bins of H are negative then the error handler is invoked with an
-     error code of `GSL_EDOM' because a probability distribution cannot
+     distribution calculated P from the histogram H.  If any of the bins
+     of H are negative then the error handler is invoked with an error
+     code of 'GSL_EDOM' because a probability distribution cannot
      contain negative values.
 
  -- Function: void gsl_histogram2d_pdf_free (gsl_histogram2d_pdf * P)
@@ -1321,7 +1250,6 @@ which are printed out.
        return 0;
      }
 
-
 
 File: gsl-ref.info,  Node: N-tuples,  Next: Monte Carlo Integration,  Prev: Histograms,  Up: Top
 
@@ -1330,7 +1258,7 @@ File: gsl-ref.info,  Node: N-tuples,  Next: Monte Carlo Integration,  Prev: Hist
 
 This chapter describes functions for creating and manipulating
 "ntuples", sets of values associated with events.  The ntuples are
-stored in files. Their values can be extracted in any combination and
+stored in files.  Their values can be extracted in any combination and
 "booked" in a histogram using a selection function.
 
    The values to be stored are held in a user-defined data structure,
@@ -1340,24 +1268,24 @@ the ntuple functions described below.
 
    A histogram can be created from ntuple data by providing a selection
 function and a value function.  The selection function specifies whether
-an event should be included in the subset to be analyzed or not. The
+an event should be included in the subset to be analyzed or not.  The
 value function computes the entry to be added to the histogram for each
 event.
 
    All the ntuple functions are defined in the header file
-`gsl_ntuple.h'
+'gsl_ntuple.h'
 
 * Menu:
 
-* The ntuple struct::
-* Creating ntuples::
-* Opening an existing ntuple file::
-* Writing ntuples::
-* Reading ntuples ::
-* Closing an ntuple file::
-* Histogramming ntuple values::
-* Example ntuple programs::
-* Ntuple References and Further Reading::
+* The ntuple struct::           
+* Creating ntuples::            
+* Opening an existing ntuple file::  
+* Writing ntuples::             
+* Reading ntuples ::            
+* Closing an ntuple file::      
+* Histogramming ntuple values::  
+* Example ntuple programs::     
+* Ntuple References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: The ntuple struct,  Next: Creating ntuples,  Up: N-tuples
@@ -1365,7 +1293,7 @@ File: gsl-ref.info,  Node: The ntuple struct,  Next: Creating ntuples,  Up: N-tu
 22.1 The ntuple struct
 ======================
 
-Ntuples are manipulated using the `gsl_ntuple' struct. This struct
+Ntuples are manipulated using the 'gsl_ntuple' struct.  This struct
 contains information on the file where the ntuple data is stored, a
 pointer to the current ntuple data row and the size of the user-defined
 ntuple data struct.
@@ -1400,7 +1328,7 @@ File: gsl-ref.info,  Node: Opening an existing ntuple file,  Next: Writing ntupl
  -- Function: gsl_ntuple * gsl_ntuple_open (char * FILENAME, void *
           NTUPLE_DATA, size_t SIZE)
      This function opens an existing ntuple file FILENAME for reading
-     and returns a pointer to a corresponding ntuple struct. The
+     and returns a pointer to a corresponding ntuple struct.  The
      ntuples in the file must have size SIZE.  A pointer to memory for
      the current ntuple row NTUPLE_DATA must be supplied--this is used
      to copy ntuples in and out of the file.
@@ -1412,11 +1340,11 @@ File: gsl-ref.info,  Node: Writing ntuples,  Next: Reading ntuples,  Prev: Openi
 ====================
 
  -- Function: int gsl_ntuple_write (gsl_ntuple * NTUPLE)
-     This function writes the current ntuple NTUPLE->NTUPLE_DATA of
-     size NTUPLE->SIZE to the corresponding file.
+     This function writes the current ntuple NTUPLE->NTUPLE_DATA of size
+     NTUPLE->SIZE to the corresponding file.
 
  -- Function: int gsl_ntuple_bookdata (gsl_ntuple * NTUPLE)
-     This function is a synonym for `gsl_ntuple_write'.
+     This function is a synonym for 'gsl_ntuple_write'.
 
 
 File: gsl-ref.info,  Node: Reading ntuples,  Next: Closing an ntuple file,  Prev: Writing ntuples,  Up: N-tuples
@@ -1445,11 +1373,11 @@ File: gsl-ref.info,  Node: Histogramming ntuple values,  Next: Example ntuple pr
 ================================
 
 Once an ntuple has been created its contents can be histogrammed in
-various ways using the function `gsl_ntuple_project'.  Two user-defined
+various ways using the function 'gsl_ntuple_project'.  Two user-defined
 functions must be provided, a function to select events and a function
-to compute scalar values. The selection function and the value function
-both accept the ntuple row as a first argument and other parameters as
-a second argument.
+to compute scalar values.  The selection function and the value function
+both accept the ntuple row as a first argument and other parameters as a
+second argument.
 
    The "selection function" determines which ntuple rows are selected
 for histogramming.  It is defined by the following struct,
@@ -1468,20 +1396,20 @@ selected by the selection function,
        void * params;
      } gsl_ntuple_value_fn;
 
-In this case the struct component FUNCTION should return the value to
-be added to the histogram for the ntuple row.
+In this case the struct component FUNCTION should return the value to be
+added to the histogram for the ntuple row.
 
  -- Function: int gsl_ntuple_project (gsl_histogram * H, gsl_ntuple *
-          NTUPLE, gsl_ntuple_value_fn * VALUE_FUNC,
-          gsl_ntuple_select_fn * SELECT_FUNC)
+          NTUPLE, gsl_ntuple_value_fn * VALUE_FUNC, gsl_ntuple_select_fn
+          * SELECT_FUNC)
      This function updates the histogram H from the ntuple NTUPLE using
-     the functions VALUE_FUNC and SELECT_FUNC. For each ntuple row
+     the functions VALUE_FUNC and SELECT_FUNC.  For each ntuple row
      where the selection function SELECT_FUNC is non-zero the
      corresponding value of that row is computed using the function
      VALUE_FUNC and added to the histogram.  Those ntuple rows where
-     SELECT_FUNC returns zero are ignored.  New entries are added to
-     the histogram, so subsequent calls can be used to accumulate
-     further data in the same histogram.
+     SELECT_FUNC returns zero are ignored.  New entries are added to the
+     histogram, so subsequent calls can be used to accumulate further
+     data in the same histogram.
 
 
 File: gsl-ref.info,  Node: Example ntuple programs,  Next: Ntuple References and Further Reading,  Prev: Histogramming ntuple values,  Up: N-tuples
@@ -1493,7 +1421,7 @@ The following example programs demonstrate the use of ntuples in
 managing a large dataset.  The first program creates a set of 10,000
 simulated "events", each with 3 associated values (x,y,z).  These are
 generated from a gaussian distribution with unit variance, for
-demonstration purposes, and written to the ntuple file `test.dat'.
+demonstration purposes, and written to the ntuple file 'test.dat'.
 
      #include <gsl/gsl_ntuple.h>
      #include <gsl/gsl_rng.h>
@@ -1539,7 +1467,7 @@ demonstration purposes, and written to the ntuple file `test.dat'.
        return 0;
      }
 
-The next program analyses the ntuple data in the file `test.dat'.  The
+The next program analyses the ntuple data in the file 'test.dat'.  The
 analysis procedure is to compute the squared-magnitude of each event,
 E^2=x^2+y^2+z^2, and select only those which exceed a lower limit of
 1.5.  The selected events are then histogrammed using their E^2 values.
@@ -1638,7 +1566,7 @@ File: gsl-ref.info,  Node: Monte Carlo Integration,  Next: Simulated Annealing,
 This chapter describes routines for multidimensional Monte Carlo
 integration.  These include the traditional Monte Carlo method and
 adaptive algorithms such as VEGAS and MISER which use importance
-sampling and stratified sampling techniques. Each algorithm computes an
+sampling and stratified sampling techniques.  Each algorithm computes an
 estimate of a multidimensional definite integral of the form,
 
      I = \int_xl^xu dx \int_yl^yu  dy ...  f(x, y, ...)
@@ -1646,21 +1574,21 @@ estimate of a multidimensional definite integral of the form,
 over a hypercubic region ((x_l,x_u), (y_l,y_u), ...) using a fixed
 number of function calls.  The routines also provide a statistical
 estimate of the error on the result.  This error estimate should be
-taken as a guide rather than as a strict error bound--random sampling
-of the region may not uncover all the important features of the
-function, resulting in an underestimate of the error.
+taken as a guide rather than as a strict error bound--random sampling of
+the region may not uncover all the important features of the function,
+resulting in an underestimate of the error.
 
    The functions are defined in separate header files for each routine,
-`gsl_monte_plain.h', `gsl_monte_miser.h' and `gsl_monte_vegas.h'.
+'gsl_monte_plain.h', 'gsl_monte_miser.h' and 'gsl_monte_vegas.h'.
 
 * Menu:
 
-* Monte Carlo Interface::
-* PLAIN Monte Carlo::
-* MISER::
-* VEGAS::
-* Monte Carlo Examples::
-* Monte Carlo Integration References and Further Reading::
+* Monte Carlo Interface::       
+* PLAIN Monte Carlo::  
+* MISER::                       
+* VEGAS::                       
+* Monte Carlo Examples::        
+* Monte Carlo Integration References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Monte Carlo Interface,  Next: PLAIN Monte Carlo,  Up: Monte Carlo Integration
@@ -1687,22 +1615,23 @@ chosen strictly within the integration region, so that endpoint
 singularities are automatically avoided.
 
    The function to be integrated has its own datatype, defined in the
-header file `gsl_monte.h'.
+header file 'gsl_monte.h'.
 
  -- Data Type: gsl_monte_function
+
      This data type defines a general function with parameters for Monte
      Carlo integration.
 
-    `double (* f) (double * X, size_t DIM, void * PARAMS)'
+     'double (* f) (double * X, size_t DIM, void * PARAMS)'
           this function should return the value f(x,params) for the
           argument X and parameters PARAMS, where X is an array of size
           DIM giving the coordinates of the point where the function is
           to be evaluated.
 
-    `size_t dim'
+     'size_t dim'
           the number of dimensions for X.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function.
 
 Here is an example for a quadratic function in two dimensions,
@@ -1710,7 +1639,7 @@ Here is an example for a quadratic function in two dimensions,
      f(x,y) = a x^2 + b x y + c y^2
 
 with a = 3, b = 2, c = 1.  The following code defines a
-`gsl_monte_function' `F' which you could pass to an integrator:
+'gsl_monte_function' 'F' which you could pass to an integrator:
 
      struct my_f_params { double a; double b; double c; };
 
@@ -1763,12 +1692,12 @@ mean,
 For large N this variance decreases asymptotically as \Var(f)/N, where
 \Var(f) is the true variance of the function over the integration
 region.  The error estimate itself should decrease as
-\sigma(f)/\sqrt{N}.  The familiar law of errors decreasing as
-1/\sqrt{N} applies--to reduce the error by a factor of 10 requires a
-100-fold increase in the number of sample points.
+\sigma(f)/\sqrt{N}.  The familiar law of errors decreasing as 1/\sqrt{N}
+applies--to reduce the error by a factor of 10 requires a 100-fold
+increase in the number of sample points.
 
    The functions described in this section are declared in the header
-file `gsl_monte_plain.h'.
+file 'gsl_monte_plain.h'.
 
  -- Function: gsl_monte_plain_state * gsl_monte_plain_alloc (size_t DIM)
      This function allocates and initializes a workspace for Monte Carlo
@@ -1788,7 +1717,7 @@ file `gsl_monte_plain.h'.
      the lower and upper limits in the arrays XL and XU, each of size
      DIM.  The integration uses a fixed number of function calls CALLS,
      and obtains random sampling points using the random number
-     generator R. A previously allocated workspace S must be supplied.
+     generator R.  A previously allocated workspace S must be supplied.
      The result of the integration is returned in RESULT, with an
      estimated absolute error ABSERR.
 
@@ -1802,10 +1731,9 @@ File: gsl-ref.info,  Node: MISER,  Next: VEGAS,  Prev: PLAIN Monte Carlo,  Up: M
 23.3 MISER
 ==========
 
-The MISER algorithm of Press and Farrar is based on recursive
-stratified sampling.  This technique aims to reduce the overall
-integration error by concentrating integration points in the regions of
-highest variance.
+The MISER algorithm of Press and Farrar is based on recursive stratified
+sampling.  This technique aims to reduce the overall integration error
+by concentrating integration points in the regions of highest variance.
 
    The idea of stratified sampling begins with the observation that for
 two disjoint regions a and b with Monte Carlo estimates of the integral
@@ -1826,21 +1754,21 @@ sub-region.
 
    The MISER algorithm proceeds by bisecting the integration region
 along one coordinate axis to give two sub-regions at each step.  The
-direction is chosen by examining all d possible bisections and
-selecting the one which will minimize the combined variance of the two
+direction is chosen by examining all d possible bisections and selecting
+the one which will minimize the combined variance of the two
 sub-regions.  The variance in the sub-regions is estimated by sampling
 with a fraction of the total number of points available to the current
 step.  The same procedure is then repeated recursively for each of the
-two half-spaces from the best bisection. The remaining sample points are
-allocated to the sub-regions using the formula for N_a and N_b.  This
-recursive allocation of integration points continues down to a
+two half-spaces from the best bisection.  The remaining sample points
+are allocated to the sub-regions using the formula for N_a and N_b.
+This recursive allocation of integration points continues down to a
 user-specified depth where each sub-region is integrated using a plain
-Monte Carlo estimate.  These individual values and their error
-estimates are then combined upwards to give an overall result and an
-estimate of its error.
+Monte Carlo estimate.  These individual values and their error estimates
+are then combined upwards to give an overall result and an estimate of
+its error.
 
    The functions described in this section are declared in the header
-file `gsl_monte_miser.h'.
+file 'gsl_monte_miser.h'.
 
  -- Function: gsl_monte_miser_state * gsl_monte_miser_alloc (size_t DIM)
      This function allocates and initializes a workspace for Monte Carlo
@@ -1861,7 +1789,7 @@ file `gsl_monte_miser.h'.
      the lower and upper limits in the arrays XL and XU, each of size
      DIM.  The integration uses a fixed number of function calls CALLS,
      and obtains random sampling points using the random number
-     generator R. A previously allocated workspace S must be supplied.
+     generator R.  A previously allocated workspace S must be supplied.
      The result of the integration is returned in RESULT, with an
      estimated absolute error ABSERR.
 
@@ -1869,22 +1797,22 @@ file `gsl_monte_miser.h'.
      This function frees the memory associated with the integrator state
      S.
 
-   The MISER algorithm has several configurable parameters. The
-following variables can be accessed through the `gsl_monte_miser_state'
+   The MISER algorithm has several configurable parameters.  The
+following variables can be accessed through the 'gsl_monte_miser_state'
 struct,
 
  -- Variable: double estimate_frac
      This parameter specifies the fraction of the currently available
      number of function calls which are allocated to estimating the
-     variance at each recursive step. The default value is 0.1.
+     variance at each recursive step.  The default value is 0.1.
 
  -- Variable: size_t min_calls
      This parameter specifies the minimum number of function calls
-     required for each estimate of the variance. If the number of
+     required for each estimate of the variance.  If the number of
      function calls allocated to the estimate using ESTIMATE_FRAC falls
-     below MIN_CALLS then MIN_CALLS are used instead.  This ensures
-     that each estimate maintains a reasonable level of accuracy.  The
-     default value of MIN_CALLS is `16 * dim'.
+     below MIN_CALLS then MIN_CALLS are used instead.  This ensures that
+     each estimate maintains a reasonable level of accuracy.  The
+     default value of MIN_CALLS is '16 * dim'.
 
  -- Variable: size_t min_calls_per_bisection
      This parameter specifies the minimum number of function calls
@@ -1892,7 +1820,7 @@ struct,
      has fewer calls available than MIN_CALLS_PER_BISECTION it performs
      a plain Monte Carlo estimate of the current sub-region and
      terminates its branch of the recursion.  The default value of this
-     parameter is `32 * min_calls'.
+     parameter is '32 * min_calls'.
 
  -- Variable: double alpha
      This parameter controls how the estimated variances for the two
@@ -1912,11 +1840,11 @@ struct,
 
  -- Variable: double dither
      This parameter introduces a random fractional variation of size
-     DITHER into each bisection, which can be used to break the
-     symmetry of integrands which are concentrated near the exact
-     center of the hypercubic integration region.  The default value of
-     dither is zero, so no variation is introduced. If needed, a
-     typical value of DITHER is 0.1.
+     DITHER into each bisection, which can be used to break the symmetry
+     of integrands which are concentrated near the exact center of the
+     hypercubic integration region.  The default value of dither is
+     zero, so no variation is introduced.  If needed, a typical value of
+     DITHER is 0.1.
 
 
 File: gsl-ref.info,  Node: VEGAS,  Next: Monte Carlo Examples,  Prev: MISER,  Up: Monte Carlo Integration
@@ -1948,18 +1876,18 @@ desired distribution.
 
    The VEGAS algorithm approximates the exact distribution by making a
 number of passes over the integration region while histogramming the
-function f. Each histogram is used to define a sampling distribution
+function f.  Each histogram is used to define a sampling distribution
 for the next pass.  Asymptotically this procedure converges to the
-desired distribution. In order to avoid the number of histogram bins
+desired distribution.  In order to avoid the number of histogram bins
 growing like K^d the probability distribution is approximated by a
-separable function: g(x_1, x_2, ...) = g_1(x_1) g_2(x_2) ...  so that
-the number of bins required is only Kd.  This is equivalent to locating
-the peaks of the function from the projections of the integrand onto
-the coordinate axes.  The efficiency of VEGAS depends on the validity
-of this assumption.  It is most efficient when the peaks of the
-integrand are well-localized.  If an integrand can be rewritten in a
-form which is approximately separable this will increase the efficiency
-of integration with VEGAS.
+separable function: g(x_1, x_2, ...) = g_1(x_1) g_2(x_2) ... so that the
+number of bins required is only Kd.  This is equivalent to locating the
+peaks of the function from the projections of the integrand onto the
+coordinate axes.  The efficiency of VEGAS depends on the validity of
+this assumption.  It is most efficient when the peaks of the integrand
+are well-localized.  If an integrand can be rewritten in a form which is
+approximately separable this will increase the efficiency of integration
+with VEGAS.
 
    VEGAS incorporates a number of additional features, and combines both
 stratified sampling and importance sampling.  The integration region is
@@ -1987,11 +1915,11 @@ switches to a kind variance reduction (rather than importance sampling).
      the lower and upper limits in the arrays XL and XU, each of size
      DIM.  The integration uses a fixed number of function calls CALLS,
      and obtains random sampling points using the random number
-     generator R. A previously allocated workspace S must be supplied.
+     generator R.  A previously allocated workspace S must be supplied.
      The result of the integration is returned in RESULT, with an
-     estimated absolute error ABSERR.  The result and its error
-     estimate are based on a weighted average of independent samples.
-     The chi-squared per degree of freedom for the weighted average is
+     estimated absolute error ABSERR.  The result and its error estimate
+     are based on a weighted average of independent samples.  The
+     chi-squared per degree of freedom for the weighted average is
      returned via the state struct component, S->CHISQ, and must be
      consistent with 1 for the weighted average to be reliable.
 
@@ -2000,32 +1928,35 @@ switches to a kind variance reduction (rather than importance sampling).
      S.
 
    The VEGAS algorithm computes a number of independent estimates of the
-integral internally, according to the `iterations' parameter described
+integral internally, according to the 'iterations' parameter described
 below, and returns their weighted average.  Random sampling of the
 integrand can occasionally produce an estimate where the error is zero,
-particularly if the function is constant in some regions. An estimate
+particularly if the function is constant in some regions.  An estimate
 with zero error causes the weighted average to break down and must be
-handled separately. In the original Fortran implementations of VEGAS
+handled separately.  In the original Fortran implementations of VEGAS
 the error estimate is made non-zero by substituting a small value
-(typically `1e-30').  The implementation in GSL differs from this and
+(typically '1e-30').  The implementation in GSL differs from this and
 avoids the use of an arbitrary constant--it either assigns the value a
 weight which is the average weight of the preceding estimates or
 discards it according to the following procedure,
 
 current estimate has zero error, weighted average has finite error
+
      The current estimate is assigned a weight which is the average
      weight of the preceding estimates.
 
 current estimate has finite error, previous estimates had zero error
+
      The previous estimates are discarded and the weighted averaging
      procedure begins with the current estimate.
 
 current estimate has zero error, previous estimates had zero error
+
      The estimates are averaged using the arithmetic mean, but no error
      is computed.
 
-   The VEGAS algorithm is highly configurable. The following variables
-can be accessed through the `gsl_monte_vegas_state' struct,
+   The VEGAS algorithm is highly configurable.  The following variables
+can be accessed through the 'gsl_monte_vegas_state' struct,
 
  -- Variable: double result
  -- Variable: double sigma
@@ -2038,12 +1969,12 @@ can be accessed through the `gsl_monte_vegas_state' struct,
      close to 1.  A value of CHISQ which differs significantly from 1
      indicates that the values from different iterations are
      inconsistent.  In this case the weighted error will be
-     under-estimated, and further iterations of the algorithm are
-     needed to obtain reliable results.
+     under-estimated, and further iterations of the algorithm are needed
+     to obtain reliable results.
 
  -- Variable: double alpha
-     The parameter `alpha' controls the stiffness of the rebinning
-     algorithm.  It is typically set between one and two. A value of
+     The parameter 'alpha' controls the stiffness of the rebinning
+     algorithm.  It is typically set between one and two.  A value of
      zero prevents rebinning of the grid.  The default value is 1.5.
 
  -- Variable: size_t iterations
@@ -2052,21 +1983,21 @@ can be accessed through the `gsl_monte_vegas_state' struct,
 
  -- Variable: int stage
      Setting this determines the "stage" of the calculation.  Normally,
-     `stage = 0' which begins with a new uniform grid and empty weighted
-     average.  Calling vegas with `stage = 1' retains the grid from the
+     'stage = 0' which begins with a new uniform grid and empty weighted
+     average.  Calling vegas with 'stage = 1' retains the grid from the
      previous run but discards the weighted average, so that one can
      "tune" the grid using a relatively small number of points and then
-     do a large run with `stage = 1' on the optimized grid.  Setting
-     `stage = 2' keeps the grid and the weighted average from the
+     do a large run with 'stage = 1' on the optimized grid.  Setting
+     'stage = 2' keeps the grid and the weighted average from the
      previous run, but may increase (or decrease) the number of
      histogram bins in the grid depending on the number of calls
-     available.  Choosing `stage = 3' enters at the main loop, so that
+     available.  Choosing 'stage = 3' enters at the main loop, so that
      nothing is changed, and is equivalent to performing additional
      iterations in a previous call.
 
  -- Variable: int mode
-     The possible choices are `GSL_VEGAS_MODE_IMPORTANCE',
-     `GSL_VEGAS_MODE_STRATIFIED', `GSL_VEGAS_MODE_IMPORTANCE_ONLY'.
+     The possible choices are 'GSL_VEGAS_MODE_IMPORTANCE',
+     'GSL_VEGAS_MODE_STRATIFIED', 'GSL_VEGAS_MODE_IMPORTANCE_ONLY'.
      This determines whether VEGAS will use importance sampling or
      stratified sampling, or whether it can pick on its own.  In low
      dimensions VEGAS uses strict stratified sampling (more precisely,
@@ -2075,12 +2006,12 @@ can be accessed through the `gsl_monte_vegas_state' struct,
 
  -- Variable: int verbose
  -- Variable: FILE * ostream
-     These parameters set the level of information printed by VEGAS. All
-     information is written to the stream OSTREAM.  The default setting
-     of VERBOSE is `-1', which turns off all output.  A VERBOSE value
-     of `0' prints summary information about the weighted average and
-     final result, while a value of `1' also displays the grid
-     coordinates.  A value of `2' prints information from the rebinning
+     These parameters set the level of information printed by VEGAS.
+     All information is written to the stream OSTREAM.  The default
+     setting of VERBOSE is '-1', which turns off all output.  A VERBOSE
+     value of '0' prints summary information about the weighted average
+     and final result, while a value of '1' also displays the grid
+     coordinates.  A value of '2' prints information from the rebinning
      procedure for each iteration.
 
 
@@ -2219,7 +2150,7 @@ special measures are needed to avoid these singularities.
      }
 
 With 500,000 function calls the plain Monte Carlo algorithm achieves a
-fractional error of 0.6%.  The estimated error `sigma' is consistent
+fractional error of 0.6%.  The estimated error 'sigma' is consistent
 with the actual error, and the computed result differs from the true
 result by about one standard deviation,
 
@@ -2241,10 +2172,10 @@ correctly estimates the error,
 In the case of the VEGAS algorithm the program uses an initial warm-up
 run of 10,000 function calls to prepare, or "warm up", the grid.  This
 is followed by a main run with five iterations of 100,000 function
-calls. The chi-squared per degree of freedom for the five iterations are
-checked for consistency with 1, and the run is repeated if the results
-have not converged. In this case the estimates are consistent on the
-first pass.
+calls.  The chi-squared per degree of freedom for the five iterations
+are checked for consistency with 1, and the run is repeated if the
+results have not converged.  In this case the estimates are consistent
+on the first pass.
 
      vegas warm-up ==================
      result =  1.386925
@@ -2259,7 +2190,7 @@ first pass.
      exact  =  1.393204
      error  = -0.000247 = 0.5 sigma
 
-If the value of `chisq' had differed significantly from 1 it would
+If the value of 'chisq' had differed significantly from 1 it would
 indicate inconsistent results, with a correspondingly underestimated
 error.  The final estimate from VEGAS (using a similar number of
 function calls) is significantly more accurate than the other two
@@ -2274,16 +2205,16 @@ File: gsl-ref.info,  Node: Monte Carlo Integration References and Further Readin
 The MISER algorithm is described in the following article by Press and
 Farrar,
 
-     W.H. Press, G.R. Farrar, `Recursive Stratified Sampling for
-     Multidimensional Monte Carlo Integration', Computers in Physics,
-     v4 (1990), pp190-195.
+     W.H. Press, G.R. Farrar, 'Recursive Stratified Sampling for
+     Multidimensional Monte Carlo Integration', Computers in Physics, v4
+     (1990), pp190-195.
 
 The VEGAS algorithm is described in the following papers,
 
-     G.P. Lepage, `A New Algorithm for Adaptive Multidimensional
+     G.P. Lepage, 'A New Algorithm for Adaptive Multidimensional
      Integration', Journal of Computational Physics 27, 192-203, (1978)
 
-     G.P. Lepage, `VEGAS: An Adaptive Multi-dimensional Integration
+     G.P. Lepage, 'VEGAS: An Adaptive Multi-dimensional Integration
      Program', Cornell preprint CLNS 80-447, March 1980
 
 
@@ -2295,7 +2226,7 @@ File: gsl-ref.info,  Node: Simulated Annealing,  Next: Ordinary Differential Equ
 Stochastic search techniques are used when the structure of a space is
 not well understood or is not smooth, so that techniques like Newton's
 method (which requires calculating Jacobian derivative matrices) cannot
-be used. In particular, these techniques are frequently used to solve
+be used.  In particular, these techniques are frequently used to solve
 combinatorial optimization problems, such as the traveling salesman
 problem.
 
@@ -2307,14 +2238,14 @@ through the space at successively lower temperatures, where the
 probability of taking a step is given by a Boltzmann distribution.
 
    The functions described in this chapter are declared in the header
-file `gsl_siman.h'.
+file 'gsl_siman.h'.
 
 * Menu:
 
-* Simulated Annealing algorithm::
-* Simulated Annealing functions::
-* Examples with Simulated Annealing::
-* Simulated Annealing References and Further Reading::
+* Simulated Annealing algorithm::  
+* Simulated Annealing functions::  
+* Examples with Simulated Annealing::  
+* Simulated Annealing References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Simulated Annealing algorithm,  Next: Simulated Annealing functions,  Up: Simulated Annealing
@@ -2331,15 +2262,15 @@ distribution,
 
 if E_{i+1} > E_i, and p = 1 when E_{i+1} <= E_i.
 
-   In other words, a step will occur if the new energy is lower.  If
-the new energy is higher, the transition can still occur, and its
-likelihood is proportional to the temperature T and inversely
-proportional to the energy difference E_{i+1} - E_i.
+   In other words, a step will occur if the new energy is lower.  If the
+new energy is higher, the transition can still occur, and its likelihood
+is proportional to the temperature T and inversely proportional to the
+energy difference E_{i+1} - E_i.
 
-   The temperature T is initially set to a high value, and a random
-walk is carried out at that temperature.  Then the temperature is
-lowered very slightly according to a "cooling schedule", for example: T
--> T/mu_T where \mu_T is slightly greater than 1.  
+   The temperature T is initially set to a high value, and a random walk
+is carried out at that temperature.  Then the temperature is lowered
+very slightly according to a "cooling schedule", for example: T ->
+T/mu_T where \mu_T is slightly greater than 1.
 
    The slight probability of taking a step that gives higher energy is
 what allows simulated annealing to frequently get out of local minima.
@@ -2352,11 +2283,11 @@ File: gsl-ref.info,  Node: Simulated Annealing functions,  Next: Examples with S
 
  -- Function: void gsl_siman_solve (const gsl_rng * R, void * X0_P,
           gsl_siman_Efunc_t EF, gsl_siman_step_t TAKE_STEP,
-          gsl_siman_metric_t DISTANCE, gsl_siman_print_t
-          PRINT_POSITION, gsl_siman_copy_t COPYFUNC,
-          gsl_siman_copy_construct_t COPY_CONSTRUCTOR,
-          gsl_siman_destroy_t DESTRUCTOR, size_t ELEMENT_SIZE,
-          gsl_siman_params_t PARAMS)
+          gsl_siman_metric_t DISTANCE, gsl_siman_print_t PRINT_POSITION,
+          gsl_siman_copy_t COPYFUNC, gsl_siman_copy_construct_t
+          COPY_CONSTRUCTOR, gsl_siman_destroy_t DESTRUCTOR, size_t
+          ELEMENT_SIZE, gsl_siman_params_t PARAMS)
+
      This function performs a simulated annealing search through a given
      space.  The space is specified by providing the functions EF and
      DISTANCE.  The simulated annealing steps are generated using the
@@ -2366,13 +2297,13 @@ File: gsl-ref.info,  Node: Simulated Annealing functions,  Next: Examples with S
      The routine offers two modes for updating configurations, a
      fixed-size mode and a variable-size mode.  In the fixed-size mode
      the configuration is stored as a single block of memory of size
-     ELEMENT_SIZE.  Copies of this configuration are created, copied
-     and destroyed internally using the standard library functions
-     `malloc', `memcpy' and `free'.  The function pointers COPYFUNC,
+     ELEMENT_SIZE.  Copies of this configuration are created, copied and
+     destroyed internally using the standard library functions 'malloc',
+     'memcpy' and 'free'.  The function pointers COPYFUNC,
      COPY_CONSTRUCTOR and DESTRUCTOR should be null pointers in
-     fixed-size mode.  In the variable-size mode the functions
-     COPYFUNC, COPY_CONSTRUCTOR and DESTRUCTOR are used to create, copy
-     and destroy configurations internally.  The variable ELEMENT_SIZE
+     fixed-size mode.  In the variable-size mode the functions COPYFUNC,
+     COPY_CONSTRUCTOR and DESTRUCTOR are used to create, copy and
+     destroy configurations internally.  The variable ELEMENT_SIZE
      should be zero in the variable-size mode.
 
      The PARAMS structure (described below) controls the run by
@@ -2380,11 +2311,11 @@ File: gsl-ref.info,  Node: Simulated Annealing functions,  Next: Examples with S
      the algorithm.
 
      On exit the best result achieved during the search is placed in
-     `*X0_P'.  If the annealing process has been successful this should
+     '*X0_P'.  If the annealing process has been successful this should
      be a good approximation to the optimal point in the space.
 
-     If the function pointer PRINT_POSITION is not null, a debugging
-     log will be printed to `stdout' with the following columns:
+     If the function pointer PRINT_POSITION is not null, a debugging log
+     will be printed to 'stdout' with the following columns:
 
           number_of_iterations temperature x x-(*x0_p) Ef(x)
 
@@ -2438,21 +2369,21 @@ prototypes for these functions are given below.
           void (*gsl_siman_destroy_t) (void *xp)
 
  -- Data Type: gsl_siman_params_t
-     These are the parameters that control a run of `gsl_siman_solve'.
+     These are the parameters that control a run of 'gsl_siman_solve'.
      This structure contains all the information needed to control the
      search, beyond the energy function, the step function and the
      initial guess.
 
-    `int n_tries'
+     'int n_tries'
           The number of points to try for each step.
 
-    `int iters_fixed_T'
+     'int iters_fixed_T'
           The number of iterations at each temperature.
 
-    `double step_size'
+     'double step_size'
           The maximum step size in the random walk.
 
-    `double k, t_initial, mu_t, t_min'
+     'double k, t_initial, mu_t, t_min'
           The parameters of the Boltzmann distribution and cooling
           schedule.
 
@@ -2469,8 +2400,8 @@ application with little change and should make things easier.
 
 * Menu:
 
-* Trivial example::
-* Traveling Salesman Problem::
+* Trivial example::             
+* Traveling Salesman Problem::  
 
 
 File: gsl-ref.info,  Node: Trivial example,  Next: Traveling Salesman Problem,  Up: Examples with Simulated Annealing
@@ -2567,8 +2498,8 @@ minimum.
        return 0;
      }
 
-   Here are a couple of plots that are generated by running
-`siman_test' in the following way:
+   Here are a couple of plots that are generated by running 'siman_test'
+in the following way:
 
      $ ./siman_test | awk '!/^#/ {print $1, $4}'
       | graph -y 1.34 1.4 -W0 -X generation -Y position
@@ -2591,12 +2522,12 @@ since I am using the great-circle distance between cities, rather than
 the driving distance.  Also: I assume the earth is a sphere, so I don't
 use geoid distances.
 
-   The `gsl_siman_solve' routine finds a route which is 3490.62
+   The 'gsl_siman_solve' routine finds a route which is 3490.62
 Kilometers long; this is confirmed by an exhaustive search of all
 possible routes with the same initial city.
 
-   The full code can be found in `siman/siman_tsp.c', but I include
-here some plots generated in the following way:
+   The full code can be found in 'siman/siman_tsp.c', but I include here
+some plots generated in the following way:
 
      $ ./siman_tsp > tsp.output
      $ grep -v "^#" tsp.output
@@ -2661,7 +2592,7 @@ File: gsl-ref.info,  Node: Simulated Annealing References and Further Reading,
 
 Further information is available in the following book,
 
-     `Modern Heuristic Techniques for Combinatorial Problems', Colin R.
+     'Modern Heuristic Techniques for Combinatorial Problems', Colin R.
      Reeves (ed.), McGraw-Hill, 1995 (ISBN 0-07-709239-2).
 
 
@@ -2677,16 +2608,16 @@ and higher-level components for adaptive step-size control.  The
 components can be combined by the user to achieve the desired solution,
 with full access to any intermediate steps.
 
-   These functions are declared in the header file `gsl_odeiv.h'.
+   These functions are declared in the header file 'gsl_odeiv.h'.
 
 * Menu:
 
-* Defining the ODE System::
-* Stepping Functions::
-* Adaptive Step-size Control::
-* Evolution::
-* ODE Example programs::
-* ODE References and Further Reading::
+* Defining the ODE System::     
+* Stepping Functions::          
+* Adaptive Step-size Control::  
+* Evolution::                   
+* ODE Example programs::        
+* ODE References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Defining the ODE System,  Next: Stepping Functions,  Up: Ordinary Differential Equations
@@ -2700,40 +2631,40 @@ The routines solve the general n-dimensional first-order system,
 
 for i = 1, \dots, n.  The stepping functions rely on the vector of
 derivatives f_i and the Jacobian matrix, J_{ij} = df_i(t,y(t)) / dy_j.
-A system of equations is defined using the `gsl_odeiv_system' datatype.
+A system of equations is defined using the 'gsl_odeiv_system' datatype.
 
  -- Data Type: gsl_odeiv_system
      This data type defines a general ODE system with arbitrary
      parameters.
 
-    `int (* function) (double t, const double y[], double dydt[], void * params)'
-          This function should store the vector elements
-          f_i(t,y,params) in the array DYDT, for arguments (T,Y) and
-          parameters PARAMS.  The function should return `GSL_SUCCESS'
-          if the calculation was completed successfully. Any other
-          return value indicates an error.
+     'int (* function) (double t, const double y[], double dydt[], void * params)'
+          This function should store the vector elements f_i(t,y,params)
+          in the array DYDT, for arguments (T,Y) and parameters PARAMS.
+          The function should return 'GSL_SUCCESS' if the calculation
+          was completed successfully.  Any other return value indicates
+          an error.
 
-    `int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params);'
+     'int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params);'
           This function should store the vector of derivative elements
           df_i(t,y,params)/dt in the array DFDT and the Jacobian matrix
           J_{ij} in the array DFDY, regarded as a row-ordered matrix
-          `J(i,j) = dfdy[i * dimension + j]' where `dimension' is the
+          'J(i,j) = dfdy[i * dimension + j]' where 'dimension' is the
           dimension of the system.  The function should return
-          `GSL_SUCCESS' if the calculation was completed successfully.
+          'GSL_SUCCESS' if the calculation was completed successfully.
           Any other return value indicates an error.
 
           Some of the simpler solver algorithms do not make use of the
           Jacobian matrix, so it is not always strictly necessary to
-          provide it (the `jacobian' element of the struct can be
-          replaced by a null pointer for those algorithms).  However,
-          it is useful to provide the Jacobian to allow the solver
-          algorithms to be interchanged--the best algorithms make use
-          of the Jacobian.
+          provide it (the 'jacobian' element of the struct can be
+          replaced by a null pointer for those algorithms).  However, it
+          is useful to provide the Jacobian to allow the solver
+          algorithms to be interchanged--the best algorithms make use of
+          the Jacobian.
 
-    `size_t dimension;'
+     'size_t dimension;'
           This is the dimension of the system of equations.
 
-    `void * params'
+     'void * params'
           This is a pointer to the arbitrary parameters of the system.
 
 
@@ -2742,8 +2673,8 @@ File: gsl-ref.info,  Node: Stepping Functions,  Next: Adaptive Step-size Control
 25.2 Stepping Functions
 =======================
 
-The lowest level components are the "stepping functions" which advance
-a solution from time t to t+h for a fixed step-size h and estimate the
+The lowest level components are the "stepping functions" which advance a
+solution from time t to t+h for a fixed step-size h and estimate the
 resulting local error.
 
  -- Function: gsl_odeiv_step * gsl_odeiv_step_alloc (const
@@ -2753,8 +2684,8 @@ resulting local error.
 
  -- Function: int gsl_odeiv_step_reset (gsl_odeiv_step * S)
      This function resets the stepping function S.  It should be used
-     whenever the next use of S will not be a continuation of a
-     previous step.
+     whenever the next use of S will not be a continuation of a previous
+     step.
 
  -- Function: void gsl_odeiv_step_free (gsl_odeiv_step * S)
      This function frees all the memory associated with the stepping
@@ -2768,13 +2699,13 @@ resulting local error.
           printf ("step method is '%s'\n",
                    gsl_odeiv_step_name (s));
 
-     would print something like `step method is 'rk4''.
+     would print something like 'step method is 'rk4''.
 
  -- Function: unsigned int gsl_odeiv_step_order (const gsl_odeiv_step *
           S)
      This function returns the order of the stepping function on the
-     previous step.  This order can vary if the stepping function
-     itself is adaptive.
+     previous step.  This order can vary if the stepping function itself
+     is adaptive.
 
  -- Function: int gsl_odeiv_step_apply (gsl_odeiv_step * S, double T,
           double H, double Y[], double YERR[], const double DYDT_IN[],
@@ -2783,23 +2714,23 @@ resulting local error.
      equations defined by DYDT, using the step size H to advance the
      system from time T and state Y to time T+H.  The new state of the
      system is stored in Y on output, with an estimate of the absolute
-     error in each component stored in YERR.  If the argument DYDT_IN
-     is not null it should point an array containing the derivatives
-     for the system at time T on input. This is optional as the
-     derivatives will be computed internally if they are not provided,
-     but allows the reuse of existing derivative information.  On
-     output the new derivatives of the system at time T+H will be
-     stored in DYDT_OUT if it is not null.
+     error in each component stored in YERR.  If the argument DYDT_IN is
+     not null it should point an array containing the derivatives for
+     the system at time T on input.  This is optional as the derivatives
+     will be computed internally if they are not provided, but allows
+     the reuse of existing derivative information.  On output the new
+     derivatives of the system at time T+H will be stored in DYDT_OUT if
+     it is not null.
 
      If the user-supplied functions defined in the system DYDT return a
-     status other than `GSL_SUCCESS' the step will be aborted.  In this
+     status other than 'GSL_SUCCESS' the step will be aborted.  In this
      case, the elements of Y will be restored to their pre-step values
      and the error code from the user-supplied function will be
      returned.  The step-size H will be set to the step-size which
      caused the error.  If the function is called again with a smaller
-     step-size, e.g. H/10, it should be possible to get closer to any
+     step-size, e.g.  H/10, it should be possible to get closer to any
      singularity.  To distinguish between error codes from the
-     user-supplied functions and those from `gsl_odeiv_step_apply'
+     user-supplied functions and those from 'gsl_odeiv_step_apply'
      itself, any user-defined return values should be distinct from the
      standard GSL error codes.
 
@@ -2847,8 +2778,8 @@ The control function examines the proposed change to the solution
 produced by a stepping function and attempts to determine the optimal
 step-size for a user-specified level of error.
 
- -- Function: gsl_odeiv_control * gsl_odeiv_control_standard_new
-          (double EPS_ABS, double EPS_REL, double A_Y, double A_DYDT)
+ -- Function: gsl_odeiv_control * gsl_odeiv_control_standard_new (double
+          EPS_ABS, double EPS_REL, double A_Y, double A_DYDT)
      The standard control object is a four parameter heuristic based on
      absolute and relative errors EPS_ABS and EPS_REL, and scaling
      factors A_Y and A_DYDT for the system state y(t) and derivatives
@@ -2860,24 +2791,24 @@ step-size for a user-specified level of error.
           D_i = eps_abs + eps_rel * (a_y |y_i| + a_dydt h |y'_i|)
 
      and comparing it with the observed error E_i = |yerr_i|.  If the
-     observed error E exceeds the desired error level D by more than
-     10% for any component then the method reduces the step-size by an
+     observed error E exceeds the desired error level D by more than 10%
+     for any component then the method reduces the step-size by an
      appropriate factor,
 
           h_new = h_old * S * (E/D)^(-1/q)
 
-     where q is the consistency order of the method (e.g. q=4 for 4(5)
-     embedded RK), and S is a safety factor of 0.9. The ratio E/D is
+     where q is the consistency order of the method (e.g.  q=4 for 4(5)
+     embedded RK), and S is a safety factor of 0.9.  The ratio E/D is
      taken to be the maximum of the ratios E_i/D_i.
 
-     If the observed error E is less than 50% of the desired error
-     level D for the maximum ratio E_i/D_i then the algorithm takes the
+     If the observed error E is less than 50% of the desired error level
+     D for the maximum ratio E_i/D_i then the algorithm takes the
      opportunity to increase the step-size to bring the error in line
      with the desired level,
 
           h_new = h_old * S * (E/D)^(-1/(q+1))
 
-     This encompasses all the standard error scaling methods. To avoid
+     This encompasses all the standard error scaling methods.  To avoid
      uncontrolled changes in the stepsize, the overall scaling factor is
      limited to the range 1/5 to 5.
 
@@ -2901,7 +2832,7 @@ step-size for a user-specified level of error.
           EPS_ABS, double EPS_REL, double A_Y, double A_DYDT, const
           double SCALE_ABS[], size_t DIM)
      This function creates a new control object which uses the same
-     algorithm as `gsl_odeiv_control_standard_new' but with an absolute
+     algorithm as 'gsl_odeiv_control_standard_new' but with an absolute
      error which is scaled for each component by the array SCALE_ABS.
      The formula for D_i for this control object is,
 
@@ -2930,14 +2861,14 @@ step-size for a user-specified level of error.
  -- Function: int gsl_odeiv_control_hadjust (gsl_odeiv_control * C,
           gsl_odeiv_step * S, const double Y[], const double YERR[],
           const double DYDT[], double * H)
-     This function adjusts the step-size H using the control function
-     C, and the current values of Y, YERR and DYDT.  The stepping
-     function STEP is also needed to determine the order of the method.
-     If the error in the y-values YERR is found to be too large then
-     the step-size H is reduced and the function returns
-     `GSL_ODEIV_HADJ_DEC'.  If the error is sufficiently small then H
-     may be increased and `GSL_ODEIV_HADJ_INC' is returned.  The
-     function returns `GSL_ODEIV_HADJ_NIL' if the step-size is
+     This function adjusts the step-size H using the control function C,
+     and the current values of Y, YERR and DYDT.  The stepping function
+     STEP is also needed to determine the order of the method.  If the
+     error in the y-values YERR is found to be too large then the
+     step-size H is reduced and the function returns
+     'GSL_ODEIV_HADJ_DEC'.  If the error is sufficiently small then H
+     may be increased and 'GSL_ODEIV_HADJ_INC' is returned.  The
+     function returns 'GSL_ODEIV_HADJ_NIL' if the step-size is
      unchanged.  The goal of the function is to estimate the largest
      step-size which satisfies the user-specified accuracy requirements
      for the current point.
@@ -2950,7 +2881,7 @@ step-size for a user-specified level of error.
           printf ("control method is '%s'\n",
                   gsl_odeiv_control_name (c));
 
-     would print something like `control method is 'standard''
+     would print something like 'control method is 'standard''
 
 
 File: gsl-ref.info,  Node: Evolution,  Next: ODE Example programs,  Prev: Adaptive Step-size Control,  Up: Ordinary Differential Equations
@@ -2976,29 +2907,29 @@ step-size is found.
           double Y[])
      This function advances the system (E, DYDT) from time T and
      position Y using the stepping function STEP.  The new time and
-     position are stored in T and Y on output.  The initial step-size
-     is taken as H, but this will be modified using the control
-     function C to achieve the appropriate error bound if necessary.
-     The routine may make several calls to STEP in order to determine
-     the optimum step-size. An estimate of the local error for the step
-     can be obtained from the components of the array `E->yerr[]'.  If
-     the step-size has been changed the value of H will be modified on
+     position are stored in T and Y on output.  The initial step-size is
+     taken as H, but this will be modified using the control function C
+     to achieve the appropriate error bound if necessary.  The routine
+     may make several calls to STEP in order to determine the optimum
+     step-size.  An estimate of the local error for the step can be
+     obtained from the components of the array 'E->yerr[]'.  If the
+     step-size has been changed the value of H will be modified on
      output.  The maximum time T1 is guaranteed not to be exceeded by
      the time-step.  On the final time-step the value of T will be set
      to T1 exactly.
 
      If the user-supplied functions defined in the system DYDT return a
-     status other than `GSL_SUCCESS' the step will be aborted.  In this
-     case,  T and Y will be restored to their pre-step values and the
+     status other than 'GSL_SUCCESS' the step will be aborted.  In this
+     case, T and Y will be restored to their pre-step values and the
      error code from the user-supplied function will be returned.  To
      distinguish between error codes from the user-supplied functions
-     and those from `gsl_odeiv_evolve_apply' itself, any user-defined
+     and those from 'gsl_odeiv_evolve_apply' itself, any user-defined
      return values should be distinct from the standard GSL error codes.
 
  -- Function: int gsl_odeiv_evolve_reset (gsl_odeiv_evolve * E)
      This function resets the evolution function E.  It should be used
-     whenever the next use of E will not be a continuation of a
-     previous step.
+     whenever the next use of E will not be a continuation of a previous
+     step.
 
  -- Function: void gsl_odeiv_evolve_free (gsl_odeiv_evolve * E)
      This function frees all the memory associated with the evolution
@@ -3022,8 +2953,8 @@ variable for the velocity, y = x'(t),
      x' = y
      y' = -x + \mu y (1-x^2)
 
-The program begins by defining functions for these derivatives and
-their Jacobian,
+The program begins by defining functions for these derivatives and their
+Jacobian,
 
      #include <stdio.h>
      #include <gsl/gsl_errno.h>
@@ -3107,8 +3038,8 @@ values Y.
 To obtain the values at regular intervals, rather than the variable
 spacings chosen by the control function, the main loop can be modified
 to advance the solution from one point to the next.  For example, the
-following main loop prints the solution at the fixed points t = 0, 1,
-2, \dots, 100,
+following main loop prints the solution at the fixed points t = 0, 1, 2,
+\dots, 100,
 
        for (i = 1; i <= 100; i++)
          {
@@ -3126,7 +3057,7 @@ following main loop prints the solution at the fixed points t = 0, 1,
          }
 
 It is also possible to work with a non-adaptive integrator, using only
-the stepping function itself.  The following program uses the `rk4'
+the stepping function itself.  The following program uses the 'rk4'
 fourth-order Runge-Kutta stepping function with a fixed stepsize of
 0.01,
 
@@ -3187,10 +3118,10 @@ File: gsl-ref.info,  Node: ODE References and Further Reading,  Prev: ODE Exampl
 Many of the basic Runge-Kutta formulas can be found in the Handbook of
 Mathematical Functions,
 
-     Abramowitz & Stegun (eds.), `Handbook of Mathematical Functions',
+     Abramowitz & Stegun (eds.), 'Handbook of Mathematical Functions',
      Section 25.5.
 
-The implicit Bulirsch-Stoer algorithm `bsimp' is described in the
+The implicit Bulirsch-Stoer algorithm 'bsimp' is described in the
 following paper,
 
      G. Bader and P. Deuflhard, "A Semi-Implicit Mid-Point Rule for
@@ -3212,18 +3143,18 @@ conditions.  Additional functions are available for computing
 derivatives and integrals of interpolating functions.
 
    The functions described in this section are declared in the header
-files `gsl_interp.h' and `gsl_spline.h'.
+files 'gsl_interp.h' and 'gsl_spline.h'.
 
 * Menu:
 
-* Introduction to Interpolation::
-* Interpolation Functions::
-* Interpolation Types::
-* Index Look-up and Acceleration::
-* Evaluation of Interpolating Functions::
-* Higher-level Interface::
-* Interpolation Example programs::
-* Interpolation References and Further Reading::
+* Introduction to Interpolation::  
+* Interpolation Functions::     
+* Interpolation Types::         
+* Index Look-up and Acceleration::  
+* Evaluation of Interpolating Functions::  
+* Higher-level Interface::      
+* Interpolation Example programs::  
+* Interpolation References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Introduction to Interpolation,  Next: Interpolation Functions,  Up: Interpolation
@@ -3233,8 +3164,8 @@ File: gsl-ref.info,  Node: Introduction to Interpolation,  Next: Interpolation F
 
 Given a set of data points (x_1, y_1) \dots (x_n, y_n) the routines
 described in this section compute a continuous interpolating function
-y(x) such that y(x_i) = y_i.  The interpolation is piecewise smooth,
-and its behavior at the end-points is determined by the type of
+y(x) such that y(x_i) = y_i.  The interpolation is piecewise smooth, and
+its behavior at the end-points is determined by the type of
 interpolation used.
 
 
@@ -3244,7 +3175,7 @@ File: gsl-ref.info,  Node: Interpolation Functions,  Next: Interpolation Types,
 ============================
 
 The interpolation function for a given dataset is stored in a
-`gsl_interp' object.  These are created by the following functions.
+'gsl_interp' object.  These are created by the following functions.
 
  -- Function: gsl_interp * gsl_interp_alloc (const gsl_interp_type * T,
           size_t SIZE)
@@ -3255,7 +3186,7 @@ The interpolation function for a given dataset is stored in a
           XA[], const double YA[], size_t SIZE)
      This function initializes the interpolation object INTERP for the
      data (XA,YA) where XA and YA are arrays of size SIZE.  The
-     interpolation object (`gsl_interp') does not save the data arrays
+     interpolation object ('gsl_interp') does not save the data arrays
      XA and YA and only stores the static state computed from the data.
      The XA data array is always assumed to be strictly ordered; the
      behavior for other arrangements is not defined.
@@ -3283,21 +3214,20 @@ The interpolation library provides five interpolation types:
      equal to the number of points.
 
  -- Interpolation Type: gsl_interp_cspline
-     Cubic spline with natural boundary conditions.  The resulting
-     curve is piecewise cubic on each interval, with matching first and
-     second derivatives at the supplied data-points.  The second
-     derivative is chosen to be zero at the first point and last point.
+     Cubic spline with natural boundary conditions.  The resulting curve
+     is piecewise cubic on each interval, with matching first and second
+     derivatives at the supplied data-points.  The second derivative is
+     chosen to be zero at the first point and last point.
 
  -- Interpolation Type: gsl_interp_cspline_periodic
      Cubic spline with periodic boundary conditions.  The resulting
      curve is piecewise cubic on each interval, with matching first and
-     second derivatives at the supplied data-points.  The derivatives
-     at the first and last points are also matched.  Note that the last
+     second derivatives at the supplied data-points.  The derivatives at
+     the first and last points are also matched.  Note that the last
      point in the data must have the same y-value as the first point,
      otherwise the resulting periodic interpolation will have a
      discontinuity at the boundary.
 
-
  -- Interpolation Type: gsl_interp_akima
      Non-rounded Akima spline with natural boundary conditions.  This
      method uses the non-rounded corner algorithm of Wodicka.
@@ -3331,7 +3261,7 @@ File: gsl-ref.info,  Node: Index Look-up and Acceleration,  Next: Evaluation of
 26.4 Index Look-up and Acceleration
 ===================================
 
-The state of searches can be stored in a `gsl_interp_accel' object,
+The state of searches can be stored in a 'gsl_interp_accel' object,
 which is a kind of iterator for interpolation lookups.  It caches the
 previous value of an index lookup.  When the subsequent interpolation
 point falls in the same interval its index value can be returned
@@ -3340,8 +3270,8 @@ immediately.
  -- Function: size_t gsl_interp_bsearch (const double X_ARRAY[], double
           X, size_t INDEX_LO, size_t INDEX_HI)
      This function returns the index i of the array X_ARRAY such that
-     `x_array[i] <= x < x_array[i+1]'.  The index is searched for in
-     the range [INDEX_LO,INDEX_HI].
+     'x_array[i] <= x < x_array[i+1]'.  The index is searched for in the
+     range [INDEX_LO,INDEX_HI].
 
  -- Function: gsl_interp_accel * gsl_interp_accel_alloc (void)
      This function returns a pointer to an accelerator object, which is
@@ -3351,10 +3281,10 @@ immediately.
 
  -- Function: size_t gsl_interp_accel_find (gsl_interp_accel * A, const
           double X_ARRAY[], size_t SIZE, double X)
-     This function performs a lookup action on the data array X_ARRAY
-     of size SIZE, using the given accelerator A.  This is how lookups
-     are performed during evaluation of an interpolation.  The function
-     returns an index i such that `x_array[i] <= x < x_array[i+1]'.
+     This function performs a lookup action on the data array X_ARRAY of
+     size SIZE, using the given accelerator A.  This is how lookups are
+     performed during evaluation of an interpolation.  The function
+     returns an index i such that 'x_array[i] <= x < x_array[i+1]'.
 
  -- Function: void gsl_interp_accel_free (gsl_interp_accel* ACC)
      This function frees the accelerator object ACC.
@@ -3381,9 +3311,9 @@ File: gsl-ref.info,  Node: Evaluation of Interpolating Functions,  Next: Higher-
  -- Function: int gsl_interp_eval_deriv_e (const gsl_interp * INTERP,
           const double XA[], const double YA[], double X,
           gsl_interp_accel * ACC, double * D)
-     These functions return the derivative D of an interpolated
-     function for a given point X, using the interpolation object
-     INTERP, data arrays XA and YA and the accelerator ACC.
+     These functions return the derivative D of an interpolated function
+     for a given point X, using the interpolation object INTERP, data
+     arrays XA and YA and the accelerator ACC.
 
  -- Function: double gsl_interp_eval_deriv2 (const gsl_interp * INTERP,
           const double XA[], const double YA[], double X,
@@ -3414,11 +3344,10 @@ File: gsl-ref.info,  Node: Higher-level Interface,  Next: Interpolation Example
 
 The functions described in the previous sections required the user to
 supply pointers to the x and y arrays on each call.  The following
-functions are equivalent to the corresponding `gsl_interp' functions
-but maintain a copy of this data in the `gsl_spline' object.  This
-removes the need to pass both XA and YA as arguments on each
-evaluation. These functions are defined in the header file
-`gsl_spline.h'.
+functions are equivalent to the corresponding 'gsl_interp' functions but
+maintain a copy of this data in the 'gsl_spline' object.  This removes
+the need to pass both XA and YA as arguments on each evaluation.  These
+functions are defined in the header file 'gsl_spline.h'.
 
  -- Function: gsl_spline * gsl_spline_alloc (const gsl_interp_type * T,
           size_t SIZE)
@@ -3506,7 +3435,7 @@ spline functions.  It computes a cubic spline interpolation of the
        return 0;
      }
 
-The output is designed to be used with the GNU plotutils `graph'
+The output is designed to be used with the GNU plotutils 'graph'
 program,
 
      $ ./a.out > interp.dat
@@ -3514,7 +3443,7 @@ program,
 
 The result shows a smooth interpolation of the original points.  The
 interpolation method can changed simply by varying the first argument of
-`gsl_spline_alloc'.
+'gsl_spline_alloc'.
 
    The next program demonstrates a periodic cubic spline with 4 data
 points.  Note that the first and last points must be supplied with the
@@ -3561,12 +3490,12 @@ same y-value for a periodic spline.
        return 0;
      }
 
-The output can be plotted with GNU `graph'.
+   The output can be plotted with GNU 'graph'.
 
      $ ./a.out > interp.dat
      $ graph -T ps < interp.dat > interp.ps
 
-The result shows a periodic interpolation of the original points. The
+The result shows a periodic interpolation of the original points.  The
 slope of the fitted curve is the same at the beginning and end of the
 data, and the second derivative is also.
 
@@ -3579,12 +3508,11 @@ File: gsl-ref.info,  Node: Interpolation References and Further Reading,  Prev:
 Descriptions of the interpolation algorithms and further references can
 be found in the following books:
 
-     C.W. Ueberhuber, `Numerical Computation (Volume 1), Chapter 9
+     C.W. Ueberhuber, 'Numerical Computation (Volume 1), Chapter 9
      "Interpolation"', Springer (1997), ISBN 3-540-62058-3.
 
-     D.M. Young, R.T. Gregory `A Survey of Numerical Mathematics
-     (Volume 1), Chapter 6.8', Dover (1988), ISBN 0-486-65691-8.
-
+     D.M. Young, R.T. Gregory 'A Survey of Numerical Mathematics (Volume
+     1), Chapter 6.8', Dover (1988), ISBN 0-486-65691-8.
 
 
 File: gsl-ref.info,  Node: Numerical Differentiation,  Next: Chebyshev Approximations,  Prev: Interpolation,  Up: Top
@@ -3595,13 +3523,13 @@ File: gsl-ref.info,  Node: Numerical Differentiation,  Next: Chebyshev Approxima
 The functions described in this chapter compute numerical derivatives by
 finite differencing.  An adaptive algorithm is used to find the best
 choice of finite difference and to estimate the error in the derivative.
-These functions are declared in the header file `gsl_deriv.h'.
+These functions are declared in the header file 'gsl_deriv.h'.
 
 * Menu:
 
-* Numerical Differentiation functions::
-* Numerical Differentiation Examples::
-* Numerical Differentiation References::
+* Numerical Differentiation functions::  
+* Numerical Differentiation Examples::  
+* Numerical Differentiation References::  
 
 
 File: gsl-ref.info,  Node: Numerical Differentiation functions,  Next: Numerical Differentiation Examples,  Up: Numerical Differentiation
@@ -3613,12 +3541,12 @@ File: gsl-ref.info,  Node: Numerical Differentiation functions,  Next: Numerical
           double H, double * RESULT, double * ABSERR)
      This function computes the numerical derivative of the function F
      at the point X using an adaptive central difference algorithm with
-     a step-size of H.   The derivative is returned in RESULT and an
+     a step-size of H.  The derivative is returned in RESULT and an
      estimate of its absolute error is returned in ABSERR.
 
      The initial value of H is used to estimate an optimal step-size,
-     based on the scaling of the truncation error and round-off error
-     in the derivative calculation.  The derivative is computed using a
+     based on the scaling of the truncation error and round-off error in
+     the derivative calculation.  The derivative is computed using a
      5-point rule for equally spaced abscissae at x-h, x-h/2, x, x+h/2,
      x+h, with an error estimate taken from the difference between the
      5-point rule and the corresponding 3-point rule x-h, x, x+h.  Note
@@ -3629,16 +3557,16 @@ File: gsl-ref.info,  Node: Numerical Differentiation functions,  Next: Numerical
           double H, double * RESULT, double * ABSERR)
      This function computes the numerical derivative of the function F
      at the point X using an adaptive forward difference algorithm with
-     a step-size of H. The function is evaluated only at points greater
+     a step-size of H.  The function is evaluated only at points greater
      than X, and never at X itself.  The derivative is returned in
-     RESULT and an estimate of its absolute error is returned in
-     ABSERR.  This function should be used if f(x) has a discontinuity
-     at X, or is undefined for values less than X.
+     RESULT and an estimate of its absolute error is returned in ABSERR.
+     This function should be used if f(x) has a discontinuity at X, or
+     is undefined for values less than X.
 
      The initial value of H is used to estimate an optimal step-size,
-     based on the scaling of the truncation error and round-off error
-     in the derivative calculation.  The derivative at x is computed
-     using an "open" 4-point rule for equally spaced abscissae at x+h/4,
+     based on the scaling of the truncation error and round-off error in
+     the derivative calculation.  The derivative at x is computed using
+     an "open" 4-point rule for equally spaced abscissae at x+h/4,
      x+h/2, x+3h/4, x+h, with an error estimate taken from the
      difference between the 4-point rule and the corresponding 2-point
      rule x+h/2, x+h.
@@ -3646,14 +3574,14 @@ File: gsl-ref.info,  Node: Numerical Differentiation functions,  Next: Numerical
  -- Function: int gsl_deriv_backward (const gsl_function * F, double X,
           double H, double * RESULT, double * ABSERR)
      This function computes the numerical derivative of the function F
-     at the point X using an adaptive backward difference algorithm
-     with a step-size of H. The function is evaluated only at points
-     less than X, and never at X itself.  The derivative is returned in
-     RESULT and an estimate of its absolute error is returned in
-     ABSERR.  This function should be used if f(x) has a discontinuity
-     at X, or is undefined for values greater than X.
-
-     This function is equivalent to calling `gsl_deriv_forward' with a
+     at the point X using an adaptive backward difference algorithm with
+     a step-size of H.  The function is evaluated only at points less
+     than X, and never at X itself.  The derivative is returned in
+     RESULT and an estimate of its absolute error is returned in ABSERR.
+     This function should be used if f(x) has a discontinuity at X, or
+     is undefined for values greater than X.
+
+     This function is equivalent to calling 'gsl_deriv_forward' with a
      negative step-size.
 
 
@@ -3664,7 +3592,7 @@ File: gsl-ref.info,  Node: Numerical Differentiation Examples,  Next: Numerical
 
 The following code estimates the derivative of the function f(x) =
 x^{3/2} at x=2 and at x=0.  The function f(x) is undefined for x<0 so
-the derivative at x=0 is computed using `gsl_deriv_forward'.
+the derivative at x=0 is computed using 'gsl_deriv_forward'.
 
      #include <stdio.h>
      #include <gsl/gsl_math.h>
@@ -3720,10 +3648,10 @@ File: gsl-ref.info,  Node: Numerical Differentiation References,  Prev: Numerica
 The algorithms used by these functions are described in the following
 sources:
 
-     Abramowitz and Stegun, `Handbook of Mathematical Functions',
+     Abramowitz and Stegun, 'Handbook of Mathematical Functions',
      Section 25.3.4, and Table 25.5 (Coefficients for Differentiation).
 
-     S.D. Conte and Carl de Boor, `Elementary Numerical Analysis: An
+     S.D. Conte and Carl de Boor, 'Elementary Numerical Analysis: An
      Algorithmic Approach', McGraw-Hill, 1972.
 
 
@@ -3735,22 +3663,22 @@ File: gsl-ref.info,  Node: Chebyshev Approximations,  Next: Series Acceleration,
 This chapter describes routines for computing Chebyshev approximations
 to univariate functions.  A Chebyshev approximation is a truncation of
 the series f(x) = \sum c_n T_n(x), where the Chebyshev polynomials
-T_n(x) = \cos(n \arccos x) provide an orthogonal basis of polynomials
-on the interval [-1,1] with the weight function 1 / \sqrt{1-x^2}.  The
+T_n(x) = \cos(n \arccos x) provide an orthogonal basis of polynomials on
+the interval [-1,1] with the weight function 1 / \sqrt{1-x^2}.  The
 first few Chebyshev polynomials are, T_0(x) = 1, T_1(x) = x, T_2(x) = 2
 x^2 - 1.  For further information see Abramowitz & Stegun, Chapter 22.
 
    The functions described in this chapter are declared in the header
-file `gsl_chebyshev.h'.
+file 'gsl_chebyshev.h'.
 
 * Menu:
 
-* Chebyshev Definitions::
-* Creation and Calculation of Chebyshev Series::
-* Chebyshev Series Evaluation::
-* Derivatives and Integrals::
-* Chebyshev Approximation examples::
-* Chebyshev Approximation References and Further Reading::
+* Chebyshev Definitions::       
+* Creation and Calculation of Chebyshev Series::  
+* Chebyshev Series Evaluation::  
+* Derivatives and Integrals::   
+* Chebyshev Approximation examples::  
+* Chebyshev Approximation References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Chebyshev Definitions,  Next: Creation and Calculation of Chebyshev Series,  Up: Chebyshev Approximations
@@ -3758,7 +3686,7 @@ File: gsl-ref.info,  Node: Chebyshev Definitions,  Next: Creation and Calculatio
 28.1 Definitions
 ================
 
-A Chebyshev series  is stored using the following structure,
+A Chebyshev series is stored using the following structure,
 
      typedef struct
      {
@@ -3784,8 +3712,8 @@ File: gsl-ref.info,  Node: Creation and Calculation of Chebyshev Series,  Next:
 =================================================
 
  -- Function: gsl_cheb_series * gsl_cheb_alloc (const size_t N)
-     This function allocates space for a Chebyshev series of order N
-     and returns a pointer to a new `gsl_cheb_series' struct.
+     This function allocates space for a Chebyshev series of order N and
+     returns a pointer to a new 'gsl_cheb_series' struct.
 
  -- Function: void gsl_cheb_free (gsl_cheb_series * CS)
      This function frees a previously allocated Chebyshev series CS.
@@ -3814,18 +3742,18 @@ File: gsl-ref.info,  Node: Chebyshev Series Evaluation,  Next: Derivatives and I
      The error estimate is made from the first neglected term in the
      series.
 
- -- Function: double gsl_cheb_eval_n (const gsl_cheb_series * CS,
-          size_t ORDER, double X)
-     This function evaluates the Chebyshev series CS at a given point
-     N, to (at most) the given order ORDER.
+ -- Function: double gsl_cheb_eval_n (const gsl_cheb_series * CS, size_t
+          ORDER, double X)
+     This function evaluates the Chebyshev series CS at a given point N,
+     to (at most) the given order ORDER.
 
- -- Function: int gsl_cheb_eval_n_err (const gsl_cheb_series * CS,
-          const size_t ORDER, const double X, double * RESULT, double *
+ -- Function: int gsl_cheb_eval_n_err (const gsl_cheb_series * CS, const
+          size_t ORDER, const double X, double * RESULT, double *
           ABSERR)
      This function evaluates a Chebyshev series CS at a given point X,
-     estimating both the series RESULT and its absolute error ABSERR,
-     to (at most) the given order ORDER.  The error estimate is made
-     from the first neglected term in the series.
+     estimating both the series RESULT and its absolute error ABSERR, to
+     (at most) the given order ORDER.  The error estimate is made from
+     the first neglected term in the series.
 
 
 File: gsl-ref.info,  Node: Derivatives and Integrals,  Next: Chebyshev Approximation examples,  Prev: Chebyshev Series Evaluation,  Up: Chebyshev Approximations
@@ -3841,18 +3769,17 @@ neglected.
 
  -- Function: int gsl_cheb_calc_deriv (gsl_cheb_series * DERIV, const
           gsl_cheb_series * CS)
-     This function computes the derivative of the series CS, storing
-     the derivative coefficients in the previously allocated DERIV.
-     The two series CS and DERIV must have been allocated with the same
-     order.
+     This function computes the derivative of the series CS, storing the
+     derivative coefficients in the previously allocated DERIV.  The two
+     series CS and DERIV must have been allocated with the same order.
 
  -- Function: int gsl_cheb_calc_integ (gsl_cheb_series * INTEG, const
           gsl_cheb_series * CS)
      This function computes the integral of the series CS, storing the
      integral coefficients in the previously allocated INTEG.  The two
      series CS and INTEG must have been allocated with the same order.
-     The lower limit of the integration is taken to be the left hand
-     end of the range A.
+     The lower limit of the integration is taken to be the left hand end
+     of the range A.
 
 
 File: gsl-ref.info,  Node: Chebyshev Approximation examples,  Next: Chebyshev Approximation References and Further Reading,  Prev: Derivatives and Integrals,  Up: Chebyshev Approximations
@@ -3921,7 +3848,7 @@ File: gsl-ref.info,  Node: Chebyshev Approximation References and Further Readin
 The following paper describes the use of Chebyshev series,
 
      R. Broucke, "Ten Subroutines for the Manipulation of Chebyshev
-     Series [C1] (Algorithm 446)". `Communications of the ACM' 16(4),
+     Series [C1] (Algorithm 446)".  'Communications of the ACM' 16(4),
      254-256 (1973)
 
 
@@ -3937,14 +3864,14 @@ compute an extrapolated value and an estimate of its error.  The
 u-transform works for both convergent and divergent series, including
 asymptotic series.
 
-   These functions are declared in the header file `gsl_sum.h'.
+   These functions are declared in the header file 'gsl_sum.h'.
 
 * Menu:
 
-* Acceleration functions::
-* Acceleration functions without error estimation::
-* Example of accelerating a series::
-* Series Acceleration References::
+* Acceleration functions::      
+* Acceleration functions without error estimation::  
+* Example of accelerating a series::  
+* Series Acceleration References::  
 
 
 File: gsl-ref.info,  Node: Acceleration functions,  Next: Acceleration functions without error estimation,  Up: Series Acceleration
@@ -3958,8 +3885,8 @@ rounding errors from each term through to the final extrapolation.
 
    These functions are intended for summing analytic series where each
 term is known to high accuracy, and the rounding errors are assumed to
-originate from finite precision. They are taken to be relative errors of
-order `GSL_DBL_EPSILON' for each term.
+originate from finite precision.  They are taken to be relative errors
+of order 'GSL_DBL_EPSILON' for each term.
 
    The calculation of the error in the extrapolated value is an O(N^2)
 process, which is expensive in time and memory.  A faster but less
@@ -3978,14 +3905,14 @@ reliable error estimate.
      This function frees the memory associated with the workspace W.
 
  -- Function: int gsl_sum_levin_u_accel (const double * ARRAY, size_t
-          ARRAY_SIZE, gsl_sum_levin_u_workspace * W, double *
-          SUM_ACCEL, double * ABSERR)
+          ARRAY_SIZE, gsl_sum_levin_u_workspace * W, double * SUM_ACCEL,
+          double * ABSERR)
      This function takes the terms of a series in ARRAY of size
      ARRAY_SIZE and computes the extrapolated limit of the series using
      a Levin u-transform.  Additional working space must be provided in
      W.  The extrapolated sum is stored in SUM_ACCEL, with an estimate
      of the absolute error stored in ABSERR.  The actual term-by-term
-     sum is returned in `w->sum_plain'. The algorithm calculates the
+     sum is returned in 'w->sum_plain'.  The algorithm calculates the
      truncation error (the difference between two successive
      extrapolations) and round-off error (propagated from the individual
      terms) to choose an optimal number of terms for the extrapolation.
@@ -4003,19 +3930,19 @@ series and attempt to estimate the error from the "truncation error" in
 the extrapolation, the difference between the final two approximations.
 Using this method avoids the need to compute an intermediate table of
 derivatives because the error is estimated from the behavior of the
-extrapolated value itself. Consequently this algorithm is an O(N)
+extrapolated value itself.  Consequently this algorithm is an O(N)
 process and only requires O(N) terms of storage.  If the series
 converges sufficiently fast then this procedure can be acceptable.  It
 is appropriate to use this method when there is a need to compute many
 extrapolations of series with similar convergence properties at
 high-speed.  For example, when numerically integrating a function
 defined by a parameterized series where the parameter varies only
-slightly. A reliable error estimate should be computed first using the
+slightly.  A reliable error estimate should be computed first using the
 full algorithm described above in order to verify the consistency of the
 results.
 
  -- Function: gsl_sum_levin_utrunc_workspace *
-gsl_sum_levin_utrunc_alloc (size_t N)
+          gsl_sum_levin_utrunc_alloc (size_t N)
      This function allocates a workspace for a Levin u-transform of N
      terms, without error estimation.  The size of the workspace is
      O(3n).
@@ -4031,12 +3958,12 @@ gsl_sum_levin_utrunc_alloc (size_t N)
      ARRAY_SIZE and computes the extrapolated limit of the series using
      a Levin u-transform.  Additional working space must be provided in
      W.  The extrapolated sum is stored in SUM_ACCEL.  The actual
-     term-by-term sum is returned in `w->sum_plain'. The algorithm
+     term-by-term sum is returned in 'w->sum_plain'.  The algorithm
      terminates when the difference between two successive
-     extrapolations reaches a minimum or is sufficiently small. The
+     extrapolations reaches a minimum or is sufficiently small.  The
      difference between these two values is used as estimate of the
-     error and is stored in ABSERR_TRUNC.  To improve the reliability
-     of the algorithm the extrapolated values are replaced by moving
+     error and is stored in ABSERR_TRUNC.  To improve the reliability of
+     the algorithm the extrapolated values are replaced by moving
      averages when calculating the truncation error, smoothing out any
      fluctuations.
 
@@ -4051,8 +3978,8 @@ the series,
 
      \zeta(2) = 1 + 1/2^2 + 1/3^2 + 1/4^2 + ...
 
-After N terms the error in the sum is O(1/N), making direct summation
-of the series converge slowly.
+After N terms the error in the sum is O(1/N), making direct summation of
+the series converge slowly.
 
      #include <stdio.h>
      #include <gsl/gsl_math.h>
@@ -4115,8 +4042,8 @@ accurate, giving the correct number of significant digits.
      estimated error  =  0.0000000000508580
      actual error     = -0.0000000000315785
 
-Note that a direct summation of this series would require 10^10 terms
-to achieve the same precision as the accelerated sum does in 13 terms.
+Note that a direct summation of this series would require 10^10 terms to
+achieve the same precision as the accelerated sum does in 13 terms.
 
 
 File: gsl-ref.info,  Node: Series Acceleration References,  Prev: Example of accelerating a series,  Up: Series Acceleration
@@ -4127,20 +4054,20 @@ File: gsl-ref.info,  Node: Series Acceleration References,  Prev: Example of acc
 The algorithms used by these functions are described in the following
 papers,
 
-     T. Fessler, W.F. Ford, D.A. Smith, HURRY: An acceleration
-     algorithm for scalar sequences and series `ACM Transactions on
-     Mathematical Software', 9(3):346-354, 1983.  and Algorithm 602
-     9(3):355-357, 1983.
+     T. Fessler, W.F. Ford, D.A. Smith, HURRY: An acceleration algorithm
+     for scalar sequences and series 'ACM Transactions on Mathematical
+     Software', 9(3):346-354, 1983.  and Algorithm 602 9(3):355-357,
+     1983.
 
 The theory of the u-transform was presented by Levin,
 
      D. Levin, Development of Non-Linear Transformations for Improving
-     Convergence of Sequences, `Intern. J. Computer Math.' B3:371-388,
+     Convergence of Sequences, 'Intern. J. Computer Math.' B3:371-388,
      1973.
 
 A review paper on the Levin Transform is available online,
      Herbert H. H. Homeier, Scalar Levin-Type Sequence Transformations,
-     `http://arxiv.org/abs/math/0005209'.
+     <http://arxiv.org/abs/math/0005209>.
 
 
 File: gsl-ref.info,  Node: Wavelet Transforms,  Next: Discrete Hankel Transforms,  Prev: Series Acceleration,  Up: Top
@@ -4151,15 +4078,15 @@ File: gsl-ref.info,  Node: Wavelet Transforms,  Next: Discrete Hankel Transforms
 This chapter describes functions for performing Discrete Wavelet
 Transforms (DWTs).  The library includes wavelets for real data in both
 one and two dimensions.  The wavelet functions are declared in the
-header files `gsl_wavelet.h' and `gsl_wavelet2d.h'.
+header files 'gsl_wavelet.h' and 'gsl_wavelet2d.h'.
 
 * Menu:
 
-* DWT Definitions::
-* DWT Initialization::
-* DWT Transform Functions::
-* DWT Examples::
-* DWT References::
+* DWT Definitions::             
+* DWT Initialization::          
+* DWT Transform Functions::     
+* DWT Examples::                
+* DWT References::              
 
 
 File: gsl-ref.info,  Node: DWT Definitions,  Next: DWT Initialization,  Up: Wavelet Transforms
@@ -4195,15 +4122,15 @@ File: gsl-ref.info,  Node: DWT Initialization,  Next: DWT Transform Functions,
 30.2 Initialization
 ===================
 
-The `gsl_wavelet' structure contains the filter coefficients defining
+The 'gsl_wavelet' structure contains the filter coefficients defining
 the wavelet and any associated offset parameters.
 
  -- Function: gsl_wavelet * gsl_wavelet_alloc (const gsl_wavelet_type *
           T, size_t K)
-     This function allocates and initializes a wavelet object of type
-     T.  The parameter K selects the specific member of the wavelet
-     family.  A null pointer is returned if insufficient memory is
-     available or if a unsupported member is selected.
+     This function allocates and initializes a wavelet object of type T.
+     The parameter K selects the specific member of the wavelet family.
+     A null pointer is returned if insufficient memory is available or
+     if a unsupported member is selected.
 
    The following wavelet types are implemented:
 
@@ -4236,15 +4163,15 @@ understand.
  -- Function: void gsl_wavelet_free (gsl_wavelet * W)
      This function frees the wavelet object W.
 
-   The `gsl_wavelet_workspace' structure contains scratch space of the
+   The 'gsl_wavelet_workspace' structure contains scratch space of the
 same size as the input data and is used to hold intermediate results
 during the transform.
 
  -- Function: gsl_wavelet_workspace * gsl_wavelet_workspace_alloc
           (size_t N)
      This function allocates a workspace for the discrete wavelet
-     transform.  To perform a one-dimensional transform on N elements,
-     a workspace of size N must be provided.  For two-dimensional
+     transform.  To perform a one-dimensional transform on N elements, a
+     workspace of size N must be provided.  For two-dimensional
      transforms of N-by-N matrices it is sufficient to allocate a
      workspace of size N, since the transform operates on individual
      rows and columns.
@@ -4267,8 +4194,8 @@ of the transform.
 
 * Menu:
 
-* DWT in one dimension::
-* DWT in two dimension::
+* DWT in one dimension::        
+* DWT in two dimension::        
 
 
 File: gsl-ref.info,  Node: DWT in one dimension,  Next: DWT in two dimension,  Up: DWT Transform Functions
@@ -4276,8 +4203,8 @@ File: gsl-ref.info,  Node: DWT in one dimension,  Next: DWT in two dimension,  U
 30.3.1 Wavelet transforms in one dimension
 ------------------------------------------
 
- -- Function: int gsl_wavelet_transform (const gsl_wavelet * W, double
-          * DATA, size_t STRIDE, size_t N, gsl_wavelet_direction DIR,
+ -- Function: int gsl_wavelet_transform (const gsl_wavelet * W, double *
+          DATA, size_t STRIDE, size_t N, gsl_wavelet_direction DIR,
           gsl_wavelet_workspace * WORK)
  -- Function: int gsl_wavelet_transform_forward (const gsl_wavelet * W,
           double * DATA, size_t STRIDE, size_t N, gsl_wavelet_workspace
@@ -4285,11 +4212,12 @@ File: gsl-ref.info,  Node: DWT in one dimension,  Next: DWT in two dimension,  U
  -- Function: int gsl_wavelet_transform_inverse (const gsl_wavelet * W,
           double * DATA, size_t STRIDE, size_t N, gsl_wavelet_workspace
           * WORK)
+
      These functions compute in-place forward and inverse discrete
      wavelet transforms of length N with stride STRIDE on the array
-     DATA. The length of the transform N is restricted to powers of
-     two.  For the `transform' version of the function the argument DIR
-     can be either `forward' (+1) or `backward' (-1).  A workspace WORK
+     DATA.  The length of the transform N is restricted to powers of
+     two.  For the 'transform' version of the function the argument DIR
+     can be either 'forward' (+1) or 'backward' (-1).  A workspace WORK
      of length N must be provided.
 
      For the forward transform, the elements of the original array are
@@ -4307,8 +4235,8 @@ File: gsl-ref.info,  Node: DWT in one dimension,  Next: DWT in two dimension,  U
      backward transform inverts these coefficients to obtain the
      original data.
 
-     These functions return a status of `GSL_SUCCESS' upon successful
-     completion.  `GSL_EINVAL' is returned if N is not an integer power
+     These functions return a status of 'GSL_SUCCESS' upon successful
+     completion.  'GSL_EINVAL' is returned if N is not an integer power
      of 2 or if insufficient workspace is provided.
 
 
@@ -4338,10 +4266,10 @@ the full discrete wavelet transform is complete.  The non-standard form
 of the discrete wavelet transform is typically used in image analysis.
 
    The functions described in this section are declared in the header
-file `gsl_wavelet2d.h'.
+file 'gsl_wavelet2d.h'.
 
- -- Function: int gsl_wavelet2d_transform (const gsl_wavelet * W,
-          double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
+ -- Function: int gsl_wavelet2d_transform (const gsl_wavelet * W, double
+          * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
           gsl_wavelet_direction DIR, gsl_wavelet_workspace * WORK)
  -- Function: int gsl_wavelet2d_transform_forward (const gsl_wavelet *
           W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
@@ -4349,24 +4277,25 @@ file `gsl_wavelet2d.h'.
  -- Function: int gsl_wavelet2d_transform_inverse (const gsl_wavelet *
           W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
           gsl_wavelet_workspace * WORK)
+
      These functions compute two-dimensional in-place forward and
      inverse discrete wavelet transforms in standard and non-standard
      forms on the array DATA stored in row-major form with dimensions
      SIZE1 and SIZE2 and physical row length TDA.  The dimensions must
      be equal (square matrix) and are restricted to powers of two.  For
-     the `transform' version of the function the argument DIR can be
-     either `forward' (+1) or `backward' (-1).  A workspace WORK of the
+     the 'transform' version of the function the argument DIR can be
+     either 'forward' (+1) or 'backward' (-1).  A workspace WORK of the
      appropriate size must be provided.  On exit, the appropriate
      elements of the array DATA are replaced by their two-dimensional
      wavelet transform.
 
-     The functions return a status of `GSL_SUCCESS' upon successful
-     completion.  `GSL_EINVAL' is returned if SIZE1 and SIZE2 are not
+     The functions return a status of 'GSL_SUCCESS' upon successful
+     completion.  'GSL_EINVAL' is returned if SIZE1 and SIZE2 are not
      equal and integer powers of 2, or if insufficient workspace is
      provided.
 
- -- Function: int gsl_wavelet2d_transform_matrix (const gsl_wavelet *
-          W, gsl_matrix * M, gsl_wavelet_direction DIR,
+ -- Function: int gsl_wavelet2d_transform_matrix (const gsl_wavelet * W,
+          gsl_matrix * M, gsl_wavelet_direction DIR,
           gsl_wavelet_workspace * WORK)
  -- Function: int gsl_wavelet2d_transform_matrix_forward (const
           gsl_wavelet * W, gsl_matrix * M, gsl_wavelet_workspace * WORK)
@@ -4378,11 +4307,11 @@ file `gsl_wavelet2d.h'.
  -- Function: int gsl_wavelet2d_nstransform (const gsl_wavelet * W,
           double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
           gsl_wavelet_direction DIR, gsl_wavelet_workspace * WORK)
- -- Function: int gsl_wavelet2d_nstransform_forward (const gsl_wavelet
-          * W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
+ -- Function: int gsl_wavelet2d_nstransform_forward (const gsl_wavelet *
+          W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
           gsl_wavelet_workspace * WORK)
- -- Function: int gsl_wavelet2d_nstransform_inverse (const gsl_wavelet
-          * W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
+ -- Function: int gsl_wavelet2d_nstransform_inverse (const gsl_wavelet *
+          W, double * DATA, size_t TDA, size_t SIZE1, size_t SIZE2,
           gsl_wavelet_workspace * WORK)
      These functions compute the two-dimensional wavelet transform in
      non-standard form.
@@ -4463,7 +4392,7 @@ transform, while setting the others to zero.
        return 0;
      }
 
-The output can be used with the GNU plotutils `graph' program,
+The output can be used with the GNU plotutils 'graph' program,
 
      $ ./a.out ecg.dat > dwt.dat
      $ graph -T ps -x 0 256 32 -h 0.3 -a dwt.dat > dwt.ps
@@ -4477,50 +4406,50 @@ File: gsl-ref.info,  Node: DWT References,  Prev: DWT Examples,  Up: Wavelet Tra
 The mathematical background to wavelet transforms is covered in the
 original lectures by Daubechies,
 
-     Ingrid Daubechies.  Ten Lectures on Wavelets.  `CBMS-NSF Regional
+     Ingrid Daubechies.  Ten Lectures on Wavelets.  'CBMS-NSF Regional
      Conference Series in Applied Mathematics' (1992), SIAM, ISBN
      0898712742.
 
 An easy to read introduction to the subject with an emphasis on the
 application of the wavelet transform in various branches of science is,
 
-     Paul S. Addison. `The Illustrated Wavelet Transform Handbook'.
+     Paul S. Addison.  'The Illustrated Wavelet Transform Handbook'.
      Institute of Physics Publishing (2002), ISBN 0750306920.
 
 For extensive coverage of signal analysis by wavelets, wavelet packets
 and local cosine bases see,
 
-     S. G. Mallat.  `A wavelet tour of signal processing' (Second
-     edition). Academic Press (1999), ISBN 012466606X.
+     S. G. Mallat.  'A wavelet tour of signal processing' (Second
+     edition).  Academic Press (1999), ISBN 012466606X.
 
 The concept of multiresolution analysis underlying the wavelet transform
 is described in,
 
      S. G. Mallat.  Multiresolution Approximations and Wavelet
-     Orthonormal Bases of L^2(R).  `Transactions of the American
+     Orthonormal Bases of L^2(R). 'Transactions of the American
      Mathematical Society', 315(1), 1989, 69-87.
 
      S. G. Mallat.  A Theory for Multiresolution Signal
-     Decomposition--The Wavelet Representation.  `IEEE Transactions on
+     Decomposition--The Wavelet Representation.  'IEEE Transactions on
      Pattern Analysis and Machine Intelligence', 11, 1989, 674-693.
 
 The coefficients for the individual wavelet families implemented by the
 library can be found in the following papers,
 
      I. Daubechies.  Orthonormal Bases of Compactly Supported Wavelets.
-     `Communications on Pure and Applied Mathematics', 41 (1988)
+     'Communications on Pure and Applied Mathematics', 41 (1988)
      909-996.
 
-     A. Cohen, I. Daubechies, and J.-C. Feauveau.  Biorthogonal Bases
-     of Compactly Supported Wavelets.  `Communications on Pure and
-     Applied Mathematics', 45 (1992) 485-560.
+     A. Cohen, I. Daubechies, and J.-C. Feauveau.  Biorthogonal Bases of
+     Compactly Supported Wavelets.  'Communications on Pure and Applied
+     Mathematics', 45 (1992) 485-560.
 
 The PhysioNet archive of physiological datasets can be found online at
-`http://www.physionet.org/' and is described in the following paper,
+<http://www.physionet.org/> and is described in the following paper,
 
      Goldberger et al.  PhysioBank, PhysioToolkit, and PhysioNet:
      Components of a New Research Resource for Complex Physiologic
-     Signals.  `Circulation' 101(23):e215-e220 2000.
+     Signals.  'Circulation' 101(23):e215-e220 2000.
 
 
 File: gsl-ref.info,  Node: Discrete Hankel Transforms,  Next: One dimensional Root-Finding,  Prev: Wavelet Transforms,  Up: Top
@@ -4530,13 +4459,13 @@ File: gsl-ref.info,  Node: Discrete Hankel Transforms,  Next: One dimensional Ro
 
 This chapter describes functions for performing Discrete Hankel
 Transforms (DHTs).  The functions are declared in the header file
-`gsl_dht.h'.
+'gsl_dht.h'.
 
 * Menu:
 
-* Discrete Hankel Transform Definition::
-* Discrete Hankel Transform Functions::
-* Discrete Hankel Transform References::
+* Discrete Hankel Transform Definition::  
+* Discrete Hankel Transform Functions::  
+* Discrete Hankel Transform References::  
 
 
 File: gsl-ref.info,  Node: Discrete Hankel Transform Definition,  Next: Discrete Hankel Transform Functions,  Up: Discrete Hankel Transforms
@@ -4558,30 +4487,30 @@ g_m given by,
 so that,
      f(t) = \sum_{m=1}^\infty (2 J_\nu(j_(\nu,m)x) / J_(\nu+1)(j_(\nu,m))^2) g_m.
 
-Suppose that f is band-limited in the sense that g_m=0 for m > M. Then
+Suppose that f is band-limited in the sense that g_m=0 for m > M.  Then
 we have the following fundamental sampling theorem.
      g_m = (2 / j_(\nu,M)^2)
            \sum_{k=1}^{M-1} f(j_(\nu,k)/j_(\nu,M))
                (J_\nu(j_(\nu,m) j_(\nu,k) / j_(\nu,M)) / J_(\nu+1)(j_(\nu,k))^2).
 
 It is this discrete expression which defines the discrete Hankel
-transform. The kernel in the summation above defines the matrix of the
+transform.  The kernel in the summation above defines the matrix of the
 \nu-Hankel transform of size M-1.  The coefficients of this matrix,
 being dependent on \nu and M, must be precomputed and stored; the
-`gsl_dht' object encapsulates this data.  The allocation function
-`gsl_dht_alloc' returns a `gsl_dht' object which must be properly
-initialized with `gsl_dht_init' before it can be used to perform
+'gsl_dht' object encapsulates this data.  The allocation function
+'gsl_dht_alloc' returns a 'gsl_dht' object which must be properly
+initialized with 'gsl_dht_init' before it can be used to perform
 transforms on data sample vectors, for fixed \nu and M, using the
-`gsl_dht_apply' function. The implementation allows a scaling of the
+'gsl_dht_apply' function.  The implementation allows a scaling of the
 fundamental interval, for convenience, so that one can assume the
 function is defined on the interval [0,X], rather than the unit
 interval.
 
    Notice that by assumption f(t) vanishes at the endpoints of the
-interval, consistent with the inversion formula and the sampling
-formula given above. Therefore, this transform corresponds to an
-orthogonal expansion in eigenfunctions of the Dirichlet problem for the
-Bessel differential equation.
+interval, consistent with the inversion formula and the sampling formula
+given above.  Therefore, this transform corresponds to an orthogonal
+expansion in eigenfunctions of the Dirichlet problem for the Bessel
+differential equation.
 
 
 File: gsl-ref.info,  Node: Discrete Hankel Transform Functions,  Next: Discrete Hankel Transform References,  Prev: Discrete Hankel Transform Definition,  Up: Discrete Hankel Transforms
@@ -4608,12 +4537,12 @@ File: gsl-ref.info,  Node: Discrete Hankel Transform Functions,  Next: Discrete
  -- Function: int gsl_dht_apply (const gsl_dht * T, double * F_IN,
           double * F_OUT)
      This function applies the transform T to the array F_IN whose size
-     is equal to the size of the transform.  The result is stored in
-     the array F_OUT which must be of the same length.
+     is equal to the size of the transform.  The result is stored in the
+     array F_OUT which must be of the same length.
 
  -- Function: double gsl_dht_x_sample (const gsl_dht * T, int N)
      This function returns the value of the N-th sample point in the
-     unit interval, (j_{\nu,n+1}/j_{\nu,M}) X. These are the points
+     unit interval, (j_{\nu,n+1}/j_{\nu,M}) X.  These are the points
      where the function f(t) is assumed to be sampled.
 
  -- Function: double gsl_dht_k_sample (const gsl_dht * T, int N)
@@ -4649,22 +4578,22 @@ without needing to recompile your program.  Each instance of a solver
 keeps track of its own state, allowing the solvers to be used in
 multi-threaded programs.
 
-   The header file `gsl_roots.h' contains prototypes for the root
+   The header file 'gsl_roots.h' contains prototypes for the root
 finding functions and related declarations.
 
 * Menu:
 
-* Root Finding Overview::
-* Root Finding Caveats::
-* Initializing the Solver::
-* Providing the function to solve::
-* Search Bounds and Guesses::
-* Root Finding Iteration::
-* Search Stopping Parameters::
-* Root Bracketing Algorithms::
-* Root Finding Algorithms using Derivatives::
-* Root Finding Examples::
-* Root Finding References and Further Reading::
+* Root Finding Overview::       
+* Root Finding Caveats::        
+* Initializing the Solver::     
+* Providing the function to solve::  
+* Search Bounds and Guesses::   
+* Root Finding Iteration::      
+* Search Stopping Parameters::  
+* Root Bracketing Algorithms::  
+* Root Finding Algorithms using Derivatives::  
+* Root Finding Examples::       
+* Root Finding References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Root Finding Overview,  Next: Root Finding Caveats,  Up: One dimensional Root-Finding
@@ -4700,11 +4629,11 @@ steps.  There are three main phases of the iteration.  The steps are,
 
    * test S for convergence, and repeat iteration if necessary
 
-The state for bracketing solvers is held in a `gsl_root_fsolver'
-struct.  The updating procedure uses only function evaluations (not
-derivatives).  The state for root polishing solvers is held in a
-`gsl_root_fdfsolver' struct.  The updates require both the function and
-its derivative (hence the name `fdf') to be supplied by the user.
+The state for bracketing solvers is held in a 'gsl_root_fsolver' struct.
+The updating procedure uses only function evaluations (not derivatives).
+The state for root polishing solvers is held in a 'gsl_root_fdfsolver'
+struct.  The updates require both the function and its derivative (hence
+the name 'fdf') to be supplied by the user.
 
 
 File: gsl-ref.info,  Node: Root Finding Caveats,  Next: Initializing the Solver,  Prev: Root Finding Overview,  Up: One dimensional Root-Finding
@@ -4715,7 +4644,7 @@ File: gsl-ref.info,  Node: Root Finding Caveats,  Next: Initializing the Solver,
 Note that root finding functions can only search for one root at a time.
 When there are several roots in the search area, the first root to be
 found will be returned; however it is difficult to predict which of the
-roots this will be. _In most cases, no error will be reported if you
+roots this will be.  _In most cases, no error will be reported if you
 try to find a root in an area where there is more than one._
 
    Care must be taken when a function may have a multiple root (such as
@@ -4725,7 +4654,7 @@ algorithms the initial interval must contain a zero-crossing, where the
 function is negative at one end of the interval and positive at the
 other end.  Roots with even-multiplicity do not cross zero, but only
 touch it instantaneously.  Algorithms based on root bracketing will
-still work for odd-multiplicity roots (e.g. cubic, quintic, ...).  Root
+still work for odd-multiplicity roots (e.g.  cubic, quintic, ...).  Root
 polishing algorithms generally work with higher multiplicity roots, but
 at a reduced rate of convergence.  In these cases the "Steffenson
 algorithm" can be used to accelerate the convergence of multiple roots.
@@ -4734,10 +4663,9 @@ algorithm" can be used to accelerate the convergence of multiple roots.
 search region, numerical root finding functions should not be used
 haphazardly to check for the _existence_ of roots.  There are better
 ways to do this.  Because it is easy to create situations where
-numerical root finders can fail, it is a bad idea to throw a root
-finder at a function you do not know much about.  In general it is best
-to examine the function visually by plotting before searching for a
-root.
+numerical root finders can fail, it is a bad idea to throw a root finder
+at a function you do not know much about.  In general it is best to
+examine the function visually by plotting before searching for a root.
 
 
 File: gsl-ref.info,  Node: Initializing the Solver,  Next: Providing the function to solve,  Prev: Root Finding Caveats,  Up: One dimensional Root-Finding
@@ -4758,13 +4686,13 @@ File: gsl-ref.info,  Node: Initializing the Solver,  Next: Providing the functio
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: gsl_root_fdfsolver * gsl_root_fdfsolver_alloc (const
           gsl_root_fdfsolver_type * T)
      This function returns a pointer to a newly allocated instance of a
-     derivative-based solver of type T.  For example, the following
-     code creates an instance of a Newton-Raphson solver,
+     derivative-based solver of type T.  For example, the following code
+     creates an instance of a Newton-Raphson solver,
 
           const gsl_root_fdfsolver_type * T
             = gsl_root_fdfsolver_newton;
@@ -4773,7 +4701,7 @@ File: gsl-ref.info,  Node: Initializing the Solver,  Next: Providing the functio
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_root_fsolver_set (gsl_root_fsolver * S,
           gsl_function * F, double X_LOWER, double X_UPPER)
@@ -4790,8 +4718,8 @@ File: gsl-ref.info,  Node: Initializing the Solver,  Next: Providing the functio
  -- Function: void gsl_root_fdfsolver_free (gsl_root_fdfsolver * S)
      These functions free all the memory associated with the solver S.
 
- -- Function: const char * gsl_root_fsolver_name (const
-          gsl_root_fsolver * S)
+ -- Function: const char * gsl_root_fsolver_name (const gsl_root_fsolver
+          * S)
  -- Function: const char * gsl_root_fdfsolver_name (const
           gsl_root_fdfsolver * S)
      These functions return a pointer to the name of the solver.  For
@@ -4800,7 +4728,7 @@ File: gsl-ref.info,  Node: Initializing the Solver,  Next: Providing the functio
           printf ("s is a '%s' solver\n",
                   gsl_root_fsolver_name (s));
 
-     would print something like `s is a 'bisection' solver'.
+     would print something like 's is a 'bisection' solver'.
 
 
 File: gsl-ref.info,  Node: Providing the function to solve,  Next: Search Bounds and Guesses,  Prev: Initializing the Solver,  Up: One dimensional Root-Finding
@@ -4816,19 +4744,19 @@ following data types:
  -- Data Type: gsl_function
      This data type defines a general function with parameters.
 
-    `double (* function) (double X, void * PARAMS)'
-          this function should return the value f(x,params) for
-          argument X and parameters PARAMS
+     'double (* function) (double X, void * PARAMS)'
+          this function should return the value f(x,params) for argument
+          X and parameters PARAMS
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function
 
    Here is an example for the general quadratic function,
 
      f(x) = a x^2 + b x + c
 
-with a = 3, b = 2, c = 1.  The following code defines a `gsl_function'
-`F' which you could pass to a root finder:
+with a = 3, b = 2, c = 1.  The following code defines a 'gsl_function'
+'F' which you could pass to a root finder:
 
      struct my_f_params { double a; double b; double c; };
 
@@ -4858,24 +4786,24 @@ The function f(x) can be evaluated using the following macro,
      This data type defines a general function with parameters and its
      first derivative.
 
-    `double (* f) (double X, void * PARAMS)'
+     'double (* f) (double X, void * PARAMS)'
           this function should return the value of f(x,params) for
           argument X and parameters PARAMS
 
-    `double (* df) (double X, void * PARAMS)'
+     'double (* df) (double X, void * PARAMS)'
           this function should return the value of the derivative of F
-          with respect to X, f'(x,params), for argument X and
-          parameters PARAMS
+          with respect to X, f'(x,params), for argument X and parameters
+          PARAMS
 
-    `void (* fdf) (double X, void * PARAMS, double * F, double * Df)'
+     'void (* fdf) (double X, void * PARAMS, double * F, double * Df)'
           this function should set the values of the function F to
-          f(x,params) and its derivative DF to f'(x,params) for
-          argument X and parameters PARAMS.  This function provides an
+          f(x,params) and its derivative DF to f'(x,params) for argument
+          X and parameters PARAMS.  This function provides an
           optimization of the separate functions for f(x) and f'(x)--it
-          is always faster to compute the function and its derivative
-          at the same time.
+          is always faster to compute the function and its derivative at
+          the same time.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function
 
    Here is an example where f(x) = 2\exp(2x):
@@ -4926,7 +4854,7 @@ evaluated at the same time using the following macro,
           (*((FDF)->fdf))(x,(FDF)->params,(y),(dy))
 
 The macro stores f(x) in its Y argument and f'(x) in its DY
-argument--both of these should be pointers to `double'.
+argument--both of these should be pointers to 'double'.
 
 
 File: gsl-ref.info,  Node: Search Bounds and Guesses,  Next: Root Finding Iteration,  Prev: Providing the function to solve,  Up: One dimensional Root-Finding
@@ -4938,8 +4866,8 @@ You provide either search bounds or an initial guess; this section
 explains how search bounds and guesses work and how function arguments
 control them.
 
-   A guess is simply an x value which is iterated until it is within
-the desired precision of a root.  It takes the form of a `double'.
+   A guess is simply an x value which is iterated until it is within the
+desired precision of a root.  It takes the form of a 'double'.
 
    Search bounds are the endpoints of a interval which is iterated until
 the length of the interval is smaller than the requested precision.  The
@@ -4965,11 +4893,11 @@ the code.
      iteration encounters an unexpected problem then an error code will
      be returned,
 
-    `GSL_EBADFUNC'
+     'GSL_EBADFUNC'
           the iteration encountered a singular point where the function
-          or its derivative evaluated to `Inf' or `NaN'.
+          or its derivative evaluated to 'Inf' or 'NaN'.
 
-    `GSL_EZERODIV'
+     'GSL_EZERODIV'
           the derivative of the function vanished at the iteration
           point, preventing the algorithm from continuing without a
           division by zero.
@@ -4980,8 +4908,8 @@ interval bounding the root.  This information can be accessed with the
 following auxiliary functions,
 
  -- Function: double gsl_root_fsolver_root (const gsl_root_fsolver * S)
- -- Function: double gsl_root_fdfsolver_root (const gsl_root_fdfsolver
-          * S)
+ -- Function: double gsl_root_fdfsolver_root (const gsl_root_fdfsolver *
+          S)
      These functions return the current estimate of the root for the
      solver S.
 
@@ -5014,15 +4942,14 @@ several standard ways.
  -- Function: int gsl_root_test_interval (double X_LOWER, double
           X_UPPER, double EPSABS, double EPSREL)
      This function tests for the convergence of the interval [X_LOWER,
-     X_UPPER] with absolute error EPSABS and relative error EPSREL.
-     The test returns `GSL_SUCCESS' if the following condition is
-     achieved,
+     X_UPPER] with absolute error EPSABS and relative error EPSREL.  The
+     test returns 'GSL_SUCCESS' if the following condition is achieved,
 
           |a - b| < epsabs + epsrel min(|a|,|b|)
 
      when the interval x = [a,b] does not include the origin.  If the
-     interval includes the origin then \min(|a|,|b|) is replaced by
-     zero (which is the minimum value of |x| over the interval).  This
+     interval includes the origin then \min(|a|,|b|) is replaced by zero
+     (which is the minimum value of |x| over the interval).  This
      ensures that the relative error is accurately estimated for roots
      close to the origin.
 
@@ -5036,22 +4963,23 @@ several standard ways.
 
  -- Function: int gsl_root_test_delta (double X1, double X0, double
           EPSABS, double EPSREL)
-     This function tests for the convergence of the sequence ..., X0,
-     X1 with absolute error EPSABS and relative error EPSREL.  The test
-     returns `GSL_SUCCESS' if the following condition is achieved,
+
+     This function tests for the convergence of the sequence ..., X0, X1
+     with absolute error EPSABS and relative error EPSREL.  The test
+     returns 'GSL_SUCCESS' if the following condition is achieved,
 
           |x_1 - x_0| < epsabs + epsrel |x_1|
 
-     and returns `GSL_CONTINUE' otherwise.
+     and returns 'GSL_CONTINUE' otherwise.
 
  -- Function: int gsl_root_test_residual (double F, double EPSABS)
-     This function tests the residual value F against the absolute
-     error bound EPSABS.  The test returns `GSL_SUCCESS' if the
-     following condition is achieved,
+     This function tests the residual value F against the absolute error
+     bound EPSABS.  The test returns 'GSL_SUCCESS' if the following
+     condition is achieved,
 
           |f| < epsabs
 
-     and returns `GSL_CONTINUE' otherwise.  This criterion is suitable
+     and returns 'GSL_CONTINUE' otherwise.  This criterion is suitable
      for situations where the precise location of the root, x, is
      unimportant provided a value can be found where the residual,
      |f(x)|, is small enough.
@@ -5073,8 +5001,9 @@ cannot fail, provided the function is well-behaved.
 since these do not cross the x-axis.
 
  -- Solver: gsl_root_fsolver_bisection
+
      The "bisection algorithm" is the simplest method of bracketing the
-     roots of a function.   It is the slowest algorithm provided by the
+     roots of a function.  It is the slowest algorithm provided by the
      library, with linear convergence.
 
      On each iteration, the interval is bisected and the value of the
@@ -5087,15 +5016,15 @@ since these do not cross the x-axis.
      At any time the current estimate of the root is taken as the
      midpoint of the interval.
 
-
  -- Solver: gsl_root_fsolver_falsepos
+
      The "false position algorithm" is a method of finding roots based
      on linear interpolation.  Its convergence is linear, but it is
      usually faster than bisection.
 
      On each iteration a line is drawn between the endpoints (a,f(a))
-     and (b,f(b)) and the point where this line crosses the x-axis
-     taken as a "midpoint".  The value of the function at this point is
+     and (b,f(b)) and the point where this line crosses the x-axis taken
+     as a "midpoint".  The value of the function at this point is
      calculated and its sign is used to determine which side of the
      interval does not contain a root.  That side is discarded to give a
      new, smaller interval containing the root.  This procedure can be
@@ -5104,8 +5033,8 @@ since these do not cross the x-axis.
      The best estimate of the root is taken from the linear
      interpolation of the interval on the current iteration.
 
-
  -- Solver: gsl_root_fsolver_brent
+
      The "Brent-Dekker method" (referred to here as "Brent's method")
      combines an interpolation strategy with the bisection algorithm.
      This produces a fast algorithm which is still robust.
@@ -5114,12 +5043,12 @@ since these do not cross the x-axis.
      interpolating curve.  On the first iteration this is a linear
      interpolation of the two endpoints.  For subsequent iterations the
      algorithm uses an inverse quadratic fit to the last three points,
-     for higher accuracy.  The intercept of the interpolating curve
-     with the x-axis is taken as a guess for the root.  If it lies
-     within the bounds of the current interval then the interpolating
-     point is accepted, and used to generate a smaller interval.  If
-     the interpolating point is not accepted then the algorithm falls
-     back to an ordinary bisection step.
+     for higher accuracy.  The intercept of the interpolating curve with
+     the x-axis is taken as a guess for the root.  If it lies within the
+     bounds of the current interval then the interpolating point is
+     accepted, and used to generate a smaller interval.  If the
+     interpolating point is not accepted then the algorithm falls back
+     to an ordinary bisection step.
 
      The best estimate of the root is taken from the most recent
      interpolation or bisection.
@@ -5140,20 +5069,21 @@ quadratic.
    These algorithms make use of both the function and its derivative.
 
  -- Derivative Solver: gsl_root_fdfsolver_newton
+
      Newton's Method is the standard root-polishing algorithm.  The
      algorithm begins with an initial guess for the location of the
-     root.  On each iteration, a line tangent to the function f is
-     drawn at that position.  The point where this line crosses the
-     x-axis becomes the new guess.  The iteration is defined by the
-     following sequence,
+     root.  On each iteration, a line tangent to the function f is drawn
+     at that position.  The point where this line crosses the x-axis
+     becomes the new guess.  The iteration is defined by the following
+     sequence,
 
           x_{i+1} = x_i - f(x_i)/f'(x_i)
 
      Newton's method converges quadratically for single roots, and
      linearly for multiple roots.
 
-
  -- Derivative Solver: gsl_root_fdfsolver_secant
+
      The "secant method" is a simplified version of Newton's method
      which does not require the computation of the derivative on every
      step.
@@ -5175,16 +5105,16 @@ quadratic.
      Asymptotically the secant method is faster than Newton's method
      whenever the cost of evaluating the derivative is more than 0.44
      times the cost of evaluating the function itself.  As with all
-     methods of computing a numerical derivative the estimate can
-     suffer from cancellation errors if the separation of the points
-     becomes too small.
+     methods of computing a numerical derivative the estimate can suffer
+     from cancellation errors if the separation of the points becomes
+     too small.
 
      On single roots, the method has a convergence of order (1 + \sqrt
      5)/2 (approximately 1.62).  It converges linearly for multiple
      roots.
 
-
  -- Derivative Solver: gsl_root_fdfsolver_steffenson
+
      The "Steffenson Method" provides the fastest convergence of all the
      routines.  It combines the basic Newton algorithm with an Aitken
      "delta-squared" acceleration.  If the Newton iterates are x_i then
@@ -5194,14 +5124,14 @@ quadratic.
 
      which converges faster than the original sequence under reasonable
      conditions.  The new sequence requires three terms before it can
-     produce its first value so the method returns accelerated values
-     on the second and subsequent iterations.  On the first iteration
-     it returns the ordinary Newton estimate.  The Newton iterate is
-     also returned if the denominator of the acceleration term ever
-     becomes zero.
+     produce its first value so the method returns accelerated values on
+     the second and subsequent iterations.  On the first iteration it
+     returns the ordinary Newton estimate.  The Newton iterate is also
+     returned if the denominator of the acceleration term ever becomes
+     zero.
 
-     As with all acceleration procedures this method can become
-     unstable if the function is not well-behaved.
+     As with all acceleration procedures this method can become unstable
+     if the function is not well-behaved.
 
 
 File: gsl-ref.info,  Node: Root Finding Examples,  Next: Root Finding References and Further Reading,  Prev: Root Finding Algorithms using Derivatives,  Up: One dimensional Root-Finding
@@ -5211,7 +5141,7 @@ File: gsl-ref.info,  Node: Root Finding Examples,  Next: Root Finding References
 
 For any root finding algorithm we need to prepare the function to be
 solved.  For this example we will use the general quadratic equation
-described earlier.  We first need a header file (`demo_fn.h') to define
+described earlier.  We first need a header file ('demo_fn.h') to define
 the function parameters,
 
      struct quadratic_params
@@ -5224,7 +5154,7 @@ the function parameters,
      void quadratic_fdf (double x, void *params,
                          double *y, double *dy);
 
-We place the function definitions in a separate file (`demo_fn.c'),
+We place the function definitions in a separate file ('demo_fn.c'),
 
      double
      quadratic (double x, void *params)
@@ -5267,7 +5197,7 @@ We place the function definitions in a separate file (`demo_fn.c'),
        *dy = 2.0 * a * x + b;
      }
 
-The first program uses the function solver `gsl_root_fsolver_brent' for
+The first program uses the function solver 'gsl_root_fsolver_brent' for
 Brent's method and the general quadratic defined above to solve the
 following equation,
 
@@ -5348,8 +5278,8 @@ Here are the results of the iterations,
          6 [2.2360634, 2.2366300] 2.2360634 -0.0000046 0.0005666
 
 If the program is modified to use the bisection solver instead of
-Brent's method, by changing `gsl_root_fsolver_brent' to
-`gsl_root_fsolver_bisection' the slower convergence of the Bisection
+Brent's method, by changing 'gsl_root_fsolver_brent' to
+'gsl_root_fsolver_bisection' the slower convergence of the Bisection
 method can be observed,
 
      $ ./a.out
@@ -5439,8 +5369,8 @@ Here are the results for Newton's method,
 Note that the error can be estimated more accurately by taking the
 difference between the current iterate and next iterate rather than the
 previous iterate.  The other derivative solvers can be investigated by
-changing `gsl_root_fdfsolver_newton' to `gsl_root_fdfsolver_secant' or
-`gsl_root_fdfsolver_steffenson'.
+changing 'gsl_root_fdfsolver_newton' to 'gsl_root_fdfsolver_secant' or
+'gsl_root_fdfsolver_steffenson'.
 
 
 File: gsl-ref.info,  Node: Root Finding References and Further Reading,  Prev: Root Finding Examples,  Up: One dimensional Root-Finding
@@ -5452,10 +5382,10 @@ For information on the Brent-Dekker algorithm see the following two
 papers,
 
      R. P. Brent, "An algorithm with guaranteed convergence for finding
-     a zero of a function", `Computer Journal', 14 (1971) 422-425
+     a zero of a function", 'Computer Journal', 14 (1971) 422-425
 
      J. C. P. Bus and T. J. Dekker, "Two Efficient Algorithms with
-     Guaranteed Convergence for Finding a Zero of a Function", `ACM
+     Guaranteed Convergence for Finding a Zero of a Function", 'ACM
      Transactions of Mathematical Software', Vol. 1 No. 4 (1975) 330-345
 
 
@@ -5474,21 +5404,21 @@ minimizers at runtime without needing to recompile your program.  Each
 instance of a minimizer keeps track of its own state, allowing the
 minimizers to be used in multi-threaded programs.
 
-   The header file `gsl_min.h' contains prototypes for the minimization
+   The header file 'gsl_min.h' contains prototypes for the minimization
 functions and related declarations.  To use the minimization algorithms
 to find the maximum of a function simply invert its sign.
 
 * Menu:
 
-* Minimization Overview::
-* Minimization Caveats::
-* Initializing the Minimizer::
-* Providing the function to minimize::
-* Minimization Iteration::
-* Minimization Stopping Parameters::
-* Minimization Algorithms::
-* Minimization Examples::
-* Minimization References and Further Reading::
+* Minimization Overview::       
+* Minimization Caveats::        
+* Initializing the Minimizer::  
+* Providing the function to minimize::  
+* Minimization Iteration::      
+* Minimization Stopping Parameters::  
+* Minimization Algorithms::     
+* Minimization Examples::       
+* Minimization References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Minimization Overview,  Next: Minimization Caveats,  Up: One dimensional Minimization
@@ -5506,21 +5436,20 @@ function at the ends of the interval,
      f(a) > f(x) < f(b)
 
 This condition guarantees that a minimum is contained somewhere within
-the interval.  On each iteration a new point x' is selected using one
-of the available algorithms.  If the new point is a better estimate of
-the minimum, i.e. where f(x') < f(x), then the current estimate of the
-minimum x is updated.  The new point also allows the size of the
-bounded interval to be reduced, by choosing the most compact set of
-points which satisfies the constraint f(a) > f(x) < f(b).  The interval
-is reduced until it encloses the true minimum to a desired tolerance.
-This provides a best estimate of the location of the minimum and a
-rigorous error estimate.
+the interval.  On each iteration a new point x' is selected using one of
+the available algorithms.  If the new point is a better estimate of the
+minimum, i.e. where f(x') < f(x), then the current estimate of the
+minimum x is updated.  The new point also allows the size of the bounded
+interval to be reduced, by choosing the most compact set of points which
+satisfies the constraint f(a) > f(x) < f(b).  The interval is reduced
+until it encloses the true minimum to a desired tolerance.  This
+provides a best estimate of the location of the minimum and a rigorous
+error estimate.
 
    Several bracketing algorithms are available within a single
-framework.  The user provides a high-level driver for the algorithm,
-and the library provides the individual functions necessary for each of
-the steps.  There are three main phases of the iteration.  The steps
-are,
+framework.  The user provides a high-level driver for the algorithm, and
+the library provides the individual functions necessary for each of the
+steps.  There are three main phases of the iteration.  The steps are,
 
    * initialize minimizer state, S, for algorithm T
 
@@ -5528,7 +5457,7 @@ are,
 
    * test S for convergence, and repeat iteration if necessary
 
-The state for the minimizers is held in a `gsl_min_fminimizer' struct.
+The state for the minimizers is held in a 'gsl_min_fminimizer' struct.
 The updating procedure uses only function evaluations (not derivatives).
 
 
@@ -5540,7 +5469,7 @@ File: gsl-ref.info,  Node: Minimization Caveats,  Next: Initializing the Minimiz
 Note that minimization functions can only search for one minimum at a
 time.  When there are several minima in the search area, the first
 minimum to be found will be returned; however it is difficult to predict
-which of the minima this will be. _In most cases, no error will be
+which of the minima this will be.  _In most cases, no error will be
 reported if you try to find a minimum in an area where there is more
 than one._
 
@@ -5579,25 +5508,25 @@ File: gsl-ref.info,  Node: Initializing the Minimizer,  Next: Providing the func
 
      If there is insufficient memory to create the minimizer then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_min_fminimizer_set (gsl_min_fminimizer * S,
           gsl_function * F, double X_MINIMUM, double X_LOWER, double
           X_UPPER)
      This function sets, or resets, an existing minimizer S to use the
-     function F and the initial search interval [X_LOWER, X_UPPER],
-     with a guess for the location of the minimum X_MINIMUM.
+     function F and the initial search interval [X_LOWER, X_UPPER], with
+     a guess for the location of the minimum X_MINIMUM.
 
      If the interval given does not contain a minimum, then the function
-     returns an error code of `GSL_EINVAL'.
+     returns an error code of 'GSL_EINVAL'.
 
- -- Function: int gsl_min_fminimizer_set_with_values
-          (gsl_min_fminimizer * S, gsl_function * F, double X_MINIMUM,
-          double F_MINIMUM, double X_LOWER, double F_LOWER, double
-          X_UPPER, double F_UPPER)
-     This function is equivalent to `gsl_min_fminimizer_set' but uses
+ -- Function: int gsl_min_fminimizer_set_with_values (gsl_min_fminimizer
+          * S, gsl_function * F, double X_MINIMUM, double F_MINIMUM,
+          double X_LOWER, double F_LOWER, double X_UPPER, double
+          F_UPPER)
+     This function is equivalent to 'gsl_min_fminimizer_set' but uses
      the values F_MINIMUM, F_LOWER and F_UPPER instead of computing
-     `f(x_minimum)', `f(x_lower)' and `f(x_upper)'.
+     'f(x_minimum)', 'f(x_lower)' and 'f(x_upper)'.
 
  -- Function: void gsl_min_fminimizer_free (gsl_min_fminimizer * S)
      This function frees all the memory associated with the minimizer S.
@@ -5610,7 +5539,7 @@ File: gsl-ref.info,  Node: Initializing the Minimizer,  Next: Providing the func
           printf ("s is a '%s' minimizer\n",
                   gsl_min_fminimizer_name (s));
 
-     would print something like `s is a 'brent' minimizer'.
+     would print something like 's is a 'brent' minimizer'.
 
 
 File: gsl-ref.info,  Node: Providing the function to minimize,  Next: Minimization Iteration,  Prev: Initializing the Minimizer,  Up: One dimensional Minimization
@@ -5620,8 +5549,8 @@ File: gsl-ref.info,  Node: Providing the function to minimize,  Next: Minimizati
 
 You must provide a continuous function of one variable for the
 minimizers to operate on.  In order to allow for general parameters the
-functions are defined by a `gsl_function' data type (*note Providing
-the function to solve::).
+functions are defined by a 'gsl_function' data type (*note Providing the
+function to solve::).
 
 
 File: gsl-ref.info,  Node: Minimization Iteration,  Next: Minimization Stopping Parameters,  Prev: Providing the function to minimize,  Up: One dimensional Minimization
@@ -5640,13 +5569,13 @@ modifications to the code.
      the iteration encounters an unexpected problem then an error code
      will be returned,
 
-    `GSL_EBADFUNC'
+     'GSL_EBADFUNC'
           the iteration encountered a singular point where the function
-          evaluated to `Inf' or `NaN'.
+          evaluated to 'Inf' or 'NaN'.
 
-    `GSL_FAILURE'
-          the algorithm could not improve the current best
-          approximation or bounding interval.
+     'GSL_FAILURE'
+          the algorithm could not improve the current best approximation
+          or bounding interval.
 
    The minimizer maintains a current best estimate of the position of
 the minimum at all times, and the current interval bounding the minimum.
@@ -5692,18 +5621,17 @@ conditions is true:
 The handling of these conditions is under user control.  The function
 below allows the user to test the precision of the current result.
 
- -- Function: int gsl_min_test_interval (double X_LOWER, double
-          X_UPPER, double EPSABS, double EPSREL)
+ -- Function: int gsl_min_test_interval (double X_LOWER, double X_UPPER,
+          double EPSABS, double EPSREL)
      This function tests for the convergence of the interval [X_LOWER,
-     X_UPPER] with absolute error EPSABS and relative error EPSREL.
-     The test returns `GSL_SUCCESS' if the following condition is
-     achieved,
+     X_UPPER] with absolute error EPSABS and relative error EPSREL.  The
+     test returns 'GSL_SUCCESS' if the following condition is achieved,
 
           |a - b| < epsabs + epsrel min(|a|,|b|)
 
      when the interval x = [a,b] does not include the origin.  If the
-     interval includes the origin then \min(|a|,|b|) is replaced by
-     zero (which is the minimum value of |x| over the interval).  This
+     interval includes the origin then \min(|a|,|b|) is replaced by zero
+     (which is the minimum value of |x| over the interval).  This
      ensures that the relative error is accurately estimated for minima
      close to the origin.
 
@@ -5730,9 +5658,10 @@ somewhere in the interval.  If a valid initial interval is used then
 these algorithm cannot fail, provided the function is well-behaved.
 
  -- Minimizer: gsl_min_fminimizer_goldensection
+
      The "golden section algorithm" is the simplest method of bracketing
-     the minimum of a function.  It is the slowest algorithm provided
-     by the library, with linear convergence.
+     the minimum of a function.  It is the slowest algorithm provided by
+     the library, with linear convergence.
 
      On each iteration, the algorithm first compares the subintervals
      from the endpoints to the current minimum.  The larger subinterval
@@ -5741,13 +5670,12 @@ these algorithm cannot fail, provided the function is well-behaved.
      point is calculated.  The new value is used with the constraint
      f(a') > f(x') < f(b') to a select new interval containing the
      minimum, by discarding the least useful point.  This procedure can
-     be continued indefinitely until the interval is sufficiently
-     small.  Choosing the golden section as the bisection ratio can be
-     shown to provide the fastest convergence for this type of
-     algorithm.
-
+     be continued indefinitely until the interval is sufficiently small.
+     Choosing the golden section as the bisection ratio can be shown to
+     provide the fastest convergence for this type of algorithm.
 
  -- Minimizer: gsl_min_fminimizer_brent
+
      The "Brent minimization algorithm" combines a parabolic
      interpolation with the golden section algorithm.  This produces a
      fast algorithm which is still robust.
@@ -5757,11 +5685,10 @@ these algorithm cannot fail, provided the function is well-behaved.
      interpolating parabola through three existing points.  The minimum
      of the parabola is taken as a guess for the minimum.  If it lies
      within the bounds of the current interval then the interpolating
-     point is accepted, and used to generate a smaller interval.  If
-     the interpolating point is not accepted then the algorithm falls
-     back to an ordinary golden section step.  The full details of
-     Brent's method include some additional checks to improve
-     convergence.
+     point is accepted, and used to generate a smaller interval.  If the
+     interpolating point is not accepted then the algorithm falls back
+     to an ordinary golden section step.  The full details of Brent's
+     method include some additional checks to improve convergence.
 
 
 File: gsl-ref.info,  Node: Minimization Examples,  Next: Minimization References and Further Reading,  Prev: Minimization Algorithms,  Up: One dimensional Minimization
@@ -5865,7 +5792,7 @@ File: gsl-ref.info,  Node: Minimization References and Further Reading,  Prev: M
 Further information on Brent's algorithm is available in the following
 book,
 
-     Richard Brent, `Algorithms for minimization without derivatives',
+     Richard Brent, 'Algorithms for minimization without derivatives',
      Prentice-Hall (1973), republished by Dover in paperback (2002),
      ISBN 0-486-41998-3.
 
@@ -5876,30 +5803,30 @@ File: gsl-ref.info,  Node: Multidimensional Root-Finding,  Next: Multidimensiona
 ********************************
 
 This chapter describes functions for multidimensional root-finding
-(solving nonlinear systems with n equations in n unknowns).  The
-library provides low level components for a variety of iterative
-solvers and convergence tests.  These can be combined by the user to
-achieve the desired solution, with full access to the intermediate
-steps of the iteration.  Each class of methods uses the same framework,
-so that you can switch between solvers at runtime without needing to
-recompile your program.  Each instance of a solver keeps track of its
-own state, allowing the solvers to be used in multi-threaded programs.
-The solvers are based on the original Fortran library MINPACK.
-
-   The header file `gsl_multiroots.h' contains prototypes for the
+(solving nonlinear systems with n equations in n unknowns).  The library
+provides low level components for a variety of iterative solvers and
+convergence tests.  These can be combined by the user to achieve the
+desired solution, with full access to the intermediate steps of the
+iteration.  Each class of methods uses the same framework, so that you
+can switch between solvers at runtime without needing to recompile your
+program.  Each instance of a solver keeps track of its own state,
+allowing the solvers to be used in multi-threaded programs.  The solvers
+are based on the original Fortran library MINPACK.
+
+   The header file 'gsl_multiroots.h' contains prototypes for the
 multidimensional root finding functions and related declarations.
 
 * Menu:
 
-* Overview of Multidimensional Root Finding::
-* Initializing the Multidimensional Solver::
-* Providing the multidimensional system of equations to solve::
-* Iteration of the multidimensional solver::
-* Search Stopping Parameters for the multidimensional solver::
-* Algorithms using Derivatives::
-* Algorithms without Derivatives::
-* Example programs for Multidimensional Root finding::
-* References and Further Reading for Multidimensional Root Finding::
+* Overview of Multidimensional Root Finding::  
+* Initializing the Multidimensional Solver::  
+* Providing the multidimensional system of equations to solve::  
+* Iteration of the multidimensional solver::  
+* Search Stopping Parameters for the multidimensional solver::  
+* Algorithms using Derivatives::  
+* Algorithms without Derivatives::  
+* Example programs for Multidimensional Root finding::  
+* References and Further Reading for Multidimensional Root Finding::  
 
 
 File: gsl-ref.info,  Node: Overview of Multidimensional Root Finding,  Next: Initializing the Multidimensional Solver,  Up: Multidimensional Root-Finding
@@ -5919,11 +5846,11 @@ iteration,
 
      x -> x' = x - J^{-1} f(x)
 
-where x, f are vector quantities and J is the Jacobian matrix J_{ij} =
-d f_i / d x_j.  Additional strategies can be used to enlarge the region
-of convergence.  These include requiring a decrease in the norm |f| on
-each step proposed by Newton's method, or taking steepest-descent steps
-in the direction of the negative gradient of |f|.
+where x, f are vector quantities and J is the Jacobian matrix J_{ij} = d
+f_i / d x_j.  Additional strategies can be used to enlarge the region of
+convergence.  These include requiring a decrease in the norm |f| on each
+step proposed by Newton's method, or taking steepest-descent steps in
+the direction of the negative gradient of |f|.
 
    Several root-finding algorithms are available within a single
 framework.  The user provides a high-level driver for the algorithms,
@@ -5944,11 +5871,11 @@ algorithms provided by the library are divided into two classes
 according to whether the derivatives are available or not.
 
    The state for solvers with an analytic Jacobian matrix is held in a
-`gsl_multiroot_fdfsolver' struct.  The updating procedure requires both
+'gsl_multiroot_fdfsolver' struct.  The updating procedure requires both
 the function and its derivatives to be supplied by the user.
 
    The state for solvers which do not use an analytic Jacobian matrix is
-held in a `gsl_multiroot_fsolver' struct.  The updating procedure uses
+held in a 'gsl_multiroot_fsolver' struct.  The updating procedure uses
 only function evaluations (not derivatives).  The algorithms estimate
 the matrix J or J^{-1} by approximate methods.
 
@@ -5963,8 +5890,8 @@ with or without derivatives.  The solver itself depends only on the
 dimension of the problem and the algorithm and can be reused for
 different problems.
 
- -- Function: gsl_multiroot_fsolver * gsl_multiroot_fsolver_alloc
-          (const gsl_multiroot_fsolver_type * T, size_t N)
+ -- Function: gsl_multiroot_fsolver * gsl_multiroot_fsolver_alloc (const
+          gsl_multiroot_fsolver_type * T, size_t N)
      This function returns a pointer to a newly allocated instance of a
      solver of type T for a system of N dimensions.  For example, the
      following code creates an instance of a hybrid solver, to solve a
@@ -5977,14 +5904,14 @@ different problems.
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: gsl_multiroot_fdfsolver * gsl_multiroot_fdfsolver_alloc
           (const gsl_multiroot_fdfsolver_type * T, size_t N)
      This function returns a pointer to a newly allocated instance of a
      derivative solver of type T for a system of N dimensions.  For
-     example, the following code creates an instance of a
-     Newton-Raphson solver, for a 2-dimensional system of equations.
+     example, the following code creates an instance of a Newton-Raphson
+     solver, for a 2-dimensional system of equations.
 
           const gsl_multiroot_fdfsolver_type * T
               = gsl_multiroot_fdfsolver_newton;
@@ -5993,22 +5920,22 @@ different problems.
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_multiroot_fsolver_set (gsl_multiroot_fsolver * S,
           gsl_multiroot_function * F, gsl_vector * X)
      This function sets, or resets, an existing solver S to use the
      function F and the initial guess X.
 
- -- Function: int gsl_multiroot_fdfsolver_set (gsl_multiroot_fdfsolver
-          * S, gsl_multiroot_function_fdf * FDF, gsl_vector * X)
+ -- Function: int gsl_multiroot_fdfsolver_set (gsl_multiroot_fdfsolver *
+          S, gsl_multiroot_function_fdf * FDF, gsl_vector * X)
      This function sets, or resets, an existing solver S to use the
      function and derivative FDF and the initial guess X.
 
  -- Function: void gsl_multiroot_fsolver_free (gsl_multiroot_fsolver *
           S)
- -- Function: void gsl_multiroot_fdfsolver_free
-          (gsl_multiroot_fdfsolver * S)
+ -- Function: void gsl_multiroot_fdfsolver_free (gsl_multiroot_fdfsolver
+          * S)
      These functions free all the memory associated with the solver S.
 
  -- Function: const char * gsl_multiroot_fsolver_name (const
@@ -6021,7 +5948,7 @@ different problems.
           printf ("s is a '%s' solver\n",
                   gsl_multiroot_fdfsolver_name (s));
 
-     would print something like `s is a 'newton' solver'.
+     would print something like 's is a 'newton' solver'.
 
 
 File: gsl-ref.info,  Node: Providing the multidimensional system of equations to solve,  Next: Iteration of the multidimensional solver,  Prev: Initializing the Multidimensional Solver,  Up: Multidimensional Root-Finding
@@ -6037,16 +5964,16 @@ defined by the following data types:
      This data type defines a general system of functions with
      parameters.
 
-    `int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
+     'int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
           this function should store the vector result f(x,params) in F
-          for argument X and parameters PARAMS, returning an
-          appropriate error code if the function cannot be computed.
+          for argument X and parameters PARAMS, returning an appropriate
+          error code if the function cannot be computed.
 
-    `size_t n'
-          the dimension of the system, i.e. the number of components of
+     'size_t n'
+          the dimension of the system, i.e.  the number of components of
           the vectors X and F.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function.
 
 Here is an example using Powell's test function,
@@ -6054,8 +5981,8 @@ Here is an example using Powell's test function,
      f_1(x) = A x_0 x_1 - 1,
      f_2(x) = exp(-x_0) + exp(-x_1) - (1 + 1/A)
 
-with A = 10^4.  The following code defines a `gsl_multiroot_function'
-system `F' which you could pass to a solver:
+with A = 10^4.  The following code defines a 'gsl_multiroot_function'
+system 'F' which you could pass to a solver:
 
      struct powell_params { double A; };
 
@@ -6084,29 +6011,29 @@ system `F' which you could pass to a solver:
      This data type defines a general system of functions with
      parameters and the corresponding Jacobian matrix of derivatives,
 
-    `int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
+     'int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
           this function should store the vector result f(x,params) in F
-          for argument X and parameters PARAMS, returning an
-          appropriate error code if the function cannot be computed.
+          for argument X and parameters PARAMS, returning an appropriate
+          error code if the function cannot be computed.
 
-    `int (* df) (const gsl_vector * X, void * PARAMS, gsl_matrix * J)'
+     'int (* df) (const gsl_vector * X, void * PARAMS, gsl_matrix * J)'
           this function should store the N-by-N matrix result J_ij = d
           f_i(x,params) / d x_j in J for argument X and parameters
           PARAMS, returning an appropriate error code if the function
           cannot be computed.
 
-    `int (* fdf) (const gsl_vector * X, void * PARAMS, gsl_vector * F, gsl_matrix * J)'
+     'int (* fdf) (const gsl_vector * X, void * PARAMS, gsl_vector * F, gsl_matrix * J)'
           This function should set the values of the F and J as above,
-          for arguments X and parameters PARAMS.  This function
-          provides an optimization of the separate functions for f(x)
-          and J(x)--it is always faster to compute the function and its
+          for arguments X and parameters PARAMS.  This function provides
+          an optimization of the separate functions for f(x) and
+          J(x)--it is always faster to compute the function and its
           derivative at the same time.
 
-    `size_t n'
-          the dimension of the system, i.e. the number of components of
+     'size_t n'
+          the dimension of the system, i.e.  the number of components of
           the vectors X and F.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function.
 
 The example of Powell's test function defined above can be extended to
@@ -6157,8 +6084,8 @@ include analytic derivatives using the following code,
      FDF.n = 2;
      FDF.params = 0;
 
-Note that the function `powell_fdf' is able to reuse existing terms
-from the function when calculating the Jacobian, thus saving time.
+Note that the function 'powell_fdf' is able to reuse existing terms from
+the function when calculating the Jacobian, thus saving time.
 
 
 File: gsl-ref.info,  Node: Iteration of the multidimensional solver,  Next: Search Stopping Parameters for the multidimensional solver,  Prev: Providing the multidimensional system of equations to solve,  Up: Multidimensional Root-Finding
@@ -6172,19 +6099,19 @@ corresponding type.  The same functions work for all solvers so that
 different methods can be substituted at runtime without modifications to
 the code.
 
- -- Function: int gsl_multiroot_fsolver_iterate (gsl_multiroot_fsolver
-          * S)
+ -- Function: int gsl_multiroot_fsolver_iterate (gsl_multiroot_fsolver *
+          S)
  -- Function: int gsl_multiroot_fdfsolver_iterate
           (gsl_multiroot_fdfsolver * S)
      These functions perform a single iteration of the solver S.  If the
      iteration encounters an unexpected problem then an error code will
      be returned,
 
-    `GSL_EBADFUNC'
+     'GSL_EBADFUNC'
           the iteration encountered a singular point where the function
-          or its derivative evaluated to `Inf' or `NaN'.
+          or its derivative evaluated to 'Inf' or 'NaN'.
 
-    `GSL_ENOPROG'
+     'GSL_ENOPROG'
           the iteration is not making any progress, preventing the
           algorithm from continuing.
 
@@ -6221,8 +6148,8 @@ File: gsl-ref.info,  Node: Search Stopping Parameters for the multidimensional s
 A root finding procedure should stop when one of the following
 conditions is true:
 
-   * A multidimensional root has been found to within the
-     user-specified precision.
+   * A multidimensional root has been found to within the user-specified
+     precision.
 
    * A user-specified maximum number of iterations has been reached.
 
@@ -6232,26 +6159,27 @@ The handling of these conditions is under user control.  The functions
 below allow the user to test the precision of the current result in
 several standard ways.
 
- -- Function: int gsl_multiroot_test_delta (const gsl_vector * DX,
-          const gsl_vector * X, double EPSABS, double EPSREL)
+ -- Function: int gsl_multiroot_test_delta (const gsl_vector * DX, const
+          gsl_vector * X, double EPSABS, double EPSREL)
+
      This function tests for the convergence of the sequence by
      comparing the last step DX with the absolute error EPSABS and
      relative error EPSREL to the current position X.  The test returns
-     `GSL_SUCCESS' if the following condition is achieved,
+     'GSL_SUCCESS' if the following condition is achieved,
 
           |dx_i| < epsabs + epsrel |x_i|
 
-     for each component of X and returns `GSL_CONTINUE' otherwise.
+     for each component of X and returns 'GSL_CONTINUE' otherwise.
 
  -- Function: int gsl_multiroot_test_residual (const gsl_vector * F,
           double EPSABS)
-     This function tests the residual value F against the absolute
-     error bound EPSABS.  The test returns `GSL_SUCCESS' if the
-     following condition is achieved,
+     This function tests the residual value F against the absolute error
+     bound EPSABS.  The test returns 'GSL_SUCCESS' if the following
+     condition is achieved,
 
           \sum_i |f_i| < epsabs
 
-     and returns `GSL_CONTINUE' otherwise.  This criterion is suitable
+     and returns 'GSL_CONTINUE' otherwise.  This criterion is suitable
      for situations where the precise location of the root, x, is
      unimportant provided a value can be found where the residual is
      small enough.
@@ -6270,21 +6198,20 @@ initial guess must be sufficiently close to the root for it to work.
 When the conditions are satisfied then convergence is quadratic.
 
  -- Derivative Solver: gsl_multiroot_fdfsolver_hybridsj
-     This is a modified version of Powell's Hybrid method as
-     implemented in the HYBRJ algorithm in MINPACK.  Minpack was
-     written by Jorge J. More', Burton S. Garbow and Kenneth E.
-     Hillstrom.  The Hybrid algorithm retains the fast convergence of
-     Newton's method but will also reduce the residual when Newton's
-     method is unreliable.
+     This is a modified version of Powell's Hybrid method as implemented
+     in the HYBRJ algorithm in MINPACK.  Minpack was written by Jorge J.
+     More', Burton S. Garbow and Kenneth E. Hillstrom.  The Hybrid
+     algorithm retains the fast convergence of Newton's method but will
+     also reduce the residual when Newton's method is unreliable.
 
      The algorithm uses a generalized trust region to keep each step
      under control.  In order to be accepted a proposed new position x'
      must satisfy the condition |D (x' - x)| < \delta, where D is a
-     diagonal scaling matrix and \delta is the size of the trust
-     region.  The components of D are computed internally, using the
-     column norms of the Jacobian to estimate the sensitivity of the
-     residual to each component of x.  This improves the behavior of the
-     algorithm for badly scaled functions.
+     diagonal scaling matrix and \delta is the size of the trust region.
+     The components of D are computed internally, using the column norms
+     of the Jacobian to estimate the sensitivity of the residual to each
+     component of x.  This improves the behavior of the algorithm for
+     badly scaled functions.
 
      On each iteration the algorithm first determines the standard
      Newton step by solving the system J dx = - f.  If this step falls
@@ -6301,40 +6228,40 @@ When the conditions are satisfied then convergence is quadratic.
      The proposed step is now tested by evaluating the function at the
      resulting point, x'.  If the step reduces the norm of the function
      sufficiently then it is accepted and size of the trust region is
-     increased.  If the proposed step fails to improve the solution
-     then the size of the trust region is decreased and another trial
-     step is computed.
+     increased.  If the proposed step fails to improve the solution then
+     the size of the trust region is decreased and another trial step is
+     computed.
 
-     The speed of the algorithm is increased by computing the changes
-     to the Jacobian approximately, using a rank-1 update.  If two
+     The speed of the algorithm is increased by computing the changes to
+     the Jacobian approximately, using a rank-1 update.  If two
      successive attempts fail to reduce the residual then the full
      Jacobian is recomputed.  The algorithm also monitors the progress
      of the solution and returns an error if several steps fail to make
      any improvement,
 
-    `GSL_ENOPROG'
+     'GSL_ENOPROG'
           the iteration is not making any progress, preventing the
           algorithm from continuing.
 
-    `GSL_ENOPROGJ'
+     'GSL_ENOPROGJ'
           re-evaluations of the Jacobian indicate that the iteration is
           not making any progress, preventing the algorithm from
           continuing.
 
-
  -- Derivative Solver: gsl_multiroot_fdfsolver_hybridj
-     This algorithm is an unscaled version of `hybridsj'.  The steps are
+     This algorithm is an unscaled version of 'hybridsj'.  The steps are
      controlled by a spherical trust region |x' - x| < \delta, instead
      of a generalized region.  This can be useful if the generalized
-     region estimated by `hybridsj' is inappropriate.
+     region estimated by 'hybridsj' is inappropriate.
 
  -- Derivative Solver: gsl_multiroot_fdfsolver_newton
+
      Newton's Method is the standard root-polishing algorithm.  The
      algorithm begins with an initial guess for the location of the
-     solution.  On each iteration a linear approximation to the
-     function F is used to estimate the step which will zero all the
-     components of the residual.  The iteration is defined by the
-     following sequence,
+     solution.  On each iteration a linear approximation to the function
+     F is used to estimate the step which will zero all the components
+     of the residual.  The iteration is defined by the following
+     sequence,
 
           x -> x' = x - J^{-1} f(x)
 
@@ -6374,8 +6301,8 @@ the algorithms described in the previous section.
      This is a version of the Hybrid algorithm which replaces calls to
      the Jacobian function by its finite difference approximation.  The
      finite difference approximation is computed using
-     `gsl_multiroots_fdjac' with a relative step size of
-     `GSL_SQRT_DBL_EPSILON'.  Note that this step size will not be
+     'gsl_multiroots_fdjac' with a relative step size of
+     'GSL_SQRT_DBL_EPSILON'.  Note that this step size will not be
      suitable for all problems.
 
  -- Solver: gsl_multiroot_fsolver_hybrid
@@ -6383,6 +6310,7 @@ the algorithms described in the previous section.
      internal scaling.
 
  -- Solver: gsl_multiroot_fsolver_dnewton
+
      The "discrete Newton algorithm" is the simplest method of solving a
      multidimensional system.  It uses the Newton iteration
 
@@ -6402,10 +6330,11 @@ the algorithms described in the previous section.
      differences are not a good approximation to the true derivatives.
 
  -- Solver: gsl_multiroot_fsolver_broyden
+
      The "Broyden algorithm" is a version of the discrete Newton
      algorithm which attempts to avoids the expensive update of the
-     Jacobian matrix on each iteration.  The changes to the Jacobian
-     are also approximated, using a rank-1 update,
+     Jacobian matrix on each iteration.  The changes to the Jacobian are
+     also approximated, using a rank-1 update,
 
           J^{-1} \to J^{-1} - (J^{-1} df - dx) dx^T J^{-1} / dx^T J^{-1} df
 
@@ -6431,14 +6360,14 @@ File: gsl-ref.info,  Node: Example programs for Multidimensional Root finding,
 
 The multidimensional solvers are used in a similar way to the
 one-dimensional root finding algorithms.  This first example
-demonstrates the `hybrids' scaled-hybrid algorithm, which does not
-require derivatives. The program solves the Rosenbrock system of
+demonstrates the 'hybrids' scaled-hybrid algorithm, which does not
+require derivatives.  The program solves the Rosenbrock system of
 equations,
 
      f_1 (x, y) = a (1 - x)
      f_2 (x, y) = b (y - x^2)
 
-with a = 1, b = 10. The solution of this system lies at (x,y) = (1,1)
+with a = 1, b = 10.  The solution of this system lies at (x,y) = (1,1)
 in a narrow valley.
 
    The first stage of the program is to define the system of equations,
@@ -6473,9 +6402,9 @@ in a narrow valley.
        return GSL_SUCCESS;
      }
 
-The main program begins by creating the function object `f', with the
-arguments `(x,y)' and parameters `(a,b)'. The solver `s' is initialized
-to use this function, with the `hybrids' method.
+The main program begins by creating the function object 'f', with the
+arguments '(x,y)' and parameters '(a,b)'.  The solver 's' is initialized
+to use this function, with the 'hybrids' method.
 
      int
      main (void)
@@ -6531,8 +6460,8 @@ can be reported to the user, a new starting point chosen or a different
 algorithm used.
 
    The intermediate state of the solution is displayed by the following
-function.  The solver state contains the vector `s->x' which is the
-current position, and the vector `s->f' with corresponding function
+function.  The solver state contains the vector 's->x' which is the
+current position, and the vector 's->f' with corresponding function
 values.
 
      int
@@ -6547,10 +6476,10 @@ values.
                gsl_vector_get (s->f, 1));
      }
 
-Here are the results of running the program. The algorithm is started at
-(-10,-5) far from the solution.  Since the solution is hidden in a
+Here are the results of running the program.  The algorithm is started
+at (-10,-5) far from the solution.  Since the solution is hidden in a
 narrow valley the earliest steps follow the gradient of the function
-downhill, in an attempt to reduce the large value of the residual. Once
+downhill, in an attempt to reduce the large value of the residual.  Once
 the root has been approximately located, on iteration 8, the Newton
 behavior takes over and convergence is very rapid.
 
@@ -6568,17 +6497,17 @@ behavior takes over and convergence is very rapid.
      iter = 11 x =   1.000   1.000  f(x) = 0.000e+00  0.000e+00
      status = success
 
-Note that the algorithm does not update the location on every
-iteration. Some iterations are used to adjust the trust-region
-parameter, after trying a step which was found to be divergent, or to
-recompute the Jacobian, when poor convergence behavior is detected.
+Note that the algorithm does not update the location on every iteration.
+Some iterations are used to adjust the trust-region parameter, after
+trying a step which was found to be divergent, or to recompute the
+Jacobian, when poor convergence behavior is detected.
 
    The next example program adds derivative information, in order to
-accelerate the solution. There are two derivative functions
-`rosenbrock_df' and `rosenbrock_fdf'. The latter computes both the
-function and its derivative simultaneously. This allows the
+accelerate the solution.  There are two derivative functions
+'rosenbrock_df' and 'rosenbrock_fdf'.  The latter computes both the
+function and its derivative simultaneously.  This allows the
 optimization of any common terms.  For simplicity we substitute calls to
-the separate `f' and `df' functions at this point in the code below.
+the separate 'f' and 'df' functions at this point in the code below.
 
      int
      rosenbrock_df (const gsl_vector * x, void *params,
@@ -6612,7 +6541,7 @@ the separate `f' and `df' functions at this point in the code below.
        return GSL_SUCCESS;
      }
 
-The main program now makes calls to the corresponding `fdfsolver'
+The main program now makes calls to the corresponding 'fdfsolver'
 versions of the functions,
 
      int
@@ -6665,13 +6594,13 @@ versions of the functions,
        return 0;
      }
 
-The addition of derivative information to the `hybrids' solver does not
+The addition of derivative information to the 'hybrids' solver does not
 make any significant difference to its behavior, since it able to
 approximate the Jacobian numerically with sufficient accuracy.  To
 illustrate the behavior of a different derivative solver we switch to
-`gnewton'. This is a traditional Newton solver with the constraint that
-it scales back its step if the full step would lead "uphill". Here is
-the output for the `gnewton' algorithm,
+'gnewton'.  This is a traditional Newton solver with the constraint that
+it scales back its step if the full step would lead "uphill".  Here is
+the output for the 'gnewton' algorithm,
 
      iter = 0 x = -10.000  -5.000 f(x) =  1.100e+01 -1.050e+03
      iter = 1 x =  -4.231 -65.317 f(x) =  5.231e+00 -8.321e+02
@@ -6680,9 +6609,9 @@ the output for the `gnewton' algorithm,
      status = success
 
 The convergence is much more rapid, but takes a wide excursion out to
-the point (-4.23,-65.3). This could cause the algorithm to go astray in
-a realistic application.  The hybrid algorithm follows the downhill
-path to the solution more reliably.
+the point (-4.23,-65.3).  This could cause the algorithm to go astray in
+a realistic application.  The hybrid algorithm follows the downhill path
+to the solution more reliably.
 
 
 File: gsl-ref.info,  Node: References and Further Reading for Multidimensional Root Finding,  Prev: Example programs for Multidimensional Root finding,  Up: Multidimensional Root-Finding
@@ -6695,7 +6624,7 @@ articles by Powell,
 
      M.J.D. Powell, "A Hybrid Method for Nonlinear Equations" (Chap 6, p
      87-114) and "A Fortran Subroutine for Solving systems of Nonlinear
-     Algebraic Equations" (Chap 7, p 115-161), in `Numerical Methods for
+     Algebraic Equations" (Chap 7, p 115-161), in 'Numerical Methods for
      Nonlinear Algebraic Equations', P. Rabinowitz, editor.  Gordon and
      Breach, 1970.
 
@@ -6703,11 +6632,11 @@ The following papers are also relevant to the algorithms described in
 this section,
 
      J.J. More', M.Y. Cosnard, "Numerical Solution of Nonlinear
-     Equations", `ACM Transactions on Mathematical Software', Vol 5, No
+     Equations", 'ACM Transactions on Mathematical Software', Vol 5, No
      1, (1979), p 64-85
 
      C.G. Broyden, "A Class of Methods for Solving Nonlinear
-     Simultaneous Equations", `Mathematics of Computation', Vol 19
+     Simultaneous Equations", 'Mathematics of Computation', Vol 19
      (1965), p 577-593
 
      J.J. More', B.S. Garbow, K.E. Hillstrom, "Testing Unconstrained
@@ -6728,23 +6657,23 @@ full access to the intermediate steps of the algorithms.  Each class of
 methods uses the same framework, so that you can switch between
 minimizers at runtime without needing to recompile your program.  Each
 instance of a minimizer keeps track of its own state, allowing the
-minimizers to be used in multi-threaded programs. The minimization
+minimizers to be used in multi-threaded programs.  The minimization
 algorithms can be used to maximize a function by inverting its sign.
 
-   The header file `gsl_multimin.h' contains prototypes for the
+   The header file 'gsl_multimin.h' contains prototypes for the
 minimization functions and related declarations.
 
 * Menu:
 
-* Multimin Overview::
-* Multimin Caveats::
-* Initializing the Multidimensional Minimizer::
-* Providing a function to minimize::
-* Multimin Iteration::
-* Multimin Stopping Criteria::
-* Multimin Algorithms::
-* Multimin Examples::
-* Multimin References and Further Reading::
+* Multimin Overview::       
+* Multimin Caveats::        
+* Initializing the Multidimensional Minimizer::  
+* Providing a function to minimize::  
+* Multimin Iteration::      
+* Multimin Stopping Criteria::  
+* Multimin Algorithms::     
+* Multimin Examples::       
+* Multimin References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Multimin Overview,  Next: Multimin Caveats,  Up: Multidimensional Minimization
@@ -6757,8 +6686,8 @@ such that the scalar function,
 
      f(x_1, ..., x_n)
 
-takes a value which is lower than at any neighboring point. For smooth
-functions the gradient g = \nabla f vanishes at the minimum. In general
+takes a value which is lower than at any neighboring point.  For smooth
+functions the gradient g = \nabla f vanishes at the minimum.  In general
 there are no bracketing methods available for the minimization of
 n-dimensional functions.  The algorithms proceed from an initial guess
 using a search algorithm which attempts to move in a downhill direction.
@@ -6771,12 +6700,12 @@ and the whole process repeated until the true n-dimensional minimum is
 found.
 
    The Nelder-Mead Simplex algorithm applies a different strategy.  It
-maintains n+1 trial parameter vectors as the vertices of a
-n-dimensional simplex.  In each iteration step it tries to improve the
-worst vertex by a simple geometrical transformation until the size of
-the simplex falls below a given tolerance.
+maintains n+1 trial parameter vectors as the vertices of a n-dimensional
+simplex.  In each iteration step it tries to improve the worst vertex by
+a simple geometrical transformation until the size of the simplex falls
+below a given tolerance.
 
-   Both types of algorithms use a standard framework. The user provides
+   Both types of algorithms use a standard framework.  The user provides
 a high-level driver for the algorithms, and the library provides the
 individual functions necessary for each of the steps.  There are three
 main phases of the iteration.  The steps are,
@@ -6790,7 +6719,7 @@ main phases of the iteration.  The steps are,
 Each iteration step consists either of an improvement to the
 line-minimisation in the current direction or an update to the search
 direction itself.  The state for the minimizers is held in a
-`gsl_multimin_fdfminimizer' struct or a `gsl_multimin_fminimizer'
+'gsl_multimin_fdfminimizer' struct or a 'gsl_multimin_fminimizer'
 struct.
 
 
@@ -6821,44 +6750,43 @@ minimizer itself depends only on the dimension of the problem and the
 algorithm and can be reused for different problems.
 
  -- Function: gsl_multimin_fdfminimizer *
-gsl_multimin_fdfminimizer_alloc (const gsl_multimin_fdfminimizer_type *
-          T, size_t N)
+          gsl_multimin_fdfminimizer_alloc (const
+          gsl_multimin_fdfminimizer_type * T, size_t N)
  -- Function: gsl_multimin_fminimizer * gsl_multimin_fminimizer_alloc
           (const gsl_multimin_fminimizer_type * T, size_t N)
      This function returns a pointer to a newly allocated instance of a
      minimizer of type T for an N-dimension function.  If there is
      insufficient memory to create the minimizer then the function
      returns a null pointer and the error handler is invoked with an
-     error code of `GSL_ENOMEM'.
+     error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_multimin_fdfminimizer_set
           (gsl_multimin_fdfminimizer * S, gsl_multimin_function_fdf *
           FDF, const gsl_vector * X, double STEP_SIZE, double TOL)
      This function initializes the minimizer S to minimize the function
-     FDF starting from the initial point X.  The size of the first
-     trial step is given by STEP_SIZE.  The accuracy of the line
-     minimization is specified by TOL.  The precise meaning of this
-     parameter depends on the method used.  Typically the line
-     minimization is considered successful if the gradient of the
-     function g is orthogonal to the current search direction p to a
-     relative accuracy of TOL, where dot(p,g) < tol |p| |g|.  A TOL
-     value of 0.1 is suitable for most purposes, since line
-     minimization only needs to be carried out approximately.    Note
-     that setting TOL to zero will force the use of "exact"
-     line-searches, which are extremely expensive.
-
- -- Function: int gsl_multimin_fminimizer_set (gsl_multimin_fminimizer
-          * S, gsl_multimin_function * F, const gsl_vector * X, const
-          gsl_vector * STEP_SIZE)
-     This function initializes the minimizer S to minimize the function
-     F, starting from the initial point X. The size of the initial
-     trial steps is given in vector STEP_SIZE. The precise meaning of
-     this parameter depends on the method used.
+     FDF starting from the initial point X.  The size of the first trial
+     step is given by STEP_SIZE.  The accuracy of the line minimization
+     is specified by TOL.  The precise meaning of this parameter depends
+     on the method used.  Typically the line minimization is considered
+     successful if the gradient of the function g is orthogonal to the
+     current search direction p to a relative accuracy of TOL, where
+     dot(p,g) < tol |p| |g|.  A TOL value of 0.1 is suitable for most
+     purposes, since line minimization only needs to be carried out
+     approximately.  Note that setting TOL to zero will force the use of
+     "exact" line-searches, which are extremely expensive.
+
+     The function int gsl_multimin_fminimizer_set
+     (gsl_multimin_fminimizer * S, gsl_multimin_function * F, const
+     gsl_vector * X, const gsl_vector * STEP_SIZE) This function
+     initializes the minimizer S to minimize the function F, starting
+     from the initial point X.  The size of the initial trial steps is
+     given in vector STEP_SIZE.  The precise meaning of this parameter
+     depends on the method used.
 
  -- Function: void gsl_multimin_fdfminimizer_free
           (gsl_multimin_fdfminimizer * S)
- -- Function: void gsl_multimin_fminimizer_free
-          (gsl_multimin_fminimizer * S)
+ -- Function: void gsl_multimin_fminimizer_free (gsl_multimin_fminimizer
+          * S)
      This function frees all the memory associated with the minimizer S.
 
  -- Function: const char * gsl_multimin_fdfminimizer_name (const
@@ -6871,7 +6799,7 @@ gsl_multimin_fdfminimizer_alloc (const gsl_multimin_fdfminimizer_type *
           printf ("s is a '%s' minimizer\n",
                   gsl_multimin_fdfminimizer_name (s));
 
-     would print something like `s is a 'conjugate_pr' minimizer'.
+     would print something like 's is a 'conjugate_pr' minimizer'.
 
 
 File: gsl-ref.info,  Node: Providing a function to minimize,  Next: Multimin Iteration,  Prev: Initializing the Multidimensional Minimizer,  Up: Multidimensional Minimization
@@ -6879,54 +6807,53 @@ File: gsl-ref.info,  Node: Providing a function to minimize,  Next: Multimin Ite
 35.4 Providing a function to minimize
 =====================================
 
-You must provide a parametric function of n variables for the
-minimizers to operate on.  You may also need to provide a routine which
-calculates the gradient of the function and a third routine which
-calculates both the function value and the gradient together.  In order
-to allow for general parameters the functions are defined by the
-following data types:
+You must provide a parametric function of n variables for the minimizers
+to operate on.  You may also need to provide a routine which calculates
+the gradient of the function and a third routine which calculates both
+the function value and the gradient together.  In order to allow for
+general parameters the functions are defined by the following data
+types:
 
  -- Data Type: gsl_multimin_function_fdf
      This data type defines a general function of n variables with
      parameters and the corresponding gradient vector of derivatives,
 
-    `double (* f) (const gsl_vector * X, void * PARAMS)'
+     'double (* f) (const gsl_vector * X, void * PARAMS)'
           this function should return the result f(x,params) for
           argument X and parameters PARAMS.
 
-    `void (* df) (const gsl_vector * X, void * PARAMS, gsl_vector * G)'
+     'void (* df) (const gsl_vector * X, void * PARAMS, gsl_vector * G)'
           this function should store the N-dimensional gradient g_i = d
           f(x,params) / d x_i in the vector G for argument X and
           parameters PARAMS, returning an appropriate error code if the
           function cannot be computed.
 
-    `void (* fdf) (const gsl_vector * X, void * PARAMS, double * f, gsl_vector * G)'
+     'void (* fdf) (const gsl_vector * X, void * PARAMS, double * f, gsl_vector * G)'
           This function should set the values of the F and G as above,
-          for arguments X and parameters PARAMS.  This function
-          provides an optimization of the separate functions for f(x)
-          and g(x)--it is always faster to compute the function and its
+          for arguments X and parameters PARAMS.  This function provides
+          an optimization of the separate functions for f(x) and
+          g(x)--it is always faster to compute the function and its
           derivative at the same time.
 
-    `size_t n'
-          the dimension of the system, i.e. the number of components of
+     'size_t n'
+          the dimension of the system, i.e.  the number of components of
           the vectors X.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function.
-
  -- Data Type: gsl_multimin_function
      This data type defines a general function of n variables with
      parameters,
 
-    `double (* f) (const gsl_vector * X, void * PARAMS)'
+     'double (* f) (const gsl_vector * X, void * PARAMS)'
           this function should return the result f(x,params) for
           argument X and parameters PARAMS.
 
-    `size_t n'
-          the dimension of the system, i.e. the number of components of
+     'size_t n'
+          the dimension of the system, i.e.  the number of components of
           the vectors X.
 
-    `void * params'
+     'void * params'
           a pointer to the parameters of the function.
 
 The following example function defines a simple paraboloid with two
@@ -7018,10 +6945,9 @@ functions,
           gsl_multimin_fdfminimizer * S)
  -- Function: double gsl_multimin_fminimizer_size (const
           gsl_multimin_fminimizer * S)
-     These functions return the current best estimate of the location
-     of the minimum, the value of the function at that point, its
-     gradient, and minimizer specific characteristic size for the
-     minimizer S.
+     These functions return the current best estimate of the location of
+     the minimum, the value of the function at that point, its gradient,
+     and minimizer specific characteristic size for the minimizer S.
 
  -- Function: int gsl_multimin_fdfminimizer_restart
           (gsl_multimin_fdfminimizer * S)
@@ -7048,14 +6974,14 @@ below allow the user to test the precision of the current result.
 
  -- Function: int gsl_multimin_test_gradient (const gsl_vector * G,
           double EPSABS)
-     This function tests the norm of the gradient G against the
-     absolute tolerance EPSABS. The gradient of a multidimensional
-     function goes to zero at a minimum. The test returns `GSL_SUCCESS'
-     if the following condition is achieved,
+     This function tests the norm of the gradient G against the absolute
+     tolerance EPSABS.  The gradient of a multidimensional function goes
+     to zero at a minimum.  The test returns 'GSL_SUCCESS' if the
+     following condition is achieved,
 
           |g| < epsabs
 
-     and returns `GSL_CONTINUE' otherwise.  A suitable choice of EPSABS
+     and returns 'GSL_CONTINUE' otherwise.  A suitable choice of EPSABS
      can be made from the desired accuracy in the function for small
      variations in x.  The relationship between these quantities is
      given by \delta f = g \delta x.
@@ -7064,8 +6990,8 @@ below allow the user to test the precision of the current result.
           EPSABS)
      This function tests the minimizer specific characteristic size (if
      applicable to the used minimizer) against absolute tolerance
-     EPSABS.  The test returns `GSL_SUCCESS' if the size is smaller
-     than tolerance, otherwise `GSL_CONTINUE' is returned.
+     EPSABS.  The test returns 'GSL_SUCCESS' if the size is smaller than
+     tolerance, otherwise 'GSL_CONTINUE' is returned.
 
 
 File: gsl-ref.info,  Node: Multimin Algorithms,  Next: Multimin Examples,  Prev: Multimin Stopping Criteria,  Up: Multidimensional Minimization
@@ -7073,59 +6999,58 @@ File: gsl-ref.info,  Node: Multimin Algorithms,  Next: Multimin Examples,  Prev:
 35.7 Algorithms
 ===============
 
-There are several minimization methods available. The best choice of
+There are several minimization methods available.  The best choice of
 algorithm depends on the problem.  All of the algorithms use the value
 of the function and its gradient at each evaluation point, except for
 the Simplex algorithm which uses function values only.
 
  -- Minimizer: gsl_multimin_fdfminimizer_conjugate_fr
-     This is the Fletcher-Reeves conjugate gradient algorithm. The
+     This is the Fletcher-Reeves conjugate gradient algorithm.  The
      conjugate gradient algorithm proceeds as a succession of line
-     minimizations. The sequence of search directions is used to build
+     minimizations.  The sequence of search directions is used to build
      up an approximation to the curvature of the function in the
      neighborhood of the minimum.
 
      An initial search direction P is chosen using the gradient, and
      line minimization is carried out in that direction.  The accuracy
      of the line minimization is specified by the parameter TOL.  The
-     minimum along this line occurs when the function gradient G and
-     the search direction P are orthogonal.  The line minimization
+     minimum along this line occurs when the function gradient G and the
+     search direction P are orthogonal.  The line minimization
      terminates when dot(p,g) < tol |p| |g|.  The search direction is
-     updated  using the Fletcher-Reeves formula p' = g' - \beta g where
-     \beta=-|g'|^2/|g|^2, and the line minimization is then repeated
-     for the new search direction.
+     updated using the Fletcher-Reeves formula p' = g' - \beta g where
+     \beta=-|g'|^2/|g|^2, and the line minimization is then repeated for
+     the new search direction.
 
  -- Minimizer: gsl_multimin_fdfminimizer_conjugate_pr
      This is the Polak-Ribiere conjugate gradient algorithm.  It is
-     similar to the Fletcher-Reeves method, differing only in the
-     choice of the coefficient \beta. Both methods work well when the
+     similar to the Fletcher-Reeves method, differing only in the choice
+     of the coefficient \beta.  Both methods work well when the
      evaluation point is close enough to the minimum of the objective
      function that it is well approximated by a quadratic hypersurface.
 
  -- Minimizer: gsl_multimin_fdfminimizer_vector_bfgs2
  -- Minimizer: gsl_multimin_fdfminimizer_vector_bfgs
      These methods use the vector Broyden-Fletcher-Goldfarb-Shanno
-     (BFGS) algorithm.  This is a quasi-Newton method which builds up
-     an approximation to the second derivatives of the function f using
-     the difference between successive gradient vectors.  By combining
-     the first and second derivatives the algorithm is able to take
+     (BFGS) algorithm.  This is a quasi-Newton method which builds up an
+     approximation to the second derivatives of the function f using the
+     difference between successive gradient vectors.  By combining the
+     first and second derivatives the algorithm is able to take
      Newton-type steps towards the function minimum, assuming quadratic
      behavior in that region.
 
-     The `bfgs2' version of this minimizer is the most efficient
-     version available, and is a faithful implementation of the line
-     minimization scheme described in Fletcher's `Practical Methods of
+     The 'bfgs2' version of this minimizer is the most efficient version
+     available, and is a faithful implementation of the line
+     minimization scheme described in Fletcher's 'Practical Methods of
      Optimization', Algorithms 2.6.2 and 2.6.4.  It supercedes the
-     original `bfgs' routine and requires substantially fewer function
+     original 'bfgs' routine and requires substantially fewer function
      and gradient evaluations.  The user-supplied tolerance TOL
      corresponds to the parameter \sigma used by Fletcher.  A value of
      0.1 is recommended for typical use (larger values correspond to
      less accurate line searches).
 
-
  -- Minimizer: gsl_multimin_fdfminimizer_steepest_descent
      The steepest descent algorithm follows the downhill gradient of the
-     function at each step. When a downhill step is successful the
+     function at each step.  When a downhill step is successful the
      step-size is increased by a factor of two.  If the downhill step
      leads to a higher function value then the algorithm backtracks and
      the step size is decreased using the parameter TOL.  A suitable
@@ -7134,7 +7059,7 @@ the Simplex algorithm which uses function values only.
      purposes.
 
  -- Minimizer: gsl_multimin_fminimizer_nmsimplex
-     This is the Simplex algorithm of Nelder and Mead. It constructs n
+     This is the Simplex algorithm of Nelder and Mead.  It constructs n
      vectors p_i from the starting vector X and the vector STEP_SIZE as
      follows:
 
@@ -7148,9 +7073,9 @@ the Simplex algorithm which uses function values only.
      On each iteration the algorithm tries to improve the parameter
      vector p_i corresponding to the highest function value by simple
      geometrical transformations.  These are reflection, reflection
-     followed by expansion, contraction and multiple contraction. Using
-     these transformations the simplex moves through the parameter
-     space towards the minimum, where it contracts itself.
+     followed by expansion, contraction and multiple contraction.  Using
+     these transformations the simplex moves through the parameter space
+     towards the minimum, where it contracts itself.
 
      After each iteration, the best vertex is returned.  Note, that due
      to the nature of the algorithm not every step improves the current
@@ -7158,9 +7083,9 @@ the Simplex algorithm which uses function values only.
 
      The routine calculates the minimizer specific characteristic size
      as the average distance from the geometrical center of the simplex
-     to all its vertices.  This size can be used as a stopping
-     criteria, as the simplex contracts itself near the minimum. The
-     size is returned by the function `gsl_multimin_fminimizer_size'.
+     to all its vertices.  This size can be used as a stopping criteria,
+     as the simplex contracts itself near the minimum.  The size is
+     returned by the function 'gsl_multimin_fminimizer_size'.
 
 
 File: gsl-ref.info,  Node: Multimin Examples,  Next: Multimin References and Further Reading,  Prev: Multimin Algorithms,  Up: Multidimensional Minimization
@@ -7170,7 +7095,7 @@ File: gsl-ref.info,  Node: Multimin Examples,  Next: Multimin References and Fur
 
 This example program finds the minimum of the paraboloid function
 defined earlier.  The location of the minimum is offset from the origin
-in x and y, and the function value at the minimum is non-zero. The main
+in x and y, and the function value at the minimum is non-zero.  The main
 program is given below, it requires the example function given earlier
 in this chapter.
 
@@ -7258,7 +7183,7 @@ successfully moves downhill, as can be seen by plotting the successive
 points.
 
 The conjugate gradient algorithm finds the minimum on its second
-direction because the function is purely quadratic. Additional
+direction because the function is purely quadratic.  Additional
 iterations would be needed for a more complicated function.
 
    Here is another example using the Nelder-Mead Simplex algorithm to
@@ -7332,7 +7257,7 @@ minimize the same example object function, as above.
        return status;
      }
 
-The minimum search stops when the Simplex size drops to 0.01. The
+The minimum search stops when the Simplex size drops to 0.01.  The
 output is shown below.
 
          1  6.500e+00  5.000e+00 f() = 512.500 size = 1.082
@@ -7363,7 +7288,7 @@ output is shown below.
         25  1.007e+00  2.003e+00 f() = 30.001  size = 0.010
 
 The simplex size first increases, while the simplex moves towards the
-minimum. After a while the size begins to decrease as the simplex
+minimum.  After a while the size begins to decrease as the simplex
 contracts around the minimum.
 
 
@@ -7375,22 +7300,21 @@ File: gsl-ref.info,  Node: Multimin References and Further Reading,  Prev: Multi
 The conjugate gradient and BFGS methods are described in detail in the
 following book,
 
-     R. Fletcher, `Practical Methods of Optimization (Second Edition)'
+     R. Fletcher, 'Practical Methods of Optimization (Second Edition)'
      Wiley (1987), ISBN 0471915475.
 
    A brief description of multidimensional minimization algorithms and
 more recent references can be found in,
 
-     C.W. Ueberhuber, `Numerical Computation (Volume 2)', Chapter 14,
+     C.W. Ueberhuber, 'Numerical Computation (Volume 2)', Chapter 14,
      Section 4.4 "Minimization Methods", p. 325-335, Springer (1997),
      ISBN 3-540-62057-5.
 
 The simplex algorithm is described in the following paper,
 
-     J.A. Nelder and R. Mead, `A simplex method for function
+     J.A. Nelder and R. Mead, 'A simplex method for function
      minimization', Computer Journal vol. 7 (1965), 308-315.
 
-
 
 File: gsl-ref.info,  Node: Least-Squares Fitting,  Next: Nonlinear Least-Squares Fitting,  Prev: Multidimensional Minimization,  Up: Top
 
@@ -7399,24 +7323,24 @@ File: gsl-ref.info,  Node: Least-Squares Fitting,  Next: Nonlinear Least-Squares
 
 This chapter describes routines for performing least squares fits to
 experimental data using linear combinations of functions.  The data may
-be weighted or unweighted, i.e. with known or unknown errors.  For
+be weighted or unweighted, i.e.  with known or unknown errors.  For
 weighted data the functions compute the best fit parameters and their
-associated covariance matrix.  For unweighted data the covariance
-matrix is estimated from the scatter of the points, giving a
+associated covariance matrix.  For unweighted data the covariance matrix
+is estimated from the scatter of the points, giving a
 variance-covariance matrix.
 
    The functions are divided into separate versions for simple one- or
-two-parameter regression and multiple-parameter fits.  The functions
-are declared in the header file `gsl_fit.h'.
+two-parameter regression and multiple-parameter fits.  The functions are
+declared in the header file 'gsl_fit.h'.
 
 * Menu:
 
-* Fitting Overview::
-* Linear regression::
-* Linear fitting without a constant term::
-* Multi-parameter fitting::
-* Fitting Examples::
-* Fitting References and Further Reading::
+* Fitting Overview::            
+* Linear regression::           
+* Linear fitting without a constant term::  
+* Multi-parameter fitting::     
+* Fitting Examples::            
+* Fitting References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Fitting Overview,  Next: Linear regression,  Up: Least-Squares Fitting
@@ -7460,12 +7384,12 @@ corresponding parameter covariance matrix of
 
      C_{ab} = \sum_i (1/w_i) (dc_a/dy_i) (dc_b/dy_i)
 
-When computing the covariance matrix for unweighted data, i.e. data
+When computing the covariance matrix for unweighted data, i.e.  data
 with unknown errors, the weight factors w_i in this sum are replaced by
 the single estimate w = 1/\sigma^2, where \sigma^2 is the computed
-variance of the residuals about the best-fit model, \sigma^2 = \sum
-(y_i - Y(c,x_i))^2 / (n-p).  This is referred to as the
-"variance-covariance matrix".  
+variance of the residuals about the best-fit model, \sigma^2 = \sum (y_i
+- Y(c,x_i))^2 / (n-p).  This is referred to as the "variance-covariance
+matrix".
 
    The standard deviations of the best-fit parameters are given by the
 square root of the corresponding diagonal elements of the covariance
@@ -7495,26 +7419,26 @@ least-squares fits to a straight line model, Y(c,x) = c_0 + c_1 x.
 
  -- Function: int gsl_fit_wlinear (const double * X, const size_t
           XSTRIDE, const double * W, const size_t WSTRIDE, const double
-          * Y, const size_t YSTRIDE, size_t N, double * C0, double *
-          C1, double * COV00, double * COV01, double * COV11, double *
+          * Y, const size_t YSTRIDE, size_t N, double * C0, double * C1,
+          double * COV00, double * COV01, double * COV11, double *
           CHISQ)
      This function computes the best-fit linear regression coefficients
      (C0,C1) of the model Y = c_0 + c_1 X for the weighted dataset (X,
      Y), two vectors of length N with strides XSTRIDE and YSTRIDE.  The
      vector W, of length N and stride WSTRIDE, specifies the weight of
-     each datapoint. The weight is the reciprocal of the variance for
+     each datapoint.  The weight is the reciprocal of the variance for
      each datapoint in Y.
 
-     The covariance matrix for the parameters (C0, C1) is computed
-     using the weights and returned via the parameters (COV00, COV01,
-     COV11).  The weighted sum of squares of the residuals from the
-     best-fit line, \chi^2, is returned in CHISQ.
+     The covariance matrix for the parameters (C0, C1) is computed using
+     the weights and returned via the parameters (COV00, COV01, COV11).
+     The weighted sum of squares of the residuals from the best-fit
+     line, \chi^2, is returned in CHISQ.
 
  -- Function: int gsl_fit_linear_est (double X, double C0, double C1,
           double C00, double C01, double C11, double * Y, double *
           Y_ERR)
      This function uses the best-fit linear regression coefficients
      C0,C1 and their covariance COV00,COV01,COV11 to compute the fitted
-     function Y and its standard deviation Y_ERR for the model Y = c_0
-     + c_1 X at the point X.
+     function Y and its standard deviation Y_ERR for the model Y = c_0 +
+     c_1 X at the point X.
 
diff --git a/gsl-1.9/doc/gsl-ref.info-4 b/gsl-1.9/doc/gsl-ref.info-4
index cedfd25..10a1176 100644
--- a/gsl-1.9/doc/gsl-ref.info-4
+++ b/gsl-1.9/doc/gsl-ref.info-4
@@ -1,12 +1,7 @@
-This is gsl-ref.info, produced by makeinfo version 4.8 from
+This is gsl-ref.info, produced by makeinfo version 5.1 from
 gsl-ref.texi.
 
-INFO-DIR-SECTION Scientific software
-START-INFO-DIR-ENTRY
-* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
-END-INFO-DIR-ENTRY
-
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 2005, 2006, 2007 The GSL Team.
 
    Permission is granted to copy, distribute and/or modify this document
@@ -20,6 +15,10 @@ License".
 
    (a) The Back-Cover Text is: "You have freedom to copy and modify this
 GNU Manual, like GNU software."
+INFO-DIR-SECTION Scientific software
+START-INFO-DIR-ENTRY
+* gsl-ref: (gsl-ref).                   GNU Scientific Library - Reference
+END-INFO-DIR-ENTRY
 
 
 File: gsl-ref.info,  Node: Linear fitting without a constant term,  Next: Multi-parameter fitting,  Prev: Linear regression,  Up: Least-Squares Fitting
@@ -28,12 +27,12 @@ File: gsl-ref.info,  Node: Linear fitting without a constant term,  Next: Multi-
 ===========================================
 
 The functions described in this section can be used to perform
-least-squares fits to a straight line model without a constant term, Y
-= c_1 X.
+least-squares fits to a straight line model without a constant term, Y =
+c_1 X.
 
  -- Function: int gsl_fit_mul (const double * X, const size_t XSTRIDE,
-          const double * Y, const size_t YSTRIDE, size_t N, double *
-          C1, double * COV11, double * SUMSQ)
+          const double * Y, const size_t YSTRIDE, size_t N, double * C1,
+          double * COV11, double * SUMSQ)
      This function computes the best-fit linear regression coefficient
      C1 of the model Y = c_1 X for the datasets (X, Y), two vectors of
      length N with strides XSTRIDE and YSTRIDE.  The errors on Y are
@@ -50,7 +49,7 @@ least-squares fits to a straight line model without a constant term, Y
      C1 of the model Y = c_1 X for the weighted datasets (X, Y), two
      vectors of length N with strides XSTRIDE and YSTRIDE.  The vector
      W, of length N and stride WSTRIDE, specifies the weight of each
-     datapoint. The weight is the reciprocal of the variance for each
+     datapoint.  The weight is the reciprocal of the variance for each
      datapoint in Y.
 
      The variance of the parameter C1 is computed using the weights and
@@ -73,8 +72,8 @@ The functions described in this section perform least-squares fits to a
 general linear model, y = X c where y is a vector of n observations, X
 is an n by p matrix of predictor variables, and the elements of the
 vector c are the p unknown best-fit parameters which are to be
-estimated.  The chi-squared value is given by \chi^2 = \sum_i w_i (y_i
-- \sum_j X_{ij} c_j)^2.
+estimated.  The chi-squared value is given by \chi^2 = \sum_i w_i (y_i -
+\sum_j X_{ij} c_j)^2.
 
    This formulation can be used for fits to any number of functions
 and/or variables by preparing the n-by-p matrix X appropriately.  For
@@ -83,8 +82,8 @@ matrix,
 
      X_{ij} = x_i^j
 
-where the index i runs over the observations and the index j runs from
-0 to p-1.
+where the index i runs over the observations and the index j runs from 0
+to p-1.
 
    To fit to a set of p sinusoidal functions with fixed frequencies
 \omega_1, \omega_2, ..., \omega_p, use,
@@ -98,7 +97,7 @@ To fit to p independent variables x_1, x_2, ..., x_p, use,
 where x_j(i) is the i-th value of the predictor variable x_j.
 
    The functions described in this section are declared in the header
-file `gsl_multifit.h'.
+file 'gsl_multifit.h'.
 
    The solution of the general linear least-squares system requires an
 additional working space for intermediate results, such as the singular
@@ -121,21 +120,21 @@ value decomposition of the matrix X.
           gsl_matrix * COV, double * CHISQ,
           gsl_multifit_linear_workspace * WORK)
      These functions compute the best-fit parameters C of the model y =
-     X c for the observations Y and the matrix of predictor variables
-     X.  The variance-covariance matrix of the model parameters COV is
+     X c for the observations Y and the matrix of predictor variables X.
+     The variance-covariance matrix of the model parameters COV is
      estimated from the scatter of the observations about the best-fit.
      The sum of squares of the residuals from the best-fit, \chi^2, is
      returned in CHISQ.
 
      The best-fit is found by singular value decomposition of the matrix
-     X using the preallocated workspace provided in WORK. The modified
-     Golub-Reinsch SVD algorithm is used, with column scaling to
-     improve the accuracy of the singular values. Any components which
-     have zero singular value (to machine precision) are discarded from
-     the fit.  In the second form of the function the components are
+     X using the preallocated workspace provided in WORK.  The modified
+     Golub-Reinsch SVD algorithm is used, with column scaling to improve
+     the accuracy of the singular values.  Any components which have
+     zero singular value (to machine precision) are discarded from the
+     fit.  In the second form of the function the components are
      discarded if the ratio of singular values s_i/s_0 falls below the
-     user-specified tolerance TOL, and the effective rank is returned
-     in RANK.
+     user-specified tolerance TOL, and the effective rank is returned in
+     RANK.
 
  -- Function: int gsl_multifit_wlinear (const gsl_matrix * X, const
           gsl_vector * W, const gsl_vector * Y, gsl_vector * C,
@@ -145,6 +144,7 @@ value decomposition of the matrix X.
           gsl_vector * W, const gsl_vector * Y, double TOL, size_t *
           RANK, gsl_vector * C, gsl_matrix * COV, double * CHISQ,
           gsl_multifit_linear_workspace * WORK)
+
      This function computes the best-fit parameters C of the weighted
      model y = X c for the observations Y with weights W and the matrix
      of predictor variables X.  The covariance matrix of the model
@@ -153,7 +153,7 @@ value decomposition of the matrix X.
      returned in CHISQ.
 
      The best-fit is found by singular value decomposition of the matrix
-     X using the preallocated workspace provided in WORK. Any
+     X using the preallocated workspace provided in WORK.  Any
      components which have zero singular value (to machine precision)
      are discarded from the fit.  In the second form of the function the
      components are discarded if the ratio of singular values s_i/s_0
@@ -225,7 +225,7 @@ standard-deviation error bars.
      }
 
 The following commands extract the data from the output of the program
-and display it using the GNU plotutils `graph' utility,
+and display it using the GNU plotutils 'graph' utility,
 
      $ ./demo > tmp
      $ more tmp
@@ -244,8 +244,8 @@ and display it using the GNU plotutils `graph' utility,
 
    The next program performs a quadratic fit y = c_0 + c_1 x + c_2 x^2
 to a weighted dataset using the generalised linear fitting function
-`gsl_multifit_wlinear'.  The model matrix X for a quadratic fit is
-given by,
+'gsl_multifit_wlinear'.  The model matrix X for a quadratic fit is given
+by,
 
      X = [ 1   , x_0  , x_0^2 ;
            1   , x_1  , x_1^2 ;
@@ -255,8 +255,8 @@ given by,
 where the column of ones corresponds to the constant term c_0.  The two
 remaining columns corresponds to the terms c_1 x and c_2 x^2.
 
-   The program reads N lines of data in the format (X, Y, ERR) where
-ERR is the error (standard deviation) in the value Y.
+   The program reads N lines of data in the format (X, Y, ERR) where ERR
+is the error (standard deviation) in the value Y.
 
      #include <stdio.h>
      #include <gsl/gsl_multifit.h>
@@ -403,9 +403,9 @@ The parameters of the quadratic fit match the coefficients of the
 expansion of e^x, taking into account the errors on the parameters and
 the O(x^3) difference between the exponential and quadratic functions
 for the larger values of x.  The errors on the parameters are given by
-the square-root of the corresponding diagonal elements of the
-covariance matrix.  The chi-squared per degree of freedom is 1.4,
-indicating a reasonable fit to the data.
+the square-root of the corresponding diagonal elements of the covariance
+matrix.  The chi-squared per degree of freedom is 1.4, indicating a
+reasonable fit to the data.
 
 
 File: gsl-ref.info,  Node: Fitting References and Further Reading,  Prev: Fitting Examples,  Up: Least-Squares Fitting
@@ -417,17 +417,17 @@ A summary of formulas and techniques for least squares fitting can be
 found in the "Statistics" chapter of the Annual Review of Particle
 Physics prepared by the Particle Data Group,
 
-     `Review of Particle Properties', R.M. Barnett et al., Physical
-     Review D54, 1 (1996) `http://pdg.lbl.gov/'
+     'Review of Particle Properties', R.M. Barnett et al., Physical
+     Review D54, 1 (1996) <http://pdg.lbl.gov/>
 
 The Review of Particle Physics is available online at the website given
 above.
 
    The tests used to prepare these routines are based on the NIST
-Statistical Reference Datasets. The datasets and their documentation are
-available from NIST at the following website,
+Statistical Reference Datasets.  The datasets and their documentation
+are available from NIST at the following website,
 
-           `http://www.nist.gov/itl/div898/strd/index.html'.
+           <http://www.nist.gov/itl/div898/strd/index.html>.
 
 
 File: gsl-ref.info,  Node: Nonlinear Least-Squares Fitting,  Next: Basis Splines,  Prev: Least-Squares Fitting,  Up: Top
@@ -445,21 +445,21 @@ without needing to recompile your program.  Each instance of a solver
 keeps track of its own state, allowing the solvers to be used in
 multi-threaded programs.
 
-   The header file `gsl_multifit_nlin.h' contains prototypes for the
+   The header file 'gsl_multifit_nlin.h' contains prototypes for the
 multidimensional nonlinear fitting functions and related declarations.
 
 * Menu:
 
-* Overview of Nonlinear Least-Squares Fitting::
-* Initializing the Nonlinear Least-Squares Solver::
-* Providing the Function to be Minimized::
-* Iteration of the Minimization Algorithm::
-* Search Stopping Parameters for Minimization Algorithms::
-* Minimization Algorithms using Derivatives::
-* Minimization Algorithms without Derivatives::
-* Computing the covariance matrix of best fit parameters::
-* Example programs for Nonlinear Least-Squares Fitting::
-* References and Further Reading for Nonlinear Least-Squares Fitting::
+* Overview of Nonlinear Least-Squares Fitting::  
+* Initializing the Nonlinear Least-Squares Solver::  
+* Providing the Function to be Minimized::  
+* Iteration of the Minimization Algorithm::  
+* Search Stopping Parameters for Minimization Algorithms::  
+* Minimization Algorithms using Derivatives::  
+* Minimization Algorithms without Derivatives::  
+* Computing the covariance matrix of best fit parameters::  
+* Example programs for Nonlinear Least-Squares Fitting::  
+* References and Further Reading for Nonlinear Least-Squares Fitting::  
 
 
 File: gsl-ref.info,  Node: Overview of Nonlinear Least-Squares Fitting,  Next: Initializing the Nonlinear Least-Squares Solver,  Up: Nonlinear Least-Squares Fitting
@@ -481,8 +481,8 @@ All algorithms proceed from an initial guess using the linearization,
 where x is the initial point, p is the proposed step and J is the
 Jacobian matrix J_{ij} = d f_i / d x_j.  Additional strategies are used
 to enlarge the region of convergence.  These include requiring a
-decrease in the norm ||F|| on each step or using a trust region to
-avoid steps which fall outside the linear regime.
+decrease in the norm ||F|| on each step or using a trust region to avoid
+steps which fall outside the linear regime.
 
    To perform a weighted least-squares fit of a nonlinear model Y(x,t)
 to data (t_i, y_i) with independent gaussian errors \sigma_i, use
@@ -492,10 +492,10 @@ function components of the following form,
 
 Note that the model parameters are denoted by x in this chapter since
 the non-linear least-squares algorithms are described geometrically
-(i.e. finding the minimum of a surface).  The independent variable of
+(i.e.  finding the minimum of a surface).  The independent variable of
 any data to be fitted is denoted by t.
 
-   With the definition above the Jacobian is J_{ij} =(1 / \sigma_i)  d
+   With the definition above the Jacobian is J_{ij} =(1 / \sigma_i) d
 Y_i / d x_j, where Y_i = Y(x,t_i).
 
 
@@ -512,7 +512,7 @@ File: gsl-ref.info,  Node: Initializing the Nonlinear Least-Squares Solver,  Nex
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: gsl_multifit_fdfsolver * gsl_multifit_fdfsolver_alloc
           (const gsl_multifit_fdfsolver_type * T, size_t N, size_t P)
@@ -531,7 +531,7 @@ File: gsl-ref.info,  Node: Initializing the Nonlinear Least-Squares Solver,  Nex
 
      If there is insufficient memory to create the solver then the
      function returns a null pointer and the error handler is invoked
-     with an error code of `GSL_ENOMEM'.
+     with an error code of 'GSL_ENOMEM'.
 
  -- Function: int gsl_multifit_fsolver_set (gsl_multifit_fsolver * S,
           gsl_multifit_function * F, gsl_vector * X)
@@ -544,8 +544,8 @@ File: gsl-ref.info,  Node: Initializing the Nonlinear Least-Squares Solver,  Nex
      to use the function and derivative FDF and the initial guess X.
 
  -- Function: void gsl_multifit_fsolver_free (gsl_multifit_fsolver * S)
- -- Function: void gsl_multifit_fdfsolver_free (gsl_multifit_fdfsolver
-          * S)
+ -- Function: void gsl_multifit_fdfsolver_free (gsl_multifit_fdfsolver *
+          S)
      These functions free all the memory associated with the solver S.
 
  -- Function: const char * gsl_multifit_fsolver_name (const
@@ -558,7 +558,7 @@ File: gsl-ref.info,  Node: Initializing the Nonlinear Least-Squares Solver,  Nex
           printf ("s is a '%s' solver\n",
                   gsl_multifit_fdfsolver_name (s));
 
-     would print something like `s is a 'lmder' solver'.
+     would print something like 's is a 'lmder' solver'.
 
 
 File: gsl-ref.info,  Node: Providing the Function to be Minimized,  Next: Iteration of the Minimization Algorithm,  Prev: Initializing the Nonlinear Least-Squares Solver,  Up: Nonlinear Least-Squares Fitting
@@ -571,57 +571,56 @@ algorithms to operate on.  In order to allow for arbitrary parameters
 the functions are defined by the following data types:
 
  -- Data Type: gsl_multifit_function
-     This data type defines a general system of functions with
-     arbitrary parameters.
+     This data type defines a general system of functions with arbitrary
+     parameters.
 
-    `int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
+     'int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
           this function should store the vector result f(x,params) in F
           for argument X and arbitrary parameters PARAMS, returning an
           appropriate error code if the function cannot be computed.
 
-    `size_t n'
-          the number of functions, i.e. the number of components of the
+     'size_t n'
+          the number of functions, i.e.  the number of components of the
           vector F.
 
-    `size_t p'
-          the number of independent variables, i.e. the number of
+     'size_t p'
+          the number of independent variables, i.e.  the number of
           components of the vector X.
 
-    `void * params'
+     'void * params'
           a pointer to the arbitrary parameters of the function.
 
  -- Data Type: gsl_multifit_function_fdf
-     This data type defines a general system of functions with
-     arbitrary parameters and the corresponding Jacobian matrix of
-     derivatives,
+     This data type defines a general system of functions with arbitrary
+     parameters and the corresponding Jacobian matrix of derivatives,
 
-    `int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
+     'int (* f) (const gsl_vector * X, void * PARAMS, gsl_vector * F)'
           this function should store the vector result f(x,params) in F
           for argument X and arbitrary parameters PARAMS, returning an
           appropriate error code if the function cannot be computed.
 
-    `int (* df) (const gsl_vector * X, void * PARAMS, gsl_matrix * J)'
+     'int (* df) (const gsl_vector * X, void * PARAMS, gsl_matrix * J)'
           this function should store the N-by-P matrix result J_ij = d
           f_i(x,params) / d x_j in J for argument X and arbitrary
           parameters PARAMS, returning an appropriate error code if the
           function cannot be computed.
 
-    `int (* fdf) (const gsl_vector * X, void * PARAMS, gsl_vector * F, gsl_matrix * J)'
+     'int (* fdf) (const gsl_vector * X, void * PARAMS, gsl_vector * F, gsl_matrix * J)'
           This function should set the values of the F and J as above,
           for arguments X and arbitrary parameters PARAMS.  This
           function provides an optimization of the separate functions
-          for f(x) and J(x)--it is always faster to compute the
-          function and its derivative at the same time.
+          for f(x) and J(x)--it is always faster to compute the function
+          and its derivative at the same time.
 
-    `size_t n'
-          the number of functions, i.e. the number of components of the
+     'size_t n'
+          the number of functions, i.e.  the number of components of the
           vector F.
 
-    `size_t p'
-          the number of independent variables, i.e. the number of
+     'size_t p'
+          the number of independent variables, i.e.  the number of
           components of the vector X.
 
-    `void * params'
+     'void * params'
           a pointer to the arbitrary parameters of the function.
 
    Note that when fitting a non-linear model against experimental data,
@@ -642,29 +641,29 @@ the code.
 
  -- Function: int gsl_multifit_fsolver_iterate (gsl_multifit_fsolver *
           S)
- -- Function: int gsl_multifit_fdfsolver_iterate
-          (gsl_multifit_fdfsolver * S)
-     These functions perform a single iteration of the solver S.  If
-     the iteration encounters an unexpected problem then an error code
-     will be returned.  The solver maintains a current estimate of the
+ -- Function: int gsl_multifit_fdfsolver_iterate (gsl_multifit_fdfsolver
+          * S)
+     These functions perform a single iteration of the solver S.  If the
+     iteration encounters an unexpected problem then an error code will
+     be returned.  The solver maintains a current estimate of the
      best-fit parameters at all times.
 
-   The solver struct S contains the following entries, which can be
-used to track the progress of the solution:
+   The solver struct S contains the following entries, which can be used
+to track the progress of the solution:
 
-`gsl_vector * x'
+'gsl_vector * x'
      The current position.
 
-`gsl_vector * f'
+'gsl_vector * f'
      The function value at the current position.
 
-`gsl_vector * dx'
+'gsl_vector * dx'
      The difference between the current position and the previous
-     position, i.e. the last step, taken as a vector.
+     position, i.e.  the last step, taken as a vector.
 
-`gsl_matrix * J'
+'gsl_matrix * J'
      The Jacobian matrix at the current position (for the
-     `gsl_multifit_fdfsolver' struct only)
+     'gsl_multifit_fdfsolver' struct only)
 
    The best-fit information also can be accessed with the following
 auxiliary functions,
@@ -673,8 +672,8 @@ auxiliary functions,
           gsl_multifit_fsolver * S)
  -- Function: gsl_vector * gsl_multifit_fdfsolver_position (const
           gsl_multifit_fdfsolver * S)
-     These functions return the current position (i.e. best-fit
-     parameters) `s->x' of the solver S.
+     These functions return the current position (i.e.  best-fit
+     parameters) 's->x' of the solver S.
 
 
 File: gsl-ref.info,  Node: Search Stopping Parameters for Minimization Algorithms,  Next: Minimization Algorithms using Derivatives,  Prev: Iteration of the Minimization Algorithm,  Up: Nonlinear Least-Squares Fitting
@@ -697,34 +696,35 @@ parameters in several standard ways.
 
  -- Function: int gsl_multifit_test_delta (const gsl_vector * DX, const
           gsl_vector * X, double EPSABS, double EPSREL)
+
      This function tests for the convergence of the sequence by
      comparing the last step DX with the absolute error EPSABS and
      relative error EPSREL to the current position X.  The test returns
-     `GSL_SUCCESS' if the following condition is achieved,
+     'GSL_SUCCESS' if the following condition is achieved,
 
           |dx_i| < epsabs + epsrel |x_i|
 
-     for each component of X and returns `GSL_CONTINUE' otherwise.
+     for each component of X and returns 'GSL_CONTINUE' otherwise.
 
  -- Function: int gsl_multifit_test_gradient (const gsl_vector * G,
           double EPSABS)
      This function tests the residual gradient G against the absolute
-     error bound EPSABS.  Mathematically, the gradient should be
-     exactly zero at the minimum. The test returns `GSL_SUCCESS' if the
+     error bound EPSABS.  Mathematically, the gradient should be exactly
+     zero at the minimum.  The test returns 'GSL_SUCCESS' if the
      following condition is achieved,
 
           \sum_i |g_i| < epsabs
 
-     and returns `GSL_CONTINUE' otherwise.  This criterion is suitable
+     and returns 'GSL_CONTINUE' otherwise.  This criterion is suitable
      for situations where the precise location of the minimum, x, is
      unimportant provided a value can be found where the gradient is
      small enough.
 
  -- Function: int gsl_multifit_gradient (const gsl_matrix * J, const
           gsl_vector * F, gsl_vector * G)
-     This function computes the gradient G of \Phi(x) = (1/2)
-     ||F(x)||^2 from the Jacobian matrix J and the function values F,
-     using the formula g = J^T f.
+     This function computes the gradient G of \Phi(x) = (1/2) ||F(x)||^2
+     from the Jacobian matrix J and the function values F, using the
+     formula g = J^T f.
 
 
 File: gsl-ref.info,  Node: Minimization Algorithms using Derivatives,  Next: Minimization Algorithms without Derivatives,  Prev: Search Stopping Parameters for Minimization Algorithms,  Up: Nonlinear Least-Squares Fitting
@@ -734,24 +734,24 @@ File: gsl-ref.info,  Node: Minimization Algorithms using Derivatives,  Next: Min
 
 The minimization algorithms described in this section make use of both
 the function and its derivative.  They require an initial guess for the
-location of the minimum. There is no absolute guarantee of
+location of the minimum.  There is no absolute guarantee of
 convergence--the function must be suitable for this technique and the
 initial guess must be sufficiently close to the minimum for it to work.
 
  -- Derivative Solver: gsl_multifit_fdfsolver_lmsder
      This is a robust and efficient version of the Levenberg-Marquardt
      algorithm as implemented in the scaled LMDER routine in MINPACK.
-     Minpack was written by Jorge J. More', Burton S. Garbow and
-     Kenneth E. Hillstrom.
+     Minpack was written by Jorge J. More', Burton S. Garbow and Kenneth
+     E. Hillstrom.
 
      The algorithm uses a generalized trust region to keep each step
      under control.  In order to be accepted a proposed new position x'
      must satisfy the condition |D (x' - x)| < \delta, where D is a
-     diagonal scaling matrix and \delta is the size of the trust
-     region.  The components of D are computed internally, using the
-     column norms of the Jacobian to estimate the sensitivity of the
-     residual to each component of x.  This improves the behavior of the
-     algorithm for badly scaled functions.
+     diagonal scaling matrix and \delta is the size of the trust region.
+     The components of D are computed internally, using the column norms
+     of the Jacobian to estimate the sensitivity of the residual to each
+     component of x.  This improves the behavior of the algorithm for
+     badly scaled functions.
 
      On each iteration the algorithm attempts to minimize the linear
      system |F + J p| subject to the constraint |D p| < \Delta.  The
@@ -771,20 +771,19 @@ initial guess must be sufficiently close to the minimum for it to work.
      returns an error if the changes in the solution are smaller than
      the machine precision.  The possible error codes are,
 
-    `GSL_ETOLF'
+     'GSL_ETOLF'
           the decrease in the function falls below machine precision
 
-    `GSL_ETOLX'
+     'GSL_ETOLX'
           the change in the position vector falls below machine
           precision
 
-    `GSL_ETOLG'
+     'GSL_ETOLG'
           the norm of the gradient, relative to the norm of the
           function, falls below machine precision
 
-     These error codes indicate that further iterations will be
-     unlikely to change the solution from its current value.
-
+     These error codes indicate that further iterations will be unlikely
+     to change the solution from its current value.
 
  -- Derivative Solver: gsl_multifit_fdfsolver_lmder
      This is an unscaled version of the LMDER algorithm.  The elements
@@ -827,21 +826,21 @@ File: gsl-ref.info,  Node: Computing the covariance matrix of best fit parameter
      covariance matrix are set to zero).
 
      If the minimisation uses the weighted least-squares function f_i =
-     (Y(x, t_i) - y_i) / \sigma_i then the covariance matrix above
-     gives the statistical error on the best-fit parameters resulting
-     from the gaussian errors \sigma_i on the underlying data y_i.
-     This can be verified from the relation \delta f = J \delta c and
-     the fact that the fluctuations in f from the data y_i are
-     normalised by \sigma_i and so satisfy <\delta f \delta f^T> = I.
+     (Y(x, t_i) - y_i) / \sigma_i then the covariance matrix above gives
+     the statistical error on the best-fit parameters resulting from the
+     gaussian errors \sigma_i on the underlying data y_i.  This can be
+     verified from the relation \delta f = J \delta c and the fact that
+     the fluctuations in f from the data y_i are normalised by \sigma_i
+     and so satisfy <\delta f \delta f^T> = I.
 
      For an unweighted least-squares function f_i = (Y(x, t_i) - y_i)
-     the covariance matrix above should be multiplied by the variance
-     of the residuals about the best-fit \sigma^2 = \sum (y_i -
-     Y(x,t_i))^2 / (n-p) to give the variance-covariance matrix
-     \sigma^2 C.  This estimates the statistical error on the best-fit
-     parameters from the scatter of the underlying data.
+     the covariance matrix above should be multiplied by the variance of
+     the residuals about the best-fit \sigma^2 = \sum (y_i - Y(x,t_i))^2
+     / (n-p) to give the variance-covariance matrix \sigma^2 C.  This
+     estimates the statistical error on the best-fit parameters from the
+     scatter of the underlying data.
 
-     For more information about covariance matrices see *Note Fitting
+     For more information about covariance matrices see *note Fitting
      Overview::.
 
 
@@ -851,16 +850,16 @@ File: gsl-ref.info,  Node: Example programs for Nonlinear Least-Squares Fitting,
 =============
 
 The following example program fits a weighted exponential model with
-background to experimental data, Y = A \exp(-\lambda t) + b. The first
-part of the program sets up the functions `expb_f' and `expb_df' to
+background to experimental data, Y = A \exp(-\lambda t) + b.  The first
+part of the program sets up the functions 'expb_f' and 'expb_df' to
 calculate the model and its Jacobian.  The appropriate fitting function
 is given by,
 
      f_i = ((A \exp(-\lambda t_i) + b) - y_i)/\sigma_i
 
 where we have chosen t_i = i.  The Jacobian matrix J is the derivative
-of these functions with respect to the three parameters (A, \lambda,
-b).  It is given by,
+of these functions with respect to the three parameters (A, \lambda, b).
+It is given by,
 
      J_{ij} = d f_i / d x_j
 
@@ -938,9 +937,9 @@ where x_0 = A, x_1 = \lambda and x_2 = b.
      }
 
 The main part of the program sets up a Levenberg-Marquardt solver and
-some simulated random data. The data uses the known parameters
+some simulated random data.  The data uses the known parameters
 (1.0,5.0,0.1) combined with gaussian noise (standard deviation = 0.1)
-over a range of 40 timesteps. The initial guess for the parameters is
+over a range of 40 timesteps.  The initial guess for the parameters is
 chosen as (0.0, 1.0, 0.0).
 
      #include <stdlib.h>
@@ -1088,7 +1087,7 @@ freedom is approximately 1).  In this case the errors on the parameters
 can be estimated from the square roots of the diagonal elements of the
 covariance matrix.
 
-   If the chi-squared value shows a poor fit (i.e. chi^2/dof >> 1) then
+   If the chi-squared value shows a poor fit (i.e.  chi^2/dof >> 1) then
 the error estimates obtained from the covariance matrix will be too
 small.  In the example program the error estimates are multiplied by
 \sqrt{\chi^2/dof} in this case, a common way of increasing the errors
@@ -1104,7 +1103,7 @@ File: gsl-ref.info,  Node: References and Further Reading for Nonlinear Least-Sq
 
 The MINPACK algorithm is described in the following article,
 
-     J.J. More', `The Levenberg-Marquardt Algorithm: Implementation and
+     J.J. More', 'The Levenberg-Marquardt Algorithm: Implementation and
      Theory', Lecture Notes in Mathematics, v630 (1978), ed G. Watson.
 
 The following paper is also relevant to the algorithms described in this
@@ -1121,7 +1120,7 @@ File: gsl-ref.info,  Node: Basis Splines,  Next: Physical Constants,  Prev: Nonl
 ****************
 
 This chapter describes functions for the computation of smoothing basis
-splines (B-splines). The header file `gsl_bspline.h' contains
+splines (B-splines).  The header file 'gsl_bspline.h' contains
 prototypes for the bspline functions and related declarations.
 
 * Menu:
@@ -1140,28 +1139,28 @@ File: gsl-ref.info,  Node: Overview of B-splines,  Next: Initializing the B-spli
 =============
 
 B-splines are commonly used as basis functions to fit smoothing curves
-to large data sets. To do this, the abscissa axis is broken up into
+to large data sets.  To do this, the abscissa axis is broken up into
 some number of intervals, where the endpoints of each interval are
-called "breakpoints". These breakpoints are then converted to "knots"
+called "breakpoints".  These breakpoints are then converted to "knots"
 by imposing various continuity and smoothness conditions at each
-interface. Given a nondecreasing knot vector t = \t_0, t_1, \dots,
-t_n+k-1\, the n basis splines of order k are defined by
+interface.  Given a nondecreasing knot vector t = \{t_0, t_1, \dots,
+t_{n+k-1}\}, the n basis splines of order k are defined by
 
      B_(i,1)(x) = (1, t_i <= x < t_(i+1)
                   (0, else
      B_(i,k)(x) = [(x - t_i)/(t_(i+k-1) - t_i)] B_(i,k-1)(x) + [(t_(i+k) - x)/(t_(i+k) - t_(i+1))] B_(i+1,k-1)(x)
 
-   for i = 0, \dots, n-1. The common case of cubic B-splines is given
-by k = 4. The above recurrence relation can be evaluated in a
+   for i = 0, \dots, n-1.  The common case of cubic B-splines is given
+by k = 4.  The above recurrence relation can be evaluated in a
 numerically stable way by the de Boor algorithm.
 
-   If we define appropriate knots on an interval [a,b] then the
-B-spline basis functions form a complete set on that interval.
-Therefore we can expand a smoothing function as
+   If we define appropriate knots on an interval [a,b] then the B-spline
+basis functions form a complete set on that interval.  Therefore we can
+expand a smoothing function as
 
      f(x) = \sum_i c_i B_(i,k)(x)
 
-   given enough (x_j, f(x_j)) data pairs. The c_i can be readily
+   given enough (x_j, f(x_j)) data pairs.  The c_i can be readily
 obtained from a least-squares fit.
 
 
@@ -1170,12 +1169,12 @@ File: gsl-ref.info,  Node: Initializing the B-splines solver,  Next: Constructin
 38.2 Initializing the B-splines solver
 ======================================
 
- -- Function: gsl_bspline_workspace * gsl_bspline_alloc (const size_t
-          K, const size_t NBREAK)
+ -- Function: gsl_bspline_workspace * gsl_bspline_alloc (const size_t K,
+          const size_t NBREAK)
      This function allocates a workspace for computing B-splines of
-     order K. The number of breakpoints is given by NBREAK. This leads
-     to n = nbreak + k - 2 basis functions. Cubic B-splines are
-     specified by k = 4. The size of the workspace is O(5k + nbreak).
+     order K.  The number of breakpoints is given by NBREAK.  This leads
+     to n = nbreak + k - 2 basis functions.  Cubic B-splines are
+     specified by k = 4.  The size of the workspace is O(5k + nbreak).
 
  -- Function: void gsl_bspline_free (gsl_bspline_workspace * W)
      This function frees the memory associated with the workspace W.
@@ -1189,13 +1188,13 @@ File: gsl-ref.info,  Node: Constructing the knots vector,  Next: Evaluation of B
  -- Function: int gsl_bspline_knots (const gsl_vector * BREAKPTS,
           gsl_bspline_workspace * W)
      This function computes the knots associated with the given
-     breakpoints and stores them internally in `w->knots'.
+     breakpoints and stores them internally in 'w->knots'.
 
  -- Function: int gsl_bspline_knots_uniform (const double a, const
           double b, gsl_bspline_workspace * W)
      This function assumes uniformly spaced breakpoints on [a,b] and
      constructs the corresponding knot vector using the previously
-     specified NBREAK parameter. The knots are stored in `w->knots'.
+     specified NBREAK parameter.  The knots are stored in 'w->knots'.
 
 
 File: gsl-ref.info,  Node: Evaluation of B-spline basis functions,  Next: Example programs for B-splines,  Prev: Constructing the knots vector,  Up: Basis Splines
@@ -1207,10 +1206,10 @@ File: gsl-ref.info,  Node: Evaluation of B-spline basis functions,  Next: Exampl
           gsl_bspline_workspace * W)
      This function evaluates all B-spline basis functions at the
      position X and stores them in B, so that the ith element of B is
-     B_i(x). B must be of length n = nbreak + k - 2. This value is also
-     stored in `w->n'.  It is far more efficient to compute all of the
-     basis functions at once than to compute them individually, due to
-     the nature of the defining recurrence relation.
+     B_i(x).  B must be of length n = nbreak + k - 2.  This value is
+     also stored in 'w->n'.  It is far more efficient to compute all of
+     the basis functions at once than to compute them individually, due
+     to the nature of the defining recurrence relation.
 
 
 File: gsl-ref.info,  Node: Example programs for B-splines,  Next: References and Further Reading,  Prev: Evaluation of B-spline basis functions,  Up: Basis Splines
@@ -1219,8 +1218,8 @@ File: gsl-ref.info,  Node: Example programs for B-splines,  Next: References and
 ===================================
 
 The following program computes a linear least squares fit to data using
-cubic B-spline basis functions with uniform breakpoints. The data is
-generated from the curve y(x) = \cos(x) \exp(-0.1 x) on [0, 15] with
+cubic B-spline basis functions with uniform breakpoints.  The data is
+generated from the curve y(x) = \cos{(x)} \exp{(-0.1 x)} on [0, 15] with
 gaussian noise added.
 
      #include <stdio.h>
@@ -1340,7 +1339,7 @@ gaussian noise added.
        return 0;
      } /* main() */
 
-   The output can be plotted with GNU `graph'.
+   The output can be plotted with GNU 'graph'.
 
      $ ./a.out > bspline.dat
      $ graph -T ps -X x -Y y -x 0 15 -y -1 1.3 < bspline.dat > bspline.ps
@@ -1354,11 +1353,11 @@ File: gsl-ref.info,  Node: References and Further Reading,  Prev: Example progra
 Further information on the algorithms described in this section can be
 found in the following book,
 
-     C. de Boor, `A Practical Guide to Splines' (1978), Springer-Verlag,
+     C. de Boor, 'A Practical Guide to Splines' (1978), Springer-Verlag,
      ISBN 0-387-90356-9.
 
 A large collection of B-spline routines is available in the PPPACK
-library available at `http://www.netlib.org/pppack'.
+library available at <http://www.netlib.org/pppack>.
 
 
 File: gsl-ref.info,  Node: Physical Constants,  Next: IEEE floating-point arithmetic,  Prev: Basis Splines,  Up: Top
@@ -1367,38 +1366,37 @@ File: gsl-ref.info,  Node: Physical Constants,  Next: IEEE floating-point arithm
 *********************
 
 This chapter describes macros for the values of physical constants, such
-as the speed of light, c, and gravitational constant, G.  The values
-are available in different unit systems, including the standard MKSA
-system (meters, kilograms, seconds, amperes) and the CGSM system
-(centimeters, grams, seconds, gauss), which is commonly used in
-Astronomy.
+as the speed of light, c, and gravitational constant, G.  The values are
+available in different unit systems, including the standard MKSA system
+(meters, kilograms, seconds, amperes) and the CGSM system (centimeters,
+grams, seconds, gauss), which is commonly used in Astronomy.
 
    The definitions of constants in the MKSA system are available in the
-file `gsl_const_mksa.h'.  The constants in the CGSM system are defined
-in `gsl_const_cgsm.h'.  Dimensionless constants, such as the fine
+file 'gsl_const_mksa.h'.  The constants in the CGSM system are defined
+in 'gsl_const_cgsm.h'.  Dimensionless constants, such as the fine
 structure constant, which are pure numbers are defined in
-`gsl_const_num.h'.
+'gsl_const_num.h'.
 
 * Menu:
 
-* Fundamental Constants::
-* Astronomy and Astrophysics::
-* Atomic and Nuclear Physics::
-* Measurement of Time::
-* Imperial Units ::
-* Speed and Nautical Units::
-* Printers Units::
-* Volume Area and Length::
-* Mass and Weight ::
-* Thermal Energy and Power::
-* Pressure::
-* Viscosity::
-* Light and Illumination::
-* Radioactivity::
-* Force and Energy::
-* Prefixes::
-* Physical Constant Examples::
-* Physical Constant References and Further Reading::
+* Fundamental Constants::       
+* Astronomy and Astrophysics::  
+* Atomic and Nuclear Physics::  
+* Measurement of Time::         
+* Imperial Units ::             
+* Speed and Nautical Units::    
+* Printers Units::              
+* Volume Area and Length::      
+* Mass and Weight ::            
+* Thermal Energy and Power::    
+* Pressure::                    
+* Viscosity::                   
+* Light and Illumination::      
+* Radioactivity::               
+* Force and Energy::            
+* Prefixes::                    
+* Physical Constant Examples::  
+* Physical Constant References and Further Reading::  
 
    The full list of constants is described briefly below.  Consult the
 header files themselves for the values of the constants used in the
@@ -1410,42 +1408,42 @@ File: gsl-ref.info,  Node: Fundamental Constants,  Next: Astronomy and Astrophys
 39.1 Fundamental Constants
 ==========================
 
-`GSL_CONST_MKSA_SPEED_OF_LIGHT'
+'GSL_CONST_MKSA_SPEED_OF_LIGHT'
      The speed of light in vacuum, c.
 
-`GSL_CONST_MKSA_VACUUM_PERMEABILITY'
-     The permeability of free space, \mu_0. This constant is defined in
+'GSL_CONST_MKSA_VACUUM_PERMEABILITY'
+     The permeability of free space, \mu_0.  This constant is defined in
      the MKSA system only.
 
-`GSL_CONST_MKSA_VACUUM_PERMITTIVITY'
+'GSL_CONST_MKSA_VACUUM_PERMITTIVITY'
      The permittivity of free space, \epsilon_0.  This constant is
      defined in the MKSA system only.
 
-`GSL_CONST_MKSA_PLANCKS_CONSTANT_H'
+'GSL_CONST_MKSA_PLANCKS_CONSTANT_H'
      Planck's constant, h.
 
-`GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR'
+'GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR'
      Planck's constant divided by 2\pi, \hbar.
 
-`GSL_CONST_NUM_AVOGADRO'
+'GSL_CONST_NUM_AVOGADRO'
      Avogadro's number, N_a.
 
-`GSL_CONST_MKSA_FARADAY'
+'GSL_CONST_MKSA_FARADAY'
      The molar charge of 1 Faraday.
 
-`GSL_CONST_MKSA_BOLTZMANN'
+'GSL_CONST_MKSA_BOLTZMANN'
      The Boltzmann constant, k.
 
-`GSL_CONST_MKSA_MOLAR_GAS'
+'GSL_CONST_MKSA_MOLAR_GAS'
      The molar gas constant, R_0.
 
-`GSL_CONST_MKSA_STANDARD_GAS_VOLUME'
+'GSL_CONST_MKSA_STANDARD_GAS_VOLUME'
      The standard gas volume, V_0.
 
-`GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT'
+'GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT'
      The Stefan-Boltzmann radiation constant, \sigma.
 
-`GSL_CONST_MKSA_GAUSS'
+'GSL_CONST_MKSA_GAUSS'
      The magnetic field of 1 Gauss.
 
 
@@ -1454,22 +1452,22 @@ File: gsl-ref.info,  Node: Astronomy and Astrophysics,  Next: Atomic and Nuclear
 39.2 Astronomy and Astrophysics
 ===============================
 
-`GSL_CONST_MKSA_ASTRONOMICAL_UNIT'
+'GSL_CONST_MKSA_ASTRONOMICAL_UNIT'
      The length of 1 astronomical unit (mean earth-sun distance), au.
 
-`GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT'
+'GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT'
      The gravitational constant, G.
 
-`GSL_CONST_MKSA_LIGHT_YEAR'
+'GSL_CONST_MKSA_LIGHT_YEAR'
      The distance of 1 light-year, ly.
 
-`GSL_CONST_MKSA_PARSEC'
+'GSL_CONST_MKSA_PARSEC'
      The distance of 1 parsec, pc.
 
-`GSL_CONST_MKSA_GRAV_ACCEL'
+'GSL_CONST_MKSA_GRAV_ACCEL'
      The standard gravitational acceleration on Earth, g.
 
-`GSL_CONST_MKSA_SOLAR_MASS'
+'GSL_CONST_MKSA_SOLAR_MASS'
      The mass of the Sun.
 
 
@@ -1478,60 +1476,60 @@ File: gsl-ref.info,  Node: Atomic and Nuclear Physics,  Next: Measurement of Tim
 39.3 Atomic and Nuclear Physics
 ===============================
 
-`GSL_CONST_MKSA_ELECTRON_CHARGE'
+'GSL_CONST_MKSA_ELECTRON_CHARGE'
      The charge of the electron, e.
 
-`GSL_CONST_MKSA_ELECTRON_VOLT'
+'GSL_CONST_MKSA_ELECTRON_VOLT'
      The energy of 1 electron volt, eV.
 
-`GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS'
+'GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS'
      The unified atomic mass, amu.
 
-`GSL_CONST_MKSA_MASS_ELECTRON'
+'GSL_CONST_MKSA_MASS_ELECTRON'
      The mass of the electron, m_e.
 
-`GSL_CONST_MKSA_MASS_MUON'
+'GSL_CONST_MKSA_MASS_MUON'
      The mass of the muon, m_\mu.
 
-`GSL_CONST_MKSA_MASS_PROTON'
+'GSL_CONST_MKSA_MASS_PROTON'
      The mass of the proton, m_p.
 
-`GSL_CONST_MKSA_MASS_NEUTRON'
+'GSL_CONST_MKSA_MASS_NEUTRON'
      The mass of the neutron, m_n.
 
-`GSL_CONST_NUM_FINE_STRUCTURE'
+'GSL_CONST_NUM_FINE_STRUCTURE'
      The electromagnetic fine structure constant \alpha.
 
-`GSL_CONST_MKSA_RYDBERG'
+'GSL_CONST_MKSA_RYDBERG'
      The Rydberg constant, Ry, in units of energy.  This is related to
      the Rydberg inverse wavelength R by Ry = h c R.
 
-`GSL_CONST_MKSA_BOHR_RADIUS'
+'GSL_CONST_MKSA_BOHR_RADIUS'
      The Bohr radius, a_0.
 
-`GSL_CONST_MKSA_ANGSTROM'
+'GSL_CONST_MKSA_ANGSTROM'
      The length of 1 angstrom.
 
-`GSL_CONST_MKSA_BARN'
+'GSL_CONST_MKSA_BARN'
      The area of 1 barn.
 
-`GSL_CONST_MKSA_BOHR_MAGNETON'
+'GSL_CONST_MKSA_BOHR_MAGNETON'
      The Bohr Magneton, \mu_B.
 
-`GSL_CONST_MKSA_NUCLEAR_MAGNETON'
+'GSL_CONST_MKSA_NUCLEAR_MAGNETON'
      The Nuclear Magneton, \mu_N.
 
-`GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT'
+'GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT'
      The absolute value of the magnetic moment of the electron, \mu_e.
      The physical magnetic moment of the electron is negative.
 
-`GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT'
+'GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT'
      The magnetic moment of the proton, \mu_p.
 
-`GSL_CONST_MKSA_THOMSON_CROSS_SECTION'
+'GSL_CONST_MKSA_THOMSON_CROSS_SECTION'
      The Thomson cross section, \sigma_T.
 
-`GSL_CONST_MKSA_DEBYE'
+'GSL_CONST_MKSA_DEBYE'
      The electric dipole moment of 1 Debye, D.
 
 
@@ -1540,16 +1538,16 @@ File: gsl-ref.info,  Node: Measurement of Time,  Next: Imperial Units,  Prev: At
 39.4 Measurement of Time
 ========================
 
-`GSL_CONST_MKSA_MINUTE'
+'GSL_CONST_MKSA_MINUTE'
      The number of seconds in 1 minute.
 
-`GSL_CONST_MKSA_HOUR'
+'GSL_CONST_MKSA_HOUR'
      The number of seconds in 1 hour.
 
-`GSL_CONST_MKSA_DAY'
+'GSL_CONST_MKSA_DAY'
      The number of seconds in 1 day.
 
-`GSL_CONST_MKSA_WEEK'
+'GSL_CONST_MKSA_WEEK'
      The number of seconds in 1 week.
 
 
@@ -1558,19 +1556,19 @@ File: gsl-ref.info,  Node: Imperial Units,  Next: Speed and Nautical Units,  Pre
 39.5 Imperial Units
 ===================
 
-`GSL_CONST_MKSA_INCH'
+'GSL_CONST_MKSA_INCH'
      The length of 1 inch.
 
-`GSL_CONST_MKSA_FOOT'
+'GSL_CONST_MKSA_FOOT'
      The length of 1 foot.
 
-`GSL_CONST_MKSA_YARD'
+'GSL_CONST_MKSA_YARD'
      The length of 1 yard.
 
-`GSL_CONST_MKSA_MILE'
+'GSL_CONST_MKSA_MILE'
      The length of 1 mile.
 
-`GSL_CONST_MKSA_MIL'
+'GSL_CONST_MKSA_MIL'
      The length of 1 mil (1/1000th of an inch).
 
 
@@ -1579,19 +1577,19 @@ File: gsl-ref.info,  Node: Speed and Nautical Units,  Next: Printers Units,  Pre
 39.6 Speed and Nautical Units
 =============================
 
-`GSL_CONST_MKSA_KILOMETERS_PER_HOUR'
+'GSL_CONST_MKSA_KILOMETERS_PER_HOUR'
      The speed of 1 kilometer per hour.
 
-`GSL_CONST_MKSA_MILES_PER_HOUR'
+'GSL_CONST_MKSA_MILES_PER_HOUR'
      The speed of 1 mile per hour.
 
-`GSL_CONST_MKSA_NAUTICAL_MILE'
+'GSL_CONST_MKSA_NAUTICAL_MILE'
      The length of 1 nautical mile.
 
-`GSL_CONST_MKSA_FATHOM'
+'GSL_CONST_MKSA_FATHOM'
      The length of 1 fathom.
 
-`GSL_CONST_MKSA_KNOT'
+'GSL_CONST_MKSA_KNOT'
      The speed of 1 knot.
 
 
@@ -1600,10 +1598,10 @@ File: gsl-ref.info,  Node: Printers Units,  Next: Volume Area and Length,  Prev:
 39.7 Printers Units
 ===================
 
-`GSL_CONST_MKSA_POINT'
+'GSL_CONST_MKSA_POINT'
      The length of 1 printer's point (1/72 inch).
 
-`GSL_CONST_MKSA_TEXPOINT'
+'GSL_CONST_MKSA_TEXPOINT'
      The length of 1 TeX point (1/72.27 inch).
 
 
@@ -1612,31 +1610,31 @@ File: gsl-ref.info,  Node: Volume Area and Length,  Next: Mass and Weight,  Prev
 39.8 Volume, Area and Length
 ============================
 
-`GSL_CONST_MKSA_MICRON'
+'GSL_CONST_MKSA_MICRON'
      The length of 1 micron.
 
-`GSL_CONST_MKSA_HECTARE'
+'GSL_CONST_MKSA_HECTARE'
      The area of 1 hectare.
 
-`GSL_CONST_MKSA_ACRE'
+'GSL_CONST_MKSA_ACRE'
      The area of 1 acre.
 
-`GSL_CONST_MKSA_LITER'
+'GSL_CONST_MKSA_LITER'
      The volume of 1 liter.
 
-`GSL_CONST_MKSA_US_GALLON'
+'GSL_CONST_MKSA_US_GALLON'
      The volume of 1 US gallon.
 
-`GSL_CONST_MKSA_CANADIAN_GALLON'
+'GSL_CONST_MKSA_CANADIAN_GALLON'
      The volume of 1 Canadian gallon.
 
-`GSL_CONST_MKSA_UK_GALLON'
+'GSL_CONST_MKSA_UK_GALLON'
      The volume of 1 UK gallon.
 
-`GSL_CONST_MKSA_QUART'
+'GSL_CONST_MKSA_QUART'
      The volume of 1 quart.
 
-`GSL_CONST_MKSA_PINT'
+'GSL_CONST_MKSA_PINT'
      The volume of 1 pint.
 
 
@@ -1645,37 +1643,37 @@ File: gsl-ref.info,  Node: Mass and Weight,  Next: Thermal Energy and Power,  Pr
 39.9 Mass and Weight
 ====================
 
-`GSL_CONST_MKSA_POUND_MASS'
+'GSL_CONST_MKSA_POUND_MASS'
      The mass of 1 pound.
 
-`GSL_CONST_MKSA_OUNCE_MASS'
+'GSL_CONST_MKSA_OUNCE_MASS'
      The mass of 1 ounce.
 
-`GSL_CONST_MKSA_TON'
+'GSL_CONST_MKSA_TON'
      The mass of 1 ton.
 
-`GSL_CONST_MKSA_METRIC_TON'
+'GSL_CONST_MKSA_METRIC_TON'
      The mass of 1 metric ton (1000 kg).
 
-`GSL_CONST_MKSA_UK_TON'
+'GSL_CONST_MKSA_UK_TON'
      The mass of 1 UK ton.
 
-`GSL_CONST_MKSA_TROY_OUNCE'
+'GSL_CONST_MKSA_TROY_OUNCE'
      The mass of 1 troy ounce.
 
-`GSL_CONST_MKSA_CARAT'
+'GSL_CONST_MKSA_CARAT'
      The mass of 1 carat.
 
-`GSL_CONST_MKSA_GRAM_FORCE'
+'GSL_CONST_MKSA_GRAM_FORCE'
      The force of 1 gram weight.
 
-`GSL_CONST_MKSA_POUND_FORCE'
+'GSL_CONST_MKSA_POUND_FORCE'
      The force of 1 pound weight.
 
-`GSL_CONST_MKSA_KILOPOUND_FORCE'
+'GSL_CONST_MKSA_KILOPOUND_FORCE'
      The force of 1 kilopound weight.
 
-`GSL_CONST_MKSA_POUNDAL'
+'GSL_CONST_MKSA_POUNDAL'
      The force of 1 poundal.
 
 
@@ -1684,16 +1682,16 @@ File: gsl-ref.info,  Node: Thermal Energy and Power,  Next: Pressure,  Prev: Mas
 39.10 Thermal Energy and Power
 ==============================
 
-`GSL_CONST_MKSA_CALORIE'
+'GSL_CONST_MKSA_CALORIE'
      The energy of 1 calorie.
 
-`GSL_CONST_MKSA_BTU'
+'GSL_CONST_MKSA_BTU'
      The energy of 1 British Thermal Unit, btu.
 
-`GSL_CONST_MKSA_THERM'
+'GSL_CONST_MKSA_THERM'
      The energy of 1 Therm.
 
-`GSL_CONST_MKSA_HORSEPOWER'
+'GSL_CONST_MKSA_HORSEPOWER'
      The power of 1 horsepower.
 
 
@@ -1702,25 +1700,25 @@ File: gsl-ref.info,  Node: Pressure,  Next: Viscosity,  Prev: Thermal Energy and
 39.11 Pressure
 ==============
 
-`GSL_CONST_MKSA_BAR'
+'GSL_CONST_MKSA_BAR'
      The pressure of 1 bar.
 
-`GSL_CONST_MKSA_STD_ATMOSPHERE'
+'GSL_CONST_MKSA_STD_ATMOSPHERE'
      The pressure of 1 standard atmosphere.
 
-`GSL_CONST_MKSA_TORR'
+'GSL_CONST_MKSA_TORR'
      The pressure of 1 torr.
 
-`GSL_CONST_MKSA_METER_OF_MERCURY'
+'GSL_CONST_MKSA_METER_OF_MERCURY'
      The pressure of 1 meter of mercury.
 
-`GSL_CONST_MKSA_INCH_OF_MERCURY'
+'GSL_CONST_MKSA_INCH_OF_MERCURY'
      The pressure of 1 inch of mercury.
 
-`GSL_CONST_MKSA_INCH_OF_WATER'
+'GSL_CONST_MKSA_INCH_OF_WATER'
      The pressure of 1 inch of water.
 
-`GSL_CONST_MKSA_PSI'
+'GSL_CONST_MKSA_PSI'
      The pressure of 1 pound per square inch.
 
 
@@ -1729,10 +1727,10 @@ File: gsl-ref.info,  Node: Viscosity,  Next: Light and Illumination,  Prev: Pres
 39.12 Viscosity
 ===============
 
-`GSL_CONST_MKSA_POISE'
+'GSL_CONST_MKSA_POISE'
      The dynamic viscosity of 1 poise.
 
-`GSL_CONST_MKSA_STOKES'
+'GSL_CONST_MKSA_STOKES'
      The kinematic viscosity of 1 stokes.
 
 
@@ -1741,25 +1739,25 @@ File: gsl-ref.info,  Node: Light and Illumination,  Next: Radioactivity,  Prev:
 39.13 Light and Illumination
 ============================
 
-`GSL_CONST_MKSA_STILB'
+'GSL_CONST_MKSA_STILB'
      The luminance of 1 stilb.
 
-`GSL_CONST_MKSA_LUMEN'
+'GSL_CONST_MKSA_LUMEN'
      The luminous flux of 1 lumen.
 
-`GSL_CONST_MKSA_LUX'
+'GSL_CONST_MKSA_LUX'
      The illuminance of 1 lux.
 
-`GSL_CONST_MKSA_PHOT'
+'GSL_CONST_MKSA_PHOT'
      The illuminance of 1 phot.
 
-`GSL_CONST_MKSA_FOOTCANDLE'
+'GSL_CONST_MKSA_FOOTCANDLE'
      The illuminance of 1 footcandle.
 
-`GSL_CONST_MKSA_LAMBERT'
+'GSL_CONST_MKSA_LAMBERT'
      The luminance of 1 lambert.
 
-`GSL_CONST_MKSA_FOOTLAMBERT'
+'GSL_CONST_MKSA_FOOTLAMBERT'
      The luminance of 1 footlambert.
 
 
@@ -1768,13 +1766,13 @@ File: gsl-ref.info,  Node: Radioactivity,  Next: Force and Energy,  Prev: Light
 39.14 Radioactivity
 ===================
 
-`GSL_CONST_MKSA_CURIE'
+'GSL_CONST_MKSA_CURIE'
      The activity of 1 curie.
 
-`GSL_CONST_MKSA_ROENTGEN'
+'GSL_CONST_MKSA_ROENTGEN'
      The exposure of 1 roentgen.
 
-`GSL_CONST_MKSA_RAD'
+'GSL_CONST_MKSA_RAD'
      The absorbed dose of 1 rad.
 
 
@@ -1783,16 +1781,16 @@ File: gsl-ref.info,  Node: Force and Energy,  Next: Prefixes,  Prev: Radioactivi
 39.15 Force and Energy
 ======================
 
-`GSL_CONST_MKSA_NEWTON'
+'GSL_CONST_MKSA_NEWTON'
      The SI unit of force, 1 Newton.
 
-`GSL_CONST_MKSA_DYNE'
+'GSL_CONST_MKSA_DYNE'
      The force of 1 Dyne = 10^-5 Newton.
 
-`GSL_CONST_MKSA_JOULE'
+'GSL_CONST_MKSA_JOULE'
      The SI unit of energy, 1 Joule.
 
-`GSL_CONST_MKSA_ERG'
+'GSL_CONST_MKSA_ERG'
      The energy 1 erg = 10^-7 Joule.
 
 
@@ -1803,52 +1801,52 @@ File: gsl-ref.info,  Node: Prefixes,  Next: Physical Constant Examples,  Prev: F
 
 These constants are dimensionless scaling factors.
 
-`GSL_CONST_NUM_YOTTA'
+'GSL_CONST_NUM_YOTTA'
      10^24
 
-`GSL_CONST_NUM_ZETTA'
+'GSL_CONST_NUM_ZETTA'
      10^21
 
-`GSL_CONST_NUM_EXA'
+'GSL_CONST_NUM_EXA'
      10^18
 
-`GSL_CONST_NUM_PETA'
+'GSL_CONST_NUM_PETA'
      10^15
 
-`GSL_CONST_NUM_TERA'
+'GSL_CONST_NUM_TERA'
      10^12
 
-`GSL_CONST_NUM_GIGA'
+'GSL_CONST_NUM_GIGA'
      10^9
 
-`GSL_CONST_NUM_MEGA'
+'GSL_CONST_NUM_MEGA'
      10^6
 
-`GSL_CONST_NUM_KILO'
+'GSL_CONST_NUM_KILO'
      10^3
 
-`GSL_CONST_NUM_MILLI'
+'GSL_CONST_NUM_MILLI'
      10^-3
 
-`GSL_CONST_NUM_MICRO'
+'GSL_CONST_NUM_MICRO'
      10^-6
 
-`GSL_CONST_NUM_NANO'
+'GSL_CONST_NUM_NANO'
      10^-9
 
-`GSL_CONST_NUM_PICO'
+'GSL_CONST_NUM_PICO'
      10^-12
 
-`GSL_CONST_NUM_FEMTO'
+'GSL_CONST_NUM_FEMTO'
      10^-15
 
-`GSL_CONST_NUM_ATTO'
+'GSL_CONST_NUM_ATTO'
      10^-18
 
-`GSL_CONST_NUM_ZEPTO'
+'GSL_CONST_NUM_ZEPTO'
      10^-21
 
-`GSL_CONST_NUM_YOCTO'
+'GSL_CONST_NUM_YOCTO'
      10^-24
 
 
@@ -1861,14 +1859,14 @@ The following program demonstrates the use of the physical constants in
 a calculation.  In this case, the goal is to calculate the range of
 light-travel times from Earth to Mars.
 
-   The required data is the average distance of each planet from the
-Sun in astronomical units (the eccentricities and inclinations of the
-orbits will be neglected for the purposes of this calculation).  The
-average radius of the orbit of Mars is 1.52 astronomical units, and for
-the orbit of Earth it is 1 astronomical unit (by definition).  These
-values are combined with the MKSA values of the constants for the speed
-of light and the length of an astronomical unit to produce a result for
-the shortest and longest light-travel times in seconds.  The figures are
+   The required data is the average distance of each planet from the Sun
+in astronomical units (the eccentricities and inclinations of the orbits
+will be neglected for the purposes of this calculation).  The average
+radius of the orbit of Mars is 1.52 astronomical units, and for the
+orbit of Earth it is 1 astronomical unit (by definition).  These values
+are combined with the MKSA values of the constants for the speed of
+light and the length of an astronomical unit to produce a result for the
+shortest and longest light-travel times in seconds.  The figures are
 converted into minutes before being displayed.
 
      #include <stdio.h>
@@ -1910,18 +1908,15 @@ File: gsl-ref.info,  Node: Physical Constant References and Further Reading,  Pr
 ====================================
 
 The authoritative sources for physical constants are the 2002 CODATA
-recommended values, published in the articles below. Further information
-on the values of physical constants is also available from the cited
-articles and the NIST website.
+recommended values, published in the articles below.  Further
+information on the values of physical constants is also available from
+the cited articles and the NIST website.
 
      Journal of Physical and Chemical Reference Data, 28(6), 1713-1852,
      1999
-
      Reviews of Modern Physics, 72(2), 351-495, 2000
-
-     `http://www.physics.nist.gov/cuu/Constants/index.html'
-
-     `http://physics.nist.gov/Pubs/SP811/appenB9.html'
+     <http://www.physics.nist.gov/cuu/Constants/index.html>
+     <http://physics.nist.gov/Pubs/SP811/appenB9.html>
 
 
 File: gsl-ref.info,  Node: IEEE floating-point arithmetic,  Next: Debugging Numerical Programs,  Prev: Physical Constants,  Up: Top
@@ -1932,13 +1927,13 @@ File: gsl-ref.info,  Node: IEEE floating-point arithmetic,  Next: Debugging Nume
 This chapter describes functions for examining the representation of
 floating point numbers and controlling the floating point environment of
 your program.  The functions described in this chapter are declared in
-the header file `gsl_ieee_utils.h'.
+the header file 'gsl_ieee_utils.h'.
 
 * Menu:
 
-* Representation of floating point numbers::
-* Setting up your IEEE environment::
-* IEEE References and Further Reading::
+* Representation of floating point numbers::  
+* Setting up your IEEE environment::  
+* IEEE References and Further Reading::  
 
 
 File: gsl-ref.info,  Node: Representation of floating point numbers,  Next: Setting up your IEEE environment,  Up: IEEE floating-point arithmetic
@@ -1949,8 +1944,8 @@ File: gsl-ref.info,  Node: Representation of floating point numbers,  Next: Sett
 The IEEE Standard for Binary Floating-Point Arithmetic defines binary
 formats for single and double precision numbers.  Each number is
 composed of three parts: a "sign bit" (s), an "exponent" (E) and a
-"fraction" (f).  The numerical value of the combination (s,E,f) is
-given by the following formula,
+"fraction" (f).  The numerical value of the combination (s,E,f) is given
+by the following formula,
 
      (-1)^s (1.fffff...) 2^E
 
@@ -1959,17 +1954,17 @@ value E_min to a maximum value E_max depending on the precision.  The
 exponent is converted to an unsigned number e, known as the "biased
 exponent", for storage by adding a "bias" parameter, e = E + bias.  The
 sequence fffff... represents the digits of the binary fraction f.  The
-binary digits are stored in "normalized form", by adjusting the
-exponent to give a leading digit of 1.  Since the leading digit is
-always 1 for normalized numbers it is assumed implicitly and does not
-have to be stored.  Numbers smaller than 2^(E_min) are be stored in
-"denormalized form" with a leading zero,
+binary digits are stored in "normalized form", by adjusting the exponent
+to give a leading digit of 1.  Since the leading digit is always 1 for
+normalized numbers it is assumed implicitly and does not have to be
+stored.  Numbers smaller than 2^(E_min) are be stored in "denormalized
+form" with a leading zero,
 
      (-1)^s (0.fffff...) 2^(E_min)
 
 This allows gradual underflow down to 2^(E_min - p) for p bits of
-precision.  A zero is encoded with the special exponent of 2^(E_min -
-1) and infinities with the exponent of 2^(E_max + 1).
+precision.  A zero is encoded with the special exponent of 2^(E_min - 1)
+and infinities with the exponent of 2^(E_max + 1).
 
 The format for single precision numbers uses 32 bits divided in the
 following way,
@@ -1998,34 +1993,33 @@ printing the IEEE representations in a human-readable form.
  -- Function: void gsl_ieee_fprintf_double (FILE * STREAM, const double
           * X)
      These functions output a formatted version of the IEEE
-     floating-point number pointed to by X to the stream STREAM. A
+     floating-point number pointed to by X to the stream STREAM.  A
      pointer is used to pass the number indirectly, to avoid any
-     undesired promotion from `float' to `double'.  The output takes
-     one of the following forms,
+     undesired promotion from 'float' to 'double'.  The output takes one
+     of the following forms,
 
-    `NaN'
+     'NaN'
           the Not-a-Number symbol
 
-    `Inf, -Inf'
+     'Inf, -Inf'
           positive or negative infinity
 
-    `1.fffff...*2^E, -1.fffff...*2^E'
+     '1.fffff...*2^E, -1.fffff...*2^E'
           a normalized floating point number
 
-    `0.fffff...*2^E, -0.fffff...*2^E'
+     '0.fffff...*2^E, -0.fffff...*2^E'
           a denormalized floating point number
 
-    `0, -0'
+     '0, -0'
           positive or negative zero
 
-
-     The output can be used directly in GNU Emacs Calc mode by
-     preceding it with `2#' to indicate binary.
+     The output can be used directly in GNU Emacs Calc mode by preceding
+     it with '2#' to indicate binary.
 
  -- Function: void gsl_ieee_printf_float (const float * X)
  -- Function: void gsl_ieee_printf_double (const double * X)
      These functions output a formatted version of the IEEE
-     floating-point number pointed to by X to the stream `stdout'.
+     floating-point number pointed to by X to the stream 'stdout'.
 
 The following program demonstrates the use of the functions by printing
 the single and double precision representations of the fraction 1/3.
@@ -2080,76 +2074,61 @@ the rounding precision and how the program should handle arithmetic
 exceptions, such as division by zero.
 
    Many of these features can now be controlled via standard functions
-such as `fpsetround', which should be used whenever they are available.
+such as 'fpsetround', which should be used whenever they are available.
 Unfortunately in the past there has been no universal API for
-controlling their behavior--each system has had its own low-level way
-of accessing them.  To help you write portable programs GSL allows you
-to specify modes in a platform-independent way using the environment
-variable `GSL_IEEE_MODE'.  The library then takes care of all the
+controlling their behavior--each system has had its own low-level way of
+accessing them.  To help you write portable programs GSL allows you to
+specify modes in a platform-independent way using the environment
+variable 'GSL_IEEE_MODE'.  The library then takes care of all the
 necessary machine-specific initializations for you when you call the
-function `gsl_ieee_env_setup'.
+function 'gsl_ieee_env_setup'.
 
  -- Function: void gsl_ieee_env_setup ()
-     This function reads the environment variable `GSL_IEEE_MODE' and
+     This function reads the environment variable 'GSL_IEEE_MODE' and
      attempts to set up the corresponding specified IEEE modes.  The
      environment variable should be a list of keywords, separated by
      commas, like this,
 
-          `GSL_IEEE_MODE' = "KEYWORD,KEYWORD,..."
+          'GSL_IEEE_MODE' = "KEYWORD,KEYWORD,..."
 
      where KEYWORD is one of the following mode-names,
 
-          `single-precision'
-
-          `double-precision'
-
-          `extended-precision'
-
-          `round-to-nearest'
-
-          `round-down'
-
-          `round-up'
-
-          `round-to-zero'
-
-          `mask-all'
-
-          `mask-invalid'
-
-          `mask-denormalized'
-
-          `mask-division-by-zero'
-
-          `mask-overflow'
-
-          `mask-underflow'
-
-          `trap-inexact'
-
-          `trap-common'
-
-     If `GSL_IEEE_MODE' is empty or undefined then the function returns
+          'single-precision'
+          'double-precision'
+          'extended-precision'
+          'round-to-nearest'
+          'round-down'
+          'round-up'
+          'round-to-zero'
+          'mask-all'
+          'mask-invalid'
+          'mask-denormalized'
+          'mask-division-by-zero'
+          'mask-overflow'
+          'mask-underflow'
+          'trap-inexact'
+          'trap-common'
+
+     If 'GSL_IEEE_MODE' is empty or undefined then the function returns
      immediately and no attempt is made to change the system's IEEE
-     mode.  When the modes from `GSL_IEEE_MODE' are turned on the
+     mode.  When the modes from 'GSL_IEEE_MODE' are turned on the
      function prints a short message showing the new settings to remind
      you that the results of the program will be affected.
 
-     If the requested modes are not supported by the platform being
-     used then the function calls the error handler and returns an
-     error code of `GSL_EUNSUP'.
+     If the requested modes are not supported by the platform being used
+     then the function calls the error handler and returns an error code
+     of 'GSL_EUNSUP'.
 
      When options are specified using this method, the resulting mode is
      based on a default setting of the highest available precision
-     (double precision or extended precision, depending on the
-     platform) in round-to-nearest mode, with all exceptions enabled
-     apart from the INEXACT exception.  The INEXACT exception is
-     generated whenever rounding occurs, so it must generally be
-     disabled in typical scientific calculations.  All other
-     floating-point exceptions are enabled by default, including
-     underflows and the use of denormalized numbers, for safety.  They
-     can be disabled with the individual `mask-' settings or together
-     using `mask-all'.
+     (double precision or extended precision, depending on the platform)
+     in round-to-nearest mode, with all exceptions enabled apart from
+     the INEXACT exception.  The INEXACT exception is generated whenever
+     rounding occurs, so it must generally be disabled in typical
+     scientific calculations.  All other floating-point exceptions are
+     enabled by default, including underflows and the use of
+     denormalized numbers, for safety.  They can be disabled with the
+     individual 'mask-' settings or together using 'mask-all'.
 
      The following adjusted combination of modes is convenient for many
      purposes,
@@ -2200,7 +2179,7 @@ summing a rapidly-decreasing series,
        return 0;
      }
 
-Here are the results of running the program in `round-to-nearest' mode.
+Here are the results of running the program in 'round-to-nearest' mode.
 This is the IEEE default so it isn't really necessary to specify it
 here,
 
@@ -2212,7 +2191,7 @@ here,
      i=19 sum=2.718281828459045535 error=4.44089e-16
 
 After nineteen terms the sum converges to within 4 \times 10^-16 of the
-correct value.  If we now change the rounding mode to `round-down' the
+correct value.  If we now change the rounding mode to 'round-down' the
 final result is less accurate,
 
      $ GSL_IEEE_MODE="round-down" ./a.out
@@ -2220,24 +2199,22 @@ final result is less accurate,
      ....
      i=19 sum=2.718281828459041094 error=-3.9968e-15
 
-The result is about 4 \times 10^-15 below the correct value, an order
-of magnitude worse than the result obtained in the `round-to-nearest'
-mode.
+The result is about 4 \times 10^-15 below the correct value, an order of
+magnitude worse than the result obtained in the 'round-to-nearest' mode.
 
-   If we change to rounding mode to `round-up' then the series no
-longer converges (the reason is that when we add each term to the sum
-the final result is always rounded up.  This is guaranteed to increase
-the sum by at least one tick on each iteration).  To avoid this problem
-we would need to use a safer converge criterion, such as `while
-(fabs(sum - oldsum) > epsilon)', with a suitably chosen value of
-epsilon.
+   If we change to rounding mode to 'round-up' then the series no longer
+converges (the reason is that when we add each term to the sum the final
+result is always rounded up.  This is guaranteed to increase the sum by
+at least one tick on each iteration).  To avoid this problem we would
+need to use a safer converge criterion, such as 'while (fabs(sum -
+oldsum) > epsilon)', with a suitably chosen value of epsilon.
 
    Finally we can see the effect of computing the sum using
-single-precision rounding, in the default `round-to-nearest' mode.  In
+single-precision rounding, in the default 'round-to-nearest' mode.  In
 this case the program thinks it is still using double precision numbers
 but the CPU rounds the result of each floating point operation to
 single-precision accuracy.  This simulates the effect of writing the
-program using single-precision `float' variables instead of `double'
+program using single-precision 'float' variables instead of 'double'
 variables.  The iteration stops after about half the number of
 iterations and the final result is much less accurate,
 
@@ -2246,9 +2223,9 @@ iterations and the final result is much less accurate,
      i=12 sum=2.718281984329223633 error=1.5587e-07
 
 with an error of O(10^-7), which corresponds to single precision
-accuracy (about 1 part in 10^7).  Continuing the iterations further
-does not decrease the error because all the subsequent results are
-rounded to the same value.
+accuracy (about 1 part in 10^7).  Continuing the iterations further does
+not decrease the error because all the subsequent results are rounded to
+the same value.
 
 
 File: gsl-ref.info,  Node: IEEE References and Further Reading,  Prev: Setting up your IEEE environment,  Up: IEEE floating-point arithmetic
@@ -2265,22 +2242,21 @@ A more pedagogical introduction to the standard can be found in the
 following paper,
 
      David Goldberg: What Every Computer Scientist Should Know About
-     Floating-Point Arithmetic. `ACM Computing Surveys', Vol. 23, No. 1
+     Floating-Point Arithmetic.  'ACM Computing Surveys', Vol. 23, No. 1
      (March 1991), pages 5-48.
 
-     Corrigendum: `ACM Computing Surveys', Vol. 23, No. 3 (September
-     1991), page 413. and see also the sections by B. A. Wichmann and
+     Corrigendum: 'ACM Computing Surveys', Vol. 23, No. 3 (September
+     1991), page 413.  and see also the sections by B. A. Wichmann and
      Charles B. Dunham in Surveyor's Forum: "What Every Computer
-     Scientist Should Know About Floating-Point Arithmetic". `ACM
+     Scientist Should Know About Floating-Point Arithmetic".  'ACM
      Computing Surveys', Vol. 24, No. 3 (September 1992), page 319.
 
-A detailed textbook on IEEE arithmetic and its practical use is
+   A detailed textbook on IEEE arithmetic and its practical use is
 available from SIAM Press,
 
-     Michael L. Overton, `Numerical Computing with IEEE Floating Point
+     Michael L. Overton, 'Numerical Computing with IEEE Floating Point
      Arithmetic', SIAM Press, ISBN 0898715717.
 
-
 
 File: gsl-ref.info,  Node: Debugging Numerical Programs,  Next: Contributors to GSL,  Prev: IEEE floating-point arithmetic,  Up: Top
 
@@ -2292,11 +2268,11 @@ programs which use GSL.
 
 * Menu:
 
-* Using gdb::
-* Examining floating point registers::
-* Handling floating point exceptions::
-* GCC warning options for numerical programs::
-* Debugging References::
+* Using gdb::                   
+* Examining floating point registers::  
+* Handling floating point exceptions::  
+* GCC warning options for numerical programs::  
+* Debugging References::        
 
 
 File: gsl-ref.info,  Node: Using gdb,  Next: Examining floating point registers,  Up: Debugging Numerical Programs
@@ -2305,29 +2281,29 @@ A.1 Using gdb
 =============
 
 Any errors reported by the library are passed to the function
-`gsl_error'.  By running your programs under gdb and setting a
+'gsl_error'.  By running your programs under gdb and setting a
 breakpoint in this function you can automatically catch any library
 errors.  You can add a breakpoint for every session by putting
 
      break gsl_error
 
-into your `.gdbinit' file in the directory where your program is
+into your '.gdbinit' file in the directory where your program is
 started.
 
    If the breakpoint catches an error then you can use a backtrace
-(`bt') to see the call-tree, and the arguments which possibly caused
-the error.  By moving up into the calling function you can investigate
-the values of variables at that point.  Here is an example from the
-program `fft/test_trap', which contains the following line,
+('bt') to see the call-tree, and the arguments which possibly caused the
+error.  By moving up into the calling function you can investigate the
+values of variables at that point.  Here is an example from the program
+'fft/test_trap', which contains the following line,
 
      status = gsl_fft_complex_wavetable_alloc (0, &complex_wavetable);
 
-The function `gsl_fft_complex_wavetable_alloc' takes the length of an
+The function 'gsl_fft_complex_wavetable_alloc' takes the length of an
 FFT as its first argument.  When this line is executed an error will be
 generated because the length of an FFT is not allowed to be zero.
 
-   To debug this problem we start `gdb', using the file `.gdbinit' to
-define a breakpoint in `gsl_error',
+   To debug this problem we start 'gdb', using the file '.gdbinit' to
+define a breakpoint in 'gsl_error',
 
      $ gdb test_trap
 
@@ -2351,7 +2327,7 @@ reason for it.
          at error.c:14
      14        if (gsl_error_handler)
 
-The first argument of `gsl_error' is always a string describing the
+The first argument of 'gsl_error' is always a string describing the
 error.  Now we can look at the backtrace to see what caused the problem,
 
      (gdb) bt
@@ -2366,8 +2342,8 @@ error.  Now we can look at the backtrace to see what caused the problem,
      #3  0x80488be in ___crt_dummy__ ()
 
 We can see that the error was generated in the function
-`gsl_fft_complex_wavetable_alloc' when it was called with an argument
-of N=0.  The original call came from line 94 in the file `test_trap.c'.
+'gsl_fft_complex_wavetable_alloc' when it was called with an argument of
+N=0.  The original call came from line 94 in the file 'test_trap.c'.
 
    By moving up to the level of the original call we can find the line
 that caused the error,
@@ -2384,7 +2360,7 @@ that caused the error,
 
 Thus we have found the line that caused the problem.  From this point we
 could also print out the values of other variables such as
-`complex_wavetable'.
+'complex_wavetable'.
 
 
 File: gsl-ref.info,  Node: Examining floating point registers,  Next: Handling floating point exceptions,  Prev: Using gdb,  Up: Debugging Numerical Programs
@@ -2393,7 +2369,7 @@ A.2 Examining floating point registers
 ======================================
 
 The contents of floating point registers can be examined using the
-command `info float' (on supported platforms).
+command 'info float' (on supported platforms).
 
      (gdb) info float
           st0: 0xc4018b895aa17a945000  Valid Normal -7.838871e+308
@@ -2412,8 +2388,8 @@ command `info float' (on supported platforms).
        fopoff: 0x08086820
        fopsel: 0x002b
 
-Individual registers can be examined using the variables $REG, where
-REG is the register name.
+Individual registers can be examined using the variables $REG, where REG
+is the register name.
 
      (gdb) p $st1
      $1 = 0.02859464454261210347719
@@ -2424,10 +2400,10 @@ File: gsl-ref.info,  Node: Handling floating point exceptions,  Next: GCC warnin
 A.3 Handling floating point exceptions
 ======================================
 
-It is possible to stop the program whenever a `SIGFPE' floating point
+It is possible to stop the program whenever a 'SIGFPE' floating point
 exception occurs.  This can be useful for finding the cause of an
-unexpected infinity or `NaN'.  The current handler settings can be
-shown with the command `info signal SIGFPE'.
+unexpected infinity or 'NaN'.  The current handler settings can be shown
+with the command 'info signal SIGFPE'.
 
      (gdb) info signal SIGFPE
      Signal  Stop  Print  Pass to program Description
@@ -2435,7 +2411,7 @@ shown with the command `info signal SIGFPE'.
 
 Unless the program uses a signal handler the default setting should be
 changed so that SIGFPE is not passed to the program, as this would cause
-it to exit.  The command `handle SIGFPE stop nopass' prevents this.
+it to exit.  The command 'handle SIGFPE stop nopass' prevents this.
 
      (gdb) handle SIGFPE stop nopass
      Signal  Stop  Print  Pass to program Description
@@ -2443,9 +2419,9 @@ it to exit.  The command `handle SIGFPE stop nopass' prevents this.
 
 Depending on the platform it may be necessary to instruct the kernel to
 generate signals for floating point exceptions.  For programs using GSL
-this can be achieved using the `GSL_IEEE_MODE' environment variable in
-conjunction with the function `gsl_ieee_env_setup' as described in
-*note IEEE floating-point arithmetic::.
+this can be achieved using the 'GSL_IEEE_MODE' environment variable in
+conjunction with the function 'gsl_ieee_env_setup' as described in *note
+IEEE floating-point arithmetic::.
 
      (gdb) set env GSL_IEEE_MODE=double-precision
 
@@ -2466,91 +2442,76 @@ programs:
        -Wwrite-strings -Wnested-externs
        -fshort-enums -fno-common -Dinline= -g -O2
 
-For details of each option consult the manual `Using and Porting GCC'.
+For details of each option consult the manual 'Using and Porting GCC'.
 The following table gives a brief explanation of what types of errors
 these options catch.
 
-`-ansi -pedantic'
+'-ansi -pedantic'
      Use ANSI C, and reject any non-ANSI extensions.  These flags help
      in writing portable programs that will compile on other systems.
-
-`-Werror'
+'-Werror'
      Consider warnings to be errors, so that compilation stops.  This
      prevents warnings from scrolling off the top of the screen and
      being lost.  You won't be able to compile the program until it is
      completely warning-free.
-
-`-Wall'
+'-Wall'
      This turns on a set of warnings for common programming problems.
-     You need `-Wall', but it is not enough on its own.
-
-`-O2'
+     You need '-Wall', but it is not enough on its own.
+'-O2'
      Turn on optimization.  The warnings for uninitialized variables in
-     `-Wall' rely on the optimizer to analyze the code.  If there is no
+     '-Wall' rely on the optimizer to analyze the code.  If there is no
      optimization then these warnings aren't generated.
-
-`-W'
-     This turns on some extra warnings not included in `-Wall', such as
+'-W'
+     This turns on some extra warnings not included in '-Wall', such as
      missing return values and comparisons between signed and unsigned
      integers.
-
-`-Wmissing-prototypes -Wstrict-prototypes'
+'-Wmissing-prototypes -Wstrict-prototypes'
      Warn if there are any missing or inconsistent prototypes.  Without
      prototypes it is harder to detect problems with incorrect
      arguments.
-
-`-Wtraditional'
+'-Wtraditional'
      This warns about certain constructs that behave differently in
      traditional and ANSI C. Whether the traditional or ANSI
      interpretation is used might be unpredictable on other compilers.
-
-`-Wconversion'
+'-Wconversion'
      The main use of this option is to warn about conversions from
-     signed to unsigned integers.  For example, `unsigned int x = -1'.
+     signed to unsigned integers.  For example, 'unsigned int x = -1'.
      If you need to perform such a conversion you can use an explicit
      cast.
-
-`-Wshadow'
+'-Wshadow'
      This warns whenever a local variable shadows another local
      variable.  If two variables have the same name then it is a
      potential source of confusion.
-
-`-Wpointer-arith -Wcast-qual -Wcast-align'
+'-Wpointer-arith -Wcast-qual -Wcast-align'
      These options warn if you try to do pointer arithmetic for types
-     which don't have a size, such as `void', if you remove a `const'
+     which don't have a size, such as 'void', if you remove a 'const'
      cast from a pointer, or if you cast a pointer to a type which has a
      different size, causing an invalid alignment.
-
-`-Wwrite-strings'
-     This option gives string constants a `const' qualifier so that it
+'-Wwrite-strings'
+     This option gives string constants a 'const' qualifier so that it
      will be a compile-time error to attempt to overwrite them.
-
-`-fshort-enums'
-     This option makes the type of `enum' as short as possible.
-     Normally this makes an `enum' different from an `int'.
+'-fshort-enums'
+     This option makes the type of 'enum' as short as possible.
+     Normally this makes an 'enum' different from an 'int'.
      Consequently any attempts to assign a pointer-to-int to a
      pointer-to-enum will generate a cast-alignment warning.
-
-`-fno-common'
+'-fno-common'
      This option prevents global variables being simultaneously defined
      in different object files (you get an error at link time).  Such a
      variable should be defined in one file and referred to in other
-     files with an `extern' declaration.
-
-`-Wnested-externs'
-     This warns if an `extern' declaration is encountered within a
+     files with an 'extern' declaration.
+'-Wnested-externs'
+     This warns if an 'extern' declaration is encountered within a
      function.
-
-`-Dinline='
-     The `inline' keyword is not part of ANSI C. Thus if you want to use
-     `-ansi' with a program which uses inline functions you can use this
-     preprocessor definition to remove the `inline' keywords.
-
-`-g'
-     It always makes sense to put debugging symbols in the executable
-     so that you can debug it using `gdb'.  The only effect of
-     debugging symbols is to increase the size of the file, and you can
-     use the `strip' command to remove them later if necessary.
+'-Dinline='
+     The 'inline' keyword is not part of ANSI C. Thus if you want to use
+     '-ansi' with a program which uses inline functions you can use this
+     preprocessor definition to remove the 'inline' keywords.
+'-g'
+     It always makes sense to put debugging symbols in the executable so
+     that you can debug it using 'gdb'.  The only effect of debugging
+     symbols is to increase the size of the file, and you can use the
+     'strip' command to remove them later if necessary.
 
 
 File: gsl-ref.info,  Node: Debugging References,  Prev: GCC warning options for numerical programs,  Up: Debugging Numerical Programs
@@ -2561,16 +2522,16 @@ A.5 References and Further Reading
 The following books are essential reading for anyone writing and
 debugging numerical programs with GCC and GDB.
 
-     R.M. Stallman, `Using and Porting GNU CC', Free Software
+     R.M. Stallman, 'Using and Porting GNU CC', Free Software
      Foundation, ISBN 1882114388
 
-     R.M. Stallman, R.H. Pesch, `Debugging with GDB: The GNU
+     R.M. Stallman, R.H. Pesch, 'Debugging with GDB: The GNU
      Source-Level Debugger', Free Software Foundation, ISBN 1882114779
 
 For a tutorial introduction to the GNU C Compiler and related programs,
 see
 
-     B.J. Gough, `An Introduction to GCC', Network Theory Ltd, ISBN
+     B.J. Gough, 'An Introduction to GCC', Network Theory Ltd, ISBN
      0954161793
 
 
@@ -2625,7 +2586,7 @@ Appendix B Contributors to GSL
 
 *Carlo Perassi*
      Implementation of the random number generators in Knuth's
-     `Seminumerical Algorithms', 3rd Ed.
+     'Seminumerical Algorithms', 3rd Ed.
 
 *Szymon Jaroszewicz*
      Wrote the routines for generating combinations.
@@ -2648,7 +2609,6 @@ Appendix B Contributors to GSL
 *Patrick Alken*
      Implementation of non-symmetric eigensystems and B-splines.
 
-
    Thanks to Nigel Lowry for help in proofreading the manual.
 
    The non-symmetric eigensystems routines contain code based on the
@@ -2679,14 +2639,14 @@ following license:
      "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
      FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-     COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+     COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
      SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+     OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 File: gsl-ref.info,  Node: Autoconf Macros,  Next: GSL CBLAS Library,  Prev: Contributors to GSL,  Up: Top
@@ -2694,18 +2654,18 @@ File: gsl-ref.info,  Node: Autoconf Macros,  Next: GSL CBLAS Library,  Prev: Con
 Appendix C Autoconf Macros
 **************************
 
-For applications using `autoconf' the standard macro `AC_CHECK_LIB' can
-be used to link with GSL automatically from a `configure' script.  The
+For applications using 'autoconf' the standard macro 'AC_CHECK_LIB' can
+be used to link with GSL automatically from a 'configure' script.  The
 library itself depends on the presence of a CBLAS and math library as
 well, so these must also be located before linking with the main
-`libgsl' file.  The following commands should be placed in the
-`configure.ac' file to perform these tests,
+'libgsl' file.  The following commands should be placed in the
+'configure.ac' file to perform these tests,
 
      AC_CHECK_LIB(m,main)
      AC_CHECK_LIB(gslcblas,main)
      AC_CHECK_LIB(gsl,main)
 
-It is important to check for `libm' and `libgslcblas' before `libgsl',
+It is important to check for 'libm' and 'libgslcblas' before 'libgsl',
 otherwise the tests will fail.  Assuming the libraries are found the
 output during the configure stage looks like this,
 
@@ -2714,39 +2674,39 @@ output during the configure stage looks like this,
      checking for main in -lgsl... yes
 
 If the library is found then the tests will define the macros
-`HAVE_LIBGSL', `HAVE_LIBGSLCBLAS', `HAVE_LIBM' and add the options
-`-lgsl -lgslcblas -lm' to the variable `LIBS'.
+'HAVE_LIBGSL', 'HAVE_LIBGSLCBLAS', 'HAVE_LIBM' and add the options
+'-lgsl -lgslcblas -lm' to the variable 'LIBS'.
 
    The tests above will find any version of the library.  They are
 suitable for general use, where the versions of the functions are not
-important.  An alternative macro is available in the file `gsl.m4' to
+important.  An alternative macro is available in the file 'gsl.m4' to
 test for a specific version of the library.  To use this macro simply
-add the following line to your `configure.in' file instead of the tests
+add the following line to your 'configure.in' file instead of the tests
 above:
 
      AM_PATH_GSL(GSL_VERSION,
                 [action-if-found],
                 [action-if-not-found])
 
-The argument `GSL_VERSION' should be the two or three digit MAJOR.MINOR
-or MAJOR.MINOR.MICRO version number of the release you require. A
-suitable choice for `action-if-not-found' is,
+The argument 'GSL_VERSION' should be the two or three digit MAJOR.MINOR
+or MAJOR.MINOR.MICRO version number of the release you require.  A
+suitable choice for 'action-if-not-found' is,
 
      AC_MSG_ERROR(could not find required version of GSL)
 
-Then you can add the variables `GSL_LIBS' and `GSL_CFLAGS' to your
-Makefile.am files to obtain the correct compiler flags.  `GSL_LIBS' is
-equal to the output of the `gsl-config --libs' command and `GSL_CFLAGS'
-is equal to `gsl-config --cflags' command. For example,
+Then you can add the variables 'GSL_LIBS' and 'GSL_CFLAGS' to your
+Makefile.am files to obtain the correct compiler flags.  'GSL_LIBS' is
+equal to the output of the 'gsl-config --libs' command and 'GSL_CFLAGS'
+is equal to 'gsl-config --cflags' command.  For example,
 
      libfoo_la_LDFLAGS = -lfoo $(GSL_LIBS) -lgslcblas
 
-Note that the macro `AM_PATH_GSL' needs to use the C compiler so it
-should appear in the `configure.in' file before the macro
-`AC_LANG_CPLUSPLUS' for programs that use C++.
+Note that the macro 'AM_PATH_GSL' needs to use the C compiler so it
+should appear in the 'configure.in' file before the macro
+'AC_LANG_CPLUSPLUS' for programs that use C++.
 
-   To test for `inline' the following test should be placed in your
-`configure.in' file,
+   To test for 'inline' the following test should be placed in your
+'configure.in' file,
 
      AC_C_INLINE
 
@@ -2756,9 +2716,9 @@ should appear in the `configure.in' file before the macro
      fi
 
 and the macro will then be defined in the compilation flags or by
-including the file `config.h' before any library headers.
+including the file 'config.h' before any library headers.
 
-   The following autoconf test will check for `extern inline',
+   The following autoconf test will check for 'extern inline',
 
      dnl Check for "extern inline", using a modified version
      dnl of the test for AC_C_INLINE from acspecific.mt
@@ -2778,13 +2738,13 @@ including the file `config.h' before any library headers.
      fi
 
    The substitution of portability functions can be made automatically
-if you use `autoconf'. For example, to test whether the BSD function
-`hypot' is available you can include the following line in the
-configure file `configure.in' for your application,
+if you use 'autoconf'.  For example, to test whether the BSD function
+'hypot' is available you can include the following line in the configure
+file 'configure.in' for your application,
 
      AC_CHECK_FUNCS(hypot)
 
-and place the following macro definitions in the file `config.h.in',
+and place the following macro definitions in the file 'config.h.in',
 
      /* Substitute gsl_hypot for missing system hypot */
 
@@ -2792,9 +2752,9 @@ and place the following macro definitions in the file `config.h.in',
      #define hypot gsl_hypot
      #endif
 
-The application source files can then use the include command `#include
-<config.h>' to substitute `gsl_hypot' for each occurrence of `hypot'
-when `hypot' is not available.
+The application source files can then use the include command '#include
+<config.h>' to substitute 'gsl_hypot' for each occurrence of 'hypot'
+when 'hypot' is not available.
 
 
 File: gsl-ref.info,  Node: GSL CBLAS Library,  Next: Free Software Needs Free Documentation,  Prev: Autoconf Macros,  Up: Top
@@ -2803,16 +2763,16 @@ Appendix D GSL CBLAS Library
 ****************************
 
 The prototypes for the low-level CBLAS functions are declared in the
-file `gsl_cblas.h'.  For the definition of the functions consult the
+file 'gsl_cblas.h'.  For the definition of the functions consult the
 documentation available from Netlib (*note BLAS References and Further
 Reading::).
 
 * Menu:
 
-* Level 1 CBLAS Functions::
-* Level 2 CBLAS Functions::
-* Level 3 CBLAS Functions::
-* GSL CBLAS Examples::
+* Level 1 CBLAS Functions::     
+* Level 2 CBLAS Functions::     
+* Level 3 CBLAS Functions::     
+* GSL CBLAS Examples::          
 
 
 File: gsl-ref.info,  Node: Level 1 CBLAS Functions,  Next: Level 2 CBLAS Functions,  Up: GSL CBLAS Library
@@ -2844,11 +2804,11 @@ D.1 Level 1
  -- Function: void cblas_zdotc_sub (const int N, const void * X, const
           int INCX, const void * Y, const int INCY, void * DOTC)
 
- -- Function: float cblas_snrm2 (const int N, const float * X, const
-          int INCX)
+ -- Function: float cblas_snrm2 (const int N, const float * X, const int
+          INCX)
 
- -- Function: float cblas_sasum (const int N, const float * X, const
-          int INCX)
+ -- Function: float cblas_sasum (const int N, const float * X, const int
+          INCX)
 
  -- Function: double cblas_dnrm2 (const int N, const double * X, const
           int INCX)
@@ -2856,11 +2816,11 @@ D.1 Level 1
  -- Function: double cblas_dasum (const int N, const double * X, const
           int INCX)
 
- -- Function: float cblas_scnrm2 (const int N, const void * X, const
-          int INCX)
+ -- Function: float cblas_scnrm2 (const int N, const void * X, const int
+          INCX)
 
- -- Function: float cblas_scasum (const int N, const void * X, const
-          int INCX)
+ -- Function: float cblas_scasum (const int N, const void * X, const int
+          INCX)
 
  -- Function: double cblas_dznrm2 (const int N, const void * X, const
           int INCX)
@@ -2889,11 +2849,11 @@ D.1 Level 1
  -- Function: void cblas_saxpy (const int N, const float ALPHA, const
           float * X, const int INCX, float * Y, const int INCY)
 
- -- Function: void cblas_dswap (const int N, double * X, const int
-          INCX, double * Y, const int INCY)
+ -- Function: void cblas_dswap (const int N, double * X, const int INCX,
+          double * Y, const int INCY)
 
- -- Function: void cblas_dcopy (const int N, const double * X, const
-          int INCX, double * Y, const int INCY)
+ -- Function: void cblas_dcopy (const int N, const double * X, const int
+          INCX, double * Y, const int INCY)
 
  -- Function: void cblas_daxpy (const int N, const double ALPHA, const
           double * X, const int INCX, double * Y, const int INCY)
@@ -2916,8 +2876,8 @@ D.1 Level 1
  -- Function: void cblas_zaxpy (const int N, const void * ALPHA, const
           void * X, const int INCX, void * Y, const int INCY)
 
- -- Function: void cblas_srotg (float * A, float * B, float * C, float
-          * S)
+ -- Function: void cblas_srotg (float * A, float * B, float * C, float *
+          S)
 
  -- Function: void cblas_srotmg (float * D1, float * D2, float * B1,
           const float B2, float * P)
@@ -2937,8 +2897,8 @@ D.1 Level 1
  -- Function: void cblas_drot (const int N, double * X, const int INCX,
           double * Y, const int INCY, const double C, const double S)
 
- -- Function: void cblas_drotm (const int N, double * X, const int
-          INCX, double * Y, const int INCY, const double * P)
+ -- Function: void cblas_drotm (const int N, double * X, const int INCX,
+          double * Y, const int INCY, const double * P)
 
  -- Function: void cblas_sscal (const int N, const float ALPHA, float *
           X, const int INCX)
@@ -2955,8 +2915,8 @@ D.1 Level 1
  -- Function: void cblas_csscal (const int N, const float ALPHA, void *
           X, const int INCX)
 
- -- Function: void cblas_zdscal (const int N, const double ALPHA, void
-          * X, const int INCX)
+ -- Function: void cblas_zdscal (const int N, const double ALPHA, void *
+          X, const int INCX)
 
 
 File: gsl-ref.info,  Node: Level 2 CBLAS Functions,  Next: Level 3 CBLAS Functions,  Prev: Level 1 CBLAS Functions,  Up: GSL CBLAS Library
@@ -2964,223 +2924,221 @@ File: gsl-ref.info,  Node: Level 2 CBLAS Functions,  Next: Level 3 CBLAS Functio
 D.2 Level 2
 ===========
 
- -- Function: void cblas_sgemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          float ALPHA, const float * A, const int LDA, const float * X,
-          const int INCX, const float BETA, float * Y, const int INCY)
+ -- Function: void cblas_sgemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const float
+          ALPHA, const float * A, const int LDA, const float * X, const
+          int INCX, const float BETA, float * Y, const int INCY)
+
+ -- Function: void cblas_sgbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const int
+          KL, const int KU, const float ALPHA, const float * A, const
+          int LDA, const float * X, const int INCX, const float BETA,
+          float * Y, const int INCY)
 
- -- Function: void cblas_sgbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          int KL, const int KU, const float ALPHA, const float * A,
-          const int LDA, const float * X, const int INCX, const float
-          BETA, float * Y, const int INCY)
+ -- Function: void cblas_strmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const float * A, const int LDA,
+          float * X, const int INCX)
 
- -- Function: void cblas_strmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const float * A,
+ -- Function: void cblas_stbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const float * A,
           const int LDA, float * X, const int INCX)
 
- -- Function: void cblas_stbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          float * A, const int LDA, float * X, const int INCX)
+ -- Function: void cblas_stpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const float * AP, float * X,
+          const int INCX)
 
- -- Function: void cblas_stpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const float * AP,
+ -- Function: void cblas_strsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const float * A, const int LDA,
           float * X, const int INCX)
 
- -- Function: void cblas_strsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const float * A,
+ -- Function: void cblas_stbsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const float * A,
           const int LDA, float * X, const int INCX)
 
- -- Function: void cblas_stbsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          float * A, const int LDA, float * X, const int INCX)
-
- -- Function: void cblas_stpsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const float * AP,
-          float * X, const int INCX)
+ -- Function: void cblas_stpsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const float * AP, float * X,
+          const int INCX)
 
- -- Function: void cblas_dgemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          double ALPHA, const double * A, const int LDA, const double *
-          X, const int INCX, const double BETA, double * Y, const int
-          INCY)
-
- -- Function: void cblas_dgbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          int KL, const int KU, const double ALPHA, const double * A,
-          const int LDA, const double * X, const int INCX, const double
-          BETA, double * Y, const int INCY)
-
- -- Function: void cblas_dtrmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const double * A,
-          const int LDA, double * X, const int INCX)
+ -- Function: void cblas_dgemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const double
+          ALPHA, const double * A, const int LDA, const double * X,
+          const int INCX, const double BETA, double * Y, const int INCY)
 
- -- Function: void cblas_dtbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          double * A, const int LDA, double * X, const int INCX)
+ -- Function: void cblas_dgbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const int
+          KL, const int KU, const double ALPHA, const double * A, const
+          int LDA, const double * X, const int INCX, const double BETA,
+          double * Y, const int INCY)
 
- -- Function: void cblas_dtpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const double * AP,
+ -- Function: void cblas_dtrmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const double * A, const int LDA,
           double * X, const int INCX)
 
- -- Function: void cblas_dtrsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const double * A,
+ -- Function: void cblas_dtbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const double * A,
           const int LDA, double * X, const int INCX)
 
- -- Function: void cblas_dtbsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          double * A, const int LDA, double * X, const int INCX)
+ -- Function: void cblas_dtpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const double * AP, double * X,
+          const int INCX)
 
- -- Function: void cblas_dtpsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const double * AP,
+ -- Function: void cblas_dtrsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const double * A, const int LDA,
           double * X, const int INCX)
 
- -- Function: void cblas_cgemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          void * ALPHA, const void * A, const int LDA, const void * X,
-          const int INCX, const void * BETA, void * Y, const int INCY)
+ -- Function: void cblas_dtbsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const double * A,
+          const int LDA, double * X, const int INCX)
 
- -- Function: void cblas_cgbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          int KL, const int KU, const void * ALPHA, const void * A,
-          const int LDA, const void * X, const int INCX, const void *
-          BETA, void * Y, const int INCY)
+ -- Function: void cblas_dtpsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const double * AP, double * X,
+          const int INCX)
 
- -- Function: void cblas_ctrmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * A,
-          const int LDA, void * X, const int INCX)
+ -- Function: void cblas_cgemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const void *
+          ALPHA, const void * A, const int LDA, const void * X, const
+          int INCX, const void * BETA, void * Y, const int INCY)
 
- -- Function: void cblas_ctbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          void * A, const int LDA, void * X, const int INCX)
+ -- Function: void cblas_cgbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const int
+          KL, const int KU, const void * ALPHA, const void * A, const
+          int LDA, const void * X, const int INCX, const void * BETA,
+          void * Y, const int INCY)
 
- -- Function: void cblas_ctpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * AP,
+ -- Function: void cblas_ctrmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * A, const int LDA,
           void * X, const int INCX)
 
- -- Function: void cblas_ctrsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * A,
+ -- Function: void cblas_ctbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const void * A,
           const int LDA, void * X, const int INCX)
 
- -- Function: void cblas_ctbsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          void * A, const int LDA, void * X, const int INCX)
+ -- Function: void cblas_ctpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * AP, void * X, const
+          int INCX)
 
- -- Function: void cblas_ctpsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * AP,
+ -- Function: void cblas_ctrsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * A, const int LDA,
           void * X, const int INCX)
 
- -- Function: void cblas_zgemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          void * ALPHA, const void * A, const int LDA, const void * X,
-          const int INCX, const void * BETA, void * Y, const int INCY)
+ -- Function: void cblas_ctbsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const void * A,
+          const int LDA, void * X, const int INCX)
 
- -- Function: void cblas_zgbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const int M, const int N, const
-          int KL, const int KU, const void * ALPHA, const void * A,
-          const int LDA, const void * X, const int INCX, const void *
-          BETA, void * Y, const int INCY)
+ -- Function: void cblas_ctpsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * AP, void * X, const
+          int INCX)
 
- -- Function: void cblas_ztrmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * A,
-          const int LDA, void * X, const int INCX)
+ -- Function: void cblas_zgemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const void *
+          ALPHA, const void * A, const int LDA, const void * X, const
+          int INCX, const void * BETA, void * Y, const int INCY)
 
- -- Function: void cblas_ztbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          void * A, const int LDA, void * X, const int INCX)
+ -- Function: void cblas_zgbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const int M, const int N, const int
+          KL, const int KU, const void * ALPHA, const void * A, const
+          int LDA, const void * X, const int INCX, const void * BETA,
+          void * Y, const int INCY)
 
- -- Function: void cblas_ztpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * AP,
+ -- Function: void cblas_ztrmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * A, const int LDA,
           void * X, const int INCX)
 
- -- Function: void cblas_ztrsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * A,
+ -- Function: void cblas_ztbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const void * A,
           const int LDA, void * X, const int INCX)
 
- -- Function: void cblas_ztbsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const int K, const
-          void * A, const int LDA, void * X, const int INCX)
+ -- Function: void cblas_ztpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * AP, void * X, const
+          int INCX)
 
- -- Function: void cblas_ztpsv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA,
-          const enum CBLAS_DIAG DIAG, const int N, const void * AP,
+ -- Function: void cblas_ztrsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * A, const int LDA,
           void * X, const int INCX)
 
- -- Function: void cblas_ssymv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const float ALPHA, const
-          float * A, const int LDA, const float * X, const int INCX,
-          const float BETA, float * Y, const int INCY)
+ -- Function: void cblas_ztbsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const int K, const void * A,
+          const int LDA, void * X, const int INCX)
 
- -- Function: void cblas_ssbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const int K, const float
-          ALPHA, const float * A, const int LDA, const float * X, const
-          int INCX, const float BETA, float * Y, const int INCY)
+ -- Function: void cblas_ztpsv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANSA, const enum
+          CBLAS_DIAG DIAG, const int N, const void * AP, void * X, const
+          int INCX)
 
- -- Function: void cblas_sspmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const float ALPHA, const
-          float * AP, const float * X, const int INCX, const float
+ -- Function: void cblas_ssymv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          A, const int LDA, const float * X, const int INCX, const float
           BETA, float * Y, const int INCY)
 
+ -- Function: void cblas_ssbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const int K, const float ALPHA,
+          const float * A, const int LDA, const float * X, const int
+          INCX, const float BETA, float * Y, const int INCY)
+
+ -- Function: void cblas_sspmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          AP, const float * X, const int INCX, const float BETA, float *
+          Y, const int INCY)
+
  -- Function: void cblas_sger (const enum CBLAS_ORDER ORDER, const int
           M, const int N, const float ALPHA, const float * X, const int
           INCX, const float * Y, const int INCY, float * A, const int
           LDA)
 
  -- Function: void cblas_ssyr (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float
-          * X, const int INCX, float * A, const int LDA)
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          X, const int INCX, float * A, const int LDA)
 
  -- Function: void cblas_sspr (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float
-          * X, const int INCX, float * AP)
-
- -- Function: void cblas_ssyr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const float ALPHA, const
-          float * X, const int INCX, const float * Y, const int INCY,
-          float * A, const int LDA)
-
- -- Function: void cblas_sspr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const float ALPHA, const
-          float * X, const int INCX, const float * Y, const int INCY,
-          float * A)
-
- -- Function: void cblas_dsymv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * A, const int LDA, const double * X, const int INCX,
-          const double BETA, double * Y, const int INCY)
-
- -- Function: void cblas_dsbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const int K, const double
-          ALPHA, const double * A, const int LDA, const double * X,
-          const int INCX, const double BETA, double * Y, const int INCY)
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          X, const int INCX, float * AP)
+
+ -- Function: void cblas_ssyr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          X, const int INCX, const float * Y, const int INCY, float * A,
+          const int LDA)
 
- -- Function: void cblas_dspmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * AP, const double * X, const int INCX, const double
-          BETA, double * Y, const int INCY)
+ -- Function: void cblas_sspr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const float ALPHA, const float *
+          X, const int INCX, const float * Y, const int INCY, float * A)
+
+ -- Function: void cblas_dsymv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * A, const int LDA, const double * X, const int INCX, const
+          double BETA, double * Y, const int INCY)
+
+ -- Function: void cblas_dsbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const int K, const double ALPHA,
+          const double * A, const int LDA, const double * X, const int
+          INCX, const double BETA, double * Y, const int INCY)
+
+ -- Function: void cblas_dspmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * AP, const double * X, const int INCX, const double BETA,
+          double * Y, const int INCY)
 
  -- Function: void cblas_dger (const enum CBLAS_ORDER ORDER, const int
           M, const int N, const double ALPHA, const double * X, const
@@ -3188,37 +3146,37 @@ D.2 Level 2
           int LDA)
 
  -- Function: void cblas_dsyr (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * X, const int INCX, double * A, const int LDA)
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * X, const int INCX, double * A, const int LDA)
 
  -- Function: void cblas_dspr (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * X, const int INCX, double * AP)
-
- -- Function: void cblas_dsyr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * X, const int INCX, const double * Y, const int INCY,
-          double * A, const int LDA)
-
- -- Function: void cblas_dspr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const double ALPHA, const
-          double * X, const int INCX, const double * Y, const int INCY,
-          double * A)
-
- -- Function: void cblas_chemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * A, const int LDA, const void * X, const int INCX,
-          const void * BETA, void * Y, const int INCY)
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * X, const int INCX, double * AP)
+
+ -- Function: void cblas_dsyr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * X, const int INCX, const double * Y, const int INCY, double
+          * A, const int LDA)
+
+ -- Function: void cblas_dspr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const double
+          * X, const int INCX, const double * Y, const int INCY, double
+          * A)
+
+ -- Function: void cblas_chemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          A, const int LDA, const void * X, const int INCX, const void *
+          BETA, void * Y, const int INCY)
 
- -- Function: void cblas_chbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const int K, const void *
-          ALPHA, const void * A, const int LDA, const void * X, const
-          int INCX, const void * BETA, void * Y, const int INCY)
+ -- Function: void cblas_chbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const int K, const void * ALPHA,
+          const void * A, const int LDA, const void * X, const int INCX,
+          const void * BETA, void * Y, const int INCY)
 
- -- Function: void cblas_chpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * AP, const void * X, const int INCX, const void * BETA,
-          void * Y, const int INCY)
+ -- Function: void cblas_chpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          AP, const void * X, const int INCX, const void * BETA, void *
+          Y, const int INCY)
 
  -- Function: void cblas_cgeru (const enum CBLAS_ORDER ORDER, const int
           M, const int N, const void * ALPHA, const void * X, const int
@@ -3236,30 +3194,29 @@ D.2 Level 2
           CBLAS_UPLO UPLO, const int N, const float ALPHA, const void *
           X, const int INCX, void * A)
 
- -- Function: void cblas_cher2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * X, const int INCX, const void * Y, const int INCY,
-          void * A, const int LDA)
+ -- Function: void cblas_cher2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          X, const int INCX, const void * Y, const int INCY, void * A,
+          const int LDA)
 
- -- Function: void cblas_chpr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * X, const int INCX, const void * Y, const int INCY,
-          void * AP)
+ -- Function: void cblas_chpr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          X, const int INCX, const void * Y, const int INCY, void * AP)
 
- -- Function: void cblas_zhemv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * A, const int LDA, const void * X, const int INCX,
+ -- Function: void cblas_zhemv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          A, const int LDA, const void * X, const int INCX, const void *
+          BETA, void * Y, const int INCY)
+
+ -- Function: void cblas_zhbmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const int K, const void * ALPHA,
+          const void * A, const int LDA, const void * X, const int INCX,
           const void * BETA, void * Y, const int INCY)
 
- -- Function: void cblas_zhbmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const int K, const void *
-          ALPHA, const void * A, const int LDA, const void * X, const
-          int INCX, const void * BETA, void * Y, const int INCY)
-
- -- Function: void cblas_zhpmv (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * AP, const void * X, const int INCX, const void * BETA,
-          void * Y, const int INCY)
+ -- Function: void cblas_zhpmv (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          AP, const void * X, const int INCX, const void * BETA, void *
+          Y, const int INCY)
 
  -- Function: void cblas_zgeru (const enum CBLAS_ORDER ORDER, const int
           M, const int N, const void * ALPHA, const void * X, const int
@@ -3270,22 +3227,21 @@ D.2 Level 2
           INCX, const void * Y, const int INCY, void * A, const int LDA)
 
  -- Function: void cblas_zher (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const double ALPHA, const void
-          * X, const int INCX, void * A, const int LDA)
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const void *
+          X, const int INCX, void * A, const int LDA)
 
  -- Function: void cblas_zhpr (const enum CBLAS_ORDER ORDER, const enum
-          CBLAS_UPLO UPLO, const int N, const double ALPHA, const void
-          * X, const int INCX, void * A)
+          CBLAS_UPLO UPLO, const int N, const double ALPHA, const void *
+          X, const int INCX, void * A)
 
- -- Function: void cblas_zher2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * X, const int INCX, const void * Y, const int INCY,
-          void * A, const int LDA)
+ -- Function: void cblas_zher2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          X, const int INCX, const void * Y, const int INCY, void * A,
+          const int LDA)
 
- -- Function: void cblas_zhpr2 (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const int N, const void * ALPHA, const
-          void * X, const int INCX, const void * Y, const int INCY,
-          void * AP)
+ -- Function: void cblas_zhpr2 (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const int N, const void * ALPHA, const void *
+          X, const int INCX, const void * Y, const int INCY, void * AP)
 
 
 File: gsl-ref.info,  Node: Level 3 CBLAS Functions,  Next: GSL CBLAS Examples,  Prev: Level 2 CBLAS Functions,  Up: GSL CBLAS Library
@@ -3293,22 +3249,22 @@ File: gsl-ref.info,  Node: Level 3 CBLAS Functions,  Next: GSL CBLAS Examples,
 D.3 Level 3
 ===========
 
- -- Function: void cblas_sgemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE
-          TRANSB, const int M, const int N, const int K, const float
-          ALPHA, const float * A, const int LDA, const float * B, const
-          int LDB, const float BETA, float * C, const int LDC)
+ -- Function: void cblas_sgemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE TRANSB,
+          const int M, const int N, const int K, const float ALPHA,
+          const float * A, const int LDA, const float * B, const int
+          LDB, const float BETA, float * C, const int LDC)
 
- -- Function: void cblas_ssymm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const float ALPHA, const float * A, const int
-          LDA, const float * B, const int LDB, const float BETA, float
-          * C, const int LDC)
+ -- Function: void cblas_ssymm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const float ALPHA, const float * A, const int
+          LDA, const float * B, const int LDB, const float BETA, float *
+          C, const int LDC)
 
- -- Function: void cblas_ssyrk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const float ALPHA, const float * A, const
-          int LDA, const float BETA, float * C, const int LDC)
+ -- Function: void cblas_ssyrk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const float ALPHA, const float * A, const int
+          LDA, const float BETA, float * C, const int LDC)
 
  -- Function: void cblas_ssyr2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
@@ -3316,34 +3272,34 @@ D.3 Level 3
           int LDA, const float * B, const int LDB, const float BETA,
           float * C, const int LDC)
 
- -- Function: void cblas_strmm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_strmm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const float ALPHA, const float * A, const int
           LDA, float * B, const int LDB)
 
- -- Function: void cblas_strsm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_strsm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const float ALPHA, const float * A, const int
           LDA, float * B, const int LDB)
 
- -- Function: void cblas_dgemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE
-          TRANSB, const int M, const int N, const int K, const double
-          ALPHA, const double * A, const int LDA, const double * B,
-          const int LDB, const double BETA, double * C, const int LDC)
+ -- Function: void cblas_dgemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE TRANSB,
+          const int M, const int N, const int K, const double ALPHA,
+          const double * A, const int LDA, const double * B, const int
+          LDB, const double BETA, double * C, const int LDC)
 
- -- Function: void cblas_dsymm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const double ALPHA, const double * A, const
-          int LDA, const double * B, const int LDB, const double BETA,
+ -- Function: void cblas_dsymm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const double ALPHA, const double * A, const int
+          LDA, const double * B, const int LDB, const double BETA,
           double * C, const int LDC)
 
- -- Function: void cblas_dsyrk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const double ALPHA, const double * A,
-          const int LDA, const double BETA, double * C, const int LDC)
+ -- Function: void cblas_dsyrk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const double ALPHA, const double * A, const
+          int LDA, const double BETA, double * C, const int LDC)
 
  -- Function: void cblas_dsyr2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
@@ -3351,34 +3307,34 @@ D.3 Level 3
           const int LDA, const double * B, const int LDB, const double
           BETA, double * C, const int LDC)
 
- -- Function: void cblas_dtrmm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_dtrmm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const double ALPHA, const double * A, const
           int LDA, double * B, const int LDB)
 
- -- Function: void cblas_dtrsm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_dtrsm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const double ALPHA, const double * A, const
           int LDA, double * B, const int LDB)
 
- -- Function: void cblas_cgemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE
-          TRANSB, const int M, const int N, const int K, const void *
-          ALPHA, const void * A, const int LDA, const void * B, const
-          int LDB, const void * BETA, void * C, const int LDC)
+ -- Function: void cblas_cgemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE TRANSB,
+          const int M, const int N, const int K, const void * ALPHA,
+          const void * A, const int LDA, const void * B, const int LDB,
+          const void * BETA, void * C, const int LDC)
 
- -- Function: void cblas_csymm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const void * ALPHA, const void * A, const int
+ -- Function: void cblas_csymm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const void * ALPHA, const void * A, const int
           LDA, const void * B, const int LDB, const void * BETA, void *
           C, const int LDC)
 
- -- Function: void cblas_csyrk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const void * ALPHA, const void * A, const
-          int LDA, const void * BETA, void * C, const int LDC)
+ -- Function: void cblas_csyrk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const void * ALPHA, const void * A, const int
+          LDA, const void * BETA, void * C, const int LDC)
 
  -- Function: void cblas_csyr2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
@@ -3386,34 +3342,34 @@ D.3 Level 3
           int LDA, const void * B, const int LDB, const void * BETA,
           void * C, const int LDC)
 
- -- Function: void cblas_ctrmm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_ctrmm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const void * ALPHA, const void * A, const int
           LDA, void * B, const int LDB)
 
- -- Function: void cblas_ctrsm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_ctrsm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const void * ALPHA, const void * A, const int
           LDA, void * B, const int LDB)
 
- -- Function: void cblas_zgemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE
-          TRANSB, const int M, const int N, const int K, const void *
-          ALPHA, const void * A, const int LDA, const void * B, const
-          int LDB, const void * BETA, void * C, const int LDC)
+ -- Function: void cblas_zgemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_TRANSPOSE TRANSA, const enum CBLAS_TRANSPOSE TRANSB,
+          const int M, const int N, const int K, const void * ALPHA,
+          const void * A, const int LDA, const void * B, const int LDB,
+          const void * BETA, void * C, const int LDC)
 
- -- Function: void cblas_zsymm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const void * ALPHA, const void * A, const int
+ -- Function: void cblas_zsymm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const void * ALPHA, const void * A, const int
           LDA, const void * B, const int LDB, const void * BETA, void *
           C, const int LDC)
 
- -- Function: void cblas_zsyrk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const void * ALPHA, const void * A, const
-          int LDA, const void * BETA, void * C, const int LDC)
+ -- Function: void cblas_zsyrk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const void * ALPHA, const void * A, const int
+          LDA, const void * BETA, void * C, const int LDC)
 
  -- Function: void cblas_zsyr2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
@@ -3421,45 +3377,45 @@ D.3 Level 3
           int LDA, const void * B, const int LDB, const void * BETA,
           void * C, const int LDC)
 
- -- Function: void cblas_ztrmm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_ztrmm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const void * ALPHA, const void * A, const int
           LDA, void * B, const int LDB)
 
- -- Function: void cblas_ztrsm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
+ -- Function: void cblas_ztrsm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const enum
           CBLAS_TRANSPOSE TRANSA, const enum CBLAS_DIAG DIAG, const int
           M, const int N, const void * ALPHA, const void * A, const int
           LDA, void * B, const int LDB)
 
- -- Function: void cblas_chemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const void * ALPHA, const void * A, const int
+ -- Function: void cblas_chemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const void * ALPHA, const void * A, const int
           LDA, const void * B, const int LDB, const void * BETA, void *
           C, const int LDC)
 
- -- Function: void cblas_cherk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const float ALPHA, const void * A, const
-          int LDA, const float BETA, void * C, const int LDC)
+ -- Function: void cblas_cherk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const float ALPHA, const void * A, const int
+          LDA, const float BETA, void * C, const int LDC)
 
  -- Function: void cblas_cher2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
           int N, const int K, const void * ALPHA, const void * A, const
-          int LDA, const void * B, const int LDB, const float BETA,
-          void * C, const int LDC)
+          int LDA, const void * B, const int LDB, const float BETA, void
+          * C, const int LDC)
 
- -- Function: void cblas_zhemm (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int
-          M, const int N, const void * ALPHA, const void * A, const int
+ -- Function: void cblas_zhemm (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO, const int M,
+          const int N, const void * ALPHA, const void * A, const int
           LDA, const void * B, const int LDB, const void * BETA, void *
           C, const int LDC)
 
- -- Function: void cblas_zherk (const enum CBLAS_ORDER ORDER, const
-          enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
-          int N, const int K, const double ALPHA, const void * A, const
-          int LDA, const double BETA, void * C, const int LDC)
+ -- Function: void cblas_zherk (const enum CBLAS_ORDER ORDER, const enum
+          CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const int
+          N, const int K, const double ALPHA, const void * A, const int
+          LDA, const double BETA, void * C, const int LDC)
 
  -- Function: void cblas_zher2k (const enum CBLAS_ORDER ORDER, const
           enum CBLAS_UPLO UPLO, const enum CBLAS_TRANSPOSE TRANS, const
@@ -3484,8 +3440,8 @@ Level-3 BLAS function SGEMM,
                          [ 1031 1032 ]
 
 The matrices are stored in row major order but could be stored in column
-major order if the first argument of the call to `cblas_sgemm' was
-changed to `CblasColMajor'.
+major order if the first argument of the call to 'cblas_sgemm' was
+changed to 'CblasColMajor'.
 
      #include <stdio.h>
      #include <gsl/gsl_cblas.h>
@@ -3525,8 +3481,8 @@ To compile the program use the following command line,
 
      $ gcc -Wall demo.c -lgslcblas
 
-There is no need to link with the main library `-lgsl' in this case as
-the CBLAS library is an independent unit. Here is the output from the
+There is no need to link with the main library '-lgsl' in this case as
+the CBLAS library is an independent unit.  Here is the output from the
 program,
 
      $ ./a.out
@@ -3553,14 +3509,14 @@ free tutorial, that is a major gap.  We have many such gaps today.
    Consider Perl, for instance.  The tutorial manuals that people
 normally use are non-free.  How did this come about?  Because the
 authors of those manuals published them with restrictive terms--no
-copying, no modification, source files not available--which exclude
-them from the free software world.
+copying, no modification, source files not available--which exclude them
+from the free software world.
 
    That wasn't the first time this sort of thing happened, and it was
-far from the last.  Many times we have heard a GNU user eagerly
-describe a manual that he is writing, his intended contribution to the
-community, only to learn that he had ruined everything by signing a
-publication contract to make it non-free.
+far from the last.  Many times we have heard a GNU user eagerly describe
+a manual that he is writing, his intended contribution to the community,
+only to learn that he had ruined everything by signing a publication
+contract to make it non-free.
 
    Free documentation, like free software, is a matter of freedom, not
 price.  The problem with the non-free manual is not that publishers
@@ -3571,9 +3527,9 @@ available in source code form, and give you permission to copy and
 modify.  Non-free manuals do not allow this.
 
    The criteria of freedom for a free manual are roughly the same as for
-free software.  Redistribution (including the normal kinds of
-commercial redistribution) must be permitted, so that the manual can
-accompany every copy of the program, both on-line and on paper.
+free software.  Redistribution (including the normal kinds of commercial
+redistribution) must be permitted, so that the manual can accompany
+every copy of the program, both on-line and on paper.
 
    Permission for modification of the technical content is crucial too.
 When people modify the software, adding or changing features, if they
@@ -3583,35 +3539,35 @@ that leaves you no choice but to write a new manual to document a
 changed version of the program is not really available to our community.
 
    Some kinds of limits on the way modification is handled are
-acceptable.  For example, requirements to preserve the original
-author's copyright notice, the distribution terms, or the list of
-authors, are ok.  It is also no problem to require modified versions to
-include notice that they were modified.  Even entire sections that may
-not be deleted or changed are acceptable, as long as they deal with
+acceptable.  For example, requirements to preserve the original author's
+copyright notice, the distribution terms, or the list of authors, are
+ok.  It is also no problem to require modified versions to include
+notice that they were modified.  Even entire sections that may not be
+deleted or changed are acceptable, as long as they deal with
 nontechnical topics (like this one).  These kinds of restrictions are
-acceptable because they don't obstruct the community's normal use of
-the manual.
+acceptable because they don't obstruct the community's normal use of the
+manual.
 
-   However, it must be possible to modify all the _technical_ content
-of the manual, and then distribute the result in all the usual media,
+   However, it must be possible to modify all the _technical_ content of
+the manual, and then distribute the result in all the usual media,
 through all the usual channels.  Otherwise, the restrictions obstruct
 the use of the manual, it is not free, and we need another manual to
 replace it.
 
    Please spread the word about this issue.  Our community continues to
-lose manuals to proprietary publishing.  If we spread the word that
-free software needs free reference manuals and free tutorials, perhaps
-the next person who wants to contribute by writing documentation will
-realize, before it is too late, that only free manuals contribute to
-the free software community.
+lose manuals to proprietary publishing.  If we spread the word that free
+software needs free reference manuals and free tutorials, perhaps the
+next person who wants to contribute by writing documentation will
+realize, before it is too late, that only free manuals contribute to the
+free software community.
 
    If you are writing documentation, please insist on publishing it
 under the GNU Free Documentation License or another free documentation
 license.  Remember that this decision requires your approval--you don't
-have to let the publisher decide.  Some commercial publishers will use
-a free license if you insist, but they will not propose the option; it
-is up to you to raise the issue and say firmly that this is what you
-want.  If the publisher you are dealing with refuses, please try other
+have to let the publisher decide.  Some commercial publishers will use a
+free license if you insist, but they will not propose the option; it is
+up to you to raise the issue and say firmly that this is what you want.
+If the publisher you are dealing with refuses, please try other
 publishers.  If you're not sure whether a proposed license is free,
 write to <licensing@gnu.org>.
 
@@ -3627,7 +3583,7 @@ paid or pay the authors to work on it.
    The Free Software Foundation maintains a list of free documentation
 published by other publishers:
 
-     `http://www.fsf.org/doc/other-free-books.html'
+     <http://www.fsf.org/doc/other-free-books.html>
 
 
 File: gsl-ref.info,  Node: GNU General Public License,  Next: GNU Free Documentation License,  Prev: Free Software Needs Free Documentation,  Up: Top
@@ -3636,6 +3592,7 @@ GNU General Public License
 **************************
 
                          Version 2, June 1991
+
      Copyright (C) 1989, 1991 Free Software Foundation, Inc.
      59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
 
@@ -3645,22 +3602,21 @@ GNU General Public License
 Preamble
 ========
 
-The licenses for most software are designed to take away your freedom
-to share and change it.  By contrast, the GNU General Public License is
-intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
+The licenses for most software are designed to take away your freedom to
+share and change it.  By contrast, the GNU General Public License is
+intended to guarantee your freedom to share and change free software--to
+make sure the software is free for all its users.  This General Public
+License applies to most of the Free Software Foundation's software and
+to any other program whose authors commit to using it.  (Some other Free
+Software Foundation software is covered by the GNU Library General
+Public License instead.)  You can apply it to your programs, too.
 
    When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it in
-new free programs; and that you know you can do these things.
+this service if you wish), that you receive source code or can get it if
+you want it, that you can change the software or use pieces of it in new
+free programs; and that you know you can do these things.
 
    To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
@@ -3694,11 +3650,12 @@ patent must be licensed for everyone's free use or not licensed at all.
 modification follow.
 
     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
   0. This License applies to any program or other work which contains a
      notice placed by the copyright holder saying it may be distributed
      under the terms of this General Public License.  The "Program",
-     below, refers to any such program or work, and a "work based on
-     the Program" means either the Program or any derivative work under
+     below, refers to any such program or work, and a "work based on the
+     Program" means either the Program or any derivative work under
      copyright law: that is to say, a work containing the Program or a
      portion of it, either verbatim or with modifications and/or
      translated into another language.  (Hereinafter, translation is
@@ -3712,8 +3669,8 @@ modification follow.
      the Program (independent of having been made by running the
      Program).  Whether that is true depends on what the Program does.
 
-  1. You may copy and distribute verbatim copies of the Program's
-     source code as you receive it, in any medium, provided that you
+  1. You may copy and distribute verbatim copies of the Program's source
+     code as you receive it, in any medium, provided that you
      conspicuously and appropriately publish on each copy an appropriate
      copyright notice and disclaimer of warranty; keep intact all the
      notices that refer to this License and to the absence of any
@@ -3724,8 +3681,8 @@ modification follow.
      and you may at your option offer warranty protection in exchange
      for a fee.
 
-  2. You may modify your copy or copies of the Program or any portion
-     of it, thus forming a work based on the Program, and copy and
+  2. You may modify your copy or copies of the Program or any portion of
+     it, thus forming a work based on the Program, and copy and
      distribute such modifications or work under the terms of Section 1
      above, provided that you also meet all of these conditions:
 
@@ -3733,9 +3690,9 @@ modification follow.
           stating that you changed the files and the date of any change.
 
        b. You must cause any work that you distribute or publish, that
-          in whole or in part contains or is derived from the Program
-          or any part thereof, to be licensed as a whole at no charge
-          to all third parties under the terms of this License.
+          in whole or in part contains or is derived from the Program or
+          any part thereof, to be licensed as a whole at no charge to
+          all third parties under the terms of this License.
 
        c. If the modified program normally reads commands interactively
           when run, you must cause it, when started running for such
@@ -3752,13 +3709,13 @@ modification follow.
      These requirements apply to the modified work as a whole.  If
      identifiable sections of that work are not derived from the
      Program, and can be reasonably considered independent and separate
-     works in themselves, then this License, and its terms, do not
-     apply to those sections when you distribute them as separate
-     works.  But when you distribute the same sections as part of a
-     whole which is a work based on the Program, the distribution of
-     the whole must be on the terms of this License, whose permissions
-     for other licensees extend to the entire whole, and thus to each
-     and every part regardless of who wrote it.
+     works in themselves, then this License, and its terms, do not apply
+     to those sections when you distribute them as separate works.  But
+     when you distribute the same sections as part of a whole which is a
+     work based on the Program, the distribution of the whole must be on
+     the terms of this License, whose permissions for other licensees
+     extend to the entire whole, and thus to each and every part
+     regardless of who wrote it.
 
      Thus, it is not the intent of this section to claim rights or
      contest your rights to work written entirely by you; rather, the
@@ -3766,9 +3723,9 @@ modification follow.
      derivative or collective works based on the Program.
 
      In addition, mere aggregation of another work not based on the
-     Program with the Program (or with a work based on the Program) on
-     a volume of a storage or distribution medium does not bring the
-     other work under the scope of this License.
+     Program with the Program (or with a work based on the Program) on a
+     volume of a storage or distribution medium does not bring the other
+     work under the scope of this License.
 
   3. You may copy and distribute the Program (or a work based on it,
      under Section 2) in object code or executable form under the terms
@@ -3799,10 +3756,10 @@ modification follow.
      plus any associated interface definition files, plus the scripts
      used to control compilation and installation of the executable.
      However, as a special exception, the source code distributed need
-     not include anything that is normally distributed (in either
-     source or binary form) with the major components (compiler,
-     kernel, and so on) of the operating system on which the executable
-     runs, unless that component itself accompanies the executable.
+     not include anything that is normally distributed (in either source
+     or binary form) with the major components (compiler, kernel, and so
+     on) of the operating system on which the executable runs, unless
+     that component itself accompanies the executable.
 
      If distribution of executable or object code is made by offering
      access to copy from a designated place, then offering equivalent
@@ -3815,25 +3772,25 @@ modification follow.
      otherwise to copy, modify, sublicense or distribute the Program is
      void, and will automatically terminate your rights under this
      License.  However, parties who have received copies, or rights,
-     from you under this License will not have their licenses
-     terminated so long as such parties remain in full compliance.
+     from you under this License will not have their licenses terminated
+     so long as such parties remain in full compliance.
 
   5. You are not required to accept this License, since you have not
      signed it.  However, nothing else grants you permission to modify
      or distribute the Program or its derivative works.  These actions
      are prohibited by law if you do not accept this License.
      Therefore, by modifying or distributing the Program (or any work
-     based on the Program), you indicate your acceptance of this
-     License to do so, and all its terms and conditions for copying,
+     based on the Program), you indicate your acceptance of this License
+     to do so, and all its terms and conditions for copying,
      distributing or modifying the Program or works based on it.
 
   6. Each time you redistribute the Program (or any work based on the
      Program), the recipient automatically receives a license from the
-     original licensor to copy, distribute or modify the Program
-     subject to these terms and conditions.  You may not impose any
-     further restrictions on the recipients' exercise of the rights
-     granted herein.  You are not responsible for enforcing compliance
-     by third parties to this License.
+     original licensor to copy, distribute or modify the Program subject
+     to these terms and conditions.  You may not impose any further
+     restrictions on the recipients' exercise of the rights granted
+     herein.  You are not responsible for enforcing compliance by third
+     parties to this License.
 
   7. If, as a consequence of a court judgment or allegation of patent
      infringement or for any other reason (not limited to patent
@@ -3844,10 +3801,10 @@ modification follow.
      your obligations under this License and any other pertinent
      obligations, then as a consequence you may not distribute the
      Program at all.  For example, if a patent license would not permit
-     royalty-free redistribution of the Program by all those who
-     receive copies directly or indirectly through you, then the only
-     way you could satisfy both it and this License would be to refrain
-     entirely from distribution of the Program.
+     royalty-free redistribution of the Program by all those who receive
+     copies directly or indirectly through you, then the only way you
+     could satisfy both it and this License would be to refrain entirely
+     from distribution of the Program.
 
      If any portion of this section is held invalid or unenforceable
      under any particular circumstance, the balance of the section is
@@ -3878,40 +3835,41 @@ modification follow.
      this License.
 
   9. The Free Software Foundation may publish revised and/or new
-     versions of the General Public License from time to time.  Such
-     new versions will be similar in spirit to the present version, but
-     may differ in detail to address new problems or concerns.
+     versions of the General Public License from time to time.  Such new
+     versions will be similar in spirit to the present version, but may
+     differ in detail to address new problems or concerns.
 
      Each version is given a distinguishing version number.  If the
-     Program specifies a version number of this License which applies
-     to it and "any later version", you have the option of following
-     the terms and conditions either of that version or of any later
-     version published by the Free Software Foundation.  If the Program
-     does not specify a version number of this License, you may choose
-     any version ever published by the Free Software Foundation.
-
- 10. If you wish to incorporate parts of the Program into other free
+     Program specifies a version number of this License which applies to
+     it and "any later version", you have the option of following the
+     terms and conditions either of that version or of any later version
+     published by the Free Software Foundation.  If the Program does not
+     specify a version number of this License, you may choose any
+     version ever published by the Free Software Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
      programs whose distribution conditions are different, write to the
-     author to ask for permission.  For software which is copyrighted
-     by the Free Software Foundation, write to the Free Software
+     author to ask for permission.  For software which is copyrighted by
+     the Free Software Foundation, write to the Free Software
      Foundation; we sometimes make exceptions for this.  Our decision
      will be guided by the two goals of preserving the free status of
      all derivatives of our free software and of promoting the sharing
      and reuse of software generally.
 
-                                NO WARRANTY
- 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
+                              NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
      WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
-     LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-     HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
-     WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
-     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-     FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE
-     QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-     PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
-     SERVICING, REPAIR OR CORRECTION.
-
- 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+     LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS
+     AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+     OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+     FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+     PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+     DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR
+     OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
      WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
      MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
      LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
@@ -3923,6 +3881,7 @@ modification follow.
      ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
                       END OF TERMS AND CONDITIONS
+
 Appendix: How to Apply These Terms to Your New Programs
 =======================================================
 
@@ -3933,11 +3892,11 @@ terms.
 
    To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
 
-     one line to give the program's name and a brief idea
-     of whAT IT DOES.
+     ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA 
+     OF WHAT IT DOES.
      Copyright (C) YYYY  NAME OF AUTHOR
 
      This program is free software; you can redistribute it
@@ -3969,9 +3928,9 @@ this when it starts in an interactive mode:
      to redistribute it under certain conditions; type `show c'
      for details.
 
-   The hypothetical commands `show w' and `show c' should show the
+   The hypothetical commands 'show w' and 'show c' should show the
 appropriate parts of the General Public License.  Of course, the
-commands you use may be called something other than `show w' and `show
+commands you use may be called something other than 'show w' and 'show
 c'; they could even be mouse-clicks or menu items--whatever suits your
 program.
 
@@ -3999,6 +3958,7 @@ GNU Free Documentation License
 ******************************
 
                       Version 1.2, November 2002
+
      Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
      51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
@@ -4025,21 +3985,21 @@ GNU Free Documentation License
      free program should come with manuals providing the same freedoms
      that the software does.  But this License is not limited to
      software manuals; it can be used for any textual work, regardless
-     of subject matter or whether it is published as a printed book.
-     We recommend this License principally for works whose purpose is
+     of subject matter or whether it is published as a printed book.  We
+     recommend this License principally for works whose purpose is
      instruction or reference.
 
   1. APPLICABILITY AND DEFINITIONS
 
      This License applies to any manual or other work, in any medium,
-     that contains a notice placed by the copyright holder saying it
-     can be distributed under the terms of this License.  Such a notice
+     that contains a notice placed by the copyright holder saying it can
+     be distributed under the terms of this License.  Such a notice
      grants a world-wide, royalty-free license, unlimited in duration,
      to use that work under the conditions stated herein.  The
      "Document", below, refers to any such manual or work.  Any member
-     of the public is a licensee, and is addressed as "you".  You
-     accept the license if you copy, modify or distribute the work in a
-     way requiring permission under copyright law.
+     of the public is a licensee, and is addressed as "you".  You accept
+     the license if you copy, modify or distribute the work in a way
+     requiring permission under copyright law.
 
      A "Modified Version" of the Document means any work containing the
      Document or a portion of it, either copied verbatim, or with
@@ -4057,12 +4017,12 @@ GNU Free Documentation License
      regarding them.
 
      The "Invariant Sections" are certain Secondary Sections whose
-     titles are designated, as being those of Invariant Sections, in
-     the notice that says that the Document is released under this
-     License.  If a section does not fit the above definition of
-     Secondary then it is not allowed to be designated as Invariant.
-     The Document may contain zero Invariant Sections.  If the Document
-     does not identify any Invariant Sections then there are none.
+     titles are designated, as being those of Invariant Sections, in the
+     notice that says that the Document is released under this License.
+     If a section does not fit the above definition of Secondary then it
+     is not allowed to be designated as Invariant.  The Document may
+     contain zero Invariant Sections.  If the Document does not identify
+     any Invariant Sections then there are none.
 
      The "Cover Texts" are certain short passages of text that are
      listed, as Front-Cover Texts or Back-Cover Texts, in the notice
@@ -4073,27 +4033,27 @@ GNU Free Documentation License
      A "Transparent" copy of the Document means a machine-readable copy,
      represented in a format whose specification is available to the
      general public, that is suitable for revising the document
-     straightforwardly with generic text editors or (for images
-     composed of pixels) generic paint programs or (for drawings) some
-     widely available drawing editor, and that is suitable for input to
-     text formatters or for automatic translation to a variety of
-     formats suitable for input to text formatters.  A copy made in an
-     otherwise Transparent file format whose markup, or absence of
-     markup, has been arranged to thwart or discourage subsequent
-     modification by readers is not Transparent.  An image format is
-     not Transparent if used for any substantial amount of text.  A
-     copy that is not "Transparent" is called "Opaque".
+     straightforwardly with generic text editors or (for images composed
+     of pixels) generic paint programs or (for drawings) some widely
+     available drawing editor, and that is suitable for input to text
+     formatters or for automatic translation to a variety of formats
+     suitable for input to text formatters.  A copy made in an otherwise
+     Transparent file format whose markup, or absence of markup, has
+     been arranged to thwart or discourage subsequent modification by
+     readers is not Transparent.  An image format is not Transparent if
+     used for any substantial amount of text.  A copy that is not
+     "Transparent" is called "Opaque".
 
      Examples of suitable formats for Transparent copies include plain
      ASCII without markup, Texinfo input format, LaTeX input format,
-     SGML or XML using a publicly available DTD, and
-     standard-conforming simple HTML, PostScript or PDF designed for
-     human modification.  Examples of transparent image formats include
-     PNG, XCF and JPG.  Opaque formats include proprietary formats that
-     can be read and edited only by proprietary word processors, SGML or
-     XML for which the DTD and/or processing tools are not generally
-     available, and the machine-generated HTML, PostScript or PDF
-     produced by some word processors for output purposes only.
+     SGML or XML using a publicly available DTD, and standard-conforming
+     simple HTML, PostScript or PDF designed for human modification.
+     Examples of transparent image formats include PNG, XCF and JPG.
+     Opaque formats include proprietary formats that can be read and
+     edited only by proprietary word processors, SGML or XML for which
+     the DTD and/or processing tools are not generally available, and
+     the machine-generated HTML, PostScript or PDF produced by some word
+     processors for output purposes only.
 
      The "Title Page" means, for a printed book, the title page itself,
      plus such following pages as are needed to hold, legibly, the
@@ -4128,8 +4088,8 @@ GNU Free Documentation License
      may not use technical measures to obstruct or control the reading
      or further copying of the copies you make or distribute.  However,
      you may accept compensation in exchange for copies.  If you
-     distribute a large enough number of copies you must also follow
-     the conditions in section 3.
+     distribute a large enough number of copies you must also follow the
+     conditions in section 3.
 
      You may also lend copies, under the same conditions stated above,
      and you may publicly display copies.
@@ -4143,12 +4103,11 @@ GNU Free Documentation License
      these Cover Texts: Front-Cover Texts on the front cover, and
      Back-Cover Texts on the back cover.  Both covers must also clearly
      and legibly identify you as the publisher of these copies.  The
-     front cover must present the full title with all words of the
-     title equally prominent and visible.  You may add other material
-     on the covers in addition.  Copying with changes limited to the
-     covers, as long as they preserve the title of the Document and
-     satisfy these conditions, can be treated as verbatim copying in
-     other respects.
+     front cover must present the full title with all words of the title
+     equally prominent and visible.  You may add other material on the
+     covers in addition.  Copying with changes limited to the covers, as
+     long as they preserve the title of the Document and satisfy these
+     conditions, can be treated as verbatim copying in other respects.
 
      If the required texts for either cover are too voluminous to fit
      legibly, you should put the first ones listed (as many as fit
@@ -4156,40 +4115,39 @@ GNU Free Documentation License
      adjacent pages.
 
      If you publish or distribute Opaque copies of the Document
-     numbering more than 100, you must either include a
-     machine-readable Transparent copy along with each Opaque copy, or
-     state in or with each Opaque copy a computer-network location from
-     which the general network-using public has access to download
-     using public-standard network protocols a complete Transparent
-     copy of the Document, free of added material.  If you use the
-     latter option, you must take reasonably prudent steps, when you
-     begin distribution of Opaque copies in quantity, to ensure that
-     this Transparent copy will remain thus accessible at the stated
-     location until at least one year after the last time you
-     distribute an Opaque copy (directly or through your agents or
-     retailers) of that edition to the public.
+     numbering more than 100, you must either include a machine-readable
+     Transparent copy along with each Opaque copy, or state in or with
+     each Opaque copy a computer-network location from which the general
+     network-using public has access to download using public-standard
+     network protocols a complete Transparent copy of the Document, free
+     of added material.  If you use the latter option, you must take
+     reasonably prudent steps, when you begin distribution of Opaque
+     copies in quantity, to ensure that this Transparent copy will
+     remain thus accessible at the stated location until at least one
+     year after the last time you distribute an Opaque copy (directly or
+     through your agents or retailers) of that edition to the public.
 
      It is requested, but not required, that you contact the authors of
-     the Document well before redistributing any large number of
-     copies, to give them a chance to provide you with an updated
-     version of the Document.
+     the Document well before redistributing any large number of copies,
+     to give them a chance to provide you with an updated version of the
+     Document.
 
   4. MODIFICATIONS
 
      You may copy and distribute a Modified Version of the Document
      under the conditions of sections 2 and 3 above, provided that you
-     release the Modified Version under precisely this License, with
-     the Modified Version filling the role of the Document, thus
-     licensing distribution and modification of the Modified Version to
-     whoever possesses a copy of it.  In addition, you must do these
-     things in the Modified Version:
+     release the Modified Version under precisely this License, with the
+     Modified Version filling the role of the Document, thus licensing
+     distribution and modification of the Modified Version to whoever
+     possesses a copy of it.  In addition, you must do these things in
+     the Modified Version:
 
        A. Use in the Title Page (and on the covers, if any) a title
-          distinct from that of the Document, and from those of
-          previous versions (which should, if there were any, be listed
-          in the History section of the Document).  You may use the
-          same title as a previous version if the original publisher of
-          that version gives permission.
+          distinct from that of the Document, and from those of previous
+          versions (which should, if there were any, be listed in the
+          History section of the Document).  You may use the same title
+          as a previous version if the original publisher of that
+          version gives permission.
 
        B. List on the Title Page, as authors, one or more persons or
           entities responsible for authorship of the modifications in
@@ -4219,31 +4177,30 @@ GNU Free Documentation License
 
        I. Preserve the section Entitled "History", Preserve its Title,
           and add to it an item stating at least the title, year, new
-          authors, and publisher of the Modified Version as given on
-          the Title Page.  If there is no section Entitled "History" in
-          the Document, create one stating the title, year, authors,
-          and publisher of the Document as given on its Title Page,
-          then add an item describing the Modified Version as stated in
-          the previous sentence.
+          authors, and publisher of the Modified Version as given on the
+          Title Page.  If there is no section Entitled "History" in the
+          Document, create one stating the title, year, authors, and
+          publisher of the Document as given on its Title Page, then add
+          an item describing the Modified Version as stated in the
+          previous sentence.
 
        J. Preserve the network location, if any, given in the Document
           for public access to a Transparent copy of the Document, and
           likewise the network locations given in the Document for
-          previous versions it was based on.  These may be placed in
-          the "History" section.  You may omit a network location for a
-          work that was published at least four years before the
-          Document itself, or if the original publisher of the version
-          it refers to gives permission.
+          previous versions it was based on.  These may be placed in the
+          "History" section.  You may omit a network location for a work
+          that was published at least four years before the Document
+          itself, or if the original publisher of the version it refers
+          to gives permission.
 
        K. For any section Entitled "Acknowledgements" or "Dedications",
-          Preserve the Title of the section, and preserve in the
-          section all the substance and tone of each of the contributor
+          Preserve the Title of the section, and preserve in the section
+          all the substance and tone of each of the contributor
           acknowledgements and/or dedications given therein.
 
-       L. Preserve all the Invariant Sections of the Document,
-          unaltered in their text and in their titles.  Section numbers
-          or the equivalent are not considered part of the section
-          titles.
+       L. Preserve all the Invariant Sections of the Document, unaltered
+          in their text and in their titles.  Section numbers or the
+          equivalent are not considered part of the section titles.
 
        M. Delete any section Entitled "Endorsements".  Such a section
           may not be included in the Modified Version.
@@ -4256,11 +4213,11 @@ GNU Free Documentation License
 
      If the Modified Version includes new front-matter sections or
      appendices that qualify as Secondary Sections and contain no
-     material copied from the Document, you may at your option
-     designate some or all of these sections as invariant.  To do this,
-     add their titles to the list of Invariant Sections in the Modified
-     Version's license notice.  These titles must be distinct from any
-     other section titles.
+     material copied from the Document, you may at your option designate
+     some or all of these sections as invariant.  To do this, add their
+     titles to the list of Invariant Sections in the Modified Version's
+     license notice.  These titles must be distinct from any other
+     section titles.
 
      You may add a section Entitled "Endorsements", provided it contains
      nothing but endorsements of your Modified Version by various
@@ -4269,15 +4226,15 @@ GNU Free Documentation License
      definition of a standard.
 
      You may add a passage of up to five words as a Front-Cover Text,
-     and a passage of up to 25 words as a Back-Cover Text, to the end
-     of the list of Cover Texts in the Modified Version.  Only one
-     passage of Front-Cover Text and one of Back-Cover Text may be
-     added by (or through arrangements made by) any one entity.  If the
-     Document already includes a cover text for the same cover,
-     previously added by you or by arrangement made by the same entity
-     you are acting on behalf of, you may not add another; but you may
-     replace the old one, on explicit permission from the previous
-     publisher that added the old one.
+     and a passage of up to 25 words as a Back-Cover Text, to the end of
+     the list of Cover Texts in the Modified Version.  Only one passage
+     of Front-Cover Text and one of Back-Cover Text may be added by (or
+     through arrangements made by) any one entity.  If the Document
+     already includes a cover text for the same cover, previously added
+     by you or by arrangement made by the same entity you are acting on
+     behalf of, you may not add another; but you may replace the old
+     one, on explicit permission from the previous publisher that added
+     the old one.
 
      The author(s) and publisher(s) of the Document do not by this
      License give permission to use their names for publicity for or to
@@ -4287,8 +4244,8 @@ GNU Free Documentation License
 
      You may combine the Document with other documents released under
      this License, under the terms defined in section 4 above for
-     modified versions, provided that you include in the combination
-     all of the Invariant Sections of all of the original documents,
+     modified versions, provided that you include in the combination all
+     of the Invariant Sections of all of the original documents,
      unmodified, and list them all as Invariant Sections of your
      combined work in its license notice, and that you preserve all
      their Warranty Disclaimers.
@@ -4315,20 +4272,20 @@ GNU Free Documentation License
      documents released under this License, and replace the individual
      copies of this License in the various documents with a single copy
      that is included in the collection, provided that you follow the
-     rules of this License for verbatim copying of each of the
-     documents in all other respects.
+     rules of this License for verbatim copying of each of the documents
+     in all other respects.
 
      You may extract a single document from such a collection, and
      distribute it individually under this License, provided you insert
-     a copy of this License into the extracted document, and follow
-     this License in all other respects regarding verbatim copying of
-     that document.
+     a copy of this License into the extracted document, and follow this
+     License in all other respects regarding verbatim copying of that
+     document.
 
   7. AGGREGATION WITH INDEPENDENT WORKS
 
      A compilation of the Document or its derivatives with other
-     separate and independent documents or works, in or on a volume of
-     a storage or distribution medium, is called an "aggregate" if the
+     separate and independent documents or works, in or on a volume of a
+     storage or distribution medium, is called an "aggregate" if the
      copyright resulting from the compilation is not used to limit the
      legal rights of the compilation's users beyond what the individual
      works permit.  When the Document is included in an aggregate, this
@@ -4371,26 +4328,26 @@ GNU Free Documentation License
      attempt to copy, modify, sublicense or distribute the Document is
      void, and will automatically terminate your rights under this
      License.  However, parties who have received copies, or rights,
-     from you under this License will not have their licenses
-     terminated so long as such parties remain in full compliance.
+     from you under this License will not have their licenses terminated
+     so long as such parties remain in full compliance.
 
- 10. FUTURE REVISIONS OF THIS LICENSE
+  10. FUTURE REVISIONS OF THIS LICENSE
 
      The Free Software Foundation may publish new, revised versions of
      the GNU Free Documentation License from time to time.  Such new
      versions will be similar in spirit to the present version, but may
      differ in detail to address new problems or concerns.  See
-     `http://www.gnu.org/copyleft/'.
+     <http://www.gnu.org/copyleft/>.
 
      Each version of the License is given a distinguishing version
      number.  If the Document specifies that a particular numbered
      version of this License "or any later version" applies to it, you
      have the option of following the terms and conditions either of
      that specified version or of any later version that has been
-     published (not as a draft) by the Free Software Foundation.  If
-     the Document does not specify a version number of this License,
-     you may choose any version ever published (not as a draft) by the
-     Free Software Foundation.
+     published (not as a draft) by the Free Software Foundation.  If the
+     Document does not specify a version number of this License, you may
+     choose any version ever published (not as a draft) by the Free
+     Software Foundation.
 
 ADDENDUM: How to use this License for your documents
 ====================================================
@@ -4409,7 +4366,7 @@ notices just after the title page:
        the section entitled ``GNU Free Documentation License''.
 
    If you have Invariant Sections, Front-Cover Texts and Back-Cover
-Texts, replace the "with...Texts." line with this:
+Texts, replace the "with...Texts."  line with this:
 
        with the Invariant Sections being LIST THEIR
        TITLES, with the Front-Cover Texts being LIST, and
@@ -4420,7 +4377,3212 @@ combination of the three, merge those two alternatives to suit the
 situation.
 
    If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of
-free software license, such as the GNU General Public License, to
-permit their use in free software.
+recommend releasing these examples in parallel under your choice of free
+software license, such as the GNU General Public License, to permit
+their use in free software.
+
+
+File: gsl-ref.info,  Node: Function Index,  Next: Variable Index,  Prev: GNU Free Documentation License,  Up: Top
+
+Function Index
+**************
+
+
+* Menu:
+
+* cblas_caxpy:                           Level 1 CBLAS Functions.
+                                                              (line  90)
+* cblas_ccopy:                           Level 1 CBLAS Functions.
+                                                              (line  87)
+* cblas_cdotc_sub:                       Level 1 CBLAS Functions.
+                                                              (line  21)
+* cblas_cdotu_sub:                       Level 1 CBLAS Functions.
+                                                              (line  18)
+* cblas_cgbmv:                           Level 2 CBLAS Functions.
+                                                              (line  93)
+* cblas_cgemm:                           Level 3 CBLAS Functions.
+                                                              (line  76)
+* cblas_cgemv:                           Level 2 CBLAS Functions.
+                                                              (line  88)
+* cblas_cgerc:                           Level 2 CBLAS Functions.
+                                                              (line 264)
+* cblas_cgeru:                           Level 2 CBLAS Functions.
+                                                              (line 260)
+* cblas_chbmv:                           Level 2 CBLAS Functions.
+                                                              (line 250)
+* cblas_chemm:                           Level 3 CBLAS Functions.
+                                                              (line 146)
+* cblas_chemv:                           Level 2 CBLAS Functions.
+                                                              (line 245)
+* cblas_cher:                            Level 2 CBLAS Functions.
+                                                              (line 268)
+* cblas_cher2:                           Level 2 CBLAS Functions.
+                                                              (line 276)
+* cblas_cher2k:                          Level 3 CBLAS Functions.
+                                                              (line 157)
+* cblas_cherk:                           Level 3 CBLAS Functions.
+                                                              (line 152)
+* cblas_chpmv:                           Level 2 CBLAS Functions.
+                                                              (line 255)
+* cblas_chpr:                            Level 2 CBLAS Functions.
+                                                              (line 272)
+* cblas_chpr2:                           Level 2 CBLAS Functions.
+                                                              (line 281)
+* cblas_cscal:                           Level 1 CBLAS Functions.
+                                                              (line 132)
+* cblas_csscal:                          Level 1 CBLAS Functions.
+                                                              (line 138)
+* cblas_cswap:                           Level 1 CBLAS Functions.
+                                                              (line  84)
+* cblas_csymm:                           Level 3 CBLAS Functions.
+                                                              (line  82)
+* cblas_csyr2k:                          Level 3 CBLAS Functions.
+                                                              (line  93)
+* cblas_csyrk:                           Level 3 CBLAS Functions.
+                                                              (line  88)
+* cblas_ctbmv:                           Level 2 CBLAS Functions.
+                                                              (line 104)
+* cblas_ctbsv:                           Level 2 CBLAS Functions.
+                                                              (line 119)
+* cblas_ctpmv:                           Level 2 CBLAS Functions.
+                                                              (line 109)
+* cblas_ctpsv:                           Level 2 CBLAS Functions.
+                                                              (line 124)
+* cblas_ctrmm:                           Level 3 CBLAS Functions.
+                                                              (line  99)
+* cblas_ctrmv:                           Level 2 CBLAS Functions.
+                                                              (line  99)
+* cblas_ctrsm:                           Level 3 CBLAS Functions.
+                                                              (line 105)
+* cblas_ctrsv:                           Level 2 CBLAS Functions.
+                                                              (line 114)
+* cblas_dasum:                           Level 1 CBLAS Functions.
+                                                              (line  39)
+* cblas_daxpy:                           Level 1 CBLAS Functions.
+                                                              (line  81)
+* cblas_dcopy:                           Level 1 CBLAS Functions.
+                                                              (line  78)
+* cblas_ddot:                            Level 1 CBLAS Functions.
+                                                              (line  15)
+* cblas_dgbmv:                           Level 2 CBLAS Functions.
+                                                              (line  52)
+* cblas_dgemm:                           Level 3 CBLAS Functions.
+                                                              (line  41)
+* cblas_dgemv:                           Level 2 CBLAS Functions.
+                                                              (line  47)
+* cblas_dger:                            Level 2 CBLAS Functions.
+                                                              (line 222)
+* cblas_dnrm2:                           Level 1 CBLAS Functions.
+                                                              (line  36)
+* cblas_drot:                            Level 1 CBLAS Functions.
+                                                              (line 120)
+* cblas_drotg:                           Level 1 CBLAS Functions.
+                                                              (line 114)
+* cblas_drotm:                           Level 1 CBLAS Functions.
+                                                              (line 123)
+* cblas_drotmg:                          Level 1 CBLAS Functions.
+                                                              (line 117)
+* cblas_dsbmv:                           Level 2 CBLAS Functions.
+                                                              (line 212)
+* cblas_dscal:                           Level 1 CBLAS Functions.
+                                                              (line 129)
+* cblas_dsdot:                           Level 1 CBLAS Functions.
+                                                              (line   9)
+* cblas_dspmv:                           Level 2 CBLAS Functions.
+                                                              (line 217)
+* cblas_dspr:                            Level 2 CBLAS Functions.
+                                                              (line 231)
+* cblas_dspr2:                           Level 2 CBLAS Functions.
+                                                              (line 240)
+* cblas_dswap:                           Level 1 CBLAS Functions.
+                                                              (line  75)
+* cblas_dsymm:                           Level 3 CBLAS Functions.
+                                                              (line  47)
+* cblas_dsymv:                           Level 2 CBLAS Functions.
+                                                              (line 207)
+* cblas_dsyr:                            Level 2 CBLAS Functions.
+                                                              (line 227)
+* cblas_dsyr2:                           Level 2 CBLAS Functions.
+                                                              (line 235)
+* cblas_dsyr2k:                          Level 3 CBLAS Functions.
+                                                              (line  58)
+* cblas_dsyrk:                           Level 3 CBLAS Functions.
+                                                              (line  53)
+* cblas_dtbmv:                           Level 2 CBLAS Functions.
+                                                              (line  63)
+* cblas_dtbsv:                           Level 2 CBLAS Functions.
+                                                              (line  78)
+* cblas_dtpmv:                           Level 2 CBLAS Functions.
+                                                              (line  68)
+* cblas_dtpsv:                           Level 2 CBLAS Functions.
+                                                              (line  83)
+* cblas_dtrmm:                           Level 3 CBLAS Functions.
+                                                              (line  64)
+* cblas_dtrmv:                           Level 2 CBLAS Functions.
+                                                              (line  58)
+* cblas_dtrsm:                           Level 3 CBLAS Functions.
+                                                              (line  70)
+* cblas_dtrsv:                           Level 2 CBLAS Functions.
+                                                              (line  73)
+* cblas_dzasum:                          Level 1 CBLAS Functions.
+                                                              (line  51)
+* cblas_dznrm2:                          Level 1 CBLAS Functions.
+                                                              (line  48)
+* cblas_icamax:                          Level 1 CBLAS Functions.
+                                                              (line  60)
+* cblas_idamax:                          Level 1 CBLAS Functions.
+                                                              (line  57)
+* cblas_isamax:                          Level 1 CBLAS Functions.
+                                                              (line  54)
+* cblas_izamax:                          Level 1 CBLAS Functions.
+                                                              (line  63)
+* cblas_sasum:                           Level 1 CBLAS Functions.
+                                                              (line  33)
+* cblas_saxpy:                           Level 1 CBLAS Functions.
+                                                              (line  72)
+* cblas_scasum:                          Level 1 CBLAS Functions.
+                                                              (line  45)
+* cblas_scnrm2:                          Level 1 CBLAS Functions.
+                                                              (line  42)
+* cblas_scopy:                           Level 1 CBLAS Functions.
+                                                              (line  69)
+* cblas_sdot:                            Level 1 CBLAS Functions.
+                                                              (line  12)
+* cblas_sdsdot:                          Level 1 CBLAS Functions.
+                                                              (line   6)
+* cblas_sgbmv:                           Level 2 CBLAS Functions.
+                                                              (line  11)
+* cblas_sgemm:                           Level 3 CBLAS Functions.
+                                                              (line   6)
+* cblas_sgemv:                           Level 2 CBLAS Functions.
+                                                              (line   6)
+* cblas_sger:                            Level 2 CBLAS Functions.
+                                                              (line 185)
+* cblas_snrm2:                           Level 1 CBLAS Functions.
+                                                              (line  30)
+* cblas_srot:                            Level 1 CBLAS Functions.
+                                                              (line 108)
+* cblas_srotg:                           Level 1 CBLAS Functions.
+                                                              (line 102)
+* cblas_srotm:                           Level 1 CBLAS Functions.
+                                                              (line 111)
+* cblas_srotmg:                          Level 1 CBLAS Functions.
+                                                              (line 105)
+* cblas_ssbmv:                           Level 2 CBLAS Functions.
+                                                              (line 175)
+* cblas_sscal:                           Level 1 CBLAS Functions.
+                                                              (line 126)
+* cblas_sspmv:                           Level 2 CBLAS Functions.
+                                                              (line 180)
+* cblas_sspr:                            Level 2 CBLAS Functions.
+                                                              (line 194)
+* cblas_sspr2:                           Level 2 CBLAS Functions.
+                                                              (line 203)
+* cblas_sswap:                           Level 1 CBLAS Functions.
+                                                              (line  66)
+* cblas_ssymm:                           Level 3 CBLAS Functions.
+                                                              (line  12)
+* cblas_ssymv:                           Level 2 CBLAS Functions.
+                                                              (line 170)
+* cblas_ssyr:                            Level 2 CBLAS Functions.
+                                                              (line 190)
+* cblas_ssyr2:                           Level 2 CBLAS Functions.
+                                                              (line 198)
+* cblas_ssyr2k:                          Level 3 CBLAS Functions.
+                                                              (line  23)
+* cblas_ssyrk:                           Level 3 CBLAS Functions.
+                                                              (line  18)
+* cblas_stbmv:                           Level 2 CBLAS Functions.
+                                                              (line  22)
+* cblas_stbsv:                           Level 2 CBLAS Functions.
+                                                              (line  37)
+* cblas_stpmv:                           Level 2 CBLAS Functions.
+                                                              (line  27)
+* cblas_stpsv:                           Level 2 CBLAS Functions.
+                                                              (line  42)
+* cblas_strmm:                           Level 3 CBLAS Functions.
+                                                              (line  29)
+* cblas_strmv:                           Level 2 CBLAS Functions.
+                                                              (line  17)
+* cblas_strsm:                           Level 3 CBLAS Functions.
+                                                              (line  35)
+* cblas_strsv:                           Level 2 CBLAS Functions.
+                                                              (line  32)
+* cblas_xerbla:                          Level 3 CBLAS Functions.
+                                                              (line 180)
+* cblas_zaxpy:                           Level 1 CBLAS Functions.
+                                                              (line  99)
+* cblas_zcopy:                           Level 1 CBLAS Functions.
+                                                              (line  96)
+* cblas_zdotc_sub:                       Level 1 CBLAS Functions.
+                                                              (line  27)
+* cblas_zdotu_sub:                       Level 1 CBLAS Functions.
+                                                              (line  24)
+* cblas_zdscal:                          Level 1 CBLAS Functions.
+                                                              (line 141)
+* cblas_zgbmv:                           Level 2 CBLAS Functions.
+                                                              (line 134)
+* cblas_zgemm:                           Level 3 CBLAS Functions.
+                                                              (line 111)
+* cblas_zgemv:                           Level 2 CBLAS Functions.
+                                                              (line 129)
+* cblas_zgerc:                           Level 2 CBLAS Functions.
+                                                              (line 304)
+* cblas_zgeru:                           Level 2 CBLAS Functions.
+                                                              (line 300)
+* cblas_zhbmv:                           Level 2 CBLAS Functions.
+                                                              (line 290)
+* cblas_zhemm:                           Level 3 CBLAS Functions.
+                                                              (line 163)
+* cblas_zhemv:                           Level 2 CBLAS Functions.
+                                                              (line 285)
+* cblas_zher:                            Level 2 CBLAS Functions.
+                                                              (line 308)
+* cblas_zher2:                           Level 2 CBLAS Functions.
+                                                              (line 316)
+* cblas_zher2k:                          Level 3 CBLAS Functions.
+                                                              (line 174)
+* cblas_zherk:                           Level 3 CBLAS Functions.
+                                                              (line 169)
+* cblas_zhpmv:                           Level 2 CBLAS Functions.
+                                                              (line 295)
+* cblas_zhpr:                            Level 2 CBLAS Functions.
+                                                              (line 312)
+* cblas_zhpr2:                           Level 2 CBLAS Functions.
+                                                              (line 321)
+* cblas_zscal:                           Level 1 CBLAS Functions.
+                                                              (line 135)
+* cblas_zswap:                           Level 1 CBLAS Functions.
+                                                              (line  93)
+* cblas_zsymm:                           Level 3 CBLAS Functions.
+                                                              (line 117)
+* cblas_zsyr2k:                          Level 3 CBLAS Functions.
+                                                              (line 128)
+* cblas_zsyrk:                           Level 3 CBLAS Functions.
+                                                              (line 123)
+* cblas_ztbmv:                           Level 2 CBLAS Functions.
+                                                              (line 145)
+* cblas_ztbsv:                           Level 2 CBLAS Functions.
+                                                              (line 160)
+* cblas_ztpmv:                           Level 2 CBLAS Functions.
+                                                              (line 150)
+* cblas_ztpsv:                           Level 2 CBLAS Functions.
+                                                              (line 165)
+* cblas_ztrmm:                           Level 3 CBLAS Functions.
+                                                              (line 134)
+* cblas_ztrmv:                           Level 2 CBLAS Functions.
+                                                              (line 140)
+* cblas_ztrsm:                           Level 3 CBLAS Functions.
+                                                              (line 140)
+* cblas_ztrsv:                           Level 2 CBLAS Functions.
+                                                              (line 155)
+* gsl_acosh:                             Elementary Functions.
+                                                              (line  27)
+* gsl_asinh:                             Elementary Functions.
+                                                              (line  31)
+* gsl_atanh:                             Elementary Functions.
+                                                              (line  35)
+* gsl_blas_caxpy:                        Level 1 GSL BLAS Interface.
+                                                              (line  92)
+* gsl_blas_ccopy:                        Level 1 GSL BLAS Interface.
+                                                              (line  81)
+* gsl_blas_cdotc:                        Level 1 GSL BLAS Interface.
+                                                              (line  27)
+* gsl_blas_cdotu:                        Level 1 GSL BLAS Interface.
+                                                              (line  20)
+* gsl_blas_cgemm:                        Level 3 GSL BLAS Interface.
+                                                              (line  13)
+* gsl_blas_cgemv:                        Level 2 GSL BLAS Interface.
+                                                              (line  12)
+* gsl_blas_cgerc:                        Level 2 GSL BLAS Interface.
+                                                              (line 106)
+* gsl_blas_cgeru:                        Level 2 GSL BLAS Interface.
+                                                              (line  97)
+* gsl_blas_chemm:                        Level 3 GSL BLAS Interface.
+                                                              (line  47)
+* gsl_blas_chemv:                        Level 2 GSL BLAS Interface.
+                                                              (line  78)
+* gsl_blas_cher:                         Level 2 GSL BLAS Interface.
+                                                              (line 126)
+* gsl_blas_cher2:                        Level 2 GSL BLAS Interface.
+                                                              (line 150)
+* gsl_blas_cher2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 168)
+* gsl_blas_cherk:                        Level 3 GSL BLAS Interface.
+                                                              (line 130)
+* gsl_blas_cscal:                        Level 1 GSL BLAS Interface.
+                                                              (line 101)
+* gsl_blas_csscal:                       Level 1 GSL BLAS Interface.
+                                                              (line 105)
+* gsl_blas_cswap:                        Level 1 GSL BLAS Interface.
+                                                              (line  72)
+* gsl_blas_csymm:                        Level 3 GSL BLAS Interface.
+                                                              (line  32)
+* gsl_blas_csyr2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 151)
+* gsl_blas_csyrk:                        Level 3 GSL BLAS Interface.
+                                                              (line 115)
+* gsl_blas_ctrmm:                        Level 3 GSL BLAS Interface.
+                                                              (line  69)
+* gsl_blas_ctrmv:                        Level 2 GSL BLAS Interface.
+                                                              (line  30)
+* gsl_blas_ctrsm:                        Level 3 GSL BLAS Interface.
+                                                              (line  92)
+* gsl_blas_ctrsv:                        Level 2 GSL BLAS Interface.
+                                                              (line  51)
+* gsl_blas_dasum:                        Level 1 GSL BLAS Interface.
+                                                              (line  46)
+* gsl_blas_daxpy:                        Level 1 GSL BLAS Interface.
+                                                              (line  90)
+* gsl_blas_dcopy:                        Level 1 GSL BLAS Interface.
+                                                              (line  80)
+* gsl_blas_ddot:                         Level 1 GSL BLAS Interface.
+                                                              (line  15)
+* gsl_blas_dgemm:                        Level 3 GSL BLAS Interface.
+                                                              (line  10)
+* gsl_blas_dgemv:                        Level 2 GSL BLAS Interface.
+                                                              (line   9)
+* gsl_blas_dger:                         Level 2 GSL BLAS Interface.
+                                                              (line  95)
+* gsl_blas_dnrm2:                        Level 1 GSL BLAS Interface.
+                                                              (line  35)
+* gsl_blas_drot:                         Level 1 GSL BLAS Interface.
+                                                              (line 126)
+* gsl_blas_drotg:                        Level 1 GSL BLAS Interface.
+                                                              (line 114)
+* gsl_blas_drotm:                        Level 1 GSL BLAS Interface.
+                                                              (line 141)
+* gsl_blas_drotmg:                       Level 1 GSL BLAS Interface.
+                                                              (line 133)
+* gsl_blas_dscal:                        Level 1 GSL BLAS Interface.
+                                                              (line 100)
+* gsl_blas_dsdot:                        Level 1 GSL BLAS Interface.
+                                                              (line  13)
+* gsl_blas_dswap:                        Level 1 GSL BLAS Interface.
+                                                              (line  71)
+* gsl_blas_dsymm:                        Level 3 GSL BLAS Interface.
+                                                              (line  29)
+* gsl_blas_dsymv:                        Level 2 GSL BLAS Interface.
+                                                              (line  68)
+* gsl_blas_dsyr:                         Level 2 GSL BLAS Interface.
+                                                              (line 117)
+* gsl_blas_dsyr2:                        Level 2 GSL BLAS Interface.
+                                                              (line 141)
+* gsl_blas_dsyr2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 148)
+* gsl_blas_dsyrk:                        Level 3 GSL BLAS Interface.
+                                                              (line 112)
+* gsl_blas_dtrmm:                        Level 3 GSL BLAS Interface.
+                                                              (line  66)
+* gsl_blas_dtrmv:                        Level 2 GSL BLAS Interface.
+                                                              (line  27)
+* gsl_blas_dtrsm:                        Level 3 GSL BLAS Interface.
+                                                              (line  89)
+* gsl_blas_dtrsv:                        Level 2 GSL BLAS Interface.
+                                                              (line  48)
+* gsl_blas_dzasum:                       Level 1 GSL BLAS Interface.
+                                                              (line  51)
+* gsl_blas_dznrm2:                       Level 1 GSL BLAS Interface.
+                                                              (line  40)
+* gsl_blas_icamax:                       Level 1 GSL BLAS Interface.
+                                                              (line  58)
+* gsl_blas_idamax:                       Level 1 GSL BLAS Interface.
+                                                              (line  57)
+* gsl_blas_isamax:                       Level 1 GSL BLAS Interface.
+                                                              (line  56)
+* gsl_blas_izamax:                       Level 1 GSL BLAS Interface.
+                                                              (line  60)
+* gsl_blas_sasum:                        Level 1 GSL BLAS Interface.
+                                                              (line  45)
+* gsl_blas_saxpy:                        Level 1 GSL BLAS Interface.
+                                                              (line  88)
+* gsl_blas_scasum:                       Level 1 GSL BLAS Interface.
+                                                              (line  50)
+* gsl_blas_scnrm2:                       Level 1 GSL BLAS Interface.
+                                                              (line  39)
+* gsl_blas_scopy:                        Level 1 GSL BLAS Interface.
+                                                              (line  78)
+* gsl_blas_sdot:                         Level 1 GSL BLAS Interface.
+                                                              (line  11)
+* gsl_blas_sdsdot:                       Level 1 GSL BLAS Interface.
+                                                              (line   6)
+* gsl_blas_sgemm:                        Level 3 GSL BLAS Interface.
+                                                              (line   6)
+* gsl_blas_sgemv:                        Level 2 GSL BLAS Interface.
+                                                              (line   6)
+* gsl_blas_sger:                         Level 2 GSL BLAS Interface.
+                                                              (line  93)
+* gsl_blas_snrm2:                        Level 1 GSL BLAS Interface.
+                                                              (line  34)
+* gsl_blas_srot:                         Level 1 GSL BLAS Interface.
+                                                              (line 124)
+* gsl_blas_srotg:                        Level 1 GSL BLAS Interface.
+                                                              (line 112)
+* gsl_blas_srotm:                        Level 1 GSL BLAS Interface.
+                                                              (line 139)
+* gsl_blas_srotmg:                       Level 1 GSL BLAS Interface.
+                                                              (line 131)
+* gsl_blas_sscal:                        Level 1 GSL BLAS Interface.
+                                                              (line  99)
+* gsl_blas_sswap:                        Level 1 GSL BLAS Interface.
+                                                              (line  69)
+* gsl_blas_ssymm:                        Level 3 GSL BLAS Interface.
+                                                              (line  26)
+* gsl_blas_ssymv:                        Level 2 GSL BLAS Interface.
+                                                              (line  65)
+* gsl_blas_ssyr:                         Level 2 GSL BLAS Interface.
+                                                              (line 115)
+* gsl_blas_ssyr2:                        Level 2 GSL BLAS Interface.
+                                                              (line 138)
+* gsl_blas_ssyr2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 145)
+* gsl_blas_ssyrk:                        Level 3 GSL BLAS Interface.
+                                                              (line 109)
+* gsl_blas_strmm:                        Level 3 GSL BLAS Interface.
+                                                              (line  63)
+* gsl_blas_strmv:                        Level 2 GSL BLAS Interface.
+                                                              (line  24)
+* gsl_blas_strsm:                        Level 3 GSL BLAS Interface.
+                                                              (line  86)
+* gsl_blas_strsv:                        Level 2 GSL BLAS Interface.
+                                                              (line  45)
+* gsl_blas_zaxpy:                        Level 1 GSL BLAS Interface.
+                                                              (line  94)
+* gsl_blas_zcopy:                        Level 1 GSL BLAS Interface.
+                                                              (line  83)
+* gsl_blas_zdotc:                        Level 1 GSL BLAS Interface.
+                                                              (line  29)
+* gsl_blas_zdotu:                        Level 1 GSL BLAS Interface.
+                                                              (line  22)
+* gsl_blas_zdscal:                       Level 1 GSL BLAS Interface.
+                                                              (line 107)
+* gsl_blas_zgemm:                        Level 3 GSL BLAS Interface.
+                                                              (line  17)
+* gsl_blas_zgemv:                        Level 2 GSL BLAS Interface.
+                                                              (line  16)
+* gsl_blas_zgerc:                        Level 2 GSL BLAS Interface.
+                                                              (line 109)
+* gsl_blas_zgeru:                        Level 2 GSL BLAS Interface.
+                                                              (line 100)
+* gsl_blas_zhemm:                        Level 3 GSL BLAS Interface.
+                                                              (line  51)
+* gsl_blas_zhemv:                        Level 2 GSL BLAS Interface.
+                                                              (line  82)
+* gsl_blas_zher:                         Level 2 GSL BLAS Interface.
+                                                              (line 128)
+* gsl_blas_zher2:                        Level 2 GSL BLAS Interface.
+                                                              (line 154)
+* gsl_blas_zher2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 172)
+* gsl_blas_zherk:                        Level 3 GSL BLAS Interface.
+                                                              (line 133)
+* gsl_blas_zscal:                        Level 1 GSL BLAS Interface.
+                                                              (line 103)
+* gsl_blas_zswap:                        Level 1 GSL BLAS Interface.
+                                                              (line  74)
+* gsl_blas_zsymm:                        Level 3 GSL BLAS Interface.
+                                                              (line  36)
+* gsl_blas_zsyr2k:                       Level 3 GSL BLAS Interface.
+                                                              (line 155)
+* gsl_blas_zsyrk:                        Level 3 GSL BLAS Interface.
+                                                              (line 119)
+* gsl_blas_ztrmm:                        Level 3 GSL BLAS Interface.
+                                                              (line  73)
+* gsl_blas_ztrmv:                        Level 2 GSL BLAS Interface.
+                                                              (line  33)
+* gsl_blas_ztrsm:                        Level 3 GSL BLAS Interface.
+                                                              (line  96)
+* gsl_blas_ztrsv:                        Level 2 GSL BLAS Interface.
+                                                              (line  54)
+* gsl_block_alloc:                       Block allocation.    (line  14)
+* gsl_block_calloc:                      Block allocation.    (line  24)
+* gsl_block_fprintf:                     Reading and writing blocks.
+                                                              (line  25)
+* gsl_block_fread:                       Reading and writing blocks.
+                                                              (line  16)
+* gsl_block_free:                        Block allocation.    (line  28)
+* gsl_block_fscanf:                      Reading and writing blocks.
+                                                              (line  33)
+* gsl_block_fwrite:                      Reading and writing blocks.
+                                                              (line   9)
+* gsl_bspline_alloc:                     Initializing the B-splines solver.
+                                                              (line   6)
+* gsl_bspline_eval:                      Evaluation of B-spline basis functions.
+                                                              (line   6)
+* gsl_bspline_free:                      Initializing the B-splines solver.
+                                                              (line  13)
+* gsl_bspline_knots:                     Constructing the knots vector.
+                                                              (line   6)
+* gsl_bspline_knots_uniform:             Constructing the knots vector.
+                                                              (line  11)
+* gsl_cdf_beta_P:                        The Beta Distribution.
+                                                              (line  21)
+* gsl_cdf_beta_Pinv:                     The Beta Distribution.
+                                                              (line  23)
+* gsl_cdf_beta_Q:                        The Beta Distribution.
+                                                              (line  22)
+* gsl_cdf_beta_Qinv:                     The Beta Distribution.
+                                                              (line  24)
+* gsl_cdf_binomial_P:                    The Binomial Distribution.
+                                                              (line  24)
+* gsl_cdf_binomial_Q:                    The Binomial Distribution.
+                                                              (line  26)
+* gsl_cdf_cauchy_P:                      The Cauchy Distribution.
+                                                              (line  22)
+* gsl_cdf_cauchy_Pinv:                   The Cauchy Distribution.
+                                                              (line  24)
+* gsl_cdf_cauchy_Q:                      The Cauchy Distribution.
+                                                              (line  23)
+* gsl_cdf_cauchy_Qinv:                   The Cauchy Distribution.
+                                                              (line  25)
+* gsl_cdf_chisq_P:                       The Chi-squared Distribution.
+                                                              (line  29)
+* gsl_cdf_chisq_Pinv:                    The Chi-squared Distribution.
+                                                              (line  31)
+* gsl_cdf_chisq_Q:                       The Chi-squared Distribution.
+                                                              (line  30)
+* gsl_cdf_chisq_Qinv:                    The Chi-squared Distribution.
+                                                              (line  32)
+* gsl_cdf_exponential_P:                 The Exponential Distribution.
+                                                              (line  20)
+* gsl_cdf_exponential_Pinv:              The Exponential Distribution.
+                                                              (line  22)
+* gsl_cdf_exponential_Q:                 The Exponential Distribution.
+                                                              (line  21)
+* gsl_cdf_exponential_Qinv:              The Exponential Distribution.
+                                                              (line  23)
+* gsl_cdf_exppow_P:                      The Exponential Power Distribution.
+                                                              (line  24)
+* gsl_cdf_exppow_Q:                      The Exponential Power Distribution.
+                                                              (line  25)
+* gsl_cdf_fdist_P:                       The F-distribution.  (line  33)
+* gsl_cdf_fdist_Pinv:                    The F-distribution.  (line  35)
+* gsl_cdf_fdist_Q:                       The F-distribution.  (line  34)
+* gsl_cdf_fdist_Qinv:                    The F-distribution.  (line  37)
+* gsl_cdf_flat_P:                        The Flat (Uniform) Distribution.
+                                                              (line  20)
+* gsl_cdf_flat_Pinv:                     The Flat (Uniform) Distribution.
+                                                              (line  22)
+* gsl_cdf_flat_Q:                        The Flat (Uniform) Distribution.
+                                                              (line  21)
+* gsl_cdf_flat_Qinv:                     The Flat (Uniform) Distribution.
+                                                              (line  23)
+* gsl_cdf_gamma_P:                       The Gamma Distribution.
+                                                              (line  33)
+* gsl_cdf_gamma_Pinv:                    The Gamma Distribution.
+                                                              (line  35)
+* gsl_cdf_gamma_Q:                       The Gamma Distribution.
+                                                              (line  34)
+* gsl_cdf_gamma_Qinv:                    The Gamma Distribution.
+                                                              (line  36)
+* gsl_cdf_gaussian_P:                    The Gaussian Distribution.
+                                                              (line  41)
+* gsl_cdf_gaussian_Pinv:                 The Gaussian Distribution.
+                                                              (line  43)
+* gsl_cdf_gaussian_Q:                    The Gaussian Distribution.
+                                                              (line  42)
+* gsl_cdf_gaussian_Qinv:                 The Gaussian Distribution.
+                                                              (line  44)
+* gsl_cdf_geometric_P:                   The Geometric Distribution.
+                                                              (line  25)
+* gsl_cdf_geometric_Q:                   The Geometric Distribution.
+                                                              (line  26)
+* gsl_cdf_gumbel1_P:                     The Type-1 Gumbel Distribution.
+                                                              (line  21)
+* gsl_cdf_gumbel1_Pinv:                  The Type-1 Gumbel Distribution.
+                                                              (line  23)
+* gsl_cdf_gumbel1_Q:                     The Type-1 Gumbel Distribution.
+                                                              (line  22)
+* gsl_cdf_gumbel1_Qinv:                  The Type-1 Gumbel Distribution.
+                                                              (line  24)
+* gsl_cdf_gumbel2_P:                     The Type-2 Gumbel Distribution.
+                                                              (line  21)
+* gsl_cdf_gumbel2_Pinv:                  The Type-2 Gumbel Distribution.
+                                                              (line  23)
+* gsl_cdf_gumbel2_Q:                     The Type-2 Gumbel Distribution.
+                                                              (line  22)
+* gsl_cdf_gumbel2_Qinv:                  The Type-2 Gumbel Distribution.
+                                                              (line  24)
+* gsl_cdf_hypergeometric_P:              The Hypergeometric Distribution.
+                                                              (line  29)
+* gsl_cdf_hypergeometric_Q:              The Hypergeometric Distribution.
+                                                              (line  31)
+* gsl_cdf_laplace_P:                     The Laplace Distribution.
+                                                              (line  19)
+* gsl_cdf_laplace_Pinv:                  The Laplace Distribution.
+                                                              (line  21)
+* gsl_cdf_laplace_Q:                     The Laplace Distribution.
+                                                              (line  20)
+* gsl_cdf_laplace_Qinv:                  The Laplace Distribution.
+                                                              (line  22)
+* gsl_cdf_logistic_P:                    The Logistic Distribution.
+                                                              (line  20)
+* gsl_cdf_logistic_Pinv:                 The Logistic Distribution.
+                                                              (line  22)
+* gsl_cdf_logistic_Q:                    The Logistic Distribution.
+                                                              (line  21)
+* gsl_cdf_logistic_Qinv:                 The Logistic Distribution.
+                                                              (line  23)
+* gsl_cdf_lognormal_P:                   The Lognormal Distribution.
+                                                              (line  22)
+* gsl_cdf_lognormal_Pinv:                The Lognormal Distribution.
+                                                              (line  26)
+* gsl_cdf_lognormal_Q:                   The Lognormal Distribution.
+                                                              (line  24)
+* gsl_cdf_lognormal_Qinv:                The Lognormal Distribution.
+                                                              (line  28)
+* gsl_cdf_negative_binomial_P:           The Negative Binomial Distribution.
+                                                              (line  24)
+* gsl_cdf_negative_binomial_Q:           The Negative Binomial Distribution.
+                                                              (line  26)
+* gsl_cdf_pareto_P:                      The Pareto Distribution.
+                                                              (line  21)
+* gsl_cdf_pareto_Pinv:                   The Pareto Distribution.
+                                                              (line  23)
+* gsl_cdf_pareto_Q:                      The Pareto Distribution.
+                                                              (line  22)
+* gsl_cdf_pareto_Qinv:                   The Pareto Distribution.
+                                                              (line  24)
+* gsl_cdf_pascal_P:                      The Pascal Distribution.
+                                                              (line  23)
+* gsl_cdf_pascal_Q:                      The Pascal Distribution.
+                                                              (line  25)
+* gsl_cdf_poisson_P:                     The Poisson Distribution.
+                                                              (line  21)
+* gsl_cdf_poisson_Q:                     The Poisson Distribution.
+                                                              (line  22)
+* gsl_cdf_rayleigh_P:                    The Rayleigh Distribution.
+                                                              (line  20)
+* gsl_cdf_rayleigh_Pinv:                 The Rayleigh Distribution.
+                                                              (line  22)
+* gsl_cdf_rayleigh_Q:                    The Rayleigh Distribution.
+                                                              (line  21)
+* gsl_cdf_rayleigh_Qinv:                 The Rayleigh Distribution.
+                                                              (line  23)
+* gsl_cdf_tdist_P:                       The t-distribution.  (line  29)
+* gsl_cdf_tdist_Pinv:                    The t-distribution.  (line  31)
+* gsl_cdf_tdist_Q:                       The t-distribution.  (line  30)
+* gsl_cdf_tdist_Qinv:                    The t-distribution.  (line  32)
+* gsl_cdf_ugaussian_P:                   The Gaussian Distribution.
+                                                              (line  49)
+* gsl_cdf_ugaussian_Pinv:                The Gaussian Distribution.
+                                                              (line  51)
+* gsl_cdf_ugaussian_Q:                   The Gaussian Distribution.
+                                                              (line  50)
+* gsl_cdf_ugaussian_Qinv:                The Gaussian Distribution.
+                                                              (line  52)
+* gsl_cdf_weibull_P:                     The Weibull Distribution.
+                                                              (line  21)
+* gsl_cdf_weibull_Pinv:                  The Weibull Distribution.
+                                                              (line  23)
+* gsl_cdf_weibull_Q:                     The Weibull Distribution.
+                                                              (line  22)
+* gsl_cdf_weibull_Qinv:                  The Weibull Distribution.
+                                                              (line  24)
+* gsl_cheb_alloc:                        Creation and Calculation of Chebyshev Series.
+                                                              (line   6)
+* gsl_cheb_calc_deriv:                   Derivatives and Integrals.
+                                                              (line  12)
+* gsl_cheb_calc_integ:                   Derivatives and Integrals.
+                                                              (line  18)
+* gsl_cheb_eval:                         Chebyshev Series Evaluation.
+                                                              (line   6)
+* gsl_cheb_eval_err:                     Chebyshev Series Evaluation.
+                                                              (line  10)
+* gsl_cheb_eval_n:                       Chebyshev Series Evaluation.
+                                                              (line  17)
+* gsl_cheb_eval_n_err:                   Chebyshev Series Evaluation.
+                                                              (line  22)
+* gsl_cheb_free:                         Creation and Calculation of Chebyshev Series.
+                                                              (line  10)
+* gsl_cheb_init:                         Creation and Calculation of Chebyshev Series.
+                                                              (line  13)
+* gsl_combination_alloc:                 Combination allocation.
+                                                              (line   6)
+* gsl_combination_calloc:                Combination allocation.
+                                                              (line  15)
+* gsl_combination_data:                  Combination properties.
+                                                              (line  13)
+* gsl_combination_fprintf:               Reading and writing combinations.
+                                                              (line  27)
+* gsl_combination_fread:                 Reading and writing combinations.
+                                                              (line  17)
+* gsl_combination_free:                  Combination allocation.
+                                                              (line  30)
+* gsl_combination_fscanf:                Reading and writing combinations.
+                                                              (line  36)
+* gsl_combination_fwrite:                Reading and writing combinations.
+                                                              (line   9)
+* gsl_combination_get:                   Accessing combination elements.
+                                                              (line   9)
+* gsl_combination_init_first:            Combination allocation.
+                                                              (line  22)
+* gsl_combination_init_last:             Combination allocation.
+                                                              (line  26)
+* gsl_combination_k:                     Combination properties.
+                                                              (line   9)
+* gsl_combination_memcpy:                Combination allocation.
+                                                              (line  33)
+* gsl_combination_n:                     Combination properties.
+                                                              (line   6)
+* gsl_combination_next:                  Combination functions.
+                                                              (line   6)
+* gsl_combination_prev:                  Combination functions.
+                                                              (line  14)
+* gsl_combination_valid:                 Combination properties.
+                                                              (line  17)
+* gsl_complex_abs:                       Properties of complex numbers.
+                                                              (line  10)
+* gsl_complex_abs2:                      Properties of complex numbers.
+                                                              (line  13)
+* gsl_complex_add:                       Complex arithmetic operators.
+                                                              (line   6)
+* gsl_complex_add_imag:                  Complex arithmetic operators.
+                                                              (line  38)
+* gsl_complex_add_real:                  Complex arithmetic operators.
+                                                              (line  22)
+* gsl_complex_arccos:                    Inverse Complex Trigonometric Functions.
+                                                              (line  19)
+* gsl_complex_arccosh:                   Inverse Complex Hyperbolic Functions.
+                                                              (line  11)
+* gsl_complex_arccosh_real:              Inverse Complex Hyperbolic Functions.
+                                                              (line  18)
+* gsl_complex_arccos_real:               Inverse Complex Trigonometric Functions.
+                                                              (line  24)
+* gsl_complex_arccot:                    Inverse Complex Trigonometric Functions.
+                                                              (line  52)
+* gsl_complex_arccoth:                   Inverse Complex Hyperbolic Functions.
+                                                              (line  39)
+* gsl_complex_arccsc:                    Inverse Complex Trigonometric Functions.
+                                                              (line  44)
+* gsl_complex_arccsch:                   Inverse Complex Hyperbolic Functions.
+                                                              (line  35)
+* gsl_complex_arccsc_real:               Inverse Complex Trigonometric Functions.
+                                                              (line  48)
+* gsl_complex_arcsec:                    Inverse Complex Trigonometric Functions.
+                                                              (line  36)
+* gsl_complex_arcsech:                   Inverse Complex Hyperbolic Functions.
+                                                              (line  31)
+* gsl_complex_arcsec_real:               Inverse Complex Trigonometric Functions.
+                                                              (line  40)
+* gsl_complex_arcsin:                    Inverse Complex Trigonometric Functions.
+                                                              (line   6)
+* gsl_complex_arcsinh:                   Inverse Complex Hyperbolic Functions.
+                                                              (line   6)
+* gsl_complex_arcsin_real:               Inverse Complex Trigonometric Functions.
+                                                              (line  11)
+* gsl_complex_arctan:                    Inverse Complex Trigonometric Functions.
+                                                              (line  31)
+* gsl_complex_arctanh:                   Inverse Complex Hyperbolic Functions.
+                                                              (line  22)
+* gsl_complex_arctanh_real:              Inverse Complex Hyperbolic Functions.
+                                                              (line  27)
+* gsl_complex_arg:                       Properties of complex numbers.
+                                                              (line   6)
+* gsl_complex_conjugate:                 Complex arithmetic operators.
+                                                              (line  54)
+* gsl_complex_cos:                       Complex Trigonometric Functions.
+                                                              (line  10)
+* gsl_complex_cosh:                      Complex Hyperbolic Functions.
+                                                              (line  10)
+* gsl_complex_cot:                       Complex Trigonometric Functions.
+                                                              (line  26)
+* gsl_complex_coth:                      Complex Hyperbolic Functions.
+                                                              (line  26)
+* gsl_complex_csc:                       Complex Trigonometric Functions.
+                                                              (line  22)
+* gsl_complex_csch:                      Complex Hyperbolic Functions.
+                                                              (line  22)
+* gsl_complex_div:                       Complex arithmetic operators.
+                                                              (line  18)
+* gsl_complex_div_imag:                  Complex arithmetic operators.
+                                                              (line  50)
+* gsl_complex_div_real:                  Complex arithmetic operators.
+                                                              (line  34)
+* gsl_complex_exp:                       Elementary Complex Functions.
+                                                              (line  24)
+* gsl_complex_inverse:                   Complex arithmetic operators.
+                                                              (line  58)
+* gsl_complex_log:                       Elementary Complex Functions.
+                                                              (line  28)
+* gsl_complex_log10:                     Elementary Complex Functions.
+                                                              (line  33)
+* gsl_complex_logabs:                    Properties of complex numbers.
+                                                              (line  17)
+* gsl_complex_log_b:                     Elementary Complex Functions.
+                                                              (line  37)
+* gsl_complex_mul:                       Complex arithmetic operators.
+                                                              (line  14)
+* gsl_complex_mul_imag:                  Complex arithmetic operators.
+                                                              (line  46)
+* gsl_complex_mul_real:                  Complex arithmetic operators.
+                                                              (line  30)
+* gsl_complex_negative:                  Complex arithmetic operators.
+                                                              (line  62)
+* gsl_complex_polar:                     Complex numbers.     (line  28)
+* gsl_complex_pow:                       Elementary Complex Functions.
+                                                              (line  15)
+* gsl_complex_pow_real:                  Elementary Complex Functions.
+                                                              (line  20)
+* gsl_complex_rect:                      Complex numbers.     (line  24)
+* gsl_complex_sec:                       Complex Trigonometric Functions.
+                                                              (line  18)
+* gsl_complex_sech:                      Complex Hyperbolic Functions.
+                                                              (line  18)
+* gsl_complex_sin:                       Complex Trigonometric Functions.
+                                                              (line   6)
+* gsl_complex_sinh:                      Complex Hyperbolic Functions.
+                                                              (line   6)
+* gsl_complex_sqrt:                      Elementary Complex Functions.
+                                                              (line   6)
+* gsl_complex_sqrt_real:                 Elementary Complex Functions.
+                                                              (line  11)
+* gsl_complex_sub:                       Complex arithmetic operators.
+                                                              (line  10)
+* gsl_complex_sub_imag:                  Complex arithmetic operators.
+                                                              (line  42)
+* gsl_complex_sub_real:                  Complex arithmetic operators.
+                                                              (line  26)
+* gsl_complex_tan:                       Complex Trigonometric Functions.
+                                                              (line  14)
+* gsl_complex_tanh:                      Complex Hyperbolic Functions.
+                                                              (line  14)
+* gsl_deriv_backward:                    Numerical Differentiation functions.
+                                                              (line  40)
+* gsl_deriv_central:                     Numerical Differentiation functions.
+                                                              (line   6)
+* gsl_deriv_forward:                     Numerical Differentiation functions.
+                                                              (line  22)
+* gsl_dht_alloc:                         Discrete Hankel Transform Functions.
+                                                              (line   6)
+* gsl_dht_apply:                         Discrete Hankel Transform Functions.
+                                                              (line  22)
+* gsl_dht_free:                          Discrete Hankel Transform Functions.
+                                                              (line  19)
+* gsl_dht_init:                          Discrete Hankel Transform Functions.
+                                                              (line  10)
+* gsl_dht_k_sample:                      Discrete Hankel Transform Functions.
+                                                              (line  33)
+* gsl_dht_new:                           Discrete Hankel Transform Functions.
+                                                              (line  14)
+* gsl_dht_x_sample:                      Discrete Hankel Transform Functions.
+                                                              (line  28)
+* GSL_EDOM:                              Error Codes.         (line  13)
+* gsl_eigen_herm:                        Complex Hermitian Matrices.
+                                                              (line  15)
+* gsl_eigen_hermv:                       Complex Hermitian Matrices.
+                                                              (line  34)
+* gsl_eigen_hermv_alloc:                 Complex Hermitian Matrices.
+                                                              (line  25)
+* gsl_eigen_hermv_free:                  Complex Hermitian Matrices.
+                                                              (line  31)
+* gsl_eigen_hermv_sort:                  Sorting Eigenvalues and Eigenvectors.
+                                                              (line  22)
+* gsl_eigen_herm_alloc:                  Complex Hermitian Matrices.
+                                                              (line   6)
+* gsl_eigen_herm_free:                   Complex Hermitian Matrices.
+                                                              (line  12)
+* gsl_eigen_nonsymm:                     Real Nonsymmetric Matrices.
+                                                              (line  60)
+* gsl_eigen_nonsymmv:                    Real Nonsymmetric Matrices.
+                                                              (line  88)
+* gsl_eigen_nonsymmv_alloc:              Real Nonsymmetric Matrices.
+                                                              (line  78)
+* gsl_eigen_nonsymmv_free:               Real Nonsymmetric Matrices.
+                                                              (line  84)
+* gsl_eigen_nonsymmv_sort:               Sorting Eigenvalues and Eigenvectors.
+                                                              (line  29)
+* gsl_eigen_nonsymmv_Z:                  Real Nonsymmetric Matrices.
+                                                              (line 102)
+* gsl_eigen_nonsymm_alloc:               Real Nonsymmetric Matrices.
+                                                              (line  17)
+* gsl_eigen_nonsymm_free:                Real Nonsymmetric Matrices.
+                                                              (line  23)
+* gsl_eigen_nonsymm_params:              Real Nonsymmetric Matrices.
+                                                              (line  27)
+* gsl_eigen_nonsymm_Z:                   Real Nonsymmetric Matrices.
+                                                              (line  72)
+* gsl_eigen_symm:                        Real Symmetric Matrices.
+                                                              (line  15)
+* gsl_eigen_symmv:                       Real Symmetric Matrices.
+                                                              (line  33)
+* gsl_eigen_symmv_alloc:                 Real Symmetric Matrices.
+                                                              (line  24)
+* gsl_eigen_symmv_free:                  Real Symmetric Matrices.
+                                                              (line  30)
+* gsl_eigen_symmv_sort:                  Sorting Eigenvalues and Eigenvectors.
+                                                              (line   6)
+* gsl_eigen_symm_alloc:                  Real Symmetric Matrices.
+                                                              (line   6)
+* gsl_eigen_symm_free:                   Real Symmetric Matrices.
+                                                              (line  12)
+* GSL_EINVAL:                            Error Codes.         (line  29)
+* GSL_ENOMEM:                            Error Codes.         (line  23)
+* GSL_ERANGE:                            Error Codes.         (line  18)
+* GSL_ERROR:                             Using GSL error reporting in your own functions.
+                                                              (line  15)
+* GSL_ERROR_VAL:                         Using GSL error reporting in your own functions.
+                                                              (line  36)
+* gsl_expm1:                             Elementary Functions.
+                                                              (line  17)
+* gsl_fcmp:                              Approximate Comparison of Floating Point Numbers.
+                                                              (line  12)
+* gsl_fft_complex_backward:              Mixed-radix FFT routines for complex data.
+                                                              (line 124)
+* gsl_fft_complex_forward:               Mixed-radix FFT routines for complex data.
+                                                              (line 117)
+* gsl_fft_complex_inverse:               Mixed-radix FFT routines for complex data.
+                                                              (line 127)
+* gsl_fft_complex_radix2_backward:       Radix-2 FFT routines for complex data.
+                                                              (line  23)
+* gsl_fft_complex_radix2_dif_backward:   Radix-2 FFT routines for complex data.
+                                                              (line  47)
+* gsl_fft_complex_radix2_dif_forward:    Radix-2 FFT routines for complex data.
+                                                              (line  40)
+* gsl_fft_complex_radix2_dif_inverse:    Radix-2 FFT routines for complex data.
+                                                              (line  50)
+* gsl_fft_complex_radix2_dif_transform:  Radix-2 FFT routines for complex data.
+                                                              (line  43)
+* gsl_fft_complex_radix2_forward:        Radix-2 FFT routines for complex data.
+                                                              (line  16)
+* gsl_fft_complex_radix2_inverse:        Radix-2 FFT routines for complex data.
+                                                              (line  26)
+* gsl_fft_complex_radix2_transform:      Radix-2 FFT routines for complex data.
+                                                              (line  19)
+* gsl_fft_complex_transform:             Mixed-radix FFT routines for complex data.
+                                                              (line 120)
+* gsl_fft_complex_wavetable_alloc:       Mixed-radix FFT routines for complex data.
+                                                              (line  44)
+* gsl_fft_complex_wavetable_free:        Mixed-radix FFT routines for complex data.
+                                                              (line  63)
+* gsl_fft_complex_workspace_alloc:       Mixed-radix FFT routines for complex data.
+                                                              (line 104)
+* gsl_fft_complex_workspace_free:        Mixed-radix FFT routines for complex data.
+                                                              (line 109)
+* gsl_fft_halfcomplex_radix2_backward:   Radix-2 FFT routines for real data.
+                                                              (line  57)
+* gsl_fft_halfcomplex_radix2_inverse:    Radix-2 FFT routines for real data.
+                                                              (line  55)
+* gsl_fft_halfcomplex_transform:         Mixed-radix FFT routines for real data.
+                                                              (line 122)
+* gsl_fft_halfcomplex_unpack:            Mixed-radix FFT routines for real data.
+                                                              (line 153)
+* gsl_fft_halfcomplex_wavetable_alloc:   Mixed-radix FFT routines for real data.
+                                                              (line  74)
+* gsl_fft_halfcomplex_wavetable_free:    Mixed-radix FFT routines for real data.
+                                                              (line  95)
+* gsl_fft_real_radix2_transform:         Radix-2 FFT routines for real data.
+                                                              (line  13)
+* gsl_fft_real_transform:                Mixed-radix FFT routines for real data.
+                                                              (line 119)
+* gsl_fft_real_unpack:                   Mixed-radix FFT routines for real data.
+                                                              (line 136)
+* gsl_fft_real_wavetable_alloc:          Mixed-radix FFT routines for real data.
+                                                              (line  72)
+* gsl_fft_real_wavetable_free:           Mixed-radix FFT routines for real data.
+                                                              (line  93)
+* gsl_fft_real_workspace_alloc:          Mixed-radix FFT routines for real data.
+                                                              (line 104)
+* gsl_fft_real_workspace_free:           Mixed-radix FFT routines for real data.
+                                                              (line 110)
+* gsl_finite:                            Infinities and Not-a-number.
+                                                              (line  25)
+* gsl_fit_linear:                        Linear regression.   (line   9)
+* gsl_fit_linear_est:                    Linear regression.   (line  39)
+* gsl_fit_mul:                           Linear fitting without a constant term.
+                                                              (line  10)
+* gsl_fit_mul_est:                       Linear fitting without a constant term.
+                                                              (line  36)
+* gsl_fit_wlinear:                       Linear regression.   (line  22)
+* gsl_fit_wmul:                          Linear fitting without a constant term.
+                                                              (line  21)
+* gsl_frexp:                             Elementary Functions.
+                                                              (line  43)
+* gsl_heapsort:                          Sorting objects.     (line  16)
+* gsl_heapsort_index:                    Sorting objects.     (line  58)
+* gsl_histogram2d_accumulate:            Updating and accessing 2D histogram elements.
+                                                              (line  25)
+* gsl_histogram2d_add:                   2D Histogram Operations.
+                                                              (line  11)
+* gsl_histogram2d_alloc:                 2D Histogram allocation.
+                                                              (line  14)
+* gsl_histogram2d_clone:                 Copying 2D Histograms.
+                                                              (line  12)
+* gsl_histogram2d_cov:                   2D Histogram Statistics.
+                                                              (line  52)
+* gsl_histogram2d_div:                   2D Histogram Operations.
+                                                              (line  31)
+* gsl_histogram2d_equal_bins_p:          2D Histogram Operations.
+                                                              (line   6)
+* gsl_histogram2d_find:                  Searching 2D histogram ranges.
+                                                              (line   9)
+* gsl_histogram2d_fprintf:               Reading and writing 2D histograms.
+                                                              (line  27)
+* gsl_histogram2d_fread:                 Reading and writing 2D histograms.
+                                                              (line  17)
+* gsl_histogram2d_free:                  2D Histogram allocation.
+                                                              (line  37)
+* gsl_histogram2d_fscanf:                Reading and writing 2D histograms.
+                                                              (line  64)
+* gsl_histogram2d_fwrite:                Reading and writing 2D histograms.
+                                                              (line   9)
+* gsl_histogram2d_get:                   Updating and accessing 2D histogram elements.
+                                                              (line  31)
+* gsl_histogram2d_get_xrange:            Updating and accessing 2D histogram elements.
+                                                              (line  38)
+* gsl_histogram2d_get_yrange:            Updating and accessing 2D histogram elements.
+                                                              (line  40)
+* gsl_histogram2d_increment:             Updating and accessing 2D histogram elements.
+                                                              (line  12)
+* gsl_histogram2d_max_bin:               2D Histogram Statistics.
+                                                              (line  10)
+* gsl_histogram2d_max_val:               2D Histogram Statistics.
+                                                              (line   6)
+* gsl_histogram2d_memcpy:                Copying 2D Histograms.
+                                                              (line   6)
+* gsl_histogram2d_min_bin:               2D Histogram Statistics.
+                                                              (line  21)
+* gsl_histogram2d_min_val:               2D Histogram Statistics.
+                                                              (line  17)
+* gsl_histogram2d_mul:                   2D Histogram Operations.
+                                                              (line  24)
+* gsl_histogram2d_nx:                    Updating and accessing 2D histogram elements.
+                                                              (line  55)
+* gsl_histogram2d_ny:                    Updating and accessing 2D histogram elements.
+                                                              (line  58)
+* gsl_histogram2d_pdf_alloc:             Resampling from 2D histograms.
+                                                              (line  38)
+* gsl_histogram2d_pdf_free:              Resampling from 2D histograms.
+                                                              (line  54)
+* gsl_histogram2d_pdf_init:              Resampling from 2D histograms.
+                                                              (line  46)
+* gsl_histogram2d_pdf_sample:            Resampling from 2D histograms.
+                                                              (line  58)
+* gsl_histogram2d_reset:                 Updating and accessing 2D histogram elements.
+                                                              (line  64)
+* gsl_histogram2d_scale:                 2D Histogram Operations.
+                                                              (line  38)
+* gsl_histogram2d_set_ranges:            2D Histogram allocation.
+                                                              (line  24)
+* gsl_histogram2d_set_ranges_uniform:    2D Histogram allocation.
+                                                              (line  31)
+* gsl_histogram2d_shift:                 2D Histogram Operations.
+                                                              (line  43)
+* gsl_histogram2d_sub:                   2D Histogram Operations.
+                                                              (line  17)
+* gsl_histogram2d_sum:                   2D Histogram Statistics.
+                                                              (line  58)
+* gsl_histogram2d_xmax:                  Updating and accessing 2D histogram elements.
+                                                              (line  53)
+* gsl_histogram2d_xmean:                 2D Histogram Statistics.
+                                                              (line  28)
+* gsl_histogram2d_xmin:                  Updating and accessing 2D histogram elements.
+                                                              (line  54)
+* gsl_histogram2d_xsigma:                2D Histogram Statistics.
+                                                              (line  40)
+* gsl_histogram2d_ymax:                  Updating and accessing 2D histogram elements.
+                                                              (line  56)
+* gsl_histogram2d_ymean:                 2D Histogram Statistics.
+                                                              (line  34)
+* gsl_histogram2d_ymin:                  Updating and accessing 2D histogram elements.
+                                                              (line  57)
+* gsl_histogram2d_ysigma:                2D Histogram Statistics.
+                                                              (line  46)
+* gsl_histogram_accumulate:              Updating and accessing histogram elements.
+                                                              (line  25)
+* gsl_histogram_add:                     Histogram Operations.
+                                                              (line  11)
+* gsl_histogram_alloc:                   Histogram allocation.
+                                                              (line  14)
+* gsl_histogram_bins:                    Updating and accessing histogram elements.
+                                                              (line  53)
+* gsl_histogram_clone:                   Copying Histograms.  (line  12)
+* gsl_histogram_div:                     Histogram Operations.
+                                                              (line  30)
+* gsl_histogram_equal_bins_p:            Histogram Operations.
+                                                              (line   6)
+* gsl_histogram_find:                    Searching histogram ranges.
+                                                              (line   9)
+* gsl_histogram_fprintf:                 Reading and writing histograms.
+                                                              (line  26)
+* gsl_histogram_fread:                   Reading and writing histograms.
+                                                              (line  17)
+* gsl_histogram_free:                    Histogram allocation.
+                                                              (line  60)
+* gsl_histogram_fscanf:                  Reading and writing histograms.
+                                                              (line  51)
+* gsl_histogram_fwrite:                  Reading and writing histograms.
+                                                              (line   9)
+* gsl_histogram_get:                     Updating and accessing histogram elements.
+                                                              (line  31)
+* gsl_histogram_get_range:               Updating and accessing histogram elements.
+                                                              (line  38)
+* gsl_histogram_increment:               Updating and accessing histogram elements.
+                                                              (line  11)
+* gsl_histogram_max:                     Updating and accessing histogram elements.
+                                                              (line  51)
+* gsl_histogram_max_bin:                 Histogram Statistics.
+                                                              (line  10)
+* gsl_histogram_max_val:                 Histogram Statistics.
+                                                              (line   6)
+* gsl_histogram_mean:                    Histogram Statistics.
+                                                              (line  24)
+* gsl_histogram_memcpy:                  Copying Histograms.  (line   6)
+* gsl_histogram_min:                     Updating and accessing histogram elements.
+                                                              (line  52)
+* gsl_histogram_min_bin:                 Histogram Statistics.
+                                                              (line  19)
+* gsl_histogram_min_val:                 Histogram Statistics.
+                                                              (line  15)
+* gsl_histogram_mul:                     Histogram Operations.
+                                                              (line  23)
+* gsl_histogram_pdf_alloc:               The histogram probability distribution struct.
+                                                              (line  33)
+* gsl_histogram_pdf_free:                The histogram probability distribution struct.
+                                                              (line  47)
+* gsl_histogram_pdf_init:                The histogram probability distribution struct.
+                                                              (line  40)
+* gsl_histogram_pdf_sample:              The histogram probability distribution struct.
+                                                              (line  51)
+* gsl_histogram_reset:                   Updating and accessing histogram elements.
+                                                              (line  59)
+* gsl_histogram_scale:                   Histogram Operations.
+                                                              (line  37)
+* gsl_histogram_set_ranges:              Histogram allocation.
+                                                              (line  23)
+* gsl_histogram_set_ranges_uniform:      Histogram allocation.
+                                                              (line  48)
+* gsl_histogram_shift:                   Histogram Operations.
+                                                              (line  41)
+* gsl_histogram_sigma:                   Histogram Statistics.
+                                                              (line  30)
+* gsl_histogram_sub:                     Histogram Operations.
+                                                              (line  17)
+* gsl_histogram_sum:                     Histogram Statistics.
+                                                              (line  37)
+* gsl_hypot:                             Elementary Functions.
+                                                              (line  22)
+* gsl_ieee_env_setup:                    Setting up your IEEE environment.
+                                                              (line  23)
+* gsl_ieee_fprintf_double:               Representation of floating point numbers.
+                                                              (line  55)
+* gsl_ieee_fprintf_float:                Representation of floating point numbers.
+                                                              (line  53)
+* gsl_ieee_printf_double:                Representation of floating point numbers.
+                                                              (line  82)
+* gsl_ieee_printf_float:                 Representation of floating point numbers.
+                                                              (line  81)
+* GSL_IMAG:                              Complex numbers.     (line  34)
+* gsl_integration_qag:                   QAG adaptive integration.
+                                                              (line  24)
+* gsl_integration_qagi:                  QAGI adaptive integration on infinite intervals.
+                                                              (line   6)
+* gsl_integration_qagil:                 QAGI adaptive integration on infinite intervals.
+                                                              (line  37)
+* gsl_integration_qagiu:                 QAGI adaptive integration on infinite intervals.
+                                                              (line  22)
+* gsl_integration_qagp:                  QAGP adaptive integration with known singular points.
+                                                              (line   6)
+* gsl_integration_qags:                  QAGS adaptive integration with singularities.
+                                                              (line  15)
+* gsl_integration_qawc:                  QAWC adaptive integration for Cauchy principal values.
+                                                              (line   6)
+* gsl_integration_qawf:                  QAWF adaptive integration for Fourier integrals.
+                                                              (line   6)
+* gsl_integration_qawo:                  QAWO adaptive integration for oscillatory functions.
+                                                              (line  54)
+* gsl_integration_qawo_table_alloc:      QAWO adaptive integration for oscillatory functions.
+                                                              (line  11)
+* gsl_integration_qawo_table_free:       QAWO adaptive integration for oscillatory functions.
+                                                              (line  50)
+* gsl_integration_qawo_table_set:        QAWO adaptive integration for oscillatory functions.
+                                                              (line  39)
+* gsl_integration_qawo_table_set_length: QAWO adaptive integration for oscillatory functions.
+                                                              (line  45)
+* gsl_integration_qaws:                  QAWS adaptive integration for singular functions.
+                                                              (line  49)
+* gsl_integration_qaws_table_alloc:      QAWS adaptive integration for singular functions.
+                                                              (line  11)
+* gsl_integration_qaws_table_free:       QAWS adaptive integration for singular functions.
+                                                              (line  44)
+* gsl_integration_qaws_table_set:        QAWS adaptive integration for singular functions.
+                                                              (line  38)
+* gsl_integration_qng:                   QNG non-adaptive Gauss-Kronrod integration.
+                                                              (line  10)
+* gsl_integration_workspace_alloc:       QAG adaptive integration.
+                                                              (line  15)
+* gsl_integration_workspace_free:        QAG adaptive integration.
+                                                              (line  20)
+* gsl_interp_accel_alloc:                Index Look-up and Acceleration.
+                                                              (line  18)
+* gsl_interp_accel_find:                 Index Look-up and Acceleration.
+                                                              (line  24)
+* gsl_interp_accel_free:                 Index Look-up and Acceleration.
+                                                              (line  31)
+* gsl_interp_akima:                      Interpolation Types. (line  34)
+* gsl_interp_akima_periodic:             Interpolation Types. (line  38)
+* gsl_interp_alloc:                      Interpolation Functions.
+                                                              (line   9)
+* gsl_interp_bsearch:                    Index Look-up and Acceleration.
+                                                              (line  12)
+* gsl_interp_cspline:                    Interpolation Types. (line  19)
+* gsl_interp_cspline_periodic:           Interpolation Types. (line  25)
+* gsl_interp_eval:                       Evaluation of Interpolating Functions.
+                                                              (line   6)
+* gsl_interp_eval_deriv:                 Evaluation of Interpolating Functions.
+                                                              (line  16)
+* gsl_interp_eval_deriv2:                Evaluation of Interpolating Functions.
+                                                              (line  26)
+* gsl_interp_eval_deriv2_e:              Evaluation of Interpolating Functions.
+                                                              (line  29)
+* gsl_interp_eval_deriv_e:               Evaluation of Interpolating Functions.
+                                                              (line  19)
+* gsl_interp_eval_e:                     Evaluation of Interpolating Functions.
+                                                              (line   9)
+* gsl_interp_eval_integ:                 Evaluation of Interpolating Functions.
+                                                              (line  36)
+* gsl_interp_eval_integ_e:               Evaluation of Interpolating Functions.
+                                                              (line  39)
+* gsl_interp_free:                       Interpolation Functions.
+                                                              (line  23)
+* gsl_interp_init:                       Interpolation Functions.
+                                                              (line  14)
+* gsl_interp_linear:                     Interpolation Types. (line   8)
+* gsl_interp_min_size:                   Interpolation Types. (line  55)
+* gsl_interp_name:                       Interpolation Types. (line  44)
+* gsl_interp_polynomial:                 Interpolation Types. (line  12)
+* gsl_isinf:                             Infinities and Not-a-number.
+                                                              (line  21)
+* gsl_isnan:                             Infinities and Not-a-number.
+                                                              (line  18)
+* GSL_IS_EVEN:                           Testing for Odd and Even Numbers.
+                                                              (line  10)
+* GSL_IS_ODD:                            Testing for Odd and Even Numbers.
+                                                              (line   6)
+* gsl_ldexp:                             Elementary Functions.
+                                                              (line  39)
+* gsl_linalg_balance_matrix:             Balancing.           (line  17)
+* gsl_linalg_bidiag_decomp:              Bidiagonalization.   (line  15)
+* gsl_linalg_bidiag_unpack:              Bidiagonalization.   (line  26)
+* gsl_linalg_bidiag_unpack2:             Bidiagonalization.   (line  35)
+* gsl_linalg_bidiag_unpack_B:            Bidiagonalization.   (line  42)
+* gsl_linalg_cholesky_decomp:            Cholesky Decomposition.
+                                                              (line  19)
+* gsl_linalg_cholesky_solve:             Cholesky Decomposition.
+                                                              (line  29)
+* gsl_linalg_cholesky_svx:               Cholesky Decomposition.
+                                                              (line  35)
+* gsl_linalg_complex_LU_decomp:          LU Decomposition.    (line  20)
+* gsl_linalg_complex_LU_det:             LU Decomposition.    (line  82)
+* gsl_linalg_complex_LU_invert:          LU Decomposition.    (line  70)
+* gsl_linalg_complex_LU_lndet:           LU Decomposition.    (line  90)
+* gsl_linalg_complex_LU_refine:          LU Decomposition.    (line  59)
+* gsl_linalg_complex_LU_sgndet:          LU Decomposition.    (line  98)
+* gsl_linalg_complex_LU_solve:           LU Decomposition.    (line  41)
+* gsl_linalg_complex_LU_svx:             LU Decomposition.    (line  50)
+* gsl_linalg_hermtd_decomp:              Tridiagonal Decomposition of Hermitian Matrices.
+                                                              (line  14)
+* gsl_linalg_hermtd_unpack:              Tridiagonal Decomposition of Hermitian Matrices.
+                                                              (line  26)
+* gsl_linalg_hermtd_unpack_T:            Tridiagonal Decomposition of Hermitian Matrices.
+                                                              (line  34)
+* gsl_linalg_hessenberg:                 Hessenberg Decomposition of Real Matrices.
+                                                              (line  16)
+* gsl_linalg_hessenberg_set_zero:        Hessenberg Decomposition of Real Matrices.
+                                                              (line  42)
+* gsl_linalg_hessenberg_unpack:          Hessenberg Decomposition of Real Matrices.
+                                                              (line  27)
+* gsl_linalg_hessenberg_unpack_accum:    Hessenberg Decomposition of Real Matrices.
+                                                              (line  33)
+* gsl_linalg_HH_solve:                   Householder solver for linear systems.
+                                                              (line   6)
+* gsl_linalg_HH_svx:                     Householder solver for linear systems.
+                                                              (line  13)
+* gsl_linalg_householder_hm:             Householder Transformations.
+                                                              (line  23)
+* gsl_linalg_householder_hv:             Householder Transformations.
+                                                              (line  35)
+* gsl_linalg_householder_mh:             Householder Transformations.
+                                                              (line  29)
+* gsl_linalg_householder_transform:      Householder Transformations.
+                                                              (line  17)
+* gsl_linalg_LU_decomp:                  LU Decomposition.    (line  18)
+* gsl_linalg_LU_det:                     LU Decomposition.    (line  81)
+* gsl_linalg_LU_invert:                  LU Decomposition.    (line  68)
+* gsl_linalg_LU_lndet:                   LU Decomposition.    (line  89)
+* gsl_linalg_LU_refine:                  LU Decomposition.    (line  56)
+* gsl_linalg_LU_sgndet:                  LU Decomposition.    (line  97)
+* gsl_linalg_LU_solve:                   LU Decomposition.    (line  39)
+* gsl_linalg_LU_svx:                     LU Decomposition.    (line  48)
+* gsl_linalg_QRPT_decomp:                QR Decomposition with Column Pivoting.
+                                                              (line  18)
+* gsl_linalg_QRPT_decomp2:               QR Decomposition with Column Pivoting.
+                                                              (line  39)
+* gsl_linalg_QRPT_QRsolve:               QR Decomposition with Column Pivoting.
+                                                              (line  60)
+* gsl_linalg_QRPT_Rsolve:                QR Decomposition with Column Pivoting.
+                                                              (line  76)
+* gsl_linalg_QRPT_Rsvx:                  QR Decomposition with Column Pivoting.
+                                                              (line  81)
+* gsl_linalg_QRPT_solve:                 QR Decomposition with Column Pivoting.
+                                                              (line  46)
+* gsl_linalg_QRPT_svx:                   QR Decomposition with Column Pivoting.
+                                                              (line  53)
+* gsl_linalg_QRPT_update:                QR Decomposition with Column Pivoting.
+                                                              (line  67)
+* gsl_linalg_QR_decomp:                  QR Decomposition.    (line  19)
+* gsl_linalg_QR_lssolve:                 QR Decomposition.    (line  49)
+* gsl_linalg_QR_QRsolve:                 QR Decomposition.    (line  93)
+* gsl_linalg_QR_QTvec:                   QR Decomposition.    (line  60)
+* gsl_linalg_QR_Qvec:                    QR Decomposition.    (line  68)
+* gsl_linalg_QR_Rsolve:                  QR Decomposition.    (line  75)
+* gsl_linalg_QR_Rsvx:                    QR Decomposition.    (line  81)
+* gsl_linalg_QR_solve:                   QR Decomposition.    (line  35)
+* gsl_linalg_QR_svx:                     QR Decomposition.    (line  42)
+* gsl_linalg_QR_unpack:                  QR Decomposition.    (line  88)
+* gsl_linalg_QR_update:                  QR Decomposition.    (line  99)
+* gsl_linalg_R_solve:                    QR Decomposition.    (line 106)
+* gsl_linalg_R_svx:                      QR Decomposition.    (line 111)
+* gsl_linalg_solve_cyc_tridiag:          Tridiagonal Systems. (line  35)
+* gsl_linalg_solve_symm_cyc_tridiag:     Tridiagonal Systems. (line  49)
+* gsl_linalg_solve_symm_tridiag:         Tridiagonal Systems. (line  19)
+* gsl_linalg_solve_tridiag:              Tridiagonal Systems. (line   6)
+* gsl_linalg_SV_decomp:                  Singular Value Decomposition.
+                                                              (line  31)
+* gsl_linalg_SV_decomp_jacobi:           Singular Value Decomposition.
+                                                              (line  50)
+* gsl_linalg_SV_decomp_mod:              Singular Value Decomposition.
+                                                              (line  44)
+* gsl_linalg_SV_solve:                   Singular Value Decomposition.
+                                                              (line  57)
+* gsl_linalg_symmtd_decomp:              Tridiagonal Decomposition of Real Symmetric Matrices.
+                                                              (line  13)
+* gsl_linalg_symmtd_unpack:              Tridiagonal Decomposition of Real Symmetric Matrices.
+                                                              (line  24)
+* gsl_linalg_symmtd_unpack_T:            Tridiagonal Decomposition of Real Symmetric Matrices.
+                                                              (line  32)
+* gsl_log1p:                             Elementary Functions.
+                                                              (line  12)
+* gsl_matrix_add:                        Matrix operations.   (line   8)
+* gsl_matrix_add_constant:               Matrix operations.   (line  34)
+* gsl_matrix_alloc:                      Matrix allocation.   (line  14)
+* gsl_matrix_calloc:                     Matrix allocation.   (line  21)
+* gsl_matrix_column:                     Creating row and column views.
+                                                              (line  24)
+* gsl_matrix_const_column:               Creating row and column views.
+                                                              (line  26)
+* gsl_matrix_const_diagonal:             Creating row and column views.
+                                                              (line  37)
+* gsl_matrix_const_ptr:                  Accessing matrix elements.
+                                                              (line  34)
+* gsl_matrix_const_row:                  Creating row and column views.
+                                                              (line  14)
+* gsl_matrix_const_subdiagonal:          Creating row and column views.
+                                                              (line  50)
+* gsl_matrix_const_submatrix:            Matrix views.        (line  20)
+* gsl_matrix_const_superdiagonal:        Creating row and column views.
+                                                              (line  62)
+* gsl_matrix_const_view_array:           Matrix views.        (line  51)
+* gsl_matrix_const_view_array_with_tda:  Matrix views.        (line  75)
+* gsl_matrix_const_view_vector:          Matrix views.        (line 101)
+* gsl_matrix_const_view_vector_with_tda: Matrix views.        (line 125)
+* gsl_matrix_diagonal:                   Creating row and column views.
+                                                              (line  36)
+* gsl_matrix_div_elements:               Matrix operations.   (line  24)
+* gsl_matrix_fprintf:                    Reading and writing matrices.
+                                                              (line  26)
+* gsl_matrix_fread:                      Reading and writing matrices.
+                                                              (line  17)
+* gsl_matrix_free:                       Matrix allocation.   (line  25)
+* gsl_matrix_fscanf:                     Reading and writing matrices.
+                                                              (line  34)
+* gsl_matrix_fwrite:                     Reading and writing matrices.
+                                                              (line   9)
+* gsl_matrix_get:                        Accessing matrix elements.
+                                                              (line  20)
+* gsl_matrix_get_col:                    Copying rows and columns.
+                                                              (line  19)
+* gsl_matrix_get_row:                    Copying rows and columns.
+                                                              (line  13)
+* gsl_matrix_isneg:                      Matrix properties.   (line   8)
+* gsl_matrix_isnull:                     Matrix properties.   (line   6)
+* gsl_matrix_ispos:                      Matrix properties.   (line   7)
+* gsl_matrix_max:                        Finding maximum and minimum elements of matrices.
+                                                              (line   8)
+* gsl_matrix_max_index:                  Finding maximum and minimum elements of matrices.
+                                                              (line  19)
+* gsl_matrix_memcpy:                     Copying matrices.    (line   6)
+* gsl_matrix_min:                        Finding maximum and minimum elements of matrices.
+                                                              (line  11)
+* gsl_matrix_minmax:                     Finding maximum and minimum elements of matrices.
+                                                              (line  14)
+* gsl_matrix_minmax_index:               Finding maximum and minimum elements of matrices.
+                                                              (line  33)
+* gsl_matrix_min_index:                  Finding maximum and minimum elements of matrices.
+                                                              (line  26)
+* gsl_matrix_mul_elements:               Matrix operations.   (line  18)
+* gsl_matrix_ptr:                        Accessing matrix elements.
+                                                              (line  32)
+* gsl_matrix_row:                        Creating row and column views.
+                                                              (line  13)
+* gsl_matrix_scale:                      Matrix operations.   (line  30)
+* gsl_matrix_set:                        Accessing matrix elements.
+                                                              (line  26)
+* gsl_matrix_set_all:                    Initializing matrix elements.
+                                                              (line   6)
+* gsl_matrix_set_col:                    Copying rows and columns.
+                                                              (line  31)
+* gsl_matrix_set_identity:               Initializing matrix elements.
+                                                              (line  12)
+* gsl_matrix_set_row:                    Copying rows and columns.
+                                                              (line  25)
+* gsl_matrix_set_zero:                   Initializing matrix elements.
+                                                              (line   9)
+* gsl_matrix_sub:                        Matrix operations.   (line  13)
+* gsl_matrix_subdiagonal:                Creating row and column views.
+                                                              (line  48)
+* gsl_matrix_submatrix:                  Matrix views.        (line  18)
+* gsl_matrix_superdiagonal:              Creating row and column views.
+                                                              (line  60)
+* gsl_matrix_swap:                       Copying matrices.    (line  11)
+* gsl_matrix_swap_columns:               Exchanging rows and columns.
+                                                              (line  14)
+* gsl_matrix_swap_rowcol:                Exchanging rows and columns.
+                                                              (line  19)
+* gsl_matrix_swap_rows:                  Exchanging rows and columns.
+                                                              (line   9)
+* gsl_matrix_transpose:                  Exchanging rows and columns.
+                                                              (line  32)
+* gsl_matrix_transpose_memcpy:           Exchanging rows and columns.
+                                                              (line  25)
+* gsl_matrix_view_array:                 Matrix views.        (line  49)
+* gsl_matrix_view_array_with_tda:        Matrix views.        (line  73)
+* gsl_matrix_view_vector:                Matrix views.        (line  99)
+* gsl_matrix_view_vector_with_tda:       Matrix views.        (line 123)
+* GSL_MAX:                               Maximum and Minimum functions.
+                                                              (line   6)
+* GSL_MAX_DBL:                           Maximum and Minimum functions.
+                                                              (line  14)
+* GSL_MAX_INT:                           Maximum and Minimum functions.
+                                                              (line  28)
+* GSL_MAX_LDBL:                          Maximum and Minimum functions.
+                                                              (line  35)
+* GSL_MIN:                               Maximum and Minimum functions.
+                                                              (line  10)
+* GSL_MIN_DBL:                           Maximum and Minimum functions.
+                                                              (line  21)
+* gsl_min_fminimizer_alloc:              Initializing the Minimizer.
+                                                              (line   6)
+* gsl_min_fminimizer_brent:              Minimization Algorithms.
+                                                              (line  30)
+* gsl_min_fminimizer_free:               Initializing the Minimizer.
+                                                              (line  39)
+* gsl_min_fminimizer_f_lower:            Minimization Iteration.
+                                                              (line  45)
+* gsl_min_fminimizer_f_minimum:          Minimization Iteration.
+                                                              (line  41)
+* gsl_min_fminimizer_f_upper:            Minimization Iteration.
+                                                              (line  43)
+* gsl_min_fminimizer_goldensection:      Minimization Algorithms.
+                                                              (line  13)
+* gsl_min_fminimizer_iterate:            Minimization Iteration.
+                                                              (line  12)
+* gsl_min_fminimizer_name:               Initializing the Minimizer.
+                                                              (line  42)
+* gsl_min_fminimizer_set:                Initializing the Minimizer.
+                                                              (line  21)
+* gsl_min_fminimizer_set_with_values:    Initializing the Minimizer.
+                                                              (line  31)
+* gsl_min_fminimizer_x_lower:            Minimization Iteration.
+                                                              (line  36)
+* gsl_min_fminimizer_x_minimum:          Minimization Iteration.
+                                                              (line  29)
+* gsl_min_fminimizer_x_upper:            Minimization Iteration.
+                                                              (line  34)
+* GSL_MIN_INT:                           Maximum and Minimum functions.
+                                                              (line  29)
+* GSL_MIN_LDBL:                          Maximum and Minimum functions.
+                                                              (line  37)
+* gsl_min_test_interval:                 Minimization Stopping Parameters.
+                                                              (line  18)
+* gsl_monte_miser_alloc:                 MISER.               (line  45)
+* gsl_monte_miser_free:                  MISER.               (line  68)
+* gsl_monte_miser_init:                  MISER.               (line  50)
+* gsl_monte_miser_integrate:             MISER.               (line  55)
+* gsl_monte_plain_alloc:                 PLAIN Monte Carlo.   (line  29)
+* gsl_monte_plain_free:                  PLAIN Monte Carlo.   (line  51)
+* gsl_monte_plain_init:                  PLAIN Monte Carlo.   (line  33)
+* gsl_monte_plain_integrate:             PLAIN Monte Carlo.   (line  38)
+* gsl_monte_vegas_alloc:                 VEGAS.               (line  50)
+* gsl_monte_vegas_free:                  VEGAS.               (line  77)
+* gsl_monte_vegas_init:                  VEGAS.               (line  55)
+* gsl_monte_vegas_integrate:             VEGAS.               (line  60)
+* gsl_multifit_covar:                    Computing the covariance matrix of best fit parameters.
+                                                              (line   6)
+* gsl_multifit_fdfsolver_alloc:          Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  16)
+* gsl_multifit_fdfsolver_free:           Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  46)
+* gsl_multifit_fdfsolver_iterate:        Iteration of the Minimization Algorithm.
+                                                              (line  14)
+* gsl_multifit_fdfsolver_lmder:          Minimization Algorithms using Derivatives.
+                                                              (line  59)
+* gsl_multifit_fdfsolver_lmsder:         Minimization Algorithms using Derivatives.
+                                                              (line  12)
+* gsl_multifit_fdfsolver_name:           Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  52)
+* gsl_multifit_fdfsolver_position:       Iteration of the Minimization Algorithm.
+                                                              (line  43)
+* gsl_multifit_fdfsolver_set:            Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  40)
+* gsl_multifit_fsolver_alloc:            Initializing the Nonlinear Least-Squares Solver.
+                                                              (line   6)
+* gsl_multifit_fsolver_free:             Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  45)
+* gsl_multifit_fsolver_iterate:          Iteration of the Minimization Algorithm.
+                                                              (line  12)
+* gsl_multifit_fsolver_name:             Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  50)
+* gsl_multifit_fsolver_position:         Iteration of the Minimization Algorithm.
+                                                              (line  41)
+* gsl_multifit_fsolver_set:              Initializing the Nonlinear Least-Squares Solver.
+                                                              (line  35)
+* gsl_multifit_gradient:                 Search Stopping Parameters for Minimization Algorithms.
+                                                              (line  45)
+* gsl_multifit_linear:                   Multi-parameter fitting.
+                                                              (line  50)
+* gsl_multifit_linear_alloc:             Multi-parameter fitting.
+                                                              (line  41)
+* gsl_multifit_linear_est:               Multi-parameter fitting.
+                                                              (line  98)
+* gsl_multifit_linear_free:              Multi-parameter fitting.
+                                                              (line  46)
+* gsl_multifit_linear_svd:               Multi-parameter fitting.
+                                                              (line  53)
+* gsl_multifit_test_delta:               Search Stopping Parameters for Minimization Algorithms.
+                                                              (line  19)
+* gsl_multifit_test_gradient:            Search Stopping Parameters for Minimization Algorithms.
+                                                              (line  31)
+* gsl_multifit_wlinear:                  Multi-parameter fitting.
+                                                              (line  74)
+* gsl_multifit_wlinear_svd:              Multi-parameter fitting.
+                                                              (line  78)
+* gsl_multimin_fdfminimizer_alloc:       Initializing the Multidimensional Minimizer.
+                                                              (line  10)
+* gsl_multimin_fdfminimizer_conjugate_fr: Multimin Algorithms.
+                                                              (line  11)
+* gsl_multimin_fdfminimizer_conjugate_pr: Multimin Algorithms.
+                                                              (line  28)
+* gsl_multimin_fdfminimizer_free:        Initializing the Multidimensional Minimizer.
+                                                              (line  44)
+* gsl_multimin_fdfminimizer_gradient:    Multimin Iteration.  (line  31)
+* gsl_multimin_fdfminimizer_iterate:     Multimin Iteration.  (line  11)
+* gsl_multimin_fdfminimizer_minimum:     Multimin Iteration.  (line  27)
+* gsl_multimin_fdfminimizer_name:        Initializing the Multidimensional Minimizer.
+                                                              (line  50)
+* gsl_multimin_fdfminimizer_restart:     Multimin Iteration.  (line  39)
+* gsl_multimin_fdfminimizer_set:         Initializing the Multidimensional Minimizer.
+                                                              (line  21)
+* gsl_multimin_fdfminimizer_steepest_descent: Multimin Algorithms.
+                                                              (line  55)
+* gsl_multimin_fdfminimizer_vector_bfgs: Multimin Algorithms. (line  36)
+* gsl_multimin_fdfminimizer_vector_bfgs2: Multimin Algorithms.
+                                                              (line  35)
+* gsl_multimin_fdfminimizer_x:           Multimin Iteration.  (line  23)
+* gsl_multimin_fminimizer_alloc:         Initializing the Multidimensional Minimizer.
+                                                              (line  13)
+* gsl_multimin_fminimizer_free:          Initializing the Multidimensional Minimizer.
+                                                              (line  46)
+* gsl_multimin_fminimizer_iterate:       Multimin Iteration.  (line  13)
+* gsl_multimin_fminimizer_minimum:       Multimin Iteration.  (line  29)
+* gsl_multimin_fminimizer_name:          Initializing the Multidimensional Minimizer.
+                                                              (line  52)
+* gsl_multimin_fminimizer_nmsimplex:     Multimin Algorithms. (line  65)
+* gsl_multimin_fminimizer_size:          Multimin Iteration.  (line  33)
+* gsl_multimin_fminimizer_x:             Multimin Iteration.  (line  25)
+* gsl_multimin_test_gradient:            Multimin Stopping Criteria.
+                                                              (line  18)
+* gsl_multimin_test_size:                Multimin Stopping Criteria.
+                                                              (line  32)
+* gsl_multiroot_fdfsolver_alloc:         Initializing the Multidimensional Solver.
+                                                              (line  27)
+* gsl_multiroot_fdfsolver_dx:            Iteration of the multidimensional solver.
+                                                              (line  48)
+* gsl_multiroot_fdfsolver_f:             Iteration of the multidimensional solver.
+                                                              (line  41)
+* gsl_multiroot_fdfsolver_free:          Initializing the Multidimensional Solver.
+                                                              (line  55)
+* gsl_multiroot_fdfsolver_gnewton:       Algorithms using Derivatives.
+                                                              (line  89)
+* gsl_multiroot_fdfsolver_hybridj:       Algorithms using Derivatives.
+                                                              (line  64)
+* gsl_multiroot_fdfsolver_hybridsj:      Algorithms using Derivatives.
+                                                              (line  13)
+* gsl_multiroot_fdfsolver_iterate:       Iteration of the multidimensional solver.
+                                                              (line  14)
+* gsl_multiroot_fdfsolver_name:          Initializing the Multidimensional Solver.
+                                                              (line  61)
+* gsl_multiroot_fdfsolver_newton:        Algorithms using Derivatives.
+                                                              (line  70)
+* gsl_multiroot_fdfsolver_root:          Iteration of the multidimensional solver.
+                                                              (line  34)
+* gsl_multiroot_fdfsolver_set:           Initializing the Multidimensional Solver.
+                                                              (line  48)
+* gsl_multiroot_fsolver_alloc:           Initializing the Multidimensional Solver.
+                                                              (line  11)
+* gsl_multiroot_fsolver_broyden:         Algorithms without Derivatives.
+                                                              (line  45)
+* gsl_multiroot_fsolver_dnewton:         Algorithms without Derivatives.
+                                                              (line  25)
+* gsl_multiroot_fsolver_dx:              Iteration of the multidimensional solver.
+                                                              (line  46)
+* gsl_multiroot_fsolver_f:               Iteration of the multidimensional solver.
+                                                              (line  39)
+* gsl_multiroot_fsolver_free:            Initializing the Multidimensional Solver.
+                                                              (line  53)
+* gsl_multiroot_fsolver_hybrid:          Algorithms without Derivatives.
+                                                              (line  21)
+* gsl_multiroot_fsolver_hybrids:         Algorithms without Derivatives.
+                                                              (line  13)
+* gsl_multiroot_fsolver_iterate:         Iteration of the multidimensional solver.
+                                                              (line  12)
+* gsl_multiroot_fsolver_name:            Initializing the Multidimensional Solver.
+                                                              (line  59)
+* gsl_multiroot_fsolver_root:            Iteration of the multidimensional solver.
+                                                              (line  32)
+* gsl_multiroot_fsolver_set:             Initializing the Multidimensional Solver.
+                                                              (line  43)
+* gsl_multiroot_test_delta:              Search Stopping Parameters for the multidimensional solver.
+                                                              (line  20)
+* gsl_multiroot_test_residual:           Search Stopping Parameters for the multidimensional solver.
+                                                              (line  32)
+* GSL_NAN:                               Infinities and Not-a-number.
+                                                              (line  14)
+* GSL_NEGINF:                            Infinities and Not-a-number.
+                                                              (line  10)
+* gsl_ntuple_bookdata:                   Writing ntuples.     (line  10)
+* gsl_ntuple_close:                      Closing an ntuple file.
+                                                              (line   6)
+* gsl_ntuple_create:                     Creating ntuples.    (line   6)
+* gsl_ntuple_open:                       Opening an existing ntuple file.
+                                                              (line   6)
+* gsl_ntuple_project:                    Histogramming ntuple values.
+                                                              (line  33)
+* gsl_ntuple_read:                       Reading ntuples.     (line   6)
+* gsl_ntuple_write:                      Writing ntuples.     (line   6)
+* gsl_odeiv_control_alloc:               Adaptive Step-size Control.
+                                                              (line  73)
+* gsl_odeiv_control_free:                Adaptive Step-size Control.
+                                                              (line  86)
+* gsl_odeiv_control_hadjust:             Adaptive Step-size Control.
+                                                              (line  90)
+* gsl_odeiv_control_init:                Adaptive Step-size Control.
+                                                              (line  80)
+* gsl_odeiv_control_name:                Adaptive Step-size Control.
+                                                              (line 105)
+* gsl_odeiv_control_scaled_new:          Adaptive Step-size Control.
+                                                              (line  60)
+* gsl_odeiv_control_standard_new:        Adaptive Step-size Control.
+                                                              (line  10)
+* gsl_odeiv_control_yp_new:              Adaptive Step-size Control.
+                                                              (line  52)
+* gsl_odeiv_control_y_new:               Adaptive Step-size Control.
+                                                              (line  44)
+* gsl_odeiv_evolve_alloc:                Evolution.           (line  14)
+* gsl_odeiv_evolve_apply:                Evolution.           (line  18)
+* gsl_odeiv_evolve_free:                 Evolution.           (line  48)
+* gsl_odeiv_evolve_reset:                Evolution.           (line  43)
+* gsl_odeiv_step_alloc:                  Stepping Functions.  (line  10)
+* gsl_odeiv_step_apply:                  Stepping Functions.  (line  40)
+* gsl_odeiv_step_bsimp:                  Stepping Functions.  (line  91)
+* gsl_odeiv_step_free:                   Stepping Functions.  (line  20)
+* gsl_odeiv_step_gear1:                  Stepping Functions.  (line  95)
+* gsl_odeiv_step_gear2:                  Stepping Functions.  (line  98)
+* gsl_odeiv_step_name:                   Stepping Functions.  (line  24)
+* gsl_odeiv_step_order:                  Stepping Functions.  (line  34)
+* gsl_odeiv_step_reset:                  Stepping Functions.  (line  15)
+* gsl_odeiv_step_rk2:                    Stepping Functions.  (line  69)
+* gsl_odeiv_step_rk2imp:                 Stepping Functions.  (line  85)
+* gsl_odeiv_step_rk4:                    Stepping Functions.  (line  72)
+* gsl_odeiv_step_rk4imp:                 Stepping Functions.  (line  88)
+* gsl_odeiv_step_rk8pd:                  Stepping Functions.  (line  82)
+* gsl_odeiv_step_rkck:                   Stepping Functions.  (line  79)
+* gsl_odeiv_step_rkf45:                  Stepping Functions.  (line  75)
+* gsl_permutation_alloc:                 Permutation allocation.
+                                                              (line   6)
+* gsl_permutation_calloc:                Permutation allocation.
+                                                              (line  14)
+* gsl_permutation_canonical_cycles:      Permutations in cyclic form.
+                                                              (line  67)
+* gsl_permutation_canonical_to_linear:   Permutations in cyclic form.
+                                                              (line  49)
+* gsl_permutation_data:                  Permutation properties.
+                                                              (line   9)
+* gsl_permutation_fprintf:               Reading and writing permutations.
+                                                              (line  27)
+* gsl_permutation_fread:                 Reading and writing permutations.
+                                                              (line  17)
+* gsl_permutation_free:                  Permutation allocation.
+                                                              (line  23)
+* gsl_permutation_fscanf:                Reading and writing permutations.
+                                                              (line  36)
+* gsl_permutation_fwrite:                Reading and writing permutations.
+                                                              (line   9)
+* gsl_permutation_get:                   Accessing permutation elements.
+                                                              (line   9)
+* gsl_permutation_init:                  Permutation allocation.
+                                                              (line  19)
+* gsl_permutation_inverse:               Permutation functions.
+                                                              (line   9)
+* gsl_permutation_inversions:            Permutations in cyclic form.
+                                                              (line  54)
+* gsl_permutation_linear_cycles:         Permutations in cyclic form.
+                                                              (line  62)
+* gsl_permutation_linear_to_canonical:   Permutations in cyclic form.
+                                                              (line  44)
+* gsl_permutation_memcpy:                Permutation allocation.
+                                                              (line  26)
+* gsl_permutation_mul:                   Applying Permutations.
+                                                              (line  35)
+* gsl_permutation_next:                  Permutation functions.
+                                                              (line  14)
+* gsl_permutation_prev:                  Permutation functions.
+                                                              (line  22)
+* gsl_permutation_reverse:               Permutation functions.
+                                                              (line   6)
+* gsl_permutation_size:                  Permutation properties.
+                                                              (line   6)
+* gsl_permutation_swap:                  Accessing permutation elements.
+                                                              (line  15)
+* gsl_permutation_valid:                 Permutation properties.
+                                                              (line  13)
+* gsl_permute:                           Applying Permutations.
+                                                              (line   6)
+* gsl_permute_inverse:                   Applying Permutations.
+                                                              (line  11)
+* gsl_permute_vector:                    Applying Permutations.
+                                                              (line  16)
+* gsl_permute_vector_inverse:            Applying Permutations.
+                                                              (line  25)
+* gsl_poly_complex_solve:                General Polynomial Equations.
+                                                              (line  25)
+* gsl_poly_complex_solve_cubic:          Cubic Equations.     (line  21)
+* gsl_poly_complex_solve_quadratic:      Quadratic Equations. (line  28)
+* gsl_poly_complex_workspace_alloc:      General Polynomial Equations.
+                                                              (line  11)
+* gsl_poly_complex_workspace_free:       General Polynomial Equations.
+                                                              (line  21)
+* gsl_poly_dd_eval:                      Divided Difference Representation of Polynomials.
+                                                              (line  17)
+* gsl_poly_dd_init:                      Divided Difference Representation of Polynomials.
+                                                              (line  10)
+* gsl_poly_dd_taylor:                    Divided Difference Representation of Polynomials.
+                                                              (line  22)
+* gsl_poly_eval:                         Polynomial Evaluation.
+                                                              (line   6)
+* gsl_poly_solve_cubic:                  Cubic Equations.     (line   6)
+* gsl_poly_solve_quadratic:              Quadratic Equations. (line   6)
+* GSL_POSINF:                            Infinities and Not-a-number.
+                                                              (line   6)
+* gsl_pow_2:                             Small integer powers.
+                                                              (line  18)
+* gsl_pow_3:                             Small integer powers.
+                                                              (line  19)
+* gsl_pow_4:                             Small integer powers.
+                                                              (line  20)
+* gsl_pow_5:                             Small integer powers.
+                                                              (line  21)
+* gsl_pow_6:                             Small integer powers.
+                                                              (line  22)
+* gsl_pow_7:                             Small integer powers.
+                                                              (line  23)
+* gsl_pow_8:                             Small integer powers.
+                                                              (line  24)
+* gsl_pow_9:                             Small integer powers.
+                                                              (line  25)
+* gsl_pow_int:                           Small integer powers.
+                                                              (line  11)
+* gsl_qrng_alloc:                        Quasi-random number generator initialization.
+                                                              (line   6)
+* gsl_qrng_clone:                        Saving and resorting quasi-random number generator state.
+                                                              (line  12)
+* gsl_qrng_free:                         Quasi-random number generator initialization.
+                                                              (line  14)
+* gsl_qrng_get:                          Sampling from a quasi-random number generator.
+                                                              (line   6)
+* gsl_qrng_init:                         Quasi-random number generator initialization.
+                                                              (line  17)
+* gsl_qrng_memcpy:                       Saving and resorting quasi-random number generator state.
+                                                              (line   6)
+* gsl_qrng_name:                         Auxiliary quasi-random number generator functions.
+                                                              (line   6)
+* gsl_qrng_niederreiter_2:               Quasi-random number generator algorithms.
+                                                              (line   8)
+* gsl_qrng_size:                         Auxiliary quasi-random number generator functions.
+                                                              (line   9)
+* gsl_qrng_sobol:                        Quasi-random number generator algorithms.
+                                                              (line  13)
+* gsl_qrng_state:                        Auxiliary quasi-random number generator functions.
+                                                              (line  10)
+* gsl_ran_bernoulli:                     The Bernoulli Distribution.
+                                                              (line   6)
+* gsl_ran_bernoulli_pdf:                 The Bernoulli Distribution.
+                                                              (line  15)
+* gsl_ran_beta:                          The Beta Distribution.
+                                                              (line   6)
+* gsl_ran_beta_pdf:                      The Beta Distribution.
+                                                              (line  15)
+* gsl_ran_binomial:                      The Binomial Distribution.
+                                                              (line   6)
+* gsl_ran_binomial_pdf:                  The Binomial Distribution.
+                                                              (line  17)
+* gsl_ran_bivariate_gaussian:            The Bivariate Gaussian Distribution.
+                                                              (line   6)
+* gsl_ran_bivariate_gaussian_pdf:        The Bivariate Gaussian Distribution.
+                                                              (line  18)
+* gsl_ran_cauchy:                        The Cauchy Distribution.
+                                                              (line   6)
+* gsl_ran_cauchy_pdf:                    The Cauchy Distribution.
+                                                              (line  16)
+* gsl_ran_chisq:                         The Chi-squared Distribution.
+                                                              (line  14)
+* gsl_ran_chisq_pdf:                     The Chi-squared Distribution.
+                                                              (line  23)
+* gsl_ran_choose:                        Shuffling and Sampling.
+                                                              (line  33)
+* gsl_ran_dirichlet:                     The Dirichlet Distribution.
+                                                              (line   6)
+* gsl_ran_dirichlet_lnpdf:               The Dirichlet Distribution.
+                                                              (line  30)
+* gsl_ran_dirichlet_pdf:                 The Dirichlet Distribution.
+                                                              (line  24)
+* gsl_ran_dir_2d:                        Spherical Vector Distributions.
+                                                              (line  10)
+* gsl_ran_dir_2d_trig_method:            Spherical Vector Distributions.
+                                                              (line  12)
+* gsl_ran_dir_3d:                        Spherical Vector Distributions.
+                                                              (line  31)
+* gsl_ran_dir_nd:                        Spherical Vector Distributions.
+                                                              (line  40)
+* gsl_ran_discrete:                      General Discrete Distributions.
+                                                              (line  59)
+* gsl_ran_discrete_free:                 General Discrete Distributions.
+                                                              (line  72)
+* gsl_ran_discrete_pdf:                  General Discrete Distributions.
+                                                              (line  64)
+* gsl_ran_discrete_preproc:              General Discrete Distributions.
+                                                              (line  49)
+* gsl_ran_exponential:                   The Exponential Distribution.
+                                                              (line   6)
+* gsl_ran_exponential_pdf:               The Exponential Distribution.
+                                                              (line  14)
+* gsl_ran_exppow:                        The Exponential Power Distribution.
+                                                              (line   6)
+* gsl_ran_exppow_pdf:                    The Exponential Power Distribution.
+                                                              (line  18)
+* gsl_ran_fdist:                         The F-distribution.  (line  13)
+* gsl_ran_fdist_pdf:                     The F-distribution.  (line  26)
+* gsl_ran_flat:                          The Flat (Uniform) Distribution.
+                                                              (line   6)
+* gsl_ran_flat_pdf:                      The Flat (Uniform) Distribution.
+                                                              (line  15)
+* gsl_ran_gamma:                         The Gamma Distribution.
+                                                              (line   6)
+* gsl_ran_gamma_knuth:                   The Gamma Distribution.
+                                                              (line  22)
+* gsl_ran_gamma_pdf:                     The Gamma Distribution.
+                                                              (line  27)
+* gsl_ran_gaussian:                      The Gaussian Distribution.
+                                                              (line   6)
+* gsl_ran_gaussian_pdf:                  The Gaussian Distribution.
+                                                              (line  19)
+* gsl_ran_gaussian_ratio_method:         The Gaussian Distribution.
+                                                              (line  27)
+* gsl_ran_gaussian_tail:                 The Gaussian Tail Distribution.
+                                                              (line   6)
+* gsl_ran_gaussian_tail_pdf:             The Gaussian Tail Distribution.
+                                                              (line  23)
+* gsl_ran_gaussian_ziggurat:             The Gaussian Distribution.
+                                                              (line  25)
+* gsl_ran_geometric:                     The Geometric Distribution.
+                                                              (line   6)
+* gsl_ran_geometric_pdf:                 The Geometric Distribution.
+                                                              (line  19)
+* gsl_ran_gumbel1:                       The Type-1 Gumbel Distribution.
+                                                              (line   6)
+* gsl_ran_gumbel1_pdf:                   The Type-1 Gumbel Distribution.
+                                                              (line  15)
+* gsl_ran_gumbel2:                       The Type-2 Gumbel Distribution.
+                                                              (line   6)
+* gsl_ran_gumbel2_pdf:                   The Type-2 Gumbel Distribution.
+                                                              (line  15)
+* gsl_ran_hypergeometric:                The Hypergeometric Distribution.
+                                                              (line   6)
+* gsl_ran_hypergeometric_pdf:            The Hypergeometric Distribution.
+                                                              (line  22)
+* gsl_ran_landau:                        The Landau Distribution.
+                                                              (line   6)
+* gsl_ran_landau_pdf:                    The Landau Distribution.
+                                                              (line  17)
+* gsl_ran_laplace:                       The Laplace Distribution.
+                                                              (line   6)
+* gsl_ran_laplace_pdf:                   The Laplace Distribution.
+                                                              (line  14)
+* gsl_ran_levy:                          The Levy alpha-Stable Distributions.
+                                                              (line   6)
+* gsl_ran_levy_skew:                     The Levy skew alpha-Stable Distribution.
+                                                              (line   6)
+* gsl_ran_logarithmic:                   The Logarithmic Distribution.
+                                                              (line   6)
+* gsl_ran_logarithmic_pdf:               The Logarithmic Distribution.
+                                                              (line  16)
+* gsl_ran_logistic:                      The Logistic Distribution.
+                                                              (line   6)
+* gsl_ran_logistic_pdf:                  The Logistic Distribution.
+                                                              (line  14)
+* gsl_ran_lognormal:                     The Lognormal Distribution.
+                                                              (line   6)
+* gsl_ran_lognormal_pdf:                 The Lognormal Distribution.
+                                                              (line  15)
+* gsl_ran_multinomial:                   The Multinomial Distribution.
+                                                              (line   6)
+* gsl_ran_multinomial_lnpdf:             The Multinomial Distribution.
+                                                              (line  34)
+* gsl_ran_multinomial_pdf:               The Multinomial Distribution.
+                                                              (line  28)
+* gsl_ran_negative_binomial:             The Negative Binomial Distribution.
+                                                              (line   6)
+* gsl_ran_negative_binomial_pdf:         The Negative Binomial Distribution.
+                                                              (line  17)
+* gsl_ran_pareto:                        The Pareto Distribution.
+                                                              (line   6)
+* gsl_ran_pareto_pdf:                    The Pareto Distribution.
+                                                              (line  15)
+* gsl_ran_pascal:                        The Pascal Distribution.
+                                                              (line   6)
+* gsl_ran_pascal_pdf:                    The Pascal Distribution.
+                                                              (line  16)
+* gsl_ran_poisson:                       The Poisson Distribution.
+                                                              (line   6)
+* gsl_ran_poisson_pdf:                   The Poisson Distribution.
+                                                              (line  16)
+* gsl_ran_rayleigh:                      The Rayleigh Distribution.
+                                                              (line   6)
+* gsl_ran_rayleigh_pdf:                  The Rayleigh Distribution.
+                                                              (line  14)
+* gsl_ran_rayleigh_tail:                 The Rayleigh Tail Distribution.
+                                                              (line   6)
+* gsl_ran_rayleigh_tail_pdf:             The Rayleigh Tail Distribution.
+                                                              (line  16)
+* gsl_ran_sample:                        Shuffling and Sampling.
+                                                              (line  59)
+* gsl_ran_shuffle:                       Shuffling and Sampling.
+                                                              (line  13)
+* gsl_ran_tdist:                         The t-distribution.  (line  14)
+* gsl_ran_tdist_pdf:                     The t-distribution.  (line  23)
+* gsl_ran_ugaussian:                     The Gaussian Distribution.
+                                                              (line  34)
+* gsl_ran_ugaussian_pdf:                 The Gaussian Distribution.
+                                                              (line  35)
+* gsl_ran_ugaussian_ratio_method:        The Gaussian Distribution.
+                                                              (line  36)
+* gsl_ran_ugaussian_tail:                The Gaussian Tail Distribution.
+                                                              (line  30)
+* gsl_ran_ugaussian_tail_pdf:            The Gaussian Tail Distribution.
+                                                              (line  32)
+* gsl_ran_weibull:                       The Weibull Distribution.
+                                                              (line   6)
+* gsl_ran_weibull_pdf:                   The Weibull Distribution.
+                                                              (line  15)
+* GSL_REAL:                              Complex numbers.     (line  33)
+* gsl_rng_alloc:                         Random number generator initialization.
+                                                              (line   6)
+* gsl_rng_borosh13:                      Other random number generators.
+                                                              (line 174)
+* gsl_rng_clone:                         Copying random number generator state.
+                                                              (line  16)
+* gsl_rng_cmrg:                          Random number generator algorithms.
+                                                              (line  95)
+* gsl_rng_coveyou:                       Other random number generators.
+                                                              (line 201)
+* gsl_rng_env_setup:                     Random number environment variables.
+                                                              (line  11)
+* gsl_rng_fishman18:                     Other random number generators.
+                                                              (line 175)
+* gsl_rng_fishman20:                     Other random number generators.
+                                                              (line 176)
+* gsl_rng_fishman2x:                     Other random number generators.
+                                                              (line 191)
+* gsl_rng_fread:                         Reading and writing random number generator state.
+                                                              (line  17)
+* gsl_rng_free:                          Random number generator initialization.
+                                                              (line  37)
+* gsl_rng_fwrite:                        Reading and writing random number generator state.
+                                                              (line   9)
+* gsl_rng_get:                           Sampling from a random number generator.
+                                                              (line  10)
+* gsl_rng_gfsr4:                         Random number generator algorithms.
+                                                              (line 170)
+* gsl_rng_knuthran:                      Other random number generators.
+                                                              (line 167)
+* gsl_rng_knuthran2:                     Other random number generators.
+                                                              (line 157)
+* gsl_rng_knuthran2002:                  Other random number generators.
+                                                              (line 166)
+* gsl_rng_lecuyer21:                     Other random number generators.
+                                                              (line 177)
+* gsl_rng_max:                           Auxiliary random number generator functions.
+                                                              (line  19)
+* gsl_rng_memcpy:                        Copying random number generator state.
+                                                              (line  11)
+* gsl_rng_min:                           Auxiliary random number generator functions.
+                                                              (line  23)
+* gsl_rng_minstd:                        Other random number generators.
+                                                              (line 113)
+* gsl_rng_mrg:                           Random number generator algorithms.
+                                                              (line 117)
+* gsl_rng_mt19937:                       Random number generator algorithms.
+                                                              (line  19)
+* gsl_rng_name:                          Auxiliary random number generator functions.
+                                                              (line  10)
+* gsl_rng_r250:                          Other random number generators.
+                                                              (line  59)
+* gsl_rng_rand:                          Unix random number generators.
+                                                              (line  17)
+* gsl_rng_rand48:                        Unix random number generators.
+                                                              (line  57)
+* gsl_rng_random_bsd:                    Unix random number generators.
+                                                              (line  26)
+* gsl_rng_random_glibc2:                 Unix random number generators.
+                                                              (line  28)
+* gsl_rng_random_libc5:                  Unix random number generators.
+                                                              (line  27)
+* gsl_rng_randu:                         Other random number generators.
+                                                              (line 104)
+* gsl_rng_ranf:                          Other random number generators.
+                                                              (line  22)
+* gsl_rng_ranlux:                        Random number generator algorithms.
+                                                              (line  68)
+* gsl_rng_ranlux389:                     Random number generator algorithms.
+                                                              (line  69)
+* gsl_rng_ranlxd1:                       Random number generator algorithms.
+                                                              (line  61)
+* gsl_rng_ranlxd2:                       Random number generator algorithms.
+                                                              (line  62)
+* gsl_rng_ranlxs0:                       Random number generator algorithms.
+                                                              (line  44)
+* gsl_rng_ranlxs1:                       Random number generator algorithms.
+                                                              (line  45)
+* gsl_rng_ranlxs2:                       Random number generator algorithms.
+                                                              (line  46)
+* gsl_rng_ranmar:                        Other random number generators.
+                                                              (line  53)
+* gsl_rng_set:                           Random number generator initialization.
+                                                              (line  25)
+* gsl_rng_size:                          Auxiliary random number generator functions.
+                                                              (line  30)
+* gsl_rng_slatec:                        Other random number generators.
+                                                              (line 140)
+* gsl_rng_state:                         Auxiliary random number generator functions.
+                                                              (line  29)
+* gsl_rng_taus:                          Random number generator algorithms.
+                                                              (line 134)
+* gsl_rng_taus2:                         Random number generator algorithms.
+                                                              (line 135)
+* gsl_rng_transputer:                    Other random number generators.
+                                                              (line  95)
+* gsl_rng_tt800:                         Other random number generators.
+                                                              (line  74)
+* gsl_rng_types_setup:                   Auxiliary random number generator functions.
+                                                              (line  40)
+* gsl_rng_uni:                           Other random number generators.
+                                                              (line 133)
+* gsl_rng_uni32:                         Other random number generators.
+                                                              (line 134)
+* gsl_rng_uniform:                       Sampling from a random number generator.
+                                                              (line  17)
+* gsl_rng_uniform_int:                   Sampling from a random number generator.
+                                                              (line  35)
+* gsl_rng_uniform_pos:                   Sampling from a random number generator.
+                                                              (line  27)
+* gsl_rng_vax:                           Other random number generators.
+                                                              (line  86)
+* gsl_rng_waterman14:                    Other random number generators.
+                                                              (line 178)
+* gsl_rng_zuf:                           Other random number generators.
+                                                              (line 144)
+* gsl_root_fdfsolver_alloc:              Initializing the Solver.
+                                                              (line  21)
+* gsl_root_fdfsolver_free:               Initializing the Solver.
+                                                              (line  48)
+* gsl_root_fdfsolver_iterate:            Root Finding Iteration.
+                                                              (line  13)
+* gsl_root_fdfsolver_name:               Initializing the Solver.
+                                                              (line  53)
+* gsl_root_fdfsolver_newton:             Root Finding Algorithms using Derivatives.
+                                                              (line  15)
+* gsl_root_fdfsolver_root:               Root Finding Iteration.
+                                                              (line  33)
+* gsl_root_fdfsolver_secant:             Root Finding Algorithms using Derivatives.
+                                                              (line  29)
+* gsl_root_fdfsolver_set:                Initializing the Solver.
+                                                              (line  42)
+* gsl_root_fdfsolver_steffenson:         Root Finding Algorithms using Derivatives.
+                                                              (line  60)
+* gsl_root_fsolver_alloc:                Initializing the Solver.
+                                                              (line   6)
+* gsl_root_fsolver_bisection:            Root Bracketing Algorithms.
+                                                              (line  16)
+* gsl_root_fsolver_brent:                Root Bracketing Algorithms.
+                                                              (line  49)
+* gsl_root_fsolver_falsepos:             Root Bracketing Algorithms.
+                                                              (line  32)
+* gsl_root_fsolver_free:                 Initializing the Solver.
+                                                              (line  47)
+* gsl_root_fsolver_iterate:              Root Finding Iteration.
+                                                              (line  12)
+* gsl_root_fsolver_name:                 Initializing the Solver.
+                                                              (line  51)
+* gsl_root_fsolver_root:                 Root Finding Iteration.
+                                                              (line  32)
+* gsl_root_fsolver_set:                  Initializing the Solver.
+                                                              (line  36)
+* gsl_root_fsolver_x_lower:              Root Finding Iteration.
+                                                              (line  38)
+* gsl_root_fsolver_x_upper:              Root Finding Iteration.
+                                                              (line  40)
+* gsl_root_test_delta:                   Search Stopping Parameters.
+                                                              (line  41)
+* gsl_root_test_interval:                Search Stopping Parameters.
+                                                              (line  19)
+* gsl_root_test_residual:                Search Stopping Parameters.
+                                                              (line  52)
+* GSL_SET_COMPLEX:                       Complex numbers.     (line  38)
+* gsl_set_error_handler:                 Error Handlers.      (line  43)
+* gsl_set_error_handler_off:             Error Handlers.      (line  69)
+* GSL_SET_IMAG:                          Complex numbers.     (line  48)
+* GSL_SET_REAL:                          Complex numbers.     (line  47)
+* gsl_sf_airy_Ai:                        Airy Functions.      (line   6)
+* gsl_sf_airy_Ai_deriv:                  Derivatives of Airy Functions.
+                                                              (line   6)
+* gsl_sf_airy_Ai_deriv_e:                Derivatives of Airy Functions.
+                                                              (line   7)
+* gsl_sf_airy_Ai_deriv_scaled:           Derivatives of Airy Functions.
+                                                              (line  18)
+* gsl_sf_airy_Ai_deriv_scaled_e:         Derivatives of Airy Functions.
+                                                              (line  20)
+* gsl_sf_airy_Ai_e:                      Airy Functions.      (line   7)
+* gsl_sf_airy_Ai_scaled:                 Airy Functions.      (line  18)
+* gsl_sf_airy_Ai_scaled_e:               Airy Functions.      (line  19)
+* gsl_sf_airy_Bi:                        Airy Functions.      (line  12)
+* gsl_sf_airy_Bi_deriv:                  Derivatives of Airy Functions.
+                                                              (line  12)
+* gsl_sf_airy_Bi_deriv_e:                Derivatives of Airy Functions.
+                                                              (line  13)
+* gsl_sf_airy_Bi_deriv_scaled:           Derivatives of Airy Functions.
+                                                              (line  26)
+* gsl_sf_airy_Bi_deriv_scaled_e:         Derivatives of Airy Functions.
+                                                              (line  28)
+* gsl_sf_airy_Bi_e:                      Airy Functions.      (line  13)
+* gsl_sf_airy_Bi_scaled:                 Airy Functions.      (line  25)
+* gsl_sf_airy_Bi_scaled_e:               Airy Functions.      (line  26)
+* gsl_sf_airy_zero_Ai:                   Zeros of Airy Functions.
+                                                              (line   6)
+* gsl_sf_airy_zero_Ai_deriv:             Zeros of Derivatives of Airy Functions.
+                                                              (line   6)
+* gsl_sf_airy_zero_Ai_deriv_e:           Zeros of Derivatives of Airy Functions.
+                                                              (line   7)
+* gsl_sf_airy_zero_Ai_e:                 Zeros of Airy Functions.
+                                                              (line   7)
+* gsl_sf_airy_zero_Bi:                   Zeros of Airy Functions.
+                                                              (line  12)
+* gsl_sf_airy_zero_Bi_deriv:             Zeros of Derivatives of Airy Functions.
+                                                              (line  12)
+* gsl_sf_airy_zero_Bi_deriv_e:           Zeros of Derivatives of Airy Functions.
+                                                              (line  13)
+* gsl_sf_airy_zero_Bi_e:                 Zeros of Airy Functions.
+                                                              (line  13)
+* gsl_sf_angle_restrict_pos:             Restriction Functions.
+                                                              (line  15)
+* gsl_sf_angle_restrict_pos_e:           Restriction Functions.
+                                                              (line  16)
+* gsl_sf_angle_restrict_symm:            Restriction Functions.
+                                                              (line   6)
+* gsl_sf_angle_restrict_symm_e:          Restriction Functions.
+                                                              (line   7)
+* gsl_sf_atanint:                        Arctangent Integral. (line   6)
+* gsl_sf_atanint_e:                      Arctangent Integral. (line   7)
+* gsl_sf_bessel_I0:                      Regular Modified Cylindrical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_I0_e:                    Regular Modified Cylindrical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_I0_scaled:               Regular Modified Cylindrical Bessel Functions.
+                                                              (line  31)
+* gsl_sf_bessel_i0_scaled:               Regular Modified Spherical Bessel Functions.
+                                                              (line  10)
+* gsl_sf_bessel_I0_scaled_e:             Regular Modified Cylindrical Bessel Functions.
+                                                              (line  32)
+* gsl_sf_bessel_i0_scaled_e:             Regular Modified Spherical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_I1:                      Regular Modified Cylindrical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_I1_e:                    Regular Modified Cylindrical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_I1_scaled:               Regular Modified Cylindrical Bessel Functions.
+                                                              (line  37)
+* gsl_sf_bessel_i1_scaled:               Regular Modified Spherical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_I1_scaled_e:             Regular Modified Cylindrical Bessel Functions.
+                                                              (line  38)
+* gsl_sf_bessel_i1_scaled_e:             Regular Modified Spherical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_i2_scaled:               Regular Modified Spherical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_i2_scaled_e:             Regular Modified Spherical Bessel Functions.
+                                                              (line  23)
+* gsl_sf_bessel_il_scaled:               Regular Modified Spherical Bessel Functions.
+                                                              (line  28)
+* gsl_sf_bessel_il_scaled_array:         Regular Modified Spherical Bessel Functions.
+                                                              (line  34)
+* gsl_sf_bessel_il_scaled_e:             Regular Modified Spherical Bessel Functions.
+                                                              (line  29)
+* gsl_sf_bessel_In:                      Regular Modified Cylindrical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_Inu:                     Regular Modified Bessel Functions - Fractional Order.
+                                                              (line   6)
+* gsl_sf_bessel_Inu_e:                   Regular Modified Bessel Functions - Fractional Order.
+                                                              (line   7)
+* gsl_sf_bessel_Inu_scaled:              Regular Modified Bessel Functions - Fractional Order.
+                                                              (line  12)
+* gsl_sf_bessel_Inu_scaled_e:            Regular Modified Bessel Functions - Fractional Order.
+                                                              (line  13)
+* gsl_sf_bessel_In_array:                Regular Modified Cylindrical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_In_e:                    Regular Modified Cylindrical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_In_scaled:               Regular Modified Cylindrical Bessel Functions.
+                                                              (line  43)
+* gsl_sf_bessel_In_scaled_array:         Regular Modified Cylindrical Bessel Functions.
+                                                              (line  49)
+* gsl_sf_bessel_In_scaled_e:             Regular Modified Cylindrical Bessel Functions.
+                                                              (line  44)
+* gsl_sf_bessel_J0:                      Regular Cylindrical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_j0:                      Regular Spherical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_J0_e:                    Regular Cylindrical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_j0_e:                    Regular Spherical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_J1:                      Regular Cylindrical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_j1:                      Regular Spherical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_J1_e:                    Regular Cylindrical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_j1_e:                    Regular Spherical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_j2:                      Regular Spherical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_j2_e:                    Regular Spherical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_jl:                      Regular Spherical Bessel Functions.
+                                                              (line  21)
+* gsl_sf_bessel_jl_array:                Regular Spherical Bessel Functions.
+                                                              (line  27)
+* gsl_sf_bessel_jl_e:                    Regular Spherical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_jl_steed_array:          Regular Spherical Bessel Functions.
+                                                              (line  35)
+* gsl_sf_bessel_Jn:                      Regular Cylindrical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_Jnu:                     Regular Bessel Function - Fractional Order.
+                                                              (line   6)
+* gsl_sf_bessel_Jnu_e:                   Regular Bessel Function - Fractional Order.
+                                                              (line   7)
+* gsl_sf_bessel_Jn_array:                Regular Cylindrical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_Jn_e:                    Regular Cylindrical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_K0:                      Irregular Modified Cylindrical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_K0_e:                    Irregular Modified Cylindrical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_K0_scaled:               Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  32)
+* gsl_sf_bessel_k0_scaled:               Irregular Modified Spherical Bessel Functions.
+                                                              (line  10)
+* gsl_sf_bessel_K0_scaled_e:             Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  33)
+* gsl_sf_bessel_k0_scaled_e:             Irregular Modified Spherical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_K1:                      Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_K1_e:                    Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_K1_scaled:               Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  38)
+* gsl_sf_bessel_k1_scaled:               Irregular Modified Spherical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_K1_scaled_e:             Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  39)
+* gsl_sf_bessel_k1_scaled_e:             Irregular Modified Spherical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_k2_scaled:               Irregular Modified Spherical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_k2_scaled_e:             Irregular Modified Spherical Bessel Functions.
+                                                              (line  23)
+* gsl_sf_bessel_kl_scaled:               Irregular Modified Spherical Bessel Functions.
+                                                              (line  28)
+* gsl_sf_bessel_kl_scaled_array:         Irregular Modified Spherical Bessel Functions.
+                                                              (line  34)
+* gsl_sf_bessel_kl_scaled_e:             Irregular Modified Spherical Bessel Functions.
+                                                              (line  29)
+* gsl_sf_bessel_Kn:                      Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_Knu:                     Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line   6)
+* gsl_sf_bessel_Knu_e:                   Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line   7)
+* gsl_sf_bessel_Knu_scaled:              Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line  19)
+* gsl_sf_bessel_Knu_scaled_e:            Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line  20)
+* gsl_sf_bessel_Kn_array:                Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_Kn_e:                    Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_Kn_scaled:               Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  44)
+* gsl_sf_bessel_Kn_scaled_array:         Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  50)
+* gsl_sf_bessel_Kn_scaled_e:             Irregular Modified Cylindrical Bessel Functions.
+                                                              (line  45)
+* gsl_sf_bessel_lnKnu:                   Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line  12)
+* gsl_sf_bessel_lnKnu_e:                 Irregular Modified Bessel Functions - Fractional Order.
+                                                              (line  13)
+* gsl_sf_bessel_sequence_Jnu_e:          Regular Bessel Function - Fractional Order.
+                                                              (line  12)
+* gsl_sf_bessel_Y0:                      Irregular Cylindrical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_y0:                      Irregular Spherical Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_Y0_e:                    Irregular Cylindrical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_y0_e:                    Irregular Spherical Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_Y1:                      Irregular Cylindrical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_y1:                      Irregular Spherical Bessel Functions.
+                                                              (line  11)
+* gsl_sf_bessel_Y1_e:                    Irregular Cylindrical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_y1_e:                    Irregular Spherical Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_y2:                      Irregular Spherical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_y2_e:                    Irregular Spherical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_yl:                      Irregular Spherical Bessel Functions.
+                                                              (line  21)
+* gsl_sf_bessel_yl_array:                Irregular Spherical Bessel Functions.
+                                                              (line  27)
+* gsl_sf_bessel_yl_e:                    Irregular Spherical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_Yn:                      Irregular Cylindrical Bessel Functions.
+                                                              (line  16)
+* gsl_sf_bessel_Ynu:                     Irregular Bessel Functions - Fractional Order.
+                                                              (line   6)
+* gsl_sf_bessel_Ynu_e:                   Irregular Bessel Functions - Fractional Order.
+                                                              (line   7)
+* gsl_sf_bessel_Yn_array:                Irregular Cylindrical Bessel Functions.
+                                                              (line  22)
+* gsl_sf_bessel_Yn_e:                    Irregular Cylindrical Bessel Functions.
+                                                              (line  17)
+* gsl_sf_bessel_zero_J0:                 Zeros of Regular Bessel Functions.
+                                                              (line   6)
+* gsl_sf_bessel_zero_J0_e:               Zeros of Regular Bessel Functions.
+                                                              (line   7)
+* gsl_sf_bessel_zero_J1:                 Zeros of Regular Bessel Functions.
+                                                              (line  12)
+* gsl_sf_bessel_zero_J1_e:               Zeros of Regular Bessel Functions.
+                                                              (line  13)
+* gsl_sf_bessel_zero_Jnu:                Zeros of Regular Bessel Functions.
+                                                              (line  18)
+* gsl_sf_bessel_zero_Jnu_e:              Zeros of Regular Bessel Functions.
+                                                              (line  19)
+* gsl_sf_beta:                           Beta Functions.      (line   6)
+* gsl_sf_beta_e:                         Beta Functions.      (line   7)
+* gsl_sf_beta_inc:                       Incomplete Beta Function.
+                                                              (line   6)
+* gsl_sf_beta_inc_e:                     Incomplete Beta Function.
+                                                              (line   7)
+* gsl_sf_Chi:                            Hyperbolic Integrals.
+                                                              (line  11)
+* gsl_sf_Chi_e:                          Hyperbolic Integrals.
+                                                              (line  12)
+* gsl_sf_choose:                         Factorials.          (line  38)
+* gsl_sf_choose_e:                       Factorials.          (line  39)
+* gsl_sf_Ci:                             Trigonometric Integrals.
+                                                              (line  11)
+* gsl_sf_Ci_e:                           Trigonometric Integrals.
+                                                              (line  12)
+* gsl_sf_clausen:                        Clausen Functions.   (line  14)
+* gsl_sf_clausen_e:                      Clausen Functions.   (line  15)
+* gsl_sf_complex_cos_e:                  Trigonometric Functions for Complex Arguments.
+                                                              (line  11)
+* gsl_sf_complex_dilog_e:                Complex Argument.    (line   6)
+* gsl_sf_complex_logsin_e:               Trigonometric Functions for Complex Arguments.
+                                                              (line  16)
+* gsl_sf_complex_log_e:                  Logarithm and Related Functions.
+                                                              (line  19)
+* gsl_sf_complex_sin_e:                  Trigonometric Functions for Complex Arguments.
+                                                              (line   6)
+* gsl_sf_conicalP_0:                     Conical Functions.   (line  22)
+* gsl_sf_conicalP_0_e:                   Conical Functions.   (line  23)
+* gsl_sf_conicalP_1:                     Conical Functions.   (line  28)
+* gsl_sf_conicalP_1_e:                   Conical Functions.   (line  29)
+* gsl_sf_conicalP_cyl_reg:               Conical Functions.   (line  41)
+* gsl_sf_conicalP_cyl_reg_e:             Conical Functions.   (line  43)
+* gsl_sf_conicalP_half:                  Conical Functions.   (line  10)
+* gsl_sf_conicalP_half_e:                Conical Functions.   (line  11)
+* gsl_sf_conicalP_mhalf:                 Conical Functions.   (line  16)
+* gsl_sf_conicalP_mhalf_e:               Conical Functions.   (line  17)
+* gsl_sf_conicalP_sph_reg:               Conical Functions.   (line  34)
+* gsl_sf_conicalP_sph_reg_e:             Conical Functions.   (line  36)
+* gsl_sf_cos:                            Circular Trigonometric Functions.
+                                                              (line  10)
+* gsl_sf_cos_e:                          Circular Trigonometric Functions.
+                                                              (line  11)
+* gsl_sf_cos_err_e:                      Trigonometric Functions With Error Estimates.
+                                                              (line  13)
+* gsl_sf_coulomb_CL_array:               Coulomb Wave Function Normalization Constant.
+                                                              (line  14)
+* gsl_sf_coulomb_CL_e:                   Coulomb Wave Function Normalization Constant.
+                                                              (line   9)
+* gsl_sf_coulomb_wave_FGp_array:         Coulomb Wave Functions.
+                                                              (line  47)
+* gsl_sf_coulomb_wave_FG_array:          Coulomb Wave Functions.
+                                                              (line  39)
+* gsl_sf_coulomb_wave_FG_e:              Coulomb Wave Functions.
+                                                              (line  19)
+* gsl_sf_coulomb_wave_F_array:           Coulomb Wave Functions.
+                                                              (line  33)
+* gsl_sf_coulomb_wave_sphF_array:        Coulomb Wave Functions.
+                                                              (line  57)
+* gsl_sf_coupling_3j:                    3-j Symbols.         (line   6)
+* gsl_sf_coupling_3j_e:                  3-j Symbols.         (line   8)
+* gsl_sf_coupling_6j:                    6-j Symbols.         (line   6)
+* gsl_sf_coupling_6j_e:                  6-j Symbols.         (line   8)
+* gsl_sf_coupling_9j:                    9-j Symbols.         (line   6)
+* gsl_sf_coupling_9j_e:                  9-j Symbols.         (line   9)
+* gsl_sf_dawson:                         Dawson Function.     (line  11)
+* gsl_sf_dawson_e:                       Dawson Function.     (line  12)
+* gsl_sf_debye_1:                        Debye Functions.     (line  13)
+* gsl_sf_debye_1_e:                      Debye Functions.     (line  14)
+* gsl_sf_debye_2:                        Debye Functions.     (line  18)
+* gsl_sf_debye_2_e:                      Debye Functions.     (line  19)
+* gsl_sf_debye_3:                        Debye Functions.     (line  23)
+* gsl_sf_debye_3_e:                      Debye Functions.     (line  24)
+* gsl_sf_debye_4:                        Debye Functions.     (line  28)
+* gsl_sf_debye_4_e:                      Debye Functions.     (line  29)
+* gsl_sf_debye_5:                        Debye Functions.     (line  33)
+* gsl_sf_debye_5_e:                      Debye Functions.     (line  34)
+* gsl_sf_debye_6:                        Debye Functions.     (line  38)
+* gsl_sf_debye_6_e:                      Debye Functions.     (line  39)
+* gsl_sf_dilog:                          Real Argument.       (line   6)
+* gsl_sf_dilog_e:                        Real Argument.       (line   7)
+* gsl_sf_doublefact:                     Factorials.          (line  18)
+* gsl_sf_doublefact_e:                   Factorials.          (line  19)
+* gsl_sf_ellint_D:                       Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  34)
+* gsl_sf_ellint_D_e:                     Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  36)
+* gsl_sf_ellint_E:                       Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  15)
+* gsl_sf_ellint_Ecomp:                   Legendre Form of Complete Elliptic Integrals.
+                                                              (line  13)
+* gsl_sf_ellint_Ecomp_e:                 Legendre Form of Complete Elliptic Integrals.
+                                                              (line  14)
+* gsl_sf_ellint_E_e:                     Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  17)
+* gsl_sf_ellint_F:                       Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line   6)
+* gsl_sf_ellint_F_e:                     Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line   8)
+* gsl_sf_ellint_Kcomp:                   Legendre Form of Complete Elliptic Integrals.
+                                                              (line   6)
+* gsl_sf_ellint_Kcomp_e:                 Legendre Form of Complete Elliptic Integrals.
+                                                              (line   7)
+* gsl_sf_ellint_P:                       Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  24)
+* gsl_sf_ellint_Pcomp:                   Legendre Form of Complete Elliptic Integrals.
+                                                              (line  20)
+* gsl_sf_ellint_Pcomp_e:                 Legendre Form of Complete Elliptic Integrals.
+                                                              (line  22)
+* gsl_sf_ellint_P_e:                     Legendre Form of Incomplete Elliptic Integrals.
+                                                              (line  26)
+* gsl_sf_ellint_RC:                      Carlson Forms.       (line   6)
+* gsl_sf_ellint_RC_e:                    Carlson Forms.       (line   8)
+* gsl_sf_ellint_RD:                      Carlson Forms.       (line  13)
+* gsl_sf_ellint_RD_e:                    Carlson Forms.       (line  15)
+* gsl_sf_ellint_RF:                      Carlson Forms.       (line  20)
+* gsl_sf_ellint_RF_e:                    Carlson Forms.       (line  22)
+* gsl_sf_ellint_RJ:                      Carlson Forms.       (line  27)
+* gsl_sf_ellint_RJ_e:                    Carlson Forms.       (line  29)
+* gsl_sf_elljac_e:                       Elliptic Functions (Jacobi).
+                                                              (line  10)
+* gsl_sf_erf:                            Error Function.      (line   6)
+* gsl_sf_erfc:                           Complementary Error Function.
+                                                              (line   6)
+* gsl_sf_erfc_e:                         Complementary Error Function.
+                                                              (line   7)
+* gsl_sf_erf_e:                          Error Function.      (line   7)
+* gsl_sf_erf_Q:                          Probability functions.
+                                                              (line  14)
+* gsl_sf_erf_Q_e:                        Probability functions.
+                                                              (line  15)
+* gsl_sf_erf_Z:                          Probability functions.
+                                                              (line   9)
+* gsl_sf_erf_Z_e:                        Probability functions.
+                                                              (line  10)
+* gsl_sf_eta:                            Eta Function.        (line  12)
+* gsl_sf_eta_e:                          Eta Function.        (line  13)
+* gsl_sf_eta_int:                        Eta Function.        (line   8)
+* gsl_sf_eta_int_e:                      Eta Function.        (line   9)
+* gsl_sf_exp:                            Exponential Function.
+                                                              (line   6)
+* gsl_sf_expint_3:                       Ei_3(x).             (line   6)
+* gsl_sf_expint_3_e:                     Ei_3(x).             (line   7)
+* gsl_sf_expint_E1:                      Exponential Integral.
+                                                              (line   6)
+* gsl_sf_expint_E1_e:                    Exponential Integral.
+                                                              (line   7)
+* gsl_sf_expint_E2:                      Exponential Integral.
+                                                              (line  12)
+* gsl_sf_expint_E2_e:                    Exponential Integral.
+                                                              (line  13)
+* gsl_sf_expint_Ei:                      Ei(x).               (line   6)
+* gsl_sf_expint_Ei_e:                    Ei(x).               (line   7)
+* gsl_sf_expm1:                          Relative Exponential Functions.
+                                                              (line   6)
+* gsl_sf_expm1_e:                        Relative Exponential Functions.
+                                                              (line   7)
+* gsl_sf_exprel:                         Relative Exponential Functions.
+                                                              (line  11)
+* gsl_sf_exprel_2:                       Relative Exponential Functions.
+                                                              (line  18)
+* gsl_sf_exprel_2_e:                     Relative Exponential Functions.
+                                                              (line  19)
+* gsl_sf_exprel_e:                       Relative Exponential Functions.
+                                                              (line  12)
+* gsl_sf_exprel_n:                       Relative Exponential Functions.
+                                                              (line  25)
+* gsl_sf_exprel_n_e:                     Relative Exponential Functions.
+                                                              (line  26)
+* gsl_sf_exp_e:                          Exponential Function.
+                                                              (line   7)
+* gsl_sf_exp_e10_e:                      Exponential Function.
+                                                              (line  11)
+* gsl_sf_exp_err_e:                      Exponentiation With Error Estimate.
+                                                              (line   6)
+* gsl_sf_exp_err_e10_e:                  Exponentiation With Error Estimate.
+                                                              (line  10)
+* gsl_sf_exp_mult:                       Exponential Function.
+                                                              (line  18)
+* gsl_sf_exp_mult_e:                     Exponential Function.
+                                                              (line  19)
+* gsl_sf_exp_mult_e10_e:                 Exponential Function.
+                                                              (line  24)
+* gsl_sf_exp_mult_err_e:                 Exponentiation With Error Estimate.
+                                                              (line  16)
+* gsl_sf_exp_mult_err_e10_e:             Exponentiation With Error Estimate.
+                                                              (line  21)
+* gsl_sf_fact:                           Factorials.          (line  11)
+* gsl_sf_fact_e:                         Factorials.          (line  12)
+* gsl_sf_fermi_dirac_0:                  Complete Fermi-Dirac Integrals.
+                                                              (line  17)
+* gsl_sf_fermi_dirac_0_e:                Complete Fermi-Dirac Integrals.
+                                                              (line  18)
+* gsl_sf_fermi_dirac_1:                  Complete Fermi-Dirac Integrals.
+                                                              (line  23)
+* gsl_sf_fermi_dirac_1_e:                Complete Fermi-Dirac Integrals.
+                                                              (line  24)
+* gsl_sf_fermi_dirac_2:                  Complete Fermi-Dirac Integrals.
+                                                              (line  29)
+* gsl_sf_fermi_dirac_2_e:                Complete Fermi-Dirac Integrals.
+                                                              (line  30)
+* gsl_sf_fermi_dirac_3half:              Complete Fermi-Dirac Integrals.
+                                                              (line  54)
+* gsl_sf_fermi_dirac_3half_e:            Complete Fermi-Dirac Integrals.
+                                                              (line  55)
+* gsl_sf_fermi_dirac_half:               Complete Fermi-Dirac Integrals.
+                                                              (line  48)
+* gsl_sf_fermi_dirac_half_e:             Complete Fermi-Dirac Integrals.
+                                                              (line  49)
+* gsl_sf_fermi_dirac_inc_0:              Incomplete Fermi-Dirac Integrals.
+                                                              (line  10)
+* gsl_sf_fermi_dirac_inc_0_e:            Incomplete Fermi-Dirac Integrals.
+                                                              (line  11)
+* gsl_sf_fermi_dirac_int:                Complete Fermi-Dirac Integrals.
+                                                              (line  35)
+* gsl_sf_fermi_dirac_int_e:              Complete Fermi-Dirac Integrals.
+                                                              (line  36)
+* gsl_sf_fermi_dirac_m1:                 Complete Fermi-Dirac Integrals.
+                                                              (line  10)
+* gsl_sf_fermi_dirac_m1_e:               Complete Fermi-Dirac Integrals.
+                                                              (line  11)
+* gsl_sf_fermi_dirac_mhalf:              Complete Fermi-Dirac Integrals.
+                                                              (line  42)
+* gsl_sf_fermi_dirac_mhalf_e:            Complete Fermi-Dirac Integrals.
+                                                              (line  43)
+* gsl_sf_gamma:                          Gamma Functions.     (line  15)
+* gsl_sf_gammainv:                       Gamma Functions.     (line  48)
+* gsl_sf_gammainv_e:                     Gamma Functions.     (line  49)
+* gsl_sf_gammastar:                      Gamma Functions.     (line  39)
+* gsl_sf_gammastar_e:                    Gamma Functions.     (line  40)
+* gsl_sf_gamma_e:                        Gamma Functions.     (line  16)
+* gsl_sf_gamma_inc:                      Incomplete Gamma Functions.
+                                                              (line   6)
+* gsl_sf_gamma_inc_e:                    Incomplete Gamma Functions.
+                                                              (line   7)
+* gsl_sf_gamma_inc_P:                    Incomplete Gamma Functions.
+                                                              (line  20)
+* gsl_sf_gamma_inc_P_e:                  Incomplete Gamma Functions.
+                                                              (line  21)
+* gsl_sf_gamma_inc_Q:                    Incomplete Gamma Functions.
+                                                              (line  13)
+* gsl_sf_gamma_inc_Q_e:                  Incomplete Gamma Functions.
+                                                              (line  14)
+* gsl_sf_gegenpoly_1:                    Gegenbauer Functions.
+                                                              (line  11)
+* gsl_sf_gegenpoly_1_e:                  Gegenbauer Functions.
+                                                              (line  14)
+* gsl_sf_gegenpoly_2:                    Gegenbauer Functions.
+                                                              (line  12)
+* gsl_sf_gegenpoly_2_e:                  Gegenbauer Functions.
+                                                              (line  16)
+* gsl_sf_gegenpoly_3:                    Gegenbauer Functions.
+                                                              (line  13)
+* gsl_sf_gegenpoly_3_e:                  Gegenbauer Functions.
+                                                              (line  18)
+* gsl_sf_gegenpoly_array:                Gegenbauer Functions.
+                                                              (line  30)
+* gsl_sf_gegenpoly_n:                    Gegenbauer Functions.
+                                                              (line  23)
+* gsl_sf_gegenpoly_n_e:                  Gegenbauer Functions.
+                                                              (line  24)
+* gsl_sf_hazard:                         Probability functions.
+                                                              (line  27)
+* gsl_sf_hazard_e:                       Probability functions.
+                                                              (line  28)
+* gsl_sf_hydrogenicR:                    Normalized Hydrogenic Bound States.
+                                                              (line  12)
+* gsl_sf_hydrogenicR_1:                  Normalized Hydrogenic Bound States.
+                                                              (line   6)
+* gsl_sf_hydrogenicR_1_e:                Normalized Hydrogenic Bound States.
+                                                              (line   7)
+* gsl_sf_hydrogenicR_e:                  Normalized Hydrogenic Bound States.
+                                                              (line  14)
+* gsl_sf_hyperg_0F1:                     Hypergeometric Functions.
+                                                              (line  10)
+* gsl_sf_hyperg_0F1_e:                   Hypergeometric Functions.
+                                                              (line  11)
+* gsl_sf_hyperg_1F1:                     Hypergeometric Functions.
+                                                              (line  21)
+* gsl_sf_hyperg_1F1_e:                   Hypergeometric Functions.
+                                                              (line  22)
+* gsl_sf_hyperg_1F1_int:                 Hypergeometric Functions.
+                                                              (line  15)
+* gsl_sf_hyperg_1F1_int_e:               Hypergeometric Functions.
+                                                              (line  16)
+* gsl_sf_hyperg_2F0:                     Hypergeometric Functions.
+                                                              (line  86)
+* gsl_sf_hyperg_2F0_e:                   Hypergeometric Functions.
+                                                              (line  87)
+* gsl_sf_hyperg_2F1:                     Hypergeometric Functions.
+                                                              (line  51)
+* gsl_sf_hyperg_2F1_conj:                Hypergeometric Functions.
+                                                              (line  63)
+* gsl_sf_hyperg_2F1_conj_e:              Hypergeometric Functions.
+                                                              (line  65)
+* gsl_sf_hyperg_2F1_conj_renorm:         Hypergeometric Functions.
+                                                              (line  78)
+* gsl_sf_hyperg_2F1_conj_renorm_e:       Hypergeometric Functions.
+                                                              (line  80)
+* gsl_sf_hyperg_2F1_e:                   Hypergeometric Functions.
+                                                              (line  53)
+* gsl_sf_hyperg_2F1_renorm:              Hypergeometric Functions.
+                                                              (line  71)
+* gsl_sf_hyperg_2F1_renorm_e:            Hypergeometric Functions.
+                                                              (line  73)
+* gsl_sf_hyperg_U:                       Hypergeometric Functions.
+                                                              (line  39)
+* gsl_sf_hyperg_U_e:                     Hypergeometric Functions.
+                                                              (line  40)
+* gsl_sf_hyperg_U_e10_e:                 Hypergeometric Functions.
+                                                              (line  45)
+* gsl_sf_hyperg_U_int:                   Hypergeometric Functions.
+                                                              (line  27)
+* gsl_sf_hyperg_U_int_e:                 Hypergeometric Functions.
+                                                              (line  28)
+* gsl_sf_hyperg_U_int_e10_e:             Hypergeometric Functions.
+                                                              (line  33)
+* gsl_sf_hypot:                          Circular Trigonometric Functions.
+                                                              (line  14)
+* gsl_sf_hypot_e:                        Circular Trigonometric Functions.
+                                                              (line  15)
+* gsl_sf_hzeta:                          Hurwitz Zeta Function.
+                                                              (line   9)
+* gsl_sf_hzeta_e:                        Hurwitz Zeta Function.
+                                                              (line  10)
+* gsl_sf_laguerre_1:                     Laguerre Functions.  (line  16)
+* gsl_sf_laguerre_1_e:                   Laguerre Functions.  (line  19)
+* gsl_sf_laguerre_2:                     Laguerre Functions.  (line  17)
+* gsl_sf_laguerre_2_e:                   Laguerre Functions.  (line  21)
+* gsl_sf_laguerre_3:                     Laguerre Functions.  (line  18)
+* gsl_sf_laguerre_3_e:                   Laguerre Functions.  (line  23)
+* gsl_sf_laguerre_n:                     Laguerre Functions.  (line  28)
+* gsl_sf_laguerre_n_e:                   Laguerre Functions.  (line  30)
+* gsl_sf_lambert_W0:                     Lambert W Functions. (line  13)
+* gsl_sf_lambert_W0_e:                   Lambert W Functions. (line  14)
+* gsl_sf_lambert_Wm1:                    Lambert W Functions. (line  18)
+* gsl_sf_lambert_Wm1_e:                  Lambert W Functions. (line  19)
+* gsl_sf_legendre_array_size:            Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  49)
+* gsl_sf_legendre_H3d:                   Radial Functions for Hyperbolic Space.
+                                                              (line  30)
+* gsl_sf_legendre_H3d_0:                 Radial Functions for Hyperbolic Space.
+                                                              (line  11)
+* gsl_sf_legendre_H3d_0_e:               Radial Functions for Hyperbolic Space.
+                                                              (line  12)
+* gsl_sf_legendre_H3d_1:                 Radial Functions for Hyperbolic Space.
+                                                              (line  20)
+* gsl_sf_legendre_H3d_1_e:               Radial Functions for Hyperbolic Space.
+                                                              (line  21)
+* gsl_sf_legendre_H3d_array:             Radial Functions for Hyperbolic Space.
+                                                              (line  39)
+* gsl_sf_legendre_H3d_e:                 Radial Functions for Hyperbolic Space.
+                                                              (line  32)
+* gsl_sf_legendre_P1:                    Legendre Polynomials.
+                                                              (line   6)
+* gsl_sf_legendre_P1_e:                  Legendre Polynomials.
+                                                              (line   9)
+* gsl_sf_legendre_P2:                    Legendre Polynomials.
+                                                              (line   7)
+* gsl_sf_legendre_P2_e:                  Legendre Polynomials.
+                                                              (line  11)
+* gsl_sf_legendre_P3:                    Legendre Polynomials.
+                                                              (line   8)
+* gsl_sf_legendre_P3_e:                  Legendre Polynomials.
+                                                              (line  13)
+* gsl_sf_legendre_Pl:                    Legendre Polynomials.
+                                                              (line  18)
+* gsl_sf_legendre_Plm:                   Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  17)
+* gsl_sf_legendre_Plm_array:             Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  23)
+* gsl_sf_legendre_Plm_deriv_array:       Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  25)
+* gsl_sf_legendre_Plm_e:                 Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  18)
+* gsl_sf_legendre_Pl_array:              Legendre Polynomials.
+                                                              (line  24)
+* gsl_sf_legendre_Pl_deriv_array:        Legendre Polynomials.
+                                                              (line  26)
+* gsl_sf_legendre_Pl_e:                  Legendre Polynomials.
+                                                              (line  19)
+* gsl_sf_legendre_Q0:                    Legendre Polynomials.
+                                                              (line  33)
+* gsl_sf_legendre_Q0_e:                  Legendre Polynomials.
+                                                              (line  34)
+* gsl_sf_legendre_Q1:                    Legendre Polynomials.
+                                                              (line  39)
+* gsl_sf_legendre_Q1_e:                  Legendre Polynomials.
+                                                              (line  40)
+* gsl_sf_legendre_Ql:                    Legendre Polynomials.
+                                                              (line  45)
+* gsl_sf_legendre_Ql_e:                  Legendre Polynomials.
+                                                              (line  46)
+* gsl_sf_legendre_sphPlm:                Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  31)
+* gsl_sf_legendre_sphPlm_array:          Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  40)
+* gsl_sf_legendre_sphPlm_deriv_array:    Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  42)
+* gsl_sf_legendre_sphPlm_e:              Associated Legendre Polynomials and Spherical Harmonics.
+                                                              (line  32)
+* gsl_sf_lnbeta:                         Beta Functions.      (line  13)
+* gsl_sf_lnbeta_e:                       Beta Functions.      (line  14)
+* gsl_sf_lnchoose:                       Factorials.          (line  44)
+* gsl_sf_lnchoose_e:                     Factorials.          (line  45)
+* gsl_sf_lncosh:                         Hyperbolic Trigonometric Functions.
+                                                              (line  10)
+* gsl_sf_lncosh_e:                       Hyperbolic Trigonometric Functions.
+                                                              (line  11)
+* gsl_sf_lndoublefact:                   Factorials.          (line  32)
+* gsl_sf_lndoublefact_e:                 Factorials.          (line  33)
+* gsl_sf_lnfact:                         Factorials.          (line  25)
+* gsl_sf_lnfact_e:                       Factorials.          (line  26)
+* gsl_sf_lngamma:                        Gamma Functions.     (line  23)
+* gsl_sf_lngamma_complex_e:              Gamma Functions.     (line  53)
+* gsl_sf_lngamma_e:                      Gamma Functions.     (line  24)
+* gsl_sf_lngamma_sgn_e:                  Gamma Functions.     (line  31)
+* gsl_sf_lnpoch:                         Pochhammer Symbol.   (line  14)
+* gsl_sf_lnpoch_e:                       Pochhammer Symbol.   (line  15)
+* gsl_sf_lnpoch_sgn_e:                   Pochhammer Symbol.   (line  20)
+* gsl_sf_lnsinh:                         Hyperbolic Trigonometric Functions.
+                                                              (line   6)
+* gsl_sf_lnsinh_e:                       Hyperbolic Trigonometric Functions.
+                                                              (line   7)
+* gsl_sf_log:                            Logarithm and Related Functions.
+                                                              (line  10)
+* gsl_sf_log_1plusx:                     Logarithm and Related Functions.
+                                                              (line  25)
+* gsl_sf_log_1plusx_e:                   Logarithm and Related Functions.
+                                                              (line  26)
+* gsl_sf_log_1plusx_mx:                  Logarithm and Related Functions.
+                                                              (line  30)
+* gsl_sf_log_1plusx_mx_e:                Logarithm and Related Functions.
+                                                              (line  31)
+* gsl_sf_log_abs:                        Logarithm and Related Functions.
+                                                              (line  14)
+* gsl_sf_log_abs_e:                      Logarithm and Related Functions.
+                                                              (line  15)
+* gsl_sf_log_e:                          Logarithm and Related Functions.
+                                                              (line  11)
+* gsl_sf_log_erfc:                       Log Complementary Error Function.
+                                                              (line   6)
+* gsl_sf_log_erfc_e:                     Log Complementary Error Function.
+                                                              (line   7)
+* gsl_sf_mathieu_a:                      Mathieu Function Characteristic Values.
+                                                              (line   6)
+* gsl_sf_mathieu_alloc:                  Mathieu Function Workspace.
+                                                              (line  10)
+* gsl_sf_mathieu_a_array:                Mathieu Function Characteristic Values.
+                                                              (line  13)
+* gsl_sf_mathieu_b:                      Mathieu Function Characteristic Values.
+                                                              (line   8)
+* gsl_sf_mathieu_b_array:                Mathieu Function Characteristic Values.
+                                                              (line  16)
+* gsl_sf_mathieu_ce:                     Angular Mathieu Functions.
+                                                              (line   6)
+* gsl_sf_mathieu_ce_array:               Angular Mathieu Functions.
+                                                              (line  13)
+* gsl_sf_mathieu_free:                   Mathieu Function Workspace.
+                                                              (line  17)
+* gsl_sf_mathieu_Mc:                     Radial Mathieu Functions.
+                                                              (line   6)
+* gsl_sf_mathieu_Mc_array:               Radial Mathieu Functions.
+                                                              (line  17)
+* gsl_sf_mathieu_Ms:                     Radial Mathieu Functions.
+                                                              (line   8)
+* gsl_sf_mathieu_Ms_array:               Radial Mathieu Functions.
+                                                              (line  20)
+* gsl_sf_mathieu_se:                     Angular Mathieu Functions.
+                                                              (line   8)
+* gsl_sf_mathieu_se_array:               Angular Mathieu Functions.
+                                                              (line  16)
+* gsl_sf_multiply_e:                     Elementary Operations.
+                                                              (line  10)
+* gsl_sf_multiply_err_e:                 Elementary Operations.
+                                                              (line  15)
+* gsl_sf_poch:                           Pochhammer Symbol.   (line   6)
+* gsl_sf_pochrel:                        Pochhammer Symbol.   (line  28)
+* gsl_sf_pochrel_e:                      Pochhammer Symbol.   (line  29)
+* gsl_sf_poch_e:                         Pochhammer Symbol.   (line   7)
+* gsl_sf_polar_to_rect:                  Conversion Functions.
+                                                              (line   6)
+* gsl_sf_pow_int:                        Power Function.      (line  10)
+* gsl_sf_pow_int_e:                      Power Function.      (line  11)
+* gsl_sf_psi:                            Digamma Function.    (line  11)
+* gsl_sf_psi_1:                          Trigamma Function.   (line  11)
+* gsl_sf_psi_1piy:                       Digamma Function.    (line  16)
+* gsl_sf_psi_1piy_e:                     Digamma Function.    (line  17)
+* gsl_sf_psi_1_e:                        Trigamma Function.   (line  12)
+* gsl_sf_psi_1_int:                      Trigamma Function.   (line   6)
+* gsl_sf_psi_1_int_e:                    Trigamma Function.   (line   7)
+* gsl_sf_psi_e:                          Digamma Function.    (line  12)
+* gsl_sf_psi_int:                        Digamma Function.    (line   6)
+* gsl_sf_psi_int_e:                      Digamma Function.    (line   7)
+* gsl_sf_psi_n:                          Polygamma Function.  (line   6)
+* gsl_sf_psi_n_e:                        Polygamma Function.  (line   7)
+* gsl_sf_rect_to_polar:                  Conversion Functions.
+                                                              (line  12)
+* gsl_sf_Shi:                            Hyperbolic Integrals.
+                                                              (line   6)
+* gsl_sf_Shi_e:                          Hyperbolic Integrals.
+                                                              (line   7)
+* gsl_sf_Si:                             Trigonometric Integrals.
+                                                              (line   6)
+* gsl_sf_sin:                            Circular Trigonometric Functions.
+                                                              (line   6)
+* gsl_sf_sinc:                           Circular Trigonometric Functions.
+                                                              (line  20)
+* gsl_sf_sinc_e:                         Circular Trigonometric Functions.
+                                                              (line  21)
+* gsl_sf_sin_e:                          Circular Trigonometric Functions.
+                                                              (line   7)
+* gsl_sf_sin_err_e:                      Trigonometric Functions With Error Estimates.
+                                                              (line   6)
+* gsl_sf_Si_e:                           Trigonometric Integrals.
+                                                              (line   7)
+* gsl_sf_synchrotron_1:                  Synchrotron Functions.
+                                                              (line   9)
+* gsl_sf_synchrotron_1_e:                Synchrotron Functions.
+                                                              (line  10)
+* gsl_sf_synchrotron_2:                  Synchrotron Functions.
+                                                              (line  15)
+* gsl_sf_synchrotron_2_e:                Synchrotron Functions.
+                                                              (line  16)
+* gsl_sf_taylorcoeff:                    Factorials.          (line  50)
+* gsl_sf_taylorcoeff_e:                  Factorials.          (line  51)
+* gsl_sf_transport_2:                    Transport Functions. (line  10)
+* gsl_sf_transport_2_e:                  Transport Functions. (line  11)
+* gsl_sf_transport_3:                    Transport Functions. (line  15)
+* gsl_sf_transport_3_e:                  Transport Functions. (line  16)
+* gsl_sf_transport_4:                    Transport Functions. (line  20)
+* gsl_sf_transport_4_e:                  Transport Functions. (line  21)
+* gsl_sf_transport_5:                    Transport Functions. (line  25)
+* gsl_sf_transport_5_e:                  Transport Functions. (line  26)
+* gsl_sf_zeta:                           Riemann Zeta Function.
+                                                              (line  14)
+* gsl_sf_zetam1:                         Riemann Zeta Function Minus One.
+                                                              (line  14)
+* gsl_sf_zetam1_e:                       Riemann Zeta Function Minus One.
+                                                              (line  15)
+* gsl_sf_zetam1_int:                     Riemann Zeta Function Minus One.
+                                                              (line  10)
+* gsl_sf_zetam1_int_e:                   Riemann Zeta Function Minus One.
+                                                              (line  11)
+* gsl_sf_zeta_e:                         Riemann Zeta Function.
+                                                              (line  15)
+* gsl_sf_zeta_int:                       Riemann Zeta Function.
+                                                              (line   9)
+* gsl_sf_zeta_int_e:                     Riemann Zeta Function.
+                                                              (line  10)
+* GSL_SIGN:                              Testing the Sign of Numbers.
+                                                              (line   6)
+* gsl_siman_solve:                       Simulated Annealing functions.
+                                                              (line   6)
+* gsl_sort:                              Sorting vectors.     (line  23)
+* gsl_sort_index:                        Sorting vectors.     (line  31)
+* gsl_sort_largest:                      Selecting the k smallest or largest elements.
+                                                              (line  23)
+* gsl_sort_largest_index:                Selecting the k smallest or largest elements.
+                                                              (line  49)
+* gsl_sort_smallest:                     Selecting the k smallest or largest elements.
+                                                              (line  16)
+* gsl_sort_smallest_index:               Selecting the k smallest or largest elements.
+                                                              (line  41)
+* gsl_sort_vector:                       Sorting vectors.     (line  27)
+* gsl_sort_vector_index:                 Sorting vectors.     (line  41)
+* gsl_sort_vector_largest:               Selecting the k smallest or largest elements.
+                                                              (line  32)
+* gsl_sort_vector_largest_index:         Selecting the k smallest or largest elements.
+                                                              (line  59)
+* gsl_sort_vector_smallest:              Selecting the k smallest or largest elements.
+                                                              (line  30)
+* gsl_sort_vector_smallest_index:        Selecting the k smallest or largest elements.
+                                                              (line  57)
+* gsl_spline_alloc:                      Higher-level Interface.
+                                                              (line  13)
+* gsl_spline_eval:                       Higher-level Interface.
+                                                              (line  26)
+* gsl_spline_eval_deriv:                 Higher-level Interface.
+                                                              (line  31)
+* gsl_spline_eval_deriv2:                Higher-level Interface.
+                                                              (line  36)
+* gsl_spline_eval_deriv2_e:              Higher-level Interface.
+                                                              (line  38)
+* gsl_spline_eval_deriv_e:               Higher-level Interface.
+                                                              (line  33)
+* gsl_spline_eval_e:                     Higher-level Interface.
+                                                              (line  28)
+* gsl_spline_eval_integ:                 Higher-level Interface.
+                                                              (line  41)
+* gsl_spline_eval_integ_e:               Higher-level Interface.
+                                                              (line  43)
+* gsl_spline_free:                       Higher-level Interface.
+                                                              (line  19)
+* gsl_spline_init:                       Higher-level Interface.
+                                                              (line  16)
+* gsl_spline_min_size:                   Higher-level Interface.
+                                                              (line  23)
+* gsl_spline_name:                       Higher-level Interface.
+                                                              (line  21)
+* gsl_stats_absdev:                      Absolute deviation.  (line   6)
+* gsl_stats_absdev_m:                    Absolute deviation.  (line  19)
+* gsl_stats_covariance:                  Covariance.          (line   6)
+* gsl_stats_covariance_m:                Covariance.          (line  14)
+* gsl_stats_kurtosis:                    Higher moments (skewness and kurtosis).
+                                                              (line  29)
+* gsl_stats_kurtosis_m_sd:               Higher moments (skewness and kurtosis).
+                                                              (line  40)
+* gsl_stats_lag1_autocorrelation:        Autocorrelation.     (line   6)
+* gsl_stats_lag1_autocorrelation_m:      Autocorrelation.     (line  15)
+* gsl_stats_max:                         Maximum and Minimum values.
+                                                              (line  12)
+* gsl_stats_max_index:                   Maximum and Minimum values.
+                                                              (line  37)
+* gsl_stats_mean:                        Mean and standard deviation and variance.
+                                                              (line   6)
+* gsl_stats_median_from_sorted_data:     Median and Percentiles.
+                                                              (line  10)
+* gsl_stats_min:                         Maximum and Minimum values.
+                                                              (line  22)
+* gsl_stats_minmax:                      Maximum and Minimum values.
+                                                              (line  32)
+* gsl_stats_minmax_index:                Maximum and Minimum values.
+                                                              (line  53)
+* gsl_stats_min_index:                   Maximum and Minimum values.
+                                                              (line  45)
+* gsl_stats_quantile_from_sorted_data:   Median and Percentiles.
+                                                              (line  25)
+* gsl_stats_sd:                          Mean and standard deviation and variance.
+                                                              (line  44)
+* gsl_stats_sd_m:                        Mean and standard deviation and variance.
+                                                              (line  46)
+* gsl_stats_sd_with_fixed_mean:          Mean and standard deviation and variance.
+                                                              (line  62)
+* gsl_stats_skew:                        Higher moments (skewness and kurtosis).
+                                                              (line   6)
+* gsl_stats_skew_m_sd:                   Higher moments (skewness and kurtosis).
+                                                              (line  19)
+* gsl_stats_variance:                    Mean and standard deviation and variance.
+                                                              (line  18)
+* gsl_stats_variance_m:                  Mean and standard deviation and variance.
+                                                              (line  36)
+* gsl_stats_variance_with_fixed_mean:    Mean and standard deviation and variance.
+                                                              (line  52)
+* gsl_stats_wabsdev:                     Weighted Samples.    (line  71)
+* gsl_stats_wabsdev_m:                   Weighted Samples.    (line  79)
+* gsl_stats_wkurtosis:                   Weighted Samples.    (line  98)
+* gsl_stats_wkurtosis_m_sd:              Weighted Samples.    (line 104)
+* gsl_stats_wmean:                       Weighted Samples.    (line  14)
+* gsl_stats_wsd:                         Weighted Samples.    (line  42)
+* gsl_stats_wsd_m:                       Weighted Samples.    (line  48)
+* gsl_stats_wsd_with_fixed_mean:         Weighted Samples.    (line  64)
+* gsl_stats_wskew:                       Weighted Samples.    (line  85)
+* gsl_stats_wskew_m_sd:                  Weighted Samples.    (line  91)
+* gsl_stats_wvariance:                   Weighted Samples.    (line  22)
+* gsl_stats_wvariance_m:                 Weighted Samples.    (line  36)
+* gsl_stats_wvariance_with_fixed_mean:   Weighted Samples.    (line  53)
+* gsl_strerror:                          Error Codes.         (line  37)
+* gsl_sum_levin_utrunc_accel:            Acceleration functions without error estimation.
+                                                              (line  32)
+* gsl_sum_levin_utrunc_alloc:            Acceleration functions without error estimation.
+                                                              (line  22)
+* gsl_sum_levin_utrunc_free:             Acceleration functions without error estimation.
+                                                              (line  28)
+* gsl_sum_levin_u_accel:                 Acceleration functions.
+                                                              (line  31)
+* gsl_sum_levin_u_alloc:                 Acceleration functions.
+                                                              (line  23)
+* gsl_sum_levin_u_free:                  Acceleration functions.
+                                                              (line  28)
+* gsl_vector_add:                        Vector operations.   (line   8)
+* gsl_vector_add_constant:               Vector operations.   (line  32)
+* gsl_vector_alloc:                      Vector allocation.   (line  14)
+* gsl_vector_calloc:                     Vector allocation.   (line  21)
+* gsl_vector_complex_const_imag:         Vector views.        (line 108)
+* gsl_vector_complex_const_real:         Vector views.        (line  97)
+* gsl_vector_complex_imag:               Vector views.        (line 106)
+* gsl_vector_complex_real:               Vector views.        (line  95)
+* gsl_vector_const_ptr:                  Accessing vector elements.
+                                                              (line  38)
+* gsl_vector_const_subvector:            Vector views.        (line  29)
+* gsl_vector_const_subvector_with_stride: Vector views.       (line  59)
+* gsl_vector_const_view_array:           Vector views.        (line 119)
+* gsl_vector_const_view_array_with_stride: Vector views.      (line 142)
+* gsl_vector_div:                        Vector operations.   (line  23)
+* gsl_vector_fprintf:                    Reading and writing vectors.
+                                                              (line  26)
+* gsl_vector_fread:                      Reading and writing vectors.
+                                                              (line  17)
+* gsl_vector_free:                       Vector allocation.   (line  25)
+* gsl_vector_fscanf:                     Reading and writing vectors.
+                                                              (line  34)
+* gsl_vector_fwrite:                     Reading and writing vectors.
+                                                              (line   9)
+* gsl_vector_get:                        Accessing vector elements.
+                                                              (line  27)
+* gsl_vector_isneg:                      Vector properties.   (line   8)
+* gsl_vector_isnull:                     Vector properties.   (line   6)
+* gsl_vector_ispos:                      Vector properties.   (line   7)
+* gsl_vector_max:                        Finding maximum and minimum elements of vectors.
+                                                              (line   6)
+* gsl_vector_max_index:                  Finding maximum and minimum elements of vectors.
+                                                              (line  17)
+* gsl_vector_memcpy:                     Copying vectors.     (line  12)
+* gsl_vector_min:                        Finding maximum and minimum elements of vectors.
+                                                              (line   9)
+* gsl_vector_minmax:                     Finding maximum and minimum elements of vectors.
+                                                              (line  12)
+* gsl_vector_minmax_index:               Finding maximum and minimum elements of vectors.
+                                                              (line  27)
+* gsl_vector_min_index:                  Finding maximum and minimum elements of vectors.
+                                                              (line  22)
+* gsl_vector_mul:                        Vector operations.   (line  18)
+* gsl_vector_ptr:                        Accessing vector elements.
+                                                              (line  37)
+* gsl_vector_reverse:                    Exchanging elements. (line  14)
+* gsl_vector_scale:                      Vector operations.   (line  28)
+* gsl_vector_set:                        Accessing vector elements.
+                                                              (line  32)
+* gsl_vector_set_all:                    Initializing vector elements.
+                                                              (line   6)
+* gsl_vector_set_basis:                  Initializing vector elements.
+                                                              (line  12)
+* gsl_vector_set_zero:                   Initializing vector elements.
+                                                              (line   9)
+* gsl_vector_sub:                        Vector operations.   (line  13)
+* gsl_vector_subvector:                  Vector views.        (line  27)
+* gsl_vector_subvector_with_stride:      Vector views.        (line  57)
+* gsl_vector_swap:                       Copying vectors.     (line  17)
+* gsl_vector_swap_elements:              Exchanging elements. (line   9)
+* gsl_vector_view_array:                 Vector views.        (line 117)
+* gsl_vector_view_array_with_stride:     Vector views.        (line 140)
+* gsl_wavelet2d_nstransform:             DWT in two dimension.
+                                                              (line  65)
+* gsl_wavelet2d_nstransform_forward:     DWT in two dimension.
+                                                              (line  68)
+* gsl_wavelet2d_nstransform_inverse:     DWT in two dimension.
+                                                              (line  71)
+* gsl_wavelet2d_nstransform_matrix:      DWT in two dimension.
+                                                              (line  77)
+* gsl_wavelet2d_nstransform_matrix_forward: DWT in two dimension.
+                                                              (line  80)
+* gsl_wavelet2d_nstransform_matrix_inverse: DWT in two dimension.
+                                                              (line  82)
+* gsl_wavelet2d_transform:               DWT in two dimension.
+                                                              (line  29)
+* gsl_wavelet2d_transform_forward:       DWT in two dimension.
+                                                              (line  32)
+* gsl_wavelet2d_transform_inverse:       DWT in two dimension.
+                                                              (line  35)
+* gsl_wavelet2d_transform_matrix:        DWT in two dimension.
+                                                              (line  55)
+* gsl_wavelet2d_transform_matrix_forward: DWT in two dimension.
+                                                              (line  58)
+* gsl_wavelet2d_transform_matrix_inverse: DWT in two dimension.
+                                                              (line  60)
+* gsl_wavelet_alloc:                     DWT Initialization.  (line   9)
+* gsl_wavelet_bspline:                   DWT Initialization.  (line  29)
+* gsl_wavelet_bspline_centered:          DWT Initialization.  (line  30)
+* gsl_wavelet_daubechies:                DWT Initialization.  (line  18)
+* gsl_wavelet_daubechies_centered:       DWT Initialization.  (line  19)
+* gsl_wavelet_free:                      DWT Initialization.  (line  44)
+* gsl_wavelet_haar:                      DWT Initialization.  (line  24)
+* gsl_wavelet_haar_centered:             DWT Initialization.  (line  25)
+* gsl_wavelet_name:                      DWT Initialization.  (line  40)
+* gsl_wavelet_transform:                 DWT in one dimension.
+                                                              (line   6)
+* gsl_wavelet_transform_forward:         DWT in one dimension.
+                                                              (line   9)
+* gsl_wavelet_transform_inverse:         DWT in one dimension.
+                                                              (line  12)
+* gsl_wavelet_workspace_alloc:           DWT Initialization.  (line  51)
+* gsl_wavelet_workspace_free:            DWT Initialization.  (line  60)
 
diff --git a/gsl-1.9/doc/gsl-ref.info-5 b/gsl-1.9/doc/gsl-ref.info-5
index 1b76f5e..e9cef63 100644
--- a/gsl-1.9/doc/gsl-ref.info-5
+++ b/gsl-1.9/doc/gsl-ref.info-5
diff --git a/gsl-1.9/doc/gsl-ref.info-6 b/gsl-1.9/doc/gsl-ref.info-6
deleted file mode 100644
index 243ca4d..0000000
--- a/gsl-1.9/doc/gsl-ref.info-6
+++ /dev/null
diff --git a/gsl-1.9/doc/multimin.texi b/gsl-1.9/doc/multimin.texi
index 4eb1ae8..c5737f0 100644
--- a/gsl-1.9/doc/multimin.texi
+++ b/gsl-1.9/doc/multimin.texi
@@ -134,7 +134,7 @@ suitable for most purposes, since line minimization only needs to
 be carried out approximately.    Note that setting @var{tol} to zero will
 force the use of ``exact'' line-searches, which are extremely expensive.
 
-@deftypefunx int gsl_multimin_fminimizer_set (gsl_multimin_fminimizer * @var{s}, gsl_multimin_function * @var{f}, const gsl_vector * @var{x}, const gsl_vector * @var{step_size})
+The function int gsl_multimin_fminimizer_set (gsl_multimin_fminimizer * @var{s}, gsl_multimin_function * @var{f}, const gsl_vector * @var{x}, const gsl_vector * @var{step_size})
 This function initializes the minimizer @var{s} to minimize the function
 @var{f}, starting from the initial point
 @var{x}. The size of the initial trial steps is given in vector
diff --git a/gsl-1.9/doc/qrng.texi b/gsl-1.9/doc/qrng.texi
index c9dc739..1e52d69 100644
--- a/gsl-1.9/doc/qrng.texi
+++ b/gsl-1.9/doc/qrng.texi
@@ -155,7 +155,7 @@ The implementations of the quasi-random sequence routines are based on
 the algorithms described in the following paper,
 
 @itemize @asis
-P. Bratley and B.L. Fox and H. Niederreiter, ``Algorithm 738: Programs
+@item P. Bratley and B.L. Fox and H. Niederreiter, ``Algorithm 738: Programs
 to Generate Niederreiter's Low-discrepancy Sequences'', @cite{ACM
 Transactions on Mathematical Software}, Vol.@: 20, No.@: 4, December, 1994,
 p.@: 494--495.
diff --git a/gsl-1.9/doc/rng.texi b/gsl-1.9/doc/rng.texi
index a947f31..53976a8 100644
--- a/gsl-1.9/doc/rng.texi
+++ b/gsl-1.9/doc/rng.texi
@@ -1382,8 +1382,7 @@ The subject of random number generation and testing is reviewed
 extensively in Knuth's @cite{Seminumerical Algorithms}.
 
 @itemize @asis
-@item
-Donald E. Knuth, @cite{The Art of Computer Programming: Seminumerical
+@item Donald E. Knuth, @cite{The Art of Computer Programming: Seminumerical
 Algorithms} (Vol 2, 3rd Ed, 1997), Addison-Wesley, ISBN 0201896842.
 @end itemize
 
@@ -1392,7 +1391,7 @@ Further information is available in the review paper written by Pierre
 L'Ecuyer,
 
 @itemize @asis
-P. L'Ecuyer, ``Random Number Generation'', Chapter 4 of the
+@item P. L'Ecuyer, ``Random Number Generation'', Chapter 4 of the
 Handbook on Simulation, Jerry Banks Ed., Wiley, 1998, 93--137.
 
 @uref{http://www.iro.umontreal.ca/~lecuyer/papers.html}