jk-jeon / fp Goto Github PK

Checking here is not needed. There is no instance where shift_amount of 0 is passed. Besides the result is the same.

Following variables do not seam to be explicitly initialised: is_closed, is_left_closed in both policy.h files.

Thanks for your thorough work!

Would you consider accepting a MR for supporting C++11? if constexpr is really handy, but since it is not allowed in C++11, I could rewrite with SFINAE. But the code would be uglier and less readable as a result.

If that would be too much for you, maybe having a permanent cpp11 branch would do?

n32 is not initialised in 1st use.

How are cache and error numbers generated?

How are the cache numbers (this and this) and error (this) numbers generated?

These numbers are different from what is found in the dragonbox repo.

How does the performance compare with;

• https://github.com/lemire/fast_double_parser
• https://github.com/fastfloat/fast_float

Hi there!

I'm looking for ftoa examples similar to the function described in this article:
https://www.geeksforgeeks.org/convert-floating-point-number-string/

Here is the function prototype taken from this article:

/**
Converts a floating-point number to a string with a given number of digits considered after the point.
\param n          --> Input Number
\param res[]      --> Array where output string to be stored
\param afterpoint --> Number of digits to be considered after the point.
*/
void ftoa(float n, char* res, int afterpoint);

I'm able to use the provided implementation but I was wondering how I could achieve the same thing with your fp library or more directly with dragonbox.
My need would be of course to use the fastest existing implementation.

Any help is welcome, thanks!

• Add CI scripts.
• Turn from_chars_unlimited_precision into one-pass for limited precision, two-pass for unlimited precision.
• Optimize from_chars_limited_precision and from_chars_unlimited_precision.
• Implement fixed-point/general formatting routines.
• Correctly implement policies. Implement an interface of to_binary_limited_precision and ryu_printf specialized for the usage in unlimited-precision parsing. (Avoid needless packing into/extracting from IEEE-754 formats.)
• Test against Microsoft STL's <charconv> dataset.
• Determine between header-only and static library; properly separate things that will reside in headers and things that will be compiled.
• Write documents on algorithm/implementation.
• Write documents on API.
• Think of an algorithm for fixed-precision binary-to-decimal conversion that use fewer amount of static data; it is desirable to make it less than 10KB. (Currently, it is possible to get about 26KB by tweaking Ryu-printf a bit.)