I need a method to calculate ln(x) for small x, other than Taylor series method

hkBattousai

I'm aiming to calculate ln(x) numerically. I'm using the following procedure for this:
1) If x is greater or equal to 1, use Newton's method.
2) If x is smaller between 0 and 1, use Taylor series expansion.

Newton's method works good, but I have problems with Taylor series expansion method.
[latex]\ln(1+x)=\sum_{n=1}^\infty \frac{(-1)^{n+1}}{n} x^n = x - \frac{x^2}{2} + \frac{x^3}{3} - \cdots \quad{\rm for}\quad \left|x\right| \leq 1\quad[/latex]
Sum of this series is [latex]\small -\infty\normalsize[/latex] for [latex]\small x=-1\normalsize[/latex], but when you try to take sum of it using a computer, it doesn't converge because of computing limitations (like using truncated series). I can't either use Newton's method for this interval, because it has a bad performance for small x values (neither it converges for small x).

For x=0.000001;
ln(x) = -13.8155... (actual)
ln(x) = -1.71828... (calculated)
(The summation goes on until absolute value of any element of the series is below a user defined [latex]\epsilon[/latex] value, which is equal to [latex]1.0 \times 10^{-14}[/latex] for this particular example.)

I need a third method to calculate ln(x) for small x argument.
Can you please suggest me one?

Pagan Harpoon

Maybe you could try directly evaluating the integral:

[tex]\int^{x}_{1}\frac{1}{x}dx[/tex]

hotvette

Quote by hkBattousai

I'm aiming to calculate ln(x) numerically. I'm using the following procedure for this:
1) If x is greater or equal to 1, use Newton's method.
2) If x is smaller between 0 and 1, use Taylor series expansion.

What's wrong with Newton's method if x < 1? How are you doing it?

hkBattousai

Quote by hotvette

What's wrong with Newton's method if x < 1? How are you doing it?

Code:

// Public method
long double Math::ln(long double num) throw(MathInvalidArgument)
{
	if (num < 0)
	{
		throw(MathInvalidArgument(L"You tried to take ln() of a negative number."));
	}
	else if (num == 0.0)
	{
		long double zero = 0.0;
		return -1.0 / zero;	// return minus infinity
	}
	else if (num <= 1.0)
	{
		return ln_ByTaylorSeriesExpansion(num);
	}
	else
	{
		return ln_ByNewtonsMethod(num);
	}
}

// Private method
long double Math::ln_ByTaylorSeriesExpansion(long double arg)
{
	arg -= 1.0; // We will use series expansion for ln(x+1)
	long double Result = 0.0, NextSum;
	long double power_of_arg_over_i = 1.0;
	for (uint64_t i=1; true; i++)
	{
		power_of_arg_over_i *= arg / static_cast<long double>(i);
		NextSum = -static_cast<long double>(MinusOneToThePowerOf(i)) * power_of_arg_over_i;
		Result += NextSum;
		if (abs(NextSum) < m_PRECISION_EPSILON)
		{
			break;
		}
	}
	return Result;
}

// Private method
long double Math::ln_ByNewtonsMethod(long double arg)
{
	long double x_k = 1.0, x_k1,asd;
	for (uint64_t i=0; true; i++)
	{
		x_k1 = x_k - ((exp(x_k) - arg) / exp(x_k));
		asd = abs(x_k1 - x_k);	// This value does not approach to zero, fluctuating between 10^(-5) and 10^(-6)
		if (abs(x_k1 - x_k) < m_PRECISION_EPSILON) break;	// m_PRECISION_EPSILON is 10^(-14)
		x_k = x_k1;
	}
	return x_k1;
}

LeonhardEuler

power_of_arg_over_i *= arg / static_cast<long double>(i);

Looking over this quickly, it seems like this isn't what you want. It looks like you're going to end up with a factorial on the bottom since the terms look like they would go

[tex]x,\ \frac{x^2}{2},\ \frac{x^3}{2*3},\ \frac{x^4}{2*3*4} ...[/tex]

LeonhardEuler

Actually, I'm very sure that's the mistake you made since you got

For x=0.000001;
ln(x) = -13.8155... (actual)
ln(x) = -1.71828... (calculated)

If you were calculating what I thought you were calculating, it's the Taylor series for [itex]e^{-x}-1[/itex]. So you would get, after shifting the argument:
[tex]e^{-(0.000001-1)} - 1\approx e-1\approx 1.7182818...[/tex]

hkBattousai

Quote by LeonhardEuler

Actually, I'm very sure that's the mistake you made since you got

If you were calculating what I thought you were calculating, it's the Taylor series for [itex]e^{x}-1[/itex]. So you would get:
[tex]e^{0.000001} - 1\approx e-1\approx 1.7182818...[/tex]

Yeah, thanks, there was an error in the code... I feel embarrassed...

The denominator term was was also accumulating into multiplication, so it was becoming factorial of the current for loop variable. It was calculating exp() instead of ln(), what an exciting coincidence...

hkBattousai

My new code is:

Code:

long double Math::ln(long double num) throw(MathInvalidArgument)
{
	if (num < 0)
	{
		throw(MathInvalidArgument(L"You tried to take ln() of a negative number."));
	}
	else if (num == 0.0)
	{
		long double zero = 0.0;
		return -1.0 / zero;	// return minus infinity
	}
	else if (num <= 1.0)
	{
		return ln_ByTaylorSeriesExpansion(num);
	}
	else
	{
		return ln_ByNewtonsMethod(num);
	}
}

long double Math::ln_ByTaylorSeriesExpansion(long double arg)
{
	arg -= 1.0; // We will use series expansion for ln(x+1)
	long double Result = 0.0, NextSum;
	long double power_of_arg = 1.0, power_of_arg_over_i;
	for (uint64_t i=1; true; i++)
	{
		power_of_arg *= arg;
		power_of_arg_over_i = power_of_arg / static_cast<long double>(i);
		NextSum = -static_cast<long double>(MinusOneToThePowerOf(i)) * power_of_arg_over_i;
		Result += NextSum;
		if (abs(NextSum) < m_PRECISION_EPSILON)
		{
			break;
		}
	}
	return Result;
}

long double Math::ln_ByNewtonsMethod(long double arg)
{
	long double x_k = 1.0, x_k1;
	for (uint64_t i=0; true; i++)
	{
		x_k1 = x_k - ((exp(x_k) - arg) / exp(x_k));
		if (abs(x_k1 - x_k) < m_PRECISION_EPSILON) break;
		x_k = x_k1;
	}
	return x_k1;
}

AlephZero

When 0 < x < 1, you could use
ln(x) = -ln(1/x)

hkBattousai

Quote by AlephZero

When 0 < x < 1, you could use
ln(x) = -ln(1/x)

Very good idea!
This way I can always use Newton's method, it is better since it converges super fast.
Thanks a lot!

hkBattousai

Quote by AlephZero

When 0 < x < 1, you could use
ln(x) = -ln(1/x)

Hmm, good advice but numerically not possible to implement.

For example, suppose that you want to calculate
ln(0.000001)
You send it into Newton's algorithm in this form
-ln(1000000)
I need to calculate
exp(1000000)
inside the Newton's algorithm, but obviously it is not possible because of the hardware and software limitations.
And I also realized that, with this code, there is a very low limit for the argument of ln(). I need to work around this problem.

LeonhardEuler

Quote by hkBattousai

Hmm, good advice but numerically not possible to implement.

For example, suppose that you want to calculate
ln(0.000001)
You send it into Newton's algorithm in this form
-ln(1000000)
I need to calculate
exp(1000000)
inside the Newton's algorithm, but obviously it is not possible because of the hardware and software limitations.
And I also realized that, with this code, there is a very low limit for the argument of ln(). I need to work around this problem.

You could work around it using the property that:
[tex]\ln{(a\cdot 10^{n})}=\ln{a}+n\ln{10}[/tex]

hotvette

Hmmm, I must be missing something. I had no problem at all finding ln(0.000001) using hkBattousai's algorithm for Newton's method. It reduces to x_k+1 = x_k - 1 + arg/exp(x_k).

Similar Threads for: I need a method to calculate ln(x) for small x, other than Taylor series method
Thread	Forum	Replies
Taylor Series Method Integral	Calculus & Beyond Homework	3
Taylor method for IVPs	Differential Equations	2
Expanding a small oscillation potential in taylor series	Classical Physics	2
What method to calculate intergration?	Calculus	4
Taylor Series Starting Method	Calculus & Beyond Homework	2

Pagan Harpoon	Maybe you could try directly evaluating the integral: [tex]\int^{x}_{1}\frac{1}{x}dx[/tex]

AlephZero $Math 2012$ Recognitions: Science Advisor	When 0 < x < 1, you could use ln(x) = -ln(1/x)

hotvette Recognitions: Homework Help	Hmmm, I must be missing something. I had no problem at all finding ln(0.000001) using hkBattousai's algorithm for Newton's method. It reduces to x_k+1 = x_k - 1 + arg/exp(x_k).