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

• hkBattousai
In summary: So for example, if you wanted to calculate ln(0.000001), you could split it up like this:ln(0.000001) = ln(10^-6) = ln(10) + ln(10^-7)And then use the Taylor series expansion for ln(10) and the Newton's method for ln(10^-7). This way, you would avoid the issue of trying to calculate exp(1000000) inside the algorithm.
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.
$\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$
Sum of this series is $\small -\infty\normalsize$ for $\small x=-1\normalsize$, 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 $\epsilon$ value, which is equal to $1.0 \times 10^{-14}$ for this particular example.)

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

Last edited:
Maybe you could try directly evaluating the integral:

$$\int^{x}_{1}\frac{1}{x}dx$$

hkBattousai said:
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?

hotvette said:
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;
}

Last edited:
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

$$x,\ \frac{x^2}{2},\ \frac{x^3}{2*3},\ \frac{x^4}{2*3*4} ...$$

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 $e^{-x}-1$. So you would get, after shifting the argument:
$$e^{-(0.000001-1)} - 1\approx e-1\approx 1.7182818...$$

Last edited:
LeonhardEuler said:
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 $e^{x}-1$. So you would get:
$$e^{0.000001} - 1\approx e-1\approx 1.7182818...$$

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...

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;
}

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

AlephZero said:
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!

AlephZero said:
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.

hkBattousai said:
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:
$$\ln{(a\cdot 10^{n})}=\ln{a}+n\ln{10}$$

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 xk+1 = xk - 1 + arg/exp(xk).

Last edited:

What is a method to calculate ln(x) for small x other than Taylor series method?

One method is the Newton's method, which uses the derivative of ln(x) to iteratively approach the solution. Another method is the continued fraction expansion method, which involves rewriting ln(x) as a series of fractions and using a finite number of terms to approximate the value.

How accurate are these alternative methods for calculating ln(x) for small x?

The accuracy of these methods depends on the number of iterations or terms used. Generally, the more iterations or terms used, the more accurate the approximation will be. However, it is important to note that these methods may not be as accurate as the Taylor series method for very small values of x.

Are these methods limited to only small values of x?

No, these methods can also be used for larger values of x. However, as x gets larger, the accuracy of these methods may decrease and the Taylor series method may be a better option.

Do these methods have any advantages over the Taylor series method?

Yes, these methods can be more efficient and require fewer calculations compared to the Taylor series method. They also do not suffer from the issue of divergence at certain values of x, which the Taylor series method may experience.

Are there any other methods for calculating ln(x) for small x?

Yes, there are other methods such as the logarithmic interpolation method and the Padé approximation method. These methods may have different levels of accuracy and efficiency compared to the methods mentioned above.

• General Math
Replies
3
Views
696
• General Math
Replies
4
Views
1K
• General Math
Replies
16
Views
4K
• General Math
Replies
7
Views
1K
• General Math
Replies
10
Views
1K
• General Math
Replies
16
Views
2K
• Calculus and Beyond Homework Help
Replies
1
Views
252
• Calculus
Replies
2
Views
1K
• General Math
Replies
4
Views
2K
• Calculus
Replies
3
Views
2K