diff --git a/previews/PR351/.documenter-siteinfo.json b/previews/PR351/.documenter-siteinfo.json index fbeae19..be79c7c 100644 --- a/previews/PR351/.documenter-siteinfo.json +++ b/previews/PR351/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.11.1","generation_timestamp":"2024-10-16T22:56:40","documenter_version":"1.7.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.5","generation_timestamp":"2024-10-16T23:01:59","documenter_version":"1.7.0"}} \ No newline at end of file diff --git a/previews/PR351/index.html b/previews/PR351/index.html index e80983f..5160fdb 100644 --- a/previews/PR351/index.html +++ b/previews/PR351/index.html @@ -4,8 +4,8 @@ A = rand(5,5) opA = LinearOperator(A) A[:,1] * 3 isa Vector
true
opA[:,1] * 3 isa LinearOperator
true
opA[:,1] * [3] isa Vector
true

However, the following returns an error

A[:,1] * [3]

This is also true for A[i,:], which would return a vector and for the scalar A[i,j]. Similarly, opA[1,1] is an operator of size (1,1):"

(opA[1,1] * [3])[1] - A[1,1] * 3
0.0

In the same spirit, the operator Matrix always returns a matrix.

Matrix(opA[:,1])
5×1 Matrix{Float64}:
- 0.5385236013866544
- 0.2419821338179703
- 0.4521510406884469
- 0.3325867599933612
- 0.3479794805586769

Other Operators

Testing

julia> Pkg.test("LinearOperators")

Bug reports and discussions

If you think you found a bug, feel free to open an issue. Focused suggestions and requests can also be opened as issues. Before opening a pull request, start an issue or a discussion on the topic, please.

If you want to ask a question not suited for a bug report, feel free to start a discussion here. This forum is for general discussion about this repository and the JuliaSmoothOptimizers organization, so questions about any of our packages are welcome.

+ 0.45204029278593383 + 0.8522006435505273 + 0.4730669148582347 + 0.8138138058191658 + 0.37645768127519086

Other Operators

Testing

julia> Pkg.test("LinearOperators")

Bug reports and discussions

If you think you found a bug, feel free to open an issue. Focused suggestions and requests can also be opened as issues. Before opening a pull request, start an issue or a discussion on the topic, please.

If you want to ask a question not suited for a bug report, feel free to start a discussion here. This forum is for general discussion about this repository and the JuliaSmoothOptimizers organization, so questions about any of our packages are welcome.

diff --git a/previews/PR351/reference/index.html b/previews/PR351/reference/index.html index eae4cd4..f561388 100644 --- a/previews/PR351/reference/index.html +++ b/previews/PR351/reference/index.html @@ -1,7 +1,7 @@ -Reference · LinearOperators.jl
GitHub

Reference

Contents

Index

Base.Matrix — Method
A = Matrix(op)

Materialize an operator as a dense array using op.ncol products.

source
LinearOperators.DiagonalAndrei — Type
DiagonalAndrei(d)

Construct a linear operator that represents a diagonal quasi-Newton approximation as described in

Andrei, N. A diagonal quasi-Newton updating method for unconstrained optimization. https://doi.org/10.1007/s11075-018-0562-7

The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.

Arguments

  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalAndrei — Method
DiagonalAndrei(d)

Construct a linear operator that represents a diagonal quasi-Newton approximation as described in

Andrei, N. A diagonal quasi-Newton updating method for unconstrained optimization. https://doi.org/10.1007/s11075-018-0562-7

The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.

Arguments

  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalPSB — Type
DiagonalPSB(d)

Construct a linear operator that represents a diagonal PSB quasi-Newton approximation as described in

M. Zhu, J. L. Nazareth and H. Wolkowicz The Quasi-Cauchy Relation and Diagonal Updating. SIAM Journal on Optimization, vol. 9, number 4, pp. 1192-1204, 1999. https://doi.org/10.1137/S1052623498331793.

The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.

Arguments

  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalPSB — Method
DiagonalPSB(d)

Construct a linear operator that represents a diagonal PSB quasi-Newton approximation as described in

M. Zhu, J. L. Nazareth and H. Wolkowicz The Quasi-Cauchy Relation and Diagonal Updating. SIAM Journal on Optimization, vol. 9, number 4, pp. 1192-1204, 1999. https://doi.org/10.1137/S1052623498331793.

The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.

Arguments

  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.LBFGSOperator — Method
LBFGSOperator(T, n; [mem=5, scaling=true])
-LBFGSOperator(n; [mem=5, scaling=true])

Construct a limited-memory BFGS approximation in forward form. If the type T is omitted, then Float64 is used.

source
LinearOperators.LSR1Operator — Method
LSR1Operator(T, n; [mem=5, scaling=false)
-LSR1Operator(n; [mem=5, scaling=false)

Construct a limited-memory SR1 approximation in forward form. If the type T is omitted, then Float64 is used.

source
LinearOperators.LinearOperator — Type

Base type to represent a linear operator. The usual arithmetic operations may be applied to operators to combine or otherwise alter them. They can be combined with other operators, with matrices and with scalars. Operators may be transposed and conjugate-transposed using the usual Julia syntax.

source
LinearOperators.LinearOperator — Method
LinearOperator(M::AbstractMatrix{T}; symmetric=false, hermitian=false, S = Vector{T}) where {T}

Construct a linear operator from a dense or sparse matrix. Use the optional keyword arguments to indicate whether the operator is symmetric and/or hermitian. Change S to use LinearOperators on GPU.

source
LinearOperators.LinearOperator — Method
LinearOperator(type::Type{T}, nrow, ncol, symmetric, hermitian, prod!,
+Reference · LinearOperators.jl
GitHub
Reference
Contents
Index
Base.Matrix — Method
A = Matrix(op)
Materialize an operator as a dense array using op.ncol products.
source
LinearOperators.DiagonalAndrei — Type
DiagonalAndrei(d)
Construct a linear operator that represents a diagonal quasi-Newton approximation as described in
Andrei, N. A diagonal quasi-Newton updating method for unconstrained optimization. https://doi.org/10.1007/s11075-018-0562-7
The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.
Arguments
  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalAndrei — Method
DiagonalAndrei(d)
Construct a linear operator that represents a diagonal quasi-Newton approximation as described in
Andrei, N. A diagonal quasi-Newton updating method for unconstrained optimization. https://doi.org/10.1007/s11075-018-0562-7
The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.
Arguments
  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalPSB — Type
DiagonalPSB(d)
Construct a linear operator that represents a diagonal PSB quasi-Newton approximation as described in
M. Zhu, J. L. Nazareth and H. Wolkowicz The Quasi-Cauchy Relation and Diagonal Updating. SIAM Journal on Optimization, vol. 9, number 4, pp. 1192-1204, 1999. https://doi.org/10.1137/S1052623498331793.
The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.
Arguments
  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.DiagonalPSB — Method
DiagonalPSB(d)
Construct a linear operator that represents a diagonal PSB quasi-Newton approximation as described in
M. Zhu, J. L. Nazareth and H. Wolkowicz The Quasi-Cauchy Relation and Diagonal Updating. SIAM Journal on Optimization, vol. 9, number 4, pp. 1192-1204, 1999. https://doi.org/10.1137/S1052623498331793.
The approximation satisfies the weak secant equation and is not guaranteed to be positive definite.
Arguments
  • d::AbstractVector: initial diagonal approximation.
source
LinearOperators.LBFGSOperator — Method
LBFGSOperator(T, n; [mem=5, scaling=true])
+LBFGSOperator(n; [mem=5, scaling=true])
Construct a limited-memory BFGS approximation in forward form. If the type T is omitted, then Float64 is used.
source
LinearOperators.LSR1Operator — Method
LSR1Operator(T, n; [mem=5, scaling=false)
+LSR1Operator(n; [mem=5, scaling=false)
Construct a limited-memory SR1 approximation in forward form. If the type T is omitted, then Float64 is used.
source
LinearOperators.LinearOperator — Type
Base type to represent a linear operator. The usual arithmetic operations may be applied to operators to combine or otherwise alter them. They can be combined with other operators, with matrices and with scalars. Operators may be transposed and conjugate-transposed using the usual Julia syntax.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::AbstractMatrix{T}; symmetric=false, hermitian=false, S = Vector{T}) where {T}
Construct a linear operator from a dense or sparse matrix. Use the optional keyword arguments to indicate whether the operator is symmetric and/or hermitian. Change S to use LinearOperators on GPU.
source
LinearOperators.LinearOperator — Method
LinearOperator(type::Type{T}, nrow, ncol, symmetric, hermitian, prod!,
                 [tprod!=nothing, ctprod!=nothing],
                 S = Vector{T}) where {T}
Construct a linear operator from functions where the type is specified as the first argument. Change S to use LinearOperators on GPU. Notice that the linear operator does not enforce the type, so using a wrong type can result in errors. For instance,
A = [im 1.0; 0.0 1.0] # Complex matrix
 function mulOp!(res, M, v, α, β)
@@ -23,26 +23,26 @@
                     (res, v, α, β) -> mulSquareOpDiagonal!(res, d, v, α, β))
It is possible to create an operator with the 3-args mul!. In this case, using the 5-args mul! will generate storage vectors.
A = rand(2, 2)
 op = LinearOperator(Float64, 2, 2, false, false, 
                     (res, v) -> mul!(res, A, v),
-                    (res, w) -> mul!(res, A', w))
The 3-args mul! also works when applying the operator on a matrix.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::Hermitian{T}, S = Vector{T}) where {T}
Constructs a linear operator from a Hermitian matrix. If its elements are real, it is also symmetric. Change S to use LinearOperators on GPU.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::SymTridiagonal{T}, S = Vector{T}) where {T}
Constructs a linear operator from a symmetric tridiagonal matrix. If its elements are real, it is also Hermitian, otherwise complex symmetric. Change S to use LinearOperators on GPU.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::Symmetric{T}, S = Vector{T}) where {T <: Real} =
Construct a linear operator from a symmetric real square matrix M. Change S to use LinearOperators on GPU.
source
LinearOperators.SpectralGradient — Type
Implementation of a spectral gradient quasi-Newton approximation described in
Birgin, E. G., Martínez, J. M., & Raydan, M. Spectral Projected Gradient Methods: Review and Perspectives. https://doi.org/10.18637/jss.v060.i03
source
LinearOperators.SpectralGradient — Method
    SpectralGradient(σ, n)
Construct a spectral gradient Hessian approximation. The approximation is defined as σI.
Arguments
  • σ::Real: initial positive multiple of the identity;
  • n::Int: operator size.
source
LinearOperators.opEye — Type
opEye()
Identity operator.
opI = opEye()
+                    (res, w) -> mul!(res, A', w))
The 3-args mul! also works when applying the operator on a matrix.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::Hermitian{T}, S = Vector{T}) where {T}
Constructs a linear operator from a Hermitian matrix. If its elements are real, it is also symmetric. Change S to use LinearOperators on GPU.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::SymTridiagonal{T}, S = Vector{T}) where {T}
Constructs a linear operator from a symmetric tridiagonal matrix. If its elements are real, it is also Hermitian, otherwise complex symmetric. Change S to use LinearOperators on GPU.
source
LinearOperators.LinearOperator — Method
LinearOperator(M::Symmetric{T}, S = Vector{T}) where {T <: Real} =
Construct a linear operator from a symmetric real square matrix M. Change S to use LinearOperators on GPU.
source
LinearOperators.SpectralGradient — Type
Implementation of a spectral gradient quasi-Newton approximation described in
Birgin, E. G., Martínez, J. M., & Raydan, M. Spectral Projected Gradient Methods: Review and Perspectives. https://doi.org/10.18637/jss.v060.i03
source
LinearOperators.SpectralGradient — Method
    SpectralGradient(σ, n)
Construct a spectral gradient Hessian approximation. The approximation is defined as σI.
Arguments
  • σ::Real: initial positive multiple of the identity;
  • n::Int: operator size.
source
LinearOperators.opEye — Method
opEye(T, n; S = Vector{T})
-opEye(n)
Identity operator of order n and of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.opEye — Method
opEye(T, nrow, ncol; S = Vector{T})
-opEye(nrow, ncol)
Rectangular identity operator of size nrowxncol and of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
Base.kron — Method
kron(A, B)
Kronecker tensor product of A and B in linear operator form, if either or both are linear operators. If both A and B are matrices, then Base.kron is used.
source
Base.push! — Method
push!(op, s, y)
Push a new {s,y} pair into a L-SR1 operator.
source
LinearOperators.opEye — Method
opEye(T, n; S = Vector{T})
+opEye(n)
Identity operator of order n and of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.opEye — Method
opEye(T, nrow, ncol; S = Vector{T})
+opEye(nrow, ncol)
Rectangular identity operator of size nrowxncol and of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
Base.kron — Method
kron(A, B)
Kronecker tensor product of A and B in linear operator form, if either or both are linear operators. If both A and B are matrices, then Base.kron is used.
source
Base.push! — Method
push!(op, s, y)
Push a new {s,y} pair into a L-SR1 operator.
source
Base.push! — Method
push!(op, s, y)
 push!(op, s, y, Bs)
 push!(op, s, y, α, g)
-push!(op, s, y, α, g, Bs)
Push a new {s,y} pair into a L-BFGS operator. The second calling sequence is used for forward updating damping, using the preallocated vector Bs. If the operator is damped, the first call will create Bs and call the second call. The third and fourth calling sequences are used in inverse LBFGS updating in conjunction with damping, where α is the most recent steplength and g the gradient used when solving d=-Hg.
source
Base.show — Method
show(io, op)
Display basic information about a linear operator.
source
Base.size — Method
m = size(op, d)
Return the size of a linear operator along dimension d.
source
Base.size — Method
m, n = size(op)
Return the size of a linear operator as a tuple.
source
LinearOperators.BlockDiagonalOperator — Method
BlockDiagonalOperator(M1, M2, ..., Mn; S = promote_type(storage_type.(M1, M2, ..., Mn)))
Creates a block-diagonal linear operator:
[ M1           ]
+push!(op, s, y, α, g, Bs)
Push a new {s,y} pair into a L-BFGS operator. The second calling sequence is used for forward updating damping, using the preallocated vector Bs. If the operator is damped, the first call will create Bs and call the second call. The third and fourth calling sequences are used in inverse LBFGS updating in conjunction with damping, where α is the most recent steplength and g the gradient used when solving d=-Hg.
source
Base.show — Method
show(io, op)
Display basic information about a linear operator.
source
Base.size — Method
m = size(op, d)
Return the size of a linear operator along dimension d.
source
Base.size — Method
m, n = size(op)
Return the size of a linear operator as a tuple.
source
LinearOperators.BlockDiagonalOperator — Method
BlockDiagonalOperator(M1, M2, ..., Mn; S = promote_type(storage_type.(M1, M2, ..., Mn)))
Creates a block-diagonal linear operator:
[ M1           ]
 [    M2        ]
 [       ...    ]
-[           Mn ]
Change S to use LinearOperators on GPU.
source
LinearOperators.InverseLBFGSOperator — Method
InverseLBFGSOperator(T, n, [mem=5; scaling=true])
-InverseLBFGSOperator(n, [mem=5; scaling=true])
Construct a limited-memory BFGS approximation in inverse form. If the type T is omitted, then Float64 is used.
source
LinearOperators.has_args5 — Method
has_args5(op)
Determine whether the operator can work with the 5-args mul!. If false, storage vectors will be generated at the first call of the 5-args mul!. No additional vectors are generated when using the 3-args mul!.
source
LinearOperators.normest — Function
normest(S) estimates the matrix 2-norm of S. This function is an adaptation of Matlab's built-in NORMEST. This method allocates.
Inputs:   S –- Matrix or LinearOperator type,    tol –-  relative error tol, default(or -1) Machine eps   maxiter –- maximum iteration, default 100
Returns:   e –- the estimated norm   cnt –- the number of iterations used
source
LinearOperators.opCholesky — Method
opCholesky(M, [check=false])
Inverse of a Hermitian and positive definite matrix as a linear operator using its Cholesky factorization.  The factorization is computed only once. The optional check argument will perform cheap hermicity and definiteness checks. This Operator is not in-place when using mul!.
source
LinearOperators.opExtension — Method
Z = opExtension(I, ncol)
-Z = opExtension(:, ncol)
Creates a LinearOperator extending a vector of size length(I) to size ncol, where the position of the elements on the new vector are given by the indices I. The operation w = Z * v is equivalent to w = zeros(ncol); w[I] = v.
Z = opExtension(k, ncol)
Alias for opExtension([k], ncol).
source
LinearOperators.opInverse — Method
opInverse(M; symm=false, herm=false)
Inverse of a matrix as a linear operator using \. Useful for triangular matrices. Note that each application of this operator applies \. This Operator is not in-place when using mul!.
source
LinearOperators.opLDL — Function
opLDL(M, [check=false])
Inverse of a symmetric matrix as a linear operator using its LDLᵀ factorization if it exists. The factorization is computed only once. The optional check argument will perform a cheap hermicity check.
If M is sparse and real, then only the upper triangle should be stored in order to use  LDLFactorizations.jl:
using LDLFactorizations
+[           Mn ]
Change S to use LinearOperators on GPU.
source
LinearOperators.InverseLBFGSOperator — Method
InverseLBFGSOperator(T, n, [mem=5; scaling=true])
+InverseLBFGSOperator(n, [mem=5; scaling=true])
Construct a limited-memory BFGS approximation in inverse form. If the type T is omitted, then Float64 is used.
source
LinearOperators.has_args5 — Method
has_args5(op)
Determine whether the operator can work with the 5-args mul!. If false, storage vectors will be generated at the first call of the 5-args mul!. No additional vectors are generated when using the 3-args mul!.
source
LinearOperators.normest — Function
normest(S) estimates the matrix 2-norm of S. This function is an adaptation of Matlab's built-in NORMEST. This method allocates.
Inputs:   S –- Matrix or LinearOperator type,    tol –-  relative error tol, default(or -1) Machine eps   maxiter –- maximum iteration, default 100
Returns:   e –- the estimated norm   cnt –- the number of iterations used
source
LinearOperators.opCholesky — Method
opCholesky(M, [check=false])
Inverse of a Hermitian and positive definite matrix as a linear operator using its Cholesky factorization.  The factorization is computed only once. The optional check argument will perform cheap hermicity and definiteness checks. This Operator is not in-place when using mul!.
source
LinearOperators.opExtension — Method
Z = opExtension(I, ncol)
+Z = opExtension(:, ncol)
Creates a LinearOperator extending a vector of size length(I) to size ncol, where the position of the elements on the new vector are given by the indices I. The operation w = Z * v is equivalent to w = zeros(ncol); w[I] = v.
Z = opExtension(k, ncol)
Alias for opExtension([k], ncol).
source
LinearOperators.opInverse — Method
opInverse(M; symm=false, herm=false)
Inverse of a matrix as a linear operator using \. Useful for triangular matrices. Note that each application of this operator applies \. This Operator is not in-place when using mul!.
source
LinearOperators.opLDL — Function
opLDL(M, [check=false])
Inverse of a symmetric matrix as a linear operator using its LDLᵀ factorization if it exists. The factorization is computed only once. The optional check argument will perform a cheap hermicity check.
If M is sparse and real, then only the upper triangle should be stored in order to use  LDLFactorizations.jl:
using LDLFactorizations
 triu!(M)
-opLDL(Symmetric(M, :U))
source
LinearOperators.opOnes — Method
opOnes(T, nrow, ncol; S = Vector{T})
-opOnes(nrow, ncol)
Operator of all ones of size nrow-by-ncol of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.opRestriction — Method
Z = opRestriction(I, ncol)
-Z = opRestriction(:, ncol)
Creates a LinearOperator restricting a ncol-sized vector to indices I. The operation Z * v is equivalent to v[I]. I can be :.
Z = opRestriction(k, ncol)
Alias for opRestriction([k], ncol).
source
LinearOperators.opZeros — Method
opZeros(T, nrow, ncol; S = Vector{T})
-opZeros(nrow, ncol)
Zero operator of size nrow-by-ncol, of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.solve_shifted_system! — Method
solveshiftedsystem!(x, B,  b, σ)
Solve linear system (B + σI) x = b, where B is a forward L-BFGS operator and σ ≥ 0.
Parameters
  • x::AbstractVector{T}: preallocated vector of length n that is used to store the solution x.
  • B::LBFGSOperator: forward L-BFGS operator that models a matrix of size n x n.
  • b::AbstractVector{T}: right-hand side vector of length n.
  • σ::T: nonnegative shift.
Returns
  • x::AbstractVector{T}: solution vector x of length n.
Method
The method uses a two-loop recursion-like approach with modifications to handle the shift σ.
Example
using Random
+opLDL(Symmetric(M, :U))
source
LinearOperators.opOnes — Method
opOnes(T, nrow, ncol; S = Vector{T})
+opOnes(nrow, ncol)
Operator of all ones of size nrow-by-ncol of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.opRestriction — Method
Z = opRestriction(I, ncol)
+Z = opRestriction(:, ncol)
Creates a LinearOperator restricting a ncol-sized vector to indices I. The operation Z * v is equivalent to v[I]. I can be :.
Z = opRestriction(k, ncol)
Alias for opRestriction([k], ncol).
source
LinearOperators.opZeros — Method
opZeros(T, nrow, ncol; S = Vector{T})
+opZeros(nrow, ncol)
Zero operator of size nrow-by-ncol, of data type T (defaults to Float64). Change S to use LinearOperators on GPU.
source
LinearOperators.solve_shifted_system! — Method
solveshiftedsystem!(x, B,  b, σ)
Solve linear system (B + σI) x = b, where B is a forward L-BFGS operator and σ ≥ 0.
Parameters
  • x::AbstractVector{T}: preallocated vector of length n that is used to store the solution x.
  • B::LBFGSOperator: forward L-BFGS operator that models a matrix of size n x n.
  • b::AbstractVector{T}: right-hand side vector of length n.
  • σ::T: nonnegative shift.
Returns
  • x::AbstractVector{T}: solution vector x of length n.
Method
The method uses a two-loop recursion-like approach with modifications to handle the shift σ.
Example
using Random
 
 # Problem setup
 n = 100  # size of the problem
@@ -68,4 +68,4 @@
 result = solve_shifted_system!(x, B, b, σ)
 
 # Check that the solution is close enough (residual test)
-@assert norm(B * x + σ * x - b) / norm(b) < 1e-8
References
Erway, J. B., Jain, V., & Marcia, R. F. Shifted L-BFGS Systems. Optimization Methods and Software, 29(5), pp. 992-1004, 2014.
source

+@assert norm(B * x + σ * x - b) / norm(b) < 1e-8

References

Erway, J. B., Jain, V., & Marcia, R. F. Shifted L-BFGS Systems. Optimization Methods and Software, 29(5), pp. 992-1004, 2014.

source
diff --git a/previews/PR351/tutorial/index.html b/previews/PR351/tutorial/index.html index 348dc7e..9d3507e 100644 --- a/previews/PR351/tutorial/index.html +++ b/previews/PR351/tutorial/index.html @@ -1,2 +1,2 @@ -Tutorial · LinearOperators.jl
GitHub
+Tutorial · LinearOperators.jl
GitHub