Merge pull request #841 from LilithHafner/trailing-whitespace

remove trailing whitespace

Author: mschauer

docs/src/signalcorr.md

@@ -1,6 +1,6 @@
 # Correlation Analysis of Signals
 
-The package provides functions to perform correlation analysis of sequential signals. 
+The package provides functions to perform correlation analysis of sequential signals.
 
 ## Autocovariance and Autocorrelation
 
@@ -18,7 +18,7 @@ crosscov
 crosscov!
 crosscor
 crosscor!
-```  
+```
 
 ## Partial Autocorrelation Function
 

src/rankcorr.jl

@@ -143,8 +143,8 @@ function corkendall!(x::RealVector, y::RealVector, permx::AbstractVector{<:Integ
         if x[i - 1] == x[i]
             k += 1
         elseif k > 0
-            # Sort the corresponding chunk of y, so the rows of hcat(x,y) are 
-            # sorted first on x, then (where x values are tied) on y. Hence 
+            # Sort the corresponding chunk of y, so the rows of hcat(x,y) are
+            # sorted first on x, then (where x values are tied) on y. Hence
             # double ties can be counted by calling countties.
             sort!(view(y, (i - k - 1):(i - 1)))
             ntiesx += div(widen(k) * (k + 1), 2) # Must use wide integers here
@@ -217,7 +217,7 @@ end
 """
     countties(x::RealVector, lo::Integer, hi::Integer)
 
-Return the number of ties within `x[lo:hi]`. Assumes `x` is sorted. 
+Return the number of ties within `x[lo:hi]`. Assumes `x` is sorted.
 """
 function countties(x::AbstractVector, lo::Integer, hi::Integer)
     # Use of widen below prevents possible overflow errors when
@@ -246,9 +246,9 @@ const SMALL_THRESHOLD = 64
 # merge_sort! copied from Julia Base
 # (commit 28330a2fef4d9d149ba0fd3ffa06347b50067647, dated 20 Sep 2020)
 """
-    merge_sort!(v::AbstractVector, lo::Integer, hi::Integer, t::AbstractVector=similar(v, 0))    
+    merge_sort!(v::AbstractVector, lo::Integer, hi::Integer, t::AbstractVector=similar(v, 0))
 
-Mutates `v` by sorting elements `x[lo:hi]` using the merge sort algorithm. 
+Mutates `v` by sorting elements `x[lo:hi]` using the merge sort algorithm.
 This method is a copy-paste-edit of sort! in base/sort.jl, amended to return the bubblesort distance.
 """
 function merge_sort!(v::AbstractVector, lo::Integer, hi::Integer, t::AbstractVector=similar(v, 0))
@@ -300,7 +300,7 @@ midpoint(lo::Integer, hi::Integer) = midpoint(promote(lo, hi)...)
 """
     insertion_sort!(v::AbstractVector, lo::Integer, hi::Integer)
 
-Mutates `v` by sorting elements `x[lo:hi]` using the insertion sort algorithm. 
+Mutates `v` by sorting elements `x[lo:hi]` using the insertion sort algorithm.
 This method is a copy-paste-edit of sort! in base/sort.jl, amended to return the bubblesort distance.
 """
 function insertion_sort!(v::AbstractVector, lo::Integer, hi::Integer)

src/robust.jl

@@ -73,10 +73,10 @@ end
 Return an iterator of all elements of `x` that replaces either `count` or
 proportion `prop` of the highest elements with the previous-highest element
 and an equal number of the lowest elements with the next-lowest element.
-                        
+
 The number of replaced elements could be smaller than specified if several
 elements equal the lower or upper bound.
-                        
+
 To compute the Winsorized mean of `x` use `mean(winsor(x))`.
 
 # Example

src/scalarstats.jl

@@ -232,24 +232,24 @@ nquantile(x, n::Integer) = quantile(x, (0:n)/n)
 Compute the quantile position in the [0, 1] interval of `value` relative to collection `itr`.
 
 Different definitions can be chosen via the `method` keyword argument.
-Let `count_less` be the number of elements of `itr` that are less than `value`, 
-`count_equal` the number of elements of `itr` that are equal to `value`, `n` the length of `itr`, 
-`greatest_smaller` the highest value below `value` and `smallest_greater` the lowest value above `value`. 
+Let `count_less` be the number of elements of `itr` that are less than `value`,
+`count_equal` the number of elements of `itr` that are equal to `value`, `n` the length of `itr`,
+`greatest_smaller` the highest value below `value` and `smallest_greater` the lowest value above `value`.
 Then `method` supports the following definitions:
 
-- `:inc` (default): Return a value in the range 0 to 1 inclusive. 
-Return `count_less / (n - 1)` if `value ∈ itr`, otherwise apply interpolation based on 
+- `:inc` (default): Return a value in the range 0 to 1 inclusive.
+Return `count_less / (n - 1)` if `value ∈ itr`, otherwise apply interpolation based on
 definition 7 of quantile in Hyndman and Fan (1996)
 (equivalent to Excel `PERCENTRANK` and `PERCENTRANK.INC`).
 This definition corresponds to the lower semi-continuous inverse of
 [`quantile`](@ref) with its default parameters.
 
 - `:exc`: Return a value in the range 0 to 1 exclusive.
-Return `(count_less + 1) / (n + 1)` if `value ∈ itr` otherwise apply interpolation 
+Return `(count_less + 1) / (n + 1)` if `value ∈ itr` otherwise apply interpolation
 based on definition 6 of quantile in Hyndman and Fan (1996)
 (equivalent to Excel `PERCENTRANK.EXC`).
 
-- `:compete`: Return `count_less / (n - 1)` if `value ∈ itr`, otherwise 
+- `:compete`: Return `count_less / (n - 1)` if `value ∈ itr`, otherwise
 return `(count_less - 1) / (n - 1)`, without interpolation
 (equivalent to MariaDB `PERCENT_RANK`, dplyr `percent_rank`).
 
@@ -361,12 +361,12 @@ function quantilerank(itr, value; method::Symbol=:inc)
     elseif method == :compete
         if value > maximum(itr)
             return 1.0
-        elseif value ≤ minimum(itr) 
+        elseif value ≤ minimum(itr)
             return 0.0
         else
             value ∈ itr && (count_less += 1)
             return (count_less - 1) / (n - 1)
-        end 
+        end
     elseif method == :tied
         return (count_less + count_equal/2) / n
     elseif method == :strict
@@ -428,7 +428,7 @@ Return the standard error of the mean for a collection `x`.
 A pre-computed `mean` may be provided.
 
 When not using weights, this is the (sample) standard deviation
-divided by the sample size. If weights are used, the 
+divided by the sample size. If weights are used, the
 variance of the sample mean is calculated as follows:
 
 * `AnalyticWeights`: Not implemented.
@@ -480,7 +480,7 @@ function sem(x; mean=nothing)
     return sqrt(variance / n)
 end
 
-function sem(x::AbstractArray; mean=nothing) 
+function sem(x::AbstractArray; mean=nothing)
     if isempty(x)
         # Return the NaN of the type that we would get for a nonempty x
         T = eltype(x)

test/rankcorr.jl

@@ -35,7 +35,7 @@ c22 = corspearman(x2, x2)
 @test isnan(corkendall([1,1,1], [1,2,3]))
 @test corkendall([-Inf,-0.0,Inf],[1,2,3]) == 1.0
 
-# Test, with exact equality, some known results. 
+# Test, with exact equality, some known results.
 # RealVector, RealVector
 @test corkendall(x1, y) == -1/sqrt(90)
 @test corkendall(x2, y) == -1/sqrt(72)

test/scalarstats.jl

@@ -108,7 +108,7 @@ z2 = [8. 2. 3. 1.; 24. 10. -1. -1.; 20. 12. 1. -2.]
              @test quantilerank(v1, 2, method=:inc)    == 1/3
              @test quantilerank(v1, 4, method=:inc)    == 5/9
              @test quantilerank(v1, 8, method=:inc)    == 2/3
-             @test quantilerank(v1, 5, method=:inc)    == 7/12        
+             @test quantilerank(v1, 5, method=:inc)    == 7/12
              @test quantilerank(v2, 7, method=:exc)    == 0.7
              @test quantilerank(v2, 5.43, method=:exc) == 0.381
              @test quantilerank(v3, 4, method=:exc)    == 6/9
@@ -155,7 +155,7 @@ z2 = [8. 2. 3. 1.; 24. 10. -1. -1.; 20. 12. 1. -2.]
          @test_throws ArgumentError quantilerank([1], 3)
      end
  end
- 
+
 ##### Dispersion
 
 @test span([3, 4, 5, 6, 2]) == (2:6)