Factorio Forums

Code: Select all

def pp(f:float):
  int_part=math.floor(f)
  f-=int_part
  s=str(int(int_part))
  if f==0:
    print(s)
    return
  s+="."
  while f!=0:
    f*=10
    int_part=math.floor(f)
    f-=int_part
    s+=str(int(int_part))
  print(s)

Code: Select all

0.09999999999999986677323704498121514916419982910156250000 0.09999999999999987
0.09999999999999988065102485279567190445959568023681640625 0.09999999999999988
0.09999999999999989452881266061012865975499153137207031250 0.0999999999999999
0.09999999999999990840660046842458541505038738250732421875 0.09999999999999991
0.09999999999999992228438827623904217034578323364257812500 0.09999999999999992
0.09999999999999993616217608405349892564117908477783203125 0.09999999999999994
0.09999999999999995003996389186795568093657493591308593750 0.09999999999999995
0.09999999999999996391775169968241243623197078704833984375 0.09999999999999996
0.09999999999999997779553950749686919152736663818359375000 0.09999999999999998
0.09999999999999999167332731531132594682276248931884765625 0.09999999999999999
0.10000000000000000555111512312578270211815834045410156250 0.1
0.10000000000000001942890293094023945741355419158935546875 0.10000000000000002
0.10000000000000003330669073875469621270895004272460937500 0.10000000000000003
0.10000000000000004718447854656915296800434589385986328125 0.10000000000000005
0.10000000000000006106226635438360972329974174499511718750 0.10000000000000006
0.10000000000000007494005416219806647859513759613037109375 0.10000000000000007
0.10000000000000008881784197001252323389053344726562500000 0.10000000000000009
0.10000000000000010269562977782697998918592929840087890625 0.1000000000000001
0.10000000000000011657341758564143674448132514953613281250 0.10000000000000012
0.10000000000000013045120539345589349977672100067138671875 0.10000000000000013
0.10000000000000014432899320127035025507211685180664062500 0.10000000000000014

Code: Select all

0.099999999999999857891452847979962825775146484375
0.099999999999999875655021241982467472553253173828125
0.09999999999999989341858963598497211933135986328125
0.099999999999999911182158029987476766109466552734375
0.0999999999999999289457264239899814128875732421875
0.0999999999999999289457264239899814128875732421875
0.09999999999999996447286321199499070644378662109375
0.09999999999999996447286321199499070644378662109375
0.099999999999999982236431605997495353221893310546875
0.099999999999999982236431605997495353221893310546875
0.1
0.10000000000000002220446049250313080847263336181640625
0.1000000000000000444089209850062616169452667236328125
0.1000000000000000444089209850062616169452667236328125
0.10000000000000006661338147750939242541790008544921875
0.10000000000000006661338147750939242541790008544921875
0.100000000000000088817841970012523233890533447265625
0.10000000000000011102230246251565404236316680908203125
0.10000000000000011102230246251565404236316680908203125
0.1000000000000001332267629550187848508358001708984375
0.1000000000000001332267629550187848508358001708984375

Code: Select all

#include <iostream>
#include <cmath>


//precondition:  pos points to somewhere in a buffer that has at 
//               least 30 more characters
//postcondition: pos points to a null character after the shortest decimal
//               string representation that will convert back to n
void to_json(double n,char*& pos){
    //todo: check NaN
    if(n<0){
        *(pos++)='-';
        n=-n;
    }
    if(n==0){
        *(pos++)='0';
        *pos=0;
        return;
    }
    //todo: check INF
    
    //increase precision so we don't loose bits when changing power.
    long double m = n;
    //find power of decimal scientitfic form.
    int e=0;
    while(m>1){
        m/=10;
        e++;
    }
    while(m<1){
        m*=10;
        e--;
    }
    
    char* start_of_number = pos;
    char* decimal_pos = pos+1;
    if(e>20){//positive exponent
    }else if(e>=0){//unlikely exponent, no leading zero
        decimal_pos = pos+e+1;
    }else if(e>-4){//no exponent, leading zero
        *(pos++)='0';
        *(pos++)='.';
        for(int zeros=1; zeros<-e; zeros++){
            *(pos++)='0';
        }
    }else{//negative expoent
    }

    //magic sauce: !!EDIT: this does a poor job (fails in both directions)
    long double rounder=std::ldexp(m,-54)*1e16;
    //get the first 16 digits
    for(int significant_digits = 0; significant_digits < 16; significant_digits++){
        if(pos==decimal_pos){
            *(pos++)='.';
        }
        long double digit = std::floor(m);
        m-=digit;
        *(pos++)='0'+(char) digit;
        m*=10;
    }
    
    //determine the 17th digit and truncate trailing zeros
    //we only need precision to rounder, 
    // so if we can make the 17th digit zero, do so.
    if(m+rounder >= 10){
        //we're close enough we can round up to 16 digits
        //this may cause repeated carrying
        do{
            pos--;
        }while(pos>start_of_number && (*pos=='9' ||  *pos=='.'));
        if(*pos=='9'){
            //we had 99...99 get rounded up to 100...00
            e++;
            *pos='1';
        }else{
            *pos+=1;
        }
    }else if(m-rounder<=0){
        //we're close enough we can round down to 16 digits
        //this may lead to many trailing zeros
        do{
            pos--;
        }while(*pos=='0' || *pos=='.');
    }else{
        //just round to the closest 17th digit 
        *pos='0'+(char) std::floor(m+0.5);
    }
    //each branch above leaves pos pointing to the last non-zero digit
    
    pos++;
    //deal with the required zeros / expoent
    if(-4<e && e < pos-start_of_number+2){
        //no expoent
        //add back any required zeros (e.g.  34 -> 34000)
        int zeros = e + 1 - (pos-start_of_number);
        while(zeros-- >0){
            *(pos++)='0';
        }
        *pos=0;
        return;
    }
    //we have an expoent
    
    if(e>0 && e<=20){
        //we didn't add the decimal earlier
        char* return_pos=pos+1;
        decimal_pos=start_of_number+1;
        while(pos>decimal_pos){
            *pos = *(pos-1);
            pos--;
        }
        *pos='.';
        pos=return_pos;
    }
    
    
    *(pos++)='e';
    if(e<0){
        *(pos++)='-';
        e=-e;
    }
    int exp_digits;
    if(e>=100){
        exp_digits=3;
    }else if(e>=10){
        exp_digits=2;
    }else{
        exp_digits=1;
    }
    std::div_t dv;
    switch(exp_digits){
        case 3:
            dv = std::div(e,100);
            *(pos++)='0'+dv.quot;
            e=dv.rem;
            //no break
        case 2:
            dv = std::div(e,10);
            *(pos++)='0'+dv.quot;
            e=dv.rem;
            //no break
        default:
            *(pos++)='0'+e;
    }
    *pos=0;
}

int main()
{
    //double test = 0.00000010000000000000001;
    double test = 1234567891000;
    char buff[30]={0};
    char* pos=buff;
    to_json(test,pos);
    double check = std::stod(buff);
    std::cout<< buff << std::endl << (check == test) << std::endl;

    return 0;
}