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

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?
 Maybe you could try directly evaluating the integral: $$\int^{x}_{1}\frac{1}{x}dx$$

Recognitions:
Homework Help
 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?

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

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

Recognitions:
Gold Member
 power_of_arg_over_i *= arg / static_cast(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} ...$$

Recognitions:
Gold Member
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...$$

 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 $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(i); NextSum = -static_cast(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; }
 Recognitions: Science Advisor When 0 < x < 1, you could use ln(x) = -ln(1/x)

 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!

 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.

Recognitions:
Gold Member
 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:
$$\ln{(a\cdot 10^{n})}=\ln{a}+n\ln{10}$$
 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 xk+1 = xk - 1 + arg/exp(xk).

 Tags converge, logarithm, newton, numeric, taylor