classify_array()

ArrayType fl::anonymous_namespace{json.cpp.hpp}::classify_array

(

const json_array &

arr

)

Definition at line 672 of file json.cpp.hpp.

                                                             {
    if (arr.empty()) return GENERIC_ARRAY;
 
    bool all_numeric = true;
    i64 min_val = fl::numeric_limits<i64>::max();
    i64 max_val = fl::numeric_limits<i64>::min();
    bool has_float = false;
    bool has_float_beyond_precision = false;
 
    for (const auto& elem : arr) {
        if (!elem) {
            all_numeric = false;
            break;
        }
 
        if (elem->is_int()) {
            auto val = elem->as_int();
            if (val) {
                i64 v = *val;
                min_val = (v < min_val) ? v : min_val;
                max_val = (v > max_val) ? v : max_val;
            } else {
                all_numeric = false;
                break;
            }
        } else if (elem->is_float()) {
            has_float = true;
            auto val = elem->as_float();
            if (!val) {
                all_numeric = false;
                break;
            }
            // Check if float is beyond integer precision (>2^24 or <-2^24).
            // Integer biased-exp comparison -- no FP arithmetic (#3022 phase 2).
            const u32 fbits = fl::bit_cast<u32>(*val);
            if (float_bits_magnitude_exceeds_2_24(fbits)) {
                has_float_beyond_precision = true;
            }
        } else {
            all_numeric = false;
            break;
        }
    }
 
    if (!all_numeric) return GENERIC_ARRAY;
 
    // Classification
    if (has_float) {
        // If floats are beyond integer precision, don't optimize
        if (has_float_beyond_precision) {
            return GENERIC_ARRAY;
        }
        return ALL_FLOATS;
    }
 
    // Integer arrays
    if (min_val >= 0 && max_val <= 255) {
        return ALL_UINT8;
    }
 
    if (min_val >= -32768 && max_val <= 32767) {
        return ALL_INT16;
    }
 
    // Large integers (>32767 or <-32768) that don't fit in int16 but can be represented as float
    // Convert to float if within float's integer precision range (+/-2^24)
    if (min_val >= -16777216 && max_val <= 16777216) {
        return ALL_FLOATS;
    }
 
    return GENERIC_ARRAY;
}

References ALL_FLOATS, ALL_INT16, ALL_UINT8, fl::bit_cast(), classify_array(), fl::FL_NO_EXCEPT, fl::float_bits_magnitude_exceeds_2_24(), GENERIC_ARRAY, fl::numeric_limits< T >::max(), and fl::numeric_limits< T >::min().

Referenced by classify_array(), and optimize_array().

Here is the call graph for this function:

Here is the caller graph for this function: