Switch to svd_trunc and svd_trunc_no_error

Author: kshyatt

docs/src/user_interface/truncations.md

@@ -113,16 +113,16 @@ combined_trunc = truncrank(10) & trunctol(; atol = 1e-6);
 
 ## Truncation Error
 
-When using truncated decompositions such as [`svd_trunc_with_err`](@ref), [`eig_trunc`](@ref), or [`eigh_trunc`](@ref), an additional truncation error value is returned.
+When using truncated decompositions such as [`svd_trunc`](@ref), [`eig_trunc`](@ref), or [`eigh_trunc`](@ref), an additional truncation error value is returned.
 This error is defined as the 2-norm of the discarded  singular values or eigenvalues, providing a measure of the approximation quality.
-For `svd_trunc_with_err` and `eigh_trunc`, this corresponds to the 2-norm difference between the original and the truncated matrix.
+For `svd_trunc` and `eigh_trunc`, this corresponds to the 2-norm difference between the original and the truncated matrix.
 For the case of `eig_trunc`, this interpretation does not hold because the norm of the non-unitary matrix of eigenvectors and its inverse also influence the approximation quality.
 
 
 For example:
 ```jldoctest truncations; output=false
 using LinearAlgebra: norm
-U, S, Vᴴ, ϵ = svd_trunc_with_err(A; trunc=truncrank(2))
+U, S, Vᴴ, ϵ = svd_trunc(A; trunc=truncrank(2))
 norm(A - U * S * Vᴴ) ≈ ϵ # ϵ is the 2-norm of the discarded singular values
 
 # output

ext/MatrixAlgebraKitChainRulesCoreExt.jl

@@ -170,15 +170,15 @@ for svd_f in (:svd_compact, :svd_full)
     end
 end
 
-function ChainRulesCore.rrule(::typeof(svd_trunc_with_err!), A, USVᴴ, alg::TruncatedAlgorithm)
+function ChainRulesCore.rrule(::typeof(svd_trunc!), A, USVᴴ, alg::TruncatedAlgorithm)
     Ac = copy_input(svd_compact, A)
     USVᴴ = svd_compact!(Ac, USVᴴ, alg.alg)
     USVᴴ′, ind = MatrixAlgebraKit.truncate(svd_trunc!, USVᴴ, alg.trunc)
     ϵ = truncation_error(diagview(USVᴴ[2]), ind)
-    return (USVᴴ′..., ϵ), _make_svd_trunc_with_err_pullback(A, USVᴴ, ind)
+    return (USVᴴ′..., ϵ), _make_svd_trunc_pullback(A, USVᴴ, ind)
 end
-function _make_svd_trunc_with_err_pullback(A, USVᴴ, ind)
-    function svd_trunc_with_err_pullback(ΔUSVᴴϵ)
+function _make_svd_trunc_pullback(A, USVᴴ, ind)
+    function svd_trunc_pullback(ΔUSVᴴϵ)
         ΔA = zero(A)
         ΔU, ΔS, ΔVᴴ, Δϵ = ΔUSVᴴϵ
         if !MatrixAlgebraKit.iszerotangent(Δϵ) && !iszero(unthunk(Δϵ))
@@ -187,26 +187,26 @@ function _make_svd_trunc_with_err_pullback(A, USVᴴ, ind)
         MatrixAlgebraKit.svd_pullback!(ΔA, A, USVᴴ, unthunk.((ΔU, ΔS, ΔVᴴ)), ind)
         return NoTangent(), ΔA, ZeroTangent(), NoTangent()
     end
-    function svd_trunc_with_err_pullback(::Tuple{ZeroTangent, ZeroTangent, ZeroTangent, ZeroTangent}) # is this extra definition useful?
+    function svd_trunc_pullback(::Tuple{ZeroTangent, ZeroTangent, ZeroTangent, ZeroTangent}) # is this extra definition useful?
         return NoTangent(), ZeroTangent(), ZeroTangent(), NoTangent()
     end
-    return svd_trunc_with_err_pullback
+    return svd_trunc_pullback
 end
 
-function ChainRulesCore.rrule(::typeof(svd_trunc!), A, USVᴴ, alg::TruncatedAlgorithm)
+function ChainRulesCore.rrule(::typeof(svd_trunc_no_error!), A, USVᴴ, alg::TruncatedAlgorithm)
     Ac = copy_input(svd_compact, A)
     USVᴴ = svd_compact!(Ac, USVᴴ, alg.alg)
     USVᴴ′, ind = MatrixAlgebraKit.truncate(svd_trunc!, USVᴴ, alg.trunc)
-    return USVᴴ′, _make_svd_trunc_pullback(A, USVᴴ, ind)
+    return USVᴴ′, _make_svd_trunc_no_error_pullback(A, USVᴴ, ind)
 end
-function _make_svd_trunc_pullback(A, USVᴴ, ind)
+function _make_svd_trunc_no_error_pullback(A, USVᴴ, ind)
     function svd_trunc_pullback(ΔUSVᴴ)
         ΔA = zero(A)
         ΔU, ΔS, ΔVᴴ = ΔUSVᴴ
         MatrixAlgebraKit.svd_pullback!(ΔA, A, USVᴴ, unthunk.((ΔU, ΔS, ΔVᴴ)), ind)
         return NoTangent(), ΔA, ZeroTangent(), NoTangent()
     end
-    function svd_trunc_pullback(::Tuple{ZeroTangent, ZeroTangent, ZeroTangent, ZeroTangent}) # is this extra definition useful?
+    function svd_trunc_pullback(::Tuple{ZeroTangent, ZeroTangent, ZeroTangent}) # is this extra definition useful?
         return NoTangent(), ZeroTangent(), ZeroTangent(), NoTangent()
     end
     return svd_trunc_pullback

ext/MatrixAlgebraKitMooncakeExt/MatrixAlgebraKitMooncakeExt.jl

@@ -303,14 +303,14 @@ function Mooncake.rrule!!(::CoDual{typeof(svd_vals)}, A_dA::CoDual, alg_dalg::Co
     return S_codual, svd_vals_adjoint
 end
 
-@is_primitive Mooncake.DefaultCtx Mooncake.ReverseMode Tuple{typeof(svd_trunc_with_err), Any, MatrixAlgebraKit.AbstractAlgorithm}
-function Mooncake.rrule!!(::CoDual{typeof(svd_trunc_with_err)}, A_dA::CoDual, alg_dalg::CoDual)
+@is_primitive Mooncake.DefaultCtx Mooncake.ReverseMode Tuple{typeof(svd_trunc), Any, MatrixAlgebraKit.AbstractAlgorithm}
+function Mooncake.rrule!!(::CoDual{typeof(svd_trunc)}, A_dA::CoDual, alg_dalg::CoDual)
     # compute primal
     A_ = Mooncake.primal(A_dA)
     dA_ = Mooncake.tangent(A_dA)
     A, dA = arrayify(A_, dA_)
     alg = Mooncake.primal(alg_dalg)
-    output = svd_trunc_with_err(A, alg)
+    output = svd_trunc(A, alg)
     # fdata call here is necessary to convert complicated Tangent type (e.g. of a Diagonal
     # of ComplexF32) into the correct **forwards** data type (since we are now in the forward
     # pass). For many types this is done automatically when the forward step returns, but
@@ -319,7 +319,7 @@ function Mooncake.rrule!!(::CoDual{typeof(svd_trunc_with_err)}, A_dA::CoDual, al
     function svd_trunc_adjoint(dy::Tuple{NoRData, NoRData, NoRData, T}) where {T <: Real}
         Utrunc, Strunc, Vᴴtrunc, ϵ = Mooncake.primal(output_codual)
         dUtrunc_, dStrunc_, dVᴴtrunc_, dϵ = Mooncake.tangent(output_codual)
-        abs(dy[4]) > MatrixAlgebraKit.defaulttol(dy[4]) && @warn "Pullback for svd_trunc_with_err does not yet support non-zero tangent for the truncation error"
+        abs(dy[4]) > MatrixAlgebraKit.defaulttol(dy[4]) && @warn "Pullback for svd_trunc does not yet support non-zero tangent for the truncation error"
         U, dU = arrayify(Utrunc, dUtrunc_)
         S, dS = arrayify(Strunc, dStrunc_)
         Vᴴ, dVᴴ = arrayify(Vᴴtrunc, dVᴴtrunc_)
@@ -332,14 +332,14 @@ function Mooncake.rrule!!(::CoDual{typeof(svd_trunc_with_err)}, A_dA::CoDual, al
     return output_codual, svd_trunc_adjoint
 end
 
-@is_primitive Mooncake.DefaultCtx Mooncake.ReverseMode Tuple{typeof(svd_trunc), Any, MatrixAlgebraKit.AbstractAlgorithm}
-function Mooncake.rrule!!(::CoDual{typeof(svd_trunc)}, A_dA::CoDual, alg_dalg::CoDual)
+@is_primitive Mooncake.DefaultCtx Mooncake.ReverseMode Tuple{typeof(svd_trunc_no_error), Any, MatrixAlgebraKit.AbstractAlgorithm}
+function Mooncake.rrule!!(::CoDual{typeof(svd_trunc_no_error)}, A_dA::CoDual, alg_dalg::CoDual)
     # compute primal
     A_ = Mooncake.primal(A_dA)
     dA_ = Mooncake.tangent(A_dA)
     A, dA = arrayify(A_, dA_)
     alg = Mooncake.primal(alg_dalg)
-    output = svd_trunc(A, alg)
+    output = svd_trunc_no_error(A, alg)
     # fdata call here is necessary to convert complicated Tangent type (e.g. of a Diagonal
     # of ComplexF32) into the correct **forwards** data type (since we are now in the forward
     # pass). For many types this is done automatically when the forward step returns, but

src/MatrixAlgebraKit.jl

@@ -16,8 +16,8 @@ export project_hermitian, project_antihermitian, project_isometric
 export project_hermitian!, project_antihermitian!, project_isometric!
 export qr_compact, qr_full, qr_null, lq_compact, lq_full, lq_null
 export qr_compact!, qr_full!, qr_null!, lq_compact!, lq_full!, lq_null!
-export svd_compact, svd_full, svd_vals, svd_trunc, svd_trunc_with_err
-export svd_compact!, svd_full!, svd_vals!, svd_trunc!, svd_trunc_with_err!
+export svd_compact, svd_full, svd_vals, svd_trunc, svd_trunc_no_error
+export svd_compact!, svd_full!, svd_vals!, svd_trunc!, svd_trunc_no_error!
 export eigh_full, eigh_vals, eigh_trunc
 export eigh_full!, eigh_vals!, eigh_trunc!
 export eig_full, eig_vals, eig_trunc

src/implementations/svd.jl

@@ -3,7 +3,7 @@
 copy_input(::typeof(svd_full), A::AbstractMatrix) = copy!(similar(A, float(eltype(A))), A)
 copy_input(::typeof(svd_compact), A) = copy_input(svd_full, A)
 copy_input(::typeof(svd_vals), A) = copy_input(svd_full, A)
-copy_input(::Union{typeof(svd_trunc), typeof(svd_trunc_with_err)}, A) = copy_input(svd_compact, A)
+copy_input(::Union{typeof(svd_trunc), typeof(svd_trunc_no_error)}, A) = copy_input(svd_compact, A)
 
 copy_input(::typeof(svd_full), A::Diagonal) = copy(A)
 
@@ -89,7 +89,7 @@ end
 function initialize_output(::typeof(svd_vals!), A::AbstractMatrix, ::AbstractAlgorithm)
     return similar(A, real(eltype(A)), (min(size(A)...),))
 end
-function initialize_output(::Union{typeof(svd_trunc!), typeof(svd_trunc_with_err!)}, A, alg::TruncatedAlgorithm)
+function initialize_output(::Union{typeof(svd_trunc!), typeof(svd_trunc_no_error!)}, A, alg::TruncatedAlgorithm)
     return initialize_output(svd_compact!, A, alg.alg)
 end
 
@@ -206,13 +206,13 @@ function svd_vals!(A::AbstractMatrix, S, alg::LAPACK_SVDAlgorithm)
     return S
 end
 
-function svd_trunc!(A, USVᴴ, alg::TruncatedAlgorithm)
+function svd_trunc_no_error!(A, USVᴴ, alg::TruncatedAlgorithm)
     U, S, Vᴴ = svd_compact!(A, USVᴴ, alg.alg)
     USVᴴtrunc, ind = truncate(svd_trunc!, (U, S, Vᴴ), alg.trunc)
     return USVᴴtrunc
 end
 
-function svd_trunc_with_err!(A, USVᴴ, alg::TruncatedAlgorithm)
+function svd_trunc!(A, USVᴴ, alg::TruncatedAlgorithm)
     U, S, Vᴴ = svd_compact!(A, USVᴴ, alg.alg)
     USVᴴtrunc, ind = truncate(svd_trunc!, (U, S, Vᴴ), alg.trunc)
     ϵ = truncation_error!(diagview(S), ind)
@@ -269,7 +269,7 @@ end
 ###
 
 function check_input(
-        ::Union{typeof(svd_trunc!), typeof(svd_trunc_with_err!)}, A::AbstractMatrix, USVᴴ, alg::CUSOLVER_Randomized
+        ::Union{typeof(svd_trunc!), typeof(svd_trunc_no_error!)}, A::AbstractMatrix, USVᴴ, alg::CUSOLVER_Randomized
     )
     m, n = size(A)
     minmn = min(m, n)
@@ -285,7 +285,7 @@ function check_input(
 end
 
 function initialize_output(
-        ::Union{typeof(svd_trunc!), typeof(svd_trunc_with_err!)}, A::AbstractMatrix, alg::TruncatedAlgorithm{<:CUSOLVER_Randomized}
+        ::Union{typeof(svd_trunc!), typeof(svd_trunc_no_error!)}, A::AbstractMatrix, alg::TruncatedAlgorithm{<:CUSOLVER_Randomized}
     )
     m, n = size(A)
     minmn = min(m, n)
@@ -369,9 +369,9 @@ function svd_full!(A::AbstractMatrix, USVᴴ, alg::GPU_SVDAlgorithm)
     return USVᴴ
 end
 
-function svd_trunc!(A::AbstractMatrix, USVᴴ, alg::TruncatedAlgorithm{<:GPU_Randomized})
+function svd_trunc_no_error!(A::AbstractMatrix, USVᴴ, alg::TruncatedAlgorithm{<:GPU_Randomized})
     U, S, Vᴴ = USVᴴ
-    check_input(svd_trunc!, A, (U, S, Vᴴ), alg.alg)
+    check_input(svd_trunc_no_error!, A, (U, S, Vᴴ), alg.alg)
     _gpu_Xgesvdr!(A, diagview(S), U, Vᴴ; alg.alg.kwargs...)
 
     # TODO: make sure that truncation is based on maxrank, otherwise this might be wrong
@@ -383,9 +383,9 @@ function svd_trunc!(A::AbstractMatrix, USVᴴ, alg::TruncatedAlgorithm{<:GPU_Ran
     return Utr, Str, Vᴴtr
 end
 
-function svd_trunc_with_err!(A::AbstractMatrix, USVᴴ, alg::TruncatedAlgorithm{<:GPU_Randomized})
+function svd_trunc!(A::AbstractMatrix, USVᴴ, alg::TruncatedAlgorithm{<:GPU_Randomized})
     U, S, Vᴴ = USVᴴ
-    check_input(svd_trunc_with_err!, A, (U, S, Vᴴ), alg.alg)
+    check_input(svd_trunc!, A, (U, S, Vᴴ), alg.alg)
     _gpu_Xgesvdr!(A, diagview(S), U, Vᴴ; alg.alg.kwargs...)
 
     # TODO: make sure that truncation is based on maxrank, otherwise this might be wrong

src/interface/svd.jl

@@ -42,10 +42,10 @@ See also [`svd_full(!)`](@ref svd_full), [`svd_vals(!)`](@ref svd_vals) and
 @functiondef svd_compact
 
 """
-    svd_trunc_with_err(A; [trunc], kwargs...) -> U, S, Vᴴ, ϵ
-    svd_trunc_with_err(A, alg::AbstractAlgorithm) -> U, S, Vᴴ, ϵ
-    svd_trunc_with_err!(A, [USVᴴ]; [trunc], kwargs...) -> U, S, Vᴴ, ϵ
-    svd_trunc_with_err!(A, [USVᴴ], alg::AbstractAlgorithm) -> U, S, Vᴴ, ϵ
+    svd_trunc(A; [trunc], kwargs...) -> U, S, Vᴴ, ϵ
+    svd_trunc(A, alg::AbstractAlgorithm) -> U, S, Vᴴ, ϵ
+    svd_trunc!(A, [USVᴴ]; [trunc], kwargs...) -> U, S, Vᴴ, ϵ
+    svd_trunc!(A, [USVᴴ], alg::AbstractAlgorithm) -> U, S, Vᴴ, ϵ
 
 Compute a partial or truncated singular value decomposition (SVD) of `A`, such that
 `A * (Vᴴ)' ≈ U * S`. Here, `U` is an isometric matrix (orthonormal columns) of size
@@ -86,22 +86,23 @@ truncation strategy is already embedded in the algorithm.
     possibly destroys the input matrix `A`. Always use the return value of the function
     as it may not always be possible to use the provided `USVᴴ` as output.
 
-See also [`svd_trunc(!)`](@ref svd_trunc), [`svd_full(!)`](@ref svd_full),
+See also [`svd_trunc_no_error(!)`](@ref svd_trunc), [`svd_full(!)`](@ref svd_full),
 [`svd_compact(!)`](@ref svd_compact), [`svd_vals(!)`](@ref svd_vals),
 and [Truncations](@ref) for more information on truncation strategies.
 """
-@functiondef svd_trunc_with_err
+@functiondef svd_trunc
 
 """
-    svd_trunc(A; [trunc], kwargs...) -> U, S, Vᴴ
-    svd_trunc(A, alg::AbstractAlgorithm) -> U, S, Vᴴ
-    svd_trunc!(A, [USVᴴ]; [trunc], kwargs...) -> U, S, Vᴴ
-    svd_trunc!(A, [USVᴴ], alg::AbstractAlgorithm) -> U, S, Vᴴ
+    svd_trunc_no_error(A; [trunc], kwargs...) -> U, S, Vᴴ
+    svd_trunc_no_error(A, alg::AbstractAlgorithm) -> U, S, Vᴴ
+    svd_trunc_no_error!(A, [USVᴴ]; [trunc], kwargs...) -> U, S, Vᴴ
+    svd_trunc_no_error!(A, [USVᴴ], alg::AbstractAlgorithm) -> U, S, Vᴴ
 
 Compute a partial or truncated singular value decomposition (SVD) of `A`, such that
 `A * (Vᴴ)' ≈ U * S`. Here, `U` is an isometric matrix (orthonormal columns) of size
 `(m, k)`, whereas  `Vᴴ` is a matrix of size `(k, n)` with orthonormal rows and `S` is a
 square diagonal matrix of size `(k, k)`, with `k` is set by the truncation strategy.
+The truncation error is *not* returned.
 
 ## Truncation
 The truncation strategy can be controlled via the `trunc` keyword argument. This can be
@@ -130,15 +131,15 @@ When `alg` is a [`TruncatedAlgorithm`](@ref), the `trunc` keyword cannot be spec
 truncation strategy is already embedded in the algorithm.
 
 !!! note
-    The bang method `svd_trunc!` optionally accepts the output structure and
+    The bang method `svd_trunc_no_error!` optionally accepts the output structure and
     possibly destroys the input matrix `A`. Always use the return value of the function
     as it may not always be possible to use the provided `USVᴴ` as output.
 
 See also [`svd_full(!)`](@ref svd_full), [`svd_compact(!)`](@ref svd_compact),
-[`svd_vals(!)`](@ref svd_vals), and [Truncations](@ref) for more information on
-truncation strategies.
+[`svd_vals(!)`](@ref svd_vals), [`svd_trunc(!)`](@ref svd_trunc) and
+[Truncations](@ref) for more information on truncation strategies.
 """
-@functiondef svd_trunc
+@functiondef svd_trunc_no_error
 
 """
     svd_vals(A; kwargs...) -> S
@@ -173,7 +174,7 @@ for f in (:svd_full!, :svd_compact!, :svd_vals!)
     end
 end
 
-for f in (:svd_trunc!, :svd_trunc_with_err!)
+for f in (:svd_trunc!, :svd_trunc_no_error!)
     @eval function select_algorithm(::typeof($f), A, alg; trunc = nothing, kwargs...)
         if alg isa TruncatedAlgorithm
             isnothing(trunc) ||

test/amd/svd.jl

@@ -140,14 +140,14 @@ end
 #             minmn = min(m, n)
 #             r = minmn - 2
 #
-#             U1, S1, V1ᴴ, ϵ1 = @constinferred svd_trunc_with_err(A; alg, trunc=truncrank(r))
+#             U1, S1, V1ᴴ, ϵ1 = @constinferred svd_trunc(A; alg, trunc=truncrank(r))
 #             @test length(S1.diag) == r
 #             @test LinearAlgebra.opnorm(A - U1 * S1 * V1ᴴ) ≈ S₀[r + 1]
 #
 #             s = 1 + sqrt(eps(real(T)))
 #             trunc2 = trunctol(; atol=s * S₀[r + 1])
 #
-#             U2, S2, V2ᴴ, ϵ2 = @constinferred svd_trunc_with_err(A; alg, trunc=trunctol(; atol=s * S₀[r + 1]))
+#             U2, S2, V2ᴴ, ϵ2 = @constinferred svd_trunc(A; alg, trunc=trunctol(; atol=s * S₀[r + 1]))
 #             @test length(S2.diag) == r
 #             @test U1 ≈ U2
 #             @test S1 ≈ S2

test/chainrules.jl

@@ -12,7 +12,7 @@ for f in
     (
         :qr_compact, :qr_full, :qr_null, :lq_compact, :lq_full, :lq_null,
         :eig_full, :eig_trunc, :eig_vals, :eigh_full, :eigh_trunc, :eigh_vals,
-        :svd_compact, :svd_trunc, :svd_trunc_with_err, :svd_vals,
+        :svd_compact, :svd_trunc, :svd_trunc_no_error, :svd_vals,
         :left_polar, :right_polar,
     )
     copy_f = Symbol(:copy_, f)
@@ -430,12 +430,12 @@ end
                 ΔUtrunc = ΔU[:, ind]
                 ΔVᴴtrunc = ΔVᴴ[ind, :]
                 test_rrule(
-                    copy_svd_trunc_with_err, A, truncalg ⊢ NoTangent();
+                    copy_svd_trunc, A, truncalg ⊢ NoTangent();
                     output_tangent = (ΔUtrunc, ΔStrunc, ΔVᴴtrunc, zero(real(T))),
                     atol = atol, rtol = rtol
                 )
                 test_rrule(
-                    copy_svd_trunc, A, truncalg ⊢ NoTangent();
+                    copy_svd_trunc_no_error, A, truncalg ⊢ NoTangent();
                     output_tangent = (ΔUtrunc, ΔStrunc, ΔVᴴtrunc),
                     atol = atol, rtol = rtol
                 )
@@ -452,12 +452,12 @@ end
             ΔUtrunc = ΔU[:, ind]
             ΔVᴴtrunc = ΔVᴴ[ind, :]
             test_rrule(
-                copy_svd_trunc_with_err, A, truncalg ⊢ NoTangent();
+                copy_svd_trunc, A, truncalg ⊢ NoTangent();
                 output_tangent = (ΔUtrunc, ΔStrunc, ΔVᴴtrunc, zero(real(T))),
                 atol = atol, rtol = rtol
             )
             test_rrule(
-                copy_svd_trunc, A, truncalg ⊢ NoTangent();
+                copy_svd_trunc_no_error, A, truncalg ⊢ NoTangent();
                 output_tangent = (ΔUtrunc, ΔStrunc, ΔVᴴtrunc),
                 atol = atol, rtol = rtol
             )
@@ -485,13 +485,13 @@ end
             trunc = truncrank(r)
             ind = MatrixAlgebraKit.findtruncated(diagview(S), trunc)
             test_rrule(
-                config, svd_trunc_with_err, A;
+                config, svd_trunc, A;
                 fkwargs = (; trunc = trunc),
                 output_tangent = (ΔU[:, ind], ΔS[ind, ind], ΔVᴴ[ind, :], zero(real(T))),
                 atol = atol, rtol = rtol, rrule_f = rrule_via_ad, check_inferred = false
             )
             test_rrule(
-                config, svd_trunc, A;
+                config, svd_trunc_no_error, A;
                 fkwargs = (; trunc = trunc),
                 output_tangent = (ΔU[:, ind], ΔS[ind, ind], ΔVᴴ[ind, :]),
                 atol = atol, rtol = rtol, rrule_f = rrule_via_ad, check_inferred = false
@@ -500,13 +500,13 @@ end
         trunc = trunctol(; atol = S[1, 1] / 2)
         ind = MatrixAlgebraKit.findtruncated(diagview(S), trunc)
         test_rrule(
-            config, svd_trunc_with_err, A;
+            config, svd_trunc, A;
             fkwargs = (; trunc = trunc),
             output_tangent = (ΔU[:, ind], ΔS[ind, ind], ΔVᴴ[ind, :], zero(real(T))),
             atol = atol, rtol = rtol, rrule_f = rrule_via_ad, check_inferred = false
         )
         test_rrule(
-            config, svd_trunc, A;
+            config, svd_trunc_no_error, A;
             fkwargs = (; trunc = trunc),
             output_tangent = (ΔU[:, ind], ΔS[ind, ind], ΔVᴴ[ind, :]),
             atol = atol, rtol = rtol, rrule_f = rrule_via_ad, check_inferred = false