Merge pull request #295 from SciML/format-code-with-juliaformatter

Format code with JuliaFormatter v2.1.5

Author: ChrisRackauckas

README.md

@@ -47,10 +47,10 @@ Let `M`, `D`, `F` be matrix-based, diagonal-matrix-based, and function-based
 ```@example operator_algebra
 using SciMLOperators, LinearAlgebra
 N = 4
-function f(v, u, p, t) 
+function f(v, u, p, t)
     u .* v
 end
-function f(w, v, u, p, t) 
+function f(w, v, u, p, t)
     w .= u .* v
 end
 

docs/pages.jl

@@ -6,6 +6,4 @@ pages = [
         "FFT Tutorial" => "tutorials/fftw.md"
     ],
     "interface.md",
-    "Premade Operators" => "premade_operators.md",
-
-]
+    "Premade Operators" => "premade_operators.md"]

docs/src/index.md

@@ -48,7 +48,7 @@ act like “normal” functions for equation solvers. For example, if `A(v,u,p,t
 has the same operation as `update_coefficients(A, u, p, t); A * v`, then `A`
 can be used in any place where a differential equation definition
 `(u,p,t) -> A(u, u, p, t)` is used without requiring the user or solver to do any extra
-work. 
+work.
 
 Another example is state-dependent mass matrices. `M(u,p,t)*u' = f(u,p,t)`.
 When solving such an equation, the solver must understand how to "update M"
@@ -66,7 +66,7 @@ an extended operator interface with all of these properties, hence the
 `AbstractSciMLOperator` interface.
 
 !!! warn
-
+    
     This means that LinearMaps.jl is fundamentally lacking and is incompatible
     with many of the tools in the SciML ecosystem, except for the specific cases
     where the matrix-free operator is a constant!

docs/src/tutorials/getting_started.md

@@ -11,16 +11,16 @@ and updating operators.
 Before we get into the deeper operators, let's show the simplest SciMLOperator:
 `MatrixOperator`. `MatrixOperator` just turns a matrix into an `AbstractSciMLOperator`,
 so it's not really a matrix-free operator but it's a starting point that is good for
-understanding the interface and testing. To create a `MatrixOperator`, simply call the 
+understanding the interface and testing. To create a `MatrixOperator`, simply call the
 constructor on a matrix:
 
 ```@example getting_started
 using SciMLOperators, LinearAlgebra
-A = [-2.0  1  0  0  0
-      1 -2  1  0  0
-      0  1 -2  1  0
-      0  0  1 -2  1
-      0  0  0  1 -2]
+A = [-2.0 1 0 0 0
+     1 -2 1 0 0
+     0 1 -2 1 0
+     0 0 1 -2 1
+     0 0 0 1 -2]
 
 opA = MatrixOperator(A)
 ```
@@ -29,7 +29,7 @@ The operators can do [operations as defined in the operator interface](@ref oper
 matrix multiplication as the core action:
 
 ```@example getting_started
-v = [3.0,2.0,1.0,2.0,3.0]
+v = [3.0, 2.0, 1.0, 2.0, 3.0]
 opA*v
 ```
 
@@ -43,7 +43,8 @@ mul!(w, opA, v)
 ```
 
 ```@example getting_started
-α = 1.0; β = 1.0
+α = 1.0;
+β = 1.0
 mul!(w, opA, v, α, β) # α*opA*v + β*w
 ```
 
@@ -64,18 +65,20 @@ For example, let's make the operator `A .* u + dt*I` where `dt` is a parameter
 and `u` is a state vector:
 
 ```@example getting_started
-A = [-2.0  1  0  0  0
-      1 -2  1  0  0
-      0  1 -2  1  0
-      0  0  1 -2  1
-      0  0  0  1 -2]
+A = [-2.0 1 0 0 0
+     1 -2 1 0 0
+     0 1 -2 1 0
+     0 0 1 -2 1
+     0 0 0 1 -2]
 
 function update_function!(B, u, p, t)
     dt = p
     B .= A .* u + dt*I
 end
 
-u = Array(1:1.0:5); p = 0.1; t = 0.0
+u = Array(1:1.0:5);
+p = 0.1;
+t = 0.0
 opB = MatrixOperator(copy(A); update_func! = update_function!)
 ```
 
@@ -123,18 +126,18 @@ With `FunctionOperator`, we directly define the operator application function `o
 which means `w = opA(u,p,t)*v`. For example we can do the following:
 
 ```@example getting_started
-function Afunc!(w,v,u,p,t)
+function Afunc!(w, v, u, p, t)
     w[1] = -2v[1] + v[2]
     for i in 2:4
-        w[i] = v[i-1] - 2v[i] + v[i+1]
+        w[i] = v[i - 1] - 2v[i] + v[i + 1]
     end
     w[5] = v[4] - 2v[5]
     nothing
 end
 
-function Afunc!(v,u,p,t)
+function Afunc!(v, u, p, t)
     w = zeros(5)
-    Afunc!(w,v,u,p,t)
+    Afunc!(w, v, u, p, t)
     w
 end
 
@@ -148,29 +151,29 @@ mfopA*v - opA*v
 ```
 
 ```@example getting_started
-mfopA(v,u,p,t) - opA(v,u,p,t)
+mfopA(v, u, p, t) - opA(v, u, p, t)
 ```
 
 We can also create the state-dependent operator as well:
 
 ```@example getting_started
-function Bfunc!(w,v,u,p,t)
+function Bfunc!(w, v, u, p, t)
     dt = p
     w[1] = -(2*u[1]-dt)*v[1] + v[2]*u[1]
     for i in 2:4
-        w[i] = v[i-1]*u[i] - (2*u[i]-dt)*v[i] + v[i+1]*u[i]
+        w[i] = v[i - 1]*u[i] - (2*u[i]-dt)*v[i] + v[i + 1]*u[i]
     end
     w[5] = v[4]*u[5] - (2*u[5]-dt)*v[5]
     nothing
 end
 
-function Bfunc!(v,u,p,t)
+function Bfunc!(v, u, p, t)
     w = zeros(5)
-    Bfunc!(w,v,u,p,t)
+    Bfunc!(w, v, u, p, t)
     w
 end
 
-mfopB = FunctionOperator(Bfunc!, zeros(5), zeros(5); u, p, t, isconstant=false)
+mfopB = FunctionOperator(Bfunc!, zeros(5), zeros(5); u, p, t, isconstant = false)
 ```
 
 ```@example getting_started
@@ -187,19 +190,19 @@ operator for `A .* u` (since right now there is not a built in operator for vect
 but that would be a fantastic thing to add!):
 
 ```@example getting_started
-function Cfunc!(w,v,u,p,t)
+function Cfunc!(w, v, u, p, t)
     w[1] = -2v[1] + v[2]
     for i in 2:4
-        w[i] = v[i-1] - 2v[i] + v[i+1]
+        w[i] = v[i - 1] - 2v[i] + v[i + 1]
     end
     w[5] = v[4] - 2v[5]
     w .= w .* u
     nothing
 end
 
-function Cfunc!(v,u,p,t)
+function Cfunc!(v, u, p, t)
     w = zeros(5)
-    Cfunc!(w,v,u,p,t)
+    Cfunc!(w, v, u, p, t)
     w
 end
 
@@ -227,11 +230,11 @@ adjoints, inverses, and more. For more information, see the [operator algebras t
 Great! You now know how to be state/parameter/time-dependent operators and make them matrix-free, along with
 doing algebras on operators. What's next?
 
-* Interested in more examples of building operators? See the example of [making a fast fourier transform linear operator](@ref fft)
-* Interested in more operators ready to go? See the [Premade Operators page](@ref premade_operators) for all of the operators included with SciMLOperators. Note that there are also downstream packages that make new operators.
-* Want to make your own SciMLOperator? See the [AbstractSciMLOperator interface page](@ref operator_interface) which describes the full interface.
+  - Interested in more examples of building operators? See the example of [making a fast fourier transform linear operator](@ref fft)
+  - Interested in more operators ready to go? See the [Premade Operators page](@ref premade_operators) for all of the operators included with SciMLOperators. Note that there are also downstream packages that make new operators.
+  - Want to make your own SciMLOperator? See the [AbstractSciMLOperator interface page](@ref operator_interface) which describes the full interface.
 
 How do you use SciMLOperators? Check out the following downstream pages:
 
-* [Using SciMLOperators in LinearSolve.jl for matrix-free Krylov methods](https://docs.sciml.ai/LinearSolve/stable/tutorials/linear/)
-* [Using SciMLOperators in OrdinaryDiffEq.jl for semi-linear ODE solvers](https://docs.sciml.ai/DiffEqDocs/stable/solvers/nonautonomous_linear_ode/)
+  - [Using SciMLOperators in LinearSolve.jl for matrix-free Krylov methods](https://docs.sciml.ai/LinearSolve/stable/tutorials/linear/)
+  - [Using SciMLOperators in OrdinaryDiffEq.jl for semi-linear ODE solvers](https://docs.sciml.ai/DiffEqDocs/stable/solvers/nonautonomous_linear_ode/)

docs/src/tutorials/operator_algebras.md

@@ -7,10 +7,10 @@ in order to build more complex objects and using their operations.
 ```@example operator_algebra
 using SciMLOperators, LinearAlgebra
 N = 4
-function f(v, u, p, t) 
+function f(v, u, p, t)
     u .* v
 end
-function f(w, v, u, p, t) 
+function f(w, v, u, p, t)
     w .= u .* v
 end
 

src/SciMLOperators.jl

@@ -38,20 +38,20 @@ the following type of equation:
 w = L(u,p,t)[v]
 ```
 
-where `L[v]` is the operator application of ``L`` on the vector ``v``. 
+where `L[v]` is the operator application of ``L`` on the vector ``v``.
 
 ## Interface
 
 An `AbstractSciMLOperator` can be called  like a function in the following ways:
 
-- `L(v, u, p, t)` - Out-of-place application where `v` is the action vector and `u` is the update vector
-- `L(w, v, u, p, t)` - In-place application where `w` is the destination, `v` is the action vector, and `u` is the update vector
-- `L(w, v, u, p, t, α, β)` - In-place application with scaling: `w = α*(L*v) + β*w`
+  - `L(v, u, p, t)` - Out-of-place application where `v` is the action vector and `u` is the update vector
+  - `L(w, v, u, p, t)` - In-place application where `w` is the destination, `v` is the action vector, and `u` is the update vector
+  - `L(w, v, u, p, t, α, β)` - In-place application with scaling: `w = α*(L*v) + β*w`
 
 Operator state can be updated separately from application:
 
-- `update_coefficients!(L, u, p, t)` for in-place operator update
-- `L = update_coefficients(L, u, p, t)` for out-of-place operator update
+  - `update_coefficients!(L, u, p, t)` for in-place operator update
+  - `L = update_coefficients(L, u, p, t)` for out-of-place operator update
 
 SciMLOperators also overloads `Base.*`, `LinearAlgebra.mul!`,
 `LinearAlgebra.ldiv!` for operator evaluation without updating operator state.
@@ -186,7 +186,6 @@ M = MatrixOperator(zero(N, N); update_func = mat_update_func,
 M(v, u, p, t) == zeros(N) # true
 M(v, u, p, t; scale = 1.0) != zero(N)
 ```
-
 """
 abstract type AbstractSciMLOperator{T} end
 

src/basic.jl

@@ -77,13 +77,15 @@ function (ii::IdentityOperator)(v::AbstractVecOrMat, u, p, t; kwargs...)
 end
 
 # In-place: w is destination, v is action vector, u is update vector
-@inline function (ii::IdentityOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
+@inline function (ii::IdentityOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
     @assert size(v, 1) == ii.len
     copy!(w, v)
 end
 
 # In-place with scaling: w = α*(ii*v) + β*w
-@inline function (ii::IdentityOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+@inline function (ii::IdentityOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     @assert size(v, 1) == ii.len
     mul!(w, I, v, α, β)
 end
@@ -179,7 +181,8 @@ function (nn::NullOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; k
 end
 
 # In-place with scaling: w = α*(nn*v) + β*w
-function (nn::NullOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+function (nn::NullOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     @assert size(v, 1) == nn.len
     lmul!(β, w)
     w
@@ -386,20 +389,21 @@ function (L::ScaledOperator)(v::AbstractVecOrMat, u, p, t; kwargs...)
 end
 
 # In-place: w is destination, v is action vector, u is update vector
-@inline function (L::ScaledOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
+@inline function (L::ScaledOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
     update_coefficients!(L.λ, u, p, t; kwargs...)
     a = convert(Number, L.λ)
     return L.L(w, v, u, p, t, a, false; kwargs...)
 end
 
 # In-place with scaling: w = α*(L*v) + β*w
-@inline function (L::ScaledOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+@inline function (L::ScaledOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     update_coefficients!(L.λ, u, p, t; kwargs...)
     a = convert(Number, L.λ * α)
     return L.L(w, v, u, p, t, a, β; kwargs...)
 end
 
-
 """
 Lazy operator addition
 
@@ -610,7 +614,8 @@ function (L::AddedOperator)(v::AbstractVecOrMat, u, p, t; kwargs...)
 end
 
 # In-place: w is destination, v is action vector, u is update vector
-@generated function (L::AddedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
+@generated function (L::AddedOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
     # We don't need to update coefficients of L, as op(w, v, u, p, t) will do it for each op
 
     ops_types = L.parameters[2].parameters
@@ -619,15 +624,16 @@ end
     quote
         L.ops[1](w, v, u, p, t; kwargs...)
         Base.@nexprs $N i->begin
-            op = L.ops[i+1]
+            op = L.ops[i + 1]
             op(w, v, u, p, t, true, true; kwargs...)
         end
         w
     end
 end
 
 # In-place with scaling: w = α*(L*v) + β*w
-@generated function (L::AddedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+@generated function (L::AddedOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     # We don't need to update coefficients of L, as op(w, v, u, p, t) will do it for each op
 
     T = L.parameters[1]
@@ -637,7 +643,7 @@ end
     quote
         L.ops[1](w, v, u, p, t, α, β; kwargs...)
         Base.@nexprs $N i->begin
-            op = L.ops[i+1]
+            op = L.ops[i + 1]
             op(w, v, u, p, t, α, true; kwargs...)
         end
         w
@@ -909,22 +915,23 @@ end
 function (L::ComposedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t; kwargs...)
     update_coefficients!(L, u, p, t; kwargs...)
     @assert iscached(L) "Cache needs to be set up for ComposedOperator. Call cache_operator(L, u) first."
-    
-    vecs = (w, L.cache[1:(end-1)]..., v)
+
+    vecs = (w, L.cache[1:(end - 1)]..., v)
     for i in reverse(1:length(L.ops))
-        L.ops[i](vecs[i], vecs[i+1], u, p, t; kwargs...)
+        L.ops[i](vecs[i], vecs[i + 1], u, p, t; kwargs...)
     end
     w
 end
 
 # In-place with scaling: w = α*(L*v) + β*w
-function (L::ComposedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+function (L::ComposedOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     update_coefficients!(L, u, p, t; kwargs...)
     @assert iscached(L) "Cache needs to be set up for ComposedOperator. Call cache_operator(L, u) first."
-    
+
     cache = L.cache[end]
     copy!(cache, w)
-    
+
     L(w, v, u, p, t; kwargs...)
     lmul!(α, w)
     axpy!(β, cache, w)
@@ -1063,10 +1070,11 @@ function (L::InvertedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t
 end
 
 # In-place with scaling: w = α*(L*v) + β*w
-function (L::InvertedOperator)(w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
+function (L::InvertedOperator)(
+        w::AbstractVecOrMat, v::AbstractVecOrMat, u, p, t, α, β; kwargs...)
     update_coefficients!(L, u, p, t; kwargs...)
     @assert iscached(L) "Cache needs to be set up for InvertedOperator. Call cache_operator(L, u) first."
-    
+
     copy!(L.cache, w)
     ldiv!(w, L.L, v)
     lmul!(α, w)