> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Float A `Float` in Kotlin is a basic type representing a single-precision 32-bit IEEE 754 floating-point number. At the language level, all types in Kotlin are objects (classes), but the compiler optimizes `Float` to a JVM primitive (`float`) whenever possible to eliminate memory overhead. It allocates 4 bytes of memory and provides a precision of 6 to 7 significant decimal digits. ## Technical Specifications * **Bit Width:** 32 bits * **Maximum Value:** `3.4028235E38` (`Float.MAX_VALUE`) * **Minimum Value:** `-3.4028235E38` (`-Float.MAX_VALUE`) * **Smallest Positive Non-Zero Value:** `1.4E-45` (`Float.MIN_VALUE`) * **Default Type Inference:** By default, Kotlin infers fractional literals as `Double`. To explicitly define a `Float`, a suffix is required. ## Syntax and Instantiation To declare a `Float` literal, you must append the `f` or `F` suffix to the numeric value. Without this suffix, the compiler treats the literal as a 64-bit `Double`, which results in a type mismatch error if explicitly typed as `Float`. ```kotlin theme={"dark"} // Explicit type declaration with suffix val pi: Float = 3.14159f // Inferred type using suffix val gravity = 9.81F // Scientific notation val planckLength = 1.616e-35f // Compilation Error: The literal is a Double, but the variable expects a Float // val invalidFloat: Float = 3.14 ``` ## Type Conversion Kotlin enforces strict type safety and does not support implicit widening conversions. You cannot assign an `Int`, `Long`, or `Double` directly to a `Float` variable. Explicit conversion functions must be invoked. ```kotlin theme={"dark"} val integerValue: Int = 42 val doubleValue: Double = 3.1415926535 // Explicit conversions val fromInt: Float = integerValue.toFloat() val fromDouble: Float = doubleValue.toFloat() // Precision loss occurs here ``` ## Memory Representation and Boxing On the JVM, Kotlin represents a `Float` as a primitive `float` when the variable is non-nullable and not used within a generic context. If the `Float` is declared as nullable (`Float?`) or used inside a generic type (such as `List`), the compiler boxes the value into a `java.lang.Float` object. ```kotlin theme={"dark"} val primitive: Float = 1.5f // Compiled to JVM primitive 'float' val boxed: Float? = 1.5f // Compiled to JVM object 'java.lang.Float' val generic: List = listOf(1.5f) // Boxed inside the collection ``` ## Special IEEE 754 Values Kotlin's `Float` implementation fully supports standard IEEE 754 special values for handling arithmetic edge cases: ```kotlin theme={"dark"} val positiveInfinity: Float = Float.POSITIVE_INFINITY // e.g., 1.0f / 0.0f val negativeInfinity: Float = Float.NEGATIVE_INFINITY // e.g., -1.0f / 0.0f val notANumber: Float = Float.NaN // e.g., 0.0f / 0.0f ``` ## Equality and Comparison Kotlin evaluates floating-point equality differently depending on the static type of the operands. When operands are statically typed as `Float` or `Float?`, the `==` operator compiles to a primitive IEEE 754 comparison (with a null check for `Float?`). Under IEEE 754 rules, `NaN` is never equal to itself, and `0.0f` is equal to `-0.0f`. When operands are statically typed as `Any`, `Comparable`, a generic type parameter, or when explicitly invoking the `.equals()` method, Kotlin applies **total ordering** behavior. Under total ordering, `NaN` is considered equal to itself and greater than any other value, while `0.0f` is considered strictly greater than `-0.0f`. ```kotlin theme={"dark"} val a: Float = Float.NaN val b: Float = Float.NaN // IEEE 754 comparison applies to Float println(a == b) // false // IEEE 754 comparison still applies to Float? val nullableA: Float? = Float.NaN val nullableB: Float? = Float.NaN println(nullableA == nullableB) // false // Total ordering applies when statically typed as Any val anyA: Any = Float.NaN val anyB: Any = Float.NaN println(anyA == anyB) // true // Total ordering applies when explicitly calling equals() println(a.equals(b)) // true ```

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More