Could anyone tell clearly how to find the exponents with fractional values or decimal values without using pre-defined function like ?

Question

ex:2^0.5=1.414....&so want. I'm newbie to c so please explain simple logic if not complicated logic is also enough

Answer 1

In mathematics, the step from integer exponentiation to real exponentiation is quite a big step. While integer exponentiation can be defined as repeated multiplication (e.g. x^5 = x*x*x*x*x) exponentiation with real values in the exponent is commonly defined via the natural exponential function. Your example of 2^0.5 can be rewritten as

2^0.5 = exp(0.5*ln(2))

where exp is the natural exponential function and ln is its inverse, the natural logarithm. Both these functions have commonly known power series:

exp(x) = 1 + x + x^2/2 + x^3/3 + ... 
ln(x)  = (x-1) - (x-1)^2/2 + (x-1)^3/3 - ...

The power series are infinite series, so you cannot calculate it exactly, but depending on how accurate you want your result to be, you can stop at some point in the series. The formula for the whole series can be found for example at wikipedia.

Note that the series expansion for the logarithm is only convergent for values of x between 0 and 2. In your example, the ln(2) is already at the edge of this region. A solution to this problem can be found by rewriting the expression even further. For any number x, ln(x) can be expandend in

ln(x) = ln(m*2^e) = ln(m) + e*ln(2)

Where m is the mantissa (between 1 and 2) and e is the exponent of the number x. In your example you would for example write:

ln(2) = ln(1*2^1) = ln(1) + 1*ln(2)

The value of ln(2) can be precalculated and stored as a constant, as it is always the same. The value of ln(1) can be accurately calculated using the series expansion from above (In your example this happens to be ln(1) = 0, but this is not generally the case). The mantissa and exponent can easily be extracted from a double or float type, by using their internal bit representation.

Armed with this information we can try to write our own ln, exp and ultimately pow functions:

#include <stdio.h>

/* constant to control how many terms in the series expansion we want to calculate before aborting */
const int N = 50;

float my_ln(float x) {
    const float ln2 = 0.6931471805599453;
    union {
        float f;
        uint32_t i;
    } u;

    /* get the mantissa by bit manipulation of the float binary representation */
    u.f = x;
    u.i = (u.i & 0x07ffffff) | 0x3f800000;

    /* calculate the logarithm according to its series expansion */
    float result = 0.0;
    float tmp = u.f - 1.0;
    for ( int i = 1; i < N; i++ ) {
        result += tmp/i;
        tmp *= 1.0 - u.f;
    }

    /* get the exponent */
    u.f = x;
    u.i = ((u.i >> 23) & 0xff) - 127;

    /* multiply it with ln(2) and add it to the logarithm of the mantissa */
    result += (float)u.i * ln2;
    return result;
}

float my_exp(float x) {
    float result = 0.0;
    float tmp = 1.0;
    for ( int i = 1; i < N; i++ ) {
        result += tmp;
        tmp *= x/i;
    }
    return result;
}

float my_pow(float x, float a) {
    /* multiply the logarithm of the base x with the exponent a and compute the natural exponential of this value */
    return my_exp( my_ln(x) * a);
}

int main() {
    float x = 2.0;
    float a = 0.5;
    printf("%f ^ %f == %f\n", x,a, my_pow(x,a));
}

This gives fairly good results, at least for the few examples that i tested. Note that writing such functions is difficult and error prone. For example the functions, that I provided above do not handle negative numbers correctly. NaNs, Infinities and Zeros are not handled correctly as well. While this could also be done with some more effort, one really should use the functions from the standard library, as they are

• well tested
• probably much faster and optimized
• probably much more accurate in more extreme number regions (very small or large numbers)