nthroot function

[stevengj]

@oscardssmith mentioned on discourse that IEEE 2018 recommends an nthroot(x, n) that computes the real nth-root of a real x, similar to the Matlab function nthroot and generalizing cbrt.

A possible implementation could be as simple as:

nthroot(x::Real, n::Integer) =
    isodd(n) || x ≥ 0 ? copysign(abs(x)^(1//n), x) :
    throw(DomainError("Exponentiation yielding a complex result requires a complex argument.  Replace nthroot(x, n) with complex(x)^(1//n)."))

though it's possible that we could have faster/more-accurate implementations in some special cases.

As discussed in #36534, it probably only makes sense to define this for x::Real arguments.

[mikmoore]

It seems that hermitian matrices should also have a compatible nthroot definition. That extension could be deferred to a follow-up PR, however.

EDIT: The discussion on discourse makes me think that we might actually want to provide a more general version of nthroot that extends to rational powers (proposed as realpow there, although that name wouldn't translate to hermitian matrices). nthroot(x,d)^n for x^(n//d) is probably passable for Real but would be rather inefficient for matrices.

[stevengj]

I would think that there should be an nthroot for any real matrix that returns a real result, similar to the discussion in JuliaLang/LinearAlgebra.jl#966? (Also an nthroot for Hermitian matrices that returns a Hermitian result.)

In principle, I agree that there might be a place for a realpow(x, p//n) that computes nthroot(x, n)^p, but note that this is very different from nthroot(x^p, n), which could be a bit confusing.

Alternatively, we could just have a method nthroot(x, n, p=1) to compute nthroot(x, n)^p, with a default definition nthroot(x::Real, n::Integer, p::Integer) = nthroot(x, n)^p?

[mikmoore]

I suppose triangular matrices with real diagonals also have real eigenvalues. So hermitian and real-diagonal triangular matrices are on the list. What other structures give rise to real eigenvalues? I don't know that I'd support having general matrices support such a function, since that could require hoping that numerical evaluation supports a nthroot-type root to avoid needing to throw an error.

Can you elaborate on the distinction between nthroot(x^p,n) vs nthroot(x,n)^p for reduced fractions p//n? I'm failing to see in what situations a difference arises (in infinite precision). If there is such a hazard, I'd be less supportive of rational powers.

[oscardssmith]

I think the problem is more that reducing the fraction changes the answer. E.G.

julia> ((complex(-1+0im))^(9))^(1/6)
0.8660254037844387 + 0.5im

julia> ((complex(-1+0im))^(3))^(1/2)
0.0 + 1.0im

[mikmoore]

Those two examples both have negative bases and even-denominator powers, so would result in DomainErrors with nthroot for any odd power-numerator (including 1) or any even power-numerator that failed to reduce the power-denominator to an odd. There's no real-valued solution for those examples regardless of the scaling of the exponent numerator/denominator. We've already established that nthroot(x,d) is distinct from ^(x,1//d) in returning real roots (or errors) rather than principle roots. So while nthroot(-1.0,6)^4 would error, any of nthroot((-1.0)^4,6), nthroot((-1.0)^2,3), or nthroot(-1.0,3)^2 would succeed and return an equivalent answer.

[Snimm]

Can I work on this?

[stevengj]

@Snimm, I think we need to first decide whether we want nthroot(x, p) or realpow(x, n//p)?

It sounds like people are leaning towards realpow(x, n//p)? Or should we have both?

• Advantage of nthroot: recommended by IEEE(?) and hence somewhat standardized(?), available in other languages (Matlab and R).
• Advantage of realpow: potentially slightly more efficient (especially if we extend to matrices, although even cbrt doesn't support matrices yet).
• Disadvantage of realpow: potentially confusing that realpow(-1.0, 4//6) is different than realpow(-1.0, 1//6)^4 (since the latter would error). On the other hand, in Julia 4//6 === 2//3 and realpow(-1.0, 2//3) == realpow(-1.0, 1//3)^2 == cbrt(-1.0)^2.

Or maybe we should have both? Or just start with nthroot?

[oscardssmith]

I'd start with nthroot

[matrixbot123]

I'd start with nthroot

what about making the cbrt function . if we use nthroot then cbrt will be less efficient . And the whole purpose of this issue was for writing cbrt function (kinda)

[oscardssmith]

we already have cbrt.

[matrixbot123]

we already have cbrt.

my mistake cbrt(A::AbstractMatrix{<:Real})

[StefanKarpinski]

Ultimately I think that having both makes sense. But implementation can be tackled starting with cbrt for matrices and nthroot. More general realpow can be done later seems like.