Merge pull request SciML#495 from LilithHafner/lh/format

Run JuliaFormatter.format()

Author: ChrisRackauckas

docs/make.jl

@@ -51,34 +51,34 @@ function create_tutorials(dirname, targetdir, excludes = [])
             Literate.markdown(ipath, targetdir)
             Literate.markdown(ipath, targetdir, execute = false, postprocess = mdpost)
             push!(tutorials,
-                  relpath(joinpath(targetdir, fname * ".md"), joinpath(@__DIR__, "src")))
+                relpath(joinpath(targetdir, fname * ".md"), joinpath(@__DIR__, "src")))
         end
     end
     return tutorials
 end
 
 koopman_tutorial = create_tutorials(joinpath(@__DIR__, "src/libs/datadrivendmd/"),
-                                    joinpath(@__DIR__, "src/libs/datadrivendmd/examples"))
+    joinpath(@__DIR__, "src/libs/datadrivendmd/examples"))
 sparse_tutorial = create_tutorials(joinpath(@__DIR__, "src/libs/datadrivensparse/"),
-                                   joinpath(@__DIR__, "src/libs/datadrivensparse/examples"))
+    joinpath(@__DIR__, "src/libs/datadrivensparse/examples"))
 sr_tutorial = create_tutorials(joinpath(@__DIR__, "src/libs/datadrivensr/"),
-                               joinpath(@__DIR__, "src/libs/datadrivensr/examples"))
+    joinpath(@__DIR__, "src/libs/datadrivensr/examples"))
 
 # Must be after tutorials is created
 include("pages.jl")
 
 # Create the docs
 makedocs(sitename = "DataDrivenDiffEq.jl",
-         authors = "Julius Martensen, Christopher Rackauckas, et al.",
-         modules = [DataDrivenDiffEq, DataDrivenDMD, DataDrivenSparse, DataDrivenSR],
-         clean = true, doctest = false, linkcheck = true,
-         warnonly = [:missing_docs, :cross_references],
-         linkcheck_ignore = ["http://cwrowley.princeton.edu/papers/Hemati-2017a.pdf",
-             "https://royalsocietypublishing.org/doi/10.1098/rspa.2020.0279",
-             "https://www.pnas.org/doi/10.1073/pnas.1517384113"],
-         format = Documenter.HTML(assets = ["assets/favicon.ico"],
-                                  canonical = "https://docs.sciml.ai/DataDrivenDiffEq/stable/"),
-         pages = pages)
+    authors = "Julius Martensen, Christopher Rackauckas, et al.",
+    modules = [DataDrivenDiffEq, DataDrivenDMD, DataDrivenSparse, DataDrivenSR],
+    clean = true, doctest = false, linkcheck = true,
+    warnonly = [:missing_docs, :cross_references],
+    linkcheck_ignore = ["http://cwrowley.princeton.edu/papers/Hemati-2017a.pdf",
+        "https://royalsocietypublishing.org/doi/10.1098/rspa.2020.0279",
+        "https://www.pnas.org/doi/10.1073/pnas.1517384113"],
+    format = Documenter.HTML(assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/DataDrivenDiffEq/stable/"),
+    pages = pages)
 
 deploydocs(repo = "github.com/SciML/DataDrivenDiffEq.jl.git";
-           push_preview = true)
+    push_preview = true)

docs/pages.jl

@@ -6,13 +6,13 @@ pages = [
     "Solutions" => "solutions.md",
     "Utilities" => "utils.md",
     "DataDrivenDMD" => ["Background" => "libs/datadrivendmd/koopman.md",
-        "Examples" => koopman_tutorial,
+        "Examples" => koopman_tutorial
     ],
     "DataDrivenSparse" => ["Background" => "libs/datadrivensparse/sparse_regression.md",
-        "Examples" => sparse_tutorial,
+        "Examples" => sparse_tutorial
     ],
     "DataDrivenSR" => ["Background" => "libs/datadrivensr/symbolic_regression.md",
-        "Examples" => sr_tutorial,
+        "Examples" => sr_tutorial
     ],
-    "Citing" => "citations.md",
+    "Citing" => "citations.md"
 ]

docs/src/libs/datadrivensparse/example_02.jl

@@ -39,8 +39,8 @@ ts = sol.t;
 # in as a function `(u,p,t)->control` or an array of measurements.
 
 prob = ContinuousDataDrivenProblem(X, ts, GaussianKernel(),
-                                   U = (u, p, t) -> [exp(-((t - 5.0) / 5.0)^2)],
-                                   p = ones(2))
+    U = (u, p, t) -> [exp(-((t - 5.0) / 5.0)^2)],
+    p = ones(2))
 
 #md plot(prob, size = (600,600))
 
@@ -66,7 +66,7 @@ sampler = DataProcessing(split = 0.8, shuffle = true, batchsize = 30, rng = rng)
 λs = exp10.(-10:0.1:0)
 opt = STLSQ(λs)
 res = solve(prob, basis, opt,
-            options = DataDrivenCommonOptions(data_processing = sampler, digits = 1))
+    options = DataDrivenCommonOptions(data_processing = sampler, digits = 1))
 #src println(res) #hide
 
 # !!! info

docs/src/libs/datadrivensparse/example_03.jl

@@ -24,9 +24,9 @@ ode_problem = ODEProblem(michaelis_menten, u0, (0.0, 4.0));
 # for the processing.
 
 prob = DataDrivenDataset(map(1:2) do i
-                             solve(remake(ode_problem, u0 = i * u0),
-                                   Tsit5(), saveat = 0.1, tspan = (0.0, 4.0))
-                         end...)
+    solve(remake(ode_problem, u0 = i * u0),
+        Tsit5(), saveat = 0.1, tspan = (0.0, 4.0))
+end...)
 
 #md plot(prob)
 

docs/src/libs/datadrivensparse/example_04.jl

@@ -20,7 +20,9 @@ using Test #src
     δ = 0.5
 end
 
-@variables begin x[1:2](t) = [20.0; 12.0] end
+@variables begin
+    x[1:2](t) = [20.0; 12.0]
+end
 
 x = collect(x)
 D = Differential(t)
@@ -52,7 +54,7 @@ basis = Basis(eqs, x, independent_variable = t, implicits = D.(x))
 
 sampler = DataProcessing(split = 0.8, shuffle = true, batchsize = 30)
 res = solve(dd_prob, basis, ImplicitOptimizer(STLSQ(1e-2:1e-2:1.0)),
-            options = DataDrivenCommonOptions(data_processing = sampler, digits = 2))
+    options = DataDrivenCommonOptions(data_processing = sampler, digits = 2))
 #md println(res) #hide
 
 # And have a look at the resulting plot

docs/src/libs/datadrivensparse/example_05.jl

@@ -36,7 +36,7 @@ end
 t = solution.t
 
 ddprob = ContinuousDataDrivenProblem(X, t, DX = DX[3:4, :],
-                                     U = (u, p, t) -> [-0.2 + 0.5 * sin(6 * t)])
+    U = (u, p, t) -> [-0.2 + 0.5 * sin(6 * t)])
 
 #md plot(ddprob)
 

docs/src/libs/datadrivensr/example_01.jl

@@ -37,9 +37,9 @@ prob = ContinuousDataDrivenProblem(X, t, U = U)
 # We will stick to simple operations, use a `L1DistLoss`, and limit the verbosity of the algorithm.
 
 eqsearch_options = SymbolicRegression.Options(binary_operators = [+, *],
-                                              loss = L1DistLoss(),
-                                              verbosity = -1, progress = false, npop = 30,
-                                              timeout_in_seconds = 60.0)
+    loss = L1DistLoss(),
+    verbosity = -1, progress = false, npop = 30,
+    timeout_in_seconds = 60.0)
 
 alg = EQSearch(eq_options = eqsearch_options)
 

docs/src/libs/datadrivensr/example_02.jl

@@ -36,9 +36,9 @@ u = collect(u)
 basis = Basis([polynomial_basis(u, 2); sin.(u)], u)
 
 eqsearch_options = SymbolicRegression.Options(binary_operators = [+, *],
-                                              loss = L1DistLoss(),
-                                              verbosity = -1, progress = false, npop = 30,
-                                              timeout_in_seconds = 60.0)
+    loss = L1DistLoss(),
+    verbosity = -1, progress = false, npop = 30,
+    timeout_in_seconds = 60.0)
 
 alg = EQSearch(eq_options = eqsearch_options)
 

lib/DataDrivenDMD/src/algorithms.jl

@@ -20,14 +20,16 @@ function truncated_svd(A::AbstractMatrix{T}, truncation::Int) where {T <: Number
 end
 
 # General method with inputs
-function (x::AbstractKoopmanAlgorithm)(X::AbstractArray, Y::AbstractArray, U::AbstractArray,
-                                       B::AbstractArray)
+function (x::AbstractKoopmanAlgorithm)(
+        X::AbstractArray, Y::AbstractArray, U::AbstractArray,
+        B::AbstractArray)
     K, _ = x(X, Y - B * U)
     return (K, B)
 end
 
-function (x::AbstractKoopmanAlgorithm)(X::AbstractArray, Y::AbstractArray, U::AbstractArray,
-                                       ::Nothing)
+function (x::AbstractKoopmanAlgorithm)(
+        X::AbstractArray, Y::AbstractArray, U::AbstractArray,
+        ::Nothing)
     return x(X, Y, U)
 end
 
@@ -113,7 +115,7 @@ end
 
 # DMDc
 function (x::DMDSVD{T})(X::AbstractArray, Y::AbstractArray,
-                        U::AbstractArray) where {T <: Real}
+        U::AbstractArray) where {T <: Real}
     isempty(U) && return x(X, Y)
     nx, m = size(X)
     nu, m = size(U)
@@ -176,7 +178,7 @@ function (x::TOTALDMD)(X::AbstractArray, Y::AbstractArray, U::AbstractArray)
 end
 
 function (x::TOTALDMD)(X::AbstractArray, Y::AbstractArray, U::AbstractArray,
-                       B::AbstractArray)
+        B::AbstractArray)
     _, _, Q = truncated_svd([X; Y], x.truncation)
     K, _ = x.alg(X * Q, (Y - B * U) * Q)
     return (K, B)

lib/DataDrivenDMD/src/result.jl

@@ -25,7 +25,7 @@ struct KoopmanResult{K, B, C, Q, P, T} <: AbstractDataDrivenResult
     retcode::DDReturnCode
 
     function KoopmanResult(k_::K, b::B, c::C, q::Q, p::P, X::AbstractMatrix{T},
-                           Y::AbstractMatrix{T}, U::AbstractMatrix) where {K, B, C, Q, P, T}
+            Y::AbstractMatrix{T}, U::AbstractMatrix) where {K, B, C, Q, P, T}
         k = Matrix(k_)
         rss = isempty(b) ? sum(abs2, Y .- c * k * X) : sum(abs2, Y .- c * (k * X .+ b * U))
         dof = sum(!iszero, k)

lib/DataDrivenDMD/src/solve.jl

@@ -1,10 +1,10 @@
 # This will get called within init in DataDrivenDiffEq
 
 function DataDrivenDiffEq.get_fit_targets(::A, prob::ABSTRACT_CONT_PROB,
-                                          basis::AbstractBasis) where {
-                                                                       A <:
-                                                                       AbstractKoopmanAlgorithm
-                                                                       }
+        basis::AbstractBasis) where {
+        A <:
+        AbstractKoopmanAlgorithm
+}
     @unpack DX, X, p, t, U = prob
 
     @assert size(DX, 1)==size(X, 1) "$(A) needs equal number of observed states and differentials for continuous problems!"
@@ -32,10 +32,10 @@ function DataDrivenDiffEq.get_fit_targets(::A, prob::ABSTRACT_CONT_PROB,
 end
 
 function DataDrivenDiffEq.get_fit_targets(::A, prob::ABSTRACT_DISCRETE_PROB,
-                                          basis::AbstractBasis) where {
-                                                                       A <:
-                                                                       AbstractKoopmanAlgorithm
-                                                                       }
+        basis::AbstractBasis) where {
+        A <:
+        AbstractKoopmanAlgorithm
+}
     # TODO Maybe we could, but this would require X[:, i+2] -> split in three here
     @assert !is_implicit(basis) "$(A) does not support implicit arguments in the basis for discrete problems!"
 
@@ -48,7 +48,7 @@ function DataDrivenDiffEq.get_fit_targets(::A, prob::ABSTRACT_DISCRETE_PROB,
     if is_controlled(basis)
         foreach(1:m) do i
             Ỹ[:, i] .= basis(X[:, i + 1], p, t[i + 1],
-                              U[:, i + 1])
+                U[:, i + 1])
         end
     else
         foreach(1:m) do i
@@ -60,9 +60,9 @@ end
 
 ## Solve the Koopman 
 function CommonSolve.solve!(prob::InternalDataDrivenProblem{A}) where {
-                                                                       A <:
-                                                                       AbstractKoopmanAlgorithm
-                                                                       }
+        A <:
+        AbstractKoopmanAlgorithm
+}
     @unpack alg, basis, testdata, traindata, control_idx, options, problem, kwargs = prob
     @unpack selector = options
     # Check for 
@@ -94,7 +94,7 @@ function convert_to_basis(res::KoopmanResult, basis::Basis, prob, options, contr
 end
 
 function (algorithm::AbstractKoopmanAlgorithm)(prob::InternalDataDrivenProblem;
-                                               control_input = nothing, kwargs...)
+        control_input = nothing, kwargs...)
     @unpack traindata, testdata, control_idx, options = prob
     @unpack abstol = options
     # Preprocess control idx, indicates if any control is active in a single basis atom

lib/DataDrivenDMD/src/type.jl

@@ -148,10 +148,10 @@ the L2 error of the prediction exceeds the `threshold`.
 `p` and `t` are the parameters of the basis and the vector of timepoints, if necessary.
 """
 function update!(k::AbstractKoopman,
-                 X::AbstractArray, Y::AbstractArray;
-                 p::AbstractArray = [], t::AbstractVector = [],
-                 U::AbstractArray = [],
-                 threshold::T = eps()) where {T <: Real}
+        X::AbstractArray, Y::AbstractArray;
+        p::AbstractArray = [], t::AbstractVector = [],
+        U::AbstractArray = [],
+        threshold::T = eps()) where {T <: Real}
     @assert updatable(k) "Linear Koopman is not updatable."
 
     Ψ₀ = k(X, p, t, U)

lib/DataDrivenDMD/test/runtests.jl

@@ -7,9 +7,19 @@ using Test
 
 const GROUP = get(ENV, "GROUP", "All")
 
-@time begin if GROUP == "All" || GROUP == "DataDrivenDMD"
-    @safetestset "Linear autonomous" begin include("./linear_autonomous.jl") end
-    @safetestset "Linear forced" begin include("./linear_forced.jl") end
-    @safetestset "Nonlinear autonomous" begin include("./nonlinear_autonomous.jl") end
-    @safetestset "Nonlinear forced" begin include("./nonlinear_forced.jl") end
-end end
+@time begin
+    if GROUP == "All" || GROUP == "DataDrivenDMD"
+        @safetestset "Linear autonomous" begin
+            include("./linear_autonomous.jl")
+        end
+        @safetestset "Linear forced" begin
+            include("./linear_forced.jl")
+        end
+        @safetestset "Nonlinear autonomous" begin
+            include("./nonlinear_autonomous.jl")
+        end
+        @safetestset "Nonlinear forced" begin
+            include("./nonlinear_forced.jl")
+        end
+    end
+end

lib/DataDrivenLux/src/algorithms/crossentropy.jl

@@ -63,15 +63,15 @@ function init_model(x::CrossEntropy, basis::Basis, dataset::Dataset, intervals)
     end
 
     return LayeredDAG(length(basis), size(dataset.y, 1), n_layers, arities, functions;
-                      skip = skip, input_functions = variable_mask, simplex = simplex)
+        skip = skip, input_functions = variable_mask, simplex = simplex)
 end
 
 function update_parameters!(cache::SearchCache{<:CrossEntropy})
     @unpack candidates, keeps, p, alg = cache
     @unpack alpha = alg
     p̄ = mean(map(candidates[keeps]) do candidate
-                  ComponentVector(get_configuration(candidate.model.model, p, candidate.st))
-              end)
+        ComponentVector(get_configuration(candidate.model.model, p, candidate.st))
+    end)
     cache.p .= alpha * p + (one(alpha) - alpha) .* p̄
     return
 end

lib/DataDrivenLux/src/algorithms/reinforce.jl

@@ -55,8 +55,8 @@ function reinforce_loss(candidates, p, alg)
     rewards = reward(losses)
     # ∇U(θ) = E[∇log(p)*R(t)]
     mean(map(enumerate(candidates)) do (i, candidate)
-             rewards[i] * -candidate(p)
-         end)
+        rewards[i] * -candidate(p)
+    end)
 end
 
 function update_parameters!(cache::SearchCache{<:Reinforce})

lib/DataDrivenLux/src/caches/cache.jl

@@ -30,11 +30,11 @@ function init_model(x::AbstractDAGSRAlgorithm, basis::Basis, dataset::Dataset, i
     end
 
     return LayeredDAG(length(basis), size(dataset.y, 1), n_layers, arities, functions;
-                      skip = skip, input_functions = variable_mask, simplex = simplex)
+        skip = skip, input_functions = variable_mask, simplex = simplex)
 end
 
 function init_cache(x::X where {X <: AbstractDAGSRAlgorithm}, basis::Basis,
-                    problem::DataDrivenProblem; kwargs...)
+        problem::DataDrivenProblem; kwargs...)
     @unpack rng, keep, observed, populationsize, optimizer, optim_options, optimiser, loss = x
     # Derive the model
     dataset = Dataset(problem)
@@ -56,9 +56,9 @@ function init_cache(x::X where {X <: AbstractDAGSRAlgorithm}, basis::Basis,
     # Derive the candidates     
     candidates = map(1:populationsize) do i
         candidate = Candidate(rng_, model, basis, dataset; observed = observed,
-                              parameterdist = parameters, ptype = TData)
+            parameterdist = parameters, ptype = TData)
         optimize_candidate!(candidate, dataset; optimizer = optimizer,
-                            options = optim_options)
+            options = optim_options)
         candidate
     end
 
@@ -93,8 +93,8 @@ function init_cache(x::X where {X <: AbstractDAGSRAlgorithm}, basis::Basis,
         optimiser_state = nothing
     end
     return SearchCache{typeof(x), ptype, typeof(optimiser_state)}(x, candidates, ages,
-                                                                  keeps, sorting, ps,
-                                                                  dataset, optimiser_state)
+        keeps, sorting, ps,
+        dataset, optimiser_state)
 end
 
 function update_cache!(cache::SearchCache)
@@ -134,7 +134,7 @@ function optimize_cache!(cache::SearchCache{<:Any, __PROCESSUSE(1)}, p = cache.p
             return true
         else
             optimize_candidate!(candidate, cache.dataset, p; optimizer = optimizer,
-                                options = optim_options)
+                options = optim_options)
             cache.ages[i] = 0
             return true
         end
@@ -151,7 +151,7 @@ function optimize_cache!(cache::SearchCache{<:Any, __PROCESSUSE(2)}, p = cache.p
             cache.ages[i] += 1
         else
             optimize_candidate!(cache.candidates[i], cache.dataset, p;
-                                optimizer = optimizer, options = optim_options)
+                optimizer = optimizer, options = optim_options)
             cache.ages[i] = 0
         end
     end
@@ -169,7 +169,7 @@ function optimize_cache!(cache::SearchCache{<:Any, __PROCESSUSE(3)}, p = cache.p
             return true
         else
             optimize_candidate!(cache.candidates[i], cache.dataset, p;
-                                optimizer = optimizer, options = optim_options)
+                optimizer = optimizer, options = optim_options)
             cache.ages[i] = 0
             return true
         end