⚡ Bolt: Optimize linearized color component conversion using Lookup Table

.jules/bolt.md

@@ -1,3 +1,7 @@
 ## 2024-07-14 - Optimize Hex Color Parsing and Formatting in KMP Hot Paths
 **Learning:** In Kotlin Multiplatform hot paths (such as hex color serialization and parsing), manual character array manipulation and bitwise shifts are substantially faster (up to 25x faster for serialization and 10x faster for parsing) than using standard library string methods like `toString(16).padStart()`, `uppercase()`, or `substring().toLong(16).toInt()`. This approach avoids platform-specific string allocation overhead.
 **Action:** When working in KMP hot paths, avoid standard library string manipulations that instantiate multiple objects per call. Favor `CharArray`, manual index iteration, bitwise shifts, and `concatToString()` to minimize allocations and latency.
+
+## 2024-07-26 - Optimize linearized color component conversion using Lookup Table
+**Learning:** In Kotlin Multiplatform, when mathematical operations depend strictly on a small, discrete domain (e.g., converting 8-bit color components 0-255 from sRGB to linear space), utilizing pre-computed arrays or lookup tables (like `DoubleArray(256)`) instead of redundant on-the-fly computation (divisions, conditionals, `.pow()`) significantly improves performance in hot paths like HCT or XYZ conversions.
+**Action:** Identify mathematical hot paths that operate on small discrete inputs, like 8-bit color components, and implement lookup tables to cache values instead of recomputing them dynamically.

halogen-core/src/commonMain/kotlin/halogen/color/ColorUtils.kt

@@ -85,15 +85,17 @@ internal object ColorUtils {
         return 116.0 * labF(y / 100.0) - 16.0
     }
 
-    fun linearized(rgbComponent: Int): Double {
+    private val LINEARIZED_LUT = DoubleArray(256) { rgbComponent ->
         val normalized = rgbComponent / 255.0
-        return if (normalized <= 0.040449936) {
+        if (normalized <= 0.040449936) {
             normalized / 12.92 * 100.0
         } else {
             ((normalized + 0.055) / 1.055).pow(2.4) * 100.0
         }
     }
 
+    fun linearized(rgbComponent: Int): Double = LINEARIZED_LUT[rgbComponent]
+
     fun delinearized(rgbComponent: Double): Int {
         val normalized = rgbComponent / 100.0
         val delinearized: Double = if (normalized <= 0.0031308) {