format code, fix typos/thinkos

Author: jlapeyre

docs/src/index.md

@@ -1,11 +1,11 @@
 # InverseLaplace
 
-*Numerical inverse Laplace transform.*
+*Numerical inverse Laplace transform*
 
 The source repository is [https://github.com/jlapeyre/InverseLaplace.jl](https://github.com/jlapeyre/InverseLaplace.jl).
 
-This package provides three numerical algorithms for numerically inverting Laplace transforms.
-InverseLaplace v0.1.0 is the last version that supports Julia v0.6.
+This package provides three algorithms for numerically inverting Laplace transforms.
+`InverseLaplace` v0.1.0 is the last version that supports Julia v0.6.
 Optimization of the Weeks method is temporarily disabled for Julia v0.7.
 
 ## Contents
@@ -18,29 +18,30 @@ Optimization of the Weeks method is temporarily disabled for Julia v0.7.
 ```@index
 ```
 
-## Inverse Laplace transform methods
+## Inverse Laplace transform algorithms
 
-Constructing these Julia types, corresponding to different numerical methods,
-returns a callable object that evaluates the inverse transform at specified points.
+Constructing these Julia types, corresponding to different numerical algorithms,
+returns a callable object that evaluates the inverse Laplace transform at specified points.
 
 ```@docs
-ILT
 Talbot
+ILT
 GWR
 Weeks
 WeeksErr
 ```
 
 ## Setting parameters
 
-The inverse Laplace tranform routines should not be treated as black boxes. They are prone to instability and can give inaccurate or
-wrong results. There are some parameters you can set to try to minimize these problems.
+The inverse Laplace tranform routines should not be treated as black boxes. They are
+prone to instability and can give inaccurate or wrong results. There are some
+parameters you can set to try to minimize these problems.
 
 ```@docs
-setNterms
-optimize
-opteval
-setparameters
+InverseLaplace.setNterms
+InverseLaplace.optimize
+InverseLaplace.opteval
+InverseLaplace.setparameters
 ```
 
 ## Analzying accuracy
@@ -63,13 +64,11 @@ gwr
 InverseLaplace.talbotarr
 ```
 
-
 ## References
 
 J.A.C Weideman, *Algorithms for Parameter Selection in the Weeks Method for Inverting the Laplace Transform,
 SIAM Journal on Scientific Computing*, Vol. 21, pp. 111-128 **(1999)**
 
-
 Abate, J. and Valkó, P.P., *Multi-precision Laplace transform inversion
 International Journal for Numerical Methods in Engineering*, Vol. 60 (Iss. 5-7) pp 979–993 **(2004)**
 

src/InverseLaplace.jl

@@ -17,23 +17,23 @@ abstract type AbstractILt end
 """
    ft::Talbot = Talbot(func::Function, Nterms::Integer=32)
 
-return `ft`, which estimates the inverse Laplace transform of `func` with
+Return `ft`, which estimates the inverse Laplace transform of `func` with
 the fixed Talbot algorithm. `ft(t)` evaluates the transform at `t`.  You may
 want to tune `Nterms` together with `setprecision(BigFloat, x)`.
 
 # Example
 
 Compute the inverse transform of the transform of `cos` at argument `pi/2`.
 ```julia-repl
-julia> ft = Talbot(s -> s/(s^2 + 1), 80);
+julia> ft = Talbot(s -> s / (s^2 + 1), 80);
 
-julia> ft(pi/2)
+julia> ft(pi / 2)
 -3.5366510684573195e-5
 ```
 
 Note that given `Float64` input, the precision of the returned value may not be satisfactory.
 ```julia-repl
-julia> Float64(ft(big(pi)/2))
+julia> Float64(ft(big(pi) / 2))
 2.114425886215604e-49
 ```
 
@@ -53,16 +53,16 @@ Talbot(Laplace_space_func::Base.Callable) = Talbot(Laplace_space_func, talbot_de
 """
    ft::GWR = GWR(func::Function, Nterms::Integer=16)
 
-return `ft`, which estimates the inverse Laplace transform of `func` with
+Return `ft`, which estimates the inverse Laplace transform of `func` with
 the GWR algorithm. `ft(t)` evaluates the transform at `t`.
 
 # Example
 
-Compute the inverse transform of the transform of `cos` at argument `pi/2`.
+Compute the inverse transform of the transform of `cos` at argument `pi / 2`.
 ```
-julia> ft = GWR(s -> s/(s^2 + 1), 16);
+julia> ft = GWR(s -> s / (s^2 + 1), 16);
 
-julia> ft(pi/2)
+julia> ft(pi / 2)
 -0.001
 ```
 """
@@ -85,7 +85,7 @@ function Base.show(io::IO, ailt::AbstractILt)
     print(io, string(typeof(ailt)), "(Nterms=", ailt.Nterms, ')')
 end
 
-# TODO get rid of this in favor of above.
+# TODO: get rid of this in favor of above.
 # Rely on broadcasting, as well.
 struct ILt{T<:Base.Callable, V<:Base.Callable} <: AbstractILt
     Laplace_space_func::T
@@ -98,7 +98,7 @@ end
 
  * deprecated. Use, ILT, Talbot, GWR, or Weeks instead *
 
-return an object that estimates the inverse Laplace transform of
+Return an object that estimates the inverse Laplace transform of
 the function `func` using the algorithm implemented by function `iltfunc`.
 `itrans(t)` estimates the inverse transform for argument `t`.  The
 accuracy of the estimates depends strongly on the choice of `iltfunc`, `t`, `Nterms`,

src/fixed_talbot.jl

@@ -10,12 +10,12 @@
 Evaluate the inverse Laplace transform of `func` at the point `t`. Use `M` terms in the algorithm.
 For `typeof(t)` is `Float64`, the default for `M` is `32`. For `BigFloat` the default is `64`.
 
-If `BigFloat` precision is larger than default, try increasing `M`. `talbot is vectorized over `t`.
+If `BigFloat` precision is larger than default, try increasing `M`.
 
 # Example
 
 ```jldoctest
-julia> InverseLaplace.talbot( s -> 1/s^3, 3)
+julia> InverseLaplace.talbot(s -> 1 / s^3, 3)
 4.50000000000153
 ```
 
@@ -50,10 +50,10 @@ talbot(func, t::Rational, args...) = talbot(func, BigFloat(t), args...)
 """
     talbotarr(func, ta::AbstractArray, M)
 
-inverse Laplace transform vectorized over `ta`. Each evaluation
-of `func(s)` is used for all elements of `ta`. This may be faster
-than a vectorized application of `talbot`, but is in general, less accurate.
-`talbotarr` uses the "fixed" Talbot method.
+Compute the inverse Laplace transform for each element in `ta`. Each evaluation
+of `func(s)` is used for all elements of `ta`. This may be faster than a
+broadcast application of `talbot` (i.e. `talbot.(...`) , but is in general, less
+accurate.  `talbotarr` uses the "fixed" Talbot method.
 """
 function talbotarr(func, t::AbstractArray, M)
     tt = typeof(t[1])
@@ -75,10 +75,12 @@ function talbotarr(func, t::AbstractArray, M)
         end
     end
     for j in 1:length(terms)
-        terms[j] *= 2/(5 * tmax)
+        terms[j] *= 2 / (5 * tmax)
     end
     return terms
 end
 
 talbotarr(func, t::AbstractArray) = talbotarr(func, t, talbot_default_num_terms)
 talbotarr(func, t::Vector{BigFloat}) = talbotarr(func, t, talbot_BigFloat_default_num_terms)
+
+#  LocalWords:  talbotarr func talbot

src/gwr.jl

@@ -33,7 +33,7 @@ julia> InverseLaplace.gwr( s -> 1/s^3, 3.0)
 function gwr(func, t, M)
     Dt = typeof(t)
     bM = convert(Dt, M)
-    tau = log(convert(Dt, 2))/t
+    tau = log(convert(Dt, 2)) / t
     broken = false
     Fi = Array{Dt}(undef, 2 * M)
 @inbounds  for i in 1: 2 * M
@@ -55,13 +55,13 @@ function gwr(func, t, M)
     Gp = zeros(Dt, M1 + 1)
     best = G0[M1]
     for k in 0:M1-2
-        for n in (M1-2-k):-1:0
+        for n in (M1 - 2 - k):-1:0
             expr = G0[n + 2] - G0[n + 1]
             if expr == 0
                 broken = true
                 break
             end
-            expr = Gm[n + 2] + (k + 1)/expr
+            expr = Gm[n + 2] + (k + 1) / expr
             Gp[n + 1] = expr
             if isodd(k) && n == M1 - 2 - k
                 best = expr

src/weeks.jl

@@ -75,7 +75,7 @@ end
 """
     optimize(w::AbstractWeeks, t, Nterms)
 
-optimize the parameters of the inverse Laplace transform `w` at the
+Optimize the parameters of the inverse Laplace transform `w` at the
 argument `t`. If `Nterms` is ommitted, the current value of `w.Nterms`
 is retained.
 
@@ -87,36 +87,36 @@ the inverse transform that are extremely inaccurate.
 `optimize` is expensive in CPU time and allocation, it performs nested single-parameter
 optimization over two parameterss.
 """
-function optimize(w::AbstractWeeks, t, N)
-    w.Nterms = N
-    return optimize(w,t)
+function optimize(w::AbstractWeeks, t, Nterms)
+    w.Nterms = Nterms
+    return optimize(w, t)
 end
 
 """
-    opteval{T<:AbstractWeeks}(w::T, t, Nterms)
+    opteval(w::AbstractWeeks, t, Nterms)
 
 estimate an inverse Laplace transform at argument `t` using `w` after
 optimizing the parameters for `t`. If `Nterms` is omitted, then the
 current value of `w.Nterms` is used.
 
 Use `Weeks` or `WeeksErr` to create `w`.
 """
-function opteval(w::AbstractWeeks, t, N)
-    optimize(w,t, N)
+function opteval(w::AbstractWeeks, t, Nterms)
+    optimize(w, t, Nterms)
     return w(t)
 end
 
-opteval(w::AbstractWeeks, t) = opteval(w,t,w.Nterms)
+opteval(w::AbstractWeeks, t) = opteval(w, t, w.Nterms)
 
 """
-    setparameters{T<:AbstractWeeks}(w::T, sigma, b, Nterms)
+    setparameters(w::AbstractWeeks, sigma, b, Nterms)
 
 Set the parameters for the inverse Laplace transform object `w` and recompute
 the internal data. Subsequent calls `w(t)` will use these parameters. If `Nterms`
 or both `Nterms` and `b` are omitted, then their current values are retained.
 """
 function setparameters(w::AbstractWeeks, sigma, b, Nterms)
-    (w.sigma, w.b, w.Nterms) = (sigma,b,Nterms)
+    (w.sigma, w.b, w.Nterms) = (sigma, b, Nterms)
     _set_coefficients(w)
    return w
 end