FloatInit

Documentation

API Reference

FloatInit

Description

Create a zero-valued floating-point number.

This public macro supports both forms:

FloatInit() - uses DefaultAllocator().
FloatInit(alloc) - binds the supplied allocator.

Parameters

Name	Direction	Description
`alloc`	in	Optional allocator override.

Usage example (from documentation)

  Float value = FloatInit();

Success

Returns a fresh Float representing positive zero (negative=false, significand=0, exponent=0) with the chosen allocator bound through the inner Int. No heap allocation happens until the value is mutated.

Failure

Function cannot fail.

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:3211:

        const char *start     = NULL;
        Str         temp      = StrInit();
        Float       parsed    = FloatInit();
    
        if (!i || !value) {

In Float.c:60:

        }
    
        *out = FloatInit(alloc);
        return FloatTryFromStr(out, text);
    }

In Float.c:77:

        }
    
        *out = FloatInit(alloc);
        return FloatTryFromStr(out, text);
    }

In Float.c:186:

        {
            i64   target_exponent = lhs->exponent < rhs->exponent ? lhs->exponent : rhs->exponent;
            Float lhs_scaled      = FloatInit(lhs->significand.bits.allocator);
            Float rhs_scaled      = FloatInit(rhs->significand.bits.allocator);

In Float.c:187:

            i64   target_exponent = lhs->exponent < rhs->exponent ? lhs->exponent : rhs->exponent;
            Float lhs_scaled      = FloatInit(lhs->significand.bits.allocator);
            Float rhs_scaled      = FloatInit(rhs->significand.bits.allocator);
    
            if (!FloatTryClone(&lhs_scaled, lhs) || !FloatTryClone(&rhs_scaled, rhs) ||

In Float.c:242:

    
        ValidateFloat(value);
        clone = FloatInit(value->significand.bits.allocator);
        (void)FloatTryClone(&clone, value);
        return clone;

In Float.c:254:

    
        ValidateFloat(value);
        *out          = FloatInit(value->significand.bits.allocator);
        out->negative = value->negative;
        out->exponent = value->exponent;

In Float.c:259:

        if (!IntTryClone(&out->significand, &value->significand)) {
            FloatDeinit(out);
            *out = FloatInit(value->significand.bits.allocator);
            return false;
        }

In Float.c:272:

        }
    
        *out = FloatInit(alloc);
        if (!float_try_int_from_u64(&out->significand, value, alloc)) {
            FloatDeinit(out);

In Float.c:275:

        if (!float_try_int_from_u64(&out->significand, value, alloc)) {
            FloatDeinit(out);
            *out = FloatInit(alloc);
            return false;
        }

In Float.c:311:

    
        ValidateInt(value);
        *out = FloatInit(value->bits.allocator);
        if (!IntTryClone(&out->significand, value)) {
            FloatDeinit(out);

In Float.c:314:

        if (!IntTryClone(&out->significand, value)) {
            FloatDeinit(out);
            *out = FloatInit(value->bits.allocator);
            return false;
        }

In Float.c:324:

        Float result;
    
        result = FloatInit(DefaultAllocator());
        (void)float_try_from_u64_value(&result, value, DefaultAllocator());
        float_normalize(&result);

In Float.c:331:

    
    Float float_from_i64(i64 value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_i64_value(&result, value, DefaultAllocator());

In Float.c:342:

    
        ValidateInt(value);
        result = FloatInit(value->bits.allocator);
        (void)float_try_from_int_value(&result, value);
        float_normalize(&result);

In Float.c:349:

    
    Float float_from_f32(float value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f32_value(&result, value, DefaultAllocator());

In Float.c:356:

    
    Float float_from_f64(double value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f64_value(&result, value, DefaultAllocator());

In Float.c:434:

    
        ValidateFloat(out);
        result = FloatInit(out->significand.bits.allocator);
        digits = StrInit(out->significand.bits.allocator);

In Float.c:526:

    
    Float FloatFromStr(const char *text) {
        Float result = FloatInit();
    
        (void)FloatTryFromStr(&result, text);

In Float.c:664:

    
    int float_compare_int_with_error(Float *lhs, Int *rhs, bool *error) {
        Float rhs_value = FloatInit(lhs->significand.bits.allocator);
        int   cmp       = 0;

In Float.c:690:

    
    int float_compare_u64_with_error(Float *lhs, u64 rhs, bool *error) {
        Float rhs_value = FloatInit(lhs->significand.bits.allocator);
        int   cmp       = 0;

In Float.c:715:

    
    int float_compare_i64_with_error(Float *lhs, i64 rhs, bool *error) {
        Float rhs_value = FloatInit(lhs->significand.bits.allocator);
        int   cmp       = 0;

In Float.c:740:

    
    int float_compare_f32_with_error(Float *lhs, float rhs, bool *error) {
        Float rhs_value = FloatInit(lhs->significand.bits.allocator);
        int   cmp       = 0;

In Float.c:765:

    
    int float_compare_f64_with_error(Float *lhs, double rhs, bool *error) {
        Float rhs_value = FloatInit(lhs->significand.bits.allocator);
        int   cmp       = 0;

In Float.c:811:

        ValidateFloat(a);
        ValidateFloat(b);
        lhs  = FloatInit(a->significand.bits.allocator);
        rhs  = FloatInit(b->significand.bits.allocator);
        temp = FloatInit(result->significand.bits.allocator);

In Float.c:812:

        ValidateFloat(b);
        lhs  = FloatInit(a->significand.bits.allocator);
        rhs  = FloatInit(b->significand.bits.allocator);
        temp = FloatInit(result->significand.bits.allocator);

In Float.c:813:

        lhs  = FloatInit(a->significand.bits.allocator);
        rhs  = FloatInit(b->significand.bits.allocator);
        temp = FloatInit(result->significand.bits.allocator);
    
        if (!FloatTryClone(&lhs, a) || !FloatTryClone(&rhs, b)) {

In Float.c:872:

    
    bool float_add_int(Float *result, Float *a, Int *b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_int_value(&rhs, b)) {

In Float.c:883:

    
    bool float_add_u64(Float *result, Float *a, u64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_u64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:894:

    
    bool float_add_i64(Float *result, Float *a, i64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_i64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:905:

    
    bool float_add_f32(Float *result, Float *a, float b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f32_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:916:

    
    bool float_add_f64(Float *result, Float *a, double b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:927:

    
    bool float_sub(Float *result, Float *a, Float *b) {
        Float rhs = FloatInit(b->significand.bits.allocator);
    
        ValidateFloat(result);

In Float.c:943:

    
    bool float_sub_int(Float *result, Float *a, Int *b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_int_value(&rhs, b)) {

In Float.c:954:

    
    bool float_sub_u64(Float *result, Float *a, u64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_u64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:965:

    
    bool float_sub_i64(Float *result, Float *a, i64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_i64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:976:

    
    bool float_sub_f32(Float *result, Float *a, float b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f32_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:987:

    
    bool float_sub_f64(Float *result, Float *a, double b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:998:

    
    bool float_mul(Float *result, Float *a, Float *b) {
        Float temp = FloatInit(result->significand.bits.allocator);
    
        ValidateFloat(result);

In Float.c:1017:

    
    bool float_mul_int(Float *result, Float *a, Int *b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_int_value(&rhs, b)) {

In Float.c:1028:

    
    bool float_mul_u64(Float *result, Float *a, u64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_u64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:1039:

    
    bool float_mul_i64(Float *result, Float *a, i64 b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_i64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:1050:

    
    bool float_mul_f32(Float *result, Float *a, float b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f32_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:1061:

    
    bool float_mul_f64(Float *result, Float *a, double b) {
        Float rhs = FloatInit(result->significand.bits.allocator);
    
        if (!float_try_from_f64_value(&rhs, b, result->significand.bits.allocator)) {

In Float.c:1072:

    
    bool float_div(Float *result, Float *a, Float *b, u64 precision) {
        Float temp   = FloatInit(result->significand.bits.allocator);
        Int   scale  = IntInit(result->significand.bits.allocator);
        Int   scaled = IntInit(result->significand.bits.allocator);

In Float.c:1085:

        }
        if (FloatIsZero(a)) {
            Float zero = FloatInit();
    
            FloatDeinit(result);

In Float.c:1118:

    
    bool float_div_int(Float *result, Float *a, Int *b, u64 precision) {
        Float rhs = FloatInit(result->significand.bits.allocator);
        bool  ok  = false;

In Float.c:1130:

    
    bool float_div_u64(Float *result, Float *a, u64 b, u64 precision) {
        Float rhs = FloatInit(result->significand.bits.allocator);
        bool  ok  = false;

In Float.c:1142:

    
    bool float_div_i64(Float *result, Float *a, i64 b, u64 precision) {
        Float rhs = FloatInit(result->significand.bits.allocator);
        bool  ok  = false;

In Float.c:1154:

    
    bool float_div_f32(Float *result, Float *a, float b, u64 precision) {
        Float rhs = FloatInit(result->significand.bits.allocator);
        bool  ok  = false;

In Float.c:1166:

    
    bool float_div_f64(Float *result, Float *a, double b, u64 precision) {
        Float rhs = FloatInit(result->significand.bits.allocator);
        bool  ok  = false;

In Float.Math.c:50:

        Float a            = FloatFromStr("1.2");
        Float b            = FloatFromStr("0.03");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:70:

        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b            = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:91:

        Float b            = FloatFromStr("0.75");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:136:

        Float a            = FloatFromStr("1.5");
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:156:

        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_THREES);
        Float b            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:177:

        Float b            = FloatFromStr("0.5");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:217:

        Float a            = FloatFromStr("12.5");
        Float b            = FloatFromStr("-0.2");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:237:

        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:258:

        Float b            = FloatFromStr("2");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:298:

        Float a            = FloatFromStr("1");
        Float b            = FloatFromStr("8");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:318:

        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:339:

        Float b            = FloatFromStr("2.5");
        Int   whole        = IntFrom(3);
        Float result_value = FloatInit();
        Str   text         = StrInit();

In Float.Math.c:383:

    
        Float a = FloatFromStr("1");
        Float b = FloatInit();
        Float r = FloatInit();
        bool  ok;

In Float.Math.c:384:

        Float a = FloatFromStr("1");
        Float b = FloatInit();
        Float r = FloatInit();
        bool  ok;

In Io.Read.c:954:

        bool        success = true;
    
        Float dec = FloatInit();
        Float sci = FloatInit();
        Float neg = FloatInit();

In Io.Read.c:955:

    
        Float dec = FloatInit();
        Float sci = FloatInit();
        Float neg = FloatInit();

In Io.Read.c:956:

        Float dec = FloatInit();
        Float sci = FloatInit();
        Float neg = FloatInit();
    
        Str dec_text = StrInit();

In Float.Convert.c:174:

    
        Float parsed = FloatFromStr("12.3.4");
        Float value  = FloatInit();
        bool  result = !FloatTryFromStr(&value, "12.3.4");

In Float.Convert.c:189:

    
        Float parsed = FloatFromStr(NULL);
        Float value  = FloatInit();
        bool  result = !FloatTryFromStr(&value, NULL);

In Float.Access.c:13:

        WriteFmt("Testing FloatIsZero\n");
    
        Float zero  = FloatInit();
        Float value = FloatFromStr("0.001");

In Float.Type.c:14:

    
    bool test_float_init(void) {
        WriteFmt("Testing FloatInit\n");
    
        Float value = FloatInit();

In Float.Type.c:16:

        WriteFmt("Testing FloatInit\n");
    
        Float value = FloatInit();
    
        bool result = FloatIsZero(&value);

In Float.Type.c:70:

        alloc.flags = 0x6D6Du;
    
        Float original = FloatInit(alloc);
        original.negative = true;
        original.exponent = -3;

Last updated on May 14, 2026

FloatGT FloatIsNegative