Assign a floating point literal to a float without a suffix

Ask

Is there a loss of precision when the conversion is carried out?

Yes, there is a loss of precision.

Narrowing . _

The floating point data types are:

• float: Single precision. They are usually a 32-bit wide type following IEEE-754 32-bit.
• double- Double precision. They are usually a 64-bit wide type following IEEE-754 64-bit.
• long double- Extended accuracy. They are usually an 80-bit type on 32-bit and 64-bit architectures. Does not necessarily follow IEEE-754 .

Every time you go from a type of higher precision to one of less, a narrowing occurs; data can be lost every time a narrowing occurs, when does this happen?

Type conversion.

According to the C standard in the §6.3.1.5 Real Floating Point Types section (translation and emphasis mine):

6.3.1.5 Real floating-point types

1. When a floatis promoted to doubleor long double, or when a doubleis promoted to long double, its value does not change .
2. When a doubleis demoted to float, a long doubleis demoted to doubleor float, or a value represented in a higher precision and range than required by its semantic type (see 6.3.1.8) is explicitly cast to that semantic type, if the value being cast can be represented exactly in the new type, it will not be changed. If the value being converted is in the range of values ​​that can be represented but cannot be represented exactly, the result will be the number closest to the value whether rounded up or down, rounding is implementation dependent. If the value being converted is outside the range of values ​​that can be represented, the behavior is undefined.

In your case, assigning the value 3.14to a floatcorresponds to a narrowing, but since the value is exactly 3.14representable by the value will not change.float

What is failing?

If the value has not changed, why does your code fail?:

float n = 3.14;

if(n == 3.14f)
   puts("Igual"); // no se imprime!

Because I lied, the value 3.14is NOT representable by floatexactly. There are floating point numbers that are not exactly representable in binary, this is due to the properties of each base ¹ .

The value 3.14 in binary is not exactly representable and with double precision its value is approximately 3.140000000000000 12434497875802 but by storing it in a floatyou have lost some precision, how much exactly? It will depend on your system...

So you will be comparing a number like the truncation of the value double3.14000000000000012434497875802 against a number like 3.14fthat in many cases will not be the same number. For example the literal 3.14 in float is approximately 3.140000 1049041748046875 so your comparison would be, more or less:

if(3.1400000000000001243449 == 3.1400001049041748046875) // El double ha sido truncado

That obviously does not comply with equality.

It's terrible! What I can do?

As eferion comments , you should avoid comparing floating point numbers by equality, due to rounding errors you should compare them by almost equality , a function like this could help you:

#include <stdbool.h>
#include <stdint.h> 

bool casi_iguales(float izquierda, float derecha)
{
     return fabs(izquierda – derecha) <= FLT_EPSILON;
}

bool casi_iguales(double izquierda, double derecha)
{
     return fabs(izquierda – derecha) <= DBL_EPSILON;
}

FLT_EPSILONThe and values DBL_EPSILON​​are the difference between 1 and the next value representable by floatand doublerespectively; in other words, they are approximately the smallest value representable by each of the types, so if the difference between izquierdaand derechais less than or equal to this value, both values ​​are almost equal .

¹ For example, 1/3 in base 10 is a pure periodic number of value 0.3333333... while in base 12 it is exactly 0.4. In decimal the value 1/10 is exactly 0.1 but in binary it is a mixed periodic number of value 0.00011001100110011...

Floating point numbers should never ever be compared using the comparison operator.

The reason is that these numbers have a certain precision, the rest of the digits being practically random.

The correct way is to perform the comparison assuming a certain margin of error:

float v1,v2;
//...
if (fabs(v1-v2)<1e-4)
  // Los números son iguales
else
  // Los números son distintos

You can play with the precision to adapt it to your needs. The example is simply illustrative.

All the best

Here is a very illustrative example of what happens. And it really is worth explaining.

You have two uninitialized memory areas like so:

Area A:

+--------------------------------------+
| qwerytuiopasdfhgjklzxcvbnm1234567890 |
+--------------------------------------+

Area B:

+--------------------------------------+
| qwerytuiopasdfhgjklzxcvbnm1234567890 |
+--------------------------------------+

Then you put a floatin A:

+----------------+
| 3.14           | // Nota como float es más pequeño.
+----------------+

And one doublein B:

+--------------------------------------+
| 3.14                                 |
+--------------------------------------+

So by comparing A to B, you get the comparison of:

+--------------------------------------+
| 3.14                                 |
+--------------------------------------+

With

+--------------------------------------+
| 3.14           gjklzxcvbnm1234567890 |
+--------------------------------------+

Being these different. I hope it was educational for you.