Skip to content

Commit afa64bc

Browse files
lkdvoslkdvos
committed
migrate logic from constructors to functions
1 parent aff5766 commit afa64bc

2 files changed

Lines changed: 78 additions & 32 deletions

File tree

‎src/interface/decompositions.jl‎

Lines changed: 8 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -329,12 +329,13 @@ struct LeftOrthAlgorithm{Kind, Alg <: AbstractAlgorithm} <: AbstractAlgorithm
329329
end
330330
LeftOrthAlgorithm{Kind}(alg::Alg) where {Kind, Alg <: AbstractAlgorithm} = LeftOrthAlgorithm{Kind, Alg}(alg)
331331

332+
# Note: specific algorithm selection is handled by `left_orth_alg` in orthnull.jl
332333
LeftOrthAlgorithm(alg::AbstractAlgorithm) = error(
333334
"""
334335
Unkown or invalid `left_orth` algorithm type `$(typeof(alg))`.
335336
To register the algorithm type for `left_orth`, define
336337
337-
MatrixAlgebraKit.LeftOrthAlgorithm(alg) = LeftOrthAlgorithm{kind}(alg)
338+
MatrixAlgebraKit.left_orth_alg(alg::CustomAlgorithm) = LeftOrthAlgorithm{kind}(alg)
338339
339340
where `kind` selects the factorization type that will be used.
340341
By default, this is either `:qr`, `:polar` or `:svd`, to select [`qr_compact!`](@ref),
@@ -343,14 +344,8 @@ LeftOrthAlgorithm(alg::AbstractAlgorithm) = error(
343344
)
344345

345346
const LeftOrthViaQR = LeftOrthAlgorithm{:qr}
346-
LeftOrthAlgorithm(alg::QRAlgorithms) = LeftOrthViaQR{typeof(alg)}(alg)
347-
348347
const LeftOrthViaPolar = LeftOrthAlgorithm{:polar}
349-
LeftOrthAlgorithm(alg::PolarAlgorithms) = LeftOrthViaPolar{typeof(alg)}(alg)
350-
351348
const LeftOrthViaSVD = LeftOrthAlgorithm{:svd}
352-
LeftOrthAlgorithm(alg::SVDAlgorithms) = LeftOrthViaSVD{typeof(alg)}(alg)
353-
LeftOrthAlgorithm(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = LeftOrthViaSVD{typeof(alg)}(alg)
354349

355350
"""
356351
RightOrthAlgorithm{Kind, Alg <: AbstractAlgorithm}(alg)
@@ -363,12 +358,13 @@ struct RightOrthAlgorithm{Kind, Alg <: AbstractAlgorithm} <: AbstractAlgorithm
363358
end
364359
RightOrthAlgorithm{Kind}(alg::Alg) where {Kind, Alg <: AbstractAlgorithm} = RightOrthAlgorithm{Kind, Alg}(alg)
365360

361+
# Note: specific algorithm selection is handled by `right_orth_alg` in orthnull.jl
366362
RightOrthAlgorithm(alg::AbstractAlgorithm) = error(
367363
"""
368364
Unkown or invalid `right_orth` algorithm type `$(typeof(alg))`.
369365
To register the algorithm type for `right_orth`, define
370366
371-
MatrixAlgebraKit.RightOrthAlgorithm(alg) = RightOrthAlgorithm{kind}(alg)
367+
MatrixAlgebraKit.right_orth_alg(alg::CustomAlgorithm) = RightOrthAlgorithm{kind}(alg)
372368
373369
where `kind` selects the factorization type that will be used.
374370
By default, this is either `:lq`, `:polar` or `:svd`, to select [`lq_compact!`](@ref),
@@ -377,14 +373,8 @@ RightOrthAlgorithm(alg::AbstractAlgorithm) = error(
377373
)
378374

379375
const RightOrthViaLQ = RightOrthAlgorithm{:lq}
380-
RightOrthAlgorithm(alg::LQAlgorithms) = RightOrthViaLQ{typeof(alg)}(alg)
381-
382376
const RightOrthViaPolar = RightOrthAlgorithm{:polar}
383-
RightOrthAlgorithm(alg::PolarAlgorithms) = RightOrthViaPolar{typeof(alg)}(alg)
384-
385377
const RightOrthViaSVD = RightOrthAlgorithm{:svd}
386-
RightOrthAlgorithm(alg::SVDAlgorithms) = RightOrthViaSVD{typeof(alg)}(alg)
387-
RightOrthAlgorithm(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = RightOrthViaSVD{typeof(alg)}(alg)
388378

389379
"""
390380
LeftNullAlgorithm{Kind, Alg <: AbstractAlgorithm}(alg)
@@ -397,12 +387,13 @@ struct LeftNullAlgorithm{Kind, Alg <: AbstractAlgorithm} <: AbstractAlgorithm
397387
end
398388
LeftNullAlgorithm{Kind}(alg::Alg) where {Kind, Alg <: AbstractAlgorithm} = LeftNullAlgorithm{Kind, Alg}(alg)
399389

390+
# Note: specific algorithm selection is handled by `left_null_alg` in orthnull.jl
400391
LeftNullAlgorithm(alg::AbstractAlgorithm) = error(
401392
"""
402393
Unkown or invalid `left_null` algorithm type `$(typeof(alg))`.
403394
To register the algorithm type for `left_null`, define
404395
405-
MatrixAlgebraKit.LeftNullAlgorithm(alg) = LeftNullAlgorithm{kind}(alg)
396+
MatrixAlgebraKit.left_null_alg(alg::CustomAlgorithm) = LeftNullAlgorithm{kind}(alg)
406397
407398
where `kind` selects the factorization type that will be used.
408399
By default, this is either `:qr` or `:svd`, to select [`qr_null!`](@ref),
@@ -411,11 +402,7 @@ LeftNullAlgorithm(alg::AbstractAlgorithm) = error(
411402
)
412403

413404
const LeftNullViaQR = LeftNullAlgorithm{:qr}
414-
LeftNullAlgorithm(alg::QRAlgorithms) = LeftNullViaQR{typeof(alg)}(alg)
415-
416405
const LeftNullViaSVD = LeftNullAlgorithm{:svd}
417-
LeftNullAlgorithm(alg::SVDAlgorithms) = LeftNullViaSVD{typeof(alg)}(alg)
418-
LeftNullAlgorithm(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = LeftNullViaSVD{typeof(alg)}(alg)
419406

420407
"""
421408
RightNullAlgorithm{Kind, Alg <: AbstractAlgorithm}(alg)
@@ -428,12 +415,13 @@ struct RightNullAlgorithm{Kind, Alg <: AbstractAlgorithm} <: AbstractAlgorithm
428415
end
429416
RightNullAlgorithm{Kind}(alg::Alg) where {Kind, Alg <: AbstractAlgorithm} = RightNullAlgorithm{Kind, Alg}(alg)
430417

418+
# Note: specific algorithm selection is handled by `right_null_alg` in orthnull.jl
431419
RightNullAlgorithm(alg::AbstractAlgorithm) = error(
432420
"""
433421
Unkown or invalid `right_null` algorithm type `$(typeof(alg))`.
434422
To register the algorithm type for `right_null`, define
435423
436-
MatrixAlgebraKit.RightNullAlgorithm(alg) = RightNullAlgorithm{kind}(alg)
424+
MatrixAlgebraKit.right_null_alg(alg::CustomAlgorithm) = RightNullAlgorithm{kind}(alg)
437425
438426
where `kind` selects the factorization type that will be used.
439427
By default, this is either `:lq` or `:svd`, to select [`lq_null!`](@ref),
@@ -442,8 +430,4 @@ RightNullAlgorithm(alg::AbstractAlgorithm) = error(
442430
)
443431

444432
const RightNullViaLQ = RightNullAlgorithm{:lq}
445-
RightNullAlgorithm(alg::LQAlgorithms) = RightNullViaLQ{typeof(alg)}(alg)
446-
447433
const RightNullViaSVD = RightNullAlgorithm{:svd}
448-
RightNullAlgorithm(alg::SVDAlgorithms) = RightNullViaSVD{typeof(alg)}(alg)
449-
RightNullAlgorithm(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = RightNullViaSVD{typeof(alg)}(alg)

‎src/interface/orthnull.jl‎

Lines changed: 70 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -436,14 +436,30 @@ from the algorithm type and wraps it in a `LeftOrthAlgorithm`. Custom algorithm
436436
registered by defining:
437437
438438
```julia
439-
MatrixAlgebraKit.LeftOrthAlgorithm(alg::CustomAlgorithm) = LeftOrthAlgorithm{kind}(alg)
439+
MatrixAlgebraKit.left_orth_alg(alg::CustomAlgorithm) = LeftOrthAlgorithm{kind}(alg)
440440
```
441441
442442
where `kind` specifies the factorization backend to use.
443443
444444
See also [`LeftOrthAlgorithm`](@ref), [`left_orth`](@ref).
445445
"""
446-
left_orth_alg(alg::AbstractAlgorithm) = LeftOrthAlgorithm(alg)
446+
left_orth_alg(alg::AbstractAlgorithm) = error(
447+
"""
448+
Unkown or invalid `left_orth` algorithm type `$(typeof(alg))`.
449+
To register the algorithm type for `left_orth`, define
450+
451+
MatrixAlgebraKit.left_orth_alg(alg::CustomAlgorithm) = LeftOrthAlgorithm{kind}(alg)
452+
453+
where `kind` selects the factorization type that will be used.
454+
By default, this is either `:qr`, `:polar` or `:svd`, to select [`qr_compact!`](@ref),
455+
[`left_polar!`](@ref), [`svd_compact!`](@ref) or [`svd_trunc!`](@ref) respectively.
456+
"""
457+
)
458+
left_orth_alg(alg::LeftOrthAlgorithm) = alg
459+
left_orth_alg(alg::QRAlgorithms) = LeftOrthViaQR(alg)
460+
left_orth_alg(alg::PolarAlgorithms) = LeftOrthViaPolar(alg)
461+
left_orth_alg(alg::SVDAlgorithms) = LeftOrthViaSVD(alg)
462+
left_orth_alg(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = LeftOrthViaSVD(alg)
447463

448464
"""
449465
right_orth_alg(alg::AbstractAlgorithm) -> RightOrthAlgorithm
@@ -455,14 +471,30 @@ from the algorithm type and wraps it in a `RightOrthAlgorithm`. Custom algorithm
455471
registered by defining:
456472
457473
```julia
458-
MatrixAlgebraKit.RightOrthAlgorithm(alg::CustomAlgorithm) = RightOrthAlgorithm{kind}(alg)
474+
MatrixAlgebraKit.right_orth_alg(alg::CustomAlgorithm) = RightOrthAlgorithm{kind}(alg)
459475
```
460476
461477
where `kind` specifies the factorization backend to use.
462478
463479
See also [`RightOrthAlgorithm`](@ref), [`right_orth`](@ref).
464480
"""
465-
right_orth_alg(alg::AbstractAlgorithm) = RightOrthAlgorithm(alg)
481+
right_orth_alg(alg::AbstractAlgorithm) = error(
482+
"""
483+
Unkown or invalid `right_orth` algorithm type `$(typeof(alg))`.
484+
To register the algorithm type for `right_orth`, define
485+
486+
MatrixAlgebraKit.right_orth_alg(alg::CustomAlgorithm) = RightOrthAlgorithm{kind}(alg)
487+
488+
where `kind` selects the factorization type that will be used.
489+
By default, this is either `:lq`, `:polar` or `:svd`, to select [`lq_compact!`](@ref),
490+
[`right_polar!`](@ref), [`svd_compact!`](@ref) or [`svd_trunc!`](@ref) respectively.
491+
"""
492+
)
493+
right_orth_alg(alg::RightOrthAlgorithm) = alg
494+
right_orth_alg(alg::LQAlgorithms) = RightOrthViaLQ(alg)
495+
right_orth_alg(alg::PolarAlgorithms) = RightOrthViaPolar(alg)
496+
right_orth_alg(alg::SVDAlgorithms) = RightOrthViaSVD(alg)
497+
right_orth_alg(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = RightOrthViaSVD(alg)
466498

467499
"""
468500
left_null_alg(alg::AbstractAlgorithm) -> LeftNullAlgorithm
@@ -474,14 +506,29 @@ the algorithm type and wraps it in a `LeftNullAlgorithm`. Custom algorithm types
474506
registered by defining:
475507
476508
```julia
477-
MatrixAlgebraKit.LeftNullAlgorithm(alg::CustomAlgorithm) = LeftNullAlgorithm{kind}(alg)
509+
MatrixAlgebraKit.left_null_alg(alg::CustomAlgorithm) = LeftNullAlgorithm{kind}(alg)
478510
```
479511
480512
where `kind` specifies the factorization backend to use.
481513
482514
See also [`LeftNullAlgorithm`](@ref), [`left_null`](@ref).
483515
"""
484-
left_null_alg(alg::AbstractAlgorithm) = LeftNullAlgorithm(alg)
516+
left_null_alg(alg::AbstractAlgorithm) = error(
517+
"""
518+
Unkown or invalid `left_null` algorithm type `$(typeof(alg))`.
519+
To register the algorithm type for `left_null`, define
520+
521+
MatrixAlgebraKit.left_null_alg(alg::CustomAlgorithm) = LeftNullAlgorithm{kind}(alg)
522+
523+
where `kind` selects the factorization type that will be used.
524+
By default, this is either `:qr` or `:svd`, to select [`qr_null!`](@ref),
525+
[`svd_compact!`](@ref) or [`svd_trunc!`](@ref) respectively.
526+
"""
527+
)
528+
left_null_alg(alg::LeftNullAlgorithm) = alg
529+
left_null_alg(alg::QRAlgorithms) = LeftNullViaQR(alg)
530+
left_null_alg(alg::SVDAlgorithms) = LeftNullViaSVD(alg)
531+
left_null_alg(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = LeftNullViaSVD(alg)
485532

486533
"""
487534
right_null_alg(alg::AbstractAlgorithm) -> RightNullAlgorithm
@@ -493,11 +540,26 @@ the algorithm type and wraps it in a `RightNullAlgorithm`. Custom algorithm type
493540
registered by defining:
494541
495542
```julia
496-
MatrixAlgebraKit.RightNullAlgorithm(alg::CustomAlgorithm) = RightNullAlgorithm{kind}(alg)
543+
MatrixAlgebraKit.right_null_alg(alg::CustomAlgorithm) = RightNullAlgorithm{kind}(alg)
497544
```
498545
499546
where `kind` specifies the factorization backend to use.
500547
501548
See also [`RightNullAlgorithm`](@ref), [`right_null`](@ref).
502549
"""
503-
right_null_alg(alg::AbstractAlgorithm) = RightNullAlgorithm(alg)
550+
right_null_alg(alg::AbstractAlgorithm) = error(
551+
"""
552+
Unkown or invalid `right_null` algorithm type `$(typeof(alg))`.
553+
To register the algorithm type for `right_null`, define
554+
555+
MatrixAlgebraKit.right_null_alg(alg::CustomAlgorithm) = RightNullAlgorithm{kind}(alg)
556+
557+
where `kind` selects the factorization type that will be used.
558+
By default, this is either `:lq` or `:svd`, to select [`lq_null!`](@ref),
559+
[`svd_compact!`](@ref) or [`svd_trunc!`](@ref) respectively.
560+
"""
561+
)
562+
right_null_alg(alg::RightNullAlgorithm) = alg
563+
right_null_alg(alg::LQAlgorithms) = RightNullViaLQ(alg)
564+
right_null_alg(alg::SVDAlgorithms) = RightNullViaSVD(alg)
565+
right_null_alg(alg::TruncatedAlgorithm{<:SVDAlgorithms}) = RightNullViaSVD(alg)

0 commit comments

Comments
 (0)