Representing small values in C

[yashrk]

Hello Guys, 
              I have to represent and use small values like 1.40715e-09 in a calculation of a polynomial equation. I know I can use maths.h but I guess that will be more processor intensive, is there any better way of doing it ?
I have to solve this using dynamic values of x in each loop -
K = 1.40715e-09 * x^5 + 9.18189e-08 * x^4
I am using PIC18F4620 in MPLAB X.

Thanx.

[T3sl4co1l]

If x and K are bounded integer ranges, it should suffice to use fixed point.

Otherwise, a floating point polynomial doesn't sound like the kind of thing you should need to compute on a PIC... find another solution?

Tim

[dannyf]

Code: [Select]

K = 1.40715e-09 * x^5 + 9.18189e-08 * x^4
rewrite it to:

Code: [Select]

K = a * (b * x + 1) * (c*x)^2^2

Find the appropriate a, b and c.

[JPortici]

if you have enough space/not so many X values use a lookup table for the output otherwise you WILL have to use floating point math to keep a parvency of precision so unless you get a MCU with an FPU you will have to let it take its sweet time to calculate the value. a pic18 is much better than a pic16 in this case. a dspic is much better than a pic18 in this case. a pic32MZ EF is much better and so on
but i don't know your requiremenets, if the value has to be calculated on the fly all the timeor it is a sporadic measure etc

[westfw]

K = 1.40715e-09 * x^5 + 9.18189e-08 * x^4

What is the range of "x"?  What is the expected range of the result?  What is the required accuracy of the result?
If you have floating point involved anyway, then using "small" values as you've shown should not cause any additional problems (though it is probably desirable to avoid floating point entirely, if you can.)  (although, with REALLY small numbers (Planck's constant squared, my memory says - a very educational experience, that assignment...), you can exceed the limits of some floating point formats...)

[Mechatrommer]

without giving much clue of how many bit resolution required, the answer can be anything. for eg, is x integer? whats the min max value of x?

[yashrk]

X is an 22 bit ADC value which is always positive

[yashrk]

And yes the value has to be calculated at least ones in every time it goes through the "main"  loop, so I do want it as fast as possible and for the accuracy I need it to be accurate till 2-3 decimal places

[Mechatrommer]

thats complicated, you'll need to track exponent from -9 to 24, probably need to device for mantissa storage/tracking as well. you'll probably will end up as slow as fp op. bed time here others may help, good luck.

[MarkF]

How fast do you need to sample the DAC and what else does the PIC need to do?

If you have lots of time, just use doubles and do the calculation.  Normal software development is to code it the most straight forward way and then optimize it if you need to reduce memory size or decrease the computation time.

[nctnico]

How fast do you need to sample the DAC and what else does the PIC need to do?

If you have lots of time, just use doubles and do the calculation.  Normal software development is to code it the most straight forward way and then optimize it if you need to reduce memory size or decrease the computation time.

Very true! I assume there is a soft floating point library for PIC as well so start using that and see if it is fast enough. Also using a faster processor (ARM) may be a lot easier than trying to squeeze performance out of a slow 8 bit processor.

[dmills]

Small PIC floating point libs are sometimes very much NOT IEEE754, so be sure to read the documentation......


Regards, Dan.

[Kalvin]

Depending of the precision required, performing the arithmetics using logarithms and performing the need conversions using lookup-tables may also be an option. Googling using the following magic keywords may give some ideas: floating point arithmetic using logarithms

[MosherIV]

Assuming the number of fractional bits stay the same between calculations, have you looked at how DSPs handle floating point numbers?

https://en.wikipedia.org/wiki/Q_%28number_format%29

[hamster_nz]

Are you calculating K given an 'x' value, or , or solving for x, when K is known?

Anyhow... this might be better

Code: [Select]

28428252164 * K = (4*x^5 + 261*x^4)


[helius]

Are we really talking about the C language here? I see a whole bunch of code snippets that use ^ for exponentiation. Really?

[MarkF]

Are we really talking about the C language here? I see a whole bunch of code snippets that use ^ for exponentiation. Really?

Ya.  That's the notation in C.  Get use to it.

[Len]

Are we really talking about the C language here? I see a whole bunch of code snippets that use ^ for exponentiation. Really?

Ya.  That's the notation in C.  Get use to it.

No it isn't. ^ is the binary xor operator in C.

yashrk wasn't writing C code. He wrote a mathematical formula and asked how it should be calculated in C.

[dannyf]

"Anyhow... this might be better"

Using x4 to calculate x5.

[hamster_nz]

If he the OP really wants to calculate this efficiently on a low end part the best way would be to normalize everything into a custom floating point format (i.e. a 32 bit number representing 0.5000 (0x80000000 to 0xFFFFFFFF) and an exponent (maybe from 2^-32768 to 2^32768).

Write a routine to normalize the numbers...

Code: [Select]

void normalize(u32 *mantissa, u16 *exponent) {
  if(*mantissa == 0) {
     *exponent = 0;
     return;
  }
  while(*mantissa & 0xC0000000 != 0) {
     *mantissa<<=1;
     *exponent--;
  }

Then multiplications become

Code: [Select]

void multiply(u32 *mantissa_1, u16 *exponent_1, u32 *mantissa_1, u16 *exponent_1) {
    *mantissa_1 = (u32)(((u64)(*mantissa_1) * (u64)*mantissa_2)>>32);
    *exponent_1 = *exponent_1 + *exponent_2;
    normalize(&mantissa_1, &exponent_1);
}

Addition is a bit trickier, as you have to put things to a common exponent (whichever is the highest) and then add, and allow for an overflow.

With that infrastructure the calculation becomes:

Code: [Select]

void calc(m_x, e_x) {

  *m_temp1 = *m_x;
  *e_temp1  = *e_x;  /* temp_1 = x */

  multiply(&m_temp1, &e_temp1, &m_x,& e_x);   /* temp_1 = x^2 */
  multiply(&m_temp1, &e_temp1, &m_x,& e_x);   /* temp_1 = x^3 */
  multiply(&m_temp1, &e_temp1, &m_x,& e_x);   /* temp_1 = x^4 */

  *m_temp2 = *m_temp1;  /* temp2 = x^4 */
  *e_temp2 = *e_temp1;

  multiply(&m_temp1, &e_temp1, &m_x,& e_x);   /* temp_1 = x^5 */

  multiply(&m_temp1, &e_temp1, &m_const1, e_const1); /* temp1 = const1 * x^5 */
  multiply(&m_temp2, &e_temp2, &m_const2, e_const2); /* temp1 = const2 * x^4*/

  add((&m_temp1, &e_temp1, &m_temp2, &e_temp2);  /* temp1 = const1 * x^5  +  const2 * x^4 */

  /* K is now in m_temp1 & e_temp1 */
}


[dannyf]

This is easy:

produce a complete compilable routine that converts a 22-bit adc to a floating point output, as per the OP's formula, with the fastest execution and/or smallest space.

Go!

[MarkF]

Are we really talking about the C language here? I see a whole bunch of code snippets that use ^ for exponentiation. Really?

Ya.  That's the notation in C.  Get use to it.

No it isn't. ^ is the binary xor operator in C.

yashrk wasn't writing C code. He wrote a mathematical formula and asked how it should be calculated in C.

You're right.  Don't know what I was thinking.   

[MarkF]

If he the OP really wants to calculate this efficiently on a low end part the best way would be to normalize everything into a custom floating point format (i.e. a 32 bit number representing 0.5000 (0x80000000 to 0xFFFFFFFF) and an exponent (maybe from 2^-32768 to 2^32768).

Write a routine to normalize the numbers...

Test... Test... Test...
Many times the compiler will out smart you and it will actually take longer to execute with the optimization.
I've seen it very often.

[westfw]

X is an 22 bit ADC value which is always positive

Sigh.  A 22bit raw ADC-reading number like "1000000", or an analog voltage value derived from that like "((1000000 * V_ref)/4194304.0)" ?
Thermocouple? (link to datasheet?)  Expected temperature range or analog voltage range?  (22bit ADC, eh?  Damn!)

but don't most of those high-res ADC have conversion times in the ms to 200ms range?  Are you sure you need "fast" ?
start with some simple optimization like:

Code: [Select]

x4 = x*x*x*x;
K = x4*(1.40715e-9 *x + 9.18189e-8);
and see if it is "fast enough" (premature optimization is the root of much evil.)
(normally, I'd hope that a compiler would produce equivalent code from a straightforward expression like "K = 1.4e-9*pow(x,4) + 9.2e-8*pow(x,5)", but ... I'm not sure, I especially don't trust the 8bit PIC compilers, and x*x*x*x is probably faster than pow(x,4) anyway.)

(edited: replace embarrassing misuse of "exp" function with correct "pow" function.)

[helius]

and x*x*x*x is probably faster than exp(x,4) anyway.)

exp(x) computes \$e^x\$. pow(x,y) is defined to return a double, anyway.