WSPR Test + String Decode Bug Fix

Author: consuelita

.gitignore

@@ -15,3 +15,4 @@
 local.properties
 /.idea
 /.kotlin/errors
+*.log

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

@@ -55,13 +55,13 @@ 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(${encodedValue.decodeToString()}, $symbol, $index)")
+            println("decode_step(encoded value: ${encodedValue.decodeToString()}, symbol: $symbol, index: $index)")
 
             return 0.toBigInteger()
         }
         else
         {
-            println("decode_step(${encodedValue.decodeToString()}, $symbol, $index)")
+            println("decode_step(encoded value: ${encodedValue.decodeToString()}, symbol: $symbol, index: $index)")
 
             if (index == symbols.size - 1)
             {
@@ -75,7 +75,7 @@ class Decoder(private val symbols: List<Symbol>)
                 val remainingSymbolSizes = remainingSymbols.map { it.size() }
                 val positionMultiplier = remainingSymbolSizes.fold(1) { acc, size -> acc * size }
 
-                println("history: $remainingSymbolSizes, p: $positionMultiplier")
+                println("history:/n  remaining symbol sizes - $remainingSymbolSizes, position multiplier: $positionMultiplier")
 
                 // Multiply decoded value by position weight
                 val result = symbol.decode(encodedValue) * positionMultiplier.toBigInteger()

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

@@ -59,8 +59,8 @@ class Encoder(private val symbols: List<Symbol>)
     {
         if (symbol.size() == 1)
         {
-            // Fixed symbols (size = 1) don't consume any of the value
-            println("encode_step($currentValue, $symbol, $index)")
+            // (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)
@@ -75,24 +75,26 @@ class Encoder(private val symbols: List<Symbol>)
             val symbolSizes = symbolsUpToHere.map { it.size() }
             val totalCapacity = symbolSizes.fold(1) { acc, size -> acc * size }
 
-            println("history: $symbolSizes, p: $totalCapacity")
+            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($currentValue, $symbol, $index)")
+            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
@@ -104,16 +106,16 @@ class Encoder(private val symbols: List<Symbol>)
                 val remainingSymbolSizes = remainingSymbols.map { it.size() }
                 val remainingCapacity = remainingSymbolSizes.fold(1) { acc, size -> acc * size }
 
-                println("history: $remainingSymbolSizes, p: $remainingCapacity")
+                println("history:\n   remaining symbol sizes $remainingSymbolSizes, remaining capacity: $remainingCapacity")
 
                 // 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("n: $symbolValue")
+                println("Symbol value: $symbolValue")
 
                 // Modulo gives us what's left for the remaining symbols
                 val leftoverValue = currentValue % remainingCapacity.toBigInteger()
-                println("m: $leftoverValue")
+                println("Leftover value: $leftoverValue")
 
                 // Encode this symbol's portion
                 val encodedBytes = symbol.encode(symbolValue)

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallLetterNumber.kt

@@ -26,7 +26,7 @@ class CallLetterNumber : Symbol {
     override fun toString(): String = "CallLetterNumber"
 
     override fun decode(encodedValue: ByteArray): BigInteger {
-        return charToValue[encodedValue.toString()]
+        return charToValue[encodedValue.decodeToString()]
             ?: throw IllegalArgumentException("CallLetterNumber, bad value: $encodedValue")
     }
 

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallLetterSpace.kt

@@ -23,7 +23,7 @@ class CallLetterSpace : Symbol {
     override fun toString(): String = "CallLetterSpace"
 
     override fun decode(encodedValue: ByteArray): BigInteger {
-        return charToValue[encodedValue.toString()]
+        return charToValue[encodedValue.decodeToString()]
             ?: throw IllegalArgumentException("CallLetterSpace, bad value: $encodedValue")
     }
 

Codex/src/main/java/org/operatorfoundation/codex/symbols/GridLetter.kt

@@ -7,7 +7,9 @@ class GridLetter : Symbol {
             "A" to 0.toBigInteger(), "B" to 1.toBigInteger(), "C" to 2.toBigInteger(),
             "D" to 3.toBigInteger(), "E" to 4.toBigInteger(), "F" to 5.toBigInteger(),
             "G" to 6.toBigInteger(), "H" to 7.toBigInteger(), "I" to 8.toBigInteger(),
-            "J" to 9.toBigInteger(), "K" to 10.toBigInteger()
+            "J" to 9.toBigInteger(), "K" to 10.toBigInteger(), "L" to 11.toBigInteger(),
+            "M" to 12.toBigInteger(), "N" to 13.toBigInteger(), "O" to 14.toBigInteger(),
+            "P" to 15.toBigInteger(), "Q" to 16.toBigInteger(), "R" to 17.toBigInteger()
         )
 
         private val valueToChar = (0..17).associate {
@@ -20,7 +22,7 @@ class GridLetter : Symbol {
     override fun toString(): String = "GridLetter"
 
     override fun decode(encodedValue: ByteArray): BigInteger {
-        return charToValue[encodedValue.toString()]
+        return charToValue[encodedValue.decodeToString()]
             ?: throw IllegalArgumentException("GridLetter, bad value $encodedValue")
     }
 

Codex/src/main/java/org/operatorfoundation/codex/symbols/Number.kt

@@ -18,7 +18,7 @@ class Number : Symbol {
     override fun toString(): String = "Number"
 
     override fun decode(encodedValue: ByteArray): BigInteger {
-        return charToValue[encodedValue.toString()]
+        return charToValue[encodedValue.decodeToString()]
             ?: throw IllegalArgumentException("Number, bad value: $encodedValue")
     }
 

Codex/src/main/java/org/operatorfoundation/codex/symbols/Power.kt

@@ -21,7 +21,7 @@ class Power : Symbol {
     override fun toString(): String = "Power"
 
     override fun decode(encodedValue: ByteArray): BigInteger {
-        return charToValue[encodedValue.toString()]
+        return charToValue[encodedValue.decodeToString()]
             ?: throw IllegalArgumentException("Power, bad value $encodedValue")
     }
 

Codex/src/test/java/org/operatorfoundation/codex/EncoderDecoderTest.kt

@@ -77,7 +77,7 @@ class EncoderDecoderTest
         val grid = wsprEncoding.subList(6, 10).joinToString("") { it.decodeToString() }
         val power = wsprEncoding[10].decodeToString()
 
-        println("$callsign $grid $power")
+        println("WSPR Message: $callsign $grid $power")
 
         // Verify decoding back to same integer
         val wsprDecoder = wsprEncoder.decoder()