remove inbounds macro

Author: jbytecode

src/atkinson94.jl

@@ -92,7 +92,7 @@ function atkinson94(
         studentized_residuals = zeros(Float64, n, n)
         copy_parameters = false
 
-        @inbounds for m = p:n
+        for m = p:n
             olsreg = ols(X[m_subset_indices, :], y[m_subset_indices])
             betas = coef(olsreg)
             e = (y .- X * betas)
@@ -103,7 +103,7 @@ function atkinson94(
             XXinv = pinv(X[m_subset_indices, :]'X[m_subset_indices, :])
 
             # scale the residual according to whether it belongs to m_subset_indices or not
-            @inbounds for index = 1:n
+            for index = 1:n
                 if index in m_subset_indices
                     h_i = X[index, :]' * XXinv * X[index, :]
                     studentized_residuals[m, index] =

src/bacon.jl

@@ -160,9 +160,9 @@ function compute_t_distance(X::Array{Float64,2}, y::Array{Float64}, subset::Arra
         scale_factor = (X[i, :]') * (covmatrix_inv * X[i, :])
         residual = (y[i] - X[i, :]' * betas)
         if i in subset
-            @inbounds t[i] = residual / (sigma * sqrt(1 - scale_factor))
+            t[i] = residual / (sigma * sqrt(1 - scale_factor))
         else
-            @inbounds t[i] = residual / (sigma * sqrt(1 + scale_factor))
+            t[i] = residual / (sigma * sqrt(1 + scale_factor))
         end
     end
     return abs.(t)
@@ -207,7 +207,7 @@ function bacon_regression_initial_subset(
         basic_subset = select_subset(X, r + 1, t)
         r = length(basic_subset)
         iter += 1
-        if iter > n 
+        if iter > n
             break
         end
     end
@@ -271,20 +271,17 @@ function bacon(
         r_prev = r
         r = length(subset)
         iter += 1
-        if iter > n 
+        if iter > n
             break
         end
     end
 
     outlierindices = setdiff(1:n, subset)
-    inlierindices = subset 
+    inlierindices = subset
     cleanols = ols(X[inlierindices, :], y[inlierindices])
     cleanbetas = coef(cleanols)
 
-    result = Dict(
-        "outliers" => outlierindices,
-        "betas" => cleanbetas
-    )
+    result = Dict("outliers" => outlierindices, "betas" => cleanbetas)
     return result
 end
 

src/cm97.jl

@@ -63,7 +63,7 @@ function cm97(X::Array{Float64,2}, y::Array{Float64,1}; maxiter::Int = 1000)::Di
     iter::Int = 0
 
     # initial weights
-    @inbounds for i = 1:n
+    for i = 1:n
         w_is[i] = 1.0 / max(hat[i, i], pbar)
     end
 
@@ -75,7 +75,7 @@ function cm97(X::Array{Float64,2}, y::Array{Float64,1}; maxiter::Int = 1000)::Di
         r = y - X * betas
         medi = median(abs.(r))
 
-        @inbounds for i = 1:n
+        for i = 1:n
             w_is[i] = (1.0 - hat[i, i])^2.0 / max(abs(r[i]), medi)
         end
 

src/dataimage.jl

@@ -5,7 +5,7 @@ export dataimage
 import ..Diagnostics:
     mahalanobisSquaredMatrix, euclideanDistances, mahalanobisSquaredBetweenPairs
 
-import ..RGB 
+import ..RGB
 
 """
 
@@ -62,7 +62,7 @@ function dataimage(
     colormatrix = Array{RGB{Float64},2}(undef, n, n)
     for i = 1:n
         for j = 1:n
-            @inbounds colormatrix[i, j] = RGB(colours[i, j])
+            colormatrix[i, j] = RGB(colours[i, j])
         end
     end
     return colormatrix

src/diagnostics.jl

@@ -1,19 +1,20 @@
 module Diagnostics
 
 
-export dffit, 
+export dffit,
     dffits,
     dfbeta,
     dfbetas,
     hatmatrix,
     studentizedResiduals,
     adjustedResiduals,
     jacknifedS,
-    cooks, cooksoutliers,
+    cooks,
+    cooksoutliers,
     mahalanobisSquaredMatrix,
     covratio,
     hadimeasure,
-    diagnose 
+    diagnose
 
 export coordinatwisemedians, mahalanobisBetweenPairs, euclideanDistances
 
@@ -47,8 +48,8 @@ function euclideanDistances(dataMatrix::Array{Float64,2})::Array{Float64,2}
     for i = 1:n
         for j = i:n
             if i != j
-                @inbounds d[i, j] = sqrt(sum((dataMatrix[i, :] .- dataMatrix[j, :]) .^ 2.0))
-                @inbounds d[j, i] = d[i, j]
+                d[i, j] = sqrt(sum((dataMatrix[i, :] .- dataMatrix[j, :]) .^ 2.0))
+                d[j, i] = d[i, j]
             end
         end
     end
@@ -66,7 +67,7 @@ function mahalanobisSquaredBetweenPairs(pairs::Matrix; covmatrix = nothing)
     try
         invm = inv(covmatrix)
         for i = 1:n
-            @inbounds for j = i:n
+            for j = i:n
                 newmat[i, j] =
                     ((pairs[i, :] .- pairs[j, :])' * invm * (pairs[i, :] .- pairs[j, :]))
                 newmat[j, i] = newmat[i, j]
@@ -113,12 +114,12 @@ function mahalanobisBetweenPairs(dataMatrix::Array{Float64,2})::Array{Float64,2}
     for i = 1:n
         for j = i:n
             if i != j
-                @inbounds d[i, j] = sqrt(
+                d[i, j] = sqrt(
                     (dataMatrix[i, :] .- dataMatrix[j, :]) *
                     covinv *
                     (dataMatrix[i, :] .- dataMatrix[j, :])',
                 )
-                @inbounds d[j, i] = d[i, j]
+                d[j, i] = d[i, j]
             end
         end
     end
@@ -497,7 +498,7 @@ function cooks(X::Array{Float64,2}, y::Array{Float64,1})::Array{Float64,1}
     s2 = sum(res .* res) / (n - p)
     d = zeros(Float64, n)
     for i = 1:n
-        @inbounds d[i] = ((res[i]^2.0) / (p * s2)) * (hat[i, i] / (1 - hat[i, i])^2.0)
+        d[i] = ((res[i]^2.0) / (p * s2)) * (hat[i, i] / (1 - hat[i, i])^2.0)
     end
     return d
 end
@@ -519,21 +520,17 @@ Calculates Cooks distance for a given regression setting and reports the potenti
 - `["cutoff"]`: Quantile of the F distribution.
 - `["potentials"]`: Vector of indices of potential regression outliers.
 """
-function cooksoutliers(setting::RegressionSetting; alpha::Float64 = 0.5)::Dict 
+function cooksoutliers(setting::RegressionSetting; alpha::Float64 = 0.5)::Dict
     X, y = @extractRegressionSetting setting
     return cooksoutliers(X, y, alpha = alpha)
 end
 
-function cooksoutliers(X::Array{Float64, 2}, y::Array{Float64, 1}; alpha::Float64 = 0.5)::Dict 
+function cooksoutliers(X::Array{Float64,2}, y::Array{Float64,1}; alpha::Float64 = 0.5)::Dict
     n, p = size(X)
     d = cooks(X, y)
     cutoff = cookscritical(n, p)
     potentials = filter(i -> d[i] >= cutoff, 1:n)
-    return Dict(
-        "distance" => d, 
-        "cutoff" => cutoff, 
-        "potentials" => potentials
-    )
+    return Dict("distance" => d, "cutoff" => cutoff, "potentials" => potentials)
 end
 
 
@@ -597,14 +594,11 @@ See also: [`dfbeta`](@ref)
 """
 function dfbetas(setting)
     y = responseVector(setting)
-    results =  map(i -> dfbeta(setting, i), 1:length(y))
+    results = map(i -> dfbeta(setting, i), 1:length(y))
     return mapreduce(permutedims, vcat, results)
 end
 
-function dfbetas(
-    X::Array{Float64,2},
-    y::Array{Float64,1}
-)
+function dfbetas(X::Array{Float64,2}, y::Array{Float64,1})
     results = map(i -> dfbeta(X, y, i), 1:length(y))
     return mapreduce(permutedims, vcat, results)
 end
@@ -724,7 +718,7 @@ function hadimeasure(X::Array{Float64,2}, y::Array{Float64,1}; c::Float64 = 2.0)
     hat = hatmatrix(X)
     H = zeros(Float64, n)
     for i = 1:n
-        @inbounds H[i] =
+        H[i] =
             (p * res2[i]) / ((1 - hat[i, i]) * (sumres - res2[i])) +
             (hat[i, i] / (1 - hat[i, i]))
     end
@@ -736,23 +730,23 @@ end
 
 function dffitcritical(n::Int, p::Int)::Float64
     return 2.0 * sqrt((p + 1) / (n - p - 1))
-end 
+end
 
 function dfbetacritical(n::Int)::Float64
     return 2.0 / sqrt(n)
-end 
+end
 
-function covratiocritical(n::Int, p::Int)::Tuple{Float64, Float64}
+function covratiocritical(n::Int, p::Int)::Tuple{Float64,Float64}
     c = 3.0 * p / n
     return (1.0 - c, 1.0 + c)
-end 
+end
 
-function hatcritical(n::Int, p::Int)::Float64 
+function hatcritical(n::Int, p::Int)::Float64
     return 2.0 * sqrt(p / n)
-end 
+end
 
-function cookscritical(n::Int, p::Int; alpha = 0.5)::Float64 
-    return quantile(FDist(p, n-p), alpha)
+function cookscritical(n::Int, p::Int; alpha = 0.5)::Float64
+    return quantile(FDist(p, n - p), alpha)
 end
 
 
@@ -772,32 +766,32 @@ Diagnose a regression setting and report potential outliers using [`dffits`](@re
 function diagnose(setting::RegressionSetting; alpha = 0.5)
     X, y = @extractRegressionSetting setting
     return diagnose(X, y, alpha = 0.5)
-end 
+end
 
 
-function diagnose(X::Array{Float64, 2}, y::Array{Float64, 1}; alpha = 0.5)
+function diagnose(X::Array{Float64,2}, y::Array{Float64,1}; alpha = 0.5)
     n, p = size(X)
-    resultdffits   = dffits(X, y)
-    resultdfbetas  = dfbetas(X, y)
-    resultcook     = cooks(X, y)
-    hatresult      = hatmatrix(X)
+    resultdffits = dffits(X, y)
+    resultdfbetas = dfbetas(X, y)
+    resultcook = cooks(X, y)
+    hatresult = hatmatrix(X)
 
-    dffitcrit      = dffitcritical(n, p)
-    dfbetacrit     = dfbetacritical(n)
-    hatcrit        = hatcritical(n, p)
-    cookscrit      = cookscritical(n, p, alpha = alpha)
+    dffitcrit = dffitcritical(n, p)
+    dfbetacrit = dfbetacritical(n)
+    hatcrit = hatcritical(n, p)
+    cookscrit = cookscritical(n, p, alpha = alpha)
 
-    dffitpotential   = filter(i -> abs(resultdffits[i]) >= dffitcrit, 1:n)
+    dffitpotential = filter(i -> abs(resultdffits[i]) >= dffitcrit, 1:n)
     dfbetaspotential = filter(i -> any(x -> (abs(x) > dfbetacrit), resultdfbetas), 1:n)
-    hatpotential     = filter(i -> abs(hatresult[i]) > hatcrit, 1:n)
-    cookpotential    = filter(i -> abs(resultcook[i]) > cookscrit, 1:n)
+    hatpotential = filter(i -> abs(hatresult[i]) > hatcrit, 1:n)
+    cookpotential = filter(i -> abs(resultcook[i]) > cookscrit, 1:n)
 
     return Dict(
         "dffit_potentials" => dffitpotential,
         "dfbeta_potentials" => dfbetaspotential,
         "hat_potentials" => hatpotential,
-        "cooks_potentials" => cookpotential
+        "cooks_potentials" => cookpotential,
     )
-end 
+end
 
 end # end of module Diagnostics 

src/ga.jl

@@ -51,7 +51,7 @@ end
 
 function Mutate(c::RealChromosome, prob::Float64)::RealChromosome
     genes = copy(c.genes)
-    @inbounds for i in eachindex(genes)
+    for i in eachindex(genes)
         if rand() < prob
             genes[i] += randn()
         end
@@ -64,8 +64,8 @@ function TournamentSelection(
 )::Tuple{RealChromosome,RealChromosome}
     n = length(pop)
     indices = sample(1:n, 4, replace = false)
-    lucky1 :: Chromosome = RealChromosome()
-    lucky2 :: Chromosome = RealChromosome()
+    lucky1::Chromosome = RealChromosome()
+    lucky2::Chromosome = RealChromosome()
     if pop[indices[1]].cost < pop[indices[2]].cost
         lucky1 = pop[indices[1]]
     else
@@ -87,15 +87,15 @@ function createPopulation(
     maxs::Array{Float64,1},
 )::Array{RealChromosome,1}
     pop = Array{RealChromosome,1}(undef, popsize)
-    @inbounds for i = 1:popsize
+    for i = 1:popsize
         c = RealChromosome(mins .+ rand(chsize) .* (maxs - mins), Inf64)
         pop[i] = c
     end
     return pop
 end
 
 function Evaluate(pop::Array{RealChromosome,1}, fcost::Function)::Array{RealChromosome,1}
-    @inbounds for i in eachindex(pop)
+    for i in eachindex(pop)
         pop[i].cost = fcost(pop[i].genes)
     end
     return pop
@@ -109,18 +109,18 @@ function Generation(
     pmutate::Float64,
 )::Array{RealChromosome,1}
     popsize = length(pop)
-    newpop = Array{Chromosome, 1}(undef, popsize)
+    newpop = Array{Chromosome,1}(undef, popsize)
     pop = sort(Evaluate(pop, fcost))
-    csize :: Int = 0
-    @inbounds for i = 1:elitism
+    csize::Int = 0
+    for i = 1:elitism
         csize += 1
         newpop[csize] = pop[i]
     end
 
     winner1 = RealChromosome()
     winner2 = RealChromosome()
 
-    @inbounds while csize < popsize
+    while csize < popsize
         parent1, parent2 = TournamentSelection(pop)
         if rand() < pcross
             offspring1, offspring2, offspring3 = LinearCrossover(parent1, parent2)
@@ -133,11 +133,11 @@ function Generation(
         end
         if (csize + 1 <= popsize)
             csize += 1
-            newpop[csize] =  winner1
+            newpop[csize] = winner1
         end
         if (csize + 1 <= popsize)
             csize += 1
-            newpop[csize] =  winner2
+            newpop[csize] = winner2
         end
     end
     return sort(newpop)

src/hadi1992.jl

@@ -36,7 +36,7 @@ function hadi1992_handle_singularity(S::Array{Float64,2})::Array{Float64,2}
     lambda_s = find_minimum_nonzero(values)
     W = zeros(Float64, p, p)
     for i = 1:p
-        @inbounds W[i, i] = 1 / max(values[i], lambda_s)
+        W[i, i] = 1 / max(values[i], lambda_s)
     end
     newS = vectors * W * vectors
     return newS