Merge pull request #224 from avik-pal/ap/format

Run formatter

Author: ChrisRackauckas

.gitignore

@@ -26,3 +26,4 @@ Manifest.toml
 # Editor generatoed file
 .*.swp
 .*.swo
+.vscode

README.md

@@ -8,7 +8,7 @@
 [![codecov](https://codecov.io/gh/SciML/SciMLOperators.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/SciML/SciMLOperators.jl)
 [![Build Status](https://github.com/SciML/SciMLOperators.jl/workflows/CI/badge.svg)](https://github.com/SciML/SciMLOperators.jl/actions?query=workflow%3ACI)
 
-[![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor's%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
+[![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor%27s%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
 [![SciML Code Style](https://img.shields.io/static/v1?label=code%20style&message=SciML&color=9558b2&labelColor=389826)](https://github.com/SciML/SciMLStyle)
 
 `SciMLOperators` is a package for managing linear, nonlinear,
@@ -28,6 +28,7 @@ or `NonlinearSolve.jl` as a linear/nonlinear operator, or to
 `SciML` ecosystem are provided in the documentation.
 
 ## Installation
+
 `SciMLOperators.jl` is a registerd package and can be installed via
 
 ```
@@ -69,7 +70,7 @@ t = 0.0     # time
 u = rand(N)
 v = L1(u, p, t) # == L1 * u
 
-u_kron = rand(N ^ 3)
+u_kron = rand(N^3)
 v_kron = L3(u_kron, p, t) # == L3 * u_kron
 ```
 
@@ -90,9 +91,9 @@ L4(v, u, p, t, α, β) # == mul!(v, L4, u, α, β)
 
 ## Roadmap
 
-- [ ] [Complete integration with `SciML` ecosystem](https://github.com/SciML/SciMLOperators.jl/issues/142)
-- [ ] [Block-matrices](https://github.com/SciML/SciMLOperators.jl/issues/161)
-- [x] [Benchmark and speed-up tensorbproduct evaluations](https://github.com/SciML/SciMLOperators.jl/issues/58)
-- [ ] [Fast tensor-sum (`kronsum`) evaluation](https://github.com/SciML/SciMLOperators.jl/issues/53)
-- [ ] [Fully flesh out operator array algebra](https://github.com/SciML/SciMLOperators.jl/issues/62)
-- [ ] [Operator fusion/matrix chain multiplication at constant `(u, p, t)`-slices](https://github.com/SciML/SciMLOperators.jl/issues/51)
+  - [ ] [Complete integration with `SciML` ecosystem](https://github.com/SciML/SciMLOperators.jl/issues/142)
+  - [ ] [Block-matrices](https://github.com/SciML/SciMLOperators.jl/issues/161)
+  - [x] [Benchmark and speed-up tensorbproduct evaluations](https://github.com/SciML/SciMLOperators.jl/issues/58)
+  - [ ] [Fast tensor-sum (`kronsum`) evaluation](https://github.com/SciML/SciMLOperators.jl/issues/53)
+  - [ ] [Fully flesh out operator array algebra](https://github.com/SciML/SciMLOperators.jl/issues/62)
+  - [ ] [Operator fusion/matrix chain multiplication at constant `(u, p, t)`-slices](https://github.com/SciML/SciMLOperators.jl/issues/51)

benchmarks/tensor.jl

@@ -4,9 +4,9 @@ using SciMLOperators: IdentityOperator, ⊗
 N = 12
 K = 100
 Id = IdentityOperator(N)
-A = rand(N,N)
-B = rand(N,N)
-C = rand(N,N)
+A = rand(N, N)
+B = rand(N, N)
+C = rand(N, N)
 
 println("#===============================#")
 println("2D Tensor Products")

docs/make.jl

@@ -5,19 +5,14 @@ cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
 
 include("pages.jl")
 
-makedocs(
-    sitename="SciMLOperators.jl",
-    authors="Vedant Puri, Alex Jones, Chris Rackauckas",
-    modules=[SciMLOperators],
-    clean=true, doctest=false, linkcheck = true,
+makedocs(sitename = "SciMLOperators.jl",
+    authors = "Vedant Puri, Alex Jones, Chris Rackauckas",
+    modules = [SciMLOperators],
+    clean = true, doctest = false, linkcheck = true,
     warnonly = [:docs_block, :missing_docs, :cross_references, :linkcheck],
-    format = Documenter.HTML(
-                             assets = ["assets/favicon.ico"],
-                             canonical="https://docs.sciml.ai/SciMLOperators/stable"),
-    pages=pages
-)
+    format = Documenter.HTML(assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/SciMLOperators/stable"),
+    pages = pages)
 
-deploydocs(
-   repo = "github.com/SciML/SciMLOperators.jl.git";
-   push_preview = true
-)
+deploydocs(repo = "github.com/SciML/SciMLOperators.jl.git";
+    push_preview = true)

docs/pages.jl

@@ -1,13 +1,12 @@
 pages = [
-         "Home" => "index.md",
-         "sciml.md",
-         "interface.md",
-         "Premade Operators" => "premade_operators.md",
-         "Tutorials" => Any[
-                            "FFT Tutorial" => "tutorials/fftw.md",
-                            # "tutorials/linear.md",
-                            # "tutorials/nonlin.md",
-                            # "tutorials/ode.md",
-                            # "tutorials/lux.md",
-                           ]
-        ]
+    "Home" => "index.md",
+    "sciml.md",
+    "interface.md",
+    "Premade Operators" => "premade_operators.md",
+    "Tutorials" => Any["FFT Tutorial" => "tutorials/fftw.md"
+    # "tutorials/linear.md",
+    # "tutorials/nonlin.md",
+    # "tutorials/ode.md",
+    # "tutorials/lux.md",
+    ],
+]

docs/src/index.md

@@ -16,14 +16,14 @@ or `NonlinearSolve.jl` as a linear or nonlinear operator, or to
 `OrdinaryDiffEq.jl` as an `ODEFunction`. Examples of usage within the
 `SciML` ecosystem are provided in the documentation.
 
-
 ## Installation
 
 To install SciMLOperators.jl, use the Julia package manager:
 
 ```julia
 using Pkg
 Pkg.add("SciMLOperators")
+```
 
 ## Examples
 
@@ -58,7 +58,7 @@ t = 0.0     # time
 u = rand(N)
 v = L1(u, p, t) # == L1 * u
 
-u_kron = rand(N ^ 3)
+u_kron = rand(N^3)
 v_kron = L3(u_kron, p, t) # == L3 * u_kron
 ```
 
@@ -94,13 +94,13 @@ object `p`.
 
 ## Features
 
-* Matrix-free operators with `FunctionOperator`
-* Fast tensor product evaluation with `TensorProductOperator`
-* Lazy algebra: addition, subtraction, multiplication, inverse, adjoint, and transpose
-* Couple fast methods for operator evaluation with inversion via `InvertibleOperator`
-* One-line API to update operator state depending on arbitrary parameters.
-* Mutating and nonmutating update behavior (Zygote compatible)
-* One-line API for pre-caching operators for in-place operator evaluations
+  - Matrix-free operators with `FunctionOperator`
+  - Fast tensor product evaluation with `TensorProductOperator`
+  - Lazy algebra: addition, subtraction, multiplication, inverse, adjoint, and transpose
+  - Couple fast methods for operator evaluation with inversion via `InvertibleOperator`
+  - One-line API to update operator state depending on arbitrary parameters.
+  - Mutating and nonmutating update behavior (Zygote compatible)
+  - One-line API for pre-caching operators for in-place operator evaluations
 
 ## Contributing
 

docs/src/interface.md

@@ -5,22 +5,22 @@
 These are the formal properties that an `AbstractSciMLOperator` should obey
 for it to work in the solvers.
 
-1. An `AbstractSciMLOperator` represents a linear or nonlinear operator, with input/output
-   being `AbstractArray`s. Specifically, a SciMLOperator, `L`, of size `(M, N)` accepts an
-   input argument `u` with leading length `N`, i.e. `size(u, 1) == N`, and returns an
-   `AbstractArray` of the same dimension with leading length `M`, i.e. `size(L * u, 1) == M`.
-2. SciMLOperators can be applied to an `AbstractArray` via overloaded `Base.*`, or
-   the in-place `LinearAlgebra.mul!`. Additionally, operators are allowed to be time,
-   or parameter dependent. The state of a SciMLOperator can be updated by calling
-   the mutating function `update_coefficients!(L, u, p, t)` where `p` represents
-   parameters, and `t`, time.  Calling a SciMLOperator as `L(du, u, p, t)` or out-of-place
-   `L(u, p, t)` will automatically update the state of `L` before applying it to `u`.
-   `L(u, p, t)` is the same operation as `L(u, p, t) * u`.
-3. To support the update functionality, we have lazily implemented a comprehensive operator
-   algebra. That means a user can add, subtract, scale, compose and invert SciMLOperators,
-   and the state of the resultant operator would be updated as expected upon calling
-   `L(du, u, p, t)` or `L(u, p, t)` so long as an update function is provided for the
-   component operators.
+ 1. An `AbstractSciMLOperator` represents a linear or nonlinear operator, with input/output
+    being `AbstractArray`s. Specifically, a SciMLOperator, `L`, of size `(M, N)` accepts an
+    input argument `u` with leading length `N`, i.e. `size(u, 1) == N`, and returns an
+    `AbstractArray` of the same dimension with leading length `M`, i.e. `size(L * u, 1) == M`.
+ 2. SciMLOperators can be applied to an `AbstractArray` via overloaded `Base.*`, or
+    the in-place `LinearAlgebra.mul!`. Additionally, operators are allowed to be time,
+    or parameter dependent. The state of a SciMLOperator can be updated by calling
+    the mutating function `update_coefficients!(L, u, p, t)` where `p` represents
+    parameters, and `t`, time.  Calling a SciMLOperator as `L(du, u, p, t)` or out-of-place
+    `L(u, p, t)` will automatically update the state of `L` before applying it to `u`.
+    `L(u, p, t)` is the same operation as `L(u, p, t) * u`.
+ 3. To support the update functionality, we have lazily implemented a comprehensive operator
+    algebra. That means a user can add, subtract, scale, compose and invert SciMLOperators,
+    and the state of the resultant operator would be updated as expected upon calling
+    `L(du, u, p, t)` or `L(u, p, t)` so long as an update function is provided for the
+    component operators.
 
 ## Overloaded Traits
 
@@ -31,9 +31,9 @@ passed to linear solver packages, and even to ordinary differential
 equation solvers. The list of overloads to the `AbstractMatrix`
 interface includes, but is not limited to, the following:
 
-- `Base: size, zero, one, +, -, *, /, \, ∘, inv, adjoint, transpose, convert`
-- `LinearAlgebra: mul!, ldiv!, lmul!, rmul!, factorize, issymmetric, ishermitian, isposdef`
-- `SparseArrays: sparse, issparse`
+  - `Base: size, zero, one, +, -, *, /, \, ∘, inv, adjoint, transpose, convert`
+  - `LinearAlgebra: mul!, ldiv!, lmul!, rmul!, factorize, issymmetric, ishermitian, isposdef`
+  - `SparseArrays: sparse, issparse`
 
 ## Multidimension arrays and batching
 
@@ -112,7 +112,7 @@ t = rand()
 # in-place update
 _A = rand(N, N)
 _d = rand(N)
-mat_update_func!  = (A, u, p, t) -> (copy!(A, _A); lmul!(t, A); nothing)
+mat_update_func! = (A, u, p, t) -> (copy!(A, _A); lmul!(t, A); nothing)
 diag_update_func! = (diag, u, p, t) -> copy!(diag, N)
 
 M = MatrixOperator(zero(N, N); update_func! = mat_update_func!)
@@ -143,7 +143,7 @@ reason, we allow update functions with arbitrary keyword arguments.
 mat_update_func = (A, u, p, t; scale = 0.0) -> scale * (p * p')
 
 M = MatrixOperator(zero(N, N); update_func = mat_update_func,
-                   accepted_kwargs = (:state,))
+    accepted_kwargs = (:state,))
 
 M(u, p, t) == zeros(N) # true
 M(u, p, t; scale = 1.0) != zero(N)
@@ -179,22 +179,22 @@ has_ldiv!
 ## Note About Affine Operators
 
 Affine operators are operators that have the action `Q*x = A*x + b`. These operators have
-no matrix representation, since if there was, it would be a linear operator instead of an 
-affine operator. You can only represent an affine operator as a linear operator in a 
-dimension of one larger via the operation: `[A b] * [u;1]`, so it would require something modified 
+no matrix representation, since if there was, it would be a linear operator instead of an
+affine operator. You can only represent an affine operator as a linear operator in a
+dimension of one larger via the operation: `[A b] * [u;1]`, so it would require something modified
 to the input as well. As such, affine operators are a distinct generalization of linear operators.
 
-While it seems like it might doom the idea of using matrix-free affine operators, it turns out 
+While it seems like it might doom the idea of using matrix-free affine operators, it turns out
 that affine operators can be used in all cases where matrix-free linear solvers are used due to
-an easy generalization of the standard convergence proofs. If Q is the affine operator 
-``Q(x) = Ax + b``, then solving ``Qx = c`` is equivalent to solving ``Ax + b = c`` or ``Ax = c-b``. 
-If you now do this same “plug-and-chug” handling of the affine operator into the GMRES/CG/etc. 
-convergence proofs, move the affine part to the rhs residual, and show it converges to solving 
-``Ax = c-b``, and thus GMRES/CG/etc. solves ``Q(x) = c`` for an affine operator properly. 
-
-That same trick can be used mostly anywhere you would've had a linear operator to extend 
-the proof to affine operators, so then ``exp(A*t)*v`` operations via Krylov methods work for A being 
-affine as well, and all sorts of things. Thus, affine operators have no matrix representation, but they 
+an easy generalization of the standard convergence proofs. If Q is the affine operator
+``Q(x) = Ax + b``, then solving ``Qx = c`` is equivalent to solving ``Ax + b = c`` or ``Ax = c-b``.
+If you now do this same “plug-and-chug” handling of the affine operator into the GMRES/CG/etc.
+convergence proofs, move the affine part to the rhs residual, and show it converges to solving
+``Ax = c-b``, and thus GMRES/CG/etc. solves ``Q(x) = c`` for an affine operator properly.
+
+That same trick can be used mostly anywhere you would've had a linear operator to extend
+the proof to affine operators, so then ``exp(A*t)*v`` operations via Krylov methods work for A being
+affine as well, and all sorts of things. Thus, affine operators have no matrix representation, but they
 are still compatible with essentially any Krylov method, which would otherwise be compatible with
 matrix-free representations, hence their support in the SciMLOperators interface.
 
@@ -206,14 +206,16 @@ state through arbitrary keyword arguments to `update_coefficients!`. When the ca
 For the [premade SciMLOperators](premade_operators.md), one can specify the keyword arguments used by an operator with an `accepted_kwargs` argument (by default, none are passed).
 
 In the below example, we create an operator that gleefully ignores `u`, `p`, and `t` and uses its own special scaling.
+
 ```@example
 using SciMLOperators
 
-γ = ScalarOperator(0.0; update_func=(a, u, p, t; my_special_scaling) -> my_special_scaling,
-                   accepted_kwargs=(:my_special_scaling,))
+γ = ScalarOperator(0.0;
+    update_func = (a, u, p, t; my_special_scaling) -> my_special_scaling,
+    accepted_kwargs = (:my_special_scaling,))
 
 # Update coefficients, then apply operator
-update_coefficients!(γ, nothing, nothing, nothing; my_special_scaling=7.0)
+update_coefficients!(γ, nothing, nothing, nothing; my_special_scaling = 7.0)
 @show γ * [2.0]
 
 # Use operator application form

docs/src/premade_operators.md

@@ -21,6 +21,7 @@ SciMLOperators.AddedScalarOperator
 SciMLOperators.ComposedScalarOperator
 SciMLOperators.InvertedScalarOperator
 ```
+
 ## Lazy Operator Combination
 
 ```@docs

docs/src/sciml.md

@@ -32,8 +32,9 @@ an extended operator interface with all of these properties, hence the
 `AbstractSciMLOperator` interface.
 
 Some packages providing similar functionality are
-* [LinearMaps.jl](https://github.com/JuliaLinearAlgebra/LinearMaps.jl)
-* [`DiffEqOperators.jl`](https://github.com/SciML/DiffEqOperators.jl/tree/master) (deprecated)
+
+  - [LinearMaps.jl](https://github.com/JuliaLinearAlgebra/LinearMaps.jl)
+  - [`DiffEqOperators.jl`](https://github.com/SciML/DiffEqOperators.jl/tree/master) (deprecated)
 
 ## Interoperability and extended Julia ecosystem
 
@@ -58,10 +59,11 @@ We provide below a list of packages that make use of `SciMLOperators`.
 If you are using `SciMLOperators` in your work, feel free to create a PR
 and add your package to this list.
 
-* [`SciML.ai`](https://sciml.ai/) ecosystem: `SciMLOperators` is compatible with, and utilized by every `SciML` package.
-* [`CalculustJL`](https://github.com/CalculustJL) packages use `SciMLOperators` to define matrix-free vector-calculus operators for solving partial differential equations.
-    * [`CalculustCore.jl`](https://github.com/CalculustJL/CalculustCore.jl)
-    * [`FourierSpaces.jl`](https://github.com/CalculustJL/FourierSpaces.jl)
-    * [`NodalPolynomialSpaces.jl`](https://github.com/CalculustJL/NodalPolynomialSpaces.jl)
-* `SparseDiffTools.jl`
+  - [`SciML.ai`](https://sciml.ai/) ecosystem: `SciMLOperators` is compatible with, and utilized by every `SciML` package.
 
+  - [`CalculustJL`](https://github.com/CalculustJL) packages use `SciMLOperators` to define matrix-free vector-calculus operators for solving partial differential equations.
+    
+      + [`CalculustCore.jl`](https://github.com/CalculustJL/CalculustCore.jl)
+      + [`FourierSpaces.jl`](https://github.com/CalculustJL/FourierSpaces.jl)
+      + [`NodalPolynomialSpaces.jl`](https://github.com/CalculustJL/NodalPolynomialSpaces.jl)
+  - `SparseDiffTools.jl`

docs/src/tutorials/fftw.md

@@ -110,5 +110,3 @@ Dx = F \ ik * F
 ≈(Dx * u, du; atol = 1.0e-8) = true
 ≈(mul!(copy(u), Dx, u), du; atol = 1.0e-8) = true
 ```
-
-