Microcontroller Embedded C Programming Lecture 64| Working with float and double variables

 

Working with float and double variables

 

 

In this article, let’s experiment with float and double data types. Before that, let me explain the range of these data types.

Figure 1. Range of float
Figure 1. Range of float

 

Float storage size is 4 bytes, and its precision is up to 6 decimal places after the decimal point, and the value range is 1.2×10 to the power -38 to 3.4×10 to the power +38. 

 

Figure 2. Range of double
Figure 2. Range of double

 

The range of double is 2.3×10 to the power -308 to 1.7×10 to the power 308, and the precision is up to 15 decimal places, and since it is double-precision storage, it consumes 8 bytes in the memory.

 

Figure 3. Program
Figure 3. Program

 

In the program, I have a variable called number, which is initialized to the number 45.78976834578. This is a real number, which has an integer part, a decimal point, and a fractional part. And I have used the data type float here. If I want to print this, I would use %f and let me print that number. The code is shown in Figure 3.

In the program’s output, you can see that the %f prints 6 decimal places of the number after the decimal point. Now the result is correct with respect to 6 decimal places. 

 

And if you want to know what is the status of the remaining decimal spaces, you can increase the width of the output by mentioning the width specifier here. So, I can write 0.9. This is like telling print up to 9 decimal places after the decimal point.

In the output, you can see that the result is now with respect to 9 decimal places, but up to 6 is correct, and the remaining three are wrong. So, there is a precision loss.

Figure 4. Used %0.9f in the printf statement
Figure 4. Used %0.9f in the printf statement

 

Now, change the data type to double; you will get better precision. You can print up to 15. Let’s print up to 14 decimal places, and give lf here. Let’s use lf for the double. The code is shown in Figure 5.

In the output, you can see that you got the better precision. The result is correct. So, the result is identical with this fractional part. 

Figure 5. Program
Figure 5. Program

 

Now, we can also print this output in scientific notation. For that, you have to use %e here instead of %f. So, %e will print this result in scientific notation.

Working with float and double variables
Figure 6. Print the output in scientific notation

 

Here we can see that you got the result in scientific notation. The meaning of e+001 is 10 to the power 1. 

 

Now you can also ask the printf to print with respect to 2 decimal places. For that, I would use 0.2 here.

Working with float and double variables
Figure 7. Print with 2 decimal places

 

You can see that the output is printed up to 2 decimal places after the decimal point. Here the 8 rounds of it’s the nearest number. That’s why it printed 45.79.  And look at the scientific notation; it is 4.58 into 10 to the power 1. So, that would give you 45.8.

 

Now let’s modify this program to store a charge of an electron. Let’s create a variable chargeE, and the charge of an electron is this number -1.60217662 x 10-19; you can also use the minus sign here. You can also store the number in scientific notation into the float or double data type variables. But you cannot write like this 10-19. What you have to do here is remove this and write e-19. This is how you store the number with scientific notation. This is like 10 to the power -19. 

Let’s print that number. Let me print using %f and %e, as shown in Figure 8. 

Working with float and double variables
Figure 8. Printing output in scientific notation

 

First of all, in the first output, it printed 0. That makes sense because it’s a very small number. And look at the scientific notation, it printed almost correct, and for the fractional part, it printed with respect to 6 decimal places. That’s why this 6 became 7 here. That means you cannot use a float variable here to store the exact value of the charge of an electron because there is a precision loss here. 

 

Here, your requirement is to show the data with respect to 8 decimal places after the decimal point. For that, you can mention 0.8(Figure 9).  

Working with float and double variables
Figure 9. Mention %0.8f and %0.8e width specifier

 

You can see that the output result won’t improve. Here 602176, then it is showing 60. So, the result will not improve.

That’s why it makes sense to use a double here because a double gives you precision up to 15 decimal places. Let’s use double here and the lf and le format specifier, and we can now see better precision for this program.

Working with float and double variables
Figure 10. Use double

 

In the Output, you can see that the fractional part is exactly like the input. The reason for that is in double, you can obtain the precision up to 15 decimal places after the decimal point.

When you try to print in a %lf format, you can see that it is printing all zeros because it’s a very small number.

So, if you want to get output, let’s introduce more decimal places; let me give %0.28lf.

Working with float and double variables
Figure 11. Use 0.28lf width specifier

 

Now in the output, it is printing the fractional part with respect to a 28 decimal place after the decimal point.

 

FastBit Embedded Brain Academy Courses

Click here: https://fastbitlab.com/course1

 

Tags:

FastBitLab

The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries.