As you saw above, I separately verified the roots are correct by substituting them back into the original equation. It seems highly improbable that Solve would get the answer wrong and then Mathematica would suddenly be unable to compute a polynomial numerically (and in a way that happens to exactly match an error in the Solve routine). It seems most likely that your reference has an error since it appears to have been derived manually (or there was a typographical error). For completeness, I tried this expression in an independent complex number calculator and I do not get your answer.

x≈-1.46272237563773 - 1.44560206980216 i x^5-3x^(2+0.3i)-32=-4,439712865010737 + 21,40303899299964 I

I get 0.

I gather you are seeking a way to handle such equations using different branches of the logarithm. That can be done by defining your own power function, parametrized by integers.

myPower[x_, y_, n_Integer] := Exp[y*(Log[x] + 2*Pi*I*n)]

For example:

x^5 - 3*myPower[x, 2 + .3*I, 1] - 32 /. 
 x -> -1.5940218425876456 - 1.2172363174830494*I

(*Out[10]= -4.26326*10^-14 - 1.86517*10^-14 I *)

This is likely to be the simplest way to go about working with such expressions.

As for built in Power, I can guarantee that behavior will not be changed.

Sergey,

Michael's answer seems correct to me to machine precision. You get a warning about machine precision and an answer. The warning is that you are only getting answers to machine precision and no better. You can get better precision if you use 3/10 instead of 0.3 and you can them specify any precision you want. For example:

In[22]:= ans = 
 Solve[x^5 - 3 x^(2 + 3 I/10) - 32 == 0 && -10 < Re[x] < 10 && -10 < 
    Im[x] < 10, x, WorkingPrecision -> 50]

Out[22]= {{x -> -1.6109463314351326392988566553712692531598610618242 \
+ 1.2464743105597007675161723821942332067829191674769 I}, {x -> \
-1.4627223756377303297165335908679364247281052953771 - 
    1.4456020698021564339153511956933357083440670693014 I}, {x -> 
   0.4163131764243939365848417988905193285864645894657 - 
    1.8028491278527650010864755199413635992617259467944 I}, {x -> 
   0.5487474851393810132123387637492439707377603539200 + 
    1.8272260736037174136816701325357997471978574779219 I}, {x -> 
   2.1448022395172964092246332752422095752340324284946 + 
    0.0334120451626065251059523893164733974520934509475 I}}

You can confirm your answer with:

In[23]:= x^5 - 3 x^(2 + 3 I/10) - 32 /. ans

Out[23]= {0.*10^-48 + 0.*10^-48 I, 0.*10^-48 + 0.*10^-48 I, 
 0.*10^-48 + 0.*10^-48 I, 0.*10^-48 + 0.*10^-48 I, 
 0.*10^-48 + 0.*10^-48 I}

So you are getting close to 50 digits of precision here.

Michael's answer was correct to machine precision (15 digits on my machine) with is usually all anyone ever needs.

Regards,

Neil

Yes. if n=-1 when x^(2+3i/10) (X+xi)^(Y+yi)=e^((Y+yi)*Ln(X+xi)) Ln(X+xi)=ln((X^2+x^2)^(1/2))+i(f+2Pn), tg(f)=x/X, n=0,1,2...

x ≈ 0.4163131764243939365848417988905193285865 - 1.802849127852765001086475519941363599262 i when (X+xi)^(Y+yi)=e^((Y+yi)*Ln(X+xi)) Ln(X+xi)=ln((X^2+x^2)^(1/2))+i(f+2Pn), tg(f)=x/X, n=-1

Thanks for the clear answer. It turns out that mathematics depends on programmers for all resources. I know of only 2 resources that are oriented in branching after the complex logarithm. But their programmers can't work with big numbers. They use number type = number. It has an accuracy of only 2^52. And Wolfram's accuracy is unlimited. For the sake of mathematicians who need it, ask your programmers to work with ramifications after the complex logarithm.

It is not difficult to create this order. It is enough to focus on the value of the value "n" in the complex logarithm formula. They can use the existing experience of these resources. Everything is simple there. Each root, each branch on its shelf. The shelf shows who was received and how, and this is enough to know with whom and how to work. I'm attaching to this post a research report on ultra-radical function. See how easy it is to navigate through different roots, different branches. Any student will understand this.