User:Creature/Logarithms

After spending some time studying mathematics, I've found of a fairly easy way to calculate logarithms in your operating system. Note that there are a few downsides to this way as well, which will be described in a moment.

Logarithms

Requirements

Firstly, there are a few requirements you need to meet in order to be able to use this method. You will need:

• Floating point support (see FPU for more details).
• Some implementation of the powf function (a function that can raise float x to float y). If y is the power to raise to, then you must be able to handle the case where 0 < y < 1.

This is basically all you need.

Downsides

The main downside of this method is precision: it is not very precise and the way I'm showing it to you may be improved (it is merely used for demonstration). The method will probably suffer from rounding errors.

The Method

For the calculation of logarithms, we're going to use a couple of other facts.

Firstly, the derivative of an exponential function f(x) = a^x (where ^ denotes to the power of) is f'(x) = c * a^x. c is a constant number that depends on the growth factor (the growth factor is a). The number c can be calculated by

         Δx
 lim    a   - 1
 Δx->0 ---------
          Δx

But the derivative of function f(x) = a^x also equals g'(x) = ln(a) * a^x, where ln is the logarithmus naturalis of a. What we have now are two derivatives of one same function, which means we can compare them.

 -> c * a^x = ln(a) * a^x             f'(x) = g(x)
 -> c = ln(a)                         Drop a^x (exists in both terms)
 -> c = log(a) = the_limit_above      ln(a) = log(a)

Note that log is the logarithmus naturalis in the standard C library (so the base number is Euler's mathematical constant, not 10).

From the definition of logarithms, we know that

 a         log10(x)
  log x = ----------
           log10(a)

So when calculating the ln (or log in the standard C library) of x, a becomes e. Because log10(e) will never change, we can calculate this number and put it in a define somewhere. By my (quick and dirty) calculations, log10(e) equals approximately 0.4342944819. Now we can transform our formula:

                a
 0.4342944819 *  log x = log10(x)

Now, if we want to implement our C function log (which uses e as base, so a = e), we use the fact that log(x) = c and the limit.

float log10(float x)
{
   return (((powf(x, 0.00001f) - 1) / 0.00001f) * LOG10_E);
}

Where LOG10_E is the number calculated earlier. We raise x to the power of 0.00001f because Δx approaches 0, so this is a fairly good choice (though inaccurate). Once you have log10, it's not hard to calculate the other logarithm functions:

float log(float x)
{
   return (log10(x) / LOG10_E);
}

We could even create a general function that calculates any type of logarithm:

// ----- Custom function that calculates the logarithm of value x with the given base.
loat logx(float x, float base)
{
   // base may not equal 1 or be negative.
   if(base == 1.f || base < 0.f)
      return 0.f; // Return what you want here, could be Not-A-Number or NAN.

   return (log10(x) / log10(base));
}

As I said, this method is inaccurate and probably could be improved to be more precise.

Alternative implementation (courtesy of Combuster)

There is an alternative way (but more complex in theory) that can be used to calculate the ln of a value x. It is much more precise (since it uses a Taylor series expansion). Wikipedia has a very nice article on this, which can be found here. Once you have implemented this way, it is again not very hard to calculate other logarithmic values.