Reed-Solomon纠错码——RS(255,251)学习及实现

news2024/9/30 0:28:55

1、基础知识

1.1 有限域

有限域_百度百科

伽罗华域（Galois Field）上的四则运算_模2的伽罗华域乘法-CSDN博客

1.2 RS（255,251）

里德-所罗门码（一种前向错误更正的信道编码）_百度百科

本原多项式： p(x) = x^8 + x^4 + x^3+ x^2 + 1

生成多项式： g(x) = x^4 + 15* x^3 + 54*x^2 + 120*ｘ＋64

根据对１.１的理解，GF（２５６）　为GF（２＾８）

ＲＳ＿ｍ　＝　８

ＲＳ＿ｎ　＝　２５５

ＲＳ＿ｋ　＝　２５１　

ＲＳ＿ｔ　＝　（ＲＳ＿ｎ　－　ＲＳ＿ｋ）／２　＝　２

根据四则运算，该域中的每个元素的数值为：

ａ（０）　＝　ｘ＾０　＝＞０ｂ

ａ（１）　＝　ｘ＾１　＝＞１ｂ

ａ（２）　＝　ｘ＾２＝＞１０ｂ

ａ（３）　＝　ｘ＾３　＝＞１１ｂ

．．．

ａ（８）　＝　ｘ＾８　＝　 x^4 + x^3+ x^2 + 1　＝＞１１１０１ｂ（由Ｐ(ｘ)推导）

ａ（９）　＝　ｘ＾９　＝　ｘ＾８＊　ｘ＝　（x^4 + x^3+ x^2 + 1）＊ｘ　＝　ｘ＾５＋ｘ＾４＋ｘ＾３＋ｘ　＝＞１１１０１０ｂ

ａ（１０）　＝　ｘ＾１０　＝　ｘ＾８＊ｘ＾２　＝　（x^4 + x^3+ x^2 + 1）＊ｘ＾２　＝ｘ＾６＋ｘ＾５＋ｘ＾４＋ｘ＾２　＝＞１１１０１００ｂ

ａ（１１）　＝　ｘ＾１１　＝　ｘ＾８＊ｘ＾３　＝　　（x^4 + x^3+ x^2 + 1）＊ｘ＾３　＝　ｘ＾７＋ｘ＾６＋ｘ＾５＋　ｘ＾３　＝＞　１１１０１０００ｂ

ａ（１２）　＝　ｘ＾１２　＝　ｘ＾８＊ｘ＾４　＝　（x^4 + x^3+ x^2 + 1）＊ｘ＾４　＝　ｘ＾８　＋　ｘ＾７＋　ｘ＾６＋　ｘ＾４　＝　（x^4 + x^3+ x^2 + 1）＋　ｘ＾７＋　ｘ＾６＋　ｘ＾４　（ｍｏｄｐ（ｘ））＝　　ｘ＾７＋　ｘ＾６　＋　 x^3+ x^2 + 1　　＝＞　１１００１１０１ｂ

．．．

只要ａ（ｎ）中的ｎ大于８或者推导出来的指数大于８就可以ｍｏｄｐ（ｘ）推导出来指数小于８

２、python实现(基础版)

# parameter
rs_n = 255
rs_k = 251
rs_m = 8
# rs_t = 2
p_x = int('100011101', 2)  # primitive polynomial GF(256)
# x_0_7 = [1, 2, 4, 8, 16, 32, 64, 128]
x8 = p_x ^ (2 ** rs_m)


# GF function
# GF_xn(n) : element a(n); GF_add(a,b): add; GF_mult(a,b): multiply

def gf_xn(n):
    if n < rs_m:
        return 2 ** n
    elif n == rs_m:
        return x8
    else:
        tmp_xn = gf_xn(n - 1) << 1
        while tmp_xn > 2 ** rs_m:
            tmp_xn_low = tmp_xn & rs_n
            tmp_xn = tmp_xn_low ^ x8
        return tmp_xn


def gf_add(a, b):
    r = a ^ b
    return r


def gf_mult(a, b):
    if a == 0 or b == 0:
        r = 0
    else:
        r_mul = 0
        r_mul_high = 0
        for i in range(rs_m):
            if a & 2 ** i:
                b_i = b << i
                r_mul = r_mul ^ b_i
        for j in range(rs_n):
            if j >= rs_m:
                if r_mul & 2 ** j:
                    r_mul_high = r_mul_high ^ gf_xn(j)
        r_mul_low = r_mul & rs_n
        r = r_mul_low ^ r_mul_high
    return r


def rs_encoder(mx):
    rx_pre = [0, 0, 0, 0]
    rx = [0, 0, 0, 0]
    for mx_i in mx:
        fec_i = gf_add(rx_pre[3], mx_i)
        rx[0] = gf_mult(64, mx_i)
        rx[1] = gf_add(gf_mult(120, fec_i), rx_pre[0])
        rx[2] = gf_add(gf_mult(54, fec_i), rx_pre[1])
        rx[3] = gf_add(gf_mult(15, fec_i), rx_pre[2])
    return rx


if __name__ == '__main__':
    mx = [0 for i in range(rs_k)]
    with open('mx.txt', 'rb') as mx_f:
        mx_all = mx_f.read()
        mx_list = mx_all.split("\n")
        for i in range(rs_k):
            mx[i] = int(mx_list[i])
        print(mx)
        rx = rs_encoder(mx)
        print(rx)

其中ｐｘ是本原多项式，ｘｎ就是GF（２５６）中的各个元素

ｍｘ　是　RS（２５5，251）　生成多项式　对应的　移位寄存器的输入B０－B２５０

ｒｘ　是ｍｘ　编码后得到的４　位　RS０－RS３

ｇｆ＿ｘｎ　以及ｇｆ＿ｍｕｌｔ　都是根据推导一步步写的，比较笨拙的写法（数学不好，算法不好没办法）