FloatToStr

Documentation

API Reference

FloatToStr

Description

Convert a float to a decimal string. Two forms via argument count:

FloatToStr(value) - uses value’s allocator.
FloatToStr(value, alloc) - uses the explicit allocator.

Success

Returns the freshly built Str.

Failure

Returns an empty Str on allocation failure. Use the FloatTryToStr form when you need explicit failure propagation.

Usage example (Cross-references)

Usage examples (Cross-references)

In Type.c:56:

        Float clone    = FloatClone(&original);
        Float expected = FloatFromStr("-12.5", &alloc.base);
        Str   text     = FloatToStr(&clone);
    
        FloatAbs(&original);

In Type.c:290:

        Str   text = StrInit(&alloc.base);
    
        text = FloatToStr(&f);
    
        bool result = ok && (ZstrCompare(StrBegin(&text), "100") == 0);

In Type.c:335:

        double two_pow_60 = 1152921504606846976.0; // 2^60, exact in f64
        Float  value      = FloatFrom(two_pow_60, &alloc.base);
        Str    text       = FloatToStr(&value);
    
        bool result = (FloatExponent(&value) == 0);

In Type.c:356:

    
        FloatAdd(&r, &a, &b);
        t       = FloatToStr(&r);
        bool ok = ZstrCompare(StrBegin(&t), "100.1") == 0;

In Type.c:378:

    
        FloatAdd(&r, &a, &z);
        t       = FloatToStr(&r);
        bool ok = ZstrCompare(StrBegin(&t), "12.5") == 0;

In Math.c:80:

    
        FloatNegate(&value);
        text = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "-12.5") == 0;

In Math.c:86:

        StrDeinit(&text);
        FloatAbs(&value);
        text   = FloatToStr(&value);
        result = result && (ZstrCompare(StrBegin(&text), "12.5") == 0);

In Math.c:106:

    
        FloatAdd(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "1.23") == 0;

In Math.c:129:

    
        FloatAdd(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_THREES) == 0;

In Math.c:153:

    
        FloatAdd(&result_value, &a, &b);
        text        = FloatToStr(&result_value);
        bool result = ZstrCompare(StrBegin(&text), "2") == 0;

In Math.c:158:

        StrDeinit(&text);
        FloatAdd(&result_value, &a, &whole);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3.25") == 0);

In Math.c:163:

        StrDeinit(&text);
        FloatAdd(&result_value, &a, 2u);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3.25") == 0);

In Math.c:168:

        StrDeinit(&text);
        FloatAdd(&result_value, &a, -1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "0.25") == 0);

In Math.c:173:

        StrDeinit(&text);
        FloatAdd(&result_value, &a, 0.75f);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "2") == 0);

In Math.c:178:

        StrDeinit(&text);
        FloatAdd(&result_value, &a, 0.75);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "2") == 0);

In Math.c:201:

    
        FloatSub(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "-0.5") == 0;

In Math.c:224:

    
        FloatSub(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_TWOS) == 0;

In Math.c:248:

    
        FloatSub(&result_value, &a, &b);
        text        = FloatToStr(&result_value);
        bool result = ZstrCompare(StrBegin(&text), "5") == 0;

In Math.c:253:

        StrDeinit(&text);
        FloatSub(&result_value, &a, &whole);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3.5") == 0);

In Math.c:258:

        StrDeinit(&text);
        FloatSub(&result_value, &a, 2u);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3.5") == 0);

In Math.c:263:

        StrDeinit(&text);
        FloatSub(&result_value, &a, -2);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "7.5") == 0);

In Math.c:268:

        StrDeinit(&text);
        FloatSub(&result_value, &a, 0.5f);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "5") == 0);

In Math.c:291:

    
        FloatMul(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "-2.5") == 0;

In Math.c:314:

    
        FloatMul(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_TWOS) == 0;

In Math.c:338:

    
        FloatMul(&result_value, &a, &b);
        text        = FloatToStr(&result_value);
        bool result = ZstrCompare(StrBegin(&text), "3") == 0;

In Math.c:343:

        StrDeinit(&text);
        FloatMul(&result_value, &a, &whole);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3") == 0);

In Math.c:348:

        StrDeinit(&text);
        FloatMul(&result_value, &a, 2u);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "3") == 0);

In Math.c:353:

        StrDeinit(&text);
        FloatMul(&result_value, &a, -2);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "-3") == 0);

In Math.c:358:

        StrDeinit(&text);
        FloatMul(&result_value, &a, 0.5f);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "0.75") == 0);

In Math.c:381:

    
        FloatDiv(&result_value, &a, &b, 3);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "0.125") == 0;

In Math.c:404:

    
        FloatDiv(&result_value, &a, &b, 0);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_ONES) == 0;

In Math.c:428:

    
        FloatDiv(&result_value, &a, &b, 1);
        text        = FloatToStr(&result_value);
        bool result = ZstrCompare(StrBegin(&text), "3") == 0;

In Math.c:433:

        StrDeinit(&text);
        FloatDiv(&result_value, &a, &whole, 1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "2.5") == 0);

In Math.c:438:

        StrDeinit(&text);
        FloatDiv(&result_value, &a, 3u, 1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "2.5") == 0);

In Math.c:443:

        StrDeinit(&text);
        FloatDiv(&result_value, &a, -3, 1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "-2.5") == 0);

In Math.c:448:

        StrDeinit(&text);
        FloatDiv(&result_value, &a, 0.5f, 1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "15") == 0);

In Math.c:453:

        StrDeinit(&text);
        FloatDiv(&result_value, &a, 0.5, 1);
        text   = FloatToStr(&result_value);
        result = result && (ZstrCompare(StrBegin(&text), "15") == 0);

In Math.c:502:

    
        FloatAdd(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "3") == 0;

In Math.c:530:

    
        FloatAdd(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "-3") == 0;

In Math.c:556:

    
        FloatAdd(&result_value, &a, &b);
        text = FloatToStr(&result_value);
    
        bool result = ZstrCompare(StrBegin(&text), "0.75") == 0;

In Math.c:862:

        Str   text = StrInit(&alloc.base);
    
        text = FloatToStr(&f);
    
        bool result = ok && (ZstrCompare(StrBegin(&text), "5") == 0);

In Math.c:884:

        Str   text = StrInit(&alloc.base);
    
        text = FloatToStr(&f);
    
        bool result = ok && (ZstrCompare(StrBegin(&text), "19") == 0);

In Math.c:905:

    
        bool ok     = FloatDiv(&quotient, &a, &b, 8);
        text        = FloatToStr(&quotient);
        bool result = ok && (ZstrCompare(StrBegin(&text), "2") == 0);

In Math.c:974:

    
        bool ok = FloatDiv(&r, &a, 3u, 1);
        text    = FloatToStr(&r);
        ok      = ok && (ZstrCompare(StrBegin(&text), "2.5") == 0);

In Convert.c:54:

    
        Float value = float_from_u64(42, ALLOCATOR_OF(&alloc));
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "42") == 0;

In Convert.c:71:

    
        Float value = float_from_i64(-42, ALLOCATOR_OF(&alloc));
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "-42") == 0;

In Convert.c:89:

        Int   integer = IntFromStr("12345678901234567890", ALLOCATOR_OF(&alloc));
        Float value   = float_from_int(&integer, ALLOCATOR_OF(&alloc));
        Str   text    = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "12345678901234567890") == 0;

In Convert.c:160:

    
        Float value = FloatFromStr("-123.45", ALLOCATOR_OF(&alloc));
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "-123.45") == 0;

In Convert.c:203:

    
        Float value = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES, ALLOCATOR_OF(&alloc));
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_ONES) == 0;

In Convert.c:219:

    
        Float value = FloatFromStr("1.2300e3", ALLOCATOR_OF(&alloc));
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "1230") == 0;

In Convert.c:332:

        Int   whole = IntFrom(100, &alloc.base);
        Float value = FloatFrom(&whole, &alloc.base);
        Str   text  = FloatToStr(&value);
    
        bool result = ZstrCompare(StrBegin(&text), "100") == 0;

In Convert.c:358:

    
        FloatNegate(&value);
        Str text = FloatToStr(&value);
    
        result = result && FloatIsNegative(&value);

In Convert.c:390:

    
        Float value = FloatFrom((u64)100, &alloc.base);
        Str   text  = FloatToStr(&value);
        bool  ok    = ZstrCompare(StrBegin(&text), "100") == 0;

In Convert.c:438:

        bool  ok    = FloatTryFromStr(&value, &text);
    
        Str printed = FloatToStr(&value);
        ok          = ok && (ZstrCompare(StrBegin(&printed), "3.14") == 0);

In Convert.c:455:

    // trailing garbage even if it stringifies as a terminator.
    static bool test_m6_to_str_neg_exp_split(void) {
        WriteFmt("Testing FloatToStr fractional loop bound for 3.14\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Convert.c:460:

    
        Float value = FloatFromStr("3.14", &alloc.base);
        Str   text  = FloatToStr(&value);
    
        bool result = (ZstrCompare(StrBegin(&text), "3.14") == 0) && (StrLen(&text) == 4);

In Convert.c:477:

    // terminates. Asserting exact text and length 5 catches all three.
    static bool test_m6_to_str_leading_zeros(void) {
        WriteFmt("Testing FloatToStr leading-zero loop for 0.001\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Convert.c:482:

    
        Float value = FloatFromStr("0.001", &alloc.base);
        Str   text  = FloatToStr(&value);
    
        bool result = (ZstrCompare(StrBegin(&text), "0.001") == 0) && (StrLen(&text) == 5);

In Convert.c:495:

    // trailing zeros exactly. Guards the positive-exponent path of float_try_to_str.
    static bool test_m6_to_str_positive_exp(void) {
        WriteFmt("Testing FloatToStr positive-exponent trailing zeros for 100\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Convert.c:501:

        // 1e2 keeps significand 1 with exponent 2, exercising the >= 0 zero loop.
        Float value = FloatFromStr("1e2", &alloc.base);
        Str   text  = FloatToStr(&value);
    
        bool result = (ZstrCompare(StrBegin(&text), "100") == 0) && (StrLen(&text) == 3);

In Convert.c:606:

        bool  ok    = FloatTryFromStr(&value, "1.");
    
        Str text = FloatToStr(&value);
        ok       = ok && (ZstrCompare(StrBegin(&text), "1") == 0);

In Convert.c:647:

    
        Float value = FloatFrom(4503599627370496.0, &alloc.base);
        Str   text  = FloatToStr(&value);
    
        bool result = (ZstrCompare(StrBegin(&text), "4503599627370496") == 0) && (StrLen(&text) == 16);

In Write.c:999:

        StrReadFmt(input, "{}", f);
    
        Str  text = FloatToStr(&f);
        bool ok   = (ZstrCompare(StrBegin(&text), expected) == 0);

In Write.c:2394:

        success = success && (ZstrLen(z) == 0);
    
        Str text = FloatToStr(&val);
        success  = success && (ZstrCompare(StrBegin(&text), "3.5") == 0);
        StrDeinit(&text);

In Write.c:2422:

        success = success && (ZstrLen(z) == 0);
    
        Str text = FloatToStr(&val);
        success  = success && (ZstrCompare(StrBegin(&text), "12.25") == 0);
        StrDeinit(&text);

In Write.c:2449:

    
        // 1.5e2 == 150
        Str text = FloatToStr(&val);
        success  = success && (ZstrCompare(StrBegin(&text), "150") == 0);
        StrDeinit(&text);

In Write.c:2474:

        success = success && (ZstrLen(z) == 0);
    
        Str text = FloatToStr(&val);
        success  = success && (ZstrCompare(StrBegin(&text), "-0.25") == 0);
        StrDeinit(&text);

In Read.c:977:

        z = "1234567890.012345";
        StrReadFmt(z, "{}", dec);
        dec_text = FloatToStr(&dec);
        success  = success && (ZstrCompare(StrBegin(&dec_text), "1234567890.012345") == 0);

In Read.c:982:

        z = "1.234567e+04";
        StrReadFmt(z, "{e}", sci);
        sci_text = FloatToStr(&sci);
        success  = success && (ZstrCompare(StrBegin(&sci_text), "12345.67") == 0);

In Read.c:987:

        z = "-0.00125";
        StrReadFmt(z, "{}", neg);
        neg_text = FloatToStr(&neg);
        success  = success && (ZstrCompare(StrBegin(&neg_text), "-0.00125") == 0);

In Read.c:2117:

        (void)FloatTryFromStr(&f, "99"); // sentinel
        StrReadFmt(in, "{}", f);
        Str  t  = FloatToStr(&f);
        bool ok = (ZstrCompare(StrBegin(&t), expect) == 0);
        StrDeinit(&t);

In Read.c:2635:

        Zstr           z   = "3.14159";
        StrReadFmt(z, "{}", f);
        Str  t  = FloatToStr(&f);
        bool ok = (ZstrCompare(StrBegin(&t), "3.14159") == 0);
        StrDeinit(&t);

In Read.c:2652:

        Zstr z   = "xyz"; // no float token
        Zstr out = str_read_fmt(z, "{}", (TypeSpecificIO[]) {TO_TYPE_SPECIFIC_IO(Float, &f)}, 1);
        Str  t   = FloatToStr(&f);
        bool ok  = (out == NULL) && (ZstrCompare(StrBegin(&t), "42") == 0);
        StrDeinit(&t);

Last updated on July 1, 2026

FloatToInt FloatTryClone