Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Hamming Error Correction With Kotlin (Part 2)

DZone's Guide to

Hamming Error Correction With Kotlin (Part 2)

Diving more deeply into Hamming(7,4) encoding, we tackle error detection and correction, off-by-one-error workouts, and the challeges of the (7,4) method.

· Java Zone ·
Free Resource

Download Microservices for Java Developers: A hands-on introduction to frameworks and containers. Brought to you in partnership with Red Hat.

In this article, we continue where we left off and focus solely on error detection for Hamming code.

Error Correction

Utilizing Hamming(7,4) encoding allows us to detect double-bit errors and even correct single-bit ones!

During the encoding, we only add parity bits, so the happy path decoding scenario involves stripping the message of the parity bits, which reside at known indexes (1,2,4…n, 2n):

fun stripHammingMetadata(input: EncodedString): BinaryString {
    return input.value.asSequence()
        .filterIndexed {
            i,
            _ - > (i + 1).isPowerOfTwo().not()
        }
        .joinToString("")
        .let(::BinaryString)
}


This is rarely the case because, since we made effort to calculate parity bits, we want to leverage them first.

The codeword validation is quite intuitive if you already understand the encoding process. We simply need to recalculate all parity bits and do the parity check (check if those values match what’s in the message):

private fun indexesOfInvalidParityBits(input: EncodedString): List < Int > {
    fun toValidationResult(it: Int, input: EncodedString): Pair < Int,
    Boolean > =
    helper.parityIndicesSequence(it - 1, input.length)
    .map {
        v - > input[v].toBinaryInt()
    }
    .fold(input[it - 1].toBinaryInt()) {
        a,
        b - > a xor b
    }
    .let {
        r - > it to(r == 0)
    }

    return generateSequence(1) {
            it * 2
        }
        .takeWhile {
            it < input.length
        }
        .map {
            toValidationResult(it, input)
        }
        .filter {
            !it.second
        }
        .map {
            it.first
        }
        .toList()
}


If they all match, then the codeword does not contain any errors:

override fun isValid(codeWord: EncodedString) =
    indexesOfInvalidParityBits(input).isEmpty()


Now, when we already know the message was transmitted incorrectly, we can request the sender to retransmit the message… or try to correct it ourselves.

Finding the distorted bit is as easy as summing the indexes of invalid parity bits – the result is the index of the faulty one. In order to correct the message, we can simply flip the bit:

override fun decode(codeWord: EncodedString): BinaryString =
    indexesOfInvalidParityBits(codeWord).let {
        result - >
            when(result.isEmpty()) {
                true - > codeWord
                false - > codeWord.withBitFlippedAt(result.sum() - 1)
            }.let {
                extractor.stripHammingMetadata(it)
            }
    }


We flip the bit using an extension:

private fun EncodedString.withBitFlippedAt(index: Int) = this[index].toString().toInt()
    .let {
        this.value.replaceRange(index, index + 1, ((it + 1) % 2).toString())
    }
    .let(::EncodedString)


We can see that it works by writing a homemade property test:

@Test
fun shouldEncodeAndDecodeWithSingleBitErrors() = repeat(10000) {
    randomMessage().let {
        assertThat(it).isEqualTo(decoder.decode(encoder.encode(it)
            .withBitFlippedAt(rand.nextInt(it.length))))
    }
}


Unfortunately, Hamming (7,4) does not distinguish between codewords containing one or two distorted bits. If you try to correct the two-bit error, the result will be incorrect.

Disappointing, right? This is what drove the decision to make use of an additional parity bit and create the Hamming (8,4).

Conclusion

We’ve seen how the error correction for Hamming codes look like and went through the extensive off-by-one-error workout.

Code snippets can be found on GitHub.

Download Building Reactive Microservices in Java: Asynchronous and Event-Based Application Design. Brought to you in partnership with Red Hat

Topics:
java ,kotlin ,hamming ,error correction ,tutorial

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}