typos and index list for ch 1 and 2 and App

Author: sveinlin

doc/.src/book/.dict4spell.txt

@@ -24,6 +24,7 @@ Kutta
 Langtangen
 Linge
 MATLAB
+Mardal
 Mathilde
 Matlab
 Miri

doc/.src/book/preface.do.txt

@@ -265,6 +265,8 @@ URL: http://hplgit.github.io/fdm-book/doc/web/.
 
 === Acknowledgments ===
 
+Professor Kent-Andre Mardal at the University of Oslo has kindly 
+contributed to enlightening discussions on several issues. 
 Many students have
 provided lots of useful feedback on the exposition and found many
 errors in the text. Special efforts in this regard were made by Imran
@@ -275,12 +277,12 @@ The collaboration with the Springer team, with Dr.~Martin Peters,
 Thanh-Ha Le Thi, and their production staff has always been a
 great pleasure and a very efficient process.
 
-Finally, want really appreciate the strong push of the COE of Simula
+Finally, want really appreciate the strong push from the COE of Simula
 Research Laboratory, Aslak Tveito, for publishing and financing books
-in open access format, including this one. We are grateful to the
+in open access format, including this one. We are grateful for the
 laboratory's financial contribution as well as to the financial
 contribution from the Department of Process, Energy and Environmental
-Technology, University College of Southeast Norway.
+Technology at the University College of Southeast Norway.
 
 # #if FORMAT in ("latex", "pdflatex")
 \vspace{1cm}

doc/.src/chapters/formulas/formulas.do.txt

@@ -41,7 +41,7 @@ label{Dop:avg:theta}\\
 
 Some may wonder why $\theta$ is absent on the right-hand side
 of (ref{Dop:fd1:theta}). The fraction is an approximation to the
-derivative at the point $t_{n+\theta}=\theta t_{n+1} + (1-theta) t_{n}$.
+derivative at the point $t_{n+\theta}=\theta t_{n+1} + (1-\theta) t_{n}$.
 
 ======= Truncation errors of finite difference approximations =======
 label{sec:form:truncerr}
@@ -170,15 +170,15 @@ The next formulas concern the action of difference operators on a $t^2$ term.
 
 !bt
 \begin{align}
-\lbrack D_t^+ t^2\rbrack^n = (2n+1)\Delta t,
+\lbrack D_t^+ t^2\rbrack^n &= (2n+1)\Delta t,
 label{form:Dop:tn2:fw}\\
-\lbrack D_t^- t^2\rbrack^n = (2n-1)\Delta t,
+\lbrack D_t^- t^2\rbrack^n &= (2n-1)\Delta t,
 label{form:Dop:tn2:bw}\\
-\lbrack D_t t^2\rbrack^n = 2n\Delta t,
+\lbrack D_t t^2\rbrack^n &= 2n\Delta t,
 label{form:Dop:tn2:cn}\\
-\lbrack D_{2t} t^2\rbrack^n = 2n\Delta t,
+\lbrack D_{2t} t^2\rbrack^n &= 2n\Delta t,
 label{form:Dop:tn2:2cn}\\
-\lbrack D_{t}D_t t^2\rbrack^n = 2,
+\lbrack D_{t}D_t t^2\rbrack^n &= 2,
 label{form:Dop2:tn2:cn}
 \end{align}
 !et
@@ -202,13 +202,15 @@ label{form:Dop2:tn3:cn}
 
 ===== Software =====
 
+idx{`sympy`}
+
 Application of finite difference operators to polynomials and exponential
 functions, resulting in the formulas above, can easily be computed by
 some `sympy` code (from the file "`lib.py`": "${src_formulas}/lib.py"):
 
 @@@CODE src-formulas/lib.py fromto: from sympy import@import inspect
 To see the results, one can now make a simple loop over the different
-type of functions and the various operators associated with them:
+types of functions and the various operators associated with them:
 
 !bc pycod
 for func in func_list:

doc/.src/chapters/softeng2/softeng2.do.txt

@@ -34,6 +34,8 @@
 
 ===== Mathematical model =====
 
+idx{`wave1D_dn_vc.py`}
+
 Let $u_t$, $u_{tt}$, $u_x$, $u_{xx}$ denote derivatives of $u$ with
 respect to the subscript, i.e., $u_{tt}$ is a second-order time
 derivative and $u_x$ is a first-order space derivative.  The
@@ -119,6 +121,8 @@ label{softeng2:wave1D:filestorage:savez}
 
 === Storing individual arrays ===
 
+idx{`savez`} idx{`storez`} idx{`load`} idx{zip archive}
+
 The `numpy.storez` function can store a set of arrays to a named
 file in a zip archive. An associated function
 `numpy.load` can be used to read the file later.
@@ -179,6 +183,8 @@ for array_name in array_names:
 ===== Using `joblib` to store arrays in files =====
 label{softeng2:wave1D:filestorage:joblib}
 
+idx{`joblib`} idx{memoize function} idx{hash}
+
 The Python package `joblib` has nice functionality for efficient storage
 of arrays on disk. The following class applies this functionality so that
 one can save an array, or in fact any Python data structure (e.g., a
@@ -409,14 +415,16 @@ cite{Langtangen_deqbook_wave}]).
 
 === Convergence rates ===
 
+idx{verification! convergence rates}
+
 A more general method for verification is to check the convergence rates.
 We must introduce one discretization parameter $h$ and assume an error
 model $E=Ch^r$, where $C$ and $r$ are constants to be determine (i.e.,
 $r$ is the rate that we are interested in). Given two experiments with
 different resolutions $h_i$ and $h_i{-1}$, we can estimate $r$ by
 
 !bt
-\[ r = \frac{\ln(E_{i}/E_{i-1})}{\ln(h_{i}h_{i-1}},tp\]
+\[ r = \frac{\ln(E_{i}/E_{i-1})}{\ln(h_{i}/h_{i-1})},\]
 !et
 where $E_i$ is the error corresponding to $h_i$ and $E_{i-1}$ corresponds to
 $h_{i-1}$. ref[Section ref{wave:pde2:fd:standing:waves}][ in cite{Langtangen_deqbook_wave}][The
@@ -427,7 +435,7 @@ for some constant $\hat c$. To compute the error, we had to rely on
 a global variable in the user action function. Below is an implementation
 where we have a more elegant solution in terms of a class: the `error`
 variable is not a class attribute and there is no need for a global
-error (which is always considered as an advantage).
+error (which is always considered an advantage).
 
 @@@CODE src-wave/wave1D/wave1D_dn_vc.py def convergence_rates@def test_convrate_sincos
 The returned sequence `r` should converge to 2 since the error
@@ -445,6 +453,8 @@ cite{Langtangen_deqbook_wave}], see the file "`wave1D_dn_vc.py`":
 
 ======= Programming the solver with classes =======
 
+idx{`wave1D_oo.py`}
+
 Many who know about class programming prefer to organize their software
 in terms of classes. This gives a richer application programming interface
 (API) since a function solver must have all its input data in terms
@@ -506,7 +516,7 @@ documentation and a doc test should now be self-explanatory:
 @@@CODE src-softeng2/UniformFDMesh.py fromto: import numpy@class Function
 
 !bnotice We rely on attribute access - not get/set functions!
-Java programmers in particular are used to get/set functions in
+Java programmers, in particular, are used to get/set functions in
 classes to access internal data. In Python, we usually apply direct
 access of the attribute, such as `m.N[i]` if `m` is a `Mesh` object.
 A widely used convention is to do this as long as access to
@@ -557,7 +567,7 @@ is reproduced (within machine precision).
 ======= Migrating loops to Cython =======
 label{wave2D3D:impl:Cython}
 
-idx{Cython}
+idx{Cython} idx{`wave2D_u0.py`} idx{`wave2D_u0_adv.py`}
 
 We now consider the "`wave2D_u0.py`": "${src_wave}/wave2D_u0/wave2D_u0.py"
 code for solving the 2D linear wave equation with constant wave
@@ -594,6 +604,8 @@ in one or more separate files with extension `.pyx`.
 
 ===== Declaring variables and annotating the code =====
 
+idx{`wave2D_u0_loop_cy.pyx`}
+
 Our starting point is the plain `advance_scalar` function for a scalar
 implementation of the updating algorithm for new values
 $u^{n+1}_{i,j}$:
@@ -786,14 +798,16 @@ the Cython version.
 
 ======= Migrating loops to Fortran =======
 
+idx{Fortran 77}
+
 Instead of relying on Cython's (excellent) ability to translate Python to C,
 we can invoke a compiled language directly and write the loops ourselves.
 Let us start with Fortran 77, because this is a language with more
 convenient array handling than C (or plain C++), because
 we can use the same multi-dimensional indices
 in the Fortran code as in the `numpy`
 arrays in the Python code, while in C these arrays are
-one-dimensional and requires us to reduce multi-dimensional indices
+one-dimensional and require us to reduce multi-dimensional indices
 to a single index.
 
 #Fortran compilers
@@ -804,6 +818,7 @@ to a single index.
 
 idx{wrapper code}
 idx{Fortran subroutine}
+idx{`wave2D_u0_loop_f77.f`}
 
 We write a Fortran subroutine `advance` in a file
 "`wave2D_u0_loop_f77.f`": "${src_wave}/wave2D_u0/wave2D_u0_loop_f77.f"
@@ -840,6 +855,8 @@ advance(u, u_n, u_nm1, f, Cx2, Cy2, dt2)
 
 ===== Building the Fortran module with f2py =====
 
+idx{Fortran 90}
+
 The nice feature of writing loops in Fortran is that, without
 much effort, the tool `f2py`
 can produce a C extension module such that
@@ -1094,10 +1111,10 @@ easier to debug.
 !bwarning Be careful with macro definitions
 Macros just perform simple text substitutions:
 `idx(hello,world)` is expanded to `(hello)*(Ny+1) + world`.
-The parenthesis in `(i)` are essential - using the natural mathematical
+The parentheses in `(i)` are essential - using the natural mathematical
 formula `i*(Ny+1) + j` in the macro definition,
 `idx(i-1,j)` would expand to `i-1*(Ny+1) + j`, which is the wrong
-formula. Macros are handy, but requires careful use.
+formula. Macros are handy, but require careful use.
 In C++, inline functions are safer and replace the need for macros.
 !ewarning
 
@@ -1109,6 +1126,8 @@ The C version of our function `advance` can be coded as follows.
 
 ===== The Cython interface file =====
 
+idx{`wave2D_u0_loop_c.c`} idx{`wave2D_u0_loop_c.h`}
+
 All the code above appears in a file "`wave2D_u0_loop_c.c`":
 "${src_wave}//wave2D_u0/wave2D_u0_loop_c.c".
 We need to compile this file together with C wrapper code such that
@@ -1178,6 +1197,8 @@ words, that we work with small meshes.
 
 ======= Migrating loops to C via f2py =======
 
+idx{`wave2D_u0_loop_c_f2py_signature.f`}
+
 An alternative to using Cython for interfacing C code is to apply
 `f2py`. The C code is the same, just the details of specifying how
 it is to be called from Python differ. The `f2py` tool requires