• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 2066
  • Last Modified:

pow(10,x) implementation!

hi,

  could anybody tell me, how can i implement pow(10,x) function, where x can be double? ofcourse, i want to minimize use of library functions to speedup the process?
0
Vikram_B
Asked:
Vikram_B
  • 2
  • 2
  • 2
1 Solution
 
sunnycoderCommented:
here is the glibc implementation of pow() (which I would not strain to comprehend)

# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
     (__extension__ ({ __tgmath_real_type ((Val1) + (Val2)) __tgmres;            \
                   if ((sizeof (__real__ (Val1)) > sizeof (double)            \
                      || sizeof (__real__ (Val2)) > sizeof (double))    \
                     && __builtin_classify_type (__real__ (Val1)            \
                                           + __real__ (Val2))     \
                        == 8)                                    \
                   {                                          \
                     if (sizeof (__real__ (Val1)) == sizeof (Val1)      \
                         && sizeof (__real__ (Val2)) == sizeof (Val2))  \
                       __tgmres = __tgml(Fct) (Val1, Val2);            \
                     else                                          \
                       __tgmres = __tgml(Cfct) (Val1, Val2);            \
                   }                                          \
                   else if (sizeof (__real__ (Val1)) == sizeof (double)   \
                        || sizeof (__real__ (Val2)) == sizeof(double) \
                        || (__builtin_classify_type (__real__ (Val1)) \
                            != 8)                              \
                        || (__builtin_classify_type (__real__ (Val2)) \
                            != 8))                              \
                   {                                          \
                     if (sizeof (__real__ (Val1)) == sizeof (Val1)      \
                         && sizeof (__real__ (Val2)) == sizeof (Val2))  \
                       __tgmres = Fct (Val1, Val2);                  \
                     else                                          \
                       __tgmres = Cfct (Val1, Val2);                  \
                   }                                          \
                   else                                          \
                   {                                          \
                     if (sizeof (__real__ (Val1)) == sizeof (Val1)      \
                         && sizeof (__real__ (Val2)) == sizeof (Val2))  \
                       __tgmres = Fct##f (Val1, Val2);                  \
                     else                                          \
                       __tgmres = Cfct##f (Val1, Val2);                  \
                   }                                          \
                   __tgmres; }))


if you feel lost then there is always the simpler one

result = 1;
for ( i = 0;  i < x; i++ )
     result = result  * 10;

;o)
0
 
sunnycoderCommented:
a little study shows that pow is implemented as a macro and not as a function... if you use pow(), your execution time would not be adversely affected... moreover, library implementation of pow() is bound to be more efficient what I or you would write... So I would say --- use pow()
0
 
Vikram_BAuthor Commented:
life is not always straignt-forward. i'm implementing the pow function on a dsp chip (TI'x 64xx) which doesn't have floating pt unit. thus, using libraty pow function is consuming lotta cpu cycles.
0
Get Certified for a Job in Cybersecurity

Want an exciting career in an emerging field? Earn your MS in Cybersecurity and get certified in ethical hacking or computer forensic investigation. WGU’s MSCSIA degree program was designed to meet the most recent U.S. Department of Homeland Security (DHS) and NSA guidelines.  

 
SethHoytCommented:
You might consider changing bases to either 2 or e by precomputing the logarithm of 10 for the desired base. Many systems have an optimized implementation for exponentiation base e, and base 2 can be done quickly for powers in binary form using the square and multiply method.

To transform the base to 2, use the identity:

10^x = (2^lg(10))^x = 2^(lg(10)*x)

where lg() is the logarithm base 2. Typically, you will need to compute log(10)/log(2) using a different base, but this is done only once and stored for later use, so efficiency is not important here. The transformation is similar for base e, but unless a built-in function exists for exponentiation base e, you should use base 2 for this.

So the idea is to compute r = log(10)/log(2) one time, either globally or offline, then find 2^(r*x).


-Seth
0
 
SethHoytCommented:
You can find the square and multiply method here:

http://www.math.ucalgary.ca/~kjell/papers/hardware/gordon98survey.pdf

-Seth
0
 
Vikram_BAuthor Commented:
thanx SethHoyt,

 that should work :)
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

Join & Write a Comment

Featured Post

Identify and Prevent Potential Cyber-threats

Become the white hat who helps safeguard our interconnected world. Transform your career future by earning your MS in Cybersecurity. WGU’s MSCSIA degree program was designed in collaboration with national intelligence organizations and IT industry leaders.

  • 2
  • 2
  • 2
Tackle projects and never again get stuck behind a technical roadblock.
Join Now