Convert a float to char[] without memory allocation

Question

Do you know how to convert a float into a buffer of chars, without allocating any memory?

=> I simply want to re-do the same thing as float.ToString() do ; so I can put the result into a buffer instead of allocating a string

I wrote a function, but it doesn't handle very well the "rounding":

• 39.71 becomes "39.709996"
• 39.71001 becomes "39.710004"

That's because 39.71 as a float is a rounding of the stored value in memory which is 39.709996. With some rounding in my function I can easily come to something like this:

• 39.71 becomes "39.71"
• 39.71001 becomes "39.71"

Which is not great either, as I would like to keep the exact same algorithm of float.ToString() that manages to write "39.71" and "39.71001"

Do you know how this float.ToString() works exactly ?

Precision on my objective : I want to append a great lot of float (mixed with other types) in a very large string - and allocate this string only one time at the end to avoid too much garbage collection. So I really need to convert the float into an array of char (whatever the exact type format, just no unmutable string)

Answer 1

From your comments it seems that you want to be able to format a lot of floats (and other value types) into a very large array of characters, without having to do a lot of memory allocations.

It's not possible to avoid all memory allocations, but you can mimimise them by using StringBuilder.AppendFormat() and StringBuilder.CopyTo().

If you have some idea of the maximum length of the final char array, you can initialise a StringBuilder with a capacity large enough to hold it. This potentially reduces the number of memory allocations, but at the expense of wasting memory if you make the buffer too large.

Code goes something like this:

int capacity = 8192; // If you have some idea of the final string length.
var sb = new StringBuilder(capacity);

for (float x = 0; x < 1000; x += 1.2345f)
    sb.AppendFormat(", {0}", x);

char[] array = new char[sb.Length];

sb.CopyTo(0, array, 0, sb.Length); // Now array[] contains the result.

Note that the minimum number of buffer allocations here is two: One for the internal buffer used by StringBuilder and one for the char[] array.

However, it is likely that a great many other small allocations will be taking place behind the scenes - but because of the way the GC works they are unlikely to make their way into any generation 1 collections, so it is not likely to cause a performance issue.

Answer 2

You can call the C stdlib sprintf() and friends which should solve most of your formatting and data problems. See https://stackoverflow.com/a/2479210/3150802 for an example. Keeping track of the printing position, i.e. the index into the char array, by evaluating sprintf()'s return value will be important.

There is some performance penalty for crossing the managed/unmanaged boundary which is unavoidable. A possible mitigation strategy is to reduce the number of such crossings, for example by writing a C wrapper function which receives a large array of floats and writes them all in one go, using s*printf().

The potential penalty for data marshaling (i.e. back-and-forth converting between CLI and native representations) may not be an issue for PODs like floats and addresses if they are bit-wise identical in both worlds.

Answer 3

Below is the solution I finally wrote, thanks to the float.ToString() source code provided by Marc Gravell.

It's much simplified but it seems to work pretty well for now (maybe I missed some special cases). The only major difference I see is that very small float like 5.34E-05 will be written basically like 0.0000534 (and actually I prefer like that)

For info here is my full StringFast class (Unity C# code): http://pastebin.com/HqAw2pTG. And some tests using it here: http://pastebin.com/brynBFyC

The test runs 1000 times these operations: 4 appends (2 string, a float and an int) and 1 string replacement. I run the tests using string with + and Concat(), using StringBuilder, and using my StringFast class. Of course for the last two I do not recreate them every time.

Here are the results, with the memory allocation and the time:

• string (+) : 302.7KB, 1.75ms
• string (.concat) : 302.7KB, 1.85ms
• StringBuilder : 259.8KB, 1.81ms
• StringFast: 58.6KB, 1.68ms

And if I replace my 5 operations by a concatenation of 100 floats :

• string (+) : 36.8MB, 116.19ms
• string (.concat) : 36.8MB, 116.19ms
• StringBuilder : 6.0MB, 63.26ms
• StringFast: 0.6MB, 51.09ms

As you can see the StringBuilder is not that great, especially when there are only a couple of operations on the string. The allocations of the StringFast class are only caused by the final ToString() I do (in order to be able to use the string with other functions)

Here is the code for the float conversion to a char array:

///<summary>Append a float without memory allocation.</summary>
public StringFast Append( float valueF )
{
    double value = valueF;
    m_isStringGenerated = false;
    ReallocateIFN( 32 ); // Check we have enough buffer allocated to handle any float number

    // Handle the 0 case
    if( value == 0 )
    {
        m_buffer[ m_bufferPos++ ] = '0';
        return this;
    }

    // Handle the negative case
    if( value < 0 )
    {
        value = -value;
        m_buffer[ m_bufferPos++ ] = '-';
    }

    // Get the 7 meaningful digits as a long
    int nbDecimals = 0;
    while( value < 1000000 )
    {
        value *= 10;
        nbDecimals++;
    }
    long valueLong = (long)System.Math.Round( value );

    // Parse the number in reverse order
    int nbChars = 0;
    bool isLeadingZero = true;
    while( valueLong != 0 || nbDecimals >= 0 )
    {
        // We stop removing leading 0 when non-0 or decimal digit
        if( valueLong%10 != 0 || nbDecimals <= 0 )
            isLeadingZero = false;

        // Write the last digit (unless a leading zero)
        if( !isLeadingZero )
            m_buffer[ m_bufferPos + (nbChars++) ] = (char)('0' + valueLong%10);

        // Add the decimal point
        if( --nbDecimals == 0 && !isLeadingZero )
            m_buffer[ m_bufferPos + (nbChars++) ] = '.';

        valueLong /= 10;
    }
    m_bufferPos += nbChars;

    // Reverse the result
    for( int i=nbChars/2-1; i>=0; i-- )
    {
        char c = m_buffer[ m_bufferPos-i-1 ];
        m_buffer[ m_bufferPos-i-1 ] = m_buffer[ m_bufferPos-nbChars+i ];
        m_buffer[ m_bufferPos-nbChars+i ] = c;
    }

    return this;
}