clean up docs

Author: vpuri3

docs/src/interface.md

@@ -9,39 +9,30 @@ for it to work in the solvers.
    being `AbstractArray`s. Specifically, a SciMLOperator, `L`, of size `(M,N)` accepts
    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`.
-   Internally, `L` lazily reshapes `u` to a matrix of size `(N, length(u) \div N)` and
-   independently acts on the column-vectors. The reshape operation is skipped for
-   `AbstractVecOrMat` arguments.
 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` representes
    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.
-4. Out of place `L = update_coefficients(L, u, p, t)`
-   
 
 ## AbstractSciMLOperator Interface Description
 
+1. `AbstractSciMLLinearOperator <: AbstractSciMLOperator`
+2. `AbstractSciMLScalarOperator <: AbstractSciMLLinearOperator`
 3. `isconstant(A)` trait for whether the operator is constant or not.
-
-2. Can absorb under multiplication by a scalar. In all algorithms things like
-   `dt*L` show up all the time, so the linear operator must be able to absorb
-   such constants.
-4. `isconstant(A)` trait for whether the operator is constant or not.
-5. Optional: `diagonal`, `symmetric`, etc traits from LinearMaps.jl.
-6. Optional: `exp(A)`. Required for simple exponential integration.
-7. Optional: `expv(A,u,t) = exp(t*A)*u` and `expv!(v,A::AbstractSciMLOperator,u,t)`
+4. Optional: `exp(A)`. Required for simple exponential integration.
+5. Optional: `expv(A,u,t) = exp(t*A)*u` and `expv!(v,A::AbstractSciMLOperator,u,t)`
    Required for sparse-saving exponential integration.
-8. Optional: factorizations. `ldiv!`, `factorize` et. al. This is only required
+6. Optional: factorizations. `ldiv!`, `factorize` et. al. This is only required
    for algorithms which use the factorization of the operator (Crank-Nicolson),
    and only for when the default linear solve is used.
-1. `AbstractSciMLLinearOperator <: AbstractSciMLOperator`
 
 ## Note About Affine Operators
 

src/batch.jl

@@ -1,4 +1,13 @@
 #
+"""
+    BatchedDiagonalOperator(diag, [; update_func])
+
+Represents a time-dependent elementwise scaling (diagonal-scaling) operation.
+Acts on `AbstractArray`s of the same size as `diag`. The update function is called
+by `update_coefficients!` and is assumed to have the following signature:
+
+    update_func(diag::AbstractVector,u,p,t) -> [modifies diag]
+"""
 struct BatchedDiagonalOperator{T,D,F} <: AbstractSciMLLinearOperator{T}
     diag::D
     update_func::F

src/interface.jl

@@ -89,24 +89,8 @@ has_mul!(L::AbstractSciMLOperator) = false # mul!(du, L, u)
 has_ldiv(L::AbstractSciMLOperator) = false # du = L\u
 has_ldiv!(L::AbstractSciMLOperator) = false # ldiv!(du, L, u)
 
-### AbstractSciMLLinearOperator Interface
-
-#=
-1. AbstractSciMLLinearOperator <: AbstractSciMLOperator
-2. Can absorb under multiplication by a scalar. In all algorithms things like
-   dt*L show up all the time, so the linear operator must be able to absorb
-   such constants.
-4. isconstant(A) trait for whether the operator is constant or not.
-5. Optional: diagonal, symmetric, etc traits from LinearMaps.jl.
-6. Optional: exp(A). Required for simple exponential integration.
-7. Optional: expmv(A,u,p,t) = exp(t*A)*u and expmv!(v,A::SciMLOperator,u,p,t)
-   Required for sparse-saving exponential integration.
-8. Optional: factorizations. A_ldiv_B, factorize et. al. This is only required
-   for algorithms which use the factorization of the operator (Crank-Nicholson),
-   and only for when the default linear solve is used.
-=#
-
-# Extra standard assumptions
+### Extra standard assumptions
+
 isconstant(L) = true
 isconstant(L::AbstractSciMLOperator) = all(isconstant, getops(L))
 #isconstant(L::AbstractSciMLOperator) = L.update_func = DEFAULT_UPDATE_FUNC

src/matrix.jl

@@ -1,3 +1,4 @@
+#
 """
     MatrixOperator(A[; update_func])
 
@@ -83,8 +84,7 @@ LinearAlgebra.ldiv!(v::AbstractVecOrMat, L::MatrixOperator, u::AbstractVecOrMat)
 LinearAlgebra.ldiv!(L::MatrixOperator, u::AbstractVecOrMat) = ldiv!(L.A, u)
 
 """
-```julia
-DiagonalOperator(diag, [; update_func])
+    DiagonalOperator(diag, [; update_func])
 
 Represents a time-dependent elementwise scaling (diagonal-scaling) operation.
 The update function is called by `update_coefficients!` and is assumed to have