it takes too long time Using exp function

The fundamental problem you face is that you are performing floating point calcuations on a processor which does not have native floating point instructions.  Perhaps it is time to use a different TI DSP.  The rest of this post presumes you cannot do that.

Some options to consider ... Use the float type versions of those operations (expf, powf or powfi, logf) instead of the standard double type versions.  Or, you could try the C62x/C64x Fast RTS Library.

Thanks and regards,

-George

In addition to what George said about using floating-point emulation, in general the best way to compute a *small* nonnegative integral power of a floating-point quantity in C is:

inline float pow_small_n(float x, unsigned n) {float xn = 1.0; for (; n != 0; --n) xn *= x; return xn;}

To compute a *general* (not necessarily small) nonnegative integral power of a floating-point quantity:

inline float pow_any_n(float x, unsigned n) {float xn = 1.0, xi = x; for (; n != 0; xi *= x, n >>= 1) if (n & 1) xn *= xi; return xn;}

Of course you can adapt these to non-float types.  For negative powers, compute the reciprocal using one of these schemes.

I assumed that the computation will not overflow.  You could add overflow checking if you think you might need it.

The C optimizer should do a good job of generating fast code for particular instances of these.  For example, for small constant n it should completely unroll the loop.

Hello,

... No trace of exp, pow, nor log in C file ...

Another additions:

Always prefer multiplies to divides (create some variable temp = 1.0 / SCANLINE_THRESHOLD).
You can also build lower precision (and faster) implementation of expf,...

In the expression mentioned, if the main argument is 16-bit, another way is to precompute a look-up table (LUT) of the function for all the permitted argument values;
the calculation is then very fast (one table indexation per point). If the other parameters are quite fixed, the LUT computation may be done at init time.

Jakez

PS: I permit myself to correct Douglas's typo:

inline float pow_any_n(float x, unsigned n) {float xn = 1.0, xi = x; for (; n != 0; xi *= xi, n >>= 1) if (n & 1) xn *= xi; return xn;}

Thanks for the correction.  I actually had that while typing up the message, but when I reviewed it before posting, for some reason it looked wrong, so I changed it :-(  Of course, it is always a good idea to test any such code with a handful of simple known cases before using the code in your application.

The LUT approach is a good idea, which I have used many times.  The idea is to build the table only the first time the function is called, and always return the corresponding table value.  A similar approach is to cache already-computed cases; look-up is slower (usually we hash the inputs to make the search faster), but it works when a complete table would be too large.