Merge pull request #238 from ArnoStrouwen/format

reapply formatter

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -1,2 +1,3 @@
 style = "sciml"
-format_markdown = true
+format_markdown = true
+format_docstrings = true

docs/pages.jl

@@ -8,5 +8,5 @@ pages = [
     # "tutorials/nonlin.md",
     # "tutorials/ode.md",
     # "tutorials/lux.md",
-    ],
+    ]
 ]

docs/src/tutorials/fftw.md

@@ -15,11 +15,11 @@ n = 256
 L = 2π
 
 dx = L / n
-x  = range(start=-L/2, stop=L/2-dx, length=n) |> Array
-u  = @. sin(5x)cos(7x);
+x = range(start = -L / 2, stop = L / 2 - dx, length = n) |> Array
+u = @. sin(5x)cos(7x);
 du = @. 5cos(5x)cos(7x) - 7sin(5x)sin(7x);
 
-k = rfftfreq(n, 2π*n/L) |> Array
+k = rfftfreq(n, 2π * n / L) |> Array
 m = length(k)
 P = plan_rfft(x)
 
@@ -29,23 +29,19 @@ bwd(u, p, t) = P \ u
 fwd(du, u, p, t) = mul!(du, P, u)
 bwd(du, u, p, t) = ldiv!(du, P, u)
 
-F = FunctionOperator(fwd, x, im*k;
-        T=ComplexF64,
-
-        op_adjoint = bwd,
-        op_inverse = bwd,
-        op_adjoint_inverse = fwd,
-
-        islinear=true,
-        )
+F = FunctionOperator(fwd, x, im * k;
+    T = ComplexF64, op_adjoint = bwd,
+    op_inverse = bwd,
+    op_adjoint_inverse = fwd, islinear = true
+)
 
 ik = im * DiagonalOperator(k)
 Dx = F \ ik * F
 
 Dx = cache_operator(Dx, x)
 
-@show ≈(Dx * u, du; atol=1e-8)
-@show ≈(mul!(copy(u), Dx, u), du; atol=1e-8)
+@show ≈(Dx * u, du; atol = 1e-8)
+@show ≈(mul!(copy(u), Dx, u), du; atol = 1e-8)
 ```
 
 ## Explanation
@@ -60,14 +56,13 @@ FFT wrapper.
 using SciMLOperators
 using LinearAlgebra, FFTW
 
-L  = 2π
-n  = 256
+L = 2π
+n = 256
 dx = L / n
-x  = range(start=-L/2, stop=L/2-dx, length=n) |> Array
+x = range(start = -L / 2, stop = L / 2 - dx, length = n) |> Array
 
-u  = @. sin(5x)cos(7x);
+u = @. sin(5x)cos(7x);
 du = @. 5cos(5x)cos(7x) - 7sin(5x)sin(7x);
-
 ```
 
 Now, we define the Fourier transform. Since our input is purely Real, we use the real
@@ -77,8 +72,8 @@ and `LinearAlgebra.mul!(xhat, transform, x)`.  We also get `k`, the frequency mo
 our finite grid, via the function `rfftfreq`.
 
 ```@example fft_explanation
-k  = rfftfreq(n, 2π*n/L) |> Array
-m  = length(k)
+k = rfftfreq(n, 2π * n / L) |> Array
+m = length(k)
 P = plan_rfft(x)
 ```
 
@@ -93,15 +88,11 @@ bwd(u, p, t) = P \ u
 
 fwd(du, u, p, t) = mul!(du, P, u)
 bwd(du, u, p, t) = ldiv!(du, P, u)
-F = FunctionOperator(fwd, x, im*k;
-        T=ComplexF64,
-
-        op_adjoint = bwd,
-        op_inverse = bwd,
-        op_adjoint_inverse = fwd,
-
-        islinear=true,
-        )
+F = FunctionOperator(fwd, x, im * k;
+    T = ComplexF64, op_adjoint = bwd,
+    op_inverse = bwd,
+    op_adjoint_inverse = fwd, islinear = true
+)
 ```
 
 After wrapping the FFT with `FunctionOperator`, we are ready to compose it with other
@@ -115,6 +106,6 @@ Dx = F \ ik * F
 
 Dx = cache_operator(Dx, x)
 
-@show ≈(Dx * u, du; atol=1e-8)
-@show ≈(mul!(copy(u), Dx, u), du; atol=1e-8)
+@show ≈(Dx * u, du; atol = 1e-8)
+@show ≈(mul!(copy(u), Dx, u), du; atol = 1e-8)
 ```

src/SciMLOperators.jl

@@ -78,30 +78,30 @@ include("func.jl")
 include("tensor.jl")
 
 export
-    IdentityOperator,
-    NullOperator,
-    ScalarOperator,
-    MatrixOperator,
-    DiagonalOperator,
-    InvertibleOperator,
-    AffineOperator,
-    AddVector,
-    FunctionOperator,
-    TensorProductOperator
+       IdentityOperator,
+       NullOperator,
+       ScalarOperator,
+       MatrixOperator,
+       DiagonalOperator,
+       InvertibleOperator,
+       AffineOperator,
+       AddVector,
+       FunctionOperator,
+       TensorProductOperator
 
 export update_coefficients!,
-    update_coefficients, isconstant,
-    iscached,
-    cache_operator, issquare,
-    islinear,
-    concretize,
-    isconvertible, has_adjoint,
-    has_expmv,
-    has_expmv!,
-    has_exp,
-    has_mul,
-    has_mul!,
-    has_ldiv,
-    has_ldiv!
+       update_coefficients, isconstant,
+       iscached,
+       cache_operator, issquare,
+       islinear,
+       concretize,
+       isconvertible, has_adjoint,
+       has_expmv,
+       has_expmv!,
+       has_exp,
+       has_mul,
+       has_mul!,
+       has_ldiv,
+       has_ldiv!
 
 end # module

src/basic.jl

@@ -180,7 +180,7 @@ $TYPEDEF
 """
 struct ScaledOperator{T,
     λType,
-    LType,
+    LType
 } <: AbstractSciMLOperator{T}
     λ::λType
     L::LType
@@ -194,7 +194,8 @@ end
 
 # constructors
 for T in SCALINGNUMBERTYPES[2:end]
-    @eval ScaledOperator(λ::$T, L::AbstractSciMLOperator) = ScaledOperator(ScalarOperator(λ),
+    @eval ScaledOperator(λ::$T, L::AbstractSciMLOperator) = ScaledOperator(
+        ScalarOperator(λ),
         L)
 end
 
@@ -312,7 +313,7 @@ Lazy operator addition
     (A1 + A2 + A3...)u = A1*u + A2*u + A3*u ....
 """
 struct AddedOperator{T,
-    O <: Tuple{Vararg{AbstractSciMLOperator}},
+    O <: Tuple{Vararg{AbstractSciMLOperator}}
 } <: AbstractSciMLOperator{T}
     ops::O
 
@@ -491,9 +492,11 @@ end
 # constructors
 for op in (:*, :∘)
     @eval Base.$op(ops::AbstractSciMLOperator...) = reduce($op, ops)
-    @eval Base.$op(A::AbstractSciMLOperator, B::AbstractSciMLOperator) = ComposedOperator(A,
+    @eval Base.$op(A::AbstractSciMLOperator, B::AbstractSciMLOperator) = ComposedOperator(
+        A,
         B)
-    @eval Base.$op(A::ComposedOperator, B::AbstractSciMLOperator) = ComposedOperator(A.ops...,
+    @eval Base.$op(A::ComposedOperator, B::AbstractSciMLOperator) = ComposedOperator(
+        A.ops...,
         B)
     @eval Base.$op(A::AbstractSciMLOperator, B::ComposedOperator) = ComposedOperator(A,
         B.ops...)
@@ -553,7 +556,7 @@ Base.size(L::ComposedOperator) = (size(first(L.ops), 1), size(last(L.ops), 2))
 for op in (:adjoint,
     :transpose)
     @eval Base.$op(L::ComposedOperator) = ComposedOperator($op.(reverse(L.ops))...;
-        cache = iscached(L) ? reverse(L.cache) : nothing,)
+        cache = iscached(L) ? reverse(L.cache) : nothing)
 end
 Base.conj(L::ComposedOperator) = ComposedOperator(conj.(L.ops); cache = L.cache)
 function Base.resize!(L::ComposedOperator, n::Integer)
@@ -596,7 +599,8 @@ for fact in (:lu, :lu!,
     :bunchkaufman, :bunchkaufman!,
     :lq, :lq!,
     :svd, :svd!)
-    @eval LinearAlgebra.$fact(L::ComposedOperator, args...) = prod(op -> $fact(op, args...),
+    @eval LinearAlgebra.$fact(L::ComposedOperator, args...) = prod(
+        op -> $fact(op, args...),
         reverse(L.ops))
 end
 

src/batch.jl

@@ -18,7 +18,7 @@ struct BatchedDiagonalOperator{T, D, F, F!} <: AbstractSciMLOperator{T}
             eltype(diag),
             typeof(diag),
             typeof(update_func),
-            typeof(update_func!),
+            typeof(update_func!)
         }(diag,
             update_func,
             update_func!)
@@ -63,7 +63,7 @@ function Base.conj(L::BatchedDiagonalOperator) # TODO - test this thoroughly
     DiagonalOperator(conj(L.diag);
         update_func = update_func,
         update_func! = update_func!,
-        accepted_kwargs = NoKwargFilter(),)
+        accepted_kwargs = NoKwargFilter())
 end
 
 function Base.convert(::Type{AbstractMatrix}, L::BatchedDiagonalOperator)