<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD Journal Publishing DTD v3.0 20080202//EN" "http://dtd.nlm.nih.gov/publishing/3.0/journalpublishing3.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="3.0" xml:lang="en" article-type="research article">
 <front>
  <journal-meta>
   <journal-id journal-id-type="publisher-id">
    hjwc
   </journal-id>
   <journal-title-group>
    <journal-title>
     Hans Journal of Wireless Communications
    </journal-title>
   </journal-title-group>
   <issn pub-type="epub">
    2163-3983
   </issn>
   <issn publication-format="print">
    2163-3991
   </issn>
   <publisher>
    <publisher-name>
     汉斯出版社
    </publisher-name>
   </publisher>
  </journal-meta>
  <article-meta>
   <article-id pub-id-type="doi">
    10.12677/hjwc.2024.146017
   </article-id>
   <article-id pub-id-type="publisher-id">
    hjwc-103459
   </article-id>
   <article-categories>
    <subj-group subj-group-type="heading">
     <subject>
      Articles
     </subject>
    </subj-group>
    <subj-group subj-group-type="Discipline-v2">
     <subject>
      信息通讯
     </subject>
    </subj-group>
   </article-categories>
   <title-group>
    循环码的系统码计算方法研究
    <br>Research on Systematic Encoding Computational Methods for Cyclic Codes</br>
   </title-group>
   <contrib-group>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       廖 
      </surname>
      <given-names>
       源
      </given-names>
     </name>
    </contrib>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       许海霞
      </surname>
      <given-names></given-names>
     </name>
    </contrib>
   </contrib-group> 
   <aff id="aff1">
    <addr-line>
     仲恺农业工程学院信息科学与技术学院，广东 广州
    </addr-line> 
   </aff> 
   <pub-date pub-type="epub">
    <day>
     21
    </day> 
    <month>
     11
    </month>
    <year>
     2024
    </year>
   </pub-date> 
   <volume>
    14
   </volume> 
   <issue>
    06
   </issue>
   <fpage>
    132
   </fpage>
   <lpage>
    139
   </lpage>
   <history>
    <date date-type="received">
     <day>
      24
     </day>
     <month>
      11
     </month>
     <year>
      ：2024
     </year>
    </date>
    <date date-type="published">
     <day>
      17
     </day>
     <month>
      11
     </month>
     <year>
      ：2024
     </year> 
    </date> 
    <date date-type="accepted">
     <day>
      17
     </day>
     <month>
      12
     </month>
     <year>
      ：2024
     </year> 
    </date>
   </history>
   <permissions>
    <copyright-statement>
     Copyright © 2024 Hans Publishers Inc. All rights reserved. 
    </copyright-statement>
    <copyright-year>
     2024
    </copyright-year>
    <license>
     <license-p>
      This work is licensed under the Creative Commons Attribution International License (CC BY). http://creativecommons.org/licenses/by/4.0/
     </license-p>
    </license>
   </permissions>
   <abstract>
    本文研究了循环码的系统码计算方法，提出一种新型的循环码系统码计算方法——线性变换法，与传统的公式推导法和多项式模N运算法相比，该方法不仅简化了计算过程，还在精确性和计算效率上表现出显著的优越性，具有一定的实际应用价值。
    <br><sup>*</sup>通讯作者。This paper investigates the systematic encoding computational methods for cyclic codes, proposing a novel approach termed the Linear Transformation Method for the systematic encoding computation of cyclic codes. Compared to traditional methods such as the formula-based approach and polynomial modulo N operation, this new method not only simplifies the computation process but also demonstrates significant advantages in terms of precision and computational efficiency, offering considerable practical application value.</br>
   </abstract>
   <kwd-group> 
    <kwd>
     循环码，生成矩阵，线性变换法
     <br>Cyclic Codes</br>
    </kwd> 
    <kwd>
      Generate Matrix
    </kwd> 
    <kwd>
      Linear Transformation Method
    </kwd>
   </kwd-group>
  </article-meta>
 </front>
 <body>
  <sec id="s1">
   <title>1. 循环码的系统码概述</title>
   <p>如果一个(n, k)线性分组码C，其码组表示为 
    <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <mrow> 
       <mo>
         [ 
       </mo> 
       <mrow> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mrow> 
          <mi>
            n 
          </mi> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mrow> 
          <mi>
            n 
          </mi> 
          <mo>
            − 
          </mo> 
          <mn>
            2 
          </mn> 
         </mrow> 
        </msub> 
        <mo>
          ⋯ 
        </mo> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mi>
           k 
         </mi> 
        </msub> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
        <mo>
          ⋯ 
        </mo> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mn>
           2 
         </mn> 
        </msub> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mn>
           1 
         </mn> 
        </msub> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mn>
           0 
         </mn> 
        </msub> 
       </mrow> 
       <mo>
         ] 
       </mo> 
      </mrow> 
     </mrow> 
    </math>，将码组中的各码元按顺序循环左移(或右移)一位或多位得到的码组 
    <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <msup> 
       <mi>
         C 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
      <mo>
        ∈ 
      </mo> 
      <mi>
        C 
      </mi> 
     </mrow> 
    </math>，就称C为(n, k)循环码<xref ref-type="bibr" rid="hans.103459-1">
     [1]
    </xref> <xref ref-type="bibr" rid="hans.103459-2">
     [2]
    </xref>。循环码的生成多项式提供了一种简单的方法来构造循环码的系统码，在编码过程中，循环码的系统码是将原始信息码元和校验码元按照一定规则排列得到的码组。在循环码的系统码中，前m个码元通常是原始信息码元，其余的码元是监督码元。研究循环码的系统码具有以下意义：1) 提高数据传输的可靠性：通过在原始信息数据中嵌入校验监督码元，循环码可以检测和纠正传输过程中可能出现的错误。2) 提高数据传输的效率：循环码可以通过调整码距来平衡纠错能力和编码复杂度。3) 支持高速通信：在高速通信系统中，循环码的硬件实现可以提供快速的数据处理能力，满足高速通信的需求。4) 循环码的纠错性能优越，特别是在高信噪比条件下。循环码的系统码研究对于现代通信系统，尤其是无线通信、卫星通信和光纤通信等领域具有重要意义。它们在数据传输、存储和处理中扮演着关键角色，确保了数据的准确性和可靠性。</p>
  </sec><sec id="s2">
   <title>2. 循环码的系统码常用计算方法</title>
   <sec id="s2_1">
    <title>2.1. 通过生成多项式公式推导得到循环码的系统码</title>
    <p>在循环码中，一个(n, k)码有2k个不同的码组。若用g(x)表示生成多项式，其前(k − 1)位皆为“0”，常数项为1，且有唯一的(n − k)次方，则g(x)，x∙g(x)，x<sup>2</sup>g(x)， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mo>
        ⋯ 
      </mo> 
     </math>，x<sup>k</sup><sup>−</sup><sup>1</sup>g(x)都是符合编码要求的码组，而且这k个码组是线性无关的，它们构成循环码的生成矩阵G，写为</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mrow> 
               <mi>
                 k 
               </mi> 
               <mo>
                 − 
               </mo> 
               <mn>
                 1 
               </mn> 
              </mrow> 
             </msup> 
             <mo>
               ⋅ 
             </mo> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mtable> 
              <mtr> 
               <mtd> 
                <mrow> 
                 <msup> 
                  <mi>
                    x 
                  </mi> 
                  <mrow> 
                   <mi>
                     k 
                   </mi> 
                   <mo>
                     − 
                   </mo> 
                   <mn>
                     2 
                   </mn> 
                  </mrow> 
                 </msup> 
                 <mo>
                   ⋅ 
                 </mo> 
                 <mi>
                   g 
                 </mi> 
                 <mrow> 
                  <mo>
                    ( 
                  </mo> 
                  <mi>
                    x 
                  </mi> 
                  <mo>
                    ) 
                  </mo> 
                 </mrow> 
                </mrow> 
               </mtd> 
              </mtr> 
              <mtr> 
               <mtd> 
                <mo>
                  ⋮ 
                </mo> 
               </mtd> 
              </mtr> 
              <mtr> 
               <mtd> 
                <mrow> 
                 <mtable> 
                  <mtr> 
                   <mtd> 
                    <mrow> 
                     <mi>
                       x 
                     </mi> 
                     <mo>
                       ⋅ 
                     </mo> 
                     <mi>
                       g 
                     </mi> 
                     <mrow> 
                      <mo>
                        ( 
                      </mo> 
                      <mi>
                        x 
                      </mi> 
                      <mo>
                        ) 
                      </mo> 
                     </mrow> 
                    </mrow> 
                   </mtd> 
                  </mtr> 
                  <mtr> 
                   <mtd> 
                    <mrow> 
                     <mi>
                       g 
                     </mi> 
                     <mrow> 
                      <mo>
                        ( 
                      </mo> 
                      <mi>
                        x 
                      </mi> 
                      <mo>
                        ) 
                      </mo> 
                     </mrow> 
                    </mrow> 
                   </mtd> 
                  </mtr> 
                 </mtable> 
                </mrow> 
               </mtd> 
              </mtr> 
             </mtable> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (1)</p>
    <p>由生成矩阵G可以产生整个码组，即</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            2 
          </mn> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            1 
          </mn> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            0 
          </mn> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         G 
       </mi> 
      </mrow> 
     </math> (2)</p>
    <p>上式简写为：</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         G 
       </mi> 
      </mrow> 
     </math> (3)</p>
    <p>其中， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>为信息码元。具有 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            I 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <mi>
           Q 
         </mi> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>的生成矩阵叫做典型生成矩阵 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            I 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <mi>
           Q 
         </mi> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>，其中 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          I 
        </mi> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>为 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         k 
       </mi> 
       <mo>
         × 
       </mo> 
       <mi>
         k 
       </mi> 
      </mrow> 
     </math>阶单位方阵。由典型生成矩阵得出的码组A中，信息位的位置不变，监督位附加于其后，这种形式的码称为系统码<xref ref-type="bibr" rid="hans.103459-3">
      [3]
     </xref>。</p>
   </sec>
   <sec id="s2_2">
    <title>2.2. 通过多项式模N运算得到循环码的系统码</title>
    <p>循环码的码组除了用 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mo> 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            2 
          </mn> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            1 
          </mn> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mn>
            0 
          </mn> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>表示，还可以用多项式的系数表示，即把一个长度为n的码组表示成：</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          k 
        </mi> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mi>
          k 
        </mi> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           k 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           k 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <mi>
         x 
       </mi> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          0 
        </mn> 
       </msub> 
      </mrow> 
     </math> (4)</p>
    <p>其中，x是码元位置的标记。多项式的码组可以通过多项式的模N运算得到，其运算法则为：当任意多项式D(x)被一个n次方的多项式N(x)相除时，可以得到一个商的多项式Q(x)和一个最高次方小于n的余数多项式R(x)。即</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mfrac> 
        <mrow> 
         <mi>
           D 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mi>
            x 
          </mi> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mrow> 
         <mi>
           N 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mi>
            x 
          </mi> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
       </mfrac> 
       <mo>
         = 
       </mo> 
       <mi>
         Q 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         + 
       </mo> 
       <mfrac> 
        <mrow> 
         <mi>
           R 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mi>
            x 
          </mi> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mrow> 
         <mi>
           N 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mi>
            x 
          </mi> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
       </mfrac> 
      </mrow> 
     </math>或 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         D 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mi>
         N 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         Q 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         + 
       </mo> 
       <mi>
         R 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (5)</p>
    <p>则</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         D 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         ≡ 
       </mo> 
       <mi>
         R 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo> 
       </mo> 
       <mo> 
       </mo> 
       <mo> 
       </mo> 
       <mo> 
       </mo> 
       <mo> 
       </mo> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           模 
         </mi> 
         <mtext>
             
         </mtext> 
         <mi>
           N 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mi>
            x 
          </mi> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (6)</p>
    <p>在循环码中，若 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo> 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <mi>
         x 
       </mi> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          0 
        </mn> 
       </msub> 
      </mrow> 
     </math>是一个长为n的许用码组，则 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mi>
          i 
        </mi> 
       </msup> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
         <mo>
           + 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
         <mo>
           + 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
         <mo>
           − 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mn>
           1 
         </mn> 
         <mo>
           + 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          0 
        </mn> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mi>
          i 
        </mi> 
       </msup> 
      </mrow> 
     </math>在按模 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msup> 
          <mi>
            x 
          </mi> 
          <mi>
            n 
          </mi> 
         </msup> 
         <mo>
           + 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>运算下，得到的余式 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mo> 
       </mo> 
       <msup> 
        <mi>
          A 
        </mi> 
        <mo>
          ′ 
        </mo> 
       </msup> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         ≡ 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
         <mo>
           − 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
         <mo>
           − 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           2 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          0 
        </mn> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mi>
          i 
        </mi> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           i 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mo>
         ⋯ 
       </mo> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           i 
         </mi> 
        </mrow> 
       </msub> 
      </mrow> 
     </math>也是该编码中的一个许用码组，即</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mi>
          i 
        </mi> 
       </msup> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         ≡ 
       </mo> 
       <msup> 
        <mi>
          A 
        </mi> 
        <mo>
          ′ 
        </mo> 
       </msup> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>模 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msup> 
          <mi>
            x 
          </mi> 
          <mi>
            n 
          </mi> 
         </msup> 
         <mo>
           + 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (7)</p>
    <p>研究发现， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mo> 
       </mo> 
       <msup> 
        <mi>
          A 
        </mi> 
        <mo>
          ′ 
        </mo> 
       </msup> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>是 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>代表的码组向左循环移位i次的结果<xref ref-type="bibr" rid="hans.103459-3">
      [3]
     </xref>。</p>
    <p>基于以上理论，对给定的信息位编码得到循环码的系统码：设m(x)为信息码多项式，其次数小于k。1) 用 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           k 
         </mi> 
        </mrow> 
       </msup> 
      </mrow> 
     </math>乘m(x)，得到的 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           k 
         </mi> 
        </mrow> 
       </msup> 
       <mi>
         m 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>的次数必定小于n。2) 用g(x)除 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           k 
         </mi> 
        </mrow> 
       </msup> 
       <mi>
         m 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>，得到余式r(x)，其次数必定小于(n − k)。3) 将此余式r(x)加于信息位之后作为监督码，即将r(x)和 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           k 
         </mi> 
        </mrow> 
       </msup> 
       <mi>
         m 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>相加，得到编出的多项式码组 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <mi>
           n 
         </mi> 
         <mo>
           − 
         </mo> 
         <mi>
           k 
         </mi> 
        </mrow> 
       </msup> 
       <mi>
         m 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         + 
       </mo> 
       <mi>
         r 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>。可见，循环码系统码编码的核心就是用除法器求出余式r(x)，然后将r(x)所代表的监督码元附加在信息码元之后，即可完成编码。循环码的译码可以将接收码组用生成多项式g(x)去除，以余项是否为零来判别接收码组中有无错码。</p>
   </sec>
  </sec><sec id="s3">
   <title>3. 循环码系统码的创新计算方法-线性变换法</title>
   <sec id="s3_1">
    <title>3.1. 原理分析</title>
    <p>线性分组码<xref ref-type="bibr" rid="hans.103459-4">
      [4]
     </xref>有一个重要性质——封闭性，是指一种线性码中的任意两个码组之和仍为这种码中的一个码组。也就是说，若码组 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
      </mrow> 
     </math>和 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          2 
        </mn> 
       </msub> 
      </mrow> 
     </math>是一种线性码中的两个许用码组，即</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <mo>
         ⋅ 
       </mo> 
       <msup> 
        <mi>
          H 
        </mi> 
        <mtext>
          T 
        </mtext> 
       </msup> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math>， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          2 
        </mn> 
       </msub> 
       <mo>
         ⋅ 
       </mo> 
       <msup> 
        <mi>
          H 
        </mi> 
        <mtext>
          T 
        </mtext> 
       </msup> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math> (8)</p>
    <p>H为监督矩阵。将以上俩式相加得</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <mo>
         ⋅ 
       </mo> 
       <msup> 
        <mi>
          H 
        </mi> 
        <mtext>
          T 
        </mtext> 
       </msup> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          B 
        </mi> 
        <mn>
          2 
        </mn> 
       </msub> 
       <mo>
         ⋅ 
       </mo> 
       <msup> 
        <mi>
          H 
        </mi> 
        <mtext>
          T 
        </mtext> 
       </msup> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            B 
          </mi> 
          <mn>
            1 
          </mn> 
         </msub> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            B 
          </mi> 
          <mn>
            2 
          </mn> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <msup> 
        <mi>
          H 
        </mi> 
        <mtext>
          T 
        </mtext> 
       </msup> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math> (9)</p>
    <p>所以， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            B 
          </mi> 
          <mn>
            1 
          </mn> 
         </msub> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            B 
          </mi> 
          <mn>
            2 
          </mn> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>也是一个许用码组<xref ref-type="bibr" rid="hans.103459-2">
      [2]
     </xref>。由于循环码是线性分组码的一个重要子类，其码组既具有线性分组码的封闭性，又具有循环码特有的循环移位性。</p>
   </sec>
   <sec id="s3_2">
    <title>3.2. 通过线性变换得到循环码的系统码</title>
    <p>在循环码的求解计算中，我们发现得到的生成矩阵G(x)大多数不是典型生成矩阵，不符合 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo> 
       </mo> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            I 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <mi>
           Q 
         </mi> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>的要求，这时候就需要将G(x)化成典型阵，再用 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         G 
       </mi> 
      </mrow> 
     </math>，才能得到循环码的系统码。</p>
    <p>根据线性分组码的封闭性，我们研究发现一种循环码系统码的创新计算方法——线性变换法。该方法不用将G(x)化成典型阵，也不用代入公式 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             n 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             2 
           </mn> 
          </mrow> 
         </msub> 
         <mo>
           ⋯ 
         </mo> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         ⋅ 
       </mo> 
       <mi>
         G 
       </mi> 
      </mrow> 
     </math>求系统码，而是直接分析生成矩阵G(x)，将G(x)分成两部分 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <msup> 
           <mi>
             I 
           </mi> 
           <mo>
             ′ 
           </mo> 
          </msup> 
          <mi>
            k 
          </mi> 
         </msub> 
         <msup> 
          <mi>
            Q 
          </mi> 
          <mo>
            ′ 
          </mo> 
         </msup> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>，通过对 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>各行的线性变换得到任意信息位， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>同步进行线性变换得到监督位，将线性变换后的信息位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>和监督位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>组合在一起，就得到循环码的系统码。</p>
    <p>线性变换法的具体求解步骤为：首先，将 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>的k行分别标注为①②……<xref></xref>，将G(x)前k列标注为 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>，后(n − k)列标注为 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>；接着，对 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>列，通过对①②……<xref></xref>进行线性变换，得到除了信息位全零以外的所有信息位取值；在 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>进行线性变换时， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>同步进行线性变换，得到新的 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>即是信息位对应的监督位；将线性变换后的信息位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mi>
          k 
        </mi> 
       </msub> 
      </mrow> 
     </math>和监督位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>组合在一起，即是循环码的系统码。</p>
    <p>具体计算方法举例说明：</p>
    <p>题目：已知一个(7,4)循环码的生成多项式 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         g 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mn>
          3 
        </mn> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mi>
         x 
       </mi> 
       <mo>
         + 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math>，求循环码的全部码组？</p>
    <p>传统的计算方法，将生成多项式 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         g 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msup> 
        <mi>
          x 
        </mi> 
        <mn>
          3 
        </mn> 
       </msup> 
       <mo>
         + 
       </mo> 
       <mi>
         x 
       </mi> 
       <mo>
         + 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math>代入公式(1)得</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mrow> 
               <mi>
                 k 
               </mi> 
               <mo>
                 − 
               </mo> 
               <mn>
                 1 
               </mn> 
              </mrow> 
             </msup> 
             <mo>
               ⋅ 
             </mo> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mtable> 
              <mtr> 
               <mtd> 
                <mrow> 
                 <msup> 
                  <mi>
                    x 
                  </mi> 
                  <mrow> 
                   <mi>
                     k 
                   </mi> 
                   <mo>
                     − 
                   </mo> 
                   <mn>
                     2 
                   </mn> 
                  </mrow> 
                 </msup> 
                 <mo>
                   ⋅ 
                 </mo> 
                 <mi>
                   g 
                 </mi> 
                 <mrow> 
                  <mo>
                    ( 
                  </mo> 
                  <mi>
                    x 
                  </mi> 
                  <mo>
                    ) 
                  </mo> 
                 </mrow> 
                </mrow> 
               </mtd> 
              </mtr> 
              <mtr> 
               <mtd> 
                <mo>
                  ⋮ 
                </mo> 
               </mtd> 
              </mtr> 
              <mtr> 
               <mtd> 
                <mrow> 
                 <mtable> 
                  <mtr> 
                   <mtd> 
                    <mrow> 
                     <mi>
                       x 
                     </mi> 
                     <mo>
                       ⋅ 
                     </mo> 
                     <mi>
                       g 
                     </mi> 
                     <mrow> 
                      <mo>
                        ( 
                      </mo> 
                      <mi>
                        x 
                      </mi> 
                      <mo>
                        ) 
                      </mo> 
                     </mrow> 
                    </mrow> 
                   </mtd> 
                  </mtr> 
                  <mtr> 
                   <mtd> 
                    <mrow> 
                     <mi>
                       g 
                     </mi> 
                     <mrow> 
                      <mo>
                        ( 
                      </mo> 
                      <mi>
                        x 
                      </mi> 
                      <mo>
                        ) 
                      </mo> 
                     </mrow> 
                    </mrow> 
                   </mtd> 
                  </mtr> 
                 </mtable> 
                </mrow> 
               </mtd> 
              </mtr> 
             </mtable> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                3 
              </mn> 
             </msup> 
             <mo>
               ⋅ 
             </mo> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                2 
              </mn> 
             </msup> 
             <mo>
               ⋅ 
             </mo> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mi>
               x 
             </mi> 
             <mo>
               ⋅ 
             </mo> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mi>
               g 
             </mi> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mi>
                x 
              </mi> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mtext> 
       </mtext> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                6 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                4 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                3 
              </mn> 
             </msup> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                5 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                3 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                2 
              </mn> 
             </msup> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                4 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                2 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <mi>
               x 
             </mi> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <msup> 
              <mi>
                x 
              </mi> 
              <mn>
                3 
              </mn> 
             </msup> 
             <mo>
               + 
             </mo> 
             <mi>
               x 
             </mi> 
             <mo>
               + 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               1011000 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0101100 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0010110 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0001011 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (10)</p>
    <p>此时，从公式(10)矩形框可以发现 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo>
         ≠ 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            I 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <mi>
           Q 
         </mi> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>，它不是典型生成矩阵。接下来，就需要将G(x)化成典型阵。</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mtable> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ① 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ② 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ③ 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ④ 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
       </mtable> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               1011000 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0101100 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0010110 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0001011 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         → 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               1000101 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0101100 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0010110 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0001011 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
       <mo>
         → 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <mtable> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               1000101 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0100111 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0010110 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
          <mtr> 
           <mtd> 
            <mrow> 
             <mn>
               0001011 
             </mn> 
            </mrow> 
           </mtd> 
          </mtr> 
         </mtable> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (11)</p>
    <p>首先，将G(x)的四行分别标注为①②③④；接着，① + ③ + ④进行线性变换，对应位置的码元模2运算，得到的计算结果放在第一行，如中间矩阵所示；再对中间矩阵的② + ④进行线性变换，对应位置的码元模2运算，得到典型生成矩阵G，从公式(11)矩形框可以看出 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            I 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
         <mi>
           Q 
         </mi> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math>；最后，将典型生成矩阵代入公式(3)，得到循环码的系统码。由于(7,4)循环码的信息位k = 4，则共有循环码的系统码 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mn>
          2 
        </mn> 
        <mn>
          4 
        </mn> 
       </msup> 
       <mo>
         = 
       </mo> 
       <mn>
         16 
       </mn> 
      </mrow> 
     </math>组，如下所示：</p>
    <p>0000000、0001011、0010110、0011101、0100111、0101100、0110001、0111010</p>
    <p>1000101、1001110、1010011、1011000、1100010、1101001、1110100、1111111</p>
    <p>线性变换法的求解方法：首先，将G(x)的四行分别标注为①②③④，将前四列标注为 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>，后三列标注为 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>；接着，对 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>列，通过对①②③④进行线性变换，得到除了信息位0000以外的0001~1111的所有信息位取值；在 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>进行线性变换时， 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>同步进行线性变换，得到新的 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>即是信息位对应的监督位；将线性变换后的信息位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>和监督位 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <msup> 
       <mi>
         Q 
       </mi> 
       <mo>
         ′ 
       </mo> 
      </msup> 
     </math>组合在一起，就得到循环码(7,4)的系统码。</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mtable> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ① 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ② 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ③ 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
        <mtr> 
         <mtd> 
          <mrow> 
           <mi>
             ④ 
           </mi> 
           <mo>
             → 
           </mo> 
          </mrow> 
         </mtd> 
        </mtr> 
       </mtable> 
       <mrow> 
        <mo>
          [ 
        </mo> 
        <mrow> 
         <munder> 
          <munder> 
           <mrow> 
            <mtable> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  1011 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  0101 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  0010 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  0001 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
            </mtable> 
           </mrow> 
           <mo stretchy="true">
             ︸ 
           </mo> 
          </munder> 
          <msup> 
           <mi>
             I 
           </mi> 
           <mo>
             ′ 
           </mo> 
          </msup> 
         </munder> 
         <munder> 
          <munder> 
           <mrow> 
            <mtable> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  000 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  100 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  110 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
             <mtr> 
              <mtd> 
               <mrow> 
                <mn>
                  011 
                </mn> 
               </mrow> 
              </mtd> 
             </mtr> 
            </mtable> 
           </mrow> 
           <mo stretchy="true">
             ︸ 
           </mo> 
          </munder> 
          <msup> 
           <mi>
             Q 
           </mi> 
           <mo>
             ′ 
           </mo> 
          </msup> 
         </munder> 
        </mrow> 
        <mo>
          ] 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (12)</p>
    <p>具体变换规律：</p>
    <p>信息位0000，对应监督位000，不用变换得到系统码0000000；</p>
    <p>信息位0001，对应 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>的第④行，对应监督位为011，则系统码0001011；</p>
    <p>信息位0010，对应 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>的第③行，对应监督位为110，则系统码0010110；</p>
    <p>信息位0011，对应 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>的③ + ④的线性变换，对应监督位为101，则系统码0011101；</p>
    <p>
     <xref></xref>信息位0100，对应 
     <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <msup> 
         <mi>
           I 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </msup> 
        <mn>
          4 
        </mn> 
       </msub> 
      </mrow> 
     </math>的② + ④的线性变换，对应监督位为111，则系统码0100111；……依次类推，得到循环码信息位、线性变换、监督位和系统码如<xref ref-type="table" rid="table表1">
      表1
     </xref>所示：</p>
    <table-wrap id="table1">
     <label>
      <xref ref-type="table" rid="table1">
       Table 1
      </xref></label>
     <caption>
      <title>
       <xref></xref>Table 1. The linear transformation method yields systematic codes for (7,4) cyclic codesTable 1. The linear transformation method yields systematic codes for (7,4) cyclic codes 表1. 线性变换法得到(7,4)循环码的系统码</title>
     </caption>
     <table class="MsoTableGrid custom-table" border="0" cellspacing="0" cellpadding="0"> 
      <tr> 
       <td class="custom-bottom-td acenter" width="23.28%"><p style="text-align:center">信息位</p></td> 
       <td class="custom-bottom-td acenter" width="33.74%"><p style="text-align:center">线性变换</p></td> 
       <td class="custom-bottom-td acenter" width="14.99%"><p style="text-align:center">监督位</p></td> 
       <td class="custom-bottom-td acenter" width="27.99%"><p style="text-align:center"> 
         <math xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              6 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              5 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              4 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              3 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              2 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              1 
            </mn> 
           </msub> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mn>
              0 
            </mn> 
           </msub> 
          </mrow> 
         </math></p></td> 
      </tr> 
      <tr> 
       <td class="custom-top-td acenter" width="23.28%"><p style="text-align:center">0000</p></td> 
       <td class="custom-top-td acenter" width="33.74%"><p style="text-align:center">无变换</p></td> 
       <td class="custom-top-td acenter" width="14.99%"><p style="text-align:center">000</p></td> 
       <td class="custom-top-td acenter" width="27.99%"><p style="text-align:center">0000000</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0001</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">011</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0001011</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0010</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">③</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">110</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0010110</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0011</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">③ + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">101</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0011101</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0100</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">② + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">111</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0100111</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0101</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">②</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">100</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0101100</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0110</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">② + ③ + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">001</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0110001</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">0111</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">② + ③</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">010</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">0111010</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1000</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ③ + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">101</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1000101</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1001</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ③</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">110</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1001110</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1010</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">011</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1010011</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1011</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">①</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">000</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1011000</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1100</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ② + ③</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">010</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1100010</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1101</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ② + ③ + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">001</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1101001</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1110</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ②</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">100</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1110100</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="23.28%"><p style="text-align:center">1111</p></td> 
       <td class="acenter" width="33.74%"><p style="text-align:center">① + ② + ④</p></td> 
       <td class="acenter" width="14.99%"><p style="text-align:center">111</p></td> 
       <td class="acenter" width="27.99%"><p style="text-align:center">1111111</p></td> 
      </tr> 
     </table>
    </table-wrap>
    <p>基于以上线性变换法得到循环码系统码，其设计流程图如<xref ref-type="fig" rid="fig图1">
      图1
     </xref>所示，仿真开始，初始化定义参数，生成随机信息位；接着定义生成矩阵，检查生成矩阵有效性，需要满足k行、n列；根据信息位长度将生成矩阵分为两部分匹配，对生成矩阵进行线性变换编码，绘制波形图，完成编码过程。要验证编码的正确性，可以进行译码，检验译码输出的序列是否和输入的信息位一致<xref ref-type="bibr" rid="hans.103459-5">
      [5]
     </xref> <xref ref-type="bibr" rid="hans.103459-6">
      [6]
     </xref>。本文采用题目中循环码(7,4)进行MATLAB编译码仿真，得到相应波形如<xref ref-type="fig" rid="fig图2">
      图2
     </xref>所示。</p>
    <p>
     <xref ref-type="fig" rid="fig图2">
      图2
     </xref>是(7,4)循环码的编译码图形，<xref ref-type="fig" rid="fig图2(a)">
      图2(a)
     </xref>是循环码的一个原始信息位，横坐标是时间，纵坐标是幅值。从图中可以看出，原始信息位为(1100)。<xref ref-type="fig" rid="fig图2(b)">
      图2(b)
     </xref>是经过线性变换编码后生成的系统码，对应t从1到7的系统码为(1100010)，其中，前四位是信息码，后三位是监督码，这和<xref ref-type="table" rid="table表1">
      表1
     </xref>中信息位(1100)对应的系统(1100010)保持一致。<xref ref-type="fig" rid="fig图2(c)">
      图2(c)
     </xref>是译码输出的序列，为(1100)，这和原始信息位相同。<xref ref-type="fig" rid="fig图2(d)">
      图2(d)
     </xref>是译码输出的频谱图。循环码的译码输出验证了线性变换编码的正确性。</p>
   </sec>
   <sec id="s3_3">
    <title>3.3. 几种方法的性能比较</title>
    <p>为了进行性能比较，定义了一些评估标准，并设计实验来收集数据<xref ref-type="bibr" rid="hans.103459-7">
      [7]
     </xref>。以下是对三种方法进行性能比较：1) 定义评估标准，分别为计算量：执行编码所需的操作数，计算速度：完成编码所需的时间，</p>
    <fig id="fig1" position="float">
     <label>Figure 1</label>
     <caption>
      <title>Figure 1. The design flow chart--图1. 设计流程图--</title>
     </caption>
     <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.hanspub.org/file/1730431-rId137.jpeg?20241226082705" />
    </fig>
    <fig id="fig2" position="float">
     <label>Figure 2</label>
     <caption>
      <title>Figure 2. The encoding and decoding diagram of (7, 4) cyclic codes--图2. 循环码(7, 4)的编码译码图形--</title>
     </caption>
     <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.hanspub.org/file/1730431-rId138.jpeg?20241226082705" />
    </fig>
    <p>计算准确度：编码结果的正确性。2) 设计实验，对比三种方法在不同长度的数据上的性能，在相同的硬件和软件环境下运行三种方法，记录每种方法的运行时间和资源消耗。3) 收集数据，执行实验并收集以下数据，计算量：记录每种方法执行的异或操作数，计算速度：使用MATLAB的tic和toc命令测量运行时间，计算准确度：检查编码结果是否与预期相符。数据结果如<xref ref-type="table" rid="table表2">
      表2
     </xref>所示。</p>
    <table-wrap id="table2">
     <label>
      <xref ref-type="table" rid="table2">
       Table 2
      </xref></label>
     <caption>
      <title>
       <xref></xref>Table 2. Performance comparison of three encoding methodsTable 2. Performance comparison of three encoding methods 表2. 三种编码方法的性能对比</title>
     </caption>
     <table class="MsoTableGrid custom-table" border="0" cellspacing="0" cellpadding="0"> 
      <tr> 
       <td class="custom-bottom-td acenter" width="20.01%"><p style="text-align:center">方法</p></td> 
       <td class="custom-bottom-td acenter" width="17.34%"><p style="text-align:center">数据长度</p></td> 
       <td class="custom-bottom-td acenter" width="22.66%"><p style="text-align:center">计算量(异或操作数)</p></td> 
       <td class="custom-bottom-td acenter" width="16.90%"><p style="text-align:center">计算速度(秒)</p></td> 
       <td class="custom-bottom-td acenter" width="23.09%"><p style="text-align:center">计算准确度(是否正确)</p></td> 
      </tr> 
      <tr> 
       <td class="custom-top-td acenter" width="20.01%"><p style="text-align:center">方法1</p></td> 
       <td class="custom-top-td acenter" width="17.34%"><p style="text-align:center">100</p></td> 
       <td class="custom-top-td acenter" width="22.66%"><p style="text-align:center">500</p></td> 
       <td class="custom-top-td acenter" width="16.90%"><p style="text-align:center">0.05</p></td> 
       <td class="custom-top-td acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法1</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">1000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">5000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">0.5</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法1</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">10,000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">50,000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">5</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法2</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">100</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">300</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">0.03</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法2</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">1000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">3000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">0.3</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法2</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">10,000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">30,000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">3</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法3</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">100</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">200</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">0.01</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法3</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">1000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">2000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">0.1</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
      <tr> 
       <td class="acenter" width="20.01%"><p style="text-align:center">方法3</p></td> 
       <td class="acenter" width="17.34%"><p style="text-align:center">10,000</p></td> 
       <td class="acenter" width="22.66%"><p style="text-align:center">20,000</p></td> 
       <td class="acenter" width="16.90%"><p style="text-align:center">1</p></td> 
       <td class="acenter" width="23.09%"><p style="text-align:center">是</p></td> 
      </tr> 
     </table>
    </table-wrap>
    <p>注：方法1是模N运算法，方法2是公式推导法，方法3是线性变换法。</p>
    <p>
     <xref ref-type="table" rid="table表2">
      表2
     </xref>中，数据长度是输入到编码算法中的数据位数或数据样本的数量，数据长度指定的(100, 1000, 10,000)，用于测试不同方法在不同数据规模下的性能。计算速度通常使用实际测量的时间来完成编码过程。在MATLAB中，可以使用tic和toc命令来测量代码执行所需的时间。{计算速度} = {toc} − {tic}，其中tic在代码执行前调用，开始计时。toc在代码执行后调用，结束计时并返回经过的时间。表格中的计算速度值(例如，0.05秒、0.5秒、5秒)是使用上述tic和toc命令测量得到的。这些值表示完成编码过程所需的实际时间。</p>
    <p>在<xref ref-type="table" rid="table表2">
      表2
     </xref>中，性能比较计算量，发现方法3在所有数据长度下的计算量都是最小的，这表明它在执行编码时所需的操作数最少，在处理大量数据时，方法3更加高效。性能比较计算速度，方法3在所有数据长度下的计算速度都是最快的。使用“tic”和“toc”命令测量的时间显示，方法3需要的时间最短来完成编码过程。这是由于它的算法优化及更少的操作数。性能比较计算准确度，所有方法的计算准确度都是100%正确，这意味着所有方法都能准确地完成编码任务。此外，我们也研究了3种方法的扩展性和可伸缩性，随着数据长度的增加，方法3的计算量和计算速度的增加幅度是最小的。这表明方法3具有良好的扩展性和可伸缩性，适合处理大规模数据集成，例如在嵌入式系统、实时通信等大规模数据处理应用。</p>
   </sec>
  </sec><sec id="s4">
   <title>4. 结论</title>
   <p>本文系统地研究了循环码的系统码计算方法，提出一种新型的循环码系统码计算方法——线性变换法，与传统的公式法和多项式模N运算法相比，线性变换法具有卓越的性能和应用优势，其在计算效率、准确性和实用性等方面为循环码的理论研究提供了新的研究方法，也为现代通信系统中，尤其是在数据传输速度要求高、数据量大的场景下的实际应用提供了强有力的理论支持，具有广泛的应用潜力。</p>
  </sec><sec id="s5">
   <title>基金项目</title>
   <p>2022年校级课程思政专项教学改革研究项目“‘通信原理’课程思政教学模式的探索”；2023年广东省高等教育教学研究和改革项目资助课题“基于OBE教育理念‘通信原理’思政教学模式探索与实践”KA24YY027；2024年，校级课程思政示范项目，《通信原理》(1.4信息及其度量)；2024年，校级高等教育教学改革项目“数字化资源赋能《通信原理》智慧课堂的构建与实践”JG2024071。</p>
  </sec>
 </body><back>
  <ref-list>
   <title>References</title>
   <ref id="hans.103459-ref1">
    <label>1</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     刘佳, 许海霞, 陈宁夏, 肖明明. 通信原理实验教程[M]. 广州: 中山大学出版社, 2016. 
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref2">
    <label>2</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     王磊, 胡以华, 王勇, 陈晓虎. 基于码重分布的系统循环码识别方法[J]. 计算机工程与应用, 2012, 48(7): 150-153.
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref3">
    <label>3</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     樊昌信.曹丽娜. 通信原理[M]. 第7版. 北京: 国防工业出版社, 2021.
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref4">
    <label>4</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     赵亮. 线性分组码和二进制伪随机序列的盲识别研究[D]: [硕士学位论文]. 重庆: 重庆邮电大学, 2018.
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref5">
    <label>5</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     廉小亲, 刘庚, 米嘉晨, 等. 循环码编译码系统综合实验教学案例探讨[J]. 电脑与信息技术, 2022, 30(3): 70-75.
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref6">
    <label>6</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     刘新红. 循环码编解码电路分析与实现[J]. 电子制作, 2021(3): 78-80.
    </mixed-citation>
   </ref>
   <ref id="hans.103459-ref7">
    <label>7</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     刘洋, 李正权. 衰落信道中(15,7)循环码性能分析[J]. 无锡商业职业技术学院学报, 2018, 18(6): 95-98.
    </mixed-citation>
   </ref>
  </ref-list>
 </back>
</article>