Question

我正在寻找Python Nth根函数/算法但在发布之前：没有INTEGER ROOT，HELL！
我在哪里可以获得至少一个如何编程第N个根函数的指南，该函数可以产生精确的float / Decimal ？对于1 ，不返回0或root(125, 1756482845)这样的功能（第一个参数是数字，第二个是根深度（或其他））。< / p>

编辑：所以，你给我这个解决方案：n ** (1.0 / exp)我在问这个问题时就知道了，但它不适用于，例如，{{1 }}。您无法用有理数表达exp = 3，因此1/3会给出错误的结果125 ** (1/3)。我要求一些“智能”算法，它为这样好的数字提供了正确的结果，并为理性4.999999...提供了至少4个小数点精确的结果。如果没有这样的功能或算法，我将使用它（exp）。

Answer 1

我会尝试gmpy2库。

>>> import gmpy2
>>> gmpy2.root(125,3)
mpfr('5.0')
>>>

gmpy2使用MPFR库来执行正确的舍入浮点运算。默认精度为53位，但可以增加。

>>> gmpy2.root(1234567890123456789**11, 11)
mpfr('1.2345678901234568e+18')  # Last digits are incorrect.
>>> gmpy2.get_context().precision=200
>>> gmpy2.root(1234567890123456789**11, 11)
mpfr('1234567890123456789.0',200)
>>>

免责声明：我保留gmpy2。

Answer 2

您可以对答案进行二元搜索。如果你想找到等于N的第k个根的X，你可以对二进制搜索的每一步进行X检验的二元搜索，无论X ^ k是否等于N + - 一些小常数以避免精度问题。 / p>

以下是代码：

import math

N,K = map(float,raw_input().split()) # We want Kth root of N
lo = 0.0
hi = N
while 1:
    mid = (lo+hi)/2
    if math.fabs(mid**K-N) < 1e-9: # mid^K is really close to N, consider mid^K == N
        print mid
        break
    elif mid**K < N: lo = mid
    else: hi = mid

对于（N，K）=（125,3），它打印5.0，正确的答案。您可以通过更改1e-9常量来使其更精确，但是在Python中存在与浮点变量精度限制相关的精度限制

Answer 3

你的意思是这样的：

>>> 125**(1/9.0)
1.7099759466766968

你可能感兴趣的其他东西是bigfloat模块（没有亲自使用，只知道它存在:) - 实际上在过去安装它时遇到了问题 - 可能是OS X故障）

Answer 4

在Squeak Smalltalk中，有一条nthRoot:消息可以回答确切的Integer结果，如果整数接收器确实是某个整数的n次幂。但是，如果解决方案是代数根，那么实现不会回退到天真的n**(1/exp);该方法通过适当照顾残差来舍入到最近的浮点数。

此处转载相关代码（MIT许可证）。基本算法使用一些Newton-Raphson：

搜索Integer的截断的第n个根

Integer>>nthRootTruncated: aPositiveInteger
    "Answer the integer part of the nth root of the receiver."
    | guess guessToTheNthMinusOne nextGuess |
    self = 0 ifTrue: [^0].
    self negative
        ifTrue:
            [aPositiveInteger even ifTrue: [ ArithmeticError signal: 'Negative numbers don''t have even roots.' ].
            ^(self negated nthRootTruncated: aPositiveInteger) negated].
    guess := 1 bitShift: self highBitOfMagnitude + aPositiveInteger - 1 // aPositiveInteger.
    [
        guessToTheNthMinusOne := guess raisedTo: aPositiveInteger - 1.
        nextGuess := (aPositiveInteger - 1 * guess * guessToTheNthMinusOne + self) // (guessToTheNthMinusOne * aPositiveInteger).
        nextGuess >= guess ] whileFalse:
            [ guess := nextGuess ].
    ( guess raisedTo: aPositiveInteger) > self  ifTrue:
            [ guess := guess - 1 ].
    ^guess

这并不是特别聪明，因为在巨大指数的情况下收敛可能非常慢，但是，它很有效。然后，相同的根从零开始舍入：

Integer>>nthRootRounded: aPositiveInteger
    "Answer the integer nearest the nth root of the receiver."
    | guess |
    self = 0 ifTrue: [^0].
    self negative
        ifTrue:
            [aPositiveInteger even ifTrue: [ ArithmeticError signal: 'Negative numbers don''t have even roots.' ].
            ^(self negated nthRootRounded: aPositiveInteger) negated].
    guess := self nthRootTruncated: aPositiveInteger.
    ^self * 2 > ((guess + 1 raisedTo: aPositiveInteger) + (guess raisedTo: aPositiveInteger))
        ifTrue: [guess + 1]
        ifFalse: [guess]

然后在nthRoot中测试精确度：

Integer>>nthRoot: aPositiveInteger
    "Answer the nth root of the receiver.
    Answer an Integer if root is exactly this Integer, else answer the Float nearest the exact root."

    | guess excess scaled nBits |
    guess := self nthRootRounded: aPositiveInteger.
    excess := (guess raisedTo: aPositiveInteger) - self.
    excess = 0 ifTrue: [ ^ guess ].

    nBits := Float precision - guess highBitOfMagnitude.
    nBits <= 0 ifTrue: [ ^(Fraction numerator: guess * 4 - excess sign denominator: 4) asFloat].

    scaled := self << (nBits * aPositiveInteger).
    guess := scaled nthRootRounded: aPositiveInteger.
    excess := (guess raisedTo: aPositiveInteger) - scaled.
    ^(Fraction numerator: guess * 4 - excess sign denominator: 1 << (nBits + 2)) asFloat

这也可以应用于Fraction，但是最近的浮点数有点复杂，而且Squeak的实现目前很幼稚。

适用于大整数，如：

(10 raisedTo: 600) nthRoot: 300 - ＆gt; 100“确切”
(10 raisedTo: 600) + 1 nthRoot: 300 - ＆gt; 100.0“不准确”

如果你没有这样的期望，最初的猜测可能会使用不精确的天真n**(1/exp)。

代码应易于在Python中移植，并为优化留下了很多空间。

我没有检查Python中可用的内容，但也许你需要正确舍入的LargeInteger - ＆gt;浮动和分数 - ＆gt;浮动，就像这里解释的那样（Smalltalk也是抱歉的，但语言并不重要）。

Answer 5

这是pow模块的函数math。

import math
math.pow(4, 0.5)

将返回4的平方根，即2.0。

对于root(125, 1756482845)，您需要做的是

math.pow(125, 1.0 / 1756482845)

精确的第n根

5 个答案: