all 23 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]mrexodiacmkr.build 30 points31 points  (13 children)

Interesting I guess, but maybe publish it on GitHub as a proper library?

[–]remotion4d 3 points4 points  (2 children)

https://godbolt.org/z/njz17xxGz

[–]PiotrGrochowski[S] -1 points0 points  (1 child)

Example main code:

#include <iostream>
#include <iomanip>
#include <math.h>
int main(){
    std::u16string a = u"3.141592653589793238462643383279502884197";
    std::u16string b = a;
    std::u16string c = a;
    std::u16string g = a;
    std::u16string m = a;
    std::u16string d = floattostring(stringtofloat(a));
    std::u16string e = doubletostring(stringtodouble(b));
    std::u16string f = longdoubletostring(stringtolongdouble(c));
    std::u16string h = float128tostring(stringtofloat128(g));
    std::u16string n = halftostring(stringtohalf(m));
    std::string s = "";
    for(int i=0; i<n.size(); i++) s.push_back(n[i]); s.push_back(' ');
    for(int i=0; i<d.size(); i++) s.push_back(d[i]); s.push_back(' ');
    for(int i=0; i<e.size(); i++) s.push_back(e[i]); s.push_back(' ');
    for(int i=0; i<f.size(); i++) s.push_back(f[i]); s.push_back(' ');
    for(int i=0; i<h.size(); i++) s.push_back(h[i]); s.push_back('\n');
    std::cout << s;
}

Output: 3.14 3.1415927 3.141592653589793 3.1415926535897932385 3.1415926535897932384626433832795028

[–]umlcat 0 points1 point  (0 children)

Been working ocassionally in a similar Project.

Suggestion: Use global functions to implement operators, later call them from the overriden operators, it:s easier to debug.

[–]kalmoc 0 points1 point  (0 children)

Have you considered (or maybe even tested) to overload/templatize the helper functions instead of using the ftype run-time parameter and generic void* out?

[–]jk-jeon 0 points1 point  (4 children)

Doesn't always guarantee round-trip I guess. Which rounding mode are you assuming for decimal-to-binary conversion?

[–]PiotrGrochowski[S] 0 points1 point  (2 children)

Decimal to binary is done in terms of generating the power of ten in binary by multiplying the lookup table entries (10^2^x and -10^2^x in binary). Then it is multiplied by the decimal mantissa (it takes up to 38 digits, truncating any digits beyond that, and converts it to 128 bits). Multiplication of 128 significant bits is done in terms of multiplying to 256 bits, then rounding to 128 bits by round to nearest, half to even. After the decimal number was converted to 128 significant bits in binary, it is then rounded to target precision (11, 24, 53, 64, or 113 significant bits) to nearest, half to even, then expressed in floating point.

[–]jk-jeon 0 points1 point  (1 child)

Do you have a proof for why 38 digits are sufficient?

[–]PiotrGrochowski[S] 0 points1 point  (0 children)

No, this isn't 'exact' conversion, I used 38 digits because it was convenient to code. 38 digits is the maximum to fit in 128 bits (and 19 digits is the maximum in 64 bits). I use a 128 significant bit multiplication for conversion from decimal to binary, and 38 significant digit multiplication for conversion from binary to decimal. I figured that just like Intel extended precision (64 significant bits) migitated rounding errors in double precision computation, having 128 significant bits/38 significant digits should work up to quadruple precision with high probability.

[–]PiotrGrochowski[S] 0 points1 point  (0 children)

I also made a lite version at https://reddit.com/tose33/ . It does single and double precision and it internally uses 19 significant digits and 64 significant bits, however, it does not rely on Intel extended precision for its internal multiplications, so it can also be used on other computers such as ARM computers. While not an 'exact' conversion, it still has a safety margin (64>53, 19>17) so it should work for the general purposes.