rename findtruncated_sorted to findtruncated_svd

Author: lkdvos

docs/src/dev_interface.md

@@ -11,5 +11,5 @@ MatrixAlgebraKit.jl provides a developer interface for specifying custom algorit
 MatrixAlgebraKit.default_algorithm
 MatrixAlgebraKit.select_algorithm
 MatrixAlgebraKit.findtruncated
-MatrixAlgebraKit.findtruncated_sorted
+MatrixAlgebraKit.findtruncated_svd
 ```

ext/MatrixAlgebraKitAMDGPUExt/MatrixAlgebraKitAMDGPUExt.jl

@@ -41,7 +41,7 @@ _gpu_heevd!(A::StridedROCMatrix, Dd::StridedROCVector, V::StridedROCMatrix; kwar
 _gpu_heev!(A::StridedROCMatrix, Dd::StridedROCVector, V::StridedROCMatrix; kwargs...)  = YArocSOLVER.heev!(A, Dd, V; kwargs...)
 _gpu_heevx!(A::StridedROCMatrix, Dd::StridedROCVector, V::StridedROCMatrix; kwargs...) = YArocSOLVER.heevx!(A, Dd, V; kwargs...)
 
-function MatrixAlgebraKit.findtruncated_sorted(values::StridedROCVector, strategy::TruncationByValue)
+function MatrixAlgebraKit.findtruncated_svd(values::StridedROCVector, strategy::TruncationByValue)
     return MatrixAlgebraKit.findtruncated(values, strategy)
 end
 

ext/MatrixAlgebraKitCUDAExt/MatrixAlgebraKitCUDAExt.jl

@@ -44,7 +44,7 @@ _gpu_gesvdj!(A::StridedCuMatrix, S::StridedCuVector, U::StridedCuMatrix, Vᴴ::S
 _gpu_heevj!(A::StridedCuMatrix, Dd::StridedCuVector, V::StridedCuMatrix; kwargs...) = YACUSOLVER.heevj!(A, Dd, V; kwargs...)
 _gpu_heevd!(A::StridedCuMatrix, Dd::StridedCuVector, V::StridedCuMatrix; kwargs...) = YACUSOLVER.heevd!(A, Dd, V; kwargs...)
 
-function MatrixAlgebraKit.findtruncated_sorted(values::StridedCuVector, strategy::TruncationByValue)
+function MatrixAlgebraKit.findtruncated_svd(values::StridedCuVector, strategy::TruncationByValue)
     return MatrixAlgebraKit.findtruncated(values, strategy)
 end
 

src/MatrixAlgebraKit.jl

@@ -38,7 +38,7 @@ export ROCSOLVER_HouseholderQR, ROCSOLVER_QRIteration, ROCSOLVER_Jacobi,
 export notrunc, truncrank, trunctol, truncerror, truncfilter
 
 VERSION >= v"1.11.0-DEV.469" &&
-    eval(Expr(:public, :default_algorithm, :findtruncated, :findtruncated_sorted,
+    eval(Expr(:public, :default_algorithm, :findtruncated, :findtruncated_svd,
               :select_algorithm))
 
 include("common/defaults.jl")

src/algorithms.jl

@@ -168,16 +168,16 @@ based on the `strategy`. The output should be a collection of indices specifying
 which values to keep. `MatrixAlgebraKit.findtruncated` is used inside of the default
 implementation of [`truncate!`](@ref) to perform the truncation. It does not assume that the
 values are sorted. For a version that assumes the values are reverse sorted (which is the
-standard case for SVD) see [`MatrixAlgebraKit.findtruncated_sorted`](@ref).
+standard case for SVD) see [`MatrixAlgebraKit.findtruncated_svd`](@ref).
 """ findtruncated
 
 @doc """
-    MatrixAlgebraKit.findtruncated_sorted(values::AbstractVector, strategy::TruncationStrategy)
+    MatrixAlgebraKit.findtruncated_svd(values::AbstractVector, strategy::TruncationStrategy)
 
 Like [`MatrixAlgebraKit.findtruncated`](@ref) but assumes that the values are real and
 sorted in descending order, as typically obtained by the SVD. This assumption is not
 checked, and this is used in the default implementation of [`svd_trunc!`](@ref).
-""" findtruncated_sorted
+""" findtruncated_svd
 
 """
     TruncatedAlgorithm(alg::AbstractAlgorithm, trunc::TruncationAlgorithm)

src/implementations/truncation.jl

@@ -2,7 +2,7 @@
 # ---------
 # Generic implementation: `findtruncated` followed by indexing
 function truncate!(::typeof(svd_trunc!), (U, S, Vᴴ), strategy::TruncationStrategy)
-    ind = findtruncated_sorted(diagview(S), strategy)
+    ind = findtruncated_svd(diagview(S), strategy)
     return U[:, ind], Diagonal(diagview(S)[ind]), Vᴴ[ind, :]
 end
 function truncate!(::typeof(eig_trunc!), (D, V), strategy::TruncationStrategy)
@@ -29,7 +29,7 @@ end
 # findtruncated
 # -------------
 # Generic fallback
-function findtruncated_sorted(values::AbstractVector, strategy::TruncationStrategy)
+function findtruncated_svd(values::AbstractVector, strategy::TruncationStrategy)
     return findtruncated(values, strategy)
 end
 
@@ -40,7 +40,7 @@ function findtruncated(values::AbstractVector, strategy::TruncationByOrder)
     howmany = min(strategy.howmany, length(values))
     return partialsortperm(values, 1:howmany; strategy.by, strategy.rev)
 end
-function findtruncated_sorted(values::AbstractVector, strategy::TruncationByOrder)
+function findtruncated_svd(values::AbstractVector, strategy::TruncationByOrder)
     @assert strategy.by === abs
     if strategy.by === abs
         howmany = min(strategy.howmany, length(values))
@@ -80,7 +80,7 @@ function findtruncated(values::AbstractVector, strategy::TruncationByError)
     I′ = _truncerr_impl(values, I; strategy.atol, strategy.rtol, strategy.p)
     return I[I′]
 end
-function findtruncated_sorted(values::AbstractVector, strategy::TruncationByError)
+function findtruncated_svd(values::AbstractVector, strategy::TruncationByError)
     I = eachindex(values)
     I′ = _truncerr_impl(values, I; strategy.atol, strategy.rtol, strategy.p)
     return I[I′]
@@ -108,8 +108,8 @@ function findtruncated(values::AbstractVector, strategy::TruncationIntersection)
     return mapreduce(Base.Fix1(findtruncated, values), _ind_intersect, strategy.components;
                      init=trues(length(values)))
 end
-function findtruncated_sorted(values::AbstractVector, strategy::TruncationIntersection)
-    return mapreduce(Base.Fix1(findtruncated_sorted, values), _ind_intersect,
+function findtruncated_svd(values::AbstractVector, strategy::TruncationIntersection)
+    return mapreduce(Base.Fix1(findtruncated_svd, values), _ind_intersect,
                      strategy.components; init=trues(length(values)))
 end
 

test/truncate.jl

@@ -3,7 +3,7 @@ using Test
 using TestExtras
 using MatrixAlgebraKit: NoTruncation, TruncationIntersection, TruncationByOrder,
                         TruncationByValue, TruncationStrategy, findtruncated,
-                        findtruncated_sorted
+                        findtruncated_svd
 
 @testset "truncate" begin
     trunc = @constinferred TruncationStrategy()
@@ -35,15 +35,15 @@ using MatrixAlgebraKit: NoTruncation, TruncationIntersection, TruncationByOrder,
     @test @constinferred(findtruncated(values, truncrank(2))) == 1:2
     @test @constinferred(findtruncated(values, truncrank(2; rev=false))) == [5, 4]
     @test @constinferred(findtruncated(values, truncrank(2; by=((-) ∘ abs)))) == [5, 4]
-    @test @constinferred(findtruncated_sorted(values, truncrank(2))) === 1:2
+    @test @constinferred(findtruncated_svd(values, truncrank(2))) === 1:2
 
     values = [1, 0.9, 0.5, -0.3, 0.01]
     strategy = trunctol(; atol=0.4)
     @test @constinferred(findtruncated(values, strategy)) == 1:3
-    @test @constinferred(findtruncated_sorted(values, strategy)) === 1:3
+    @test @constinferred(findtruncated_svd(values, strategy)) === 1:3
     strategy = trunctol(; atol=0.4, rev=true)
     @test @constinferred(findtruncated(values, strategy)) == 4:5
-    @test @constinferred(findtruncated_sorted(values, strategy)) === 4:5
+    @test @constinferred(findtruncated_svd(values, strategy)) === 4:5
 
     values = [0.01, 1, 0.9, -0.3, 0.5]
     for strategy in (trunctol(; atol=0.4), trunctol(; atol=0.2, by=identity))
@@ -65,5 +65,5 @@ using MatrixAlgebraKit: NoTruncation, TruncationIntersection, TruncationByOrder,
     strategy = truncerror(; atol=0.2, rtol=0)
     @test issetequal(@constinferred(findtruncated(values, strategy)), 2:5)
     vals_sorted = sort(values; by=abs, rev=true)
-    @test @constinferred(findtruncated_sorted(vals_sorted, strategy)) == 1:4
+    @test @constinferred(findtruncated_svd(vals_sorted, strategy)) == 1:4
 end