Is an irrational root of a real number imaginary or real?

[hkBattousai]

We can easily comment the result of a root operation just by the information if the degree of the root is odd or even.

But what if the degree of the root (or power) is irrational?

For example;
$-64 ^ \frac{1}{2} \, = \, j8 \,\,\,\,\, (imaginary)$
$-64 ^ \frac{1}{3} \, = \, -4 \,\,\,\,\, (real)$

But what about:
$+7^{\pi - 3} \, = \, 7^{0.14159265...}$
Is it real, imaginary or complex?

 

[disregardthat]

$$a^r=e^{r Log a}$$ is a root for this exponent and is real for all positive a. Hence 7^pi has a real root. For negative a however we have $$\log a = (2\pi k+\pi) i + Log |a|$$, so $$a^r=e^{r(2\pi k+\pi) i+r Log |a|}=|a|^re^{r(2\pi k+\pi) i}$$ which is real only when $$e^{r(2\pi k+\pi) i }$$ is real. There is a real solution whenever $$\sin((2\pi k+\pi)i) = 0$$ has a solution for an integer k, that is whenever r(2k+1) is an integer. Hence for negative a and irrational r you will get that a^r is not real.

Note that you cannot speak of "the" root. If r is an integer there are r roots of which only some may be real. For irrational r you will infinitely many roots, but if a is negative, all of them are non-real.

 

[mathwonk]

Every positive real number has the form e^r for some real number r. Thus for any positive real number a = e^r, and any real number x, we have a^x = (e^r)^x = e^(rx).

Moreover, there is a power series for computing any power of e, i.e.
e^y = 1 + y + y^2/2+ y^3/(2.3) +... Thus for any real number y, e^y is also real.

And thus for any positive real number a = e^r, and any real number x, then a^x = e^(rx), is also real.

 

[Mark44]

We can easily comment the result of a root operation just by the information if the degree of the root is odd or even.

But what if the degree of the root (or power) is irrational?

For example;
$-64 ^ \frac{1}{2} \, = \, j8 \,\,\,\,\, (imaginary)$
$-64 ^ \frac{1}{3} \, = \, -4 \,\,\,\,\, (real)$

Neither of the other responders noticed this, so I will comment on it. Your first equation is incorrect.
-64^1/2 = $-\sqrt{64}$ = -8, a real number.

What you no doubt meant but wrote incorrectly was (-64)^1/2, which we math people write as 8i.

 

[disregardthat]

Neither of the other responders noticed this, so I will comment on it. Your first equation is incorrect.
-64^1/2 = $-\sqrt{64}$ = -8, a real number.

What you no doubt meant but wrote incorrectly was (-64)^1/2, which we math people write as 8i.

He presumably meant (-64)^(1/2) and wrote j8 where j is the imaginary unit.

 

[hkBattousai]

Thanks for the correction.
"j" is the imaginary unit for engineer people...

 

[HallsofIvy]

Oh, those engineers and their jmaginary numbers!

 

[hkBattousai]

$$a^r=e^{r Log a}$$ is a root for this exponent and is real for all positive a. Hence 7^pi has a real root. For negative a however we have $$\log a = (2\pi k+\pi) i + Log |a|$$, so $$a^r=e^{r(2\pi k+\pi) i+r Log |a|}=|a|^re^{r(2\pi k+\pi) i}$$ which is real only when $$e^{r(2\pi k+\pi) i }$$ is real. There is a real solution whenever $$\sin((2\pi k+\pi)i) = 0$$ has a solution for an integer k, that is whenever r(2k+1) is an integer. Hence for negative a and irrational r you will get that a^r is not real.

Note that you cannot speak of "the" root. If r is an integer there are r roots of which only some may be real. For irrational r you will infinitely many roots, but if a is negative, all of them are non-real.

Can I conclude the following equation from your text?

$ln(z)\,=\,ln(re^{j\theta})\,=\,ln(r)\,+\,j(2\pi k\,+\,\theta)$

 

[disregardthat]

Can I conclude the following equation from your text?

$ln(z)\,=\,ln(re^{j\theta})\,=\,ln(r)\,+\,j(2\pi k\,+\,\theta)$

These are the values for the multivalued function ln(z). You would need a rule for choosing k i order to get a function out of this, and that is what we call branches for multivalued functions like log. We usually use the principal value http://en.wikipedia.org/wiki/Complex_logarithm#Definition_of_principal_value.

 

[hkBattousai]

Here is my code, looks like to be working fine for now:

These are working OK:

long double Math::exp(long double num)
{
	long double Ret = 0;
	//long double f, p;
	for (uint8_t i=0; i<=m_PRECISION_TAYLOR_FACTORIAL; i++)
	{
		Ret += UnsignedIntegerPower(num, i) / fact(i);
	}
	return Ret;
}

long double Math::ln(long double num)
{
	long double x_k = 1.0, x_k1;
	for (uint8_t i=0; i<m_PRECISION_NEWTON_QUADRATIC; i++)
	{
		x_k1 = x_k + num * exp(-x_k) - 1.0;
		if (abs(x_k1 - x_k) < m_PRECISION_EPSILON) break;
		x_k = x_k1;
	}
	return x_k1;
}

long double Math::pow(long double base, long double exponent)
{
	bool bNegateResult;
	if ((base < 0.0) && (IsInteger(exponent) == false))
	{			// complex result
		return 0.0;	// we are not dealing with it
	}			// use "ComplexNumber" class for it
	else if ((base < 0.0) && IsOdd(exponent))
	{
		bNegateResult = true;
	}
	else	// if (((base < 0) && IsEven(exponent)) || (base >= 0))
	{
		bNegateResult = false;
	}
	double long Ret = exp(exponent * ln(abs(base)));
	return bNegateResult ? -Ret : Ret;
}

long double Math::root(long double base, long double degree)
{
	return pow(base, static_cast<long double>(1.0) / degree);
}

I haven't test ComplexNumber methods yet:

ComplexNumber::ComplexNumber(	long double dbRealPartOrRadius/* = 0.0*/,
				long double dbImaginaryPartOrAngle/* = 0.0*/,
				bool bIsRadial/* = false*/)
{
	if (bIsRadial)
	{
		dbRealPartOrRadius = RadialToRealPart(dbRealPartOrRadius, dbImaginaryPartOrAngle);
		dbImaginaryPartOrAngle = RadialToImaginaryPart(dbRealPartOrRadius, dbImaginaryPartOrAngle);
	}
	else
	{
		m_dbRealPart = dbRealPartOrRadius;
		m_dbImaginaryPart = dbImaginaryPartOrAngle;
	}
}

ComplexNumber ComplexNumber::Power(ComplexNumber cn, long double dbDegree)
{
	//long double radius, theta;
	//radius = Math::pow(cn.GetRadius(), dbDegree);
	//theta = Math::GetRreferenceAngle(dbDegree * cn.GetAngle());
	ComplexNumber Ret(	Math::pow(cn.GetRadius(), dbDegree),
				Math::GetRreferenceAngle(dbDegree * cn.GetAngle()),
				true);
	return Ret;
}

std::vector<ComplexNumber> ComplexNumber::FindRoots(ComplexNumber cn, uint64_t nDegree)
{
	std::vector<ComplexNumber> Roots;
	ComplexNumber FirstRoot = Power(cn, 1.0 / static_cast<long double>(nDegree));
	long double radius, theta;
	radius = FirstRoot.GetRadius();
	theta = FirstRoot.GetAngle();
	for (uint64_t k = 0; k<nDegree; k++)
	{
		ComplexNumber ARoot(radius, theta + k * 2.0 * Math::PI / static_cast<long double>(nDegree));
		Roots.push_back(ARoot);
	}
	return Roots;
}