Merge branch 'main' of github.com:OperatorFoundation/CodexKotlin

Author: Dr. Brandon Wiley

Codex/src/main/java/org/operatorfoundation/codex/Decoder.kt

@@ -55,14 +55,10 @@ class Decoder(private val symbols: List<Symbol>)
         if (symbol.size() == 1)
         {
             // Symbols with size 1 don't contribute to the numeric value
-            println("decode_step(encoded value: ${encodedValue.decodeToString()}, symbol: $symbol, index: $index)")
-
             return 0.toBigInteger()
         }
         else
         {
-            println("decode_step(encoded value: ${encodedValue.decodeToString()}, symbol: $symbol, index: $index)")
-
             if (index == symbols.size - 1)
             {
                 // Last symbol: just return its decoded value
@@ -73,13 +69,11 @@ class Decoder(private val symbols: List<Symbol>)
                 // Calculate product of remaining symbol sizes
                 val remainingSymbols = symbols.subList(index + 1, symbols.size)
                 val remainingSymbolSizes = remainingSymbols.map { it.size() }
-                val positionMultiplier = remainingSymbolSizes.fold(1) { acc, size -> acc * size }
-
-                println("history:/n  remaining symbol sizes - $remainingSymbolSizes, position multiplier: $positionMultiplier")
+                // Use BigInteger to avoid integer overflow when multiplying symbol sizes
+                val positionMultiplier = remainingSymbolSizes.fold(BigInteger.ONE) { acc, size -> acc * size.toBigInteger() }
 
                 // Multiply decoded value by position weight
-                val result = symbol.decode(encodedValue) * positionMultiplier.toBigInteger()
-                println("result: $result")
+                val result = symbol.decode(encodedValue) * positionMultiplier
 
                 return result
             }

Codex/src/main/java/org/operatorfoundation/codex/Encoder.kt

@@ -60,8 +60,6 @@ class Encoder(private val symbols: List<Symbol>)
         if (symbol.size() == 1)
         {
             // (size = 1) don't consume any of the value
-            println("encode_step( current value: $currentValue, symbol: $symbol, index: $index)")
-
             // For debugging: show symbol capacity up to this point
             val symbolsUpToHere = if (index == 0)
             {
@@ -71,56 +69,40 @@ class Encoder(private val symbols: List<Symbol>)
             {
                 symbols.subList(0, symbols.size - index)
             }
-            
-            val symbolSizes = symbolsUpToHere.map { it.size() }
-            val totalCapacity = symbolSizes.fold(1) { acc, size -> acc * size }
-
-            println("history (symbol sizes): $symbolSizes, total capacity: $totalCapacity")
 
             // Symbol with size 1 encodes its fixed value and passes through the current value
             val encodedBytes = symbol.encode(currentValue)
             val result = Pair(encodedBytes, currentValue)
 
-            println("result: (${encodedBytes.decodeToString()}, $currentValue)")
-
             return result
         }
         else
         {
-            println("encode_step(currrent value: $currentValue, symbol: $symbol, index: $index)")
-
             if (index == symbols.size - 1)
             {
                 // Last symbol: encode all remaining value
                 val encodedBytes = symbol.encode(currentValue)
                 val result = Pair(encodedBytes, 0.toBigInteger())
 
-                println("result: (${encodedBytes.decodeToString()}, 0)")
-
                 return result
             }
             else
             {
                 // Calculate capacity of remaining symbols
                 val remainingSymbols = symbols.subList(index + 1, symbols.size)
                 val remainingSymbolSizes = remainingSymbols.map { it.size() }
-                val remainingCapacity = remainingSymbolSizes.fold(1) { acc, size -> acc * size }
-
-                println("history:\n   remaining symbol sizes $remainingSymbolSizes, remaining capacity: $remainingCapacity")
+                val remainingCapacity = remainingSymbolSizes.fold(BigInteger.ONE) { acc, size -> acc * size.toBigInteger() }
 
                 // Determine value for this symbol position
                 // Division gives us how many "chunks" of remaining capacity we have
-                val symbolValue = (currentValue / remainingCapacity.toBigInteger()).min(symbol.size().toBigInteger() - 1.toBigInteger())
-                println("Symbol value: $symbolValue")
+                val symbolValue = (currentValue / remainingCapacity).min(symbol.size().toBigInteger() - BigInteger.ONE)
 
                 // Modulo gives us what's left for the remaining symbols
-                val leftoverValue = currentValue % remainingCapacity.toBigInteger()
-                println("Leftover value: $leftoverValue")
+                val leftoverValue = currentValue % remainingCapacity
 
                 // Encode this symbol's portion
                 val encodedBytes = symbol.encode(symbolValue)
                 val result = Pair(encodedBytes, leftoverValue)
-                println("result: (${encodedBytes.decodeToString()}, $leftoverValue)")
 
                 return result
             }