Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 5 additions & 3 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -18,9 +18,11 @@ to [bounds on $`\hat A`$'s eigenvalues](https://en.wikipedia.org/wiki/Gershgorin

The package provides O(mn) heuristics (`symcover`, `cover`), *soft* covers that
penalize violations (`soft_symcover`, `soft_cover`), and objective-minimal hard
covers (`symcover_min`, `cover_min`). The default penalties, squared-log for
hard covers and the power-mean penalty `PowerMean{2}` for soft covers, use
built-in solvers; other penalties use JuMP with HiGHS or Ipopt.
covers (`symcover_min`, `cover_min`). Penalties are functions of the log slack
`z = log(a[i]*b[j]) - log|A[i,j]|` of each nonzero entry. The defaults, the ℓ₂
penalty `AbsLog{2}` (`z^2`) for hard covers and the power-mean penalty
`PowerMean{2}` for soft covers, use built-in solvers; other penalties use JuMP
with HiGHS or Ipopt.

## Installation

Expand Down
4 changes: 2 additions & 2 deletions docs/src/index.md
Original file line number Diff line number Diff line change
Expand Up @@ -13,8 +13,8 @@ C_{ij} \;\geq\; |A_{ij}| \quad \text{for all } i, j.
```

For symmetric `A`, a single vector suffices (`b = a`). A matrix has many hard
covers; a *minimal cover* is the one that minimizes a chosen penalty on the gap
between `C` and `|A|`. A *soft cover* penalizes violations of the inequality
covers; a *minimal cover* is the one that minimizes a chosen penalty on the log
slack `log C[i,j] - log|A[i,j]|` of each nonzero entry. A *soft cover* penalizes violations of the inequality
instead of enforcing it.

## Installation
Expand Down
55 changes: 36 additions & 19 deletions docs/src/objectives.md
Original file line number Diff line number Diff line change
Expand Up @@ -7,27 +7,44 @@ CurrentModule = MatrixCovers
## Penalty functions

Any hard cover is valid, but tighter covers better capture the scaling of `A`.
The tightness of a cover is measured through the ratios
`r[i, j] = |A[i,j]| / (a[i] * b[j])`: a hard cover has every `0 ≤ r[i, j] ≤ 1`,
and `r[i, j] == 1` means the constraint is exactly tight.
The tightness of a cover is measured on each nonzero entry by the coverage ratio
`r[i, j] = |A[i,j]| / (a[i] * b[j])`, or equivalently by the log slack

A **penalty function** `ϕ` combines those ratios into a scalar objective:
```math
z_{ij} = \log(a_i b_j) - \log|A_{ij}| = -\log r_{ij}.
```

A hard cover has every `z[i, j] ≥ 0` (every `r[i, j] ≤ 1`), `z[i, j] == 0` means
the constraint is exactly tight, and `z[i, j] < 0` marks an entry the cover
violates.

A **penalty function** `ρ` combines the log slacks into a scalar objective, a
sum over the nonzero entries of `A`:

```math
\sum_{i,j} \phi\!\left(\frac{|A_{ij}|}{a_i\, b_j}\right).
E = \sum_{i,j:\, A_{ij} \ne 0} \rho(z_{ij}).
```

Three penalty families are provided:
Zero entries constrain nothing and are excluded from the sum. A nonzero entry
over a zero product `a[i] * b[j]` has `z = -∞`, and every built-in penalty is
infinite there.

Three penalty families are provided, all parameterized by an exponent `p`:

- [`AbsLog`](@ref)`{p}`: `ρ(z) = |z|^p`, the ℓ_p penalty on the log slacks.
`AbsLog{1}` gives the ℓ₁ objective, a linear program, and `AbsLog{2}` the ℓ₂
objective, whose minimizer among hard covers is the ℓ₂-minimal cover. It is
convex in log space, and `AbsLog{2}` is the default for hard covers.
- [`PowerMean`](@ref)`{p}`: `ρ(z) = (exp(-p z) - 1 + p z)/p`, which is
`(r^p - 1 - p log r)/p` in the ratio. It is strictly convex in log space and
power-mean `p = 2` is the default for soft covers. Its minimizer makes the
mean of `r^p` over the nonzero entries of every row and column equal to one.
- [`AbsLinear`](@ref)`{p}`: `ρ(z) = |1 - exp(-z)|^p`, which is `|1 - r|^p` in
the ratio. It is nonconvex. On entries the cover satisfies it is at most one,
approaching one as `r → 0`, so a small entry costs a soft cover at most a
bounded amount; an exact zero is excluded from the sum and costs nothing.

- [`AbsLog`](@ref)`{p}`: `ϕ(r) = |log r|^p`, with `ϕ(0) = 0`. It is convex in
log space and is the default for hard covers.
- [`PowerMean`](@ref)`{p}`: `ϕ(r) = (r^p - 1 - p log r)/p`, with `ϕ(0) = 0`. It
is strictly convex in log space and is the default for soft covers. Its
minimizer makes the mean of `r^p` over the nonzero entries of every row and
column equal to one.
- [`AbsLinear`](@ref)`{p}`: `ϕ(r) = |1-r|^p`. It is nonconvex but finite and
continuous at zero, so an entry that shrinks to zero drops out of the soft
cover continuously.
A penalty object is callable on a log slack: `AbsLog{2}()(z)` returns `z^2`.

[`cover_objective`](@ref) evaluates any penalty for a given cover:

Expand All @@ -41,10 +58,10 @@ julia> a = symcover(A)
2.0
4.0

julia> cover_objective(AbsLog{1}(), a, A) # sum of log-excesses (L1)
julia> cover_objective(AbsLog{1}(), a, A) # ℓ₁: sum of log slacks
2.772588722239781

julia> cover_objective(AbsLog{2}(), a, A) # sum of squared log-excesses (L2)
julia> cover_objective(AbsLog{2}(), a, A) # ℓ₂: sum of squared log slacks
3.843624111345611
```

Expand All @@ -68,8 +85,8 @@ their `_min` counterparts minimize the selected objective.
covers that are tight on a maximum-product transversal (see
[Transversals and conditioning](@ref)); with a `PowerMean{p}` penalty and a
`target` ratio `t`, it instead pushes the ratios of the entries off the
transversal toward `t`, minimizing `∑ t^p φ(r/t)` over them with `φ` the
`PowerMean{p}` penalty. Adding `maxbalance=true` replaces that objective within
transversal toward `t`, minimizing `∑ t^p ρ(z + log t)` over them with `ρ` the
`PowerMean{p}` penalty, which is least at `z = -log t`, where `r = t`. Adding `maxbalance=true` replaces that objective within
each fully indecomposable block by its `p → ∞` limit, max-balancing: across
every partition of a block's rows, the largest ratio in one direction equals
the largest in the other, which also minimizes the block's largest ratio. The
Expand Down
15 changes: 5 additions & 10 deletions ext/MatrixCoversIpoptExt.jl
Original file line number Diff line number Diff line change
Expand Up @@ -300,13 +300,12 @@ function MatrixCovers.soft_symcover!(::AbsLinear{2}, a::AbstractVector, A)
fi, fj, flog = _sym_edge_list(A, T)
supported = _degrees(fi, n) .> 0
ti, tj, tlog, tw = _triangle(fi, fj, flog)
n_zeros = n^2 - length(fi) # a zero entry contributes (1-0)^2 = 1 regardless of α

model = _ipopt_model(; unscaled=true)
start0 = [supported[k] ? log(T(a[pr[k]])) : zero(T) for k in 1:n]
@variable(model, α[k=1:n], start = start0[k])
@objective(model, Min,
sum(tw[k] * (1 - exp(tlog[k] - α[ti[k]] - α[tj[k]]))^2 for k in eachindex(ti)) + n_zeros)
sum(tw[k] * (1 - exp(tlog[k] - α[ti[k]] - α[tj[k]]))^2 for k in eachindex(ti)))
JuMP.optimize!(model)
stats = solved_stats(model, "soft_symcover!")
lα = JuMP.value.(α)
Expand All @@ -326,7 +325,6 @@ function MatrixCovers.soft_symcover!(::AbsLinear{1}, a::AbstractVector, A)
fi, fj, flog = _sym_edge_list(A, T)
supported = _degrees(fi, n) .> 0
ti, tj, tlog, tw = _triangle(fi, fj, flog)
n_zeros = n^2 - length(fi) # a zero entry contributes |1 - 0| = 1 regardless of α

model = _ipopt_model()
start0 = [supported[k] ? log(T(a[pr[k]])) : zero(T) for k in 1:n]
Expand All @@ -336,7 +334,7 @@ function MatrixCovers.soft_symcover!(::AbsLinear{1}, a::AbstractVector, A)
@constraint(model, 1 - exp(tlog[k] - α[ti[k]] - α[tj[k]]) <= t[k])
@constraint(model, -1 + exp(tlog[k] - α[ti[k]] - α[tj[k]]) <= t[k])
end
@objective(model, Min, sum(tw[k] * t[k] for k in eachindex(ti)) + n_zeros)
@objective(model, Min, sum(tw[k] * t[k] for k in eachindex(ti)))
JuMP.optimize!(model)
stats = solved_stats(model, "soft_symcover!")
lα = JuMP.value.(α)
Expand All @@ -349,8 +347,7 @@ end

# ============================================================
# Soft cover: soft_cover!(::AbsLinear{p}, a, b, A)
# Asymmetric soft-cover model. Post-processing balances component gauges; zero
# entries contribute the constant `ϕ(0) = 1`.
# Asymmetric soft-cover model. Post-processing balances component gauges.
# ============================================================

function MatrixCovers.soft_cover!(::AbsLinear{2}, a::AbstractVector, b::AbstractVector, A)
Expand All @@ -362,15 +359,14 @@ function MatrixCovers.soft_cover!(::AbsLinear{2}, a::AbstractVector, b::Abstract
ei, ej, elog = _edge_list(A, T)
nza = _degrees(ei, m)
nzb = _degrees(ej, n)
n_zeros = m * n - length(ei)

model = _ipopt_model(; unscaled=true)
α0 = [nza[i] > 0 ? log(T(a[pr[i]])) : zero(T) for i in 1:m]
β0 = [nzb[j] > 0 ? log(T(b[pc[j]])) : zero(T) for j in 1:n]
@variable(model, α[i=1:m], start = α0[i])
@variable(model, β[j=1:n], start = β0[j])
@objective(model, Min,
sum((1 - exp(elog[e] - α[ei[e]] - β[ej[e]]))^2 for e in eachindex(ei)) + n_zeros)
sum((1 - exp(elog[e] - α[ei[e]] - β[ej[e]]))^2 for e in eachindex(ei)))
_pin_gauge!(model, α, β, A, nza, nzb)
JuMP.optimize!(model)
stats = solved_stats(model, "soft_cover!")
Expand All @@ -395,7 +391,6 @@ function MatrixCovers.soft_cover!(::AbsLinear{1}, a::AbstractVector, b::Abstract
ei, ej, elog = _edge_list(A, T)
nza = _degrees(ei, m)
nzb = _degrees(ej, n)
n_zeros = m * n - length(ei)

model = _ipopt_model()
α0 = [nza[i] > 0 ? log(T(a[pr[i]])) : zero(T) for i in 1:m]
Expand All @@ -407,7 +402,7 @@ function MatrixCovers.soft_cover!(::AbsLinear{1}, a::AbstractVector, b::Abstract
@constraint(model, 1 - exp(elog[e] - α[ei[e]] - β[ej[e]]) <= t[e])
@constraint(model, -1 + exp(elog[e] - α[ei[e]] - β[ej[e]]) <= t[e])
end
@objective(model, Min, sum(t) + n_zeros)
@objective(model, Min, sum(t))
_pin_gauge!(model, α, β, A, nza, nzb)
JuMP.optimize!(model)
stats = solved_stats(model, "soft_cover!")
Expand Down
88 changes: 44 additions & 44 deletions ext/MatrixCoversUnitfulExt.jl
Original file line number Diff line number Diff line change
Expand Up @@ -197,47 +197,47 @@ symsplit(x::AbstractVector) = (x, ())
symsplit(r::Tuple) = (first(r), Base.tail(r))
asymsplit(r::Tuple) = (r[1], r[2], Base.tail(Base.tail(r)))

function sym(f, A::QMatrix, ϕ...; kwargs...)
a, rest = symsplit(f(ϕ..., strip_matrix(A); kwargs...))
function sym(f, A::QMatrix, ρ...; kwargs...)
a, rest = symsplit(f(ρ..., strip_matrix(A); kwargs...))
return isempty(rest) ? reattach(a, factor_units_sym(A)) : (reattach(a, factor_units_sym(A)), rest...)
end

function asym(f, A::QMatrix, ϕ...; kwargs...)
function asym(f, A::QMatrix, ρ...; kwargs...)
ua, ub = factor_units(A)
a, b, rest = asymsplit(f(ϕ..., strip_matrix(A); kwargs...))
a, b, rest = asymsplit(f(ρ..., strip_matrix(A); kwargs...))
return (reattach(a, ua), reattach(b, ub), rest...)
end

# Allocating scratch from `A` permits uninitialized destination vectors.
function sym!(f, a::QVector, A::QMatrix, ϕ...; kwargs...)
function sym!(f, a::QVector, A::QMatrix, ρ...; kwargs...)
ua = factor_units_sym(A)
An = strip_matrix(A)
x, rest = symsplit(f(ϕ..., similar(a, float(real(eltype(An)))), An; kwargs...))
x, rest = symsplit(f(ρ..., similar(a, float(real(eltype(An)))), An; kwargs...))
a .= reattach(x, ua)
return isempty(rest) ? a : (a, rest...)
end

function asym!(f, a::QVector, b::QVector, A::QMatrix, ϕ...; kwargs...)
function asym!(f, a::QVector, b::QVector, A::QMatrix, ρ...; kwargs...)
ua, ub = factor_units(A)
An = strip_matrix(A)
T = float(real(eltype(An)))
x, y, rest = asymsplit(f(ϕ..., similar(a, T), similar(b, T), An; kwargs...))
x, y, rest = asymsplit(f(ρ..., similar(a, T), similar(b, T), An; kwargs...))
a .= reattach(x, ua)
b .= reattach(y, ub)
return (a, b, rest...)
end

# `a` is a start, and is read.
function symstart!(f, a::QVector, A::QMatrix, ϕ...; kwargs...)
function symstart!(f, a::QVector, A::QMatrix, ρ...; kwargs...)
ua = factor_units_sym(A)
x, rest = symsplit(f(ϕ..., strip_start(a, ua), strip_matrix(A); kwargs...))
x, rest = symsplit(f(ρ..., strip_start(a, ua), strip_matrix(A); kwargs...))
a .= reattach(x, ua)
return isempty(rest) ? a : (a, rest...)
end

function asymstart!(f, a::QVector, b::QVector, A::QMatrix, ϕ...; kwargs...)
function asymstart!(f, a::QVector, b::QVector, A::QMatrix, ρ...; kwargs...)
ua, ub = factor_units(A)
x, y, rest = asymsplit(f(ϕ..., strip_start(a, ua), strip_start(b, ub), strip_matrix(A); kwargs...))
x, y, rest = asymsplit(f(ρ..., strip_start(a, ua), strip_start(b, ub), strip_matrix(A); kwargs...))
a .= reattach(x, ua)
b .= reattach(y, ub)
return (a, b, rest...)
Expand All @@ -246,16 +246,16 @@ end
# Mirror the core penalty dispatch while specializing on unitful matrices.
const PENALTIES = (:(AbsLog{1}), :(AbsLog{2}), :(AbsLinear{1}), :(AbsLinear{2}))

# Heuristic covers and initializers: `ϕ` is checked but not consulted.
# Heuristic covers and initializers: `ρ` is checked but not consulted.
MC.symcover(A::QMatrix; kwargs...) = sym(MC.symcover, A; kwargs...)
MC.symcover(ϕ::MC.AbstractCoverPenalty, A::QMatrix; kwargs...) = sym(MC.symcover, A, ϕ; kwargs...)
MC.symcover(ρ::MC.AbstractCoverPenalty, A::QMatrix; kwargs...) = sym(MC.symcover, A, ρ; kwargs...)
MC.symcover!(a::QVector, A::QMatrix; kwargs...) = sym!(MC.symcover!, a, A; kwargs...)
MC.symcover!(ϕ::MC.AbstractCoverPenalty, a::QVector, A::QMatrix; kwargs...) = sym!(MC.symcover!, a, A, ϕ; kwargs...)
MC.symcover!(ρ::MC.AbstractCoverPenalty, a::QVector, A::QMatrix; kwargs...) = sym!(MC.symcover!, a, A, ρ; kwargs...)

MC.cover(A::QMatrix; kwargs...) = asym(MC.cover, A; kwargs...)
MC.cover(ϕ::MC.AbstractCoverPenalty, A::QMatrix; kwargs...) = asym(MC.cover, A, ϕ; kwargs...)
MC.cover(ρ::MC.AbstractCoverPenalty, A::QMatrix; kwargs...) = asym(MC.cover, A, ρ; kwargs...)
MC.cover!(a::QVector, b::QVector, A::QMatrix; kwargs...) = asym!(MC.cover!, a, b, A; kwargs...)
MC.cover!(ϕ::MC.AbstractCoverPenalty, a::QVector, b::QVector, A::QMatrix; kwargs...) = asym!(MC.cover!, a, b, A, ϕ; kwargs...)
MC.cover!(ρ::MC.AbstractCoverPenalty, a::QVector, b::QVector, A::QMatrix; kwargs...) = asym!(MC.cover!, a, b, A, ρ; kwargs...)

# Core `cover`/`cover!` methods dispatch on `Adjoint`/`Transpose` without an eltype
# bound, so a wrapped `Quantity` matrix needs these to stay unambiguous.
Expand Down Expand Up @@ -289,46 +289,46 @@ const QSparseSym = Union{QSparse,
Symmetric{<:Quantity,<:SparseMatrixCSC},
Hermitian{<:Quantity,<:SparseMatrixCSC}}

MC.symcover_min(ϕ::AbsLog{2}, A::QSparseSym; kwargs...) =
sym(MC.symcover_min, A, ϕ; kwargs...)
MC.symcover_min(ρ::AbsLog{2}, A::QSparseSym; kwargs...) =
sym(MC.symcover_min, A, ρ; kwargs...)

MC.cover_min(ϕ::AbsLog{2}, A::QSparse; kwargs...) =
asym(MC.cover_min, A, ϕ; kwargs...)
MC.cover_min(ρ::AbsLog{2}, A::QSparse; kwargs...) =
asym(MC.cover_min, A, ρ; kwargs...)

MC.cover_transversal(A::QSparse; kwargs...) = asym(MC.cover_transversal, A; kwargs...)

MC.soft_symcover(ϕ::AbsLog{2}, A::QSparseSym; kwargs...) =
sym(MC.soft_symcover, A, ϕ; kwargs...)
MC.soft_symcover(ρ::AbsLog{2}, A::QSparseSym; kwargs...) =
sym(MC.soft_symcover, A, ρ; kwargs...)

MC.soft_cover(ϕ::AbsLog{2}, A::QSparse; kwargs...) =
asym(MC.soft_cover, A, ϕ; kwargs...)
MC.soft_cover(ρ::AbsLog{2}, A::QSparse; kwargs...) =
asym(MC.soft_cover, A, ρ; kwargs...)

MC.symcover_min!(ϕ::AbsLog{2}, a::QVector, A::QSparseSym; kwargs...) =
symstart!(MC.symcover_min!, a, A, ϕ; kwargs...)
MC.symcover_min!(ρ::AbsLog{2}, a::QVector, A::QSparseSym; kwargs...) =
symstart!(MC.symcover_min!, a, A, ρ; kwargs...)

MC.cover_min!(ϕ::AbsLog{2}, a::QVector, b::QVector, A::QSparse; kwargs...) =
asymstart!(MC.cover_min!, a, b, A, ϕ; kwargs...)
MC.cover_min!(ρ::AbsLog{2}, a::QVector, b::QVector, A::QSparse; kwargs...) =
asymstart!(MC.cover_min!, a, b, A, ρ; kwargs...)

for P in PENALTIES
@eval begin
MC.soft_symcover(ϕ::$P, A::QMatrix; kwargs...) = sym(MC.soft_symcover, A, ϕ; kwargs...)
MC.soft_symcover!(ϕ::$P, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.soft_symcover!, a, A, ϕ; kwargs...)
MC.soft_cover(ϕ::$P, A::QMatrix; kwargs...) = asym(MC.soft_cover, A, ϕ; kwargs...)
MC.soft_cover!(ϕ::$P, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.soft_cover!, a, b, A, ϕ; kwargs...)

MC.symcover_min(ϕ::$P, A::QMatrix; kwargs...) = sym(MC.symcover_min, A, ϕ; kwargs...)
MC.symcover_min!(ϕ::$P, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.symcover_min!, a, A, ϕ; kwargs...)
MC.cover_min(ϕ::$P, A::QMatrix; kwargs...) = asym(MC.cover_min, A, ϕ; kwargs...)
MC.cover_min!(ϕ::$P, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.cover_min!, a, b, A, ϕ; kwargs...)
MC.soft_symcover(ρ::$P, A::QMatrix; kwargs...) = sym(MC.soft_symcover, A, ρ; kwargs...)
MC.soft_symcover!(ρ::$P, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.soft_symcover!, a, A, ρ; kwargs...)
MC.soft_cover(ρ::$P, A::QMatrix; kwargs...) = asym(MC.soft_cover, A, ρ; kwargs...)
MC.soft_cover!(ρ::$P, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.soft_cover!, a, b, A, ρ; kwargs...)

MC.symcover_min(ρ::$P, A::QMatrix; kwargs...) = sym(MC.symcover_min, A, ρ; kwargs...)
MC.symcover_min!(ρ::$P, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.symcover_min!, a, A, ρ; kwargs...)
MC.cover_min(ρ::$P, A::QMatrix; kwargs...) = asym(MC.cover_min, A, ρ; kwargs...)
MC.cover_min!(ρ::$P, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.cover_min!, a, b, A, ρ; kwargs...)
end
end

# `PowerMean` is parametric in its exponent.
MC.cover_transversal(ϕ::PowerMean, A::QMatrix; kwargs...) = asym(MC.cover_transversal, A, ϕ; kwargs...)
MC.cover_transversal!(ϕ::PowerMean, a::QVector, b::QVector, A::QMatrix; kwargs...) = asym!(MC.cover_transversal!, a, b, A, ϕ; kwargs...)
MC.soft_symcover(ϕ::PowerMean, A::QMatrix; kwargs...) = sym(MC.soft_symcover, A, ϕ; kwargs...)
MC.soft_symcover!(ϕ::PowerMean, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.soft_symcover!, a, A, ϕ; kwargs...)
MC.soft_cover(ϕ::PowerMean, A::QMatrix; kwargs...) = asym(MC.soft_cover, A, ϕ; kwargs...)
MC.soft_cover!(ϕ::PowerMean, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.soft_cover!, a, b, A, ϕ; kwargs...)
MC.cover_transversal(ρ::PowerMean, A::QMatrix; kwargs...) = asym(MC.cover_transversal, A, ρ; kwargs...)
MC.cover_transversal!(ρ::PowerMean, a::QVector, b::QVector, A::QMatrix; kwargs...) = asym!(MC.cover_transversal!, a, b, A, ρ; kwargs...)
MC.soft_symcover(ρ::PowerMean, A::QMatrix; kwargs...) = sym(MC.soft_symcover, A, ρ; kwargs...)
MC.soft_symcover!(ρ::PowerMean, a::QVector, A::QMatrix; kwargs...) = symstart!(MC.soft_symcover!, a, A, ρ; kwargs...)
MC.soft_cover(ρ::PowerMean, A::QMatrix; kwargs...) = asym(MC.soft_cover, A, ρ; kwargs...)
MC.soft_cover!(ρ::PowerMean, a::QVector, b::QVector, A::QMatrix; kwargs...) = asymstart!(MC.soft_cover!, a, b, A, ρ; kwargs...)

end # module MatrixCoversUnitfulExt
Loading
Loading