Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash-preview-04-17· GoogleHugging Face LMArena Human Preference 140K

template<sizet Sign, sizet Mantissa, sizet Exponent, int Bias = Exponent ? (1 <<…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with o3-mini’s answer.
  1. User

    template<size_t Sign, size_t Mantissa, size_t Exponent, int Bias = Exponent ? (1 << (Exponent - 1)) - 1 : 0> requires (Sign + Mantissa + Exponent <= 8 && Sign + Mantissa + Exponent > 0) class f_t : public data_type::interface { public: static constexpr size_t Bits = Sign + Mantissa + Exponent; inline static const std::string Name = [] { return std::string{"f"} + std::to_string(Bits); }(); static constexpr size_t BitSize = Bits;

        struct binary {
            uint8_t s:Sign;
            uint8_t m:Mantissa;
            uint8_t e:Exponent;
        };
        static_assert(sizeof(binary) == 1);
    
        using storage_t = uint8_t;
        using native_t  = float32_t;
        using ptr_t     = ptr_t_<native_t, std::decay_t<f_t<Sign, Mantissa, Exponent>>>;
    
        static native_t load(const storage_t* data, const size_t offset) requires (Bits == 8) {
            binary b = *(binary*)(data + offset);
            return b.m * std::exp2f(b.e - Bias);
        }
    
        static void store(storage_t* data, const size_t offset, const native_t value) requires (Bits == 8) {
            // ???
        }
    
        [[nodiscard]] std::string_view name() const override {
            return Name;
        }
    
        [[nodiscard]] size_t bit_size() const override {
            return BitSize;
        }
    };
    

    }

  2. Gemini Assistant
    #include <cmath>
    #include <cstdint>
    #include <string>
    #include <string_view>
    #include <limits>
    #include <algorithm> // For std::min, std::max, std::round
    #include <type_traits> // For std::decay_t
    
    // Assume data_type::interface and float32_t are defined elsewhere
    // Example placeholders:
    namespace data_type {
        class interface {
        public:
            virtual ~interface() = default;
            [[nodiscard]] virtual std::string_view name() const = 0;
            [[nodiscard]] virtual size_t bit_size() const = 0;
        };
    }
    using float32_t = float; // Assuming float corresponds to float32_t
    
    // Placeholder for ptr_t_ if needed, though not used in load/store static methods
    template<typename T, typename Derived>
    struct ptr_t_ {};
    
    
    namespace custom_types {
    
        // Custom floating-point format based on the provided load function's structure:
        // Value = (sign ? -1 : 1) * Mantissa_value * 2^(Exponent_value - Bias)
        // Mantissa_value is the integer interpretation of the Mantissa bits.
        // Exponent_value is the integer interpretation of the Exponent bits.
        // This is NOT a standard IEEE 754 format.
        //
        // Template parameters:
        //   Sign:     Number of sign bits (0 or 1).
        //   Mantissa: Number of mantissa bits. The integer value represented by these bits.
        //   Exponent: Number of exponent bits. The integer value represented by these bits.
        //   Bias:     The exponent bias. Calculated based on Exponent bits.
        //
        // Constraints:
        //   Sign + Mantissa + Exponent must be exactly 8 bits.
        //   Sign must be 0 or 1.
        //   Total bits must be greater than 0 (handled by base template constraint).
        template<size_t Sign, size_t Mantissa, size_t Exponent, int Bias = Exponent ? (1 << (Exponent - 1)) - 1 : 0>
        requires (Sign + Mantissa + Exponent == 8 && Sign <= 1)
        class f_t : public data_type::interface {
        public:
            static constexpr size_t Bits = Sign + Mantissa + Exponent;
            inline static const std::string Name = [] {
                // Example: f8_1_4_3 (8 bits, 1 sign, 4 mantissa, 3 exponent)
                return std::string{"f"} + std::to_string(Bits) + "_" + std::to_string(Sign) + "_" + std::to_string(Mantissa) + "_" + std::to_string(Exponent);
            }();
            static constexpr size_t BitSize = Bits;
    
            // Representation in memory (bit fields are implementation-defined order,
            // but we will manually construct and extract bytes assuming S (MSB) -> M -> E (LSB)).
            // The struct is mainly for conceptual clarity and the static_assert.
            struct binary {
                // Bit-field order is implementation-defined. Assuming S M E.
                uint8_t s:Sign;
                uint8_t m:Mantissa;
                uint8_t e:Exponent;
            };
            static_assert(sizeof(binary) == 1, "f_t must be exactly 1 byte.");
    
            using storage_t = uint8_t;
            using native_t  = float32_t;
            using ptr_t     = ptr_t_<native_t, std::decay_t<f_t<Sign, Mantissa, Exponent>>>;
    
            // Loads the custom 8-bit float format based on the definition
            // Value = Mantissa_value * 2^(Exponent_value - Bias) * (sign ? -1 : 1)
            // Assumes S M E bit order in the byte.
            static native_t load(const storage_t* data, const size_t offset) requires (Bits == 8) {
                uint8_t byte_val = *(data + offset);
    
                uint8_t s_bits = 0;
                if constexpr (Sign == 1) {
                     // Sign bit is at position Mantissa + Exponent (from LSB)
                     s_bits = (byte_val >> (Mantissa + Exponent)) & 1;
                }
    
                uint8_t m_bits = 0;
                if constexpr (Mantissa > 0) {
                     // Mantissa bits are at position Exponent (from LSB)
                     m_bits = (byte_val >> Exponent) & ((1 << Mantissa) - 1);
                }
    
                uint8_t e_bits = 0;
                if constexpr (Exponent > 0) {
                     // Exponent bits are at position 0 (LSB)
                     e_bits = byte_val & ((1 << Exponent) - 1);
                }
    
                // Handle zero representation (all bits zero)
                if (byte_val == 0x00) { // A common representation for 0.0
                     return 0.0f;
                }
                 // Handle potential NaN pattern (arbitrarily using all bits set)
                if (byte_val == 0xFF) { // Arbitrary choice for NaN
                     return std::numeric_limits<float32_t>::quiet_NaN();
                }
    
    
                // Apply the format's interpretation: Mantissa_value * 2^(Exponent_value - Bias)
                float32_t magnitude = static_cast<float32_t>(m_bits);
                if constexpr (Exponent > 0) {
                     magnitude *= std::exp2f(static_cast<float>(e_bits - Bias));
                } else {
                     // If Exponent is 0, Bias is 0, exp2f(0) is 1.0. This branch is redundant
                     // but makes the logic clearer for Exponent=0 case.
                     // magnitude remains m_bits * 1.0f
                }
    
    
                return (s_bits == 1) ? -magnitude : magnitude;
            }
    
            // Stores a float32_t into the custom 8-bit float format.
            // Finds the best s, m, e bits to approximate the input value using the format:
            // value ≈ (s ? -1 : 1) * m_bits * 2^(e_bits - Bias)
            // Assumes S M E bit order for storage.
            static void store(storage_t* data, const size_t offset, const native_t value) requires (Bits == 8) {
                // Handle zero
                if (value == 0.0f) {
                    *(data + offset) = 0x00; // Assume all bits zero represents 0.0
                    return;
                }
                // Arbitrary choice for NaN representation: all bits set
                if (std::isnan(value)) {
                     *(data + offset) = 0xFF;
                     return;
                }
    
                uint8_t s = 0;
                if constexpr (Sign == 1) {
                    s = (value < 0.0f);
                }
    
                float32_t abs_value = std::fabs(value);
    
                // Special case: Mantissa is 0. Only magnitude 0 is representable (scaled by 2^exp).
                // The format becomes (sign ? -1 : 1) * 0 * 2^(e - Bias) which is always 0 magnitude.
                // If the input value was non-zero, the best representation is signed zero (if Sign=1).
                if constexpr (Mantissa == 0) {
                     uint8_t byte_val = 0;
                     if constexpr (Sign == 1) {
                          // If Mantissa is 0, Sign bit is at position Exponent (from LSB)
                          byte_val |= (static_cast<uint8_t>(s) << Exponent);
                     }
                     // Mantissa and Exponent bits remain 0 in the byte.
                     *(data + offset) = byte_val;
                     return;
                }
    
                // Calculate max representable magnitude for clamping Inf or large values
                const uint8_t max_m = (1 << Mantissa) - 1;
                uint8_t max_e_bits = (1 << Exponent) - 1; // This is 0 if Exponent is 0
                int max_exp = max_e_bits - Bias;
                float32_t max_representable_abs = static_cast<float32_t>(max_m);
                if constexpr (Exponent > 0) {
                     max_representable_abs *= std::exp2f(static_cast<float>(max_exp));
                } // If Exponent=0, scale is 1.0, max abs is just max_m.
    
                // Clamp Inf or values exceeding max representable magnitude
                if (std::isinf(abs_value) || abs_value > max_representable_abs) {
                    uint8_t clamped_e_bits = max_e_bits;
                    uint8_t clamped_m_bits = max_m;
    
                    // Construct the byte with clamped values assuming S M E bit order
                    uint8_t byte_val = 0;
                    if constexpr (Sign == 1) {
                        byte_val |= (static_cast<uint8_t>(s) << (Mantissa + Exponent));
                    }
                    byte_val |= (static_cast<uint8_t>(clamped_m_bits) << Exponent);
                    if constexpr (Exponent > 0) {
                        byte_val |= static_cast<uint8_t>(clamped_e_bits);
                    }
                     *(data + offset) = byte_val;
                     return;
                }
    
                // Find the best m and e combination for finite, non-zero, non-NaN values
                uint8_t best_e_bits = 0;
                uint8_t best_m_bits = 0;
                float32_t min_error = std::numeric_limits<float32_t>::max();
    
                // Iterate through all possible exponent bit values (e_bits)
                // If Exponent is 0, this loop runs once for e_bits = 0
                for (uint8_t e_bits = 0; e_bits < (1 << Exponent); ++e_bits) {
                    int exp = e_bits - Bias;
                    float32_t scale = std::exp2f(static_cast<float>(exp));
    
                    // Calculate the ideal mantissa value for this exponent scale
                    float32_t m_candidate_float = abs_value / scale;
    
                    // Clamp the ideal mantissa to the valid float range [0.0f, static_cast<float>(max_m)]
                    // before rounding, to handle values that would round outside the integer range [0, max_m].
                    float32_t m_clamped_float = m_candidate_float;
                    // Note: m_candidate_float is >= 0 since abs_value >= 0 and scale > 0
                    if (m_clamped_float > static_cast<float32_t>(max_m)) {
                         m_clamped_float = static_cast<float32_t>(max_m);
                    }
                    // Ensure it's not negative due to precision issues near zero, though unlikely with abs_value
                    if (m_clamped_float < 0.0f && abs_value > 0.0f) {
                        // This indicates a potential issue with scale or value being extremely small,
                        // leading to division by very small scale resulting in large float
                        // which might then lose precision near 0 after large number operations.
                        // Clamping to 0.0f is safer.
                        m_clamped_float = 0.0f;
                    }
    
    
                    // Round the clamped float mantissa to the nearest integer mantissa bit value
                    uint8_t m_rounded_clamped = static_cast<uint8_t>(std::round(m_clamped_float));
    
                    // Double-check clamping after rounding - mainly for safety though should be within [0, max_m] now
                     m_rounded_clamped = std::min(m_rounded_clamped, max_m);
                     m_rounded_clamped = std::max(m_rounded_clamped, static_cast<uint8_t>(0));
    
    
                    // The represented value for this (e, m) pair
                    float32_t represented_value = static_cast<float32_t>(m_rounded_clamped) * scale;
    
                    // Calculate the error (difference between original value and represented value magnitude)
                    float32_t current_error = std::fabs(abs_value - represented_value);
    
                    // Update best values if this representation has a smaller error
                    // Uses < for comparison. If errors are equal, the first valid (e.g., smallest e_bits) is chosen.
                    // min_error starts as max(), so the first representation found will be selected initially.
                    if (current_error < min_error) {
                        min_error = current_error;
                        best_e_bits = e_bits;
                        best_m_bits = m_rounded_clamped;
                    }
                }
    
                // Construct the final byte from sign (s), best mantissa bits (best_m_bits),
                // and best exponent bits (best_e_bits).
                // Assumes S (MSB), M, E (LSB) bit order in the byte.
                uint8_t byte_val = 0;
                if constexpr (Sign == 1) {
                     byte_val |= (static_cast<uint8_t>(s) << (Mantissa + Exponent));
                }
                if constexpr (Mantissa > 0) {
                     byte_val |= (static_cast<uint8_t>(best_m_bits) << Exponent);
                }
                if constexpr (Exponent > 0) {
                     byte_val |= static_cast<uint8_t>(best_e_bits);
                }
    
                // Store the resulting byte
                *(data + offset) = byte_val;
            }
    
    
            [[nodiscard]] std::string_view name() const override {
                return Name;
            }
    
            [[nodiscard]] size_t bit_size() const override {
                return BitSize;
            }
        };
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.

Identical first prompt