fix: correct the out-of-domain DomainError messages

The `lazy"..."` literal introduced for the negative-eigenvalue error does
not process the `\` line continuation, so the rendered message contained a
literal backslash, newline and indentation. Use ordinary string
concatenation, as elsewhere in this file, and report the tolerance under
its user-facing name `domain_atol` rather than `atol`.

Restore the distinction between the real ("a negative real eigenvalue")
and complex ("an eigenvalue on the negative real axis") variants by
passing the description to the shared helper, and give
`_check_nonzero_eigenvalues` the same `@noinline` throw helper so both
domain checks stay free of error-path code on the GPU.

Thread `domain_atol` back into the diagonal kernels invoked by the
`squareroot` eigendecomposition paths, and let the `DiagonalAlgorithm`
kernel reuse `_clamp_domain_eigenvalues!` again so it matches `power!`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: lkdvos

src/implementations/matrixfunctions.jl

@@ -1,20 +1,33 @@
 # Shared helpers for matrix functions with a restricted domain
 # -------------------------------------------------------------
 
+# The throwing branches live in `@noinline` helpers so that the reductions and broadcasts
+# below stay free of error-path code, which keeps them GPU friendly.
+@noinline function throw_negative_eigenvalue(λmin, atol, what)
+    return throw(
+        DomainError(
+            λmin,
+            "The matrix has $what beyond `domain_atol = $atol` and the result of this matrix function is complex. " *
+                "Pass a complex matrix to obtain the principal value, or increase `domain_atol` if the eigenvalue is a rounding artifact."
+        )
+    )
+end
+
+@noinline function throw_zero_eigenvalue(amin, atol)
+    return throw(
+        DomainError(
+            amin,
+            "The matrix has a (numerically) zero eigenvalue within `domain_atol = $atol`, for which this matrix function is not defined."
+        )
+    )
+end
+
 # Clamp real eigenvalues that are negative within `atol` (rounding artifacts) to zero,
 # and throw a `DomainError` for eigenvalues that are genuinely negative, since then the
 # result cannot be expressed with the same (real) scalar type.
 function _clamp_domain_eigenvalues!(λ::AbstractVector{<:Real}, atol::Real)
     λmin = minimum(λ; init = zero(eltype(λ)))
-    if λmin < -atol
-        throw(
-            DomainError(
-                λmin,
-                "The matrix has a negative real eigenvalue beyond `domain_atol = $atol` and the result of this matrix function is complex. " *
-                    "Pass a complex matrix to obtain the principal value, or increase `domain_atol` if the eigenvalue is a rounding artifact."
-            )
-        )
-    end
+    λmin < -atol && throw_negative_eigenvalue(λmin, atol, "a negative real eigenvalue")
     λ .= max.(λ, zero(eltype(λ)))
     return λ
 end
@@ -32,15 +45,7 @@ end
 function _clamp_domain_eigenvalues!(λ::AbstractVector{<:Complex}, atol::Real)
     onaxis = x -> abs(imag(x)) <= atol && real(x) < 0
     λmin = mapreduce(x -> onaxis(x) ? real(x) : zero(real(x)), min, λ; init = zero(real(eltype(λ))))
-    if λmin < -atol
-        throw(
-            DomainError(
-                λmin,
-                "The matrix has an eigenvalue on the negative real axis beyond `domain_atol = $atol` and the result of this matrix function is complex. " *
-                    "Pass a complex matrix to obtain the principal value, or increase `domain_atol` if the eigenvalue is a rounding artifact."
-            )
-        )
-    end
+    λmin < -atol && throw_negative_eigenvalue(λmin, atol, "an eigenvalue on the negative real axis")
     λ .= ifelse.(onaxis.(λ), zero(eltype(λ)), λ)
     return λ
 end
@@ -49,14 +54,7 @@ end
 # e.g. `logarithm` and `power` with a negative fractional power.
 function _check_nonzero_eigenvalues(λ, atol::Real)
     amin = minimum(abs, λ; init = typemax(real(eltype(λ))))
-    if amin <= atol
-        throw(
-            DomainError(
-                amin,
-                "The matrix has a (numerically) zero eigenvalue within `domain_atol = $atol`, for which this matrix function is not defined."
-            )
-        )
-    end
+    amin <= atol && throw_zero_eigenvalue(amin, atol)
     return λ
 end
 

src/implementations/squareroot.jl

@@ -38,9 +38,8 @@ function squareroot!(A::AbstractMatrix, sqrtA, alg::MatrixFunctionViaLA)
     # `LinearAlgebra.sqrt` of a real matrix is real whenever the principal square root is,
     # so a complex result with a real output signals a genuine domain violation
     sqrtAc = LinearAlgebra.sqrt(A)
-    if eltype(sqrtAc) <: Complex && !(eltype(sqrtA) <: Complex)
+    eltype(sqrtAc) <: Complex && !(eltype(sqrtA) <: Complex) &&
         throw(_realness_domainerror(squareroot!))
-    end
     copy!(sqrtA, sqrtAc)
     return sqrtA
 end
@@ -50,8 +49,7 @@ function squareroot!(A::AbstractMatrix, sqrtA, alg::MatrixFunctionViaEigh)
     D, V = eigh_full!(A, alg.eigh_alg)
     diag_alg = DiagonalAlgorithm(; domain_atol = alg.domain_atol)
     # `sqrt(A) = (V * D^(1/4)) * (V * D^(1/4))'` is hermitian by construction
-    sqrtD = squareroot!(D, D, diag_alg)
-    Vs = rmul!(V, squareroot!(sqrtD, sqrtD, diag_alg))
+    Vs = rmul!(V, power!(D, 1 // 4, D, diag_alg))
     return _mul_herm!(sqrtA, Vs)
 end
 

src/interface/logarithm.jl

@@ -11,18 +11,14 @@ Compute the principal logarithm `logA` of the square matrix `A`, i.e. the logari
 whose eigenvalues have imaginary part in `(-π, π]`.
 
 The scalar type of the output matches that of the input.
-As a consequence, a real matrix with eigenvalues on the negative real axis, for which
-the principal logarithm is complex, leads to a `DomainError`; pass a complex matrix
-to obtain the principal value.
-A matrix with (numerically) zero eigenvalues has no logarithm and also leads to a
-`DomainError`.
+As a consequence, a real matrix with eigenvalues on the negative real axis, for which the principal logarithm is complex, leads to a `DomainError`; pass a complex matrix to obtain the principal value.
+A matrix with (numerically) zero eigenvalues has no logarithm and also leads to a `DomainError`.
 Both checks use a tolerance `domain_atol`, which can be specified for the algorithms
 that support it and defaults to [`default_domain_atol`](@ref).
 
 !!! note
-    The bang method `logarithm!` 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 `logA` as output.
+    The bang method `logarithm!` 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 `logA` as output.
 """
 @functiondef logarithm