/*
    14__limits_float.c
    Greske zaokruzivanja kod tipa float
    Napomena: Ovaj primjer obavezno compilirati s ANSI C
    kompatibilnim compilerom (npr. GCC)
*/
 
#include <stdio.h>
 
/* Tip float <--> IEEE-754 standard za jednostruku preciznost:
   |x|xxxxxxxx|xxxxxxxxxxxxxxxxxxxxxxx| (32 bita)
   predznak - 1 bit
   karakteristika - 8 bitova (sluzi za spremanje eksponenta)
   mantisa - 23 bita
*/
 
int main ()
{
    float f;
    double d;
 
    /* 1E9 i 1E10 ce se ispisati ispravno (tocno),
       no vec 1E11 (pa i 1E12) vise nece */
    f=1E9f;
    printf("1E9: %f\n", f);
    f=1E10f;
    printf("1E10: %f\n", f);
    f=1E11f;
    printf("1E11: %f\n", f);
    f=1E12f;
    printf("1E12: %f\n\n", f);
 
    /* Uzrok pogresnog ispisivanja gornjih brojeva lezi u cinjenici da
       tip float ima preciznost od 23 binarne znamenke.
       Slijedeci primjer pokazat ce nam koja je to granica kada tip float
       postaje "neprecizan".
    */
    /* Primijetimo da je 16777215 == 2^24-1 */
    f=16777215.f;
    printf("2^24-1: %f\n", f);
    f=f+1;
    printf("2^24: %f\n", f);
    /* Da bismo mogli zbrojiti 2^24 i 1 trebale bi nam minimalno 24
       binarne znamenke u mantisi.
       Stoga ispada da 2^24+1 iznosi 2^24. */
    f=f+1;
    printf("2^24+1: %f\n\n", f);
 
    /* Ukoliko prethodni primjer provedemo na tipu double vidjet cemo da
       se nece pojaviti navedeni problem buduci da tip double (64 bita)
       ima (daleko) vecu preciznost od tipa float */
    d=16777215.;
    printf("2^24-1: %f\n", d);
    d=d+1;
    printf("2^24: %f\n", d);
    d=d+1;
    printf("2^24+1: %f\n", d);
 
    return 0;
}