Merge pull request #259 from control-toolbox/auto-juliaformatter-pr

[AUTO] JuliaFormatter.jl run

bench/Bench.jl

@@ -2,7 +2,6 @@ using MLStyle
 using MacroTools
 
 function doBenchMarking(expr, f)
-
     expr = MacroTools.striplines(expr)
     println("Benchmarking $expr")
     write(f, string(expr) * "\n")
@@ -12,11 +11,9 @@ function doBenchMarking(expr, f)
         $expr
     end))
     write(f, "\n```\n\n")
-
 end
 
 function bench(file::String)
-
     file_name = split(file, ".")[1]
     println("Benching $file_name.jl\n")
 
@@ -39,7 +36,6 @@ function bench(file::String)
         #dump(expr)
 
         open(file_name_output, write = true, append = true) do f
-
             if has_displayed
                 write(f, "```julia\n")
                 has_displayed = false
@@ -48,13 +44,11 @@ function bench(file::String)
             if hasproperty(expr, :head) &&
                expr.head == :macrocall &&
                expr.args[1] == Symbol("@benchmark")
-
                 has_displayed = true
                 doBenchMarking(expr, f)
                 expr = :()
 
             else
-
                 MLStyle.@match expr begin
                     :(display($benchname)) => begin
                         has_displayed = true
@@ -67,15 +61,11 @@ function bench(file::String)
                         write(f, string(expr) * "\n")
                     end
                 end
-
             end
-
         end
 
         return expr
-
     end
 
     include(mapexpr, file)
-
 end

bench/bench_nlp_constraints.jl

@@ -157,11 +157,9 @@ function nlp_constraints_original(ocp::OptimalControlModel)
     (ul, uind, uu),
     (xl, xind, xu),
     (vl, vind, vu)
-
 end
 
 function test_alloc_bad(ocp, N)
-
     println("    getters and setters")
     begin
         function get_state(XU, i, n, m)
@@ -173,15 +171,15 @@ function test_alloc_bad(ocp, N)
         end
 
         function set_control_constraint!(C, i, ξ, nξ, nc)
-            C[(i-1)*nc+1:(i-1)*nc+nξ] = ξ
+            C[((i - 1) * nc + 1):((i - 1) * nc + nξ)] = ξ
         end
 
         function set_state_constraint!(C, i, η, nη, nξ, nc)
-            C[(i-1)*nc+nξ+1:(i-1)*nc+nξ+nη] = η
+            C[((i - 1) * nc + nξ + 1):((i - 1) * nc + nξ + nη)] = η
         end
 
         function set_mixed_constraint!(C, i, ψ, nψ, nξ, nη, nc)
-            C[(i-1)*nc+nξ+nη+1:(i-1)*nc+nξ+nη+nψ] = ψ
+            C[((i - 1) * nc + nξ + nη + 1):((i - 1) * nc + nξ + nη + nψ)] = ψ
         end
     end
 
@@ -226,7 +224,6 @@ function test_alloc_bad(ocp, N)
     println("   end for loop")
 
     nothing
-
 end
 
 # --------------------------------------------------------------------
@@ -408,41 +405,38 @@ function nlp_constraints_optimized(ocp::OptimalControlModel)
     (uind, ul, uu),
     (xind, xl, xu),
     (vind, vl, vu)
-
 end
 
 function test_alloc_good(ocp, N)
-
     begin
-
         println("    getters and setters")
         begin
             function get_state(XU, i, n, m)
                 if n == 1
-                    return XU[(i-1)*(n+m)+1]
+                    return XU[(i - 1) * (n + m) + 1]
                 else
-                    return @view XU[(i-1)*(n+m)+1:(i-1)*(n+m)+n]
+                    return @view XU[((i - 1) * (n + m) + 1):((i - 1) * (n + m) + n)]
                 end
             end
 
             function get_control(XU, i, n, m)
                 if m == 1
-                    return XU[(i-1)*(n+m)+n+1]
+                    return XU[(i - 1) * (n + m) + n + 1]
                 else
-                    return @view XU[(i-1)*(n+m)+n+1:(i-1)*(n+m)+n+m]
+                    return @view XU[((i - 1) * (n + m) + n + 1):((i - 1) * (n + m) + n + m)]
                 end
             end
 
             function set_control_constraint!(C, i, valξ, nξ, nc)
-                C[(i-1)*nc+1:(i-1)*nc+nξ] = valξ
+                C[((i - 1) * nc + 1):((i - 1) * nc + nξ)] = valξ
             end
 
             function set_state_constraint!(C, i, valη, nη, nξ, nc)
-                C[(i-1)*nc+nξ+1:(i-1)*nc+nξ+nη] = valη
+                C[((i - 1) * nc + nξ + 1):((i - 1) * nc + nξ + nη)] = valη
             end
 
             function set_mixed_constraint!(C, i, valψ, nψ, nξ, nη, nc)
-                C[(i-1)*nc+nξ+nη+1:(i-1)*nc+nξ+nη+nψ] = valψ
+                C[((i - 1) * nc + nξ + nη + 1):((i - 1) * nc + nξ + nη + nψ)] = valψ
             end
         end
 
@@ -510,24 +504,23 @@ function test_alloc_good(ocp, N)
                 nothing
                 =#
             t = times[i]
-            x[:] = XU[(i-1)*(n+m)+1:(i-1)*(n+m)+n]
-            u[:] = @view XU[(i-1)*(n+m)+n+1:(i-1)*(n+m)+n+m]
+            x[:] = XU[((i - 1) * (n + m) + 1):((i - 1) * (n + m) + n)]
+            u[:] = @view XU[((i - 1) * (n + m) + n + 1):((i - 1) * (n + m) + n + m)]
             ξ!(valξ, t, u, v)
             η!(valη, t, x, v)
             ψ!(valψ, t, x, u, v)
             #set_control_constraint!(C, i, valξ, nξ, nc)
-            C[(i-1)*nc+1:(i-1)*nc+nξ] = valξ
+            C[((i - 1) * nc + 1):((i - 1) * nc + nξ)] = valξ
             #set_state_constraint!(C, i, valη, nη, nξ, nc)
-            C[(i-1)*nc+nξ+1:(i-1)*nc+nξ+nη] = valη
+            C[((i - 1) * nc + nξ + 1):((i - 1) * nc + nξ + nη)] = valη
             #set_mixed_constraint!(C, i, valψ, nψ, nξ, nη, nc)
-            C[(i-1)*nc+nξ+nη+1:(i-1)*nc+nξ+nη+nψ] = valψ
+            C[((i - 1) * nc + nξ + nη + 1):((i - 1) * nc + nξ + nη + nψ)] = valψ
             #end
         end
         println("   end for loop")
 
         nothing
     end
-
 end
 
 N = 10000

bench/bench_scalar.jl

@@ -1,7 +1,6 @@
 using BenchmarkTools
 
 function tt()
-
     function bench_scalar(y)
         x = 0
         for i = 1:y
@@ -62,5 +61,4 @@ function tt()
     end
 
     @benchmark bench_scalar_6()
-
 end

bench/bench_usage.jl

@@ -34,11 +34,11 @@ F = Fun_dim_usage_each_call((t, x, u) -> x + u[1])
 @benchmark F(t, x, u)
 
 # fun with dimension usage handled by parameterization
-struct Fun_dim_usage_parametrization{dim_x,dim_u}
+struct Fun_dim_usage_parametrization{dim_x, dim_u}
     f::Function
 end
 
-function (F::Fun_dim_usage_parametrization{1,1})(
+function (F::Fun_dim_usage_parametrization{1, 1})(
     t::Real,
     x::Vector{<:Real},
     u::Vector{<:Real},
@@ -51,11 +51,11 @@ end
 # bench fun with dimension usage handled by parameterization
 
 # x, u scalar
-F = Fun_dim_usage_parametrization{1,1}((t, x, u) -> x + u)
+F = Fun_dim_usage_parametrization{1, 1}((t, x, u) -> x + u)
 @benchmark F(t, x, u)
 
 # x scalar, u vector
-F = Fun_dim_usage_parametrization{1,1}((t, x, u) -> x + u[1])
+F = Fun_dim_usage_parametrization{1, 1}((t, x, u) -> x + u[1])
 @benchmark F(t, x, u)
 
 # direct call to the function