hamming_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hamming Code Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert alphabet to codeword (binary)\n",
    "def gen_codeword(alphabet):\n",
    "    ascii = ord(alphabet) # Get an ASCII value of an alphabet\n",
    "    binary = bin(ascii)[2:] # Generate binary value out of ascii variable and remove the first 2 bits\n",
    "    return binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate Hamming Code\n",
    "def Hamming_gen(input_alphabet):\n",
    "    dataword = gen_codeword(input_alphabet) # Generate a binary value of an ASCII value of an alphabet\n",
    "    \n",
    "    r1 = str(int(dataword[0]) ^ int(dataword[2]) ^ int(dataword[3]) ^ int(dataword[5]) ^ int(dataword[6])) # Generate redundant bit 1\n",
    "    r2 = str(int(dataword[0]) ^ int(dataword[1]) ^ int(dataword[3]) ^ int(dataword[4]) ^ int(dataword[6])) # Generate redundant bit 2\n",
    "    r4 = str(int(dataword[3]) ^ int(dataword[4]) ^ int(dataword[5])) # Generate redundant bit 4\n",
    "    r8 = str(int(dataword[0]) ^ int(dataword[1]) ^ int(dataword[2])) # Generate redundant bit 8\n",
    "\n",
    "    redundancy = r8+r4+r2+r1 # Combine each redundant bit to create a parity bit\n",
    "    codeword = dataword[:3] + r8 + dataword[3:6] + r4 + dataword[6] + r2 + r1 # Generate a Hamming code\n",
    "\n",
    "    print(\"Hamming Code Generator\")\n",
    "    print(\"Input Alphabet: \" + input_alphabet)\n",
    "    print(\"Alphabet to Binary: \" + dataword)\n",
    "    print(\"Redundancy Bits: \" + redundancy)\n",
    "    print(\"Hamming Code Codeword: \" + codeword + \"\\n\")\n",
    "    \n",
    "    return codeword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hamming Code Checker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hamming Code Checker\n",
    "def Hamming_check(codeword):\n",
    "    \n",
    "    s1 = str(int(codeword[0]) ^ int(codeword[2]) ^ int(codeword[4]) ^ int(codeword[6]) ^ int(codeword[8]) ^ int(codeword[10])) # Generate new redundant bit 1 \n",
    "    s2 = str(int(codeword[0]) ^ int(codeword[1]) ^ int(codeword[4]) ^ int(codeword[5]) ^ int(codeword[8]) ^ int(codeword[9])) # Generate new redundant bit 2\n",
    "    s3 = str(int(codeword[4]) ^ int(codeword[5]) ^ int(codeword[6]) ^ int(codeword[7])) # Generate new redundant bit 4\n",
    "    s4 = str(int(codeword[0]) ^ int(codeword[1]) ^ int(codeword[2]) ^ int(codeword[3])) # Generate new redundant bit 8\n",
    "\n",
    "    error_pos = s4 + s3 + s2 + s1 # The location of an error bit in binary\n",
    "    error_pos = int(error_pos,2) # The location of an error bit in decimal\n",
    "\n",
    "    print(\"Hamming Code Checker\")\n",
    "    print(\"Received Codeword: \" + codeword)\n",
    "\n",
    "    if error_pos == 0: # If the location of an error is 0, then there is no error\n",
    "        print(\"No Error Found\")\n",
    "        return error_pos\n",
    "    else: # Identify the error location of the received codeword\n",
    "        print(\"Error Position at \" + str(error_pos))\n",
    "        return error_pos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hamming Code Generator and Checker Test Cases\n",
      "\n",
      "Test Case: 1\n",
      "Hamming Code Generator\n",
      "Input Alphabet: a\n",
      "Alphabet to Binary: 1100001\n",
      "Redundancy Bits: 0010\n",
      "Hamming Code Codeword: 11000000110\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000000110\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 2\n",
      "Hamming Code Generator\n",
      "Input Alphabet: b\n",
      "Alphabet to Binary: 1100010\n",
      "Redundancy Bits: 0100\n",
      "Hamming Code Codeword: 11000011000\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000011000\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 3\n",
      "Hamming Code Generator\n",
      "Input Alphabet: c\n",
      "Alphabet to Binary: 1100011\n",
      "Redundancy Bits: 0111\n",
      "Hamming Code Codeword: 11000011111\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000011111\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 4\n",
      "Hamming Code Generator\n",
      "Input Alphabet: d\n",
      "Alphabet to Binary: 1100100\n",
      "Redundancy Bits: 0111\n",
      "Hamming Code Codeword: 11000101011\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000101011\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 5\n",
      "Hamming Code Generator\n",
      "Input Alphabet: e\n",
      "Alphabet to Binary: 1100101\n",
      "Redundancy Bits: 0100\n",
      "Hamming Code Codeword: 11000101100\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000101100\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 6\n",
      "Hamming Code Generator\n",
      "Input Alphabet: f\n",
      "Alphabet to Binary: 1100110\n",
      "Redundancy Bits: 0010\n",
      "Hamming Code Codeword: 11000110010\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000110010\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 7\n",
      "Hamming Code Generator\n",
      "Input Alphabet: g\n",
      "Alphabet to Binary: 1100111\n",
      "Redundancy Bits: 0001\n",
      "Hamming Code Codeword: 11000110101\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11000110101\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 8\n",
      "Hamming Code Generator\n",
      "Input Alphabet: h\n",
      "Alphabet to Binary: 1101000\n",
      "Redundancy Bits: 0110\n",
      "Hamming Code Codeword: 11001001010\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001001010\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 9\n",
      "Hamming Code Generator\n",
      "Input Alphabet: i\n",
      "Alphabet to Binary: 1101001\n",
      "Redundancy Bits: 0101\n",
      "Hamming Code Codeword: 11001001101\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001001101\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 10\n",
      "Hamming Code Generator\n",
      "Input Alphabet: j\n",
      "Alphabet to Binary: 1101010\n",
      "Redundancy Bits: 0011\n",
      "Hamming Code Codeword: 11001010011\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001010011\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 11\n",
      "Hamming Code Generator\n",
      "Input Alphabet: k\n",
      "Alphabet to Binary: 1101011\n",
      "Redundancy Bits: 0000\n",
      "Hamming Code Codeword: 11001010100\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001010100\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 12\n",
      "Hamming Code Generator\n",
      "Input Alphabet: l\n",
      "Alphabet to Binary: 1101100\n",
      "Redundancy Bits: 0000\n",
      "Hamming Code Codeword: 11001100000\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001100000\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 13\n",
      "Hamming Code Generator\n",
      "Input Alphabet: m\n",
      "Alphabet to Binary: 1101101\n",
      "Redundancy Bits: 0011\n",
      "Hamming Code Codeword: 11001100111\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001100111\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 14\n",
      "Hamming Code Generator\n",
      "Input Alphabet: n\n",
      "Alphabet to Binary: 1101110\n",
      "Redundancy Bits: 0101\n",
      "Hamming Code Codeword: 11001111001\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001111001\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 15\n",
      "Hamming Code Generator\n",
      "Input Alphabet: o\n",
      "Alphabet to Binary: 1101111\n",
      "Redundancy Bits: 0110\n",
      "Hamming Code Codeword: 11001111110\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11001111110\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 16\n",
      "Hamming Code Generator\n",
      "Input Alphabet: p\n",
      "Alphabet to Binary: 1110000\n",
      "Redundancy Bits: 1000\n",
      "Hamming Code Codeword: 11110000000\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110000000\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 17\n",
      "Hamming Code Generator\n",
      "Input Alphabet: q\n",
      "Alphabet to Binary: 1110001\n",
      "Redundancy Bits: 1011\n",
      "Hamming Code Codeword: 11110000111\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110000111\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 18\n",
      "Hamming Code Generator\n",
      "Input Alphabet: r\n",
      "Alphabet to Binary: 1110010\n",
      "Redundancy Bits: 1101\n",
      "Hamming Code Codeword: 11110011001\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110011001\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 19\n",
      "Hamming Code Generator\n",
      "Input Alphabet: s\n",
      "Alphabet to Binary: 1110011\n",
      "Redundancy Bits: 1110\n",
      "Hamming Code Codeword: 11110011110\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110011110\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 20\n",
      "Hamming Code Generator\n",
      "Input Alphabet: t\n",
      "Alphabet to Binary: 1110100\n",
      "Redundancy Bits: 1110\n",
      "Hamming Code Codeword: 11110101010\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110101010\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 21\n",
      "Hamming Code Generator\n",
      "Input Alphabet: u\n",
      "Alphabet to Binary: 1110101\n",
      "Redundancy Bits: 1101\n",
      "Hamming Code Codeword: 11110101101\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110101101\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 22\n",
      "Hamming Code Generator\n",
      "Input Alphabet: v\n",
      "Alphabet to Binary: 1110110\n",
      "Redundancy Bits: 1011\n",
      "Hamming Code Codeword: 11110110011\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110110011\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 23\n",
      "Hamming Code Generator\n",
      "Input Alphabet: w\n",
      "Alphabet to Binary: 1110111\n",
      "Redundancy Bits: 1000\n",
      "Hamming Code Codeword: 11110110100\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11110110100\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 24\n",
      "Hamming Code Generator\n",
      "Input Alphabet: x\n",
      "Alphabet to Binary: 1111000\n",
      "Redundancy Bits: 1111\n",
      "Hamming Code Codeword: 11111001011\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11111001011\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 25\n",
      "Hamming Code Generator\n",
      "Input Alphabet: y\n",
      "Alphabet to Binary: 1111001\n",
      "Redundancy Bits: 1100\n",
      "Hamming Code Codeword: 11111001100\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11111001100\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 26\n",
      "Hamming Code Generator\n",
      "Input Alphabet: z\n",
      "Alphabet to Binary: 1111010\n",
      "Redundancy Bits: 1010\n",
      "Hamming Code Codeword: 11111010010\n",
      "\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11111010010\n",
      "No Error Found\n",
      "\n",
      "============================================================================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Generator and Checker Samples\n",
    "print(\"Hamming Code Generator and Checker Test Cases\\n\")\n",
    "for i in range (ord('a'),ord('z')+1):\n",
    "    print(\"Test Case: \" + str(i-ord('a')+1))\n",
    "    Hamming_check(Hamming_gen(chr(i)))\n",
    "    print(\"\\n============================================================================\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hamming Code Checker Error Test Cases\n",
      "\n",
      "Test Case: 1\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10011000100\n",
      "Error Position at 7\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 2\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10010011110\n",
      "Error Position at 3\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 3\n",
      "Hamming Code Checker\n",
      "Received Codeword: 11010011101\n",
      "Error Position at 10\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 4\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10010101000\n",
      "Error Position at 1\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 5\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10011101110\n",
      "Error Position at 7\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 6\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10000110000\n",
      "Error Position at 8\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 7\n",
      "Hamming Code Checker\n",
      "Received Codeword: 00010110111\n",
      "Error Position at 11\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 8\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10011000000\n",
      "Error Position at 4\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 9\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10011101111\n",
      "Error Position at 6\n",
      "\n",
      "============================================================================\n",
      "\n",
      "Test Case: 10\n",
      "Hamming Code Checker\n",
      "Received Codeword: 10011110001\n",
      "Error Position at 6\n",
      "\n",
      "============================================================================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Checker Error Samples\n",
    "error = [ # Generate random codeword for running error test cases on Hamming_check()\n",
    "    [\"10011000100\"],\n",
    "    [\"10010011110\"],\n",
    "    [\"11010011101\"],\n",
    "    [\"10010101000\"],\n",
    "    [\"10011101110\"],\n",
    "    [\"10000110000\"],\n",
    "    [\"00010110111\"],\n",
    "    [\"10011000000\"],\n",
    "    [\"10011101111\"],\n",
    "    [\"10011110001\"]\n",
    "]\n",
    "\n",
    "print(\"Hamming Code Checker Error Test Cases\\n\")\n",
    "for i in range(0,len(error)):\n",
    "    print(\"Test Case: \" + str(i+1))\n",
    "    Hamming_check(error[i][0])\n",
    "    print(\"\\n============================================================================\\n\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}