Raíz cúbica del número negativo en python

Question

¿Alguien me puede ayudar a encontrar una solución sobre cómo calcular una raíz cúbica del número negativo usando python?

>>> math.pow(-3, float(1)/3) 
nan 

no funciona. La raíz cúbica del número negativo es número negativo. Alguna solución?

Answer 1

que puede usar:

-math.pow(3, float(1)/3) 

o más en general:

if x > 0: 
    return math.pow(x, float(1)/3) 
elif x < 0: 
    return -math.pow(abs(x), float(1)/3) 
else: 
    return 0 

Answer 2

solución primitiva:

def cubic_root(nr): 
    if nr<0: 
    return -math.pow(-nr, float(1)/3) 
    else: 
    return math.pow(nr, float(1)/3) 

Probablemente masivamente no Pythonic, pero debería funcionar.

Answer 3

math.pow(abs(x),float(1)/3) * (1,-1)[x<0] 

Answer 4

Tomando las respuestas anteriores y haciéndolo en una sola línea:

import math 
def cubic_root(x): 
    return math.copysign(math.pow(abs(x), 1.0/3.0), x) 

Answer 5

También puede incluir la biblioteca libm que ofrece una función cbrt (raíz cúbica):

from ctypes import * 
libm = cdll.LoadLibrary('libm.so.6') 
libm.cbrt.restype = c_double 
libm.cbrt.argtypes = [c_double] 
libm.cbrt(-8.0) 

da el esperado

-2.0 

Answer 6

La raíz cúbica de un número negativo es solo el negativo de la raíz cúbica del valor absoluto de ese número.

es decir, x^(1/3) para x < 0 es lo mismo que (-1) * (| x |)^(1/3)

Simplemente haga su número positivo, y luego realizar cúbico raíz.

Answer 7

Un uso simple de De Moivre's formula, es suficiente para mostrar que la raíz cúbica de un valor, independientemente del signo, es una función con múltiples valores. Eso significa que, para cualquier valor de entrada, habrá tres soluciones. La mayoría de las soluciones presentadas hasta ahora solo devuelven la raíz principal. A continuación, se muestra una solución que devuelve todas las raíces válidas y pruebas explícitas para casos especiales no complejos.

import numpy 
import math 
def cuberoot(z): 
    z = complex(z) 
    x = z.real 
    y = z.imag 
    mag = abs(z) 
    arg = math.atan2(y,x) 
    return [ mag**(1./3) * numpy.exp(1j*(arg+2*n*math.pi)/3) for n in range(1,4) ] 

Editar: a lo solicitado, en los casos en que no es apropiado tener dependencia de numpy, el código siguiente hace lo mismo.

def cuberoot(z): 
    z = complex(z) 
    x = z.real 
    y = z.imag 
    mag = abs(z) 
    arg = math.atan2(y,x) 
    resMag = mag**(1./3) 
    resArg = [ (arg+2*math.pi*n)/3. for n in range(1,4) ] 
    return [ resMag*(math.cos(a) + math.sin(a)*1j) for a in resArg ] 

Answer 8

Puede obtener la completa (todas las raíces n) y más general (ninguna señal, ningún poder) solución usando:

import cmath 

x, t = -3., 3 # x**(1/t) 

a = cmath.exp((1./t)*cmath.log(x)) 
p = cmath.exp(1j*2*cmath.pi*(1./t)) 

r = [a*(p**i) for i in range(t)] 

Explicación: una es usando la ecuación x ^u = exp (u * log (x)). Esta solución será entonces una de las raíces, y para obtener las otras, rotarla en el plano complejo en una (rotación completa)/t.

Answer 9

Puede utilizar cbrt de scipy.special:

>>> from scipy.special import cbrt 
>>> cbrt(-3) 
-1.4422495703074083 

Esto también funciona para las matrices.

Answer 10

Acabo de tener un problema muy similar y encontré la solución NumPy de this forum post.

En una descripción, podemos utilizar los métodos NumPy sign y absolute para ayudarnos. Aquí está un ejemplo que ha trabajado para mí:

import numpy as np 

x = np.array([-81,25]) 
print x 
#>>> [-81 25] 

xRoot5 = np.sign(x) * np.absolute(x)**(1.0/5.0)  
print xRoot5 
#>>> [-2.40822469 1.90365394] 

print xRoot5**5 
#>>> [-81. 25.] 

Así que volviendo a la raíz del problema cubo original:

import numpy as np 

y = -3. 
np.sign(y) * np.absolute(y)**(1./3.) 
#>>> -1.4422495703074083 

espero que esto ayude.

Answer 11

Para una aritmética, respuesta calculadora-como en Python 3:

>>> -3.0**(1/3) 
-1.4422495703074083 

o -3.0**(1./3) en Python 2.

Para la solución algebraica de x**3 + (0*x**2 + 0*x) + 3 = 0 uso numpy:

>>> p = [1,0,0,3] 
>>> numpy.roots(p) 
[-3.0+0.j   1.5+2.59807621j 1.5-2.59807621j] 

Answer 12

este también funciona con numpy array:

cbrt = lambda n: n/abs(n)*abs(n)**(1./3)