Replace power operator with inline multiplications about cubicequationsolver

[RNavega]

Hi @shril, the output list comes from timeit.repeat() and is the time taken, in seconds, to call the piece of code one million times.
There's three results because repeat() profiles it three times by default, so we can see what was the best (the smallest) time.

On all three repeats the inline multiplication was faster.
x*x*x*x is faster than x**4 for example.

Edit: I'll look into a PR.

[shril]

@RNavega can you please explain the output list? And please further raise a PR.
@devojoyti please look into this.

[shril]

@RNavega thanks. Please raise a PR.

[RNavega]

@shril sorry for the delay, end of year. I'll work on a PR, thank you.

[RNavega]

I don't know if a PR would be useful.
If you're using Python 3+ and your a, b, c, d coefficients are always float values, then you can use this shortened code (this code starts at the findF, findG and findH calls, which were inlined):

    f = ((3.0 * c / a) - ((b*b) / (a*a))) / 3.0
    _a2 = a*a
    g = (((2.0 * (b*b*b)) / (_a2*a)) - ((9.0 * b * c) / _a2) + (27.0 * d / a)) / 27.0
    h = ((g*g) / 4.0 + (f*f*f) / 27.0)

    if f == g == h == 0:                # All 3 Roots are Real and Equal
        d_a = (d / a)
        x = (d_a ** 0.33333333333333333) if d_a >= 0.0 else -((-d_a) ** 0.33333333333333333) # 0.333... = (1.0 / 3.0)
        return np.array((x, x, x))

    elif h <= 0.0:                        # All 3 roots are Real
        i = sqrt(((g*g) / 4.0) - h)
        j = i ** 0.33333333333333333
        k_ = acos(-g / (2 * i)) / 3.0
        L = -j
        M = cos(k_)   
        N = 1.73205080756887729 * sin(k_) # 1.732... = sqrt(3.0)
        P = -b / (3.0 * a)

        x1 = 2.0 * j * M + P
        x2 = L * (M + N) + P
        x3 = L * (M - N) + P
        return np.array((x1, x2, x3))

    else:                               # One Real Root and two Complex Roots
        hSqr = sqrt(h)
        gH = -g / 2.0
        R = (gH + hSqr)
        S = R ** 0.33333333333333333 if R >= 0.0 else -((-R) ** 0.33333333333333333)
        T = (gH - hSqr)
        U = T ** 0.33333333333333333 if T >= 0.0 else -((-T) ** 0.33333333333333333)
        return np.array(((S + U) - (b / (3.0 * a)), ))

This was done reading your code as well as following the main reference (www.1728.org/cubic2.htm).

edit: This removes a few arithmetic operations as well as one redundant sqrt() and cos() calls.

[RNavega]

Oops, now I get why you're negating values below zero if they're being cubic-rooted. If not, the numbers become complex.
I added that back.