1. 實驗目的
   加深理解Hamming(7,4)碼的編碼方法和抗干擾性能。
   通過程式設計實現Hamming(7，4)碼的編碼演算法，進一步掌握按位二進位制加法的實現原理。

2. 實驗要求
   輸入：長度為4的任意二進位制序列。
   輸出：輸入資料經Hamming(7，4）編碼器編碼之後，通過二元對稱通道模擬器(另一篇部落格)（錯誤概率為0.1）傳輸後，再經過Hamming(7，4）譯碼器譯碼輸出得到信宿端的長度為4的二進位制序列。

3. 程式碼

   • HammingUtil

package com.tanrong.hamming;

/**
 * Created by tanrong.ltr on 16/6/18.
 */
 

public class HammingUtil {

    /**
     * 根據傳入的4位二進位制序列算出7位漢明碼
     * 其中前三位為資訊碼 後三位為監督碼
     * @param d
     * @return
     */
    public static int[] encode(int[] d){
        if (d.length!=4){
            return new int[4];
        }
        // 根據四位資訊碼算出三位監督碼
        int p1 = d[0] ^ d[1] ^ d[3];
        int
 
 p2 = d[0] ^ d[2] ^ d[3];
        int p3 = d[1] ^ d[2] ^ d[3];

        int[] results=new int[7];
        results[0]=d[0];
        results[1]=d[1];
        results[2]=d[2];
        results[3]=d[3];

        results[4]=p1;
        results[5]=p2;
        results[6]=p3;

        return results;
    }
    /**
     * 根據傳入的7位漢明碼算出2進位制序列
     *
     * 其中後三位為監督碼
     * @param
 
 d
     * @return
     */
    public static int[] decode(int[] d){
        if (d.length!=7){
            return new int[4];
        }

        int c1 = d[4] ^ d[0] ^ d[1] ^ d[3];
        int c2 = d[5] ^ d[0] ^ d[2] ^ d[3];
        int c3 = d[6] ^ d[1] ^ d[2] ^ d[3];


        if (c1 + c2 + c3 == 3) d[3] = 1 ^ d[3];
        else if (c1 + c2 == 2) d[0] = 1 ^ d[0];
        else if (c1 + c3 == 2) d[1] = 1 ^ d[1];
        else if (c2 + c3 == 2) d[2] = 1 ^ d[2];

        int[] results=new int[4];
        results[0]=d[0];
        results[1]=d[1];
        results[2]=d[2];
        results[3]=d[3];

        return results;
    }

    /***
     * 返回四位的16進位制編碼
     * @param s
     * @return
     */
    public static int fromHex(String s) {
        return Integer.parseInt(s, 16) & 0xFFFF;
    }
}

• Main

package com.tanrong.hamming;

import com.tanrong.channelCapacity.BSC;

import java.util.Scanner;

/**
 * Created by tanrong.ltr on 16/6/18.
 *
 */
public class Main {
    private static final double errorProbability=0.1;
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入長度為4的二進位制序列,以空格隔開");
        int d[] = new int[4];
        for (int i = 0; i < 4; i++) {
            d[i] = HammingUtil.fromHex(sc.next());
        }
        int[] encodeData=HammingUtil.encode(d);
        println("編碼後",encodeData);
        BSC bsc=new BSC(errorProbability);
        int[] transmitedData=bsc.send(encodeData);
        println("BSC傳輸後",transmitedData);

        int[] decodeData=HammingUtil.decode(transmitedData);
        println("解碼結果",decodeData);
    }
    private static void println(String message,int[] data){
        System.out.println(message);
        for (int i:data){
            System.out.printf(i+" ");
        }
        System.out.println();
    }
}

• BSC

package com.tanrong.channelCapacity;

/**
 * Created by tanrong.ltr on 16/6/18.
 * https://github.com/chsasank/LDPC-Codes/blob/master/src/ldpc/BSC.java
 */

/**
 * BSC通道模擬器,當隨機數小於錯誤發生概率時會發生傳輸錯誤
 */
public class BSC {
    double errorProbability;

    /**
     * 設定BSC的錯誤發生概率
     * @param f
     */
    public BSC(double f){
        errorProbability = f;
    }

    /**
     * 經BSC傳輸訊號,返回傳輸後的值
     * @param data
     * @return
     */
    public int[] send(int[] data){
        boolean [] x=int2boolean(data);
        for(int i = 0; i<x.length;i++)
            if(Math.random()<errorProbability){
                x[i] = !x[i];
            }
        return boolean2int(x);
    }

    /**
     * 將Boolean型陣列轉為整形
     * @param data
     * @return
     */
    private boolean[] int2boolean(int[] data){
        boolean [] x=new boolean[data.length];
        for (int i = 0; i < data.length; i++) {
            x[i] = data[i] != 0;
        }
        return x;
    }

    /**
     * 將int型陣列轉為boolean型
     * @param data
     * @return
     */
    private int[] boolean2int(boolean[] data){
        int[] x=new int[data.length];
        for (int i = 0; i < data.length; i++) {
            x[i]=data[i]?1:0;
        }
        return x;
    }
}

執行結果