Float

Documentation

API Reference

Float

Description

Decimal arbitrary-precision floating-point value. The number represented is (-1)^negative * significand * 10^exponent.

Fields

Name	Description
`negative`	Sign flag. Zero is always normalized to non-negative.
`significand`	Integer significand stored without decimal point.
`exponent`	Base-10 exponent applied to the significand.

Usage example (from documentation)

  Float value = FloatFromStr("12.5");

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:843:

    }
    
    static Str FloatFmtToDecimalStr(Float *value, u32 precision, bool has_precision) {
        Str canonical = FloatToStr(value);

In Io.c:898:

    }
    
    static Str FloatFmtToScientificStr(Float *value, u32 precision, bool has_precision, bool uppercase) {
        Str digits = IntToStr(&value->significand);
        Str result = StrInit();

In Io.c:1468:

    }
    
    void _write_Float(Str *o, FmtInfo *fmt_info, Float *value) {
        size start_len = 0;
        Str  temp      = StrInit();

In Io.c:1481:

    
        if (FloatFmtUsesUnsupportedFlags(fmt_info)) {
            LOG_FATAL("Float only supports decimal and scientific formatting");
        }

In Io.c:2843:

    }
    
    const char *_read_Float(const char *i, FmtInfo *fmt_info, Float *value) {
        size        token_len = 0;
        const char *start     = NULL;

In Io.c:2847:

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

In Io.c:2854:

    
        if (FloatFmtUsesUnsupportedFlags(fmt_info)) {
            LOG_ERROR("Float only supports decimal and scientific reading");
            return i;
        }

In Io.c:2865:

    
        if (!*i) {
            LOG_ERROR("Failed to parse Float: empty input");
            return i;
        }

In Io.c:2873:

    
        if (token_len == 0) {
            LOG_ERROR("Failed to parse Float");
            return start;
        }

In Float.c:7:

    /// Arbitrary-precision decimal floating-point implementation built on top of Int.
    
    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Container/Int.h>
    #include <Misra/Std/Log.h>

In Float.c:17:

    #include <string.h>
    
    static void float_normalize(Float *value);
    static void float_replace(Float *dst, Float *src);
    static Int  float_pow10(u64 power);

In Float.c:18:

    
    static void float_normalize(Float *value);
    static void float_replace(Float *dst, Float *src);
    static Int  float_pow10(u64 power);
    static void float_scale_to_exponent(Float *value, i64 target_exponent);

In Float.c:20:

    static void float_replace(Float *dst, Float *src);
    static Int  float_pow10(u64 power);
    static void float_scale_to_exponent(Float *value, i64 target_exponent);
    static int  float_abs_compare(Float *lhs, Float *rhs);
    static i64  float_add_i64_checked(i64 a, i64 b);

In Float.c:21:

    static Int  float_pow10(u64 power);
    static void float_scale_to_exponent(Float *value, i64 target_exponent);
    static int  float_abs_compare(Float *lhs, Float *rhs);
    static i64  float_add_i64_checked(i64 a, i64 b);
    static i64  float_sub_i64_checked(i64 a, i64 b);

In Float.c:24:

    static i64  float_add_i64_checked(i64 a, i64 b);
    static i64  float_sub_i64_checked(i64 a, i64 b);
    static Float float_from_f32_value(float value);
    static Float float_from_f64_value(double value);

In Float.c:25:

    static i64  float_sub_i64_checked(i64 a, i64 b);
    static Float float_from_f32_value(float value);
    static Float float_from_f64_value(double value);
    
    static i64 float_add_i64_checked(i64 a, i64 b) {

In Float.c:29:

    static i64 float_add_i64_checked(i64 a, i64 b) {
        if ((b > 0 && a > INT64_MAX - b) || (b < 0 && a < INT64_MIN - b)) {
            LOG_FATAL("Float exponent overflow");
        }

In Float.c:37:

    static i64 float_sub_i64_checked(i64 a, i64 b) {
        if ((b > 0 && a < INT64_MIN + b) || (b < 0 && a > INT64_MAX + b)) {
            LOG_FATAL("Float exponent overflow");
        }

In Float.c:43:

    }
    
    static Float float_from_f32_value(float value) {
        char text[32] = {0};
        int  len      = snprintf(text, sizeof(text), "%.9g", (double)value);

In Float.c:48:

    
        if (len < 0 || len >= (int)sizeof(text)) {
            LOG_FATAL("Failed to convert f32 to Float");
        }

In Float.c:54:

    }
    
    static Float float_from_f64_value(double value) {
        char text[48] = {0};
        int  len      = snprintf(text, sizeof(text), "%.17g", value);

In Float.c:59:

    
        if (len < 0 || len >= (int)sizeof(text)) {
            LOG_FATAL("Failed to convert f64 to Float");
        }

In Float.c:65:

    }
    
    static void float_replace(Float *dst, Float *src) {
        FloatDeinit(dst);
        *dst = *src;

In Float.c:79:

    }
    
    static void float_scale_to_exponent(Float *value, i64 target_exponent) {
        ValidateFloat(value);

In Float.c:107:

    }
    
    static int float_abs_compare(Float *lhs, Float *rhs) {
        ValidateFloat(lhs);
        ValidateFloat(rhs);

In Float.c:117:

        {
            i64   target_exponent = lhs->exponent < rhs->exponent ? lhs->exponent : rhs->exponent;
            Float lhs_scaled      = FloatClone(lhs);
            Float rhs_scaled      = FloatClone(rhs);
            int   cmp             = 0;

In Float.c:118:

            i64   target_exponent = lhs->exponent < rhs->exponent ? lhs->exponent : rhs->exponent;
            Float lhs_scaled      = FloatClone(lhs);
            Float rhs_scaled      = FloatClone(rhs);
            int   cmp             = 0;

In Float.c:131:

    }
    
    static void float_normalize(Float *value) {
        ValidateFloat(value);

In Float.c:150:

    }
    
    bool FloatIsZero(Float *value) {
        ValidateFloat(value);
        return IntIsZero(&value->significand);

In Float.c:155:

    }
    
    bool FloatIsNegative(Float *value) {
        ValidateFloat(value);
        return !FloatIsZero(value) && value->negative;

In Float.c:160:

    }
    
    i64 FloatExponent(Float *value) {
        ValidateFloat(value);
        return value->exponent;

In Float.c:165:

    }
    
    Float FloatClone(Float *value) {
        Float clone = FloatInit();

In Float.c:166:

    
    Float FloatClone(Float *value) {
        Float clone = FloatInit();
    
        ValidateFloat(value);

In Float.c:175:

    }
    
    Float MISRA_PRIV_FloatFromU64(u64 value) {
        Float result = FloatInit();

In Float.c:176:

    
    Float MISRA_PRIV_FloatFromU64(u64 value) {
        Float result = FloatInit();
    
        result.significand = MISRA_PRIV_IntFromU64(value);

In Float.c:183:

    }
    
    Float MISRA_PRIV_FloatFromI64(i64 value) {
        Float result    = FloatInit();
        u64   magnitude = 0;

In Float.c:184:

    
    Float MISRA_PRIV_FloatFromI64(i64 value) {
        Float result    = FloatInit();
        u64   magnitude = 0;

In Float.c:199:

    }
    
    Float MISRA_PRIV_FloatFromInt(Int *value) {
        Float result = FloatInit();

In Float.c:200:

    
    Float MISRA_PRIV_FloatFromInt(Int *value) {
        Float result = FloatInit();
    
        ValidateInt(value);

In Float.c:208:

    }
    
    Float MISRA_PRIV_FloatFromF32(float value) {
        return float_from_f32_value(value);
    }

In Float.c:212:

    }
    
    Float MISRA_PRIV_FloatFromF64(double value) {
        return float_from_f64_value(value);
    }

In Float.c:216:

    }
    
    bool FloatToInt(Int *result, Float *value) {
        Int temp = IntInit();

In Float.c:263:

    }
    
    Float FloatFromStr(const char *text) {
        Float result          = FloatInit();
        Str   digits          = StrInit();

In Float.c:264:

    
    Float FloatFromStr(const char *text) {
        Float result          = FloatInit();
        Str   digits          = StrInit();
        size  pos             = 0;

In Float.c:296:

            if (ch == '.') {
                if (saw_decimal) {
                    LOG_FATAL("Invalid Float format");
                }

In Float.c:309:

                pos++;
                if (text[pos] == '\0') {
                    LOG_FATAL("Invalid Float exponent");
                }

In Float.c:315:

                parsed = strtoll(text + pos, &endptr, 10);
                if (errno == ERANGE || endptr == text + pos || *endptr != '\0') {
                    LOG_FATAL("Invalid Float exponent");
                }

In Float.c:323:

            }
    
            LOG_FATAL("Invalid Float format");
        }

In Float.c:327:

    
        if (!saw_digit) {
            LOG_FATAL("Invalid Float format");
        }

In Float.c:339:

    }
    
    Str FloatToStr(Float *value) {
        Str digits = StrInit();
        Str result = StrInit();

In Float.c:389:

    }
    
    int(FloatCompare)(Float *lhs, Float *rhs) {
        int cmp = 0;

In Float.c:406:

    }
    
    int MISRA_PRIV_FloatCompareInt(Float *lhs, Int *rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromInt(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:407:

    
    int MISRA_PRIV_FloatCompareInt(Float *lhs, Int *rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromInt(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:414:

    }
    
    int MISRA_PRIV_FloatCompareU64(Float *lhs, u64 rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromU64(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:415:

    
    int MISRA_PRIV_FloatCompareU64(Float *lhs, u64 rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromU64(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:422:

    }
    
    int MISRA_PRIV_FloatCompareI64(Float *lhs, i64 rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromI64(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:423:

    
    int MISRA_PRIV_FloatCompareI64(Float *lhs, i64 rhs) {
        Float rhs_value = MISRA_PRIV_FloatFromI64(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:430:

    }
    
    int MISRA_PRIV_FloatCompareF32(Float *lhs, float rhs) {
        Float rhs_value = float_from_f32_value(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:431:

    
    int MISRA_PRIV_FloatCompareF32(Float *lhs, float rhs) {
        Float rhs_value = float_from_f32_value(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:438:

    }
    
    int MISRA_PRIV_FloatCompareF64(Float *lhs, double rhs) {
        Float rhs_value = float_from_f64_value(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:439:

    
    int MISRA_PRIV_FloatCompareF64(Float *lhs, double rhs) {
        Float rhs_value = float_from_f64_value(rhs);
        int   cmp       = FloatCompare(lhs, &rhs_value);

In Float.c:446:

    }
    
    void FloatNegate(Float *value) {
        ValidateFloat(value);

In Float.c:454:

    }
    
    void FloatAbs(Float *value) {
        ValidateFloat(value);
        value->negative = false;

In Float.c:459:

    }
    
    void(FloatAdd)(Float *result, Float *a, Float *b) {
        Float lhs  = FloatClone(a);
        Float rhs  = FloatClone(b);

In Float.c:460:

    
    void(FloatAdd)(Float *result, Float *a, Float *b) {
        Float lhs  = FloatClone(a);
        Float rhs  = FloatClone(b);
        Float temp = FloatInit();

In Float.c:461:

    void(FloatAdd)(Float *result, Float *a, Float *b) {
        Float lhs  = FloatClone(a);
        Float rhs  = FloatClone(b);
        Float temp = FloatInit();
        i64   exp  = 0;

In Float.c:462:

        Float lhs  = FloatClone(a);
        Float rhs  = FloatClone(b);
        Float temp = FloatInit();
        i64   exp  = 0;

In Float.c:498:

    }
    
    void MISRA_PRIV_FloatAddInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);

In Float.c:499:

    
    void MISRA_PRIV_FloatAddInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);
    
        FloatAdd(result, a, &rhs);

In Float.c:505:

    }
    
    void MISRA_PRIV_FloatAddU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);

In Float.c:506:

    
    void MISRA_PRIV_FloatAddU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);
    
        FloatAdd(result, a, &rhs);

In Float.c:512:

    }
    
    void MISRA_PRIV_FloatAddI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);

In Float.c:513:

    
    void MISRA_PRIV_FloatAddI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);
    
        FloatAdd(result, a, &rhs);

In Float.c:519:

    }
    
    void MISRA_PRIV_FloatAddF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);

In Float.c:520:

    
    void MISRA_PRIV_FloatAddF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);
    
        FloatAdd(result, a, &rhs);

In Float.c:526:

    }
    
    void MISRA_PRIV_FloatAddF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);

In Float.c:527:

    
    void MISRA_PRIV_FloatAddF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);
    
        FloatAdd(result, a, &rhs);

In Float.c:533:

    }
    
    void(FloatSub)(Float *result, Float *a, Float *b) {
        Float rhs = FloatClone(b);

In Float.c:534:

    
    void(FloatSub)(Float *result, Float *a, Float *b) {
        Float rhs = FloatClone(b);
    
        ValidateFloat(result);

In Float.c:545:

    }
    
    void MISRA_PRIV_FloatSubInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);

In Float.c:546:

    
    void MISRA_PRIV_FloatSubInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);
    
        FloatSub(result, a, &rhs);

In Float.c:552:

    }
    
    void MISRA_PRIV_FloatSubU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);

In Float.c:553:

    
    void MISRA_PRIV_FloatSubU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);
    
        FloatSub(result, a, &rhs);

In Float.c:559:

    }
    
    void MISRA_PRIV_FloatSubI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);

In Float.c:560:

    
    void MISRA_PRIV_FloatSubI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);
    
        FloatSub(result, a, &rhs);

In Float.c:566:

    }
    
    void MISRA_PRIV_FloatSubF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);

In Float.c:567:

    
    void MISRA_PRIV_FloatSubF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);
    
        FloatSub(result, a, &rhs);

In Float.c:573:

    }
    
    void MISRA_PRIV_FloatSubF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);

In Float.c:574:

    
    void MISRA_PRIV_FloatSubF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);
    
        FloatSub(result, a, &rhs);

In Float.c:580:

    }
    
    void(FloatMul)(Float *result, Float *a, Float *b) {
        Float temp = FloatInit();

In Float.c:581:

    
    void(FloatMul)(Float *result, Float *a, Float *b) {
        Float temp = FloatInit();
    
        ValidateFloat(result);

In Float.c:595:

    }
    
    void MISRA_PRIV_FloatMulInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);

In Float.c:596:

    
    void MISRA_PRIV_FloatMulInt(Float *result, Float *a, Int *b) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);
    
        FloatMul(result, a, &rhs);

In Float.c:602:

    }
    
    void MISRA_PRIV_FloatMulU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);

In Float.c:603:

    
    void MISRA_PRIV_FloatMulU64(Float *result, Float *a, u64 b) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);
    
        FloatMul(result, a, &rhs);

In Float.c:609:

    }
    
    void MISRA_PRIV_FloatMulI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);

In Float.c:610:

    
    void MISRA_PRIV_FloatMulI64(Float *result, Float *a, i64 b) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);
    
        FloatMul(result, a, &rhs);

In Float.c:616:

    }
    
    void MISRA_PRIV_FloatMulF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);

In Float.c:617:

    
    void MISRA_PRIV_FloatMulF32(Float *result, Float *a, float b) {
        Float rhs = float_from_f32_value(b);
    
        FloatMul(result, a, &rhs);

In Float.c:623:

    }
    
    void MISRA_PRIV_FloatMulF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);

In Float.c:624:

    
    void MISRA_PRIV_FloatMulF64(Float *result, Float *a, double b) {
        Float rhs = float_from_f64_value(b);
    
        FloatMul(result, a, &rhs);

In Float.c:630:

    }
    
    void(FloatDiv)(Float *result, Float *a, Float *b, u64 precision) {
        Float temp   = FloatInit();
        Int   scale  = IntInit();

In Float.c:631:

    
    void(FloatDiv)(Float *result, Float *a, Float *b, u64 precision) {
        Float temp   = FloatInit();
        Int   scale  = IntInit();
        Int   scaled = IntInit();

In Float.c:643:

        }
        if (FloatIsZero(a)) {
            Float zero = FloatInit();
            float_replace(result, &zero);
            return;

In Float.c:662:

    }
    
    void MISRA_PRIV_FloatDivInt(Float *result, Float *a, Int *b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);

In Float.c:663:

    
    void MISRA_PRIV_FloatDivInt(Float *result, Float *a, Int *b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromInt(b);
    
        FloatDiv(result, a, &rhs, precision);

In Float.c:669:

    }
    
    void MISRA_PRIV_FloatDivU64(Float *result, Float *a, u64 b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);

In Float.c:670:

    
    void MISRA_PRIV_FloatDivU64(Float *result, Float *a, u64 b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromU64(b);
    
        FloatDiv(result, a, &rhs, precision);

In Float.c:676:

    }
    
    void MISRA_PRIV_FloatDivI64(Float *result, Float *a, i64 b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);

In Float.c:677:

    
    void MISRA_PRIV_FloatDivI64(Float *result, Float *a, i64 b, u64 precision) {
        Float rhs = MISRA_PRIV_FloatFromI64(b);
    
        FloatDiv(result, a, &rhs, precision);

In Float.c:683:

    }
    
    void MISRA_PRIV_FloatDivF32(Float *result, Float *a, float b, u64 precision) {
        Float rhs = float_from_f32_value(b);

In Float.c:684:

    
    void MISRA_PRIV_FloatDivF32(Float *result, Float *a, float b, u64 precision) {
        Float rhs = float_from_f32_value(b);
    
        FloatDiv(result, a, &rhs, precision);

In Float.c:690:

    }
    
    void MISRA_PRIV_FloatDivF64(Float *result, Float *a, double b, u64 precision) {
        Float rhs = float_from_f64_value(b);

In Float.c:691:

    
    void MISRA_PRIV_FloatDivF64(Float *result, Float *a, double b, u64 precision) {
        Float rhs = float_from_f64_value(b);
    
        FloatDiv(result, a, &rhs, precision);

In Float.Math.c:1:

    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Container/Int.h>
    #include <Misra/Std/Log.h>

In Float.Math.c:27:

        WriteFmt("Testing FloatNegate and FloatAbs\n");
    
        Float value = FloatFromStr("12.5");
        Str   text  = StrInit();

In Float.Math.c:48:

        WriteFmt("Testing FloatAdd with small floats\n");
    
        Float a            = FloatFromStr("1.2");
        Float b            = FloatFromStr("0.03");
        Float result_value = FloatInit();

In Float.Math.c:49:

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

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:68:

        WriteFmt("Testing FloatAdd with very large floats\n");
    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b            = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float result_value = FloatInit();

In Float.Math.c:69:

    
        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: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:88:

        WriteFmt("Testing FloatAdd generic dispatch\n");
    
        Float a            = FloatFromStr("1.25");
        Float b            = FloatFromStr("0.75");
        Int   whole        = IntFrom(2);

In Float.Math.c:89:

    
        Float a            = FloatFromStr("1.25");
        Float b            = FloatFromStr("0.75");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();

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:134:

        WriteFmt("Testing FloatSub with small floats\n");
    
        Float a            = FloatFromStr("1.5");
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();

In Float.Math.c:135:

    
        Float a            = FloatFromStr("1.5");
        Float b            = FloatFromStr("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:154:

        WriteFmt("Testing FloatSub with very large floats\n");
    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_THREES);
        Float b            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float result_value = FloatInit();

In Float.Math.c:155:

    
        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: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:174:

        WriteFmt("Testing FloatSub generic dispatch\n");
    
        Float a            = FloatFromStr("5.5");
        Float b            = FloatFromStr("0.5");
        Int   whole        = IntFrom(2);

In Float.Math.c:175:

    
        Float a            = FloatFromStr("5.5");
        Float b            = FloatFromStr("0.5");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();

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:215:

        WriteFmt("Testing FloatMul with small floats\n");
    
        Float a            = FloatFromStr("12.5");
        Float b            = FloatFromStr("-0.2");
        Float result_value = FloatInit();

In Float.Math.c:216:

    
        Float a            = FloatFromStr("12.5");
        Float b            = FloatFromStr("-0.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:235:

        WriteFmt("Testing FloatMul with very large and small floats\n");
    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();

In Float.Math.c:236:

    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b            = FloatFromStr("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:255:

        WriteFmt("Testing FloatMul generic dispatch\n");
    
        Float a            = FloatFromStr("1.5");
        Float b            = FloatFromStr("2");
        Int   whole        = IntFrom(2);

In Float.Math.c:256:

    
        Float a            = FloatFromStr("1.5");
        Float b            = FloatFromStr("2");
        Int   whole        = IntFrom(2);
        Float result_value = FloatInit();

In Float.Math.c:258:

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

In Float.Math.c:296:

        WriteFmt("Testing FloatDiv with small floats\n");
    
        Float a            = FloatFromStr("1");
        Float b            = FloatFromStr("8");
        Float result_value = FloatInit();

In Float.Math.c:297:

    
        Float a            = FloatFromStr("1");
        Float b            = FloatFromStr("8");
        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:316:

        WriteFmt("Testing FloatDiv with very large and small floats\n");
    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float b            = FloatFromStr("2");
        Float result_value = FloatInit();

In Float.Math.c:317:

    
        Float a            = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float b            = FloatFromStr("2");
        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:336:

        WriteFmt("Testing FloatDiv generic dispatch\n");
    
        Float a            = FloatFromStr("7.5");
        Float b            = FloatFromStr("2.5");
        Int   whole        = IntFrom(3);

In Float.Math.c:337:

    
        Float a            = FloatFromStr("7.5");
        Float b            = FloatFromStr("2.5");
        Int   whole        = IntFrom(3);
        Float result_value = FloatInit();

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:382:

        WriteFmt("Testing FloatDiv divide-by-zero handling\n");
    
        Float a = FloatFromStr("1");
        Float b = FloatInit();
        Float r = FloatInit();

In Float.Math.c:383:

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

In Float.Math.c:384:

        Float a = FloatFromStr("1");
        Float b = FloatInit();
        Float r = FloatInit();
    
        FloatDiv(&r, &a, &b, 4);

In Float.Math.c:391:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Math tests\n\n");
    
        TestFunction tests[] = {

In Float.Math.c:416:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Float.Math");
    }

In Io.Read.c:935:

    
    bool test_float_reading(void) {
        WriteFmt("Testing Float reading\n");
    
        const char *z = NULL;

In Io.Read.c:940:

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

In Io.Read.c:941:

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

In Io.Read.c:942:

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

In Float.Compare.c:1:

    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Container/Int.h>
    #include <Misra/Std/Log.h>

In Float.Compare.c:17:

        WriteFmt("Testing FloatCompare with small floats\n");
    
        Float a = FloatFromStr("1.23");
        Float b = FloatFromStr("123e-2");
        Float c = FloatFromStr("-1.23");

In Float.Compare.c:18:

    
        Float a = FloatFromStr("1.23");
        Float b = FloatFromStr("123e-2");
        Float c = FloatFromStr("-1.23");

In Float.Compare.c:19:

        Float a = FloatFromStr("1.23");
        Float b = FloatFromStr("123e-2");
        Float c = FloatFromStr("-1.23");
    
        bool result = FloatCompare(&a, &b) == 0;

In Float.Compare.c:35:

        WriteFmt("Testing FloatCompare with very large floats\n");
    
        Float a = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float c = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);

In Float.Compare.c:36:

    
        Float a = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float c = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);

In Float.Compare.c:37:

        Float a = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float b = FloatFromStr(FLOAT_TEST_VERY_LARGE_TWOS);
        Float c = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
    
        bool result = FloatLT(&a, &b);

In Float.Compare.c:53:

        WriteFmt("Testing FloatCompare with very large and small floats\n");
    
        Float large          = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float negative_large = FloatFromStr("-" FLOAT_TEST_VERY_LARGE_ONES);
        Float small          = FloatFromStr("2.5");

In Float.Compare.c:54:

    
        Float large          = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float negative_large = FloatFromStr("-" FLOAT_TEST_VERY_LARGE_ONES);
        Float small          = FloatFromStr("2.5");

In Float.Compare.c:55:

        Float large          = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Float negative_large = FloatFromStr("-" FLOAT_TEST_VERY_LARGE_ONES);
        Float small          = FloatFromStr("2.5");
    
        bool result = FloatGT(&large, &small);

In Float.Compare.c:68:

    
    bool test_float_compare_wrappers(void) {
        WriteFmt("Testing Float compare macros\n");
    
        Float a        = FloatFromStr("-2");

In Float.Compare.c:70:

        WriteFmt("Testing Float compare macros\n");
    
        Float a        = FloatFromStr("-2");
        Float b        = FloatFromStr("0.5");
        Float expected = FloatFromStr("5e-1");

In Float.Compare.c:71:

    
        Float a        = FloatFromStr("-2");
        Float b        = FloatFromStr("0.5");
        Float expected = FloatFromStr("5e-1");

In Float.Compare.c:72:

        Float a        = FloatFromStr("-2");
        Float b        = FloatFromStr("0.5");
        Float expected = FloatFromStr("5e-1");
    
        bool result = FloatLT(&a, &b);

In Float.Compare.c:90:

        WriteFmt("Testing FloatCompare generic dispatch\n");
    
        Float value = FloatFromStr("12.5");
        Float same  = FloatFromStr("12.5");
        Int   whole = IntFrom(12);

In Float.Compare.c:91:

    
        Float value = FloatFromStr("12.5");
        Float same  = FloatFromStr("12.5");
        Int   whole = IntFrom(12);
        Int   next  = IntFrom(13);

In Float.Compare.c:117:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Compare tests\n\n");
    
        TestFunction tests[] = {

In Float.Compare.c:128:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Compare");
    }

In Io.Write.c:662:

    
    bool test_float_formatting(void) {
        WriteFmt("Testing Float formatting\n");
    
        Str   output  = StrInit();

In Io.Write.c:666:

        Str   output  = StrInit();
        bool  success = true;
        Float exact   = FloatFromStr("1234567890.012345");
        Float sci     = FloatFromStr("12345.67");
        Float short_v = FloatFromStr("1.2");

In Io.Write.c:667:

        bool  success = true;
        Float exact   = FloatFromStr("1234567890.012345");
        Float sci     = FloatFromStr("12345.67");
        Float short_v = FloatFromStr("1.2");

In Io.Write.c:668:

        Float exact   = FloatFromStr("1234567890.012345");
        Float sci     = FloatFromStr("12345.67");
        Float short_v = FloatFromStr("1.2");
    
        StrWriteFmt(&output, "{}", exact);

In Float.Convert.c:1:

    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Container/Int.h>
    #include <Misra/Std/Log.h>

In Float.Convert.c:24:

        WriteFmt("Testing FloatFrom with unsigned integer\n");
    
        Float value = FloatFrom(42);
        Str   text  = FloatToStr(&value);

In Float.Convert.c:38:

        WriteFmt("Testing FloatFrom with signed integer\n");
    
        Float value = FloatFrom(-42);
        Str   text  = FloatToStr(&value);

In Float.Convert.c:53:

    
        Int   integer = IntFromStr("12345678901234567890");
        Float value   = FloatFrom(&integer);
        Str   text    = FloatToStr(&value);

In Float.Convert.c:67:

        WriteFmt("Testing FloatToInt exact conversion\n");
    
        Float value        = FloatFromStr("1234500e-2");
        Int   result_value = IntInit();
        Str   text         = StrInit();

In Float.Convert.c:84:

        WriteFmt("Testing FloatToInt fractional failure handling\n");
    
        Float value        = FloatFromStr("123.45");
        Int   result_value = IntFrom(99);

In Float.Convert.c:98:

        WriteFmt("Testing FloatToInt negative failure handling\n");
    
        Float value        = FloatFromStr("-42");
        Int   result_value = IntFrom(99);

In Float.Convert.c:110:

    
    bool test_float_string_round_trip(void) {
        WriteFmt("Testing Float string round trip\n");
    
        Float value = FloatFromStr("-123.45");

In Float.Convert.c:112:

        WriteFmt("Testing Float string round trip\n");
    
        Float value = FloatFromStr("-123.45");
        Str   text  = FloatToStr(&value);

In Float.Convert.c:123:

    
    bool test_float_very_large_string_round_trip(void) {
        WriteFmt("Testing Float very large string round trip\n");
    
        Float value = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);

In Float.Convert.c:125:

        WriteFmt("Testing Float very large string round trip\n");
    
        Float value = FloatFromStr(FLOAT_TEST_VERY_LARGE_ONES);
        Str   text  = FloatToStr(&value);

In Float.Convert.c:136:

    
    bool test_float_scientific_parse(void) {
        WriteFmt("Testing Float scientific parsing\n");
    
        Float value = FloatFromStr("1.2300e3");

In Float.Convert.c:138:

        WriteFmt("Testing Float scientific parsing\n");
    
        Float value = FloatFromStr("1.2300e3");
        Str   text  = FloatToStr(&value);

In Float.Convert.c:163:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Convert tests\n\n");
    
        TestFunction tests[] = {

In Float.Convert.c:185:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Float.Convert");
    }

In Float.Access.c:1:

    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Log.h>

In Float.Access.c:13:

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

In Float.Access.c:14:

    
        Float zero  = FloatInit();
        Float value = FloatFromStr("0.001");
    
        bool result = FloatIsZero(&zero);

In Float.Access.c:27:

        WriteFmt("Testing FloatIsNegative\n");
    
        Float neg  = FloatFromStr("-42");
        Float pos  = FloatFromStr("42");
        Float zero = FloatFromStr("-0.0");

In Float.Access.c:28:

    
        Float neg  = FloatFromStr("-42");
        Float pos  = FloatFromStr("42");
        Float zero = FloatFromStr("-0.0");

In Float.Access.c:29:

        Float neg  = FloatFromStr("-42");
        Float pos  = FloatFromStr("42");
        Float zero = FloatFromStr("-0.0");
    
        bool result = FloatIsNegative(&neg);

In Float.Access.c:44:

        WriteFmt("Testing FloatExponent\n");
    
        Float value = FloatFromStr("12.34");
    
        bool result = FloatExponent(&value) == -2;

In Float.Access.c:53:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Access tests\n\n");
    
        TestFunction tests[] = {

In Float.Access.c:62:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Access");
    }

In Float.Type.c:1:

    #include <Misra/Std/Container/Float.h>
    #include <Misra/Std/Log.h>
    #include <string.h>

In Float.Type.c:14:

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

In Float.Type.c:27:

        WriteFmt("Testing FloatClear\n");
    
        Float value = FloatFromStr("-123.45");
    
        FloatClear(&value);

In Float.Type.c:42:

        WriteFmt("Testing FloatClone\n");
    
        Float original = FloatFromStr("-12.5");
        Float clone    = FloatClone(&original);
        Float expected = FloatFromStr("-12.5");

In Float.Type.c:43:

    
        Float original = FloatFromStr("-12.5");
        Float clone    = FloatClone(&original);
        Float expected = FloatFromStr("-12.5");
        Str   text     = FloatToStr(&clone);

In Float.Type.c:44:

        Float original = FloatFromStr("-12.5");
        Float clone    = FloatClone(&original);
        Float expected = FloatFromStr("-12.5");
        Str   text     = FloatToStr(&clone);

In Float.Type.c:61:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Type tests\n\n");
    
        TestFunction tests[] = {

In Float.Type.c:70:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Type");
    }

In Io.h:139:

                TypeSpecificIO: (x),                                                                                       \
                Str: TO_TYPE_SPECIFIC_IO(Str, &(x)),                                                                       \
                Float: TO_TYPE_SPECIFIC_IO(Float, &(x)),                                                                   \
                Int: TO_TYPE_SPECIFIC_IO(Int, &(x)),                                                                       \
                BitVec: TO_TYPE_SPECIFIC_IO(BitVec, &(x)),                                                                 \

In Io.h:175:

                TypeSpecificIO: (x),                                                                                       \
                Str: TO_TYPE_SPECIFIC_IO(Str, (void *)&(x)),                                                               \
                Float: TO_TYPE_SPECIFIC_IO(Float, (void *)&(x)),                                                           \
                Int: TO_TYPE_SPECIFIC_IO(Int, (void *)&(x)),                                                               \
                BitVec: TO_TYPE_SPECIFIC_IO(BitVec, (void *)&(x)),                                                         \

In Io.h:545:

    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    void _write_Float(Str *o, FmtInfo *fmt_info, Float *value);
    void _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv);
    void _write_Int(Str *o, FmtInfo *fmt_info, Int *value);

In Io.h:562:

    const char *_read_f32(const char *i, FmtInfo *fmt_info, f32 *v);
    const char *_read_f64(const char *i, FmtInfo *fmt_info, f64 *v);
    const char *_read_Float(const char *i, FmtInfo *fmt_info, Float *value);
    const char *_read_BitVec(const char *i, FmtInfo *fmt_info, BitVec *bv);
    const char *_read_Int(const char *i, FmtInfo *fmt_info, Int *value);

In Container.h:22:

    #include <Misra/Std/Container/BitVec.h>
    #include <Misra/Std/Container/Int.h>
    #include <Misra/Std/Container/Float.h>
    
    #endif // MISRA_STD_CONTAINER_H

In Float.h:10:

    #define MISRA_STD_CONTAINER_FLOAT_H
    
    #include "Float/Type.h"
    #include "Float/Init.h"
    #include "Float/Access.h"

In Float.h:11:

    
    #include "Float/Type.h"
    #include "Float/Init.h"
    #include "Float/Access.h"
    #include "Float/Memory.h"

In Float.h:12:

    #include "Float/Type.h"
    #include "Float/Init.h"
    #include "Float/Access.h"
    #include "Float/Memory.h"
    #include "Float/Convert.h"

In Float.h:13:

    #include "Float/Init.h"
    #include "Float/Access.h"
    #include "Float/Memory.h"
    #include "Float/Convert.h"
    #include "Float/Private.h"

In Float.h:14:

    #include "Float/Access.h"
    #include "Float/Memory.h"
    #include "Float/Convert.h"
    #include "Float/Private.h"
    #include "Float/Compare.h"

In Float.h:15:

    #include "Float/Memory.h"
    #include "Float/Convert.h"
    #include "Float/Private.h"
    #include "Float/Compare.h"
    #include "Float/Math.h"

In Float.h:16:

    #include "Float/Convert.h"
    #include "Float/Private.h"
    #include "Float/Compare.h"
    #include "Float/Math.h"

In Float.h:17:

    #include "Float/Private.h"
    #include "Float/Compare.h"
    #include "Float/Math.h"
    
    #endif // MISRA_STD_CONTAINER_FLOAT_H

In Math.h:28:

    /// TAGS: Float, Math, Negate, Sign
    ///
    void FloatNegate(Float *value);
    ///
    /// Replace a float with its absolute value.

In Math.h:39:

    /// TAGS: Float, Math, AbsoluteValue
    ///
    void FloatAbs(Float *value);
    ///
    /// Add two floats.

In Math.h:52:

    /// TAGS: Float, Math, Add
    ///
    void (FloatAdd)(Float *result, Float *a, Float *b);
    ///
    /// Subtract one float from another.

In Math.h:65:

    /// TAGS: Float, Math, Subtract
    ///
    void (FloatSub)(Float *result, Float *a, Float *b);
    ///
    /// Multiply two floats.

In Math.h:78:

    /// TAGS: Float, Math, Multiply
    ///
    void (FloatMul)(Float *result, Float *a, Float *b);
    ///
    /// Divide one float by another.

In Math.h:95:

    /// TAGS: Float, Math, Divide, Precision
    ///
    void (FloatDiv)(Float *result, Float *a, Float *b, u64 precision);
    #ifndef __cplusplus
    #    define MISRA_FLOAT_ADD_DISPATCH(rhs)                                                                              \

In Math.h:100:

            _Generic(                                                                                                      \
                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatAddValueFloat,                                                                      \
                Float *: FloatAdd,                                                                                         \
                const Float *: MISRA_PRIV_FloatAddConstFloat,                                                              \

In Math.h:101:

                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatAddValueFloat,                                                                      \
                Float *: FloatAdd,                                                                                         \
                const Float *: MISRA_PRIV_FloatAddConstFloat,                                                              \
                Int: MISRA_PRIV_FloatAddValueInt,                                                                          \

In Math.h:102:

                Float: MISRA_PRIV_FloatAddValueFloat,                                                                      \
                Float *: FloatAdd,                                                                                         \
                const Float *: MISRA_PRIV_FloatAddConstFloat,                                                              \
                Int: MISRA_PRIV_FloatAddValueInt,                                                                          \
                Int *: MISRA_PRIV_FloatAddInt,                                                                             \

In Math.h:123:

            _Generic(                                                                                                      \
                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatSubValueFloat,                                                                      \
                Float *: FloatSub,                                                                                         \
                const Float *: MISRA_PRIV_FloatSubConstFloat,                                                              \

In Math.h:124:

                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatSubValueFloat,                                                                      \
                Float *: FloatSub,                                                                                         \
                const Float *: MISRA_PRIV_FloatSubConstFloat,                                                              \
                Int: MISRA_PRIV_FloatSubValueInt,                                                                          \

In Math.h:125:

                Float: MISRA_PRIV_FloatSubValueFloat,                                                                      \
                Float *: FloatSub,                                                                                         \
                const Float *: MISRA_PRIV_FloatSubConstFloat,                                                              \
                Int: MISRA_PRIV_FloatSubValueInt,                                                                          \
                Int *: MISRA_PRIV_FloatSubInt,                                                                             \

In Math.h:146:

            _Generic(                                                                                                      \
                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatMulValueFloat,                                                                      \
                Float *: FloatMul,                                                                                         \
                const Float *: MISRA_PRIV_FloatMulConstFloat,                                                              \

In Math.h:147:

                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatMulValueFloat,                                                                      \
                Float *: FloatMul,                                                                                         \
                const Float *: MISRA_PRIV_FloatMulConstFloat,                                                              \
                Int: MISRA_PRIV_FloatMulValueInt,                                                                          \

In Math.h:148:

                Float: MISRA_PRIV_FloatMulValueFloat,                                                                      \
                Float *: FloatMul,                                                                                         \
                const Float *: MISRA_PRIV_FloatMulConstFloat,                                                              \
                Int: MISRA_PRIV_FloatMulValueInt,                                                                          \
                Int *: MISRA_PRIV_FloatMulInt,                                                                             \

In Math.h:169:

            _Generic(                                                                                                      \
                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatDivValueFloat,                                                                      \
                Float *: FloatDiv,                                                                                         \
                const Float *: MISRA_PRIV_FloatDivConstFloat,                                                              \

In Math.h:170:

                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatDivValueFloat,                                                                      \
                Float *: FloatDiv,                                                                                         \
                const Float *: MISRA_PRIV_FloatDivConstFloat,                                                              \
                Int: MISRA_PRIV_FloatDivValueInt,                                                                          \

In Math.h:171:

                Float: MISRA_PRIV_FloatDivValueFloat,                                                                      \
                Float *: FloatDiv,                                                                                         \
                const Float *: MISRA_PRIV_FloatDivConstFloat,                                                              \
                Int: MISRA_PRIV_FloatDivValueInt,                                                                          \
                Int *: MISRA_PRIV_FloatDivInt,                                                                             \

In Convert.h:66:

    /// TAGS: Float, Convert, Int, Export
    ///
    bool  FloatToInt(Int *result, Float *value);
    ///
    /// Parse a decimal string into a float.

In Convert.h:82:

    /// TAGS: Float, Convert, String, Parse
    ///
    Float FloatFromStr(const char *text);
    ///
    /// Convert a float to a normalized decimal string.

In Convert.h:95:

    /// TAGS: Float, Convert, String, Format
    ///
    Str   FloatToStr(Float *value);
    
    #ifdef __cplusplus

In Compare.h:29:

    /// TAGS: Float, Compare, Ordering
    ///
    int (FloatCompare)(Float *lhs, Float *rhs);
    #ifndef __cplusplus
    #    define MISRA_FLOAT_COMPARE_DISPATCH(rhs)                                                                          \

In Compare.h:34:

            _Generic(                                                                                                      \
                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatCompareValueFloat,                                                                  \
                Float *: FloatCompare,                                                                                     \
                const Float *: MISRA_PRIV_FloatCompareConstFloat,                                                          \

In Compare.h:35:

                (rhs),                                                                                                     \
                Float: MISRA_PRIV_FloatCompareValueFloat,                                                                  \
                Float *: FloatCompare,                                                                                     \
                const Float *: MISRA_PRIV_FloatCompareConstFloat,                                                          \
                Int: MISRA_PRIV_FloatCompareValueInt,                                                                      \

In Compare.h:36:

                Float: MISRA_PRIV_FloatCompareValueFloat,                                                                  \
                Float *: FloatCompare,                                                                                     \
                const Float *: MISRA_PRIV_FloatCompareConstFloat,                                                          \
                Int: MISRA_PRIV_FloatCompareValueInt,                                                                      \
                Int *: MISRA_PRIV_FloatCompareInt,                                                                         \

In Init.h:21:

    /// TAGS: Float, Init, Zero, Construct
    ///
    static inline Float FloatInit(void) {
        Float value;

In Init.h:22:

    ///
    static inline Float FloatInit(void) {
        Float value;
    
        value.negative    = false;

In Init.h:40:

    /// TAGS: Float, Deinit, Destroy, Memory
    ///
    static inline void FloatDeinit(Float *value) {
        ValidateFloat(value);
        IntDeinit(&value->significand);

In Init.h:57:

    /// TAGS: Float, Clear, Zero, Reset
    ///
    static inline void FloatClear(Float *value) {
        ValidateFloat(value);
        IntClear(&value->significand);

In Memory.h:28:

    /// TAGS: Float, Memory, Clone, Copy
    ///
    Float FloatClone(Float *value);
    
    #ifdef __cplusplus

In Access.h:28:

    /// TAGS: Float, Access, Zero, Predicate
    ///
    bool FloatIsZero(Float *value);
    ///
    /// Test whether a floating-point value is negative.

In Access.h:41:

    /// TAGS: Float, Access, Negative, Predicate
    ///
    bool FloatIsNegative(Float *value);
    ///
    /// Read the base-10 exponent of a float.

In Access.h:54:

    /// TAGS: Float, Access, Exponent
    ///
    i64  FloatExponent(Float *value);
    
    #ifdef __cplusplus

In Type.h:30:

        Int  significand;
        i64  exponent;
    } Float;
    
    ///

In Type.h:43:

    /// TAGS: Float, Validate, Safety, Debug
    ///
    static inline void ValidateFloat(const Float *value) {
        ValidateInt(value ? &value->significand : NULL);
    }

Last updated on April 20, 2026

BitVecXor FloatAbs